package main

import (

"archive/tar"

"bytes"

"encoding/json"

"fmt"

"io/ioutil"

"os"

"os/exec"

"path/filepath"

"reflect"

"regexp"

"runtime"

"strconv"

"strings"

"text/template"

"time"

"github.com/docker/docker/builder/dockerfile/command"

"github.com/docker/docker/pkg/archive"

"github.com/docker/docker/pkg/integration/checker"

icmd "github.com/docker/docker/pkg/integration/cmd"

"github.com/docker/docker/pkg/stringutils"

"github.com/go-check/check"

)

func (s *DockerSuite) TestBuildJSONEmptyRun(c *check.C) {

name := "testbuildjsonemptyrun"

_, err := buildImage(

name,

`

FROM busybox

RUN []

`,

true)

if err != nil {

c.Fatal("error when dealing with a RUN statement with empty JSON array")

}

}

func (s *DockerSuite) TestBuildShCmdJSONEntrypoint(c *check.C) {

name := "testbuildshcmdjsonentrypoint"

_, err := buildImage(

name,

`

FROM busybox

ENTRYPOINT ["echo"]

CMD echo test

`,

true)

if err != nil {

c.Fatal(err)

}

out, _ := dockerCmd(c, "run", "--rm", name)

if daemonPlatform == "windows" {

if !strings.Contains(out, "cmd /S /C echo test") {

c.Fatalf("CMD did not contain cmd /S /C echo test : %q", out)

}

} else {

if strings.TrimSpace(out) != "/bin/sh -c echo test" {

c.Fatalf("CMD did not contain /bin/sh -c : %q", out)

}

}

}

func (s *DockerSuite) TestBuildEnvironmentReplacementUser(c *check.C) {

// Windows does not support FROM scratch or the USER command

testRequires(c, DaemonIsLinux)

name := "testbuildenvironmentreplacement"

_, err := buildImage(name, `

FROM scratch

ENV user foo

USER ${user}

`, true)

if err != nil {

c.Fatal(err)

}

res := inspectFieldJSON(c, name, "Config.User")

if res != `"foo"` {

c.Fatal("User foo from environment not in Config.User on image")

}

}

func (s *DockerSuite) TestBuildEnvironmentReplacementVolume(c *check.C) {

name := "testbuildenvironmentreplacement"

var volumePath string

if daemonPlatform == "windows" {

volumePath = "c:/quux"

} else {

volumePath = "/quux"

}

_, err := buildImage(name, `

FROM `+minimalBaseImage()+`

ENV volume `+volumePath+`

VOLUME ${volume}

`, true)

if err != nil {

c.Fatal(err)

}

res := inspectFieldJSON(c, name, "Config.Volumes")

var volumes map[string]interface{}

if err := json.Unmarshal([]byte(res), &volumes); err != nil {

c.Fatal(err)

}

if _, ok := volumes[volumePath]; !ok {

c.Fatal("Volume " + volumePath + " from environment not in Config.Volumes on image")

}

}

func (s *DockerSuite) TestBuildEnvironmentReplacementExpose(c *check.C) {

// Windows does not support FROM scratch or the EXPOSE command

testRequires(c, DaemonIsLinux)

name := "testbuildenvironmentreplacement"

_, err := buildImage(name, `

FROM scratch

ENV port 80

EXPOSE ${port}

ENV ports " 99 100 "

EXPOSE ${ports}

`, true)

if err != nil {

c.Fatal(err)

}

res := inspectFieldJSON(c, name, "Config.ExposedPorts")

var exposedPorts map[string]interface{}

if err := json.Unmarshal([]byte(res), &exposedPorts); err != nil {

c.Fatal(err)

}

exp := []int{80, 99, 100}

for _, p := range exp {

tmp := fmt.Sprintf("%d/tcp", p)

if _, ok := exposedPorts[tmp]; !ok {

c.Fatalf("Exposed port %d from environment not in Config.ExposedPorts on image", p)

}

}

}

func (s *DockerSuite) TestBuildEnvironmentReplacementWorkdir(c *check.C) {

name := "testbuildenvironmentreplacement"

_, err := buildImage(name, `

FROM busybox

ENV MYWORKDIR /work

RUN mkdir ${MYWORKDIR}

WORKDIR ${MYWORKDIR}

`, true)

if err != nil {

c.Fatal(err)

}

}

func (s *DockerSuite) TestBuildEnvironmentReplacementAddCopy(c *check.C) {

name := "testbuildenvironmentreplacement"

ctx, err := fakeContext(`

FROM `+minimalBaseImage()+`

ENV baz foo

ENV quux bar

ENV dot .

ENV fee fff

ENV gee ggg

ADD ${baz} ${dot}

COPY ${quux} ${dot}

ADD ${zzz:-${fee}} ${dot}

COPY ${zzz:-${gee}} ${dot}

`,

map[string]string{

"foo": "test1",

"bar": "test2",

"fff": "test3",

"ggg": "test4",

})

if err != nil {

c.Fatal(err)

}

defer ctx.Close()

if _, err := buildImageFromContext(name, ctx, true); err != nil {

c.Fatal(err)

}

}

func (s *DockerSuite) TestBuildEnvironmentReplacementEnv(c *check.C) {

// ENV expansions work differently in Windows

testRequires(c, DaemonIsLinux)

name := "testbuildenvironmentreplacement"

_, err := buildImage(name,

`

FROM busybox

ENV foo zzz

ENV bar ${foo}

ENV abc1='$foo'

ENV env1=$foo env2=${foo} env3="$foo" env4="${foo}"

RUN [ "$abc1" = '$foo' ] && (echo "$abc1" | grep -q foo)

ENV abc2="\$foo"

RUN [ "$abc2" = '$foo' ] && (echo "$abc2" | grep -q foo)

ENV abc3 '$foo'

RUN [ "$abc3" = '$foo' ] && (echo "$abc3" | grep -q foo)

ENV abc4 "\$foo"

RUN [ "$abc4" = '$foo' ] && (echo "$abc4" | grep -q foo)

`, true)

if err != nil {

c.Fatal(err)

}

res := inspectFieldJSON(c, name, "Config.Env")

envResult := []string{}

if err = json.Unmarshal([]byte(res), &envResult); err != nil {

c.Fatal(err)

}

found := false

envCount := 0

for _, env := range envResult {

parts := strings.SplitN(env, "=", 2)

if parts[0] == "bar" {

found = true

if parts[1] != "zzz" {

c.Fatalf("Could not find replaced var for env `bar`: got %q instead of `zzz`", parts[1])

}

} else if strings.HasPrefix(parts[0], "env") {

envCount++

if parts[1] != "zzz" {

c.Fatalf("%s should be 'foo' but instead its %q", parts[0], parts[1])

}

} else if strings.HasPrefix(parts[0], "env") {

envCount++

if parts[1] != "foo" {

c.Fatalf("%s should be 'foo' but instead its %q", parts[0], parts[1])

}

}

}

if !found {

c.Fatal("Never found the `bar` env variable")

}

if envCount != 4 {

c.Fatalf("Didn't find all env vars - only saw %d\n%s", envCount, envResult)

}

}

func (s *DockerSuite) TestBuildHandleEscapes(c *check.C) {

// The volume paths used in this test are invalid on Windows

testRequires(c, DaemonIsLinux)

name := "testbuildhandleescapes"

_, err := buildImage(name,

`

FROM scratch

ENV FOO bar

VOLUME ${FOO}

`, true)

if err != nil {

c.Fatal(err)

}

var result map[string]map[string]struct{}

res := inspectFieldJSON(c, name, "Config.Volumes")

if err = json.Unmarshal([]byte(res), &result); err != nil {

c.Fatal(err)

}

if _, ok := result["bar"]; !ok {

c.Fatalf("Could not find volume bar set from env foo in volumes table, got %q", result)

}

deleteImages(name)

_, err = buildImage(name,

`

FROM scratch

ENV FOO bar

VOLUME \${FOO}

`, true)

if err != nil {

c.Fatal(err)

}

res = inspectFieldJSON(c, name, "Config.Volumes")

if err = json.Unmarshal([]byte(res), &result); err != nil {

c.Fatal(err)

}

if _, ok := result["${FOO}"]; !ok {

c.Fatalf("Could not find volume ${FOO} set from env foo in volumes table, got %q", result)

}

deleteImages(name)

// this test in particular provides *7* backslashes and expects 6 to come back.

// Like above, the first escape is swallowed and the rest are treated as

// literals, this one is just less obvious because of all the character noise.

_, err = buildImage(name,

`

FROM scratch

ENV FOO bar

VOLUME \\\\\\\${FOO}

`, true)

if err != nil {

c.Fatal(err)

}

res = inspectFieldJSON(c, name, "Config.Volumes")

if err = json.Unmarshal([]byte(res), &result); err != nil {

c.Fatal(err)

}

if _, ok := result[`\\\${FOO}`]; !ok {

c.Fatalf(`Could not find volume \\\${FOO} set from env foo in volumes table, got %q`, result)

}

}

func (s *DockerSuite) TestBuildOnBuildLowercase(c *check.C) {

name := "testbuildonbuildlowercase"

name2 := "testbuildonbuildlowercase2"

_, err := buildImage(name,

`

FROM busybox

onbuild run echo quux

`, true)

if err != nil {

c.Fatal(err)

}

_, out, err := buildImageWithOut(name2, fmt.Sprintf(`

FROM %s

`, name), true)

if err != nil {

c.Fatal(err)

}

if !strings.Contains(out, "quux") {

c.Fatalf("Did not receive the expected echo text, got %s", out)

}

if strings.Contains(out, "ONBUILD ONBUILD") {

c.Fatalf("Got an ONBUILD ONBUILD error with no error: got %s", out)

}

}

func (s *DockerSuite) TestBuildEnvEscapes(c *check.C) {

// ENV expansions work differently in Windows

testRequires(c, DaemonIsLinux)

name := "testbuildenvescapes"

_, err := buildImage(name,

`

FROM busybox

ENV TEST foo

CMD echo \$

`,

true)

if err != nil {

c.Fatal(err)

}

out, _ := dockerCmd(c, "run", "-t", name)

if strings.TrimSpace(out) != "$" {

c.Fatalf("Env TEST was not overwritten with bar when foo was supplied to dockerfile: was %q", strings.TrimSpace(out))

}

}

func (s *DockerSuite) TestBuildEnvOverwrite(c *check.C) {

// ENV expansions work differently in Windows

testRequires(c, DaemonIsLinux)

name := "testbuildenvoverwrite"

_, err := buildImage(name,

`

FROM busybox

ENV TEST foo

CMD echo ${TEST}

`,

true)

if err != nil {

c.Fatal(err)

}

out, _ := dockerCmd(c, "run", "-e", "TEST=bar", "-t", name)

if strings.TrimSpace(out) != "bar" {

c.Fatalf("Env TEST was not overwritten with bar when foo was supplied to dockerfile: was %q", strings.TrimSpace(out))

}

}

func (s *DockerSuite) TestBuildOnBuildCmdEntrypointJSON(c *check.C) {

name1 := "onbuildcmd"

name2 := "onbuildgenerated"

_, err := buildImage(name1, `

FROM busybox

ONBUILD CMD ["hello world"]

ONBUILD ENTRYPOINT ["echo"]

ONBUILD RUN ["true"]`,

false)

if err != nil {

c.Fatal(err)

}

_, err = buildImage(name2, fmt.Sprintf(`FROM %s`, name1), false)

if err != nil {

c.Fatal(err)

}

out, _ := dockerCmd(c, "run", name2)

if !regexp.MustCompile(`(?m)^hello world`).MatchString(out) {

c.Fatalf("did not get echo output from onbuild. Got: %q", out)

}

}

func (s *DockerSuite) TestBuildOnBuildEntrypointJSON(c *check.C) {

name1 := "onbuildcmd"

name2 := "onbuildgenerated"

_, err := buildImage(name1, `

FROM busybox

ONBUILD ENTRYPOINT ["echo"]`,

false)

if err != nil {

c.Fatal(err)

}

_, err = buildImage(name2, fmt.Sprintf("FROM %s\nCMD [\"hello world\"]\n", name1), false)

if err != nil {

c.Fatal(err)

}

out, _ := dockerCmd(c, "run", name2)

if !regexp.MustCompile(`(?m)^hello world`).MatchString(out) {

c.Fatal("got malformed output from onbuild", out)

}

}

func (s *DockerSuite) TestBuildCacheAdd(c *check.C) {

testRequires(c, DaemonIsLinux) // Windows doesn't have httpserver image yet

name := "testbuildtwoimageswithadd"

server, err := fakeStorage(map[string]string{

"robots.txt": "hello",

"index.html": "world",

})

if err != nil {

c.Fatal(err)

}

defer server.Close()

if _, err := buildImage(name,

fmt.Sprintf(`FROM scratch

ADD %s/robots.txt /`, server.URL()),

true); err != nil {

c.Fatal(err)

}

if err != nil {

c.Fatal(err)

}

deleteImages(name)

_, out, err := buildImageWithOut(name,

fmt.Sprintf(`FROM scratch

ADD %s/index.html /`, server.URL()),

true)

if err != nil {

c.Fatal(err)

}

if strings.Contains(out, "Using cache") {

c.Fatal("2nd build used cache on ADD, it shouldn't")

}

}

func (s *DockerSuite) TestBuildLastModified(c *check.C) {

name := "testbuildlastmodified"

server, err := fakeStorage(map[string]string{

"file": "hello",

})

if err != nil {

c.Fatal(err)

}

defer server.Close()

var out, out2 string

dFmt := `FROM busybox

ADD %s/file /`

dockerfile := fmt.Sprintf(dFmt, server.URL())

if _, _, err = buildImageWithOut(name, dockerfile, false); err != nil {

c.Fatal(err)

}

out, _ = dockerCmd(c, "run", name, "ls", "-le", "/file")

// Build it again and make sure the mtime of the file didn't change.

// Wait a few seconds to make sure the time changed enough to notice

time.Sleep(2 * time.Second)

if _, _, err = buildImageWithOut(name, dockerfile, false); err != nil {

c.Fatal(err)

}

out2, _ = dockerCmd(c, "run", name, "ls", "-le", "/file")

if out != out2 {

c.Fatalf("MTime changed:\nOrigin:%s\nNew:%s", out, out2)

}

// Now 'touch' the file and make sure the timestamp DID change this time

// Create a new fakeStorage instead of just using Add() to help windows

server, err = fakeStorage(map[string]string{

"file": "hello",

})

if err != nil {

c.Fatal(err)

}

defer server.Close()

dockerfile = fmt.Sprintf(dFmt, server.URL())

if _, _, err = buildImageWithOut(name, dockerfile, false); err != nil {

c.Fatal(err)

}

out2, _ = dockerCmd(c, "run", name, "ls", "-le", "/file")

if out == out2 {

c.Fatalf("MTime didn't change:\nOrigin:%s\nNew:%s", out, out2)

}

}

func (s *DockerSuite) TestBuildAddSingleFileToRoot(c *check.C) {

testRequires(c, DaemonIsLinux) // Linux specific test

name := "testaddimg"

ctx, err := fakeContext(fmt.Sprintf(`FROM busybox

RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd

RUN echo 'dockerio:x:1001:' >> /etc/group

RUN touch /exists

RUN chown dockerio.dockerio /exists

ADD test_file /

RUN [ $(ls -l /test_file | awk '{print $3":"$4}') = 'root:root' ]

RUN [ $(ls -l /test_file | awk '{print $1}') = '%s' ]

RUN [ $(ls -l /exists | awk '{print $3":"$4}') = 'dockerio:dockerio' ]`, expectedFileChmod),

map[string]string{

"test_file": "test1",

})

if err != nil {

c.Fatal(err)

}

defer ctx.Close()

if _, err := buildImageFromContext(name, ctx, true); err != nil {

c.Fatal(err)

}

}

// Issue #3960: "ADD src ." hangs

func (s *DockerSuite) TestBuildAddSingleFileToWorkdir(c *check.C) {

name := "testaddsinglefiletoworkdir"

ctx, err := fakeContext(`FROM busybox

ADD test_file .`,

map[string]string{

"test_file": "test1",

})

if err != nil {

c.Fatal(err)

}

defer ctx.Close()

errChan := make(chan error)

go func() {

_, err := buildImageFromContext(name, ctx, true)

errChan <- err

close(errChan)

}()

select {

case <-time.After(15 * time.Second):

c.Fatal("Build with adding to workdir timed out")

case err := <-errChan:

c.Assert(err, check.IsNil)

}

}

func (s *DockerSuite) TestBuildAddSingleFileToExistDir(c *check.C) {

testRequires(c, DaemonIsLinux) // Linux specific test

name := "testaddsinglefiletoexistdir"

ctx, err := fakeContext(`FROM busybox

RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd

RUN echo 'dockerio:x:1001:' >> /etc/group

RUN mkdir /exists

RUN touch /exists/exists_file

RUN chown -R dockerio.dockerio /exists

ADD test_file /exists/

RUN [ $(ls -l / | grep exists | awk '{print $3":"$4}') = 'dockerio:dockerio' ]

RUN [ $(ls -l /exists/test_file | awk '{print $3":"$4}') = 'root:root' ]

RUN [ $(ls -l /exists/exists_file | awk '{print $3":"$4}') = 'dockerio:dockerio' ]`,

map[string]string{

"test_file": "test1",

})

if err != nil {

c.Fatal(err)

}

defer ctx.Close()

if _, err := buildImageFromContext(name, ctx, true); err != nil {

c.Fatal(err)

}

}

func (s *DockerSuite) TestBuildCopyAddMultipleFiles(c *check.C) {

testRequires(c, DaemonIsLinux) // Linux specific test

server, err := fakeStorage(map[string]string{

"robots.txt": "hello",

})

if err != nil {

c.Fatal(err)

}

defer server.Close()

name := "testcopymultiplefilestofile"

ctx, err := fakeContext(fmt.Sprintf(`FROM busybox

RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd

RUN echo 'dockerio:x:1001:' >> /etc/group

RUN mkdir /exists

RUN touch /exists/exists_file

RUN chown -R dockerio.dockerio /exists

COPY test_file1 test_file2 /exists/

ADD test_file3 test_file4 %s/robots.txt /exists/

RUN [ $(ls -l / | grep exists | awk '{print $3":"$4}') = 'dockerio:dockerio' ]

RUN [ $(ls -l /exists/test_file1 | awk '{print $3":"$4}') = 'root:root' ]

RUN [ $(ls -l /exists/test_file2 | awk '{print $3":"$4}') = 'root:root' ]

RUN [ $(ls -l /exists/test_file3 | awk '{print $3":"$4}') = 'root:root' ]

RUN [ $(ls -l /exists/test_file4 | awk '{print $3":"$4}') = 'root:root' ]

RUN [ $(ls -l /exists/robots.txt | awk '{print $3":"$4}') = 'root:root' ]

RUN [ $(ls -l /exists/exists_file | awk '{print $3":"$4}') = 'dockerio:dockerio' ]

`, server.URL()),

map[string]string{

"test_file1": "test1",

"test_file2": "test2",

"test_file3": "test3",

"test_file4": "test4",

})

if err != nil {

c.Fatal(err)

}

defer ctx.Close()

if _, err := buildImageFromContext(name, ctx, true); err != nil {

c.Fatal(err)

}

}

// This test is mainly for user namespaces to verify that new directories

// are created as the remapped root uid/gid pair

func (s *DockerSuite) TestBuildAddToNewDestination(c *check.C) {

testRequires(c, DaemonIsLinux) // Linux specific test

name := "testaddtonewdest"

ctx, err := fakeContext(`FROM busybox

ADD . /new_dir

RUN ls -l /

RUN [ $(ls -l / | grep new_dir | awk '{print $3":"$4}') = 'root:root' ]`,

map[string]string{

"test_dir/test_file": "test file",

})

if err != nil {

c.Fatal(err)

}

defer ctx.Close()

if _, err := buildImageFromContext(name, ctx, true); err != nil {

c.Fatal(err)

}

}

// This test is mainly for user namespaces to verify that new directories

// are created as the remapped root uid/gid pair

func (s *DockerSuite) TestBuildCopyToNewParentDirectory(c *check.C) {

testRequires(c, DaemonIsLinux) // Linux specific test

name := "testcopytonewdir"

ctx, err := fakeContext(`FROM busybox

COPY test_dir /new_dir

RUN ls -l /new_dir

RUN [ $(ls -l / | grep new_dir | awk '{print $3":"$4}') = 'root:root' ]`,

map[string]string{

"test_dir/test_file": "test file",

})

if err != nil {

c.Fatal(err)

}

defer ctx.Close()

if _, err := buildImageFromContext(name, ctx, true); err != nil {

c.Fatal(err)

}

}

// This test is mainly for user namespaces to verify that new directories

// are created as the remapped root uid/gid pair

func (s *DockerSuite) TestBuildWorkdirIsContainerRoot(c *check.C) {

testRequires(c, DaemonIsLinux) // Linux specific test

name := "testworkdirownership"

if _, err := buildImage(name, `FROM busybox

WORKDIR /new_dir

RUN ls -l /

RUN [ $(ls -l / | grep new_dir | awk '{print $3":"$4}') = 'root:root' ]`, true); err != nil {

c.Fatal(err)

}

}

func (s *DockerSuite) TestBuildAddFileWithWhitespace(c *check.C) {

testRequires(c, DaemonIsLinux) // Not currently passing on Windows

name := "testaddfilewithwhitespace"

ctx, err := fakeContext(`FROM busybox

RUN mkdir "/test dir"

RUN mkdir "/test_dir"

ADD [ "test file1", "/test_file1" ]

ADD [ "test_file2", "/test file2" ]

ADD [ "test file3", "/test file3" ]

ADD [ "test dir/test_file4", "/test_dir/test_file4" ]

ADD [ "test_dir/test_file5", "/test dir/test_file5" ]

ADD [ "test dir/test_file6", "/test dir/test_file6" ]

RUN [ $(cat "/test_file1") = 'test1' ]

RUN [ $(cat "/test file2") = 'test2' ]

RUN [ $(cat "/test file3") = 'test3' ]

RUN [ $(cat "/test_dir/test_file4") = 'test4' ]

RUN [ $(cat "/test dir/test_file5") = 'test5' ]

RUN [ $(cat "/test dir/test_file6") = 'test6' ]`,

map[string]string{

"test file1": "test1",

"test_file2": "test2",

"test file3": "test3",

"test dir/test_file4": "test4",

"test_dir/test_file5": "test5",

"test dir/test_file6": "test6",

})

if err != nil {

c.Fatal(err)

}

defer ctx.Close()

if _, err := buildImageFromContext(name, ctx, true); err != nil {

c.Fatal(err)

}

}

func (s *DockerSuite) TestBuildCopyFileWithWhitespace(c *check.C) {

dockerfile := `FROM busybox

RUN mkdir "/test dir"

RUN mkdir "/test_dir"

COPY [ "test file1", "/test_file1" ]

COPY [ "test_file2", "/test file2" ]

COPY [ "test file3", "/test file3" ]

COPY [ "test dir/test_file4", "/test_dir/test_file4" ]

COPY [ "test_dir/test_file5", "/test dir/test_file5" ]

COPY [ "test dir/test_file6", "/test dir/test_file6" ]

RUN [ $(cat "/test_file1") = 'test1' ]

RUN [ $(cat "/test file2") = 'test2' ]

RUN [ $(cat "/test file3") = 'test3' ]

RUN [ $(cat "/test_dir/test_file4") = 'test4' ]

RUN [ $(cat "/test dir/test_file5") = 'test5' ]

RUN [ $(cat "/test dir/test_file6") = 'test6' ]`

if daemonPlatform == "windows" {

dockerfile = `FROM ` + WindowsBaseImage + `

RUN mkdir "C:/test dir"

RUN mkdir "C:/test_dir"

COPY [ "test file1", "/test_file1" ]

COPY [ "test_file2", "/test file2" ]

COPY [ "test file3", "/test file3" ]

COPY [ "test dir/test_file4", "/test_dir/test_file4" ]

COPY [ "test_dir/test_file5", "/test dir/test_file5" ]

COPY [ "test dir/test_file6", "/test dir/test_file6" ]

RUN find "test1" "C:/test_file1"

RUN find "test2" "C:/test file2"

RUN find "test3" "C:/test file3"

RUN find "test4" "C:/test_dir/test_file4"

RUN find "test5" "C:/test dir/test_file5"

RUN find "test6" "C:/test dir/test_file6"`

}

name := "testcopyfilewithwhitespace"

ctx, err := fakeContext(dockerfile,

map[string]string{

"test file1": "test1",

"test_file2": "test2",

"test file3": "test3",

"test dir/test_file4": "test4",

"test_dir/test_file5": "test5",

"test dir/test_file6": "test6",

})

if err != nil {

c.Fatal(err)

}

defer ctx.Close()

if _, err := buildImageFromContext(name, ctx, true); err != nil {

c.Fatal(err)

}

}

func (s *DockerSuite) TestBuildCopyWildcard(c *check.C) {

name := "testcopywildcard"

server, err := fakeStorage(map[string]string{

"robots.txt": "hello",

"index.html": "world",

})

if err != nil {

c.Fatal(err)

}

defer server.Close()

ctx, err := fakeContext(fmt.Sprintf(`FROM busybox

COPY file*.txt /tmp/

RUN ls /tmp/file1.txt /tmp/file2.txt

RUN [ "mkdir", "/tmp1" ]

COPY dir* /tmp1/

RUN ls /tmp1/dirt /tmp1/nested_file /tmp1/nested_dir/nest_nest_file

RUN [ "mkdir", "/tmp2" ]

ADD dir/*dir %s/robots.txt /tmp2/

RUN ls /tmp2/nest_nest_file /tmp2/robots.txt

`, server.URL()),

map[string]string{

"file1.txt": "test1",

"file2.txt": "test2",

"dir/nested_file": "nested file",

"dir/nested_dir/nest_nest_file": "2 times nested",

"dirt": "dirty",

})

if err != nil {

c.Fatal(err)

}

defer ctx.Close()

id1, err := buildImageFromContext(name, ctx, true)

if err != nil {

c.Fatal(err)

}

// Now make sure we use a cache the 2nd time

id2, err := buildImageFromContext(name, ctx, true)

if err != nil {

c.Fatal(err)

}

if id1 != id2 {

c.Fatal("didn't use the cache")

}

}

func (s *DockerSuite) TestBuildCopyWildcardInName(c *check.C) {

name := "testcopywildcardinname"

ctx, err := fakeContext(`FROM busybox

COPY *.txt /tmp/

RUN [ "$(cat /tmp/\*.txt)" = 'hi there' ]

`, map[string]string{"*.txt": "hi there"})

if err != nil {

// Normally we would do c.Fatal(err) here but given that

// the odds of this failing are so rare, it must be because

// the OS we're running the client on doesn't support * in

// filenames (like windows). So, instead of failing the test

// just let it pass. Then we don't need to explicitly

// say which OSs this works on or not.

return

}

defer ctx.Close()

_, err = buildImageFromContext(name, ctx, true)

if err != nil {

c.Fatalf("should have built: %q", err)

}

}

func (s *DockerSuite) TestBuildCopyWildcardCache(c *check.C) {

name := "testcopywildcardcache"

ctx, err := fakeContext(`FROM busybox

COPY file1.txt /tmp/`,

map[string]string{

"file1.txt": "test1",

})

if err != nil {

c.Fatal(err)

}

defer ctx.Close()

id1, err := buildImageFromContext(name, ctx, true)

if err != nil {

c.Fatal(err)

}

// Now make sure we use a cache the 2nd time even with wild cards.

// Use the same context so the file is the same and the checksum will match

ctx.Add("Dockerfile", `FROM busybox

COPY file*.txt /tmp/`)

id2, err := buildImageFromContext(name, ctx, true)

if err != nil {

c.Fatal(err)

}

if id1 != id2 {

c.Fatal("didn't use the cache")

}

}

func (s *DockerSuite) TestBuildAddSingleFileToNonExistingDir(c *check.C) {

testRequires(c, DaemonIsLinux) // Linux specific test

name := "testaddsinglefiletononexistingdir"

ctx, err := fakeContext(`FROM busybox

RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd

RUN echo 'dockerio:x:1001:' >> /etc/group

RUN touch /exists

RUN chown dockerio.dockerio /exists

ADD test_file /test_dir/

RUN [ $(ls -l / | grep test_dir | awk '{print $3":"$4}') = 'root:root' ]

RUN [ $(ls -l /test_dir/test_file | awk '{print $3":"$4}') = 'root:root' ]

RUN [ $(ls -l /exists | awk '{print $3":"$4}') = 'dockerio:dockerio' ]`,

map[string]string{

"test_file": "test1",

})

if err != nil {

c.Fatal(err)

}

defer ctx.Close()

if _, err := buildImageFromContext(name, ctx, true); err != nil {

c.Fatal(err)

}

}

func (s *DockerSuite) TestBuildAddDirContentToRoot(c *check.C) {

testRequires(c, DaemonIsLinux) // Linux specific test

name := "testadddircontenttoroot"

ctx, err := fakeContext(`FROM busybox