github.com/containers/podman/v5@v5.1.0-rc1/test/e2e/ps_test.go (about) 1 package integration 2 3 import ( 4 "fmt" 5 "regexp" 6 "sort" 7 "strconv" 8 9 . "github.com/containers/podman/v5/test/utils" 10 "github.com/containers/storage/pkg/stringid" 11 "github.com/docker/go-units" 12 . "github.com/onsi/ginkgo/v2" 13 . "github.com/onsi/gomega" 14 . "github.com/onsi/gomega/gexec" 15 ) 16 17 var _ = Describe("Podman ps", func() { 18 19 It("podman ps no containers", func() { 20 session := podmanTest.Podman([]string{"ps"}) 21 session.WaitWithDefaultTimeout() 22 Expect(session).Should(ExitCleanly()) 23 }) 24 25 It("podman container ps no containers", func() { 26 session := podmanTest.Podman([]string{"container", "ps"}) 27 session.WaitWithDefaultTimeout() 28 Expect(session).Should(ExitCleanly()) 29 }) 30 31 It("podman ps default", func() { 32 session := podmanTest.RunTopContainer("") 33 session.WaitWithDefaultTimeout() 34 Expect(session).Should(ExitCleanly()) 35 36 result := podmanTest.Podman([]string{"ps"}) 37 result.WaitWithDefaultTimeout() 38 Expect(result).Should(ExitCleanly()) 39 Expect(result.OutputToStringArray()).ShouldNot(BeEmpty()) 40 }) 41 42 It("podman ps all", func() { 43 _, ec, _ := podmanTest.RunLsContainer("") 44 Expect(ec).To(Equal(0)) 45 46 result := podmanTest.Podman([]string{"ps", "-a"}) 47 result.WaitWithDefaultTimeout() 48 Expect(result).Should(ExitCleanly()) 49 Expect(result.OutputToStringArray()).ShouldNot(BeEmpty()) 50 }) 51 52 It("podman container list all", func() { 53 _, ec, _ := podmanTest.RunLsContainer("") 54 Expect(ec).To(Equal(0)) 55 56 result := podmanTest.Podman([]string{"container", "list", "-a"}) 57 result.WaitWithDefaultTimeout() 58 Expect(result).Should(ExitCleanly()) 59 Expect(result.OutputToStringArray()).ShouldNot(BeEmpty()) 60 61 result = podmanTest.Podman([]string{"container", "ls", "-a"}) 62 result.WaitWithDefaultTimeout() 63 Expect(result).Should(ExitCleanly()) 64 Expect(result.OutputToStringArray()).ShouldNot(BeEmpty()) 65 }) 66 67 It("podman ps size flag", func() { 68 _, ec, _ := podmanTest.RunLsContainer("") 69 Expect(ec).To(Equal(0)) 70 71 result := podmanTest.Podman([]string{"ps", "-a", "--size"}) 72 result.WaitWithDefaultTimeout() 73 Expect(result).Should(ExitCleanly()) 74 Expect(result.OutputToStringArray()).ShouldNot(BeEmpty()) 75 }) 76 77 It("podman ps quiet flag", func() { 78 _, ec, fullCid := podmanTest.RunLsContainer("") 79 Expect(ec).To(Equal(0)) 80 81 result := podmanTest.Podman([]string{"ps", "-a", "-q"}) 82 result.WaitWithDefaultTimeout() 83 Expect(result).Should(ExitCleanly()) 84 Expect(result.OutputToStringArray()).ShouldNot(BeEmpty()) 85 Expect(fullCid).To(ContainSubstring(result.OutputToStringArray()[0])) 86 }) 87 88 It("podman ps latest flag", func() { 89 SkipIfRemote("--latest is not supported on podman-remote") 90 _, ec, _ := podmanTest.RunLsContainer("") 91 Expect(ec).To(Equal(0)) 92 _, ec, _ = podmanTest.RunLsContainer("") 93 Expect(ec).To(Equal(0)) 94 95 result := podmanTest.Podman([]string{"ps", "-q", "--latest"}) 96 result.WaitWithDefaultTimeout() 97 Expect(result).Should(ExitCleanly()) 98 Expect(result.OutputToStringArray()).To(HaveLen(1)) 99 }) 100 101 It("podman ps last flag", func() { 102 Skip("--last flag nonfunctional and disabled") 103 104 // Make sure that non-running containers are being counted as 105 // well. 106 session := podmanTest.Podman([]string{"create", "alpine", "top"}) 107 session.WaitWithDefaultTimeout() 108 Expect(session).Should(ExitCleanly()) 109 110 result := podmanTest.Podman([]string{"ps", "--last", "2"}) 111 result.WaitWithDefaultTimeout() 112 Expect(result).Should(ExitCleanly()) 113 Expect(result.OutputToStringArray()).Should(HaveLen(2)) // 1 container 114 115 _, ec, _ := podmanTest.RunLsContainer("test1") 116 Expect(ec).To(Equal(0)) 117 118 _, ec, _ = podmanTest.RunLsContainer("test2") 119 Expect(ec).To(Equal(0)) 120 121 _, ec, _ = podmanTest.RunLsContainer("test3") 122 Expect(ec).To(Equal(0)) 123 124 result = podmanTest.Podman([]string{"ps", "--last", "2"}) 125 result.WaitWithDefaultTimeout() 126 Expect(result).Should(ExitCleanly()) 127 Expect(result.OutputToStringArray()).Should(HaveLen(3)) // 2 containers 128 129 result = podmanTest.Podman([]string{"ps", "--last", "3"}) 130 result.WaitWithDefaultTimeout() 131 Expect(result).Should(ExitCleanly()) 132 Expect(result.OutputToStringArray()).Should(HaveLen(4)) // 3 containers 133 134 result = podmanTest.Podman([]string{"ps", "--last", "100"}) 135 result.WaitWithDefaultTimeout() 136 Expect(result).Should(ExitCleanly()) 137 Expect(result.OutputToStringArray()).Should(HaveLen(5)) // 4 containers (3 running + 1 created) 138 }) 139 140 It("podman ps no-trunc", func() { 141 _, ec, fullCid := podmanTest.RunLsContainer("") 142 Expect(ec).To(Equal(0)) 143 144 result := podmanTest.Podman([]string{"ps", "-aq", "--no-trunc"}) 145 result.WaitWithDefaultTimeout() 146 Expect(result).Should(ExitCleanly()) 147 Expect(result.OutputToStringArray()).ShouldNot(BeEmpty()) 148 Expect(fullCid).To(Equal(result.OutputToStringArray()[0])) 149 }) 150 151 It("podman ps --filter network=container:<name>", func() { 152 ctrAlpha := "alpha" 153 container := podmanTest.Podman([]string{"run", "-dt", "--name", ctrAlpha, ALPINE, "top"}) 154 container.WaitWithDefaultTimeout() 155 Expect(container).Should(ExitCleanly()) 156 157 ctrBravo := "bravo" 158 containerBravo := podmanTest.Podman([]string{"run", "-dt", "--network", "container:alpha", "--name", ctrBravo, ALPINE, "top"}) 159 containerBravo.WaitWithDefaultTimeout() 160 Expect(containerBravo).Should(ExitCleanly()) 161 162 result := podmanTest.Podman([]string{"ps", "-a", "--format", "table {{.Names}}", "--filter", "network=container:alpha"}) 163 result.WaitWithDefaultTimeout() 164 result.WaitWithDefaultTimeout() 165 Expect(result).Should(ExitCleanly()) 166 167 actual := result.OutputToString() 168 Expect(actual).To(ContainSubstring("bravo")) 169 Expect(actual).To(ContainSubstring("NAMES")) 170 }) 171 172 It("podman ps --filter network=container:<id>", func() { 173 ctrAlpha := "first" 174 container := podmanTest.Podman([]string{"run", "-dt", "--name", ctrAlpha, ALPINE, "top"}) 175 container.WaitWithDefaultTimeout() 176 cid := container.OutputToString() 177 Expect(container).Should(ExitCleanly()) 178 179 ctrBravo := "second" 180 containerBravo := podmanTest.Podman([]string{"run", "-dt", "--network", "container:" + cid, "--name", ctrBravo, ALPINE, "top"}) 181 containerBravo.WaitWithDefaultTimeout() 182 Expect(containerBravo).Should(ExitCleanly()) 183 184 result := podmanTest.Podman([]string{"ps", "-a", "--format", "table {{.Names}}", "--filter", "network=container:" + cid}) 185 result.WaitWithDefaultTimeout() 186 result.WaitWithDefaultTimeout() 187 Expect(result).Should(ExitCleanly()) 188 actual := result.OutputToString() 189 Expect(actual).To(ContainSubstring("second")) 190 Expect(actual).ToNot(ContainSubstring("table")) 191 }) 192 193 It("podman ps --filter label=test=with,comma", func() { 194 ctrAlpha := "first" 195 container := podmanTest.Podman([]string{"run", "-dt", "--label", "test=with,comma", "--name", ctrAlpha, ALPINE, "top"}) 196 container.WaitWithDefaultTimeout() 197 Expect(container).Should(ExitCleanly()) 198 199 ctrBravo := "second" 200 containerBravo := podmanTest.Podman([]string{"run", "-dt", "--name", ctrBravo, ALPINE, "top"}) 201 containerBravo.WaitWithDefaultTimeout() 202 Expect(containerBravo).Should(ExitCleanly()) 203 204 result := podmanTest.Podman([]string{"ps", "-a", "--format", "table {{.Names}}", "--filter", "label=test=with,comma"}) 205 result.WaitWithDefaultTimeout() 206 result.WaitWithDefaultTimeout() 207 Expect(result).Should(ExitCleanly()) 208 actual := result.OutputToString() 209 Expect(actual).To(ContainSubstring("first")) 210 Expect(actual).ToNot(ContainSubstring("table")) 211 }) 212 213 It("podman ps namespace flag", func() { 214 _, ec, _ := podmanTest.RunLsContainer("") 215 Expect(ec).To(Equal(0)) 216 217 result := podmanTest.Podman([]string{"ps", "-a", "--namespace"}) 218 result.WaitWithDefaultTimeout() 219 Expect(result).Should(ExitCleanly()) 220 Expect(result.OutputToStringArray()).ShouldNot(BeEmpty()) 221 }) 222 223 It("podman ps namespace flag even for remote", func() { 224 session := podmanTest.RunTopContainer("test1") 225 session.WaitWithDefaultTimeout() 226 227 result := podmanTest.Podman([]string{"ps", "-a", "--ns", "--format", 228 "{{with .Namespaces}}{{.Cgroup}}:{{.IPC}}:{{.MNT}}:{{.NET}}:{{.PIDNS}}:{{.User}}:{{.UTS}}{{end}}"}) 229 result.WaitWithDefaultTimeout() 230 Expect(result).Should(ExitCleanly()) 231 // it must contains `::` when some ns is null. If it works normally, it should be "$num1:$num2:$num3" 232 Expect(result.OutputToString()).ToNot(ContainSubstring(`::`)) 233 }) 234 235 It("podman ps with no containers is valid json format", func() { 236 result := podmanTest.Podman([]string{"ps", "--format", "json"}) 237 result.WaitWithDefaultTimeout() 238 Expect(result).Should(ExitCleanly()) 239 Expect(result.OutputToString()).To(BeValidJSON()) 240 }) 241 242 It("podman ps namespace flag with json format", func() { 243 _, ec, _ := podmanTest.RunLsContainer("test1") 244 Expect(ec).To(Equal(0)) 245 246 result := podmanTest.Podman([]string{"ps", "-a", "--ns", "--format", "{{ json . }}"}) 247 result.WaitWithDefaultTimeout() 248 Expect(result).Should(ExitCleanly()) 249 Expect(result.OutputToString()).To(BeValidJSON()) 250 // https://github.com/containers/podman/issues/16436 251 Expect(result.OutputToString()).To(HavePrefix("{"), "test for single json object and not array see #16436") 252 }) 253 254 It("podman ps json format Created field is int64", func() { 255 session := podmanTest.RunTopContainer("test1") 256 session.WaitWithDefaultTimeout() 257 Expect(session).Should(ExitCleanly()) 258 259 result := podmanTest.Podman([]string{"ps", "--format", "json"}) 260 result.WaitWithDefaultTimeout() 261 Expect(result).Should(ExitCleanly()) 262 263 // Make sure Created field is an int64 264 created, err := result.jq(".[0].Created") 265 Expect(err).ToNot(HaveOccurred()) 266 _, err = strconv.ParseInt(created, 10, 64) 267 Expect(err).ToNot(HaveOccurred()) 268 }) 269 270 It("podman ps print a human-readable `Status` with json format", func() { 271 _, ec, _ := podmanTest.RunLsContainer("test1") 272 Expect(ec).To(Equal(0), "container exit code") 273 274 result := podmanTest.Podman([]string{"ps", "-a", "--format", "json"}) 275 result.WaitWithDefaultTimeout() 276 Expect(result).Should(ExitCleanly()) 277 Expect(result.OutputToString()).To(BeValidJSON()) 278 // must contain "Status" 279 match, StatusLine := result.GrepString(`Status`) 280 Expect(match).To(BeTrue(), "found 'Status'") 281 // we waited for container to exit, so this must contain `Exited` 282 Expect(StatusLine[0]).To(ContainSubstring("Exited")) 283 }) 284 285 It("podman ps namespace flag with go template format", func() { 286 _, ec, _ := podmanTest.RunLsContainer("test1") 287 Expect(ec).To(Equal(0)) 288 289 result := podmanTest.Podman([]string{"ps", "-a", "--format", "table {{.ID}} {{.Image}} {{.ImageID}} {{.Labels}}"}) 290 result.WaitWithDefaultTimeout() 291 Expect(result).Should(ExitCleanly()) 292 293 Expect(result.OutputToString()).ToNot(ContainSubstring("table")) 294 295 actual := result.OutputToStringArray() 296 Expect(actual[0]).To(ContainSubstring("CONTAINER ID")) 297 Expect(actual[0]).ToNot(ContainSubstring("ImageID")) 298 Expect(actual[1]).To(ContainSubstring("alpine:latest")) 299 }) 300 301 It("podman ps ancestor filter flag", func() { 302 _, ec, cid := podmanTest.RunLsContainer("test1") 303 Expect(ec).To(Equal(0)) 304 305 result := podmanTest.Podman([]string{"ps", "-q", "--no-trunc", "-a", "--filter", "ancestor=quay.io/libpod/alpine:latest"}) 306 result.WaitWithDefaultTimeout() 307 Expect(result).Should(ExitCleanly()) 308 Expect(result.OutputToString()).To(Equal(cid)) 309 310 // Query just by image name, without :latest tag 311 result = podmanTest.Podman([]string{"ps", "-q", "--no-trunc", "-a", "--filter", "ancestor=quay.io/libpod/alpine"}) 312 result.WaitWithDefaultTimeout() 313 Expect(result).Should(ExitCleanly()) 314 Expect(result.OutputToString()).To(Equal(cid)) 315 316 // Query by truncated image name should match (regexp match) 317 result = podmanTest.Podman([]string{"ps", "-q", "--no-trunc", "-a", "--filter", "ancestor=quay.io/libpod/alpi"}) 318 result.WaitWithDefaultTimeout() 319 Expect(result).Should(ExitCleanly()) 320 Expect(result.OutputToString()).To(Equal(cid)) 321 322 // Query using regex by truncated image name should match (regexp match) 323 result = podmanTest.Podman([]string{"ps", "-q", "--no-trunc", "-a", "--filter", "ancestor=^(quay.io|docker.io)/libpod/alpine:[a-zA-Z]+"}) 324 result.WaitWithDefaultTimeout() 325 Expect(result).Should(ExitCleanly()) 326 Expect(result.OutputToString()).To(Equal(cid)) 327 328 // Query for a non-existing image using regex should not match anything 329 result = podmanTest.Podman([]string{"ps", "-q", "--no-trunc", "-a", "--filter", "ancestor=^quai.io/libpod/alpi"}) 330 result.WaitWithDefaultTimeout() 331 Expect(result).Should(ExitCleanly()) 332 Expect(result.OutputToString()).To(Equal("")) 333 }) 334 335 It("podman ps id filter flag", func() { 336 _, ec, fullCid := podmanTest.RunLsContainer("") 337 Expect(ec).To(Equal(0)) 338 339 result := podmanTest.Podman([]string{"ps", "-a", "--filter", fmt.Sprintf("id=%s", fullCid)}) 340 result.WaitWithDefaultTimeout() 341 Expect(result).Should(ExitCleanly()) 342 }) 343 344 It("podman ps id filter flag", func() { 345 session := podmanTest.RunTopContainer("") 346 session.WaitWithDefaultTimeout() 347 Expect(session).Should(ExitCleanly()) 348 fullCid := session.OutputToString() 349 350 result := podmanTest.Podman([]string{"ps", "-aq", "--no-trunc", "--filter", "status=running"}) 351 result.WaitWithDefaultTimeout() 352 Expect(result).Should(ExitCleanly()) 353 Expect(result.OutputToStringArray()[0]).To(Equal(fullCid)) 354 }) 355 356 It("podman ps multiple filters", func() { 357 session := podmanTest.Podman([]string{"run", "-d", "--name", "test1", "--label", "key1=value1", ALPINE, "top"}) 358 session.WaitWithDefaultTimeout() 359 Expect(session).Should(ExitCleanly()) 360 fullCid := session.OutputToString() 361 362 session2 := podmanTest.Podman([]string{"run", "-d", "--name", "test2", "--label", "key1=value1", ALPINE, "top"}) 363 session2.WaitWithDefaultTimeout() 364 Expect(session2).Should(ExitCleanly()) 365 366 result := podmanTest.Podman([]string{"ps", "-aq", "--no-trunc", "--filter", "name=test1", "--filter", "label=key1=value1"}) 367 result.WaitWithDefaultTimeout() 368 Expect(result).Should(ExitCleanly()) 369 370 output := result.OutputToStringArray() 371 Expect(output).To(HaveLen(1)) 372 Expect(output[0]).To(Equal(fullCid)) 373 }) 374 375 It("podman ps filter by exited does not need all", func() { 376 ctr := podmanTest.Podman([]string{"run", ALPINE, "ls", "/"}) 377 ctr.WaitWithDefaultTimeout() 378 Expect(ctr).Should(ExitCleanly()) 379 380 psAll := podmanTest.Podman([]string{"ps", "-aq", "--no-trunc"}) 381 psAll.WaitWithDefaultTimeout() 382 Expect(psAll).Should(ExitCleanly()) 383 384 psFilter := podmanTest.Podman([]string{"ps", "--no-trunc", "--quiet", "--filter", "status=exited"}) 385 psFilter.WaitWithDefaultTimeout() 386 Expect(psFilter).Should(ExitCleanly()) 387 388 Expect(psAll.OutputToString()).To(Equal(psFilter.OutputToString())) 389 }) 390 391 It("podman filter without status does not find non-running", func() { 392 ctrName := "aContainerName" 393 ctr := podmanTest.Podman([]string{"create", "--name", ctrName, ALPINE, "ls", "/"}) 394 ctr.WaitWithDefaultTimeout() 395 Expect(ctr).Should(ExitCleanly()) 396 397 psFilter := podmanTest.Podman([]string{"ps", "--no-trunc", "--quiet", "--format", "{{.Names}}", "--filter", fmt.Sprintf("name=%s", ctrName)}) 398 psFilter.WaitWithDefaultTimeout() 399 Expect(psFilter).Should(ExitCleanly()) 400 401 actual := psFilter.OutputToString() 402 Expect(actual).ToNot(ContainSubstring(ctrName)) 403 Expect(actual).ToNot(ContainSubstring("NAMES")) 404 }) 405 406 It("podman ps mutually exclusive flags", func() { 407 session := podmanTest.Podman([]string{"ps", "-aqs"}) 408 session.WaitWithDefaultTimeout() 409 Expect(session).To(ExitWithError(125, "quiet conflicts with size and namespace")) 410 411 session = podmanTest.Podman([]string{"ps", "-a", "--ns", "-s"}) 412 session.WaitWithDefaultTimeout() 413 Expect(session).To(ExitWithError(125, "size and namespace options conflict")) 414 }) 415 416 It("podman --format by size", func() { 417 session := podmanTest.Podman([]string{"create", BB, "ls"}) 418 session.WaitWithDefaultTimeout() 419 Expect(session).Should(ExitCleanly()) 420 421 session = podmanTest.Podman([]string{"create", ALPINE, "top"}) 422 session.WaitWithDefaultTimeout() 423 Expect(session).Should(ExitCleanly()) 424 425 session = podmanTest.Podman([]string{"ps", "-a", "--format", "{{.Size}}"}) 426 session.WaitWithDefaultTimeout() 427 Expect(session).Should(Exit(0)) 428 Expect(session.ErrorToString()).To(ContainSubstring("Size format requires --size option")) 429 }) 430 431 It("podman --sort by size", func() { 432 session := podmanTest.Podman([]string{"create", BB, "ls"}) 433 session.WaitWithDefaultTimeout() 434 Expect(session).Should(ExitCleanly()) 435 436 session = podmanTest.Podman([]string{"create", ALPINE, "top"}) 437 session.WaitWithDefaultTimeout() 438 Expect(session).Should(ExitCleanly()) 439 440 session = podmanTest.Podman([]string{"ps", "-a", "-s", "--sort=size", "--format", "{{.Size}}"}) 441 session.WaitWithDefaultTimeout() 442 Expect(session).Should(ExitCleanly()) 443 444 sortedArr := session.OutputToStringArray() 445 446 // TODO: This may be broken - the test was running without the 447 // ability to perform any sorting for months and succeeded 448 // without error. 449 Expect(sort.SliceIsSorted(sortedArr, func(i, j int) bool { 450 r := regexp.MustCompile(`^\S+\s+\(virtual (\S+)\)`) 451 matches1 := r.FindStringSubmatch(sortedArr[i]) 452 matches2 := r.FindStringSubmatch(sortedArr[j]) 453 454 // sanity check in case an oddly formatted size appears 455 if len(matches1) < 2 || len(matches2) < 2 { 456 return sortedArr[i] < sortedArr[j] 457 } 458 size1, _ := units.FromHumanSize(matches1[1]) 459 size2, _ := units.FromHumanSize(matches2[1]) 460 return size1 < size2 461 })).To(BeTrue(), "slice is sorted") 462 463 }) 464 465 It("podman --sort by command", func() { 466 session := podmanTest.RunTopContainer("") 467 session.WaitWithDefaultTimeout() 468 Expect(session).Should(ExitCleanly()) 469 470 session = podmanTest.Podman([]string{"run", "-d", ALPINE, "pwd"}) 471 session.WaitWithDefaultTimeout() 472 Expect(session).Should(ExitCleanly()) 473 474 session = podmanTest.Podman([]string{"ps", "-a", "--sort=command", "--format", "{{.Command}}"}) 475 session.WaitWithDefaultTimeout() 476 Expect(session).Should(ExitCleanly()) 477 478 Expect(session.OutputToString()).ToNot(ContainSubstring("COMMAND")) 479 480 sortedArr := session.OutputToStringArray() 481 Expect(sort.SliceIsSorted(sortedArr, func(i, j int) bool { return sortedArr[i] < sortedArr[j] })).To(BeTrue(), "slice is sorted") 482 }) 483 484 It("podman --pod", func() { 485 _, ec, podid := podmanTest.CreatePod(nil) 486 Expect(ec).To(Equal(0)) 487 488 session := podmanTest.RunTopContainerInPod("", podid) 489 session.WaitWithDefaultTimeout() 490 Expect(session).Should(ExitCleanly()) 491 492 session = podmanTest.Podman([]string{"ps", "--no-trunc"}) 493 session.WaitWithDefaultTimeout() 494 Expect(session).Should(ExitCleanly()) 495 Expect(session.OutputToString()).ToNot(ContainSubstring(podid)) 496 497 session = podmanTest.Podman([]string{"ps", "--pod", "--no-trunc"}) 498 session.WaitWithDefaultTimeout() 499 Expect(session).Should(ExitCleanly()) 500 Expect(session.OutputToString()).To(ContainSubstring(podid)) 501 }) 502 503 It("podman --pod with a non-empty pod name", func() { 504 podName := "testPodName" 505 _, ec, podid := podmanTest.CreatePod(map[string][]string{"--name": {podName}}) 506 Expect(ec).To(Equal(0)) 507 508 session := podmanTest.RunTopContainerInPod("", podName) 509 session.WaitWithDefaultTimeout() 510 Expect(session).Should(ExitCleanly()) 511 512 // "--no-trunc" must be given. If not it will trunc the pod ID 513 // in the output and you will have to trunc it in the test too. 514 session = podmanTest.Podman([]string{"ps", "--pod", "--no-trunc"}) 515 516 session.WaitWithDefaultTimeout() 517 Expect(session).Should(ExitCleanly()) 518 519 output := session.OutputToString() 520 Expect(output).To(ContainSubstring(podid)) 521 Expect(output).To(ContainSubstring(podName)) 522 }) 523 524 It("podman ps test with single port range", func() { 525 session := podmanTest.Podman([]string{"run", "-dt", "-p", "2000-2006:2000-2006", ALPINE, "top"}) 526 session.WaitWithDefaultTimeout() 527 Expect(session).Should(ExitCleanly()) 528 529 session = podmanTest.Podman([]string{"ps", "--format", "{{.Ports}}"}) 530 session.WaitWithDefaultTimeout() 531 Expect(session).To(ExitCleanly()) 532 533 actual := session.OutputToString() 534 Expect(actual).To(ContainSubstring("0.0.0.0:2000-2006")) 535 Expect(actual).ToNot(ContainSubstring("PORT")) 536 }) 537 538 It("podman ps test with invalid port range", func() { 539 session := podmanTest.Podman([]string{ 540 "run", "-p", "1000-2000:2000-3000", "-p", "1999-2999:3001-4001", ALPINE, 541 }) 542 session.WaitWithDefaultTimeout() 543 Expect(session).Should(ExitWithError(125, "conflicting port mappings for host port 1999 (protocol tcp)")) 544 }) 545 546 It("podman ps test with multiple port range", func() { 547 session := podmanTest.Podman([]string{ 548 "run", "-dt", 549 "-p", "3000-3001:3000-3001", 550 "-p", "3100-3102:4000-4002", 551 "-p", "30080:30080", 552 "-p", "30443:30443", 553 "-p", "8000:8080", 554 ALPINE, "top"}, 555 ) 556 session.WaitWithDefaultTimeout() 557 Expect(session).Should(ExitCleanly()) 558 559 session = podmanTest.Podman([]string{"ps", "--format", "{{.Ports}}"}) 560 session.WaitWithDefaultTimeout() 561 Expect(session.OutputToString()).To(ContainSubstring( 562 "0.0.0.0:3000-3001->3000-3001/tcp, 0.0.0.0:3100-3102->4000-4002/tcp, 0.0.0.0:8000->8080/tcp, 0.0.0.0:30080->30080/tcp, 0.0.0.0:30443->30443/tcp", 563 )) 564 }) 565 566 It("podman ps sync flag", func() { 567 session := podmanTest.RunTopContainer("") 568 session.WaitWithDefaultTimeout() 569 Expect(session).Should(ExitCleanly()) 570 fullCid := session.OutputToString() 571 572 result := podmanTest.Podman([]string{"ps", "-q", "--no-trunc", "--sync"}) 573 result.WaitWithDefaultTimeout() 574 Expect(result).Should(ExitCleanly()) 575 Expect(result.OutputToStringArray()[0]).To(Equal(fullCid)) 576 }) 577 578 It("podman ps filter name regexp", func() { 579 session := podmanTest.Podman([]string{"run", "-d", "--name", "test1", ALPINE, "top"}) 580 session.WaitWithDefaultTimeout() 581 Expect(session).Should(ExitCleanly()) 582 fullCid := session.OutputToString() 583 584 session2 := podmanTest.Podman([]string{"run", "-d", "--name", "test11", ALPINE, "top"}) 585 session2.WaitWithDefaultTimeout() 586 Expect(session2).Should(ExitCleanly()) 587 588 result := podmanTest.Podman([]string{"ps", "-aq", "--no-trunc", "--filter", "name=test1"}) 589 result.WaitWithDefaultTimeout() 590 Expect(result).Should(ExitCleanly()) 591 592 output := result.OutputToStringArray() 593 Expect(output).To(HaveLen(2)) 594 595 result = podmanTest.Podman([]string{"ps", "-aq", "--no-trunc", "--filter", "name=test1$"}) 596 result.WaitWithDefaultTimeout() 597 Expect(result).Should(ExitCleanly()) 598 599 output = result.OutputToStringArray() 600 Expect(output).To(HaveLen(1)) 601 Expect(output[0]).To(Equal(fullCid)) 602 }) 603 604 It("podman ps quiet template", func() { 605 ctrName := "testCtr" 606 session := podmanTest.Podman([]string{"run", "-d", "--name", ctrName, ALPINE, "top"}) 607 session.WaitWithDefaultTimeout() 608 Expect(session).Should(ExitCleanly()) 609 610 result := podmanTest.Podman([]string{"ps", "-q", "-a", "--format", "{{ .Names }}"}) 611 result.WaitWithDefaultTimeout() 612 Expect(result).Should(ExitCleanly()) 613 614 output := result.OutputToStringArray() 615 Expect(output).To(HaveLen(1)) 616 Expect(output[0]).To(Equal(ctrName)) 617 }) 618 619 It("podman ps test with port shared with pod", func() { 620 podName := "testPod" 621 pod := podmanTest.Podman([]string{"pod", "create", "-p", "8085:80", "--name", podName}) 622 pod.WaitWithDefaultTimeout() 623 Expect(pod).Should(ExitCleanly()) 624 625 ctrName := "testCtr" 626 session := podmanTest.Podman([]string{"run", "--name", ctrName, "-dt", "--pod", podName, ALPINE, "top"}) 627 session.WaitWithDefaultTimeout() 628 Expect(session).Should(ExitCleanly()) 629 630 ps := podmanTest.Podman([]string{"ps", "--filter", fmt.Sprintf("name=%s", ctrName), "--format", "{{.Ports}}"}) 631 ps.WaitWithDefaultTimeout() 632 Expect(ps).Should(ExitCleanly()) 633 Expect(ps.OutputToString()).To(ContainSubstring("0.0.0.0:8085->80/tcp")) 634 }) 635 636 It("podman ps truncate long create command", func() { 637 session := podmanTest.Podman([]string{"run", ALPINE, "echo", "very", "long", "create", "command"}) 638 session.WaitWithDefaultTimeout() 639 Expect(session).Should(ExitCleanly()) 640 641 session = podmanTest.Podman([]string{"ps", "-a"}) 642 session.WaitWithDefaultTimeout() 643 Expect(session.OutputToString()).To(ContainSubstring("echo very long cr...")) 644 }) 645 It("podman ps --format {{RunningFor}}", func() { 646 _, ec, _ := podmanTest.RunLsContainer("") 647 Expect(ec).To(Equal(0)) 648 649 result := podmanTest.Podman([]string{"ps", "-a", "--format", "{{.RunningFor}}"}) 650 result.WaitWithDefaultTimeout() 651 Expect(result).Should(ExitCleanly()) 652 653 actual := result.OutputToString() 654 Expect(actual).To(ContainSubstring("ago")) 655 Expect(actual).ToNot(ContainSubstring("RUNNING FOR")) 656 }) 657 658 It("podman ps filter test", func() { 659 session := podmanTest.Podman([]string{"run", "-d", "--name", "test1", "--label", "foo=1", 660 "--label", "bar=2", "--volume", "volume1:/test", ALPINE, "top"}) 661 session.WaitWithDefaultTimeout() 662 Expect(session).Should(ExitCleanly()) 663 cid1 := session.OutputToString() 664 665 session = podmanTest.Podman([]string{"run", "--name", "test2", "--label", "foo=1", 666 ALPINE, "ls", "/fail"}) 667 session.WaitWithDefaultTimeout() 668 Expect(session).Should(ExitWithError(1, "ls: /fail: No such file or directory")) 669 670 session = podmanTest.Podman([]string{"create", "--name", "test3", ALPINE, cid1}) 671 session.WaitWithDefaultTimeout() 672 Expect(session).Should(ExitCleanly()) 673 674 session = podmanTest.Podman([]string{"run", "--name", "test4", "--volume", "volume1:/test1", 675 "--volume", "/:/test2", ALPINE, "ls"}) 676 session.WaitWithDefaultTimeout() 677 Expect(session).Should(ExitCleanly()) 678 679 session = podmanTest.Podman([]string{"ps", "--all", "--filter", "name=test"}) 680 session.WaitWithDefaultTimeout() 681 Expect(session).Should(ExitCleanly()) 682 Expect(session.OutputToStringArray()).To(HaveLen(5)) 683 Expect(session.OutputToString()).To(ContainSubstring("test1")) 684 Expect(session.OutputToString()).To(ContainSubstring("test2")) 685 Expect(session.OutputToString()).To(ContainSubstring("test3")) 686 Expect(session.OutputToString()).To(ContainSubstring("test4")) 687 688 session = podmanTest.Podman([]string{"ps", "--all", "--filter", "name=test1", "--filter", "name=test2"}) 689 session.WaitWithDefaultTimeout() 690 Expect(session).Should(ExitCleanly()) 691 Expect(session.OutputToStringArray()).To(HaveLen(3)) 692 Expect(session.OutputToString()).To(ContainSubstring("test1")) 693 Expect(session.OutputToString()).To(ContainSubstring("test2")) 694 695 // check container id matches with regex 696 session = podmanTest.Podman([]string{"ps", "--all", "--filter", "id=" + cid1[:40], "--filter", "id=" + cid1 + "$"}) 697 session.WaitWithDefaultTimeout() 698 Expect(session).Should(ExitCleanly()) 699 Expect(session.OutputToStringArray()).To(HaveLen(2)) 700 Expect(session.OutputToString()).To(ContainSubstring("test1")) 701 702 session = podmanTest.Podman([]string{"ps", "--filter", "status=created"}) 703 session.WaitWithDefaultTimeout() 704 Expect(session).Should(ExitCleanly()) 705 Expect(session.OutputToStringArray()).To(HaveLen(2)) 706 Expect(session.OutputToString()).To(ContainSubstring("test3")) 707 708 session = podmanTest.Podman([]string{"ps", "--filter", "status=created", "--filter", "status=exited"}) 709 session.WaitWithDefaultTimeout() 710 Expect(session).Should(ExitCleanly()) 711 Expect(session.OutputToStringArray()).To(HaveLen(4)) 712 Expect(session.OutputToString()).To(ContainSubstring("test2")) 713 Expect(session.OutputToString()).To(ContainSubstring("test3")) 714 Expect(session.OutputToString()).To(ContainSubstring("test4")) 715 716 session = podmanTest.Podman([]string{"ps", "--all", "--filter", "label=foo=1"}) 717 session.WaitWithDefaultTimeout() 718 Expect(session).Should(ExitCleanly()) 719 Expect(session.OutputToStringArray()).To(HaveLen(3)) 720 Expect(session.OutputToString()).To(ContainSubstring("test1")) 721 Expect(session.OutputToString()).To(ContainSubstring("test2")) 722 723 session = podmanTest.Podman([]string{"ps", "--filter", "label=foo=1", "--filter", "status=exited"}) 724 session.WaitWithDefaultTimeout() 725 Expect(session).Should(ExitCleanly()) 726 Expect(session.OutputToStringArray()).To(HaveLen(2)) 727 Expect(session.OutputToString()).To(ContainSubstring("test2")) 728 729 session = podmanTest.Podman([]string{"ps", "--all", "--filter", "label=foo=1", "--filter", "label=non=1"}) 730 session.WaitWithDefaultTimeout() 731 Expect(session).Should(ExitCleanly()) 732 Expect(session.OutputToStringArray()).To(HaveLen(1)) 733 734 session = podmanTest.Podman([]string{"ps", "--all", "--filter", "label=foo=1", "--filter", "label=bar=2"}) 735 session.WaitWithDefaultTimeout() 736 Expect(session).Should(ExitCleanly()) 737 Expect(session.OutputToStringArray()).To(HaveLen(2)) 738 Expect(session.OutputToString()).To(ContainSubstring("test1")) 739 740 session = podmanTest.Podman([]string{"ps", "--all", "--filter", "exited=1"}) 741 session.WaitWithDefaultTimeout() 742 Expect(session).Should(ExitCleanly()) 743 Expect(session.OutputToStringArray()).To(HaveLen(2)) 744 Expect(session.OutputToString()).To(ContainSubstring("test2")) 745 746 session = podmanTest.Podman([]string{"ps", "--all", "--filter", "exited=1", "--filter", "exited=0"}) 747 session.WaitWithDefaultTimeout() 748 Expect(session).Should(ExitCleanly()) 749 Expect(session.OutputToStringArray()).To(HaveLen(3)) 750 Expect(session.OutputToString()).To(ContainSubstring("test2")) 751 Expect(session.OutputToString()).To(ContainSubstring("test4")) 752 753 session = podmanTest.Podman([]string{"ps", "--all", "--filter", "volume=volume1"}) 754 session.WaitWithDefaultTimeout() 755 Expect(session).Should(ExitCleanly()) 756 Expect(session.OutputToStringArray()).To(HaveLen(3)) 757 Expect(session.OutputToString()).To(ContainSubstring("test1")) 758 Expect(session.OutputToString()).To(ContainSubstring("test4")) 759 760 session = podmanTest.Podman([]string{"ps", "--all", "--filter", "volume=/:/test2"}) 761 session.WaitWithDefaultTimeout() 762 Expect(session).Should(ExitCleanly()) 763 Expect(session.OutputToStringArray()).To(HaveLen(2)) 764 Expect(session.OutputToString()).To(ContainSubstring("test4")) 765 766 session = podmanTest.Podman([]string{"ps", "--all", "--filter", "before=test2"}) 767 session.WaitWithDefaultTimeout() 768 Expect(session).Should(ExitCleanly()) 769 Expect(session.OutputToStringArray()).To(HaveLen(2)) 770 Expect(session.OutputToString()).To(ContainSubstring("test1")) 771 772 session = podmanTest.Podman([]string{"ps", "--all", "--filter", "since=test2"}) 773 session.WaitWithDefaultTimeout() 774 Expect(session).Should(ExitCleanly()) 775 Expect(session.OutputToStringArray()).To(HaveLen(3)) 776 Expect(session.OutputToString()).To(ContainSubstring("test3")) 777 Expect(session.OutputToString()).To(ContainSubstring("test4")) 778 }) 779 It("podman ps filter pod", func() { 780 pod1 := podmanTest.Podman([]string{"pod", "create", "--name", "pod1"}) 781 pod1.WaitWithDefaultTimeout() 782 Expect(pod1).Should(ExitCleanly()) 783 con1 := podmanTest.Podman([]string{"run", "-dt", "--pod", "pod1", ALPINE, "top"}) 784 con1.WaitWithDefaultTimeout() 785 Expect(con1).Should(ExitCleanly()) 786 787 pod2 := podmanTest.Podman([]string{"pod", "create", "--name", "pod2"}) 788 pod2.WaitWithDefaultTimeout() 789 Expect(pod2).Should(ExitCleanly()) 790 con2 := podmanTest.Podman([]string{"run", "-dt", "--pod", "pod2", ALPINE, "top"}) 791 con2.WaitWithDefaultTimeout() 792 Expect(con2).Should(ExitCleanly()) 793 794 // bogus pod name or id should not result in error 795 session := podmanTest.Podman([]string{"ps", "--filter", "pod=1234"}) 796 session.WaitWithDefaultTimeout() 797 Expect(session).Should(ExitCleanly()) 798 799 // filter by pod name 800 session = podmanTest.Podman([]string{"ps", "-q", "--no-trunc", "--filter", "pod=pod1"}) 801 session.WaitWithDefaultTimeout() 802 Expect(session).Should(ExitCleanly()) 803 Expect(session.OutputToStringArray()).To(HaveLen(2)) 804 Expect(session.OutputToStringArray()).To(ContainElement(con1.OutputToString())) 805 806 // filter by full pod id 807 session = podmanTest.Podman([]string{"ps", "-q", "--no-trunc", "--filter", "pod=" + pod1.OutputToString()}) 808 session.WaitWithDefaultTimeout() 809 Expect(session).Should(ExitCleanly()) 810 Expect(session.OutputToStringArray()).To(HaveLen(2)) 811 Expect(session.OutputToStringArray()).To(ContainElement(con1.OutputToString())) 812 813 // filter by partial pod id 814 session = podmanTest.Podman([]string{"ps", "-q", "--no-trunc", "--filter", "pod=" + pod1.OutputToString()[0:12]}) 815 session.WaitWithDefaultTimeout() 816 Expect(session).Should(ExitCleanly()) 817 Expect(session.OutputToStringArray()).To(HaveLen(2)) 818 Expect(session.OutputToStringArray()).To(ContainElement(con1.OutputToString())) 819 820 // filter by multiple pods is inclusive 821 session = podmanTest.Podman([]string{"ps", "-q", "--no-trunc", "--filter", "pod=pod1", "--filter", "pod=pod2"}) 822 session.WaitWithDefaultTimeout() 823 Expect(session).Should(ExitCleanly()) 824 Expect(session.OutputToStringArray()).To(HaveLen(4)) 825 Expect(session.OutputToStringArray()).To(ContainElement(con1.OutputToString())) 826 Expect(session.OutputToStringArray()).To(ContainElement(con2.OutputToString())) 827 828 }) 829 830 It("podman ps filter network", func() { 831 net := stringid.GenerateRandomID() 832 session := podmanTest.Podman([]string{"network", "create", net}) 833 session.WaitWithDefaultTimeout() 834 Expect(session).Should(ExitCleanly()) 835 defer podmanTest.removeNetwork(net) 836 837 session = podmanTest.Podman([]string{"create", "--network", net, ALPINE}) 838 session.WaitWithDefaultTimeout() 839 Expect(session).Should(ExitCleanly()) 840 ctrWithNet := session.OutputToString() 841 842 session = podmanTest.Podman([]string{"create", ALPINE}) 843 session.WaitWithDefaultTimeout() 844 Expect(session).Should(ExitCleanly()) 845 ctrWithoutNet := session.OutputToString() 846 847 session = podmanTest.Podman([]string{"ps", "--all", "--no-trunc", "--filter", "network=" + net}) 848 session.WaitWithDefaultTimeout() 849 Expect(session).Should(ExitCleanly()) 850 actual := session.OutputToString() 851 Expect(actual).To(ContainSubstring(ctrWithNet)) 852 Expect(actual).ToNot(ContainSubstring(ctrWithoutNet)) 853 }) 854 855 It("podman ps --format networks", func() { 856 session := podmanTest.Podman([]string{"create", ALPINE}) 857 session.WaitWithDefaultTimeout() 858 Expect(session).Should(ExitCleanly()) 859 860 session = podmanTest.Podman([]string{"ps", "--all", "--format", "{{ .Networks }}"}) 861 session.WaitWithDefaultTimeout() 862 Expect(session).Should(ExitCleanly()) 863 864 actual := session.OutputToString() 865 Expect(actual).ToNot(ContainSubstring("NETWORKS")) 866 if isRootless() { 867 // rootless container don't have a network by default 868 Expect(actual).To(BeEmpty()) 869 } else { 870 // default network name is podman 871 Expect(actual).To(Equal("podman")) 872 } 873 874 net1 := stringid.GenerateRandomID() 875 session = podmanTest.Podman([]string{"network", "create", net1}) 876 session.WaitWithDefaultTimeout() 877 Expect(session).Should(ExitCleanly()) 878 defer podmanTest.removeNetwork(net1) 879 net2 := stringid.GenerateRandomID() 880 session = podmanTest.Podman([]string{"network", "create", net2}) 881 session.WaitWithDefaultTimeout() 882 Expect(session).Should(ExitCleanly()) 883 defer podmanTest.removeNetwork(net2) 884 885 session = podmanTest.Podman([]string{"create", "--network", net1 + "," + net2, ALPINE}) 886 session.WaitWithDefaultTimeout() 887 Expect(session).Should(ExitCleanly()) 888 cid := session.OutputToString() 889 890 session = podmanTest.Podman([]string{"ps", "--all", "--format", "{{ .Networks }}", "--filter", "id=" + cid}) 891 session.WaitWithDefaultTimeout() 892 Expect(session).Should(ExitCleanly()) 893 // the output is not deterministic so check both possible orders 894 Expect(session.OutputToString()).To(Or(Equal(net1+","+net2), Equal(net2+","+net1))) 895 }) 896 897 })