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