mirror of
https://github.com/moby/moby.git
synced 2022-11-09 12:21:53 -05:00
0fabf3e41e
Replaced using a bit of grep-ing;
```
find . -name "*_test.go" -exec sed -E -i 's#assert.Assert\((.*), fmt.Sprintf\((.*)\)\)$#assert.Assert\(\1, \2\)#g' '{}' \;
```
Signed-off-by: Sebastiaan van Stijn <github@gone.nl>
859 lines
35 KiB
Go
859 lines
35 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/docker/docker/api/types/versions"
|
|
"github.com/docker/docker/integration-cli/cli"
|
|
"github.com/docker/docker/integration-cli/cli/build"
|
|
"github.com/docker/docker/pkg/stringid"
|
|
"gotest.tools/assert"
|
|
is "gotest.tools/assert/cmp"
|
|
"gotest.tools/icmd"
|
|
)
|
|
|
|
func (s *DockerSuite) TestPsListContainersBase(c *testing.T) {
|
|
existingContainers := ExistingContainerIDs(c)
|
|
|
|
out := runSleepingContainer(c, "-d")
|
|
firstID := strings.TrimSpace(out)
|
|
|
|
out = runSleepingContainer(c, "-d")
|
|
secondID := strings.TrimSpace(out)
|
|
|
|
// not long running
|
|
out, _ = dockerCmd(c, "run", "-d", "busybox", "true")
|
|
thirdID := strings.TrimSpace(out)
|
|
|
|
out = runSleepingContainer(c, "-d")
|
|
fourthID := strings.TrimSpace(out)
|
|
|
|
// make sure the second is running
|
|
assert.Assert(c, waitRun(secondID) == nil)
|
|
|
|
// make sure third one is not running
|
|
dockerCmd(c, "wait", thirdID)
|
|
|
|
// make sure the forth is running
|
|
assert.Assert(c, waitRun(fourthID) == nil)
|
|
|
|
// all
|
|
out, _ = dockerCmd(c, "ps", "-a")
|
|
assert.Equal(c, assertContainerList(RemoveOutputForExistingElements(out, existingContainers), []string{fourthID, thirdID, secondID, firstID}), true, fmt.Sprintf("ALL: Container list is not in the correct order: \n%s", out))
|
|
|
|
// running
|
|
out, _ = dockerCmd(c, "ps")
|
|
assert.Equal(c, assertContainerList(RemoveOutputForExistingElements(out, existingContainers), []string{fourthID, secondID, firstID}), true, fmt.Sprintf("RUNNING: Container list is not in the correct order: \n%s", out))
|
|
|
|
// limit
|
|
out, _ = dockerCmd(c, "ps", "-n=2", "-a")
|
|
expected := []string{fourthID, thirdID}
|
|
assert.Equal(c, assertContainerList(RemoveOutputForExistingElements(out, existingContainers), expected), true, fmt.Sprintf("LIMIT & ALL: Container list is not in the correct order: \n%s", out))
|
|
|
|
out, _ = dockerCmd(c, "ps", "-n=2")
|
|
assert.Equal(c, assertContainerList(RemoveOutputForExistingElements(out, existingContainers), expected), true, fmt.Sprintf("LIMIT: Container list is not in the correct order: \n%s", out))
|
|
|
|
// filter since
|
|
out, _ = dockerCmd(c, "ps", "-f", "since="+firstID, "-a")
|
|
expected = []string{fourthID, thirdID, secondID}
|
|
assert.Equal(c, assertContainerList(RemoveOutputForExistingElements(out, existingContainers), expected), true, fmt.Sprintf("SINCE filter & ALL: Container list is not in the correct order: \n%s", out))
|
|
|
|
out, _ = dockerCmd(c, "ps", "-f", "since="+firstID)
|
|
expected = []string{fourthID, secondID}
|
|
assert.Equal(c, assertContainerList(RemoveOutputForExistingElements(out, existingContainers), expected), true, fmt.Sprintf("SINCE filter: Container list is not in the correct order: \n%s", out))
|
|
|
|
out, _ = dockerCmd(c, "ps", "-f", "since="+thirdID)
|
|
expected = []string{fourthID}
|
|
assert.Equal(c, assertContainerList(RemoveOutputForExistingElements(out, existingContainers), expected), true, fmt.Sprintf("SINCE filter: Container list is not in the correct order: \n%s", out))
|
|
|
|
// filter before
|
|
out, _ = dockerCmd(c, "ps", "-f", "before="+fourthID, "-a")
|
|
expected = []string{thirdID, secondID, firstID}
|
|
assert.Equal(c, assertContainerList(RemoveOutputForExistingElements(out, existingContainers), expected), true, fmt.Sprintf("BEFORE filter & ALL: Container list is not in the correct order: \n%s", out))
|
|
|
|
out, _ = dockerCmd(c, "ps", "-f", "before="+fourthID)
|
|
expected = []string{secondID, firstID}
|
|
assert.Equal(c, assertContainerList(RemoveOutputForExistingElements(out, existingContainers), expected), true, fmt.Sprintf("BEFORE filter: Container list is not in the correct order: \n%s", out))
|
|
|
|
out, _ = dockerCmd(c, "ps", "-f", "before="+thirdID)
|
|
expected = []string{secondID, firstID}
|
|
assert.Equal(c, assertContainerList(RemoveOutputForExistingElements(out, existingContainers), expected), true, fmt.Sprintf("SINCE filter: Container list is not in the correct order: \n%s", out))
|
|
|
|
// filter since & before
|
|
out, _ = dockerCmd(c, "ps", "-f", "since="+firstID, "-f", "before="+fourthID, "-a")
|
|
expected = []string{thirdID, secondID}
|
|
assert.Equal(c, assertContainerList(RemoveOutputForExistingElements(out, existingContainers), expected), true, fmt.Sprintf("SINCE filter, BEFORE filter & ALL: Container list is not in the correct order: \n%s", out))
|
|
|
|
out, _ = dockerCmd(c, "ps", "-f", "since="+firstID, "-f", "before="+fourthID)
|
|
expected = []string{secondID}
|
|
assert.Equal(c, assertContainerList(RemoveOutputForExistingElements(out, existingContainers), expected), true, fmt.Sprintf("SINCE filter, BEFORE filter: Container list is not in the correct order: \n%s", out))
|
|
|
|
// filter since & limit
|
|
out, _ = dockerCmd(c, "ps", "-f", "since="+firstID, "-n=2", "-a")
|
|
expected = []string{fourthID, thirdID}
|
|
|
|
assert.Equal(c, assertContainerList(RemoveOutputForExistingElements(out, existingContainers), expected), true, fmt.Sprintf("SINCE filter, LIMIT & ALL: Container list is not in the correct order: \n%s", out))
|
|
|
|
out, _ = dockerCmd(c, "ps", "-f", "since="+firstID, "-n=2")
|
|
assert.Equal(c, assertContainerList(RemoveOutputForExistingElements(out, existingContainers), expected), true, fmt.Sprintf("SINCE filter, LIMIT: Container list is not in the correct order: \n%s", out))
|
|
|
|
// filter before & limit
|
|
out, _ = dockerCmd(c, "ps", "-f", "before="+fourthID, "-n=1", "-a")
|
|
expected = []string{thirdID}
|
|
assert.Equal(c, assertContainerList(RemoveOutputForExistingElements(out, existingContainers), expected), true, fmt.Sprintf("BEFORE filter, LIMIT & ALL: Container list is not in the correct order: \n%s", out))
|
|
|
|
out, _ = dockerCmd(c, "ps", "-f", "before="+fourthID, "-n=1")
|
|
assert.Equal(c, assertContainerList(RemoveOutputForExistingElements(out, existingContainers), expected), true, fmt.Sprintf("BEFORE filter, LIMIT: Container list is not in the correct order: \n%s", out))
|
|
|
|
// filter since & filter before & limit
|
|
out, _ = dockerCmd(c, "ps", "-f", "since="+firstID, "-f", "before="+fourthID, "-n=1", "-a")
|
|
expected = []string{thirdID}
|
|
assert.Equal(c, assertContainerList(RemoveOutputForExistingElements(out, existingContainers), expected), true, fmt.Sprintf("SINCE filter, BEFORE filter, LIMIT & ALL: Container list is not in the correct order: \n%s", out))
|
|
|
|
out, _ = dockerCmd(c, "ps", "-f", "since="+firstID, "-f", "before="+fourthID, "-n=1")
|
|
assert.Equal(c, assertContainerList(RemoveOutputForExistingElements(out, existingContainers), expected), true, fmt.Sprintf("SINCE filter, BEFORE filter, LIMIT: Container list is not in the correct order: \n%s", out))
|
|
|
|
}
|
|
|
|
func assertContainerList(out string, expected []string) bool {
|
|
lines := strings.Split(strings.Trim(out, "\n "), "\n")
|
|
|
|
if len(lines)-1 != len(expected) {
|
|
return false
|
|
}
|
|
|
|
containerIDIndex := strings.Index(lines[0], "CONTAINER ID")
|
|
for i := 0; i < len(expected); i++ {
|
|
foundID := lines[i+1][containerIDIndex : containerIDIndex+12]
|
|
if foundID != expected[i][:12] {
|
|
return false
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
func (s *DockerSuite) TestPsListContainersSize(c *testing.T) {
|
|
// Problematic on Windows as it doesn't report the size correctly @swernli
|
|
testRequires(c, DaemonIsLinux)
|
|
dockerCmd(c, "run", "-d", "busybox")
|
|
|
|
baseOut, _ := dockerCmd(c, "ps", "-s", "-n=1")
|
|
baseLines := strings.Split(strings.Trim(baseOut, "\n "), "\n")
|
|
baseSizeIndex := strings.Index(baseLines[0], "SIZE")
|
|
baseFoundsize := baseLines[1][baseSizeIndex:]
|
|
baseBytes, err := strconv.Atoi(strings.Split(baseFoundsize, "B")[0])
|
|
assert.NilError(c, err)
|
|
|
|
name := "test_size"
|
|
dockerCmd(c, "run", "--name", name, "busybox", "sh", "-c", "echo 1 > test")
|
|
id := getIDByName(c, name)
|
|
|
|
var result *icmd.Result
|
|
|
|
wait := make(chan struct{})
|
|
go func() {
|
|
result = icmd.RunCommand(dockerBinary, "ps", "-s", "-n=1")
|
|
close(wait)
|
|
}()
|
|
select {
|
|
case <-wait:
|
|
case <-time.After(3 * time.Second):
|
|
c.Fatalf("Calling \"docker ps -s\" timed out!")
|
|
}
|
|
result.Assert(c, icmd.Success)
|
|
lines := strings.Split(strings.Trim(result.Combined(), "\n "), "\n")
|
|
assert.Equal(c, len(lines), 2, "Expected 2 lines for 'ps -s -n=1' output, got %d", len(lines))
|
|
sizeIndex := strings.Index(lines[0], "SIZE")
|
|
idIndex := strings.Index(lines[0], "CONTAINER ID")
|
|
foundID := lines[1][idIndex : idIndex+12]
|
|
assert.Equal(c, foundID, id[:12], fmt.Sprintf("Expected id %s, got %s", id[:12], foundID))
|
|
expectedSize := fmt.Sprintf("%dB", 2+baseBytes)
|
|
foundSize := lines[1][sizeIndex:]
|
|
assert.Assert(c, strings.Contains(foundSize, expectedSize), "Expected size %q, got %q", expectedSize, foundSize)
|
|
}
|
|
|
|
func (s *DockerSuite) TestPsListContainersFilterStatus(c *testing.T) {
|
|
existingContainers := ExistingContainerIDs(c)
|
|
|
|
// start exited container
|
|
out := cli.DockerCmd(c, "run", "-d", "busybox").Combined()
|
|
firstID := strings.TrimSpace(out)
|
|
|
|
// make sure the exited container is not running
|
|
cli.DockerCmd(c, "wait", firstID)
|
|
|
|
// start running container
|
|
out = cli.DockerCmd(c, "run", "-itd", "busybox").Combined()
|
|
secondID := strings.TrimSpace(out)
|
|
|
|
// filter containers by exited
|
|
out = cli.DockerCmd(c, "ps", "--no-trunc", "-q", "--filter=status=exited").Combined()
|
|
containerOut := strings.TrimSpace(out)
|
|
assert.Equal(c, RemoveOutputForExistingElements(containerOut, existingContainers), firstID)
|
|
|
|
out = cli.DockerCmd(c, "ps", "-a", "--no-trunc", "-q", "--filter=status=running").Combined()
|
|
containerOut = strings.TrimSpace(out)
|
|
assert.Equal(c, RemoveOutputForExistingElements(containerOut, existingContainers), secondID)
|
|
|
|
result := cli.Docker(cli.Args("ps", "-a", "-q", "--filter=status=rubbish"), cli.WithTimeout(time.Second*60))
|
|
err := "Invalid filter 'status=rubbish'"
|
|
if versions.LessThan(testEnv.DaemonAPIVersion(), "1.32") {
|
|
err = "Unrecognised filter value for status: rubbish"
|
|
}
|
|
result.Assert(c, icmd.Expected{
|
|
ExitCode: 1,
|
|
Err: err,
|
|
})
|
|
// Windows doesn't support pausing of containers
|
|
if testEnv.OSType != "windows" {
|
|
// pause running container
|
|
out = cli.DockerCmd(c, "run", "-itd", "busybox").Combined()
|
|
pausedID := strings.TrimSpace(out)
|
|
cli.DockerCmd(c, "pause", pausedID)
|
|
// make sure the container is unpaused to let the daemon stop it properly
|
|
defer func() { cli.DockerCmd(c, "unpause", pausedID) }()
|
|
|
|
out = cli.DockerCmd(c, "ps", "--no-trunc", "-q", "--filter=status=paused").Combined()
|
|
containerOut = strings.TrimSpace(out)
|
|
assert.Equal(c, RemoveOutputForExistingElements(containerOut, existingContainers), pausedID)
|
|
}
|
|
}
|
|
|
|
func (s *DockerSuite) TestPsListContainersFilterHealth(c *testing.T) {
|
|
existingContainers := ExistingContainerIDs(c)
|
|
// Test legacy no health check
|
|
out := runSleepingContainer(c, "--name=none_legacy")
|
|
containerID := strings.TrimSpace(out)
|
|
|
|
cli.WaitRun(c, containerID)
|
|
|
|
out = cli.DockerCmd(c, "ps", "-q", "-l", "--no-trunc", "--filter=health=none").Combined()
|
|
containerOut := strings.TrimSpace(out)
|
|
assert.Equal(c, containerOut, containerID, fmt.Sprintf("Expected id %s, got %s for legacy none filter, output: %q", containerID, containerOut, out))
|
|
|
|
// Test no health check specified explicitly
|
|
out = runSleepingContainer(c, "--name=none", "--no-healthcheck")
|
|
containerID = strings.TrimSpace(out)
|
|
|
|
cli.WaitRun(c, containerID)
|
|
|
|
out = cli.DockerCmd(c, "ps", "-q", "-l", "--no-trunc", "--filter=health=none").Combined()
|
|
containerOut = strings.TrimSpace(out)
|
|
assert.Equal(c, containerOut, containerID, fmt.Sprintf("Expected id %s, got %s for none filter, output: %q", containerID, containerOut, out))
|
|
|
|
// Test failing health check
|
|
out = runSleepingContainer(c, "--name=failing_container", "--health-cmd=exit 1", "--health-interval=1s")
|
|
containerID = strings.TrimSpace(out)
|
|
|
|
waitForHealthStatus(c, "failing_container", "starting", "unhealthy")
|
|
|
|
out = cli.DockerCmd(c, "ps", "-q", "--no-trunc", "--filter=health=unhealthy").Combined()
|
|
containerOut = strings.TrimSpace(out)
|
|
assert.Equal(c, containerOut, containerID, fmt.Sprintf("Expected containerID %s, got %s for unhealthy filter, output: %q", containerID, containerOut, out))
|
|
|
|
// Check passing healthcheck
|
|
out = runSleepingContainer(c, "--name=passing_container", "--health-cmd=exit 0", "--health-interval=1s")
|
|
containerID = strings.TrimSpace(out)
|
|
|
|
waitForHealthStatus(c, "passing_container", "starting", "healthy")
|
|
|
|
out = cli.DockerCmd(c, "ps", "-q", "--no-trunc", "--filter=health=healthy").Combined()
|
|
containerOut = strings.TrimSpace(RemoveOutputForExistingElements(out, existingContainers))
|
|
assert.Equal(c, containerOut, containerID, fmt.Sprintf("Expected containerID %s, got %s for healthy filter, output: %q", containerID, containerOut, out))
|
|
}
|
|
|
|
func (s *DockerSuite) TestPsListContainersFilterID(c *testing.T) {
|
|
// start container
|
|
out, _ := dockerCmd(c, "run", "-d", "busybox")
|
|
firstID := strings.TrimSpace(out)
|
|
|
|
// start another container
|
|
runSleepingContainer(c)
|
|
|
|
// filter containers by id
|
|
out, _ = dockerCmd(c, "ps", "-a", "-q", "--filter=id="+firstID)
|
|
containerOut := strings.TrimSpace(out)
|
|
assert.Equal(c, containerOut, firstID[:12], fmt.Sprintf("Expected id %s, got %s for exited filter, output: %q", firstID[:12], containerOut, out))
|
|
}
|
|
|
|
func (s *DockerSuite) TestPsListContainersFilterName(c *testing.T) {
|
|
// start container
|
|
dockerCmd(c, "run", "--name=a_name_to_match", "busybox")
|
|
id := getIDByName(c, "a_name_to_match")
|
|
|
|
// start another container
|
|
runSleepingContainer(c, "--name=b_name_to_match")
|
|
|
|
// filter containers by name
|
|
out, _ := dockerCmd(c, "ps", "-a", "-q", "--filter=name=a_name_to_match")
|
|
containerOut := strings.TrimSpace(out)
|
|
assert.Equal(c, containerOut, id[:12], fmt.Sprintf("Expected id %s, got %s for exited filter, output: %q", id[:12], containerOut, out))
|
|
}
|
|
|
|
// Test for the ancestor filter for ps.
|
|
// There is also the same test but with image:tag@digest in docker_cli_by_digest_test.go
|
|
//
|
|
// What the test setups :
|
|
// - Create 2 image based on busybox using the same repository but different tags
|
|
// - Create an image based on the previous image (images_ps_filter_test2)
|
|
// - Run containers for each of those image (busybox, images_ps_filter_test1, images_ps_filter_test2)
|
|
// - Filter them out :P
|
|
func (s *DockerSuite) TestPsListContainersFilterAncestorImage(c *testing.T) {
|
|
existingContainers := ExistingContainerIDs(c)
|
|
|
|
// Build images
|
|
imageName1 := "images_ps_filter_test1"
|
|
buildImageSuccessfully(c, imageName1, build.WithDockerfile(`FROM busybox
|
|
LABEL match me 1`))
|
|
imageID1 := getIDByName(c, imageName1)
|
|
|
|
imageName1Tagged := "images_ps_filter_test1:tag"
|
|
buildImageSuccessfully(c, imageName1Tagged, build.WithDockerfile(`FROM busybox
|
|
LABEL match me 1 tagged`))
|
|
imageID1Tagged := getIDByName(c, imageName1Tagged)
|
|
|
|
imageName2 := "images_ps_filter_test2"
|
|
buildImageSuccessfully(c, imageName2, build.WithDockerfile(fmt.Sprintf(`FROM %s
|
|
LABEL match me 2`, imageName1)))
|
|
imageID2 := getIDByName(c, imageName2)
|
|
|
|
// start containers
|
|
dockerCmd(c, "run", "--name=first", "busybox", "echo", "hello")
|
|
firstID := getIDByName(c, "first")
|
|
|
|
// start another container
|
|
dockerCmd(c, "run", "--name=second", "busybox", "echo", "hello")
|
|
secondID := getIDByName(c, "second")
|
|
|
|
// start third container
|
|
dockerCmd(c, "run", "--name=third", imageName1, "echo", "hello")
|
|
thirdID := getIDByName(c, "third")
|
|
|
|
// start fourth container
|
|
dockerCmd(c, "run", "--name=fourth", imageName1Tagged, "echo", "hello")
|
|
fourthID := getIDByName(c, "fourth")
|
|
|
|
// start fifth container
|
|
dockerCmd(c, "run", "--name=fifth", imageName2, "echo", "hello")
|
|
fifthID := getIDByName(c, "fifth")
|
|
|
|
var filterTestSuite = []struct {
|
|
filterName string
|
|
expectedIDs []string
|
|
}{
|
|
// non existent stuff
|
|
{"nonexistent", []string{}},
|
|
{"nonexistent:tag", []string{}},
|
|
// image
|
|
{"busybox", []string{firstID, secondID, thirdID, fourthID, fifthID}},
|
|
{imageName1, []string{thirdID, fifthID}},
|
|
{imageName2, []string{fifthID}},
|
|
// image:tag
|
|
{fmt.Sprintf("%s:latest", imageName1), []string{thirdID, fifthID}},
|
|
{imageName1Tagged, []string{fourthID}},
|
|
// short-id
|
|
{stringid.TruncateID(imageID1), []string{thirdID, fifthID}},
|
|
{stringid.TruncateID(imageID2), []string{fifthID}},
|
|
// full-id
|
|
{imageID1, []string{thirdID, fifthID}},
|
|
{imageID1Tagged, []string{fourthID}},
|
|
{imageID2, []string{fifthID}},
|
|
}
|
|
|
|
var out string
|
|
for _, filter := range filterTestSuite {
|
|
out, _ = dockerCmd(c, "ps", "-a", "-q", "--no-trunc", "--filter=ancestor="+filter.filterName)
|
|
checkPsAncestorFilterOutput(c, RemoveOutputForExistingElements(out, existingContainers), filter.filterName, filter.expectedIDs)
|
|
}
|
|
|
|
// Multiple ancestor filter
|
|
out, _ = dockerCmd(c, "ps", "-a", "-q", "--no-trunc", "--filter=ancestor="+imageName2, "--filter=ancestor="+imageName1Tagged)
|
|
checkPsAncestorFilterOutput(c, RemoveOutputForExistingElements(out, existingContainers), imageName2+","+imageName1Tagged, []string{fourthID, fifthID})
|
|
}
|
|
|
|
func checkPsAncestorFilterOutput(c *testing.T, out string, filterName string, expectedIDs []string) {
|
|
var actualIDs []string
|
|
if out != "" {
|
|
actualIDs = strings.Split(out[:len(out)-1], "\n")
|
|
}
|
|
sort.Strings(actualIDs)
|
|
sort.Strings(expectedIDs)
|
|
|
|
assert.Equal(c, len(actualIDs), len(expectedIDs), fmt.Sprintf("Expected filtered container(s) for %s ancestor filter to be %v:%v, got %v:%v", filterName, len(expectedIDs), expectedIDs, len(actualIDs), actualIDs))
|
|
if len(expectedIDs) > 0 {
|
|
same := true
|
|
for i := range expectedIDs {
|
|
if actualIDs[i] != expectedIDs[i] {
|
|
c.Logf("%s, %s", actualIDs[i], expectedIDs[i])
|
|
same = false
|
|
break
|
|
}
|
|
}
|
|
assert.Equal(c, same, true, fmt.Sprintf("Expected filtered container(s) for %s ancestor filter to be %v, got %v", filterName, expectedIDs, actualIDs))
|
|
}
|
|
}
|
|
|
|
func (s *DockerSuite) TestPsListContainersFilterLabel(c *testing.T) {
|
|
// start container
|
|
dockerCmd(c, "run", "--name=first", "-l", "match=me", "-l", "second=tag", "busybox")
|
|
firstID := getIDByName(c, "first")
|
|
|
|
// start another container
|
|
dockerCmd(c, "run", "--name=second", "-l", "match=me too", "busybox")
|
|
secondID := getIDByName(c, "second")
|
|
|
|
// start third container
|
|
dockerCmd(c, "run", "--name=third", "-l", "nomatch=me", "busybox")
|
|
thirdID := getIDByName(c, "third")
|
|
|
|
// filter containers by exact match
|
|
out, _ := dockerCmd(c, "ps", "-a", "-q", "--no-trunc", "--filter=label=match=me")
|
|
containerOut := strings.TrimSpace(out)
|
|
assert.Equal(c, containerOut, firstID, fmt.Sprintf("Expected id %s, got %s for exited filter, output: %q", firstID, containerOut, out))
|
|
|
|
// filter containers by two labels
|
|
out, _ = dockerCmd(c, "ps", "-a", "-q", "--no-trunc", "--filter=label=match=me", "--filter=label=second=tag")
|
|
containerOut = strings.TrimSpace(out)
|
|
assert.Equal(c, containerOut, firstID, fmt.Sprintf("Expected id %s, got %s for exited filter, output: %q", firstID, containerOut, out))
|
|
|
|
// filter containers by two labels, but expect not found because of AND behavior
|
|
out, _ = dockerCmd(c, "ps", "-a", "-q", "--no-trunc", "--filter=label=match=me", "--filter=label=second=tag-no")
|
|
containerOut = strings.TrimSpace(out)
|
|
assert.Equal(c, containerOut, "", fmt.Sprintf("Expected nothing, got %s for exited filter, output: %q", containerOut, out))
|
|
|
|
// filter containers by exact key
|
|
out, _ = dockerCmd(c, "ps", "-a", "-q", "--no-trunc", "--filter=label=match")
|
|
containerOut = strings.TrimSpace(out)
|
|
assert.Assert(c, strings.Contains(containerOut, firstID))
|
|
assert.Assert(c, strings.Contains(containerOut, secondID))
|
|
assert.Assert(c, !strings.Contains(containerOut, thirdID))
|
|
}
|
|
|
|
func (s *DockerSuite) TestPsListContainersFilterExited(c *testing.T) {
|
|
runSleepingContainer(c, "--name=sleep")
|
|
|
|
firstZero, _ := dockerCmd(c, "run", "-d", "busybox", "true")
|
|
secondZero, _ := dockerCmd(c, "run", "-d", "busybox", "true")
|
|
|
|
out, _, err := dockerCmdWithError("run", "--name", "nonzero1", "busybox", "false")
|
|
assert.Assert(c, err != nil, "Should fail. out: %s", out)
|
|
firstNonZero := getIDByName(c, "nonzero1")
|
|
|
|
out, _, err = dockerCmdWithError("run", "--name", "nonzero2", "busybox", "false")
|
|
assert.Assert(c, err != nil, "Should fail. out: %s", out)
|
|
secondNonZero := getIDByName(c, "nonzero2")
|
|
|
|
// filter containers by exited=0
|
|
out, _ = dockerCmd(c, "ps", "-a", "-q", "--no-trunc", "--filter=exited=0")
|
|
assert.Assert(c, strings.Contains(out, strings.TrimSpace(firstZero)))
|
|
assert.Assert(c, strings.Contains(out, strings.TrimSpace(secondZero)))
|
|
assert.Assert(c, !strings.Contains(out, strings.TrimSpace(firstNonZero)))
|
|
assert.Assert(c, !strings.Contains(out, strings.TrimSpace(secondNonZero)))
|
|
out, _ = dockerCmd(c, "ps", "-a", "-q", "--no-trunc", "--filter=exited=1")
|
|
assert.Assert(c, strings.Contains(out, strings.TrimSpace(firstNonZero)))
|
|
assert.Assert(c, strings.Contains(out, strings.TrimSpace(secondNonZero)))
|
|
assert.Assert(c, !strings.Contains(out, strings.TrimSpace(firstZero)))
|
|
assert.Assert(c, !strings.Contains(out, strings.TrimSpace(secondZero)))
|
|
}
|
|
|
|
func (s *DockerSuite) TestPsRightTagName(c *testing.T) {
|
|
// TODO Investigate further why this fails on Windows to Windows CI
|
|
testRequires(c, DaemonIsLinux)
|
|
|
|
existingContainers := ExistingContainerNames(c)
|
|
|
|
tag := "asybox:shmatest"
|
|
dockerCmd(c, "tag", "busybox", tag)
|
|
|
|
var id1 string
|
|
out := runSleepingContainer(c)
|
|
id1 = strings.TrimSpace(string(out))
|
|
|
|
var id2 string
|
|
out = runSleepingContainerInImage(c, tag)
|
|
id2 = strings.TrimSpace(string(out))
|
|
|
|
var imageID string
|
|
out = inspectField(c, "busybox", "Id")
|
|
imageID = strings.TrimSpace(string(out))
|
|
|
|
var id3 string
|
|
out = runSleepingContainerInImage(c, imageID)
|
|
id3 = strings.TrimSpace(string(out))
|
|
|
|
out, _ = dockerCmd(c, "ps", "--no-trunc")
|
|
lines := strings.Split(strings.TrimSpace(string(out)), "\n")
|
|
lines = RemoveLinesForExistingElements(lines, existingContainers)
|
|
// skip header
|
|
lines = lines[1:]
|
|
assert.Equal(c, len(lines), 3, "There should be 3 running container, got %d", len(lines))
|
|
for _, line := range lines {
|
|
f := strings.Fields(line)
|
|
switch f[0] {
|
|
case id1:
|
|
assert.Equal(c, f[1], "busybox", fmt.Sprintf("Expected %s tag for id %s, got %s", "busybox", id1, f[1]))
|
|
case id2:
|
|
assert.Equal(c, f[1], tag, fmt.Sprintf("Expected %s tag for id %s, got %s", tag, id2, f[1]))
|
|
case id3:
|
|
assert.Equal(c, f[1], imageID, fmt.Sprintf("Expected %s imageID for id %s, got %s", tag, id3, f[1]))
|
|
default:
|
|
c.Fatalf("Unexpected id %s, expected %s and %s and %s", f[0], id1, id2, id3)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (s *DockerSuite) TestPsListContainersFilterCreated(c *testing.T) {
|
|
// create a container
|
|
out, _ := dockerCmd(c, "create", "busybox")
|
|
cID := strings.TrimSpace(out)
|
|
shortCID := cID[:12]
|
|
|
|
// Make sure it DOESN'T show up w/o a '-a' for normal 'ps'
|
|
out, _ = dockerCmd(c, "ps", "-q")
|
|
assert.Assert(c, !strings.Contains(out, shortCID), "Should have not seen '%s' in ps output:\n%s", shortCID, out)
|
|
// Make sure it DOES show up as 'Created' for 'ps -a'
|
|
out, _ = dockerCmd(c, "ps", "-a")
|
|
|
|
hits := 0
|
|
for _, line := range strings.Split(out, "\n") {
|
|
if !strings.Contains(line, shortCID) {
|
|
continue
|
|
}
|
|
hits++
|
|
assert.Assert(c, strings.Contains(line, "Created"), "Missing 'Created' on '%s'", line)
|
|
}
|
|
|
|
assert.Equal(c, hits, 1, fmt.Sprintf("Should have seen '%s' in ps -a output once:%d\n%s", shortCID, hits, out))
|
|
|
|
// filter containers by 'create' - note, no -a needed
|
|
out, _ = dockerCmd(c, "ps", "-q", "-f", "status=created")
|
|
containerOut := strings.TrimSpace(out)
|
|
assert.Assert(c, strings.HasPrefix(cID, containerOut))
|
|
}
|
|
|
|
// Test for GitHub issue #12595
|
|
func (s *DockerSuite) TestPsImageIDAfterUpdate(c *testing.T) {
|
|
// TODO: Investigate why this fails on Windows to Windows CI further.
|
|
testRequires(c, DaemonIsLinux)
|
|
originalImageName := "busybox:TestPsImageIDAfterUpdate-original"
|
|
updatedImageName := "busybox:TestPsImageIDAfterUpdate-updated"
|
|
|
|
existingContainers := ExistingContainerIDs(c)
|
|
|
|
icmd.RunCommand(dockerBinary, "tag", "busybox:latest", originalImageName).Assert(c, icmd.Success)
|
|
|
|
originalImageID := getIDByName(c, originalImageName)
|
|
|
|
result := icmd.RunCommand(dockerBinary, append([]string{"run", "-d", originalImageName}, sleepCommandForDaemonPlatform()...)...)
|
|
result.Assert(c, icmd.Success)
|
|
containerID := strings.TrimSpace(result.Combined())
|
|
|
|
result = icmd.RunCommand(dockerBinary, "ps", "--no-trunc")
|
|
result.Assert(c, icmd.Success)
|
|
|
|
lines := strings.Split(strings.TrimSpace(string(result.Combined())), "\n")
|
|
lines = RemoveLinesForExistingElements(lines, existingContainers)
|
|
// skip header
|
|
lines = lines[1:]
|
|
assert.Equal(c, len(lines), 1)
|
|
|
|
for _, line := range lines {
|
|
f := strings.Fields(line)
|
|
assert.Equal(c, f[1], originalImageName)
|
|
}
|
|
|
|
icmd.RunCommand(dockerBinary, "commit", containerID, updatedImageName).Assert(c, icmd.Success)
|
|
icmd.RunCommand(dockerBinary, "tag", updatedImageName, originalImageName).Assert(c, icmd.Success)
|
|
|
|
result = icmd.RunCommand(dockerBinary, "ps", "--no-trunc")
|
|
result.Assert(c, icmd.Success)
|
|
|
|
lines = strings.Split(strings.TrimSpace(string(result.Combined())), "\n")
|
|
lines = RemoveLinesForExistingElements(lines, existingContainers)
|
|
// skip header
|
|
lines = lines[1:]
|
|
assert.Equal(c, len(lines), 1)
|
|
|
|
for _, line := range lines {
|
|
f := strings.Fields(line)
|
|
assert.Equal(c, f[1], originalImageID)
|
|
}
|
|
|
|
}
|
|
|
|
func (s *DockerSuite) TestPsNotShowPortsOfStoppedContainer(c *testing.T) {
|
|
testRequires(c, DaemonIsLinux)
|
|
dockerCmd(c, "run", "--name=foo", "-d", "-p", "5000:5000", "busybox", "top")
|
|
assert.Assert(c, waitRun("foo") == nil)
|
|
out, _ := dockerCmd(c, "ps")
|
|
lines := strings.Split(strings.TrimSpace(string(out)), "\n")
|
|
expected := "0.0.0.0:5000->5000/tcp"
|
|
fields := strings.Fields(lines[1])
|
|
assert.Equal(c, fields[len(fields)-2], expected, fmt.Sprintf("Expected: %v, got: %v", expected, fields[len(fields)-2]))
|
|
|
|
dockerCmd(c, "kill", "foo")
|
|
dockerCmd(c, "wait", "foo")
|
|
out, _ = dockerCmd(c, "ps", "-l")
|
|
lines = strings.Split(strings.TrimSpace(string(out)), "\n")
|
|
fields = strings.Fields(lines[1])
|
|
assert.Assert(c, fields[len(fields)-2] != expected, "Should not got %v", expected)
|
|
}
|
|
|
|
func (s *DockerSuite) TestPsShowMounts(c *testing.T) {
|
|
existingContainers := ExistingContainerNames(c)
|
|
|
|
prefix, slash := getPrefixAndSlashFromDaemonPlatform()
|
|
|
|
mp := prefix + slash + "test"
|
|
|
|
dockerCmd(c, "volume", "create", "ps-volume-test")
|
|
// volume mount containers
|
|
runSleepingContainer(c, "--name=volume-test-1", "--volume", "ps-volume-test:"+mp)
|
|
assert.Assert(c, waitRun("volume-test-1") == nil)
|
|
runSleepingContainer(c, "--name=volume-test-2", "--volume", mp)
|
|
assert.Assert(c, waitRun("volume-test-2") == nil)
|
|
// bind mount container
|
|
var bindMountSource string
|
|
var bindMountDestination string
|
|
if DaemonIsWindows() {
|
|
bindMountSource = "c:\\"
|
|
bindMountDestination = "c:\\t"
|
|
} else {
|
|
bindMountSource = "/tmp"
|
|
bindMountDestination = "/t"
|
|
}
|
|
runSleepingContainer(c, "--name=bind-mount-test", "-v", bindMountSource+":"+bindMountDestination)
|
|
assert.Assert(c, waitRun("bind-mount-test") == nil)
|
|
|
|
out, _ := dockerCmd(c, "ps", "--format", "{{.Names}} {{.Mounts}}")
|
|
|
|
lines := strings.Split(strings.TrimSpace(string(out)), "\n")
|
|
lines = RemoveLinesForExistingElements(lines, existingContainers)
|
|
assert.Equal(c, len(lines), 3)
|
|
|
|
fields := strings.Fields(lines[0])
|
|
assert.Equal(c, len(fields), 2)
|
|
assert.Equal(c, fields[0], "bind-mount-test")
|
|
assert.Equal(c, fields[1], bindMountSource)
|
|
|
|
fields = strings.Fields(lines[1])
|
|
assert.Equal(c, len(fields), 2)
|
|
|
|
anonymousVolumeID := fields[1]
|
|
|
|
fields = strings.Fields(lines[2])
|
|
assert.Equal(c, fields[1], "ps-volume-test")
|
|
|
|
// filter by volume name
|
|
out, _ = dockerCmd(c, "ps", "--format", "{{.Names}} {{.Mounts}}", "--filter", "volume=ps-volume-test")
|
|
|
|
lines = strings.Split(strings.TrimSpace(string(out)), "\n")
|
|
lines = RemoveLinesForExistingElements(lines, existingContainers)
|
|
assert.Equal(c, len(lines), 1)
|
|
|
|
fields = strings.Fields(lines[0])
|
|
assert.Equal(c, fields[1], "ps-volume-test")
|
|
|
|
// empty results filtering by unknown volume
|
|
out, _ = dockerCmd(c, "ps", "--format", "{{.Names}} {{.Mounts}}", "--filter", "volume=this-volume-should-not-exist")
|
|
assert.Equal(c, len(strings.TrimSpace(string(out))), 0)
|
|
|
|
// filter by mount destination
|
|
out, _ = dockerCmd(c, "ps", "--format", "{{.Names}} {{.Mounts}}", "--filter", "volume="+mp)
|
|
|
|
lines = strings.Split(strings.TrimSpace(string(out)), "\n")
|
|
lines = RemoveLinesForExistingElements(lines, existingContainers)
|
|
assert.Equal(c, len(lines), 2)
|
|
|
|
fields = strings.Fields(lines[0])
|
|
assert.Equal(c, fields[1], anonymousVolumeID)
|
|
fields = strings.Fields(lines[1])
|
|
assert.Equal(c, fields[1], "ps-volume-test")
|
|
|
|
// filter by bind mount source
|
|
out, _ = dockerCmd(c, "ps", "--format", "{{.Names}} {{.Mounts}}", "--filter", "volume="+bindMountSource)
|
|
|
|
lines = strings.Split(strings.TrimSpace(string(out)), "\n")
|
|
lines = RemoveLinesForExistingElements(lines, existingContainers)
|
|
assert.Equal(c, len(lines), 1)
|
|
|
|
fields = strings.Fields(lines[0])
|
|
assert.Equal(c, len(fields), 2)
|
|
assert.Equal(c, fields[0], "bind-mount-test")
|
|
assert.Equal(c, fields[1], bindMountSource)
|
|
|
|
// filter by bind mount destination
|
|
out, _ = dockerCmd(c, "ps", "--format", "{{.Names}} {{.Mounts}}", "--filter", "volume="+bindMountDestination)
|
|
|
|
lines = strings.Split(strings.TrimSpace(string(out)), "\n")
|
|
lines = RemoveLinesForExistingElements(lines, existingContainers)
|
|
assert.Equal(c, len(lines), 1)
|
|
|
|
fields = strings.Fields(lines[0])
|
|
assert.Equal(c, len(fields), 2)
|
|
assert.Equal(c, fields[0], "bind-mount-test")
|
|
assert.Equal(c, fields[1], bindMountSource)
|
|
|
|
// empty results filtering by unknown mount point
|
|
out, _ = dockerCmd(c, "ps", "--format", "{{.Names}} {{.Mounts}}", "--filter", "volume="+prefix+slash+"this-path-was-never-mounted")
|
|
assert.Equal(c, len(strings.TrimSpace(string(out))), 0)
|
|
}
|
|
|
|
func (s *DockerSuite) TestPsListContainersFilterNetwork(c *testing.T) {
|
|
existing := ExistingContainerIDs(c)
|
|
|
|
// TODO default network on Windows is not called "bridge", and creating a
|
|
// custom network fails on Windows fails with "Error response from daemon: plugin not found")
|
|
testRequires(c, DaemonIsLinux)
|
|
|
|
// create some containers
|
|
runSleepingContainer(c, "--net=bridge", "--name=onbridgenetwork")
|
|
runSleepingContainer(c, "--net=none", "--name=onnonenetwork")
|
|
|
|
// Filter docker ps on non existing network
|
|
out, _ := dockerCmd(c, "ps", "--filter", "network=doesnotexist")
|
|
containerOut := strings.TrimSpace(string(out))
|
|
lines := strings.Split(containerOut, "\n")
|
|
|
|
// skip header
|
|
lines = lines[1:]
|
|
|
|
// ps output should have no containers
|
|
assert.Equal(c, len(RemoveLinesForExistingElements(lines, existing)), 0)
|
|
|
|
// Filter docker ps on network bridge
|
|
out, _ = dockerCmd(c, "ps", "--filter", "network=bridge")
|
|
containerOut = strings.TrimSpace(string(out))
|
|
|
|
lines = strings.Split(containerOut, "\n")
|
|
|
|
// skip header
|
|
lines = lines[1:]
|
|
|
|
// ps output should have only one container
|
|
assert.Equal(c, len(RemoveLinesForExistingElements(lines, existing)), 1)
|
|
|
|
// Making sure onbridgenetwork is on the output
|
|
assert.Assert(c, strings.Contains(containerOut, "onbridgenetwork"), "Missing the container on network\n")
|
|
// Filter docker ps on networks bridge and none
|
|
out, _ = dockerCmd(c, "ps", "--filter", "network=bridge", "--filter", "network=none")
|
|
containerOut = strings.TrimSpace(string(out))
|
|
|
|
lines = strings.Split(containerOut, "\n")
|
|
|
|
// skip header
|
|
lines = lines[1:]
|
|
|
|
//ps output should have both the containers
|
|
assert.Equal(c, len(RemoveLinesForExistingElements(lines, existing)), 2)
|
|
|
|
// Making sure onbridgenetwork and onnonenetwork is on the output
|
|
assert.Assert(c, strings.Contains(containerOut, "onnonenetwork"), "Missing the container on none network\n")
|
|
assert.Assert(c, strings.Contains(containerOut, "onbridgenetwork"), "Missing the container on bridge network\n")
|
|
nwID, _ := dockerCmd(c, "network", "inspect", "--format", "{{.ID}}", "bridge")
|
|
|
|
// Filter by network ID
|
|
out, _ = dockerCmd(c, "ps", "--filter", "network="+nwID)
|
|
containerOut = strings.TrimSpace(string(out))
|
|
|
|
assert.Assert(c, is.Contains(containerOut, "onbridgenetwork"))
|
|
|
|
// Filter by partial network ID
|
|
partialnwID := string(nwID[0:4])
|
|
|
|
out, _ = dockerCmd(c, "ps", "--filter", "network="+partialnwID)
|
|
containerOut = strings.TrimSpace(string(out))
|
|
|
|
lines = strings.Split(containerOut, "\n")
|
|
|
|
// skip header
|
|
lines = lines[1:]
|
|
|
|
// ps output should have only one container
|
|
assert.Equal(c, len(RemoveLinesForExistingElements(lines, existing)), 1)
|
|
|
|
// Making sure onbridgenetwork is on the output
|
|
assert.Assert(c, strings.Contains(containerOut, "onbridgenetwork"), "Missing the container on network\n")
|
|
}
|
|
|
|
func (s *DockerSuite) TestPsByOrder(c *testing.T) {
|
|
out := runSleepingContainer(c, "--name", "xyz-abc")
|
|
container1 := strings.TrimSpace(out)
|
|
|
|
out = runSleepingContainer(c, "--name", "xyz-123")
|
|
container2 := strings.TrimSpace(out)
|
|
|
|
runSleepingContainer(c, "--name", "789-abc")
|
|
runSleepingContainer(c, "--name", "789-123")
|
|
|
|
// Run multiple time should have the same result
|
|
out = cli.DockerCmd(c, "ps", "--no-trunc", "-q", "-f", "name=xyz").Combined()
|
|
assert.Equal(c, strings.TrimSpace(out), fmt.Sprintf("%s\n%s", container2, container1))
|
|
|
|
// Run multiple time should have the same result
|
|
out = cli.DockerCmd(c, "ps", "--no-trunc", "-q", "-f", "name=xyz").Combined()
|
|
assert.Equal(c, strings.TrimSpace(out), fmt.Sprintf("%s\n%s", container2, container1))
|
|
}
|
|
|
|
func (s *DockerSuite) TestPsListContainersFilterPorts(c *testing.T) {
|
|
testRequires(c, DaemonIsLinux)
|
|
existingContainers := ExistingContainerIDs(c)
|
|
|
|
out, _ := dockerCmd(c, "run", "-d", "--publish=80", "busybox", "top")
|
|
id1 := strings.TrimSpace(out)
|
|
|
|
out, _ = dockerCmd(c, "run", "-d", "--expose=8080", "busybox", "top")
|
|
id2 := strings.TrimSpace(out)
|
|
|
|
out, _ = dockerCmd(c, "ps", "--no-trunc", "-q")
|
|
assert.Assert(c, strings.Contains(strings.TrimSpace(out), id1))
|
|
assert.Assert(c, strings.Contains(strings.TrimSpace(out), id2))
|
|
out, _ = dockerCmd(c, "ps", "--no-trunc", "-q", "--filter", "publish=80-8080/udp")
|
|
assert.Assert(c, strings.TrimSpace(out) != id1)
|
|
assert.Assert(c, strings.TrimSpace(out) != id2)
|
|
|
|
out, _ = dockerCmd(c, "ps", "--no-trunc", "-q", "--filter", "expose=8081")
|
|
assert.Assert(c, strings.TrimSpace(out) != id1)
|
|
assert.Assert(c, strings.TrimSpace(out) != id2)
|
|
|
|
out, _ = dockerCmd(c, "ps", "--no-trunc", "-q", "--filter", "publish=80-81")
|
|
assert.Equal(c, strings.TrimSpace(out), id1)
|
|
assert.Assert(c, strings.TrimSpace(out) != id2)
|
|
|
|
out, _ = dockerCmd(c, "ps", "--no-trunc", "-q", "--filter", "expose=80/tcp")
|
|
assert.Equal(c, strings.TrimSpace(out), id1)
|
|
assert.Assert(c, strings.TrimSpace(out) != id2)
|
|
|
|
out, _ = dockerCmd(c, "ps", "--no-trunc", "-q", "--filter", "expose=8080/tcp")
|
|
out = RemoveOutputForExistingElements(out, existingContainers)
|
|
assert.Assert(c, strings.TrimSpace(out) != id1)
|
|
assert.Equal(c, strings.TrimSpace(out), id2)
|
|
}
|
|
|
|
func (s *DockerSuite) TestPsNotShowLinknamesOfDeletedContainer(c *testing.T) {
|
|
testRequires(c, DaemonIsLinux, MinimumAPIVersion("1.31"))
|
|
existingContainers := ExistingContainerNames(c)
|
|
|
|
dockerCmd(c, "create", "--name=aaa", "busybox", "top")
|
|
dockerCmd(c, "create", "--name=bbb", "--link=aaa", "busybox", "top")
|
|
|
|
out, _ := dockerCmd(c, "ps", "--no-trunc", "-a", "--format", "{{.Names}}")
|
|
lines := strings.Split(strings.TrimSpace(string(out)), "\n")
|
|
lines = RemoveLinesForExistingElements(lines, existingContainers)
|
|
expected := []string{"bbb", "aaa,bbb/aaa"}
|
|
var names []string
|
|
names = append(names, lines...)
|
|
assert.Assert(c, is.DeepEqual(names, expected), "Expected array with non-truncated names: %v, got: %v", expected, names)
|
|
|
|
dockerCmd(c, "rm", "bbb")
|
|
|
|
out, _ = dockerCmd(c, "ps", "--no-trunc", "-a", "--format", "{{.Names}}")
|
|
out = RemoveOutputForExistingElements(out, existingContainers)
|
|
assert.Equal(c, strings.TrimSpace(out), "aaa")
|
|
}
|