github.com/containers/podman/v4@v4.9.4/test/e2e/stop_test.go (about) 1 package integration 2 3 import ( 4 "fmt" 5 "strings" 6 7 . "github.com/containers/podman/v4/test/utils" 8 . "github.com/onsi/ginkgo/v2" 9 . "github.com/onsi/gomega" 10 . "github.com/onsi/gomega/gexec" 11 ) 12 13 var _ = Describe("Podman stop", func() { 14 15 It("podman stop bogus container", func() { 16 session := podmanTest.Podman([]string{"stop", "foobar"}) 17 session.WaitWithDefaultTimeout() 18 Expect(session).Should(Exit(125)) 19 }) 20 21 It("podman stop --ignore bogus container", func() { 22 session := podmanTest.RunTopContainer("") 23 session.WaitWithDefaultTimeout() 24 Expect(session).Should(ExitCleanly()) 25 cid := session.OutputToString() 26 27 session = podmanTest.Podman([]string{"stop", "--ignore", "foobar", cid}) 28 session.WaitWithDefaultTimeout() 29 Expect(session).Should(ExitCleanly()) 30 output := session.OutputToString() 31 Expect(output).To(ContainSubstring(cid)) 32 }) 33 34 It("podman stop container by id", func() { 35 session := podmanTest.RunTopContainer("") 36 session.WaitWithDefaultTimeout() 37 Expect(session).Should(ExitCleanly()) 38 cid := session.OutputToString() 39 session = podmanTest.Podman([]string{"stop", cid}) 40 session.WaitWithDefaultTimeout() 41 Expect(session).Should(ExitCleanly()) 42 43 finalCtrs := podmanTest.Podman([]string{"ps", "-q"}) 44 finalCtrs.WaitWithDefaultTimeout() 45 Expect(finalCtrs).Should(ExitCleanly()) 46 Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal("")) 47 }) 48 49 It("podman stop single container by short id", func() { 50 session := podmanTest.RunTopContainer("test1") 51 session.WaitWithDefaultTimeout() 52 Expect(session).Should(ExitCleanly()) 53 cid := session.OutputToString() 54 shortID := cid[0:10] 55 56 session = podmanTest.Podman([]string{"stop", shortID}) 57 session.WaitWithDefaultTimeout() 58 Expect(session).Should(ExitCleanly()) 59 Expect(session.OutputToString()).To(Equal(shortID)) 60 }) 61 62 It("podman stop container by name", func() { 63 session := podmanTest.RunTopContainer("test1") 64 session.WaitWithDefaultTimeout() 65 Expect(session).Should(ExitCleanly()) 66 session = podmanTest.Podman([]string{"stop", "test1"}) 67 session.WaitWithDefaultTimeout() 68 Expect(session).Should(ExitCleanly()) 69 70 finalCtrs := podmanTest.Podman([]string{"ps", "-q"}) 71 finalCtrs.WaitWithDefaultTimeout() 72 Expect(finalCtrs).Should(ExitCleanly()) 73 Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal("")) 74 }) 75 76 It("podman container stop by name", func() { 77 session := podmanTest.RunTopContainer("test1") 78 session.WaitWithDefaultTimeout() 79 Expect(session).Should(ExitCleanly()) 80 session = podmanTest.Podman([]string{"container", "stop", "test1"}) 81 session.WaitWithDefaultTimeout() 82 Expect(session).Should(ExitCleanly()) 83 84 finalCtrs := podmanTest.Podman([]string{"ps", "-q"}) 85 finalCtrs.WaitWithDefaultTimeout() 86 Expect(finalCtrs).Should(ExitCleanly()) 87 Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal("")) 88 }) 89 90 It("podman stop stopped container", func() { 91 session := podmanTest.RunTopContainer("test1") 92 session.WaitWithDefaultTimeout() 93 Expect(session).Should(ExitCleanly()) 94 95 session2 := podmanTest.Podman([]string{"stop", "test1"}) 96 session2.WaitWithDefaultTimeout() 97 Expect(session2).Should(ExitCleanly()) 98 99 session3 := podmanTest.Podman([]string{"stop", "test1"}) 100 session3.WaitWithDefaultTimeout() 101 Expect(session3).Should(ExitCleanly()) 102 103 finalCtrs := podmanTest.Podman([]string{"ps", "-q"}) 104 finalCtrs.WaitWithDefaultTimeout() 105 Expect(finalCtrs).Should(ExitCleanly()) 106 Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal("")) 107 108 // make sure we only have one cleanup event for this container 109 events := podmanTest.Podman([]string{"events", "--since=30s", "--stream=false"}) 110 events.WaitWithDefaultTimeout() 111 Expect(events).Should(ExitCleanly()) 112 Expect(strings.Count(events.OutputToString(), "container cleanup")).To(Equal(1), "cleanup event should show up exactly once") 113 }) 114 115 It("podman stop all containers -t", func() { 116 session := podmanTest.RunTopContainer("test1") 117 session.WaitWithDefaultTimeout() 118 Expect(session).Should(ExitCleanly()) 119 cid1 := session.OutputToString() 120 121 session = podmanTest.RunTopContainer("test2") 122 session.WaitWithDefaultTimeout() 123 Expect(session).Should(ExitCleanly()) 124 cid2 := session.OutputToString() 125 126 session = podmanTest.RunTopContainer("test3") 127 session.WaitWithDefaultTimeout() 128 Expect(session).Should(ExitCleanly()) 129 cid3 := session.OutputToString() 130 131 session = podmanTest.Podman([]string{"stop", "-a", "-t", "1"}) 132 session.WaitWithDefaultTimeout() 133 Expect(session).Should(ExitCleanly()) 134 output := session.OutputToString() 135 Expect(output).To(ContainSubstring(cid1)) 136 Expect(output).To(ContainSubstring(cid2)) 137 Expect(output).To(ContainSubstring(cid3)) 138 139 finalCtrs := podmanTest.Podman([]string{"ps", "-q"}) 140 finalCtrs.WaitWithDefaultTimeout() 141 Expect(finalCtrs).Should(ExitCleanly()) 142 Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal("")) 143 }) 144 145 It("podman stop container --time", func() { 146 session := podmanTest.RunTopContainer("test4") 147 session.WaitWithDefaultTimeout() 148 Expect(session).Should(ExitCleanly()) 149 150 session = podmanTest.Podman([]string{"stop", "--time", "0", "test4"}) 151 session.WaitWithDefaultTimeout() 152 Expect(session).Should(ExitCleanly()) 153 output := session.OutputToString() 154 Expect(output).To(ContainSubstring("test4")) 155 156 finalCtrs := podmanTest.Podman([]string{"ps", "-q"}) 157 finalCtrs.WaitWithDefaultTimeout() 158 Expect(finalCtrs).Should(ExitCleanly()) 159 Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal("")) 160 }) 161 162 It("podman stop container --timeout", func() { 163 session := podmanTest.Podman([]string{"run", "-d", "--name", "test5", ALPINE, "sleep", "100"}) 164 session.WaitWithDefaultTimeout() 165 Expect(session).Should(ExitCleanly()) 166 session = podmanTest.Podman([]string{"stop", "--timeout", "0", "test5"}) 167 // Without timeout container stops in 10 seconds 168 // If not stopped in 5 seconds, then --timeout did not work 169 session.Wait(5) 170 Expect(session).Should(ExitCleanly()) 171 output := session.OutputToString() 172 Expect(output).To(ContainSubstring("test5")) 173 174 finalCtrs := podmanTest.Podman([]string{"ps", "-q"}) 175 finalCtrs.WaitWithDefaultTimeout() 176 Expect(finalCtrs).Should(ExitCleanly()) 177 Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal("")) 178 }) 179 180 It("podman stop container --timeout Warning", func() { 181 SkipIfRemote("warning will happen only on server side") 182 session := podmanTest.Podman([]string{"run", "-d", "--name", "test5", ALPINE, "sleep", "100"}) 183 session.WaitWithDefaultTimeout() 184 Expect(session).Should(ExitCleanly()) 185 session = podmanTest.Podman([]string{"stop", "--timeout", "1", "test5"}) 186 session.WaitWithDefaultTimeout() 187 Expect(session).Should(Exit(0)) 188 warning := session.ErrorToString() 189 Expect(warning).To(ContainSubstring("StopSignal SIGTERM failed to stop container test5 in 1 seconds, resorting to SIGKILL")) 190 }) 191 192 It("podman stop latest containers", func() { 193 SkipIfRemote("--latest flag n/a") 194 session := podmanTest.RunTopContainer("test1") 195 session.WaitWithDefaultTimeout() 196 Expect(session).Should(ExitCleanly()) 197 cid := session.OutputToString() 198 199 session = podmanTest.Podman([]string{"stop", "-l", "-t", "1"}) 200 session.WaitWithDefaultTimeout() 201 Expect(session).Should(ExitCleanly()) 202 Expect(session.OutputToString()).To(Equal(cid)) 203 204 finalCtrs := podmanTest.Podman([]string{"ps", "-q"}) 205 finalCtrs.WaitWithDefaultTimeout() 206 Expect(finalCtrs).Should(ExitCleanly()) 207 Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal("")) 208 }) 209 210 It("podman stop all containers with one stopped", func() { 211 session := podmanTest.RunTopContainer("test1") 212 session.WaitWithDefaultTimeout() 213 Expect(session).Should(ExitCleanly()) 214 session2 := podmanTest.RunTopContainer("test2") 215 session2.WaitWithDefaultTimeout() 216 Expect(session2).Should(ExitCleanly()) 217 cid := "-l" 218 if IsRemote() { 219 cid = "test2" 220 } 221 session3 := podmanTest.Podman([]string{"stop", cid, "-t", "1"}) 222 session3.WaitWithDefaultTimeout() 223 Expect(session3).Should(ExitCleanly()) 224 session4 := podmanTest.Podman([]string{"stop", "-a", "-t", "1"}) 225 session4.WaitWithDefaultTimeout() 226 Expect(session4).Should(ExitCleanly()) 227 finalCtrs := podmanTest.Podman([]string{"ps", "-q"}) 228 finalCtrs.WaitWithDefaultTimeout() 229 Expect(finalCtrs).Should(ExitCleanly()) 230 Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal("")) 231 }) 232 233 It("podman stop all containers with one created", func() { 234 session := podmanTest.RunTopContainer("test1") 235 session.WaitWithDefaultTimeout() 236 Expect(session).Should(ExitCleanly()) 237 session2 := podmanTest.Podman([]string{"create", ALPINE, "/bin/sh"}) 238 session2.WaitWithDefaultTimeout() 239 Expect(session2).Should(ExitCleanly()) 240 session3 := podmanTest.Podman([]string{"stop", "-a", "-t", "1"}) 241 session3.WaitWithDefaultTimeout() 242 Expect(session3).Should(ExitCleanly()) 243 finalCtrs := podmanTest.Podman([]string{"ps", "-q"}) 244 finalCtrs.WaitWithDefaultTimeout() 245 Expect(finalCtrs).Should(ExitCleanly()) 246 Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal("")) 247 }) 248 249 It("podman stop should return silent success on stopping configured containers", func() { 250 // following container is not created on OCI runtime 251 // so we return success and assume that it is stopped 252 session2 := podmanTest.Podman([]string{"create", "--name", "stopctr", ALPINE, "/bin/sh"}) 253 session2.WaitWithDefaultTimeout() 254 Expect(session2).Should(ExitCleanly()) 255 session3 := podmanTest.Podman([]string{"stop", "stopctr"}) 256 session3.WaitWithDefaultTimeout() 257 Expect(session3).Should(ExitCleanly()) 258 }) 259 260 It("podman stop --cidfile", func() { 261 tmpDir := GinkgoT().TempDir() 262 tmpFile := tmpDir + "cid" 263 264 session := podmanTest.Podman([]string{"create", "--cidfile", tmpFile, ALPINE, "top"}) 265 session.WaitWithDefaultTimeout() 266 Expect(session).Should(ExitCleanly()) 267 cid := session.OutputToStringArray()[0] 268 269 session = podmanTest.Podman([]string{"start", cid}) 270 session.WaitWithDefaultTimeout() 271 Expect(session).Should(ExitCleanly()) 272 273 result := podmanTest.Podman([]string{"stop", "--cidfile", tmpFile}) 274 result.WaitWithDefaultTimeout() 275 Expect(result).Should(ExitCleanly()) 276 output := result.OutputToString() 277 Expect(output).To(ContainSubstring(cid)) 278 }) 279 280 It("podman stop multiple --cidfile", func() { 281 tmpDir := GinkgoT().TempDir() 282 tmpFile1 := tmpDir + "cid-1" 283 tmpFile2 := tmpDir + "cid-2" 284 285 session := podmanTest.Podman([]string{"run", "--cidfile", tmpFile1, "-d", ALPINE, "top"}) 286 session.WaitWithDefaultTimeout() 287 Expect(session).Should(ExitCleanly()) 288 cid1 := session.OutputToStringArray()[0] 289 Expect(podmanTest.NumberOfContainers()).To(Equal(1)) 290 291 session = podmanTest.Podman([]string{"run", "--cidfile", tmpFile2, "-d", ALPINE, "top"}) 292 session.WaitWithDefaultTimeout() 293 Expect(session).Should(ExitCleanly()) 294 cid2 := session.OutputToStringArray()[0] 295 Expect(podmanTest.NumberOfContainers()).To(Equal(2)) 296 297 result := podmanTest.Podman([]string{"stop", "--cidfile", tmpFile1, "--cidfile", tmpFile2}) 298 result.WaitWithDefaultTimeout() 299 Expect(result).Should(ExitCleanly()) 300 output := result.OutputToString() 301 Expect(output).To(ContainSubstring(cid1)) 302 Expect(output).To(ContainSubstring(cid2)) 303 Expect(podmanTest.NumberOfContainers()).To(Equal(2)) 304 }) 305 306 It("podman stop invalid --latest and --cidfile and --all", func() { 307 SkipIfRemote("--latest flag n/a") 308 309 result := podmanTest.Podman([]string{"stop", "--cidfile", "foobar", "--latest"}) 310 result.WaitWithDefaultTimeout() 311 Expect(result).Should(Exit(125)) 312 313 result = podmanTest.Podman([]string{"stop", "--cidfile", "foobar", "--all"}) 314 result.WaitWithDefaultTimeout() 315 Expect(result).Should(Exit(125)) 316 317 result = podmanTest.Podman([]string{"stop", "--cidfile", "foobar", "--all", "--latest"}) 318 result.WaitWithDefaultTimeout() 319 Expect(result).Should(Exit(125)) 320 321 result = podmanTest.Podman([]string{"stop", "--latest", "--all"}) 322 result.WaitWithDefaultTimeout() 323 Expect(result).Should(Exit(125)) 324 }) 325 326 It("podman stop --all", func() { 327 session := podmanTest.RunTopContainer("") 328 session.WaitWithDefaultTimeout() 329 Expect(session).Should(ExitCleanly()) 330 Expect(podmanTest.NumberOfContainersRunning()).To(Equal(1)) 331 332 session = podmanTest.RunTopContainer("") 333 session.WaitWithDefaultTimeout() 334 Expect(session).Should(ExitCleanly()) 335 Expect(podmanTest.NumberOfContainersRunning()).To(Equal(2)) 336 337 session = podmanTest.Podman([]string{"stop", "--all"}) 338 session.WaitWithDefaultTimeout() 339 Expect(session).Should(ExitCleanly()) 340 Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0)) 341 }) 342 343 It("podman stop --ignore", func() { 344 session := podmanTest.RunTopContainer("") 345 session.WaitWithDefaultTimeout() 346 Expect(session).Should(ExitCleanly()) 347 cid := session.OutputToString() 348 Expect(podmanTest.NumberOfContainersRunning()).To(Equal(1)) 349 350 session = podmanTest.Podman([]string{"stop", "bogus", cid}) 351 session.WaitWithDefaultTimeout() 352 Expect(session).Should(Exit(125)) 353 354 session = podmanTest.Podman([]string{"stop", "--ignore", "bogus", cid}) 355 session.WaitWithDefaultTimeout() 356 Expect(session).Should(ExitCleanly()) 357 Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0)) 358 }) 359 360 It("podman stop --filter", func() { 361 session1 := podmanTest.Podman([]string{"container", "create", ALPINE}) 362 session1.WaitWithDefaultTimeout() 363 Expect(session1).Should(ExitCleanly()) 364 cid1 := session1.OutputToString() 365 366 session1 = podmanTest.Podman([]string{"container", "create", ALPINE}) 367 session1.WaitWithDefaultTimeout() 368 Expect(session1).Should(ExitCleanly()) 369 cid2 := session1.OutputToString() 370 371 session1 = podmanTest.Podman([]string{"container", "create", ALPINE}) 372 session1.WaitWithDefaultTimeout() 373 Expect(session1).Should(ExitCleanly()) 374 cid3 := session1.OutputToString() 375 shortCid3 := cid3[0:5] 376 377 session1 = podmanTest.Podman([]string{"container", "create", "--label", "test=with,comma", ALPINE}) 378 session1.WaitWithDefaultTimeout() 379 Expect(session1).Should(ExitCleanly()) 380 cid4 := session1.OutputToString() 381 382 session1 = podmanTest.Podman([]string{"start", "--all"}) 383 session1.WaitWithDefaultTimeout() 384 Expect(session1).Should(ExitCleanly()) 385 386 session1 = podmanTest.Podman([]string{"stop", cid1, "-f", "status=running"}) 387 session1.WaitWithDefaultTimeout() 388 Expect(session1).Should(Exit(125)) 389 390 session1 = podmanTest.Podman([]string{"stop", "-a", "--filter", fmt.Sprintf("id=%swrongid", shortCid3)}) 391 session1.WaitWithDefaultTimeout() 392 Expect(session1).Should(ExitCleanly()) 393 Expect(session1.OutputToString()).To(BeEmpty()) 394 395 session1 = podmanTest.Podman([]string{"stop", "-a", "--filter", fmt.Sprintf("id=%s", shortCid3)}) 396 session1.WaitWithDefaultTimeout() 397 Expect(session1).Should(ExitCleanly()) 398 Expect(session1.OutputToString()).To(BeEquivalentTo(cid3)) 399 400 session1 = podmanTest.Podman([]string{"stop", "-a", "--filter", "label=test=with,comma"}) 401 session1.WaitWithDefaultTimeout() 402 Expect(session1).Should(ExitCleanly()) 403 Expect(session1.OutputToString()).To(BeEquivalentTo(cid4)) 404 405 session1 = podmanTest.Podman([]string{"stop", "-f", fmt.Sprintf("id=%s", cid2)}) 406 session1.WaitWithDefaultTimeout() 407 Expect(session1).Should(ExitCleanly()) 408 Expect(session1.OutputToString()).To(BeEquivalentTo(cid2)) 409 }) 410 })