github.com/stchris/docker@v1.4.2-0.20150106053530-1510a324dbd5/integration-cli/docker_cli_events_test.go (about) 1 package main 2 3 import ( 4 "fmt" 5 "os/exec" 6 "strconv" 7 "strings" 8 "testing" 9 "time" 10 ) 11 12 func TestEventsUntag(t *testing.T) { 13 out, _, _ := dockerCmd(t, "images", "-q") 14 image := strings.Split(out, "\n")[0] 15 dockerCmd(t, "tag", image, "utest:tag1") 16 dockerCmd(t, "tag", image, "utest:tag2") 17 dockerCmd(t, "rmi", "utest:tag1") 18 dockerCmd(t, "rmi", "utest:tag2") 19 eventsCmd := exec.Command("timeout", "0.2", dockerBinary, "events", "--since=1") 20 out, _, _ = runCommandWithOutput(eventsCmd) 21 events := strings.Split(out, "\n") 22 nEvents := len(events) 23 // The last element after the split above will be an empty string, so we 24 // get the two elements before the last, which are the untags we're 25 // looking for. 26 for _, v := range events[nEvents-3 : nEvents-1] { 27 if !strings.Contains(v, "untag") { 28 t.Fatalf("event should be untag, not %#v", v) 29 } 30 } 31 logDone("events - untags are logged") 32 } 33 34 func TestEventsPause(t *testing.T) { 35 name := "testeventpause" 36 out, _, _ := dockerCmd(t, "images", "-q") 37 image := strings.Split(out, "\n")[0] 38 dockerCmd(t, "run", "-d", "--name", name, image, "sleep", "2") 39 dockerCmd(t, "pause", name) 40 dockerCmd(t, "unpause", name) 41 42 defer deleteAllContainers() 43 44 eventsCmd := exec.Command(dockerBinary, "events", "--since=0", fmt.Sprintf("--until=%d", time.Now().Unix())) 45 out, _, _ = runCommandWithOutput(eventsCmd) 46 events := strings.Split(out, "\n") 47 if len(events) <= 1 { 48 t.Fatalf("Missing expected event") 49 } 50 51 pauseEvent := strings.Fields(events[len(events)-3]) 52 unpauseEvent := strings.Fields(events[len(events)-2]) 53 54 if pauseEvent[len(pauseEvent)-1] != "pause" { 55 t.Fatalf("event should be pause, not %#v", pauseEvent) 56 } 57 if unpauseEvent[len(unpauseEvent)-1] != "unpause" { 58 t.Fatalf("event should be unpause, not %#v", unpauseEvent) 59 } 60 61 waitCmd := exec.Command(dockerBinary, "wait", name) 62 if waitOut, _, err := runCommandWithOutput(waitCmd); err != nil { 63 t.Fatalf("error thrown while waiting for container: %s, %v", waitOut, err) 64 } 65 66 logDone("events - pause/unpause is logged") 67 } 68 69 func TestEventsContainerFailStartDie(t *testing.T) { 70 defer deleteAllContainers() 71 72 out, _, _ := dockerCmd(t, "images", "-q") 73 image := strings.Split(out, "\n")[0] 74 eventsCmd := exec.Command(dockerBinary, "run", "-d", "--name", "testeventdie", image, "blerg") 75 _, _, err := runCommandWithOutput(eventsCmd) 76 if err == nil { 77 t.Fatalf("Container run with command blerg should have failed, but it did not") 78 } 79 80 eventsCmd = exec.Command(dockerBinary, "events", "--since=0", fmt.Sprintf("--until=%d", time.Now().Unix())) 81 out, _, _ = runCommandWithOutput(eventsCmd) 82 events := strings.Split(out, "\n") 83 if len(events) <= 1 { 84 t.Fatalf("Missing expected event") 85 } 86 87 startEvent := strings.Fields(events[len(events)-3]) 88 dieEvent := strings.Fields(events[len(events)-2]) 89 90 if startEvent[len(startEvent)-1] != "start" { 91 t.Fatalf("event should be start, not %#v", startEvent) 92 } 93 if dieEvent[len(dieEvent)-1] != "die" { 94 t.Fatalf("event should be die, not %#v", dieEvent) 95 } 96 97 logDone("events - container failed to start logs die") 98 } 99 100 func TestEventsLimit(t *testing.T) { 101 defer deleteAllContainers() 102 for i := 0; i < 30; i++ { 103 dockerCmd(t, "run", "busybox", "echo", strconv.Itoa(i)) 104 } 105 eventsCmd := exec.Command(dockerBinary, "events", "--since=0", fmt.Sprintf("--until=%d", time.Now().Unix())) 106 out, _, _ := runCommandWithOutput(eventsCmd) 107 events := strings.Split(out, "\n") 108 nEvents := len(events) - 1 109 if nEvents != 64 { 110 t.Fatalf("events should be limited to 64, but received %d", nEvents) 111 } 112 logDone("events - limited to 64 entries") 113 } 114 115 func TestEventsContainerEvents(t *testing.T) { 116 dockerCmd(t, "run", "--rm", "busybox", "true") 117 eventsCmd := exec.Command(dockerBinary, "events", "--since=0", fmt.Sprintf("--until=%d", time.Now().Unix())) 118 out, exitCode, err := runCommandWithOutput(eventsCmd) 119 if exitCode != 0 || err != nil { 120 t.Fatalf("Failed to get events with exit code %d: %s", exitCode, err) 121 } 122 events := strings.Split(out, "\n") 123 events = events[:len(events)-1] 124 if len(events) < 4 { 125 t.Fatalf("Missing expected event") 126 } 127 createEvent := strings.Fields(events[len(events)-4]) 128 startEvent := strings.Fields(events[len(events)-3]) 129 dieEvent := strings.Fields(events[len(events)-2]) 130 destroyEvent := strings.Fields(events[len(events)-1]) 131 if createEvent[len(createEvent)-1] != "create" { 132 t.Fatalf("event should be create, not %#v", createEvent) 133 } 134 if startEvent[len(startEvent)-1] != "start" { 135 t.Fatalf("event should be start, not %#v", startEvent) 136 } 137 if dieEvent[len(dieEvent)-1] != "die" { 138 t.Fatalf("event should be die, not %#v", dieEvent) 139 } 140 if destroyEvent[len(destroyEvent)-1] != "destroy" { 141 t.Fatalf("event should be destroy, not %#v", destroyEvent) 142 } 143 144 logDone("events - container create, start, die, destroy is logged") 145 } 146 147 func TestEventsImageUntagDelete(t *testing.T) { 148 name := "testimageevents" 149 defer deleteImages(name) 150 _, err := buildImage(name, 151 `FROM scratch 152 MAINTAINER "docker"`, 153 true) 154 if err != nil { 155 t.Fatal(err) 156 } 157 if err := deleteImages(name); err != nil { 158 t.Fatal(err) 159 } 160 eventsCmd := exec.Command(dockerBinary, "events", "--since=0", fmt.Sprintf("--until=%d", time.Now().Unix())) 161 out, exitCode, err := runCommandWithOutput(eventsCmd) 162 if exitCode != 0 || err != nil { 163 t.Fatalf("Failed to get events with exit code %d: %s", exitCode, err) 164 } 165 events := strings.Split(out, "\n") 166 t.Log(events) 167 events = events[:len(events)-1] 168 if len(events) < 2 { 169 t.Fatalf("Missing expected event") 170 } 171 untagEvent := strings.Fields(events[len(events)-2]) 172 deleteEvent := strings.Fields(events[len(events)-1]) 173 if untagEvent[len(untagEvent)-1] != "untag" { 174 t.Fatalf("untag should be untag, not %#v", untagEvent) 175 } 176 if deleteEvent[len(deleteEvent)-1] != "delete" { 177 t.Fatalf("delete should be delete, not %#v", deleteEvent) 178 } 179 logDone("events - image untag, delete is logged") 180 } 181 182 func TestEventsImagePull(t *testing.T) { 183 since := time.Now().Unix() 184 pullCmd := exec.Command(dockerBinary, "pull", "hello-world") 185 if out, _, err := runCommandWithOutput(pullCmd); err != nil { 186 t.Fatalf("pulling the hello-world image from has failed: %s, %v", out, err) 187 } 188 189 eventsCmd := exec.Command(dockerBinary, "events", 190 fmt.Sprintf("--since=%d", since), 191 fmt.Sprintf("--until=%d", time.Now().Unix())) 192 out, _, _ := runCommandWithOutput(eventsCmd) 193 194 events := strings.Split(strings.TrimSpace(out), "\n") 195 event := strings.TrimSpace(events[len(events)-1]) 196 197 if !strings.HasSuffix(event, "hello-world:latest: pull") { 198 t.Fatalf("Missing pull event - got:%q", event) 199 } 200 201 logDone("events - image pull is logged") 202 } 203 204 func TestEventsImageImport(t *testing.T) { 205 since := time.Now().Unix() 206 207 defer deleteImages("cirros") 208 209 server, err := fileServer(map[string]string{ 210 "/cirros.tar.gz": "/cirros.tar.gz", 211 }) 212 if err != nil { 213 t.Fatal(err) 214 } 215 defer server.Close() 216 fileURL := fmt.Sprintf("%s/cirros.tar.gz", server.URL) 217 importCmd := exec.Command(dockerBinary, "import", fileURL, "cirros") 218 out, _, err := runCommandWithOutput(importCmd) 219 if err != nil { 220 t.Errorf("import failed with errors: %v, output: %q", err, out) 221 } 222 223 eventsCmd := exec.Command(dockerBinary, "events", 224 fmt.Sprintf("--since=%d", since), 225 fmt.Sprintf("--until=%d", time.Now().Unix())) 226 out, _, _ = runCommandWithOutput(eventsCmd) 227 228 events := strings.Split(strings.TrimSpace(out), "\n") 229 event := strings.TrimSpace(events[len(events)-1]) 230 231 if !strings.HasSuffix(event, ": import") { 232 t.Fatalf("Missing pull event - got:%q", event) 233 } 234 235 logDone("events - image import is logged") 236 } 237 238 func TestEventsFilters(t *testing.T) { 239 since := time.Now().Unix() 240 out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "run", "--rm", "busybox", "true")) 241 if err != nil { 242 t.Fatal(out, err) 243 } 244 out, _, err = runCommandWithOutput(exec.Command(dockerBinary, "run", "--rm", "busybox", "true")) 245 if err != nil { 246 t.Fatal(out, err) 247 } 248 eventsCmd := exec.Command(dockerBinary, "events", fmt.Sprintf("--since=%d", since), fmt.Sprintf("--until=%d", time.Now().Unix()), "--filter", "event=die") 249 out, exitCode, err := runCommandWithOutput(eventsCmd) 250 if exitCode != 0 || err != nil { 251 t.Fatalf("Failed to get events with exit code %d: %s", exitCode, err) 252 } 253 events := strings.Split(out, "\n") 254 events = events[:len(events)-1] 255 if len(events) != 2 { 256 t.Fatalf("Expected 2 events, got %d: %v", len(events), events) 257 } 258 dieEvent := strings.Fields(events[len(events)-1]) 259 if dieEvent[len(dieEvent)-1] != "die" { 260 t.Fatalf("event should be die, not %#v", dieEvent) 261 } 262 263 dieEvent = strings.Fields(events[len(events)-2]) 264 if dieEvent[len(dieEvent)-1] != "die" { 265 t.Fatalf("event should be die, not %#v", dieEvent) 266 } 267 268 eventsCmd = exec.Command(dockerBinary, "events", fmt.Sprintf("--since=%d", since), fmt.Sprintf("--until=%d", time.Now().Unix()), "--filter", "event=die", "--filter", "event=start") 269 out, exitCode, err = runCommandWithOutput(eventsCmd) 270 if exitCode != 0 || err != nil { 271 t.Fatalf("Failed to get events with exit code %d: %s", exitCode, err) 272 } 273 events = strings.Split(out, "\n") 274 events = events[:len(events)-1] 275 if len(events) != 4 { 276 t.Fatalf("Expected 4 events, got %d: %v", len(events), events) 277 } 278 startEvent := strings.Fields(events[len(events)-4]) 279 if startEvent[len(startEvent)-1] != "start" { 280 t.Fatalf("event should be start, not %#v", startEvent) 281 } 282 dieEvent = strings.Fields(events[len(events)-3]) 283 if dieEvent[len(dieEvent)-1] != "die" { 284 t.Fatalf("event should be die, not %#v", dieEvent) 285 } 286 startEvent = strings.Fields(events[len(events)-2]) 287 if startEvent[len(startEvent)-1] != "start" { 288 t.Fatalf("event should be start, not %#v", startEvent) 289 } 290 dieEvent = strings.Fields(events[len(events)-1]) 291 if dieEvent[len(dieEvent)-1] != "die" { 292 t.Fatalf("event should be die, not %#v", dieEvent) 293 } 294 295 logDone("events - filters") 296 }