kotovalexarian-likes-github/moby--moby
1
0
Fork 0
mirror of https://github.com/moby/moby.git synced 2022-11-09 12:21:53 -05:00
Code Releases Activity

Clean more build utils in integration cli

Browse source 
- Remove deprecated buildImage* functions
- Rename buildImageNew to buildImage
- Use *check.C in fakeContext* setup and in getIdByName

Signed-off-by: Vincent Demeester <vincent@sbr.pm>
This commit is contained in:
Vincent Demeester 2017-01-16 11:30:14 +01:00
parent 8c7651998f
commit c10f6ef43f
No known key found for this signature in database
GPG key ID: 083CC6FD6EB699A3
28 changed files with 587 additions and 1194 deletions
Download patch file Download diff file Expand all files Collapse all files

1
integration-cli/daemon/daemon.go
View file

@ -791,6 +791,7 @@ func WaitInspectWithArgs(dockerBinary, name, expr, expected string, timeout time
} }
// BuildImageCmdWithHost create a build command with the specified arguments. // BuildImageCmdWithHost create a build command with the specified arguments.
// Deprecated
// FIXME(vdemeester) move this away // FIXME(vdemeester) move this away
func BuildImageCmdWithHost(dockerBinary, name, dockerfile, host string, useCache bool, buildFlags ...string) *exec.Cmd { func BuildImageCmdWithHost(dockerBinary, name, dockerfile, host string, useCache bool, buildFlags ...string) *exec.Cmd {
args := []string{} args := []string{}

21
integration-cli/docker_api_build_test.go
View file

@ -28,8 +28,7 @@ COPY * /tmp/
RUN find / -xdev -name ba* RUN find / -xdev -name ba*
RUN find /tmp/` RUN find /tmp/`
} }
server, err := fakeStorage(map[string]string{"testD": testD}) server := fakeStorage(c, map[string]string{"testD": testD})
c.Assert(err, checker.IsNil)
defer server.Close() defer server.Close()
res, body, err := request.SockRequestRaw("POST", "/build?dockerfile=baz&remote="+server.URL()+"/testD", nil, "application/json", daemonHost()) res, body, err := request.SockRequestRaw("POST", "/build?dockerfile=baz&remote="+server.URL()+"/testD", nil, "application/json", daemonHost())
@ -66,11 +65,9 @@ func (s *DockerSuite) TestBuildAPIRemoteTarballContext(c *check.C) {
// failed to close tar archive // failed to close tar archive
c.Assert(tw.Close(), checker.IsNil) c.Assert(tw.Close(), checker.IsNil)
server, err := fakeBinaryStorage(map[string]*bytes.Buffer{ server := fakeBinaryStorage(c, map[string]*bytes.Buffer{
"testT.tar": buffer, "testT.tar": buffer,
}) })
c.Assert(err, checker.IsNil)
defer server.Close() defer server.Close()
res, b, err := request.SockRequestRaw("POST", "/build?remote="+server.URL()+"/testT.tar", nil, "application/tar", daemonHost()) res, b, err := request.SockRequestRaw("POST", "/build?remote="+server.URL()+"/testT.tar", nil, "application/tar", daemonHost())
@ -115,12 +112,11 @@ RUN echo 'right'
// failed to close tar archive // failed to close tar archive
c.Assert(tw.Close(), checker.IsNil) c.Assert(tw.Close(), checker.IsNil)
server, err := fakeBinaryStorage(map[string]*bytes.Buffer{ server := fakeBinaryStorage(c, map[string]*bytes.Buffer{
"testT.tar": buffer, "testT.tar": buffer,
}) })
c.Assert(err, checker.IsNil)
defer server.Close() defer server.Close()
url := "/build?dockerfile=custom&remote=" + server.URL() + "/testT.tar" url := "/build?dockerfile=custom&remote=" + server.URL() + "/testT.tar"
res, body, err := request.SockRequestRaw("POST", url, nil, "application/tar", daemonHost()) res, body, err := request.SockRequestRaw("POST", url, nil, "application/tar", daemonHost())
c.Assert(err, checker.IsNil) c.Assert(err, checker.IsNil)
@ -135,11 +131,10 @@ RUN echo 'right'
} }
func (s *DockerSuite) TestBuildAPILowerDockerfile(c *check.C) { func (s *DockerSuite) TestBuildAPILowerDockerfile(c *check.C) {
git, err := newFakeGit("repo", map[string]string{ git := newFakeGit(c, "repo", map[string]string{
"dockerfile": `FROM busybox "dockerfile": `FROM busybox
RUN echo from dockerfile`, RUN echo from dockerfile`,
}, false) }, false)
c.Assert(err, checker.IsNil)
defer git.Close() defer git.Close()
res, body, err := request.SockRequestRaw("POST", "/build?remote="+git.RepoURL, nil, "application/json", daemonHost()) res, body, err := request.SockRequestRaw("POST", "/build?remote="+git.RepoURL, nil, "application/json", daemonHost())
@ -154,13 +149,12 @@ RUN echo from dockerfile`,
} }
func (s *DockerSuite) TestBuildAPIBuildGitWithF(c *check.C) { func (s *DockerSuite) TestBuildAPIBuildGitWithF(c *check.C) {
git, err := newFakeGit("repo", map[string]string{ git := newFakeGit(c, "repo", map[string]string{
"baz": `FROM busybox "baz": `FROM busybox
RUN echo from baz`, RUN echo from baz`,
"Dockerfile": `FROM busybox "Dockerfile": `FROM busybox
RUN echo from Dockerfile`, RUN echo from Dockerfile`,
}, false) }, false)
c.Assert(err, checker.IsNil)
defer git.Close() defer git.Close()
// Make sure it tries to 'dockerfile' query param value // Make sure it tries to 'dockerfile' query param value
@ -177,13 +171,12 @@ RUN echo from Dockerfile`,
func (s *DockerSuite) TestBuildAPIDoubleDockerfile(c *check.C) { func (s *DockerSuite) TestBuildAPIDoubleDockerfile(c *check.C) {
testRequires(c, UnixCli) // dockerfile overwrites Dockerfile on Windows testRequires(c, UnixCli) // dockerfile overwrites Dockerfile on Windows
git, err := newFakeGit("repo", map[string]string{ git := newFakeGit(c, "repo", map[string]string{
"Dockerfile": `FROM busybox "Dockerfile": `FROM busybox
RUN echo from Dockerfile`, RUN echo from Dockerfile`,
"dockerfile": `FROM busybox "dockerfile": `FROM busybox
RUN echo from dockerfile`, RUN echo from dockerfile`,
}, false) }, false)
c.Assert(err, checker.IsNil)
defer git.Close() defer git.Close()
// Make sure it tries to 'dockerfile' query param value // Make sure it tries to 'dockerfile' query param value

7
integration-cli/docker_api_containers_test.go
View file

@ -1766,19 +1766,18 @@ func (s *DockerSuite) TestContainersAPICreateMountsCreate(c *check.C) {
destPath := prefix + slash + "foo" destPath := prefix + slash + "foo"
var ( var (
err error
testImg string testImg string
) )
if testEnv.DaemonPlatform() != "windows" { if testEnv.DaemonPlatform() != "windows" {
testImg, err = buildImage("test-mount-config", ` testImg = "test-mount-config"
buildImageSuccessfully(c, testImg, withDockerfile(`
FROM busybox FROM busybox
RUN mkdir `+destPath+` && touch `+destPath+slash+`bar RUN mkdir `+destPath+` && touch `+destPath+slash+`bar
CMD cat `+destPath+slash+`bar CMD cat `+destPath+slash+`bar
`, true) `))
} else { } else {
testImg = "busybox" testImg = "busybox"
} }
c.Assert(err, checker.IsNil)
type testCase struct { type testCase struct {
cfg mounttypes.Mount cfg mounttypes.Mount

16
integration-cli/docker_api_images_test.go
View file

@ -52,9 +52,8 @@ func (s *DockerSuite) TestAPIImagesSaveAndLoad(c *check.C) {
// TODO Windows to Windows CI: Investigate further why this test fails. // TODO Windows to Windows CI: Investigate further why this test fails.
testRequires(c, Network) testRequires(c, Network)
testRequires(c, DaemonIsLinux) testRequires(c, DaemonIsLinux)
out, err := buildImage("saveandload", "FROM busybox\nENV FOO bar", false) buildImageSuccessfully(c, "saveandload", withDockerfile("FROM busybox\nENV FOO bar"))
c.Assert(err, checker.IsNil) id := getIDByName(c, "saveandload")
id := strings.TrimSpace(out)
res, body, err := request.SockRequestRaw("GET", "/images/"+id+"/get", nil, "", daemonHost()) res, body, err := request.SockRequestRaw("GET", "/images/"+id+"/get", nil, "", daemonHost())
c.Assert(err, checker.IsNil) c.Assert(err, checker.IsNil)
@ -77,9 +76,8 @@ func (s *DockerSuite) TestAPIImagesDelete(c *check.C) {
testRequires(c, Network) testRequires(c, Network)
} }
name := "test-api-images-delete" name := "test-api-images-delete"
out, err := buildImage(name, "FROM busybox\nENV FOO bar", false) buildImageSuccessfully(c, name, withDockerfile("FROM busybox\nENV FOO bar"))
c.Assert(err, checker.IsNil) id := getIDByName(c, name)
id := strings.TrimSpace(out)
dockerCmd(c, "tag", name, "test:tag1") dockerCmd(c, "tag", name, "test:tag1")
@ -101,10 +99,8 @@ func (s *DockerSuite) TestAPIImagesHistory(c *check.C) {
testRequires(c, Network) testRequires(c, Network)
} }
name := "test-api-images-history" name := "test-api-images-history"
out, err := buildImage(name, "FROM busybox\nENV FOO bar", false) buildImageSuccessfully(c, name, withDockerfile("FROM busybox\nENV FOO bar"))
c.Assert(err, checker.IsNil) id := getIDByName(c, name)
id := strings.TrimSpace(out)
status, body, err := request.SockRequest("GET", "/images/"+id+"/history", nil, daemonHost()) status, body, err := request.SockRequest("GET", "/images/"+id+"/history", nil, daemonHost())
c.Assert(err, checker.IsNil) c.Assert(err, checker.IsNil)

899
integration-cli/docker_cli_build_test.go
View file

File diff suppressed because it is too large Load diff

15
integration-cli/docker_cli_build_unix_test.go
View file

@ -25,13 +25,11 @@ func (s *DockerSuite) TestBuildResourceConstraintsAreUsed(c *check.C) {
testRequires(c, cpuCfsQuota) testRequires(c, cpuCfsQuota)
name := "testbuildresourceconstraints" name := "testbuildresourceconstraints"
ctx, err := fakeContext(` ctx := fakeContext(c, `
FROM hello-world:frozen FROM hello-world:frozen
RUN ["/hello"] RUN ["/hello"]
`, map[string]string{}) `, map[string]string{})
c.Assert(err, checker.IsNil) _, _, err := dockerCmdInDir(c, ctx.Dir, "build", "--no-cache", "--rm=false", "--memory=64m", "--memory-swap=-1", "--cpuset-cpus=0", "--cpuset-mems=0", "--cpu-shares=100", "--cpu-quota=8000", "--ulimit", "nofile=42", "-t", name, ".")
_, _, err = dockerCmdInDir(c, ctx.Dir, "build", "--no-cache", "--rm=false", "--memory=64m", "--memory-swap=-1", "--cpuset-cpus=0", "--cpuset-mems=0", "--cpu-shares=100", "--cpu-quota=8000", "--ulimit", "nofile=42", "-t", name, ".")
if err != nil { if err != nil {
c.Fatal(err) c.Fatal(err)
} }
@ -114,9 +112,7 @@ func (s *DockerSuite) TestBuildAddChangeOwnership(c *check.C) {
defer ctx.Close() defer ctx.Close()
if _, err := buildImageFromContext(name, ctx, true); err != nil { buildImageSuccessfully(c, name, withExternalBuildContext(ctx))
c.Fatalf("build failed to complete for TestBuildAddChangeOwnership: %v", err)
}
} }
// Test that an infinite sleep during a build is killed if the client disconnects. // Test that an infinite sleep during a build is killed if the client disconnects.
@ -137,10 +133,7 @@ func (s *DockerSuite) TestBuildCancellationKillsSleep(c *check.C) {
defer observer.Stop() defer observer.Stop()
// (Note: one year, will never finish) // (Note: one year, will never finish)
ctx, err := fakeContext("FROM busybox\nRUN sleep 31536000", nil) ctx := fakeContext(c, "FROM busybox\nRUN sleep 31536000", nil)
if err != nil {
c.Fatal(err)
}
defer ctx.Close() defer ctx.Close()
buildCmd := exec.Command(dockerBinary, "build", "-t", name, ".") buildCmd := exec.Command(dockerBinary, "build", "-t", name, ".")

16
integration-cli/docker_cli_by_digest_test.go
View file

@ -193,10 +193,9 @@ func (s *DockerRegistrySuite) TestBuildByDigest(c *check.C) {
// do the build // do the build
name := "buildbydigest" name := "buildbydigest"
_, err = buildImage(name, fmt.Sprintf( buildImageSuccessfully(c, name, withDockerfile(fmt.Sprintf(
`FROM %s `FROM %s
CMD ["/bin/echo", "Hello World"]`, imageReference), CMD ["/bin/echo", "Hello World"]`, imageReference)))
true)
c.Assert(err, checker.IsNil) c.Assert(err, checker.IsNil)
// get the build's image id // get the build's image id
@ -417,20 +416,17 @@ func (s *DockerRegistrySuite) TestPsListContainersFilterAncestorImageByDigest(c
// build an image from it // build an image from it
imageName1 := "images_ps_filter_test" imageName1 := "images_ps_filter_test"
_, err = buildImage(imageName1, fmt.Sprintf( buildImageSuccessfully(c, imageName1, withDockerfile(fmt.Sprintf(
`FROM %s `FROM %s
LABEL match me 1`, imageReference), true) LABEL match me 1`, imageReference)))
c.Assert(err, checker.IsNil)
// run a container based on that // run a container based on that
dockerCmd(c, "run", "--name=test1", imageReference, "echo", "hello") dockerCmd(c, "run", "--name=test1", imageReference, "echo", "hello")
expectedID, err := getIDByName("test1") expectedID := getIDByName(c, "test1")
c.Assert(err, check.IsNil)
// run a container based on the a descendant of that too // run a container based on the a descendant of that too
dockerCmd(c, "run", "--name=test2", imageName1, "echo", "hello") dockerCmd(c, "run", "--name=test2", imageName1, "echo", "hello")
expectedID1, err := getIDByName("test2") expectedID1 := getIDByName(c, "test2")
c.Assert(err, check.IsNil)
expectedIDs := []string{expectedID, expectedID1} expectedIDs := []string{expectedID, expectedID1}

24
integration-cli/docker_cli_create_test.go
View file

@ -204,12 +204,8 @@ func (s *DockerSuite) TestCreateLabels(c *check.C) {
func (s *DockerSuite) TestCreateLabelFromImage(c *check.C) { func (s *DockerSuite) TestCreateLabelFromImage(c *check.C) {
imageName := "testcreatebuildlabel" imageName := "testcreatebuildlabel"
_, err := buildImage(imageName, buildImageSuccessfully(c, imageName, withDockerfile(`FROM busybox
`FROM busybox LABEL k1=v1 k2=v2`))
LABEL k1=v1 k2=v2`,
true)
c.Assert(err, check.IsNil)
name := "test_create_labels_from_image" name := "test_create_labels_from_image"
expected := map[string]string{"k2": "x", "k3": "v3", "k1": "v1"} expected := map[string]string{"k2": "x", "k3": "v3", "k1": "v1"}
@ -263,13 +259,9 @@ func (s *DockerSuite) TestCreateModeIpcContainer(c *check.C) {
func (s *DockerSuite) TestCreateByImageID(c *check.C) { func (s *DockerSuite) TestCreateByImageID(c *check.C) {
imageName := "testcreatebyimageid" imageName := "testcreatebyimageid"
imageID, err := buildImage(imageName, buildImageSuccessfully(c, imageName, withDockerfile(`FROM busybox
`FROM busybox MAINTAINER dockerio`))
MAINTAINER dockerio`, imageID := getIDByName(c, imageName)
true)
if err != nil {
c.Fatal(err)
}
truncatedImageID := stringid.TruncateID(imageID) truncatedImageID := stringid.TruncateID(imageID)
dockerCmd(c, "create", imageID) dockerCmd(c, "create", imageID)
@ -444,16 +436,14 @@ RUN chmod 755 /entrypoint.sh
ENTRYPOINT ["/entrypoint.sh"] ENTRYPOINT ["/entrypoint.sh"]
CMD echo foobar` CMD echo foobar`
ctx, err := fakeContext(dockerfile, map[string]string{ ctx := fakeContext(c, dockerfile, map[string]string{
"entrypoint.sh": `#!/bin/sh "entrypoint.sh": `#!/bin/sh
echo "I am an entrypoint" echo "I am an entrypoint"
exec "$@"`, exec "$@"`,
}) })
c.Assert(err, check.IsNil)
defer ctx.Close() defer ctx.Close()
_, err = buildImageFromContext(name, ctx, true) buildImageSuccessfully(c, name, withExternalBuildContext(ctx))
c.Assert(err, check.IsNil)
out, _ := dockerCmd(c, "create", "--entrypoint=", name, "echo", "foo") out, _ := dockerCmd(c, "create", "--entrypoint=", name, "echo", "foo")
id := strings.TrimSpace(out) id := strings.TrimSpace(out)

18
integration-cli/docker_cli_events_test.go
View file

@ -379,11 +379,9 @@ func (s *DockerSuite) TestEventsFilterImageLabels(c *check.C) {
label := "io.docker.testing=image" label := "io.docker.testing=image"
// Build a test image. // Build a test image.
_, err := buildImage(name, fmt.Sprintf(` buildImageSuccessfully(c, name, withDockerfile(fmt.Sprintf(`
FROM busybox:latest FROM busybox:latest
LABEL %s`, label), true) LABEL %s`, label)))
c.Assert(err, checker.IsNil, check.Commentf("Couldn't create image"))
dockerCmd(c, "tag", name, "labelfiltertest:tag1") dockerCmd(c, "tag", name, "labelfiltertest:tag1")
dockerCmd(c, "tag", name, "labelfiltertest:tag2") dockerCmd(c, "tag", name, "labelfiltertest:tag2")
dockerCmd(c, "tag", "busybox:latest", "labelfiltertest:tag3") dockerCmd(c, "tag", "busybox:latest", "labelfiltertest:tag3")
@ -462,10 +460,10 @@ func (s *DockerSuite) TestEventsCommit(c *check.C) {
func (s *DockerSuite) TestEventsCopy(c *check.C) { func (s *DockerSuite) TestEventsCopy(c *check.C) {
// Build a test image. // Build a test image.
id, err := buildImage("cpimg", ` buildImageSuccessfully(c, "cpimg", withDockerfile(`
FROM busybox FROM busybox
RUN echo HI > /file`, true) RUN echo HI > /file`))
c.Assert(err, checker.IsNil, check.Commentf("Couldn't create image")) id := getIDByName(c, "cpimg")
// Create an empty test file. // Create an empty test file.
tempFile, err := ioutil.TempFile("", "test-events-copy-") tempFile, err := ioutil.TempFile("", "test-events-copy-")
@ -595,11 +593,9 @@ func (s *DockerSuite) TestEventsFilterType(c *check.C) {
label := "io.docker.testing=image" label := "io.docker.testing=image"
// Build a test image. // Build a test image.
_, err := buildImage(name, fmt.Sprintf(` buildImageSuccessfully(c, name, withDockerfile(fmt.Sprintf(`
FROM busybox:latest FROM busybox:latest
LABEL %s`, label), true) LABEL %s`, label)))
c.Assert(err, checker.IsNil, check.Commentf("Couldn't create image"))
dockerCmd(c, "tag", name, "labelfiltertest:tag1") dockerCmd(c, "tag", name, "labelfiltertest:tag1")
dockerCmd(c, "tag", name, "labelfiltertest:tag2") dockerCmd(c, "tag", name, "labelfiltertest:tag2")
dockerCmd(c, "tag", "busybox:latest", "labelfiltertest:tag3") dockerCmd(c, "tag", "busybox:latest", "labelfiltertest:tag3")

8
integration-cli/docker_cli_events_unix_test.go
View file

@ -310,11 +310,9 @@ func (s *DockerSuite) TestEventsImageUntagDelete(c *check.C) {
defer observer.Stop() defer observer.Stop()
name := "testimageevents" name := "testimageevents"
imageID, err := buildImage(name, buildImageSuccessfully(c, name, withDockerfile(`FROM scratch
`FROM scratch MAINTAINER "docker"`))
MAINTAINER "docker"`, imageID := getIDByName(c, name)
true)
c.Assert(err, checker.IsNil)
c.Assert(deleteImages(name), checker.IsNil) c.Assert(deleteImages(name), checker.IsNil)
testActions := map[string]chan bool{ testActions := map[string]chan bool{

8
integration-cli/docker_cli_exec_test.go
View file

@ -473,13 +473,9 @@ func (s *DockerSuite) TestExecWithImageUser(c *check.C) {
// Not applicable on Windows // Not applicable on Windows
testRequires(c, DaemonIsLinux) testRequires(c, DaemonIsLinux)
name := "testbuilduser" name := "testbuilduser"
_, err := buildImage(name, buildImageSuccessfully(c, name, withDockerfile(`FROM busybox
`FROM busybox
RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd
USER dockerio`, USER dockerio`))
true)
c.Assert(err, checker.IsNil)
dockerCmd(c, "run", "-d", "--name", "dockerioexec", name, "top") dockerCmd(c, "run", "-d", "--name", "dockerioexec", name, "top")
out, _ := dockerCmd(c, "exec", "dockerioexec", "whoami") out, _ := dockerCmd(c, "exec", "dockerioexec", "whoami")

21
integration-cli/docker_cli_health_test.go
View file

@ -40,16 +40,12 @@ func (s *DockerSuite) TestHealth(c *check.C) {
testRequires(c, DaemonIsLinux) // busybox doesn't work on Windows testRequires(c, DaemonIsLinux) // busybox doesn't work on Windows
imageName := "testhealth" imageName := "testhealth"
_, err := buildImage(imageName, buildImageSuccessfully(c, imageName, withDockerfile(`FROM busybox
`FROM busybox
RUN echo OK > /status RUN echo OK > /status
CMD ["/bin/sleep", "120"] CMD ["/bin/sleep", "120"]
STOPSIGNAL SIGKILL STOPSIGNAL SIGKILL
HEALTHCHECK --interval=1s --timeout=30s \ HEALTHCHECK --interval=1s --timeout=30s \
CMD cat /status`, CMD cat /status`))
true)
c.Check(err, check.IsNil)
// No health status before starting // No health status before starting
name := "test_health" name := "test_health"
@ -91,10 +87,8 @@ func (s *DockerSuite) TestHealth(c *check.C) {
dockerCmd(c, "rm", "noh") dockerCmd(c, "rm", "noh")
// Disable the check with a new build // Disable the check with a new build
_, err = buildImage("no_healthcheck", buildImageSuccessfully(c, "no_healthcheck", withDockerfile(`FROM testhealth
`FROM testhealth HEALTHCHECK NONE`))
HEALTHCHECK NONE`, true)
c.Check(err, check.IsNil)
out, _ = dockerCmd(c, "inspect", "--format={{.ContainerConfig.Healthcheck.Test}}", "no_healthcheck") out, _ = dockerCmd(c, "inspect", "--format={{.ContainerConfig.Healthcheck.Test}}", "no_healthcheck")
c.Check(out, checker.Equals, "[NONE]\n") c.Check(out, checker.Equals, "[NONE]\n")
@ -137,15 +131,12 @@ func (s *DockerSuite) TestHealth(c *check.C) {
dockerCmd(c, "rm", "-f", "test") dockerCmd(c, "rm", "-f", "test")
// Check JSON-format // Check JSON-format
_, err = buildImage(imageName, buildImageSuccessfully(c, imageName, withDockerfile(`FROM busybox
`FROM busybox
RUN echo OK > /status RUN echo OK > /status
CMD ["/bin/sleep", "120"] CMD ["/bin/sleep", "120"]
STOPSIGNAL SIGKILL STOPSIGNAL SIGKILL
HEALTHCHECK --interval=1s --timeout=30s \ HEALTHCHECK --interval=1s --timeout=30s \
CMD ["cat", "/my status"]`, CMD ["cat", "/my status"]`))
true)
c.Check(err, check.IsNil)
out, _ = dockerCmd(c, "inspect", out, _ = dockerCmd(c, "inspect",
"--format={{.Config.Healthcheck.Test}}", imageName) "--format={{.Config.Healthcheck.Test}}", imageName)
c.Check(out, checker.Equals, "[CMD cat /my status]\n") c.Check(out, checker.Equals, "[CMD cat /my status]\n")

9
integration-cli/docker_cli_history_test.go
View file

@ -14,7 +14,7 @@ import (
// sort is not predictable it doesn't always fail. // sort is not predictable it doesn't always fail.
func (s *DockerSuite) TestBuildHistory(c *check.C) { func (s *DockerSuite) TestBuildHistory(c *check.C) {
name := "testbuildhistory" name := "testbuildhistory"
_, err := buildImage(name, `FROM `+minimalBaseImage()+` buildImageSuccessfully(c, name, withDockerfile(`FROM `+minimalBaseImage()+`
LABEL label.A="A" LABEL label.A="A"
LABEL label.B="B" LABEL label.B="B"
LABEL label.C="C" LABEL label.C="C"
@ -40,12 +40,9 @@ LABEL label.V="V"
LABEL label.W="W" LABEL label.W="W"
LABEL label.X="X" LABEL label.X="X"
LABEL label.Y="Y" LABEL label.Y="Y"
LABEL label.Z="Z"`, LABEL label.Z="Z"`))
true)
c.Assert(err, checker.IsNil) out, _ := dockerCmd(c, "history", name)
out, _ := dockerCmd(c, "history", "testbuildhistory")
actualValues := strings.Split(out, "\n")[1:27] actualValues := strings.Split(out, "\n")[1:27]
expectedValues := [26]string{"Z", "Y", "X", "W", "V", "U", "T", "S", "R", "Q", "P", "O", "N", "M", "L", "K", "J", "I", "H", "G", "F", "E", "D", "C", "B", "A"} expectedValues := [26]string{"Z", "Y", "X", "W", "V", "U", "T", "S", "R", "Q", "P", "O", "N", "M", "L", "K", "J", "I", "H", "G", "F", "E", "D", "C", "B", "A"}

95
integration-cli/docker_cli_images_test.go
View file

@ -12,6 +12,7 @@ import (
"github.com/docker/docker/integration-cli/checker" "github.com/docker/docker/integration-cli/checker"
"github.com/docker/docker/pkg/stringid" "github.com/docker/docker/pkg/stringid"
icmd "github.com/docker/docker/pkg/testutil/cmd"
"github.com/go-check/check" "github.com/go-check/check"
) )
@ -45,20 +46,17 @@ func (s *DockerSuite) TestImagesEnsureImageWithBadTagIsNotListed(c *check.C) {
} }
func (s *DockerSuite) TestImagesOrderedByCreationDate(c *check.C) { func (s *DockerSuite) TestImagesOrderedByCreationDate(c *check.C) {
id1, err := buildImage("order:test_a", buildImageSuccessfully(c, "order:test_a", withDockerfile(`FROM busybox
`FROM busybox MAINTAINER dockerio1`))
MAINTAINER dockerio1`, true) id1 := getIDByName(c, "order:test_a")
c.Assert(err, checker.IsNil)
time.Sleep(1 * time.Second) time.Sleep(1 * time.Second)
id2, err := buildImage("order:test_c", buildImageSuccessfully(c, "order:test_c", withDockerfile(`FROM busybox
`FROM busybox MAINTAINER dockerio2`))
MAINTAINER dockerio2`, true) id2 := getIDByName(c, "order:test_c")
c.Assert(err, checker.IsNil)
time.Sleep(1 * time.Second) time.Sleep(1 * time.Second)
id3, err := buildImage("order:test_b", buildImageSuccessfully(c, "order:test_b", withDockerfile(`FROM busybox
`FROM busybox MAINTAINER dockerio3`))
MAINTAINER dockerio3`, true) id3 := getIDByName(c, "order:test_b")
c.Assert(err, checker.IsNil)
out, _ := dockerCmd(c, "images", "-q", "--no-trunc") out, _ := dockerCmd(c, "images", "-q", "--no-trunc")
imgs := strings.Split(out, "\n") imgs := strings.Split(out, "\n")
@ -77,20 +75,17 @@ func (s *DockerSuite) TestImagesFilterLabelMatch(c *check.C) {
imageName1 := "images_filter_test1" imageName1 := "images_filter_test1"
imageName2 := "images_filter_test2" imageName2 := "images_filter_test2"
imageName3 := "images_filter_test3" imageName3 := "images_filter_test3"
image1ID, err := buildImage(imageName1, buildImageSuccessfully(c, imageName1, withDockerfile(`FROM busybox
`FROM busybox LABEL match me`))
LABEL match me`, true) image1ID := getIDByName(c, imageName1)
c.Assert(err, check.IsNil)
image2ID, err := buildImage(imageName2, buildImageSuccessfully(c, imageName2, withDockerfile(`FROM busybox
`FROM busybox LABEL match="me too"`))
LABEL match="me too"`, true) image2ID := getIDByName(c, imageName2)
c.Assert(err, check.IsNil)
image3ID, err := buildImage(imageName3, buildImageSuccessfully(c, imageName3, withDockerfile(`FROM busybox
`FROM busybox LABEL nomatch me`))
LABEL nomatch me`, true) image3ID := getIDByName(c, imageName3)
c.Assert(err, check.IsNil)
out, _ := dockerCmd(c, "images", "--no-trunc", "-q", "-f", "label=match") out, _ := dockerCmd(c, "images", "--no-trunc", "-q", "-f", "label=match")
out = strings.TrimSpace(out) out = strings.TrimSpace(out)
@ -117,15 +112,15 @@ func (s *DockerSuite) TestImagesFilterLabelWithCommit(c *check.C) {
} }
func (s *DockerSuite) TestImagesFilterSinceAndBefore(c *check.C) { func (s *DockerSuite) TestImagesFilterSinceAndBefore(c *check.C) {
imageID1, err := buildImage("image:1", `FROM `+minimalBaseImage()+` buildImageSuccessfully(c, "image:1", withDockerfile(`FROM `+minimalBaseImage()+`
LABEL number=1`, true) LABEL number=1`))
c.Assert(err, checker.IsNil) imageID1 := getIDByName(c, "image:1")
imageID2, err := buildImage("image:2", `FROM `+minimalBaseImage()+` buildImageSuccessfully(c, "image:2", withDockerfile(`FROM `+minimalBaseImage()+`
LABEL number=2`, true) LABEL number=2`))
c.Assert(err, checker.IsNil) imageID2 := getIDByName(c, "image:2")
imageID3, err := buildImage("image:3", `FROM `+minimalBaseImage()+` buildImageSuccessfully(c, "image:3", withDockerfile(`FROM `+minimalBaseImage()+`
LABEL number=3`, true) LABEL number=3`))
c.Assert(err, checker.IsNil) imageID3 := getIDByName(c, "image:3")
expected := []string{imageID3, imageID2} expected := []string{imageID3, imageID2}
@ -185,13 +180,16 @@ func assertImageList(out string, expected []string) bool {
return true return true
} }
// FIXME(vdemeester) should be a unit test on `docker image ls`
func (s *DockerSuite) TestImagesFilterSpaceTrimCase(c *check.C) { func (s *DockerSuite) TestImagesFilterSpaceTrimCase(c *check.C) {
imageName := "images_filter_test" imageName := "images_filter_test"
buildImage(imageName, // Build a image and fail to build so that we have dangling images ?
`FROM busybox buildImage(imageName, withDockerfile(`FROM busybox
RUN touch /test/foo RUN touch /test/foo
RUN touch /test/bar RUN touch /test/bar
RUN touch /test/baz`, true) RUN touch /test/baz`)).Assert(c, icmd.Expected{
ExitCode: 1,
})
filters := []string{ filters := []string{
"dangling=true", "dangling=true",
@ -250,6 +248,7 @@ func (s *DockerSuite) TestImagesEnsureDanglingImageOnlyListedOnce(c *check.C) {
} }
// FIXME(vdemeester) should be a unit test for `docker image ls`
func (s *DockerSuite) TestImagesWithIncorrectFilter(c *check.C) { func (s *DockerSuite) TestImagesWithIncorrectFilter(c *check.C) {
out, _, err := dockerCmdWithError("images", "-f", "dangling=invalid") out, _, err := dockerCmdWithError("images", "-f", "dangling=invalid")
c.Assert(err, check.NotNil) c.Assert(err, check.NotNil)
@ -261,32 +260,33 @@ func (s *DockerSuite) TestImagesEnsureOnlyHeadsImagesShown(c *check.C) {
FROM busybox FROM busybox
MAINTAINER docker MAINTAINER docker
ENV foo bar` ENV foo bar`
name := "scratch-image"
head, out, err := buildImageWithOut("scratch-image", dockerfile, false) result := buildImage(name, withDockerfile(dockerfile))
c.Assert(err, check.IsNil) result.Assert(c, icmd.Success)
id := getIDByName(c, name)
// this is just the output of docker build // this is just the output of docker build
// we're interested in getting the image id of the MAINTAINER instruction // we're interested in getting the image id of the MAINTAINER instruction
// and that's located at output, line 5, from 7 to end // and that's located at output, line 5, from 7 to end
split := strings.Split(out, "\n") split := strings.Split(result.Combined(), "\n")
intermediate := strings.TrimSpace(split[5][7:]) intermediate := strings.TrimSpace(split[5][7:])
out, _ = dockerCmd(c, "images") out, _ := dockerCmd(c, "images")
// images shouldn't show non-heads images // images shouldn't show non-heads images
c.Assert(out, checker.Not(checker.Contains), intermediate) c.Assert(out, checker.Not(checker.Contains), intermediate)
// images should contain final built images // images should contain final built images
c.Assert(out, checker.Contains, stringid.TruncateID(head)) c.Assert(out, checker.Contains, stringid.TruncateID(id))
} }
func (s *DockerSuite) TestImagesEnsureImagesFromScratchShown(c *check.C) { func (s *DockerSuite) TestImagesEnsureImagesFromScratchShown(c *check.C) {
testRequires(c, DaemonIsLinux) // Windows does not support FROM scratch testRequires(c, DaemonIsLinux) // Windows does not support FROM scratch
dockerfile := ` dockerfile := `
FROM scratch FROM scratch
MAINTAINER docker` MAINTAINER docker`
id, _, err := buildImageWithOut("scratch-image", dockerfile, false) name := "scratch-image"
c.Assert(err, check.IsNil) buildImageSuccessfully(c, name, withDockerfile(dockerfile))
id := getIDByName(c, name)
out, _ := dockerCmd(c, "images") out, _ := dockerCmd(c, "images")
// images should contain images built from scratch // images should contain images built from scratch
@ -299,9 +299,10 @@ func (s *DockerSuite) TestImagesEnsureImagesFromBusyboxShown(c *check.C) {
dockerfile := ` dockerfile := `
FROM busybox FROM busybox
MAINTAINER docker` MAINTAINER docker`
name := "busybox-image"
id, _, err := buildImageWithOut("busybox-image", dockerfile, false) buildImageSuccessfully(c, name, withDockerfile(dockerfile))
c.Assert(err, check.IsNil) id := getIDByName(c, name)
out, _ := dockerCmd(c, "images") out, _ := dockerCmd(c, "images")
// images should contain images built from busybox // images should contain images built from busybox

3
integration-cli/docker_cli_logs_test.go
View file

@ -130,8 +130,7 @@ func (s *DockerSuite) TestLogsTail(c *check.C) {
func (s *DockerSuite) TestLogsFollowStopped(c *check.C) { func (s *DockerSuite) TestLogsFollowStopped(c *check.C) {
dockerCmd(c, "run", "--name=test", "busybox", "echo", "hello") dockerCmd(c, "run", "--name=test", "busybox", "echo", "hello")
id, err := getIDByName("test") id := getIDByName(c, "test")
c.Assert(err, check.IsNil)
logsCmd := exec.Command(dockerBinary, "logs", "-f", id) logsCmd := exec.Command(dockerBinary, "logs", "-f", id)
c.Assert(logsCmd.Start(), checker.IsNil) c.Assert(logsCmd.Start(), checker.IsNil)

66
integration-cli/docker_cli_ps_test.go
View file

@ -157,8 +157,7 @@ func (s *DockerSuite) TestPsListContainersSize(c *check.C) {
name := "test_size" name := "test_size"
dockerCmd(c, "run", "--name", name, "busybox", "sh", "-c", "echo 1 > test") dockerCmd(c, "run", "--name", name, "busybox", "sh", "-c", "echo 1 > test")
id, err := getIDByName(name) id := getIDByName(c, name)
c.Assert(err, checker.IsNil)
runCmd := exec.Command(dockerBinary, "ps", "-s", "-n=1") runCmd := exec.Command(dockerBinary, "ps", "-s", "-n=1")
var out string var out string
@ -286,8 +285,7 @@ func (s *DockerSuite) TestPsListContainersFilterID(c *check.C) {
func (s *DockerSuite) TestPsListContainersFilterName(c *check.C) { func (s *DockerSuite) TestPsListContainersFilterName(c *check.C) {
// start container // start container
dockerCmd(c, "run", "--name=a_name_to_match", "busybox") dockerCmd(c, "run", "--name=a_name_to_match", "busybox")
id, err := getIDByName("a_name_to_match") id := getIDByName(c, "a_name_to_match")
c.Assert(err, check.IsNil)
// start another container // start another container
runSleepingContainer(c, "--name=b_name_to_match") runSleepingContainer(c, "--name=b_name_to_match")
@ -309,47 +307,39 @@ func (s *DockerSuite) TestPsListContainersFilterName(c *check.C) {
func (s *DockerSuite) TestPsListContainersFilterAncestorImage(c *check.C) { func (s *DockerSuite) TestPsListContainersFilterAncestorImage(c *check.C) {
// Build images // Build images
imageName1 := "images_ps_filter_test1" imageName1 := "images_ps_filter_test1"
imageID1, err := buildImage(imageName1, buildImageSuccessfully(c, imageName1, withDockerfile(`FROM busybox
`FROM busybox LABEL match me 1`))
LABEL match me 1`, true) imageID1 := getIDByName(c, imageName1)
c.Assert(err, checker.IsNil)
imageName1Tagged := "images_ps_filter_test1:tag" imageName1Tagged := "images_ps_filter_test1:tag"
imageID1Tagged, err := buildImage(imageName1Tagged, buildImageSuccessfully(c, imageName1Tagged, withDockerfile(`FROM busybox
`FROM busybox LABEL match me 1 tagged`))
LABEL match me 1 tagged`, true) imageID1Tagged := getIDByName(c, imageName1Tagged)
c.Assert(err, checker.IsNil)
imageName2 := "images_ps_filter_test2" imageName2 := "images_ps_filter_test2"
imageID2, err := buildImage(imageName2, buildImageSuccessfully(c, imageName2, withDockerfile(fmt.Sprintf(`FROM %s
fmt.Sprintf(`FROM %s LABEL match me 2`, imageName1)))
LABEL match me 2`, imageName1), true) imageID2 := getIDByName(c, imageName2)
c.Assert(err, checker.IsNil)
// start containers // start containers
dockerCmd(c, "run", "--name=first", "busybox", "echo", "hello") dockerCmd(c, "run", "--name=first", "busybox", "echo", "hello")
firstID, err := getIDByName("first") firstID := getIDByName(c, "first")
c.Assert(err, check.IsNil)
// start another container // start another container
dockerCmd(c, "run", "--name=second", "busybox", "echo", "hello") dockerCmd(c, "run", "--name=second", "busybox", "echo", "hello")
secondID, err := getIDByName("second") secondID := getIDByName(c, "second")
c.Assert(err, check.IsNil)
// start third container // start third container
dockerCmd(c, "run", "--name=third", imageName1, "echo", "hello") dockerCmd(c, "run", "--name=third", imageName1, "echo", "hello")
thirdID, err := getIDByName("third") thirdID := getIDByName(c, "third")
c.Assert(err, check.IsNil)
// start fourth container // start fourth container
dockerCmd(c, "run", "--name=fourth", imageName1Tagged, "echo", "hello") dockerCmd(c, "run", "--name=fourth", imageName1Tagged, "echo", "hello")
fourthID, err := getIDByName("fourth") fourthID := getIDByName(c, "fourth")
c.Assert(err, check.IsNil)
// start fifth container // start fifth container
dockerCmd(c, "run", "--name=fifth", imageName2, "echo", "hello") dockerCmd(c, "run", "--name=fifth", imageName2, "echo", "hello")
fifthID, err := getIDByName("fifth") fifthID := getIDByName(c, "fifth")
c.Assert(err, check.IsNil)
var filterTestSuite = []struct { var filterTestSuite = []struct {
filterName string filterName string
@ -410,18 +400,15 @@ func checkPsAncestorFilterOutput(c *check.C, out string, filterName string, expe
func (s *DockerSuite) TestPsListContainersFilterLabel(c *check.C) { func (s *DockerSuite) TestPsListContainersFilterLabel(c *check.C) {
// start container // start container
dockerCmd(c, "run", "--name=first", "-l", "match=me", "-l", "second=tag", "busybox") dockerCmd(c, "run", "--name=first", "-l", "match=me", "-l", "second=tag", "busybox")
firstID, err := getIDByName("first") firstID := getIDByName(c, "first")
c.Assert(err, check.IsNil)
// start another container // start another container
dockerCmd(c, "run", "--name=second", "-l", "match=me too", "busybox") dockerCmd(c, "run", "--name=second", "-l", "match=me too", "busybox")
secondID, err := getIDByName("second") secondID := getIDByName(c, "second")
c.Assert(err, check.IsNil)
// start third container // start third container
dockerCmd(c, "run", "--name=third", "-l", "nomatch=me", "busybox") dockerCmd(c, "run", "--name=third", "-l", "nomatch=me", "busybox")
thirdID, err := getIDByName("third") thirdID := getIDByName(c, "third")
c.Assert(err, check.IsNil)
// filter containers by exact match // filter containers by exact match
out, _ := dockerCmd(c, "ps", "-a", "-q", "--no-trunc", "--filter=label=match=me") out, _ := dockerCmd(c, "ps", "-a", "-q", "--no-trunc", "--filter=label=match=me")
@ -450,23 +437,19 @@ func (s *DockerSuite) TestPsListContainersFilterExited(c *check.C) {
runSleepingContainer(c, "--name=sleep") runSleepingContainer(c, "--name=sleep")
dockerCmd(c, "run", "--name", "zero1", "busybox", "true") dockerCmd(c, "run", "--name", "zero1", "busybox", "true")
firstZero, err := getIDByName("zero1") firstZero := getIDByName(c, "zero1")
c.Assert(err, checker.IsNil)
dockerCmd(c, "run", "--name", "zero2", "busybox", "true") dockerCmd(c, "run", "--name", "zero2", "busybox", "true")
secondZero, err := getIDByName("zero2") secondZero := getIDByName(c, "zero2")
c.Assert(err, checker.IsNil)
out, _, err := dockerCmdWithError("run", "--name", "nonzero1", "busybox", "false") out, _, err := dockerCmdWithError("run", "--name", "nonzero1", "busybox", "false")
c.Assert(err, checker.NotNil, check.Commentf("Should fail.", out, err)) c.Assert(err, checker.NotNil, check.Commentf("Should fail.", out, err))
firstNonZero, err := getIDByName("nonzero1") firstNonZero := getIDByName(c, "nonzero1")
c.Assert(err, checker.IsNil)
out, _, err = dockerCmdWithError("run", "--name", "nonzero2", "busybox", "false") out, _, err = dockerCmdWithError("run", "--name", "nonzero2", "busybox", "false")
c.Assert(err, checker.NotNil, check.Commentf("Should fail.", out, err)) c.Assert(err, checker.NotNil, check.Commentf("Should fail.", out, err))
secondNonZero, err := getIDByName("nonzero2") secondNonZero := getIDByName(c, "nonzero2")
c.Assert(err, checker.IsNil)
// filter containers by exited=0 // filter containers by exited=0
out, _ = dockerCmd(c, "ps", "-a", "-q", "--no-trunc", "--filter=exited=0") out, _ = dockerCmd(c, "ps", "-a", "-q", "--no-trunc", "--filter=exited=0")
@ -671,8 +654,7 @@ func (s *DockerSuite) TestPsImageIDAfterUpdate(c *check.C) {
icmd.RunCommand(dockerBinary, "tag", "busybox:latest", originalImageName).Assert(c, icmd.Success) icmd.RunCommand(dockerBinary, "tag", "busybox:latest", originalImageName).Assert(c, icmd.Success)
originalImageID, err := getIDByName(originalImageName) originalImageID := getIDByName(c, originalImageName)
c.Assert(err, checker.IsNil)
result := icmd.RunCommand(dockerBinary, append([]string{"run", "-d", originalImageName}, sleepCommandForDaemonPlatform()...)...) result := icmd.RunCommand(dockerBinary, append([]string{"run", "-d", originalImageName}, sleepCommandForDaemonPlatform()...)...)
result.Assert(c, icmd.Success) result.Assert(c, icmd.Success)

44
integration-cli/docker_cli_pull_local_test.go
View file

@ -65,14 +65,13 @@ func testConcurrentPullWholeRepo(c *check.C) {
repos := []string{} repos := []string{}
for _, tag := range []string{"recent", "fresh", "todays"} { for _, tag := range []string{"recent", "fresh", "todays"} {
repo := fmt.Sprintf("%v:%v", repoName, tag) repo := fmt.Sprintf("%v:%v", repoName, tag)
_, err := buildImage(repo, fmt.Sprintf(` buildImageSuccessfully(c, repo, withDockerfile(fmt.Sprintf(`
FROM busybox FROM busybox
ENTRYPOINT ["/bin/echo"] ENTRYPOINT ["/bin/echo"]
ENV FOO foo ENV FOO foo
ENV BAR bar ENV BAR bar
CMD echo %s CMD echo %s
`, repo), true) `, repo)))
c.Assert(err, checker.IsNil)
dockerCmd(c, "push", repo) dockerCmd(c, "push", repo)
repos = append(repos, repo) repos = append(repos, repo)
} }
@ -154,14 +153,13 @@ func testConcurrentPullMultipleTags(c *check.C) {
repos := []string{} repos := []string{}
for _, tag := range []string{"recent", "fresh", "todays"} { for _, tag := range []string{"recent", "fresh", "todays"} {
repo := fmt.Sprintf("%v:%v", repoName, tag) repo := fmt.Sprintf("%v:%v", repoName, tag)
_, err := buildImage(repo, fmt.Sprintf(` buildImageSuccessfully(c, repo, withDockerfile(fmt.Sprintf(`
FROM busybox FROM busybox
ENTRYPOINT ["/bin/echo"] ENTRYPOINT ["/bin/echo"]
ENV FOO foo ENV FOO foo
ENV BAR bar ENV BAR bar
CMD echo %s CMD echo %s
`, repo), true) `, repo)))
c.Assert(err, checker.IsNil)
dockerCmd(c, "push", repo) dockerCmd(c, "push", repo)
repos = append(repos, repo) repos = append(repos, repo)
} }
@ -209,21 +207,15 @@ func testPullIDStability(c *check.C) {
derivedImage := privateRegistryURL + "/dockercli/id-stability" derivedImage := privateRegistryURL + "/dockercli/id-stability"
baseImage := "busybox" baseImage := "busybox"
_, err := buildImage(derivedImage, fmt.Sprintf(` buildImageSuccessfully(c, derivedImage, withDockerfile(fmt.Sprintf(`
FROM %s FROM %s
ENV derived true ENV derived true
ENV asdf true ENV asdf true
RUN dd if=/dev/zero of=/file bs=1024 count=1024 RUN dd if=/dev/zero of=/file bs=1024 count=1024
CMD echo %s CMD echo %s
`, baseImage, derivedImage), true) `, baseImage, derivedImage)))
if err != nil {
c.Fatal(err)
}
originalID, err := getIDByName(derivedImage) originalID := getIDByName(c, derivedImage)
if err != nil {
c.Fatalf("error inspecting: %v", err)
}
dockerCmd(c, "push", derivedImage) dockerCmd(c, "push", derivedImage)
// Pull // Pull
@ -232,10 +224,7 @@ func testPullIDStability(c *check.C) {
c.Fatalf("repull redownloaded a layer: %s", out) c.Fatalf("repull redownloaded a layer: %s", out)
} }
derivedIDAfterPull, err := getIDByName(derivedImage) derivedIDAfterPull := getIDByName(c, derivedImage)
if err != nil {
c.Fatalf("error inspecting: %v", err)
}
if derivedIDAfterPull != originalID { if derivedIDAfterPull != originalID {
c.Fatal("image's ID unexpectedly changed after a repush/repull") c.Fatal("image's ID unexpectedly changed after a repush/repull")
@ -252,17 +241,11 @@ func testPullIDStability(c *check.C) {
dockerCmd(c, "rmi", derivedImage) dockerCmd(c, "rmi", derivedImage)
dockerCmd(c, "pull", derivedImage) dockerCmd(c, "pull", derivedImage)
derivedIDAfterPull, err = getIDByName(derivedImage) derivedIDAfterPull = getIDByName(c, derivedImage)
if err != nil {
c.Fatalf("error inspecting: %v", err)
}
if derivedIDAfterPull != originalID { if derivedIDAfterPull != originalID {
c.Fatal("image's ID unexpectedly changed after a repush/repull") c.Fatal("image's ID unexpectedly changed after a repush/repull")
} }
if err != nil {
c.Fatalf("error inspecting: %v", err)
}
// Make sure the image still runs // Make sure the image still runs
out, _ = dockerCmd(c, "run", "--rm", derivedImage) out, _ = dockerCmd(c, "run", "--rm", derivedImage)
@ -283,14 +266,9 @@ func (s *DockerSchema1RegistrySuite) TestPullIDStability(c *check.C) {
func testPullNoLayers(c *check.C) { func testPullNoLayers(c *check.C) {
repoName := fmt.Sprintf("%v/dockercli/scratch", privateRegistryURL) repoName := fmt.Sprintf("%v/dockercli/scratch", privateRegistryURL)
_, err := buildImage(repoName, ` buildImageSuccessfully(c, repoName, withDockerfile(`
FROM scratch FROM scratch
ENV foo bar`, ENV foo bar`))
true)
if err != nil {
c.Fatal(err)
}
dockerCmd(c, "push", repoName) dockerCmd(c, "push", repoName)
dockerCmd(c, "rmi", repoName) dockerCmd(c, "rmi", repoName)
dockerCmd(c, "pull", repoName) dockerCmd(c, "pull", repoName)

7
integration-cli/docker_cli_pull_trusted_test.go
View file

@ -149,11 +149,10 @@ func (s *DockerTrustSuite) TestTrustedOfflinePull(c *check.C) {
func (s *DockerTrustSuite) TestTrustedPullDelete(c *check.C) { func (s *DockerTrustSuite) TestTrustedPullDelete(c *check.C) {
repoName := fmt.Sprintf("%v/dockercli/%s:latest", privateRegistryURL, "trusted-pull-delete") repoName := fmt.Sprintf("%v/dockercli/%s:latest", privateRegistryURL, "trusted-pull-delete")
// tag the image and upload it to the private registry // tag the image and upload it to the private registry
_, err := buildImage(repoName, ` buildImageSuccessfully(c, repoName, withDockerfile(`
FROM busybox FROM busybox
CMD echo trustedpulldelete CMD echo trustedpulldelete
`, true) `))
icmd.RunCmd(icmd.Command(dockerBinary, "push", repoName), trustedCmd).Assert(c, SuccessSigningAndPushing) icmd.RunCmd(icmd.Command(dockerBinary, "push", repoName), trustedCmd).Assert(c, SuccessSigningAndPushing)
dockerCmd(c, "rmi", repoName) dockerCmd(c, "rmi", repoName)
@ -176,7 +175,7 @@ func (s *DockerTrustSuite) TestTrustedPullDelete(c *check.C) {
// rmi of tag should also remove the digest reference // rmi of tag should also remove the digest reference
dockerCmd(c, "rmi", repoName) dockerCmd(c, "rmi", repoName)
_, err = inspectFieldWithError(imageByDigest, "Id") _, err := inspectFieldWithError(imageByDigest, "Id")
c.Assert(err, checker.NotNil, check.Commentf("digest reference should have been removed")) c.Assert(err, checker.NotNil, check.Commentf("digest reference should have been removed"))
_, err = inspectFieldWithError(imageID, "Id") _, err = inspectFieldWithError(imageID, "Id")

5
integration-cli/docker_cli_push_test.go
View file

@ -161,14 +161,13 @@ func testConcurrentPush(c *check.C) {
repos := []string{} repos := []string{}
for _, tag := range []string{"push1", "push2", "push3"} { for _, tag := range []string{"push1", "push2", "push3"} {
repo := fmt.Sprintf("%v:%v", repoName, tag) repo := fmt.Sprintf("%v:%v", repoName, tag)
_, err := buildImage(repo, fmt.Sprintf(` buildImageSuccessfully(c, repo, withDockerfile(fmt.Sprintf(`
FROM busybox FROM busybox
ENTRYPOINT ["/bin/echo"] ENTRYPOINT ["/bin/echo"]
ENV FOO foo ENV FOO foo
ENV BAR bar ENV BAR bar
CMD echo %s CMD echo %s
`, repo), true) `, repo)))
c.Assert(err, checker.IsNil)
repos = append(repos, repo) repos = append(repos, repo)
} }

5
integration-cli/docker_cli_restart_test.go
View file

@ -12,8 +12,7 @@ import (
func (s *DockerSuite) TestRestartStoppedContainer(c *check.C) { func (s *DockerSuite) TestRestartStoppedContainer(c *check.C) {
dockerCmd(c, "run", "--name=test", "busybox", "echo", "foobar") dockerCmd(c, "run", "--name=test", "busybox", "echo", "foobar")
cleanedContainerID, err := getIDByName("test") cleanedContainerID := getIDByName(c, "test")
c.Assert(err, check.IsNil)
out, _ := dockerCmd(c, "logs", cleanedContainerID) out, _ := dockerCmd(c, "logs", cleanedContainerID)
c.Assert(out, checker.Equals, "foobar\n") c.Assert(out, checker.Equals, "foobar\n")
@ -21,7 +20,7 @@ func (s *DockerSuite) TestRestartStoppedContainer(c *check.C) {
dockerCmd(c, "restart", cleanedContainerID) dockerCmd(c, "restart", cleanedContainerID)
// Wait until the container has stopped // Wait until the container has stopped
err = waitInspect(cleanedContainerID, "{{.State.Running}}", "false", 20*time.Second) err := waitInspect(cleanedContainerID, "{{.State.Running}}", "false", 20*time.Second)
c.Assert(err, checker.IsNil) c.Assert(err, checker.IsNil)
out, _ = dockerCmd(c, "logs", cleanedContainerID) out, _ = dockerCmd(c, "logs", cleanedContainerID)

7
integration-cli/docker_cli_rm_test.go
View file

@ -58,13 +58,12 @@ func (s *DockerSuite) TestRmContainerOrphaning(c *check.C) {
MAINTAINER Integration Tests` MAINTAINER Integration Tests`
// build first dockerfile // build first dockerfile
img1, err := buildImage(img, dockerfile1, true) buildImageSuccessfully(c, img, withDockerfile(dockerfile1))
c.Assert(err, check.IsNil, check.Commentf("Could not build image %s", img)) img1 := getIDByName(c, img)
// run container on first image // run container on first image
dockerCmd(c, "run", img) dockerCmd(c, "run", img)
// rebuild dockerfile with a small addition at the end // rebuild dockerfile with a small addition at the end
_, err = buildImage(img, dockerfile2, true) buildImageSuccessfully(c, img, withDockerfile(dockerfile2))
c.Assert(err, check.IsNil, check.Commentf("Could not rebuild image %s", img))
// try to remove the image, should not error out. // try to remove the image, should not error out.
out, _, err := dockerCmdWithError("rmi", img) out, _, err := dockerCmdWithError("rmi", img)
c.Assert(err, check.IsNil, check.Commentf("Expected to removing the image, but failed: %s", out)) c.Assert(err, check.IsNil, check.Commentf("Expected to removing the image, but failed: %s", out))

29
integration-cli/docker_cli_rmi_test.go
View file

@ -147,8 +147,8 @@ func (s *DockerSuite) TestRmiImgIDForce(c *check.C) {
// See https://github.com/docker/docker/issues/14116 // See https://github.com/docker/docker/issues/14116
func (s *DockerSuite) TestRmiImageIDForceWithRunningContainersAndMultipleTags(c *check.C) { func (s *DockerSuite) TestRmiImageIDForceWithRunningContainersAndMultipleTags(c *check.C) {
dockerfile := "FROM busybox\nRUN echo test 14116\n" dockerfile := "FROM busybox\nRUN echo test 14116\n"
imgID, err := buildImage("test-14116", dockerfile, false) buildImageSuccessfully(c, "test-14116", withDockerfile(dockerfile))
c.Assert(err, checker.IsNil) imgID := getIDByName(c, "test-14116")
newTag := "newtag" newTag := "newtag"
dockerCmd(c, "tag", imgID, newTag) dockerCmd(c, "tag", imgID, newTag)
@ -205,14 +205,8 @@ func (s *DockerSuite) TestRmiForceWithMultipleRepositories(c *check.C) {
tag1 := imageName + ":tag1" tag1 := imageName + ":tag1"
tag2 := imageName + ":tag2" tag2 := imageName + ":tag2"
_, err := buildImage(tag1, buildImageSuccessfully(c, tag1, withDockerfile(`FROM busybox
`FROM busybox MAINTAINER "docker"`))
MAINTAINER "docker"`,
true)
if err != nil {
c.Fatal(err)
}
dockerCmd(c, "tag", tag1, tag2) dockerCmd(c, "tag", tag1, tag2)
out, _ := dockerCmd(c, "rmi", "-f", tag2) out, _ := dockerCmd(c, "rmi", "-f", tag2)
@ -240,8 +234,8 @@ func (s *DockerSuite) TestRmiContainerImageNotFound(c *check.C) {
imageIds := make([]string, 2) imageIds := make([]string, 2)
for i, name := range imageNames { for i, name := range imageNames {
dockerfile := fmt.Sprintf("FROM busybox\nMAINTAINER %s\nRUN echo %s\n", name, name) dockerfile := fmt.Sprintf("FROM busybox\nMAINTAINER %s\nRUN echo %s\n", name, name)
id, err := buildImage(name, dockerfile, false) buildImageSuccessfully(c, name, withoutCache, withDockerfile(dockerfile))
c.Assert(err, checker.IsNil) id := getIDByName(c, name)
imageIds[i] = id imageIds[i] = id
} }
@ -269,9 +263,7 @@ RUN echo 0 #layer0
RUN echo 1 #layer1 RUN echo 1 #layer1
RUN echo 2 #layer2 RUN echo 2 #layer2
` `
_, err := buildImage(image, dockerfile, false) buildImageSuccessfully(c, image, withoutCache, withDockerfile(dockerfile))
c.Assert(err, checker.IsNil)
out, _ := dockerCmd(c, "history", "-q", image) out, _ := dockerCmd(c, "history", "-q", image)
ids := strings.Split(out, "\n") ids := strings.Split(out, "\n")
idToTag := ids[2] idToTag := ids[2]
@ -294,7 +286,7 @@ RUN echo 2 #layer2
// At this point we have 2 containers, one based on layer2 and another based on layer0. // At this point we have 2 containers, one based on layer2 and another based on layer0.
// Try to untag "tmp2" without the -f flag. // Try to untag "tmp2" without the -f flag.
out, _, err = dockerCmdWithError("rmi", newTag) out, _, err := dockerCmdWithError("rmi", newTag)
// should not be untagged without the -f flag // should not be untagged without the -f flag
c.Assert(err, checker.NotNil) c.Assert(err, checker.NotNil)
c.Assert(out, checker.Contains, cid[:12]) c.Assert(out, checker.Contains, cid[:12])
@ -307,10 +299,9 @@ RUN echo 2 #layer2
} }
func (*DockerSuite) TestRmiParentImageFail(c *check.C) { func (*DockerSuite) TestRmiParentImageFail(c *check.C) {
_, err := buildImage("test", ` buildImageSuccessfully(c, "test", withDockerfile(`
FROM busybox FROM busybox
RUN echo hello`, false) RUN echo hello`))
c.Assert(err, checker.IsNil)
id := inspectField(c, "busybox", "ID") id := inspectField(c, "busybox", "ID")
out, _, err := dockerCmdWithError("rmi", id) out, _, err := dockerCmdWithError("rmi", id)

115
integration-cli/docker_cli_run_test.go
View file

@ -410,10 +410,7 @@ func (s *DockerSuite) TestRunCreateVolumesInSymlinkDir(c *check.C) {
containerPath = "/test/test" containerPath = "/test/test"
cmd = "true" cmd = "true"
} }
if _, err := buildImage(name, dockerFile, false); err != nil { buildImageSuccessfully(c, name, withDockerfile(dockerFile))
c.Fatal(err)
}
dockerCmd(c, "run", "-v", containerPath, name, cmd) dockerCmd(c, "run", "-v", containerPath, name, cmd)
} }
@ -438,10 +435,7 @@ func (s *DockerSuite) TestRunCreateVolumesInSymlinkDir2(c *check.C) {
containerPath = "/test/test" containerPath = "/test/test"
cmd = "true" cmd = "true"
} }
if _, err := buildImage(name, dockerFile, false); err != nil { buildImageSuccessfully(c, name, withDockerfile(dockerFile))
c.Fatal(err)
}
dockerCmd(c, "run", "-v", containerPath, name, cmd) dockerCmd(c, "run", "-v", containerPath, name, cmd)
} }
@ -1409,10 +1403,7 @@ func (s *DockerSuite) TestRunNonRootUserResolvName(c *check.C) {
dockerCmd(c, "run", "--name=testperm", "--user=nobody", "busybox", "nslookup", "apt.dockerproject.org") dockerCmd(c, "run", "--name=testperm", "--user=nobody", "busybox", "nslookup", "apt.dockerproject.org")
cID, err := getIDByName("testperm") cID := getIDByName(c, "testperm")
if err != nil {
c.Fatal(err)
}
fmode := (os.FileMode)(0644) fmode := (os.FileMode)(0644)
finfo, err := os.Stat(containerStorageFile(cID, "resolv.conf")) finfo, err := os.Stat(containerStorageFile(cID, "resolv.conf"))
@ -1462,10 +1453,7 @@ func (s *DockerSuite) TestRunResolvconfUpdate(c *check.C) {
//1. test that a restarting container gets an updated resolv.conf //1. test that a restarting container gets an updated resolv.conf
dockerCmd(c, "run", "--name=first", "busybox", "true") dockerCmd(c, "run", "--name=first", "busybox", "true")
containerID1, err := getIDByName("first") containerID1 := getIDByName(c, "first")
if err != nil {
c.Fatal(err)
}
// replace resolv.conf with our temporary copy // replace resolv.conf with our temporary copy
bytesResolvConf := []byte(tmpResolvConf) bytesResolvConf := []byte(tmpResolvConf)
@ -1492,10 +1480,7 @@ func (s *DockerSuite) TestRunResolvconfUpdate(c *check.C) {
//2. test that a restarting container does not receive resolv.conf updates //2. test that a restarting container does not receive resolv.conf updates
// if it modified the container copy of the starting point resolv.conf // if it modified the container copy of the starting point resolv.conf
dockerCmd(c, "run", "--name=second", "busybox", "sh", "-c", "echo 'search mylittlepony.com' >>/etc/resolv.conf") dockerCmd(c, "run", "--name=second", "busybox", "sh", "-c", "echo 'search mylittlepony.com' >>/etc/resolv.conf")
containerID2, err := getIDByName("second") containerID2 := getIDByName(c, "second")
if err != nil {
c.Fatal(err)
}
//make a change to resolv.conf (in this case replacing our tmp copy with orig copy) //make a change to resolv.conf (in this case replacing our tmp copy with orig copy)
if err := ioutil.WriteFile("/etc/resolv.conf", resolvConfSystem, 0644); err != nil { if err := ioutil.WriteFile("/etc/resolv.conf", resolvConfSystem, 0644); err != nil {
@ -1581,10 +1566,7 @@ func (s *DockerSuite) TestRunResolvconfUpdate(c *check.C) {
// Run the container so it picks up the old settings // Run the container so it picks up the old settings
dockerCmd(c, "run", "--name=third", "busybox", "true") dockerCmd(c, "run", "--name=third", "busybox", "true")
containerID3, err := getIDByName("third") containerID3 := getIDByName(c, "third")
if err != nil {
c.Fatal(err)
}
// Create a modified resolv.conf.aside and override resolv.conf with it // Create a modified resolv.conf.aside and override resolv.conf with it
bytesResolvConf = []byte(tmpResolvConf) bytesResolvConf = []byte(tmpResolvConf)
@ -1698,15 +1680,10 @@ func (s *DockerSuite) TestRunCopyVolumeUIDGID(c *check.C) {
// Not applicable on Windows as it does not support uid or gid in this way // Not applicable on Windows as it does not support uid or gid in this way
testRequires(c, DaemonIsLinux) testRequires(c, DaemonIsLinux)
name := "testrunvolumesuidgid" name := "testrunvolumesuidgid"
_, err := buildImage(name, buildImageSuccessfully(c, name, withDockerfile(`FROM busybox
`FROM busybox
RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd
RUN echo 'dockerio:x:1001:' >> /etc/group RUN echo 'dockerio:x:1001:' >> /etc/group
RUN mkdir -p /hello && touch /hello/test && chown dockerio.dockerio /hello`, RUN mkdir -p /hello && touch /hello/test && chown dockerio.dockerio /hello`))
true)
if err != nil {
c.Fatal(err)
}
// Test that the uid and gid is copied from the image to the volume // Test that the uid and gid is copied from the image to the volume
out, _ := dockerCmd(c, "run", "--rm", "-v", "/hello", name, "sh", "-c", "ls -l / | grep hello | awk '{print $3\":\"$4}'") out, _ := dockerCmd(c, "run", "--rm", "-v", "/hello", name, "sh", "-c", "ls -l / | grep hello | awk '{print $3\":\"$4}'")
@ -1722,13 +1699,8 @@ func (s *DockerSuite) TestRunCopyVolumeContent(c *check.C) {
// that copies from the image to the volume. // that copies from the image to the volume.
testRequires(c, DaemonIsLinux) testRequires(c, DaemonIsLinux)
name := "testruncopyvolumecontent" name := "testruncopyvolumecontent"
_, err := buildImage(name, buildImageSuccessfully(c, name, withDockerfile(`FROM busybox
`FROM busybox RUN mkdir -p /hello/local && echo hello > /hello/local/world`))
RUN mkdir -p /hello/local && echo hello > /hello/local/world`,
true)
if err != nil {
c.Fatal(err)
}
// Test that the content is copied from the image to the volume // Test that the content is copied from the image to the volume
out, _ := dockerCmd(c, "run", "--rm", "-v", "/hello", name, "find", "/hello") out, _ := dockerCmd(c, "run", "--rm", "-v", "/hello", name, "find", "/hello")
@ -1739,13 +1711,9 @@ func (s *DockerSuite) TestRunCopyVolumeContent(c *check.C) {
func (s *DockerSuite) TestRunCleanupCmdOnEntrypoint(c *check.C) { func (s *DockerSuite) TestRunCleanupCmdOnEntrypoint(c *check.C) {
name := "testrunmdcleanuponentrypoint" name := "testrunmdcleanuponentrypoint"
if _, err := buildImage(name, buildImageSuccessfully(c, name, withDockerfile(`FROM busybox
`FROM busybox
ENTRYPOINT ["echo"] ENTRYPOINT ["echo"]
CMD ["testingpoint"]`, CMD ["testingpoint"]`))
true); err != nil {
c.Fatal(err)
}
out, exit := dockerCmd(c, "run", "--entrypoint", "whoami", name) out, exit := dockerCmd(c, "run", "--entrypoint", "whoami", name)
if exit != 0 { if exit != 0 {
@ -1879,9 +1847,7 @@ func testRunWriteSpecialFilesAndNotCommit(c *check.C, name, path string) {
func eqToBaseDiff(out string, c *check.C) bool { func eqToBaseDiff(out string, c *check.C) bool {
name := "eqToBaseDiff" + stringutils.GenerateRandomAlphaOnlyString(32) name := "eqToBaseDiff" + stringutils.GenerateRandomAlphaOnlyString(32)
dockerCmd(c, "run", "--name", name, "busybox", "echo", "hello") dockerCmd(c, "run", "--name", name, "busybox", "echo", "hello")
cID, err := getIDByName(name) cID := getIDByName(c, name)
c.Assert(err, check.IsNil)
baseDiff, _ := dockerCmd(c, "diff", cID) baseDiff, _ := dockerCmd(c, "diff", cID)
baseArr := strings.Split(baseDiff, "\n") baseArr := strings.Split(baseDiff, "\n")
sort.Strings(baseArr) sort.Strings(baseArr)
@ -2229,14 +2195,9 @@ func (s *DockerSuite) TestVolumesNoCopyData(c *check.C) {
// are pre-populated such as is built in the dockerfile used in this test. // are pre-populated such as is built in the dockerfile used in this test.
testRequires(c, DaemonIsLinux) testRequires(c, DaemonIsLinux)
prefix, slash := getPrefixAndSlashFromDaemonPlatform() prefix, slash := getPrefixAndSlashFromDaemonPlatform()
if _, err := buildImage("dataimage", buildImageSuccessfully(c, "dataimage", withDockerfile(`FROM busybox
`FROM busybox
RUN ["mkdir", "-p", "/foo"] RUN ["mkdir", "-p", "/foo"]
RUN ["touch", "/foo/bar"]`, RUN ["touch", "/foo/bar"]`))
true); err != nil {
c.Fatal(err)
}
dockerCmd(c, "run", "--name", "test", "-v", prefix+slash+"foo", "busybox") dockerCmd(c, "run", "--name", "test", "-v", prefix+slash+"foo", "busybox")
if out, _, err := dockerCmdWithError("run", "--volumes-from", "test", "dataimage", "ls", "-lh", "/foo/bar"); err == nil || !strings.Contains(out, "No such file or directory") { if out, _, err := dockerCmdWithError("run", "--volumes-from", "test", "dataimage", "ls", "-lh", "/foo/bar"); err == nil || !strings.Contains(out, "No such file or directory") {
@ -2265,13 +2226,8 @@ func (s *DockerSuite) TestRunNoOutputFromPullInStdout(c *check.C) {
func (s *DockerSuite) TestRunVolumesCleanPaths(c *check.C) { func (s *DockerSuite) TestRunVolumesCleanPaths(c *check.C) {
testRequires(c, SameHostDaemon) testRequires(c, SameHostDaemon)
prefix, slash := getPrefixAndSlashFromDaemonPlatform() prefix, slash := getPrefixAndSlashFromDaemonPlatform()
if _, err := buildImage("run_volumes_clean_paths", buildImageSuccessfully(c, "run_volumes_clean_paths", withDockerfile(`FROM busybox
`FROM busybox VOLUME `+prefix+`/foo/`))
VOLUME `+prefix+`/foo/`,
true); err != nil {
c.Fatal(err)
}
dockerCmd(c, "run", "-v", prefix+"/foo", "-v", prefix+"/bar/", "--name", "dark_helmet", "run_volumes_clean_paths") dockerCmd(c, "run", "-v", prefix+"/foo", "-v", prefix+"/bar/", "--name", "dark_helmet", "run_volumes_clean_paths")
out, err := inspectMountSourceField("dark_helmet", prefix+slash+"foo"+slash) out, err := inspectMountSourceField("dark_helmet", prefix+slash+"foo"+slash)
@ -3444,8 +3400,7 @@ func testRunContainerWithCgroupParent(c *check.C, cgroupParent, name string) {
if len(cgroupPaths) == 0 { if len(cgroupPaths) == 0 {
c.Fatalf("unexpected output - %q", string(out)) c.Fatalf("unexpected output - %q", string(out))
} }
id, err := getIDByName(name) id := getIDByName(c, name)
c.Assert(err, check.IsNil)
expectedCgroup := path.Join(cgroupParent, id) expectedCgroup := path.Join(cgroupParent, id)
found := false found := false
for _, path := range cgroupPaths { for _, path := range cgroupPaths {
@ -3485,8 +3440,7 @@ func testRunInvalidCgroupParent(c *check.C, cgroupParent, cleanCgroupParent, nam
if len(cgroupPaths) == 0 { if len(cgroupPaths) == 0 {
c.Fatalf("unexpected output - %q", string(out)) c.Fatalf("unexpected output - %q", string(out))
} }
id, err := getIDByName(name) id := getIDByName(c, name)
c.Assert(err, check.IsNil)
expectedCgroup := path.Join(cleanCgroupParent, id) expectedCgroup := path.Join(cleanCgroupParent, id)
found := false found := false
for _, path := range cgroupPaths { for _, path := range cgroupPaths {
@ -3919,15 +3873,10 @@ func (s *DockerSuite) TestRunInitLayerPathOwnership(c *check.C) {
// Not applicable on Windows as it does not support Linux uid/gid ownership // Not applicable on Windows as it does not support Linux uid/gid ownership
testRequires(c, DaemonIsLinux) testRequires(c, DaemonIsLinux)
name := "testetcfileownership" name := "testetcfileownership"
_, err := buildImage(name, buildImageSuccessfully(c, name, withDockerfile(`FROM busybox
`FROM busybox
RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd
RUN echo 'dockerio:x:1001:' >> /etc/group RUN echo 'dockerio:x:1001:' >> /etc/group
RUN chown dockerio:dockerio /etc`, RUN chown dockerio:dockerio /etc`))
true)
if err != nil {
c.Fatal(err)
}
// Test that dockerio ownership of /etc is retained at runtime // Test that dockerio ownership of /etc is retained at runtime
out, _ := dockerCmd(c, "run", "--rm", name, "stat", "-c", "%U:%G", "/etc") out, _ := dockerCmd(c, "run", "--rm", name, "stat", "-c", "%U:%G", "/etc")
@ -4056,11 +4005,10 @@ func (s *DockerSuite) TestRunNamedVolumeCopyImageData(c *check.C) {
testRequires(c, DaemonIsLinux) testRequires(c, DaemonIsLinux)
testImg := "testvolumecopy" testImg := "testvolumecopy"
_, err := buildImage(testImg, ` buildImageSuccessfully(c, testImg, withDockerfile(`
FROM busybox FROM busybox
RUN mkdir -p /foo && echo hello > /foo/hello RUN mkdir -p /foo && echo hello > /foo/hello
`, true) `))
c.Assert(err, check.IsNil)
dockerCmd(c, "run", "-v", "foo:/foo", testImg) dockerCmd(c, "run", "-v", "foo:/foo", testImg)
out, _ := dockerCmd(c, "run", "-v", "foo:/foo", "busybox", "cat", "/foo/hello") out, _ := dockerCmd(c, "run", "-v", "foo:/foo", "busybox", "cat", "/foo/hello")
@ -4136,14 +4084,9 @@ func (s *DockerSuite) TestRunVolumeWithOneCharacter(c *check.C) {
func (s *DockerSuite) TestRunVolumeCopyFlag(c *check.C) { func (s *DockerSuite) TestRunVolumeCopyFlag(c *check.C) {
testRequires(c, DaemonIsLinux) // Windows does not support copying data from image to the volume testRequires(c, DaemonIsLinux) // Windows does not support copying data from image to the volume
_, err := buildImage("volumecopy", buildImageSuccessfully(c, "volumecopy", withDockerfile(`FROM busybox
`FROM busybox
RUN mkdir /foo && echo hello > /foo/bar RUN mkdir /foo && echo hello > /foo/bar
CMD cat /foo/bar`, CMD cat /foo/bar`))
true,
)
c.Assert(err, checker.IsNil)
dockerCmd(c, "volume", "create", "test") dockerCmd(c, "volume", "create", "test")
// test with the nocopy flag // test with the nocopy flag
@ -4232,22 +4175,20 @@ RUN chmod 755 /entrypoint.sh
ENTRYPOINT ["/entrypoint.sh"] ENTRYPOINT ["/entrypoint.sh"]
CMD echo foobar` CMD echo foobar`
ctx, err := fakeContext(dockerfile, map[string]string{ ctx := fakeContext(c, dockerfile, map[string]string{
"entrypoint.sh": `#!/bin/sh "entrypoint.sh": `#!/bin/sh
echo "I am an entrypoint" echo "I am an entrypoint"
exec "$@"`, exec "$@"`,
}) })
c.Assert(err, check.IsNil)
defer ctx.Close() defer ctx.Close()
_, err = buildImageFromContext(name, ctx, true) buildImageSuccessfully(c, name, withExternalBuildContext(ctx))
c.Assert(err, check.IsNil)
out, _ := dockerCmd(c, "run", "--entrypoint=", "-t", name, "echo", "foo") out, _ := dockerCmd(c, "run", "--entrypoint=", "-t", name, "echo", "foo")
c.Assert(strings.TrimSpace(out), check.Equals, "foo") c.Assert(strings.TrimSpace(out), check.Equals, "foo")
// CMD will be reset as well (the same as setting a custom entrypoint) // CMD will be reset as well (the same as setting a custom entrypoint)
_, _, err = dockerCmdWithError("run", "--entrypoint=", "-t", name) _, _, err := dockerCmdWithError("run", "--entrypoint=", "-t", name)
c.Assert(err, check.NotNil) c.Assert(err, check.NotNil)
c.Assert(err.Error(), checker.Contains, "No command specified") c.Assert(err.Error(), checker.Contains, "No command specified")
} }

10
integration-cli/docker_cli_run_unix_test.go
View file

@ -828,17 +828,11 @@ func (s *DockerSuite) TestRunTmpfsMounts(c *check.C) {
func (s *DockerSuite) TestRunTmpfsMountsOverrideImageVolumes(c *check.C) { func (s *DockerSuite) TestRunTmpfsMountsOverrideImageVolumes(c *check.C) {
name := "img-with-volumes" name := "img-with-volumes"
_, err := buildImage( buildImageSuccessfully(c, name, withDockerfile(`
name,
`
FROM busybox FROM busybox
VOLUME /run VOLUME /run
RUN touch /run/stuff RUN touch /run/stuff
`, `))
true)
if err != nil {
c.Fatal(err)
}
out, _ := dockerCmd(c, "run", "--tmpfs", "/run", name, "ls", "/run") out, _ := dockerCmd(c, "run", "--tmpfs", "/run", name, "ls", "/run")
c.Assert(out, checker.Not(checker.Contains), "stuff") c.Assert(out, checker.Not(checker.Contains), "stuff")
} }

11
integration-cli/docker_cli_save_load_test.go
View file

@ -260,12 +260,9 @@ func (s *DockerSuite) TestSaveDirectoryPermissions(c *check.C) {
os.Mkdir(extractionDirectory, 0777) os.Mkdir(extractionDirectory, 0777)
defer os.RemoveAll(tmpDir) defer os.RemoveAll(tmpDir)
_, err = buildImage(name, buildImageSuccessfully(c, name, withDockerfile(`FROM busybox
`FROM busybox
RUN adduser -D user && mkdir -p /opt/a/b && chown -R user:user /opt/a RUN adduser -D user && mkdir -p /opt/a/b && chown -R user:user /opt/a
RUN touch /opt/a/b/c && chown user:user /opt/a/b/c`, RUN touch /opt/a/b/c && chown user:user /opt/a/b/c`))
true)
c.Assert(err, checker.IsNil, check.Commentf("%v", err))
out, _, err := testutil.RunCommandPipelineWithOutput( out, _, err := testutil.RunCommandPipelineWithOutput(
exec.Command(dockerBinary, "save", name), exec.Command(dockerBinary, "save", name),
@ -358,9 +355,7 @@ func (s *DockerSuite) TestSaveLoadNoTag(c *check.C) {
name := "saveloadnotag" name := "saveloadnotag"
_, err := buildImage(name, "FROM busybox\nENV foo=bar", true) buildImageSuccessfully(c, name, withDockerfile("FROM busybox\nENV foo=bar"))
c.Assert(err, checker.IsNil, check.Commentf("%v", err))
id := inspectField(c, name, "Id") id := inspectField(c, name, "Id")
// Test to make sure that save w/o name just shows imageID during load // Test to make sure that save w/o name just shows imageID during load

6
integration-cli/docker_cli_save_load_unix_test.go
View file

@ -72,11 +72,9 @@ func (s *DockerSuite) TestSaveAndLoadRepoStdout(c *check.C) {
func (s *DockerSuite) TestSaveAndLoadWithProgressBar(c *check.C) { func (s *DockerSuite) TestSaveAndLoadWithProgressBar(c *check.C) {
name := "test-load" name := "test-load"
_, err := buildImage(name, ` buildImageSuccessfully(c, name, withDockerfile(`FROM busybox
FROM busybox
RUN touch aa RUN touch aa
`, true) `))
c.Assert(err, check.IsNil)
tmptar := name + ".tar" tmptar := name + ".tar"
dockerCmd(c, "save", "-o", tmptar, name) dockerCmd(c, "save", "-o", tmptar, name)

12
integration-cli/docker_cli_tag_test.go
View file

@ -142,13 +142,9 @@ func (s *DockerSuite) TestTagInvalidRepoName(c *check.C) {
// ensure tags cannot create ambiguity with image ids // ensure tags cannot create ambiguity with image ids
func (s *DockerSuite) TestTagTruncationAmbiguity(c *check.C) { func (s *DockerSuite) TestTagTruncationAmbiguity(c *check.C) {
imageID, err := buildImage("notbusybox:latest", buildImageSuccessfully(c, "notbusybox:latest", withDockerfile(`FROM busybox
`FROM busybox MAINTAINER dockerio`))
MAINTAINER dockerio`, imageID := getIDByName(c, "notbusybox:latest")
true)
if err != nil {
c.Fatal(err)
}
truncatedImageID := stringid.TruncateID(imageID) truncatedImageID := stringid.TruncateID(imageID)
truncatedTag := fmt.Sprintf("notbusybox:%s", truncatedImageID) truncatedTag := fmt.Sprintf("notbusybox:%s", truncatedImageID)
@ -159,7 +155,7 @@ func (s *DockerSuite) TestTagTruncationAmbiguity(c *check.C) {
c.Logf("Built image: %s", imageID) c.Logf("Built image: %s", imageID)
// test setting tag fails // test setting tag fails
_, _, err = dockerCmdWithError("tag", "busybox:latest", truncatedTag) _, _, err := dockerCmdWithError("tag", "busybox:latest", truncatedTag)
if err != nil { if err != nil {
c.Fatalf("Error tagging with an image id: %s", err) c.Fatalf("Error tagging with an image id: %s", err)
} }

303
integration-cli/docker_utils_test.go
View file

@ -368,52 +368,41 @@ func (f *FakeContext) Close() error {
return os.RemoveAll(f.Dir) return os.RemoveAll(f.Dir)
} }
func fakeContextFromNewTempDir() (*FakeContext, error) { func fakeContextFromNewTempDir(c *check.C) *FakeContext {
tmp, err := ioutil.TempDir("", "fake-context") tmp, err := ioutil.TempDir("", "fake-context")
if err != nil { c.Assert(err, checker.IsNil)
return nil, err
}
if err := os.Chmod(tmp, 0755); err != nil { if err := os.Chmod(tmp, 0755); err != nil {
return nil, err c.Fatal(err)
} }
return fakeContextFromDir(tmp), nil return fakeContextFromDir(tmp)
} }
func fakeContextFromDir(dir string) *FakeContext { func fakeContextFromDir(dir string) *FakeContext {
return &FakeContext{dir} return &FakeContext{dir}
} }
func fakeContextWithFiles(files map[string]string) (*FakeContext, error) { func fakeContextWithFiles(c *check.C, files map[string]string) *FakeContext {
ctx, err := fakeContextFromNewTempDir() ctx := fakeContextFromNewTempDir(c)
if err != nil {
return nil, err
}
for file, content := range files { for file, content := range files {
if err := ctx.Add(file, content); err != nil { if err := ctx.Add(file, content); err != nil {
ctx.Close() ctx.Close()
return nil, err c.Fatal(err)
} }
} }
return ctx, nil return ctx
} }
func fakeContextAddDockerfile(ctx *FakeContext, dockerfile string) error { func fakeContextAddDockerfile(c *check.C, ctx *FakeContext, dockerfile string) {
if err := ctx.Add("Dockerfile", dockerfile); err != nil { if err := ctx.Add("Dockerfile", dockerfile); err != nil {
ctx.Close() ctx.Close()
return err c.Fatal(err)
} }
return nil
} }
func fakeContext(dockerfile string, files map[string]string) (*FakeContext, error) { func fakeContext(c *check.C, dockerfile string, files map[string]string) *FakeContext {
ctx, err := fakeContextWithFiles(files) ctx := fakeContextWithFiles(c, files)
if err != nil { fakeContextAddDockerfile(c, ctx, dockerfile)
return nil, err return ctx
}
if err := fakeContextAddDockerfile(ctx, dockerfile); err != nil {
return nil, err
}
return ctx, nil
} }
// FakeStorage is a static file server. It might be running locally or remotely // FakeStorage is a static file server. It might be running locally or remotely
@ -424,34 +413,28 @@ type FakeStorage interface {
CtxDir() string CtxDir() string
} }
func fakeBinaryStorage(archives map[string]*bytes.Buffer) (FakeStorage, error) { func fakeBinaryStorage(c *check.C, archives map[string]*bytes.Buffer) FakeStorage {
ctx, err := fakeContextFromNewTempDir() ctx := fakeContextFromNewTempDir(c)
if err != nil {
return nil, err
}
for name, content := range archives { for name, content := range archives {
if err := ctx.addFile(name, content.Bytes()); err != nil { if err := ctx.addFile(name, content.Bytes()); err != nil {
return nil, err c.Fatal(err)
} }
} }
return fakeStorageWithContext(ctx) return fakeStorageWithContext(c, ctx)
} }
// fakeStorage returns either a local or remote (at daemon machine) file server // fakeStorage returns either a local or remote (at daemon machine) file server
func fakeStorage(files map[string]string) (FakeStorage, error) { func fakeStorage(c *check.C, files map[string]string) FakeStorage {
ctx, err := fakeContextWithFiles(files) ctx := fakeContextWithFiles(c, files)
if err != nil { return fakeStorageWithContext(c, ctx)
return nil, err
}
return fakeStorageWithContext(ctx)
} }
// fakeStorageWithContext returns either a local or remote (at daemon machine) file server // fakeStorageWithContext returns either a local or remote (at daemon machine) file server
func fakeStorageWithContext(ctx *FakeContext) (FakeStorage, error) { func fakeStorageWithContext(c *check.C, ctx *FakeContext) FakeStorage {
if testEnv.LocalDaemon() { if testEnv.LocalDaemon() {
return newLocalFakeStorage(ctx) return newLocalFakeStorage(c, ctx)
} }
return newRemoteFileServer(ctx) return newRemoteFileServer(c, ctx)
} }
// localFileStorage is a file storage on the running machine // localFileStorage is a file storage on the running machine
@ -473,13 +456,13 @@ func (s *localFileStorage) Close() error {
return s.FakeContext.Close() return s.FakeContext.Close()
} }
func newLocalFakeStorage(ctx *FakeContext) (*localFileStorage, error) { func newLocalFakeStorage(c *check.C, ctx *FakeContext) *localFileStorage {
handler := http.FileServer(http.Dir(ctx.Dir)) handler := http.FileServer(http.Dir(ctx.Dir))
server := httptest.NewServer(handler) server := httptest.NewServer(handler)
return &localFileStorage{ return &localFileStorage{
FakeContext: ctx, FakeContext: ctx,
Server: server, Server: server,
}, nil }
} }
// remoteFileServer is a containerized static file server started on the remote // remoteFileServer is a containerized static file server started on the remote
@ -517,58 +500,45 @@ func (f *remoteFileServer) Close() error {
return deleteContainer(false, f.container) return deleteContainer(false, f.container)
} }
func newRemoteFileServer(ctx *FakeContext) (*remoteFileServer, error) { func newRemoteFileServer(c *check.C, ctx *FakeContext) *remoteFileServer {
var ( var (
image = fmt.Sprintf("fileserver-img-%s", strings.ToLower(stringutils.GenerateRandomAlphaOnlyString(10))) image = fmt.Sprintf("fileserver-img-%s", strings.ToLower(stringutils.GenerateRandomAlphaOnlyString(10)))
container = fmt.Sprintf("fileserver-cnt-%s", strings.ToLower(stringutils.GenerateRandomAlphaOnlyString(10))) container = fmt.Sprintf("fileserver-cnt-%s", strings.ToLower(stringutils.GenerateRandomAlphaOnlyString(10)))
) )
if err := ensureHTTPServerImage(); err != nil { c.Assert(ensureHTTPServerImage(), checker.IsNil)
return nil, err
}
// Build the image // Build the image
if err := fakeContextAddDockerfile(ctx, `FROM httpserver fakeContextAddDockerfile(c, ctx, `FROM httpserver
COPY . /static`); err != nil { COPY . /static`)
return nil, fmt.Errorf("Cannot add Dockerfile to context: %v", err) buildImageSuccessfully(c, image, withoutCache, withExternalBuildContext(ctx))
}
if _, err := buildImageFromContext(image, ctx, false); err != nil {
return nil, fmt.Errorf("failed building file storage container image: %v", err)
}
// Start the container // Start the container
runCmd := exec.Command(dockerBinary, "run", "-d", "-P", "--name", container, image) dockerCmd(c, "run", "-d", "-P", "--name", container, image)
if out, ec, err := runCommandWithOutput(runCmd); err != nil {
return nil, fmt.Errorf("failed to start file storage container. ec=%v\nout=%s\nerr=%v", ec, out, err)
}
// Find out the system assigned port // Find out the system assigned port
out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "port", container, "80/tcp")) out, _ := dockerCmd(c, "port", container, "80/tcp")
if err != nil {
return nil, fmt.Errorf("failed to find container port: err=%v\nout=%s", err, out)
}
fileserverHostPort := strings.Trim(out, "\n") fileserverHostPort := strings.Trim(out, "\n")
_, port, err := net.SplitHostPort(fileserverHostPort) _, port, err := net.SplitHostPort(fileserverHostPort)
if err != nil { if err != nil {
return nil, fmt.Errorf("unable to parse file server host:port: %v", err) c.Fatalf("unable to parse file server host:port: %v", err)
} }
dockerHostURL, err := url.Parse(daemonHost()) dockerHostURL, err := url.Parse(daemonHost())
if err != nil { if err != nil {
return nil, fmt.Errorf("unable to parse daemon host URL: %v", err) c.Fatalf("unable to parse daemon host URL: %v", err)
} }
host, _, err := net.SplitHostPort(dockerHostURL.Host) host, _, err := net.SplitHostPort(dockerHostURL.Host)
if err != nil { if err != nil {
return nil, fmt.Errorf("unable to parse docker daemon host:port: %v", err) c.Fatalf("unable to parse docker daemon host:port: %v", err)
} }
return &remoteFileServer{ return &remoteFileServer{
container: container, container: container,
image: image, image: image,
host: fmt.Sprintf("%s:%s", host, port), host: fmt.Sprintf("%s:%s", host, port),
ctx: ctx}, nil ctx: ctx}
} }
func inspectFieldAndUnmarshall(c *check.C, name, field string, output interface{}) { func inspectFieldAndUnmarshall(c *check.C, name, field string, output interface{}) {
@ -671,51 +641,17 @@ func inspectImage(name, filter string) (string, error) {
return strings.TrimSpace(out), nil return strings.TrimSpace(out), nil
} }
func getIDByName(name string) (string, error) { func getIDByName(c *check.C, name string) string {
return inspectFieldWithError(name, "Id") id, err := inspectFieldWithError(name, "Id")
} c.Assert(err, checker.IsNil)
return id
// Deprecated
func buildImageCmd(name, dockerfile string, useCache bool, buildFlags ...string) *exec.Cmd {
return daemon.BuildImageCmdWithHost(dockerBinary, name, dockerfile, "", useCache, buildFlags...)
}
// Deprecated
func buildImageWithOut(name, dockerfile string, useCache bool, buildFlags ...string) (string, string, error) {
buildCmd := buildImageCmd(name, dockerfile, useCache, buildFlags...)
out, exitCode, err := runCommandWithOutput(buildCmd)
if err != nil || exitCode != 0 {
return "", out, fmt.Errorf("failed to build the image: %s", out)
}
id, err := getIDByName(name)
if err != nil {
return "", out, err
}
return id, out, nil
}
// Deprecated
func buildImageWithStdoutStderr(name, dockerfile string, useCache bool, buildFlags ...string) (string, string, string, error) {
buildCmd := buildImageCmd(name, dockerfile, useCache, buildFlags...)
result := icmd.RunCmd(transformCmd(buildCmd))
err := result.Error
exitCode := result.ExitCode
if err != nil || exitCode != 0 {
return "", result.Stdout(), result.Stderr(), fmt.Errorf("failed to build the image: %s", result.Combined())
}
id, err := getIDByName(name)
if err != nil {
return "", result.Stdout(), result.Stderr(), err
}
return id, result.Stdout(), result.Stderr(), nil
} }
func buildImageSuccessfully(c *check.C, name string, cmdOperators ...func(*icmd.Cmd) func()) { func buildImageSuccessfully(c *check.C, name string, cmdOperators ...func(*icmd.Cmd) func()) {
buildImageNew(name, cmdOperators...).Assert(c, icmd.Success) buildImage(name, cmdOperators...).Assert(c, icmd.Success)
} }
// FIXME(vdemeester) rename this buildImage once deprecated buildImage is no more func buildImage(name string, cmdOperators ...func(*icmd.Cmd) func()) *icmd.Result {
func buildImageNew(name string, cmdOperators ...func(*icmd.Cmd) func()) *icmd.Result {
cmd := icmd.Command(dockerBinary, "build", "-t", name) cmd := icmd.Command(dockerBinary, "build", "-t", name)
for _, op := range cmdOperators { for _, op := range cmdOperators {
deferFn := op(&cmd) deferFn := op(&cmd)
@ -733,11 +669,16 @@ func withBuildContextPath(path string) func(*icmd.Cmd) func() {
} }
} }
func withBuildContext(c *check.C, contextOperators ...func(*FakeContext) error) func(*icmd.Cmd) func() { func withExternalBuildContext(ctx *FakeContext) func(*icmd.Cmd) func() {
ctx, err := fakeContextFromNewTempDir() return func(cmd *icmd.Cmd) func() {
if err != nil { cmd.Dir = ctx.Dir
c.Fatalf("error creating build context : %v", err) cmd.Command = append(cmd.Command, ".")
return nil
} }
}
func withBuildContext(c *check.C, contextOperators ...func(*FakeContext) error) func(*icmd.Cmd) func() {
ctx := fakeContextFromNewTempDir(c)
for _, op := range contextOperators { for _, op := range contextOperators {
if err := op(ctx); err != nil { if err := op(ctx); err != nil {
c.Fatal(err) c.Fatal(err)
@ -796,108 +737,6 @@ func withEnvironmentVariales(envs ...string) func(cmd *icmd.Cmd) func() {
} }
} }
// Deprecated
func buildImage(name, dockerfile string, useCache bool, buildFlags ...string) (string, error) {
id, _, err := buildImageWithOut(name, dockerfile, useCache, buildFlags...)
return id, err
}
// Deprecated
func buildImageFromContext(name string, ctx *FakeContext, useCache bool, buildFlags ...string) (string, error) {
id, _, err := buildImageFromContextWithOut(name, ctx, useCache, buildFlags...)
if err != nil {
return "", err
}
return id, nil
}
// Deprecated
func buildImageFromContextWithOut(name string, ctx *FakeContext, useCache bool, buildFlags ...string) (string, string, error) {
args := []string{"build", "-t", name}
if !useCache {
args = append(args, "--no-cache")
}
args = append(args, buildFlags...)
args = append(args, ".")
result := icmd.RunCmd(icmd.Cmd{
Command: append([]string{dockerBinary}, args...),
Dir: ctx.Dir,
})
out := result.Combined()
if result.Error != nil || result.ExitCode != 0 {
return "", "", fmt.Errorf("failed to build the image: %s", out)
}
id, err := getIDByName(name)
if err != nil {
return "", "", err
}
return id, out, nil
}
// Deprecated
func buildImageFromContextWithStdoutStderr(name string, ctx *FakeContext, useCache bool, buildFlags ...string) (string, string, string, error) {
args := []string{"build", "-t", name}
if !useCache {
args = append(args, "--no-cache")
}
args = append(args, buildFlags...)
args = append(args, ".")
result := icmd.RunCmd(icmd.Cmd{
Command: append([]string{dockerBinary}, args...),
Dir: ctx.Dir,
})
exitCode := result.ExitCode
err := result.Error
if err != nil || exitCode != 0 {
return "", result.Stdout(), result.Stderr(), fmt.Errorf("failed to build the image: %s", result.Combined())
}
id, err := getIDByName(name)
if err != nil {
return "", result.Stdout(), result.Stderr(), err
}
return id, result.Stdout(), result.Stderr(), nil
}
// Deprecated
func buildImageFromGitWithStdoutStderr(name string, ctx *fakeGit, useCache bool, buildFlags ...string) (string, string, string, error) {
args := []string{"build", "-t", name}
if !useCache {
args = append(args, "--no-cache")
}
args = append(args, buildFlags...)
args = append(args, ctx.RepoURL)
result := icmd.RunCmd(icmd.Cmd{
Command: append([]string{dockerBinary}, args...),
})
exitCode := result.ExitCode
err := result.Error
if err != nil || exitCode != 0 {
return "", result.Stdout(), result.Stderr(), fmt.Errorf("failed to build the image: %s", result.Combined())
}
id, err := getIDByName(name)
if err != nil {
return "", result.Stdout(), result.Stderr(), err
}
return id, result.Stdout(), result.Stderr(), nil
}
// Deprecated
func buildImageFromPath(name, path string, useCache bool, buildFlags ...string) (string, error) {
args := []string{"build", "-t", name}
if !useCache {
args = append(args, "--no-cache")
}
args = append(args, buildFlags...)
args = append(args, path)
buildCmd := exec.Command(dockerBinary, args...)
out, exitCode, err := runCommandWithOutput(buildCmd)
if err != nil || exitCode != 0 {
return "", fmt.Errorf("failed to build the image: %s", out)
}
return getIDByName(name)
}
type gitServer interface { type gitServer interface {
URL() string URL() string
Close() error Close() error
@ -927,69 +766,63 @@ func (g *fakeGit) Close() {
os.RemoveAll(g.root) os.RemoveAll(g.root)
} }
func newFakeGit(name string, files map[string]string, enforceLocalServer bool) (*fakeGit, error) { func newFakeGit(c *check.C, name string, files map[string]string, enforceLocalServer bool) *fakeGit {
ctx, err := fakeContextWithFiles(files) ctx := fakeContextWithFiles(c, files)
if err != nil {
return nil, err
}
defer ctx.Close() defer ctx.Close()
curdir, err := os.Getwd() curdir, err := os.Getwd()
if err != nil { if err != nil {
return nil, err c.Fatal(err)
} }
defer os.Chdir(curdir) defer os.Chdir(curdir)
if output, err := exec.Command("git", "init", ctx.Dir).CombinedOutput(); err != nil { if output, err := exec.Command("git", "init", ctx.Dir).CombinedOutput(); err != nil {
return nil, fmt.Errorf("error trying to init repo: %s (%s)", err, output) c.Fatalf("error trying to init repo: %s (%s)", err, output)
} }
err = os.Chdir(ctx.Dir) err = os.Chdir(ctx.Dir)
if err != nil { if err != nil {
return nil, err c.Fatal(err)
} }
if output, err := exec.Command("git", "config", "user.name", "Fake User").CombinedOutput(); err != nil { if output, err := exec.Command("git", "config", "user.name", "Fake User").CombinedOutput(); err != nil {
return nil, fmt.Errorf("error trying to set 'user.name': %s (%s)", err, output) c.Fatalf("error trying to set 'user.name': %s (%s)", err, output)
} }
if output, err := exec.Command("git", "config", "user.email", "fake.user@example.com").CombinedOutput(); err != nil { if output, err := exec.Command("git", "config", "user.email", "fake.user@example.com").CombinedOutput(); err != nil {
return nil, fmt.Errorf("error trying to set 'user.email': %s (%s)", err, output) c.Fatalf("error trying to set 'user.email': %s (%s)", err, output)
} }
if output, err := exec.Command("git", "add", "*").CombinedOutput(); err != nil { if output, err := exec.Command("git", "add", "*").CombinedOutput(); err != nil {
return nil, fmt.Errorf("error trying to add files to repo: %s (%s)", err, output) c.Fatalf("error trying to add files to repo: %s (%s)", err, output)
} }
if output, err := exec.Command("git", "commit", "-a", "-m", "Initial commit").CombinedOutput(); err != nil { if output, err := exec.Command("git", "commit", "-a", "-m", "Initial commit").CombinedOutput(); err != nil {
return nil, fmt.Errorf("error trying to commit to repo: %s (%s)", err, output) c.Fatalf("error trying to commit to repo: %s (%s)", err, output)
} }
root, err := ioutil.TempDir("", "docker-test-git-repo") root, err := ioutil.TempDir("", "docker-test-git-repo")
if err != nil { if err != nil {
return nil, err c.Fatal(err)
} }
repoPath := filepath.Join(root, name+".git") repoPath := filepath.Join(root, name+".git")
if output, err := exec.Command("git", "clone", "--bare", ctx.Dir, repoPath).CombinedOutput(); err != nil { if output, err := exec.Command("git", "clone", "--bare", ctx.Dir, repoPath).CombinedOutput(); err != nil {
os.RemoveAll(root) os.RemoveAll(root)
return nil, fmt.Errorf("error trying to clone --bare: %s (%s)", err, output) c.Fatalf("error trying to clone --bare: %s (%s)", err, output)
} }
err = os.Chdir(repoPath) err = os.Chdir(repoPath)
if err != nil { if err != nil {
os.RemoveAll(root) os.RemoveAll(root)
return nil, err c.Fatal(err)
} }
if output, err := exec.Command("git", "update-server-info").CombinedOutput(); err != nil { if output, err := exec.Command("git", "update-server-info").CombinedOutput(); err != nil {
os.RemoveAll(root) os.RemoveAll(root)
return nil, fmt.Errorf("error trying to git update-server-info: %s (%s)", err, output) c.Fatalf("error trying to git update-server-info: %s (%s)", err, output)
} }
err = os.Chdir(curdir) err = os.Chdir(curdir)
if err != nil { if err != nil {
os.RemoveAll(root) os.RemoveAll(root)
return nil, err c.Fatal(err)
} }
var server gitServer var server gitServer
if !enforceLocalServer { if !enforceLocalServer {
// use fakeStorage server, which might be local or remote (at test daemon) // use fakeStorage server, which might be local or remote (at test daemon)
server, err = fakeStorageWithContext(fakeContextFromDir(root)) server = fakeStorageWithContext(c, fakeContextFromDir(root))
if err != nil {
return nil, fmt.Errorf("cannot start fake storage: %v", err)
}
} else { } else {
// always start a local http server on CLI test machine // always start a local http server on CLI test machine
httpServer := httptest.NewServer(http.FileServer(http.Dir(root))) httpServer := httptest.NewServer(http.FileServer(http.Dir(root)))
@ -999,7 +832,7 @@ func newFakeGit(name string, files map[string]string, enforceLocalServer bool) (
root: root, root: root,
server: server, server: server,
RepoURL: fmt.Sprintf("%s/%s.git", server.URL(), name), RepoURL: fmt.Sprintf("%s/%s.git", server.URL(), name),
}, nil }
} }
// Write `content` to the file at path `dst`, creating it if necessary, // Write `content` to the file at path `dst`, creating it if necessary,