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