github.com/containers/podman/v4@v4.9.4/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/v4/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()) 410 411 session = podmanTest.Podman([]string{"ps", "-a", "--ns", "-s"}) 412 session.WaitWithDefaultTimeout() 413 Expect(session).To(ExitWithError()) 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(Exit(125)) 544 Expect(session.ErrorToString()).To(ContainSubstring("conflicting port mappings for host port 1999")) 545 }) 546 547 It("podman ps test with multiple port range", func() { 548 session := podmanTest.Podman([]string{ 549 "run", "-dt", 550 "-p", "3000-3001:3000-3001", 551 "-p", "3100-3102:4000-4002", 552 "-p", "30080:30080", 553 "-p", "30443:30443", 554 "-p", "8000:8080", 555 ALPINE, "top"}, 556 ) 557 session.WaitWithDefaultTimeout() 558 Expect(session).Should(ExitCleanly()) 559 560 session = podmanTest.Podman([]string{"ps", "--format", "{{.Ports}}"}) 561 session.WaitWithDefaultTimeout() 562 Expect(session.OutputToString()).To(ContainSubstring( 563 "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", 564 )) 565 }) 566 567 It("podman ps sync flag", func() { 568 session := podmanTest.RunTopContainer("") 569 session.WaitWithDefaultTimeout() 570 Expect(session).Should(ExitCleanly()) 571 fullCid := session.OutputToString() 572 573 result := podmanTest.Podman([]string{"ps", "-q", "--no-trunc", "--sync"}) 574 result.WaitWithDefaultTimeout() 575 Expect(result).Should(ExitCleanly()) 576 Expect(result.OutputToStringArray()[0]).To(Equal(fullCid)) 577 }) 578 579 It("podman ps filter name regexp", func() { 580 session := podmanTest.Podman([]string{"run", "-d", "--name", "test1", ALPINE, "top"}) 581 session.WaitWithDefaultTimeout() 582 Expect(session).Should(ExitCleanly()) 583 fullCid := session.OutputToString() 584 585 session2 := podmanTest.Podman([]string{"run", "-d", "--name", "test11", ALPINE, "top"}) 586 session2.WaitWithDefaultTimeout() 587 Expect(session2).Should(ExitCleanly()) 588 589 result := podmanTest.Podman([]string{"ps", "-aq", "--no-trunc", "--filter", "name=test1"}) 590 result.WaitWithDefaultTimeout() 591 Expect(result).Should(ExitCleanly()) 592 593 output := result.OutputToStringArray() 594 Expect(output).To(HaveLen(2)) 595 596 result = podmanTest.Podman([]string{"ps", "-aq", "--no-trunc", "--filter", "name=test1$"}) 597 result.WaitWithDefaultTimeout() 598 Expect(result).Should(ExitCleanly()) 599 600 output = result.OutputToStringArray() 601 Expect(output).To(HaveLen(1)) 602 Expect(output[0]).To(Equal(fullCid)) 603 }) 604 605 It("podman ps quiet template", func() { 606 ctrName := "testCtr" 607 session := podmanTest.Podman([]string{"run", "-d", "--name", ctrName, ALPINE, "top"}) 608 session.WaitWithDefaultTimeout() 609 Expect(session).Should(ExitCleanly()) 610 611 result := podmanTest.Podman([]string{"ps", "-q", "-a", "--format", "{{ .Names }}"}) 612 result.WaitWithDefaultTimeout() 613 Expect(result).Should(ExitCleanly()) 614 615 output := result.OutputToStringArray() 616 Expect(output).To(HaveLen(1)) 617 Expect(output[0]).To(Equal(ctrName)) 618 }) 619 620 It("podman ps test with port shared with pod", func() { 621 podName := "testPod" 622 pod := podmanTest.Podman([]string{"pod", "create", "-p", "8085:80", "--name", podName}) 623 pod.WaitWithDefaultTimeout() 624 Expect(pod).Should(ExitCleanly()) 625 626 ctrName := "testCtr" 627 session := podmanTest.Podman([]string{"run", "--name", ctrName, "-dt", "--pod", podName, ALPINE, "top"}) 628 session.WaitWithDefaultTimeout() 629 Expect(session).Should(ExitCleanly()) 630 631 ps := podmanTest.Podman([]string{"ps", "--filter", fmt.Sprintf("name=%s", ctrName), "--format", "{{.Ports}}"}) 632 ps.WaitWithDefaultTimeout() 633 Expect(ps).Should(ExitCleanly()) 634 Expect(ps.OutputToString()).To(ContainSubstring("0.0.0.0:8085->80/tcp")) 635 }) 636 637 It("podman ps truncate long create command", func() { 638 session := podmanTest.Podman([]string{"run", ALPINE, "echo", "very", "long", "create", "command"}) 639 session.WaitWithDefaultTimeout() 640 Expect(session).Should(ExitCleanly()) 641 642 session = podmanTest.Podman([]string{"ps", "-a"}) 643 session.WaitWithDefaultTimeout() 644 Expect(session.OutputToString()).To(ContainSubstring("echo very long cr...")) 645 }) 646 It("podman ps --format {{RunningFor}}", func() { 647 _, ec, _ := podmanTest.RunLsContainer("") 648 Expect(ec).To(Equal(0)) 649 650 result := podmanTest.Podman([]string{"ps", "-a", "--format", "{{.RunningFor}}"}) 651 result.WaitWithDefaultTimeout() 652 Expect(result).Should(ExitCleanly()) 653 654 actual := result.OutputToString() 655 Expect(actual).To(ContainSubstring("ago")) 656 Expect(actual).ToNot(ContainSubstring("RUNNING FOR")) 657 }) 658 659 It("podman ps filter test", func() { 660 session := podmanTest.Podman([]string{"run", "-d", "--name", "test1", "--label", "foo=1", 661 "--label", "bar=2", "--volume", "volume1:/test", ALPINE, "top"}) 662 session.WaitWithDefaultTimeout() 663 Expect(session).Should(ExitCleanly()) 664 cid1 := session.OutputToString() 665 666 session = podmanTest.Podman([]string{"run", "--name", "test2", "--label", "foo=1", 667 ALPINE, "ls", "/fail"}) 668 session.WaitWithDefaultTimeout() 669 Expect(session).Should(Exit(1)) 670 671 session = podmanTest.Podman([]string{"create", "--name", "test3", ALPINE, cid1}) 672 session.WaitWithDefaultTimeout() 673 Expect(session).Should(ExitCleanly()) 674 675 session = podmanTest.Podman([]string{"run", "--name", "test4", "--volume", "volume1:/test1", 676 "--volume", "/:/test2", ALPINE, "ls"}) 677 session.WaitWithDefaultTimeout() 678 Expect(session).Should(ExitCleanly()) 679 680 session = podmanTest.Podman([]string{"ps", "--all", "--filter", "name=test"}) 681 session.WaitWithDefaultTimeout() 682 Expect(session).Should(ExitCleanly()) 683 Expect(session.OutputToStringArray()).To(HaveLen(5)) 684 Expect(session.OutputToString()).To(ContainSubstring("test1")) 685 Expect(session.OutputToString()).To(ContainSubstring("test2")) 686 Expect(session.OutputToString()).To(ContainSubstring("test3")) 687 Expect(session.OutputToString()).To(ContainSubstring("test4")) 688 689 session = podmanTest.Podman([]string{"ps", "--all", "--filter", "name=test1", "--filter", "name=test2"}) 690 session.WaitWithDefaultTimeout() 691 Expect(session).Should(ExitCleanly()) 692 Expect(session.OutputToStringArray()).To(HaveLen(3)) 693 Expect(session.OutputToString()).To(ContainSubstring("test1")) 694 Expect(session.OutputToString()).To(ContainSubstring("test2")) 695 696 // check container id matches with regex 697 session = podmanTest.Podman([]string{"ps", "--all", "--filter", "id=" + cid1[:40], "--filter", "id=" + cid1 + "$"}) 698 session.WaitWithDefaultTimeout() 699 Expect(session).Should(ExitCleanly()) 700 Expect(session.OutputToStringArray()).To(HaveLen(2)) 701 Expect(session.OutputToString()).To(ContainSubstring("test1")) 702 703 session = podmanTest.Podman([]string{"ps", "--filter", "status=created"}) 704 session.WaitWithDefaultTimeout() 705 Expect(session).Should(ExitCleanly()) 706 Expect(session.OutputToStringArray()).To(HaveLen(2)) 707 Expect(session.OutputToString()).To(ContainSubstring("test3")) 708 709 session = podmanTest.Podman([]string{"ps", "--filter", "status=created", "--filter", "status=exited"}) 710 session.WaitWithDefaultTimeout() 711 Expect(session).Should(ExitCleanly()) 712 Expect(session.OutputToStringArray()).To(HaveLen(4)) 713 Expect(session.OutputToString()).To(ContainSubstring("test2")) 714 Expect(session.OutputToString()).To(ContainSubstring("test3")) 715 Expect(session.OutputToString()).To(ContainSubstring("test4")) 716 717 session = podmanTest.Podman([]string{"ps", "--all", "--filter", "label=foo=1"}) 718 session.WaitWithDefaultTimeout() 719 Expect(session).Should(ExitCleanly()) 720 Expect(session.OutputToStringArray()).To(HaveLen(3)) 721 Expect(session.OutputToString()).To(ContainSubstring("test1")) 722 Expect(session.OutputToString()).To(ContainSubstring("test2")) 723 724 session = podmanTest.Podman([]string{"ps", "--filter", "label=foo=1", "--filter", "status=exited"}) 725 session.WaitWithDefaultTimeout() 726 Expect(session).Should(ExitCleanly()) 727 Expect(session.OutputToStringArray()).To(HaveLen(2)) 728 Expect(session.OutputToString()).To(ContainSubstring("test2")) 729 730 session = podmanTest.Podman([]string{"ps", "--all", "--filter", "label=foo=1", "--filter", "label=non=1"}) 731 session.WaitWithDefaultTimeout() 732 Expect(session).Should(ExitCleanly()) 733 Expect(session.OutputToStringArray()).To(HaveLen(1)) 734 735 session = podmanTest.Podman([]string{"ps", "--all", "--filter", "label=foo=1", "--filter", "label=bar=2"}) 736 session.WaitWithDefaultTimeout() 737 Expect(session).Should(ExitCleanly()) 738 Expect(session.OutputToStringArray()).To(HaveLen(2)) 739 Expect(session.OutputToString()).To(ContainSubstring("test1")) 740 741 session = podmanTest.Podman([]string{"ps", "--all", "--filter", "exited=1"}) 742 session.WaitWithDefaultTimeout() 743 Expect(session).Should(ExitCleanly()) 744 Expect(session.OutputToStringArray()).To(HaveLen(2)) 745 Expect(session.OutputToString()).To(ContainSubstring("test2")) 746 747 session = podmanTest.Podman([]string{"ps", "--all", "--filter", "exited=1", "--filter", "exited=0"}) 748 session.WaitWithDefaultTimeout() 749 Expect(session).Should(ExitCleanly()) 750 Expect(session.OutputToStringArray()).To(HaveLen(3)) 751 Expect(session.OutputToString()).To(ContainSubstring("test2")) 752 Expect(session.OutputToString()).To(ContainSubstring("test4")) 753 754 session = podmanTest.Podman([]string{"ps", "--all", "--filter", "volume=volume1"}) 755 session.WaitWithDefaultTimeout() 756 Expect(session).Should(ExitCleanly()) 757 Expect(session.OutputToStringArray()).To(HaveLen(3)) 758 Expect(session.OutputToString()).To(ContainSubstring("test1")) 759 Expect(session.OutputToString()).To(ContainSubstring("test4")) 760 761 session = podmanTest.Podman([]string{"ps", "--all", "--filter", "volume=/:/test2"}) 762 session.WaitWithDefaultTimeout() 763 Expect(session).Should(ExitCleanly()) 764 Expect(session.OutputToStringArray()).To(HaveLen(2)) 765 Expect(session.OutputToString()).To(ContainSubstring("test4")) 766 767 session = podmanTest.Podman([]string{"ps", "--all", "--filter", "before=test2"}) 768 session.WaitWithDefaultTimeout() 769 Expect(session).Should(ExitCleanly()) 770 Expect(session.OutputToStringArray()).To(HaveLen(2)) 771 Expect(session.OutputToString()).To(ContainSubstring("test1")) 772 773 session = podmanTest.Podman([]string{"ps", "--all", "--filter", "since=test2"}) 774 session.WaitWithDefaultTimeout() 775 Expect(session).Should(ExitCleanly()) 776 Expect(session.OutputToStringArray()).To(HaveLen(3)) 777 Expect(session.OutputToString()).To(ContainSubstring("test3")) 778 Expect(session.OutputToString()).To(ContainSubstring("test4")) 779 }) 780 It("podman ps filter pod", func() { 781 pod1 := podmanTest.Podman([]string{"pod", "create", "--name", "pod1"}) 782 pod1.WaitWithDefaultTimeout() 783 Expect(pod1).Should(ExitCleanly()) 784 con1 := podmanTest.Podman([]string{"run", "-dt", "--pod", "pod1", ALPINE, "top"}) 785 con1.WaitWithDefaultTimeout() 786 Expect(con1).Should(ExitCleanly()) 787 788 pod2 := podmanTest.Podman([]string{"pod", "create", "--name", "pod2"}) 789 pod2.WaitWithDefaultTimeout() 790 Expect(pod2).Should(ExitCleanly()) 791 con2 := podmanTest.Podman([]string{"run", "-dt", "--pod", "pod2", ALPINE, "top"}) 792 con2.WaitWithDefaultTimeout() 793 Expect(con2).Should(ExitCleanly()) 794 795 // bogus pod name or id should not result in error 796 session := podmanTest.Podman([]string{"ps", "--filter", "pod=1234"}) 797 session.WaitWithDefaultTimeout() 798 Expect(session).Should(ExitCleanly()) 799 800 // filter by pod name 801 session = podmanTest.Podman([]string{"ps", "-q", "--no-trunc", "--filter", "pod=pod1"}) 802 session.WaitWithDefaultTimeout() 803 Expect(session).Should(ExitCleanly()) 804 Expect(session.OutputToStringArray()).To(HaveLen(2)) 805 Expect(session.OutputToStringArray()).To(ContainElement(con1.OutputToString())) 806 807 // filter by full pod id 808 session = podmanTest.Podman([]string{"ps", "-q", "--no-trunc", "--filter", "pod=" + pod1.OutputToString()}) 809 session.WaitWithDefaultTimeout() 810 Expect(session).Should(ExitCleanly()) 811 Expect(session.OutputToStringArray()).To(HaveLen(2)) 812 Expect(session.OutputToStringArray()).To(ContainElement(con1.OutputToString())) 813 814 // filter by partial pod id 815 session = podmanTest.Podman([]string{"ps", "-q", "--no-trunc", "--filter", "pod=" + pod1.OutputToString()[0:12]}) 816 session.WaitWithDefaultTimeout() 817 Expect(session).Should(ExitCleanly()) 818 Expect(session.OutputToStringArray()).To(HaveLen(2)) 819 Expect(session.OutputToStringArray()).To(ContainElement(con1.OutputToString())) 820 821 // filter by multiple pods is inclusive 822 session = podmanTest.Podman([]string{"ps", "-q", "--no-trunc", "--filter", "pod=pod1", "--filter", "pod=pod2"}) 823 session.WaitWithDefaultTimeout() 824 Expect(session).Should(ExitCleanly()) 825 Expect(session.OutputToStringArray()).To(HaveLen(4)) 826 Expect(session.OutputToStringArray()).To(ContainElement(con1.OutputToString())) 827 Expect(session.OutputToStringArray()).To(ContainElement(con2.OutputToString())) 828 829 }) 830 831 It("podman ps filter network", func() { 832 net := stringid.GenerateRandomID() 833 session := podmanTest.Podman([]string{"network", "create", net}) 834 session.WaitWithDefaultTimeout() 835 Expect(session).Should(ExitCleanly()) 836 defer podmanTest.removeNetwork(net) 837 838 session = podmanTest.Podman([]string{"create", "--network", net, ALPINE}) 839 session.WaitWithDefaultTimeout() 840 Expect(session).Should(ExitCleanly()) 841 ctrWithNet := session.OutputToString() 842 843 session = podmanTest.Podman([]string{"create", ALPINE}) 844 session.WaitWithDefaultTimeout() 845 Expect(session).Should(ExitCleanly()) 846 ctrWithoutNet := session.OutputToString() 847 848 session = podmanTest.Podman([]string{"ps", "--all", "--no-trunc", "--filter", "network=" + net}) 849 session.WaitWithDefaultTimeout() 850 Expect(session).Should(ExitCleanly()) 851 actual := session.OutputToString() 852 Expect(actual).To(ContainSubstring(ctrWithNet)) 853 Expect(actual).ToNot(ContainSubstring(ctrWithoutNet)) 854 }) 855 856 It("podman ps --format networks", func() { 857 session := podmanTest.Podman([]string{"create", ALPINE}) 858 session.WaitWithDefaultTimeout() 859 Expect(session).Should(ExitCleanly()) 860 861 session = podmanTest.Podman([]string{"ps", "--all", "--format", "{{ .Networks }}"}) 862 session.WaitWithDefaultTimeout() 863 Expect(session).Should(ExitCleanly()) 864 865 actual := session.OutputToString() 866 Expect(actual).ToNot(ContainSubstring("NETWORKS")) 867 if isRootless() { 868 // rootless container don't have a network by default 869 Expect(actual).To(BeEmpty()) 870 } else { 871 // default network name is podman 872 Expect(actual).To(Equal("podman")) 873 } 874 875 net1 := stringid.GenerateRandomID() 876 session = podmanTest.Podman([]string{"network", "create", net1}) 877 session.WaitWithDefaultTimeout() 878 Expect(session).Should(ExitCleanly()) 879 defer podmanTest.removeNetwork(net1) 880 net2 := stringid.GenerateRandomID() 881 session = podmanTest.Podman([]string{"network", "create", net2}) 882 session.WaitWithDefaultTimeout() 883 Expect(session).Should(ExitCleanly()) 884 defer podmanTest.removeNetwork(net2) 885 886 session = podmanTest.Podman([]string{"create", "--network", net1 + "," + net2, ALPINE}) 887 session.WaitWithDefaultTimeout() 888 Expect(session).Should(ExitCleanly()) 889 cid := session.OutputToString() 890 891 session = podmanTest.Podman([]string{"ps", "--all", "--format", "{{ .Networks }}", "--filter", "id=" + cid}) 892 session.WaitWithDefaultTimeout() 893 Expect(session).Should(ExitCleanly()) 894 // the output is not deterministic so check both possible orders 895 Expect(session.OutputToString()).To(Or(Equal(net1+","+net2), Equal(net2+","+net1))) 896 }) 897 898 })