@@ -791,6 +791,7 @@ func WaitInspectWithArgs(dockerBinary, name, expr, expected string, timeout time

 }

 // BuildImageCmdWithHost create a build command with the specified arguments.

+// Deprecated

 // FIXME(vdemeester) move this away

 func BuildImageCmdWithHost(dockerBinary, name, dockerfile, host string, useCache bool, buildFlags ...string) *exec.Cmd {

 	args := []string{}

@@ -28,8 +28,7 @@ COPY * /tmp/

 RUN find / -xdev -name ba*

 RUN find /tmp/`

 	}

-	server, err := fakeStorage(map[string]string{"testD": testD})

-	c.Assert(err, checker.IsNil)

+	server := fakeStorage(c, map[string]string{"testD": testD})

 	defer server.Close()

 	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

 	c.Assert(tw.Close(), checker.IsNil)

-	server, err := fakeBinaryStorage(map[string]*bytes.Buffer{

+	server := fakeBinaryStorage(c, map[string]*bytes.Buffer{

 		"testT.tar": buffer,

 	})

-	c.Assert(err, checker.IsNil)

-

 	defer server.Close()

 	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

 	c.Assert(tw.Close(), checker.IsNil)

-	server, err := fakeBinaryStorage(map[string]*bytes.Buffer{

+	server := fakeBinaryStorage(c, map[string]*bytes.Buffer{

 		"testT.tar": buffer,

 	})

-	c.Assert(err, checker.IsNil)

-

 	defer server.Close()

+

 	url := "/build?dockerfile=custom&remote=" + server.URL() + "/testT.tar"

 	res, body, err := request.SockRequestRaw("POST", url, nil, "application/tar", daemonHost())

 	c.Assert(err, checker.IsNil)

@@ -135,11 +131,10 @@ RUN echo 'right'

 }

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

-	git, err := newFakeGit("repo", map[string]string{

+	git := newFakeGit(c, "repo", map[string]string{

 		"dockerfile": `FROM busybox

 RUN echo from dockerfile`,

 	}, false)

-	c.Assert(err, checker.IsNil)

 	defer git.Close()

 	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) {

-	git, err := newFakeGit("repo", map[string]string{

+	git := newFakeGit(c, "repo", map[string]string{

 		"baz": `FROM busybox

 RUN echo from baz`,

 		"Dockerfile": `FROM busybox

 RUN echo from Dockerfile`,

 	}, false)

-	c.Assert(err, checker.IsNil)

 	defer git.Close()

 	// Make sure it tries to 'dockerfile' query param value

@@ -177,13 +171,12 @@ RUN echo from Dockerfile`,

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

 	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

 RUN echo from Dockerfile`,

 		"dockerfile": `FROM busybox

 RUN echo from dockerfile`,

 	}, false)

-	c.Assert(err, checker.IsNil)

 	defer git.Close()

 	// Make sure it tries to 'dockerfile' query param value

@@ -1766,19 +1766,18 @@ func (s *DockerSuite) TestContainersAPICreateMountsCreate(c *check.C) {

 	destPath := prefix + slash + "foo"

 	var (

-		err     error

 		testImg string

 	)

 	if testEnv.DaemonPlatform() != "windows" {

-		testImg, err = buildImage("test-mount-config", `

+		testImg = "test-mount-config"

+		buildImageSuccessfully(c, testImg, withDockerfile(`

 	FROM busybox

 	RUN mkdir `+destPath+` && touch `+destPath+slash+`bar

 	CMD cat `+destPath+slash+`bar

-	`, true)

+	`))

 	} else {

 		testImg = "busybox"

 	}

-	c.Assert(err, checker.IsNil)

 	type testCase struct {

 		cfg      mounttypes.Mount

@@ -52,9 +52,8 @@ func (s *DockerSuite) TestAPIImagesSaveAndLoad(c *check.C) {

 	// TODO Windows to Windows CI: Investigate further why this test fails.

 	testRequires(c, Network)

 	testRequires(c, DaemonIsLinux)

-	out, err := buildImage("saveandload", "FROM busybox\nENV FOO bar", false)

-	c.Assert(err, checker.IsNil)

-	id := strings.TrimSpace(out)

+	buildImageSuccessfully(c, "saveandload", withDockerfile("FROM busybox\nENV FOO bar"))

+	id := getIDByName(c, "saveandload")

 	res, body, err := request.SockRequestRaw("GET", "/images/"+id+"/get", nil, "", daemonHost())

 	c.Assert(err, checker.IsNil)

@@ -77,9 +76,8 @@ func (s *DockerSuite) TestAPIImagesDelete(c *check.C) {

 		testRequires(c, Network)

 	}

 	name := "test-api-images-delete"

-	out, err := buildImage(name, "FROM busybox\nENV FOO bar", false)

-	c.Assert(err, checker.IsNil)

-	id := strings.TrimSpace(out)

+	buildImageSuccessfully(c, name, withDockerfile("FROM busybox\nENV FOO bar"))

+	id := getIDByName(c, name)

 	dockerCmd(c, "tag", name, "test:tag1")

@@ -101,10 +99,8 @@ func (s *DockerSuite) TestAPIImagesHistory(c *check.C) {

 		testRequires(c, Network)

 	}

 	name := "test-api-images-history"

-	out, err := buildImage(name, "FROM busybox\nENV FOO bar", false)

-	c.Assert(err, checker.IsNil)

-

-	id := strings.TrimSpace(out)

+	buildImageSuccessfully(c, name, withDockerfile("FROM busybox\nENV FOO bar"))

+	id := getIDByName(c, name)

 	status, body, err := request.SockRequest("GET", "/images/"+id+"/history", nil, daemonHost())

 	c.Assert(err, checker.IsNil)

@@ -271,7 +271,7 @@ func (s *DockerSuite) TestBuildOnBuildLowercase(c *check.C) {

   onbuild run echo quux

   `))

-	result := buildImageNew(name2, withDockerfile(fmt.Sprintf(`

+	result := buildImage(name2, withDockerfile(fmt.Sprintf(`

   FROM %s

   `, name)))

 	result.Assert(c, icmd.Success)

@@ -361,69 +361,45 @@ ONBUILD ENTRYPOINT ["echo"]`))

 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{

+	server := fakeStorage(c, 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") {

+	buildImageSuccessfully(c, name, withDockerfile(fmt.Sprintf(`FROM scratch

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

+

+	result := buildImage(name, withDockerfile(fmt.Sprintf(`FROM scratch

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

+	result.Assert(c, icmd.Success)

+	if strings.Contains(result.Combined(), "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{

+	server := fakeStorage(c, 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)

-	}

-

+	buildImageSuccessfully(c, name, withoutCache, withDockerfile(dockerfile))

 	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)

-	}

+	buildImageSuccessfully(c, name, withoutCache, withDockerfile(dockerfile))

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

 	if out != out2 {

@@ -432,19 +408,13 @@ ADD %s/file /`

 	// 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{

+	server = fakeStorage(c, 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)

-	}

+	buildImageSuccessfully(c, name, withoutCache, withDockerfile(dockerfile))

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

 	if out == out2 {

@@ -459,28 +429,21 @@ ADD %s/file /`

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

 	name := "testbuildmodifyfileinfolder"

-	ctx, err := fakeContext(`FROM busybox

+	ctx := fakeContext(c, `FROM busybox

 RUN ["mkdir", "/test"]

 ADD folder/file /test/changetarget`,

 		map[string]string{})

-	if err != nil {

-		c.Fatal(err)

-	}

 	defer ctx.Close()

 	if err := ctx.Add("folder/file", "first"); err != nil {

 		c.Fatal(err)

 	}

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

-	if err != nil {

-		c.Fatal(err)

-	}

+	buildImageSuccessfully(c, name, withExternalBuildContext(ctx))

+	id1 := getIDByName(c, name)

 	if err := ctx.Add("folder/file", "second"); err != nil {

 		c.Fatal(err)

 	}

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

-	if err != nil {

-		c.Fatal(err)

-	}

+	buildImageSuccessfully(c, name, withExternalBuildContext(ctx))

+	id2 := getIDByName(c, name)

 	if id1 == id2 {

 		c.Fatal("cache was used even though file contents in folder was changed")

 	}

@@ -504,20 +467,16 @@ RUN [ $(ls -l /exists | awk '{print $3":"$4}') = 'dockerio:dockerio' ]`, expecte

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

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

 	name := "testaddsinglefiletoworkdir"

-	ctx, err := fakeContext(`FROM busybox

+	ctx := fakeContext(c, `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

+		errChan <- buildImage(name, withExternalBuildContext(ctx)).Error

 		close(errChan)

 	}()

 	select {

@@ -546,12 +505,9 @@ RUN [ $(ls -l /exists/exists_file | awk '{print $3":"$4}') = 'dockerio:dockerio'

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

 	testRequires(c, DaemonIsLinux) // Linux specific test

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

+	server := fakeStorage(c, map[string]string{

 		"robots.txt": "hello",

 	})

-	if err != nil {

-		c.Fatal(err)

-	}

 	defer server.Close()

 	buildImageSuccessfully(c, "testcopymultiplefilestofile", withBuildContext(c,

@@ -664,16 +620,13 @@ RUN find "test6" "C:/test dir/test_file6"`

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

 	name := "testcopywildcard"

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

+	server := fakeStorage(c, 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

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

 	COPY file*.txt /tmp/

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

 	RUN [ "mkdir",  "/tmp1" ]

@@ -690,21 +643,14 @@ func (s *DockerSuite) TestBuildCopyWildcard(c *check.C) {

 			"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)

-	}

+	buildImageSuccessfully(c, name, withExternalBuildContext(ctx))

+	id1 := getIDByName(c, name)

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

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

-	if err != nil {

-		c.Fatal(err)

-	}

+	buildImageSuccessfully(c, name, withExternalBuildContext(ctx))

+	id2 := getIDByName(c, name)

 	if id1 != id2 {

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

@@ -734,30 +680,23 @@ func (s *DockerSuite) TestBuildCopyWildcardInName(c *check.C) {

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

 	name := "testcopywildcardcache"

-	ctx, err := fakeContext(`FROM busybox

+	ctx := fakeContext(c, `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)

-	}

+	buildImageSuccessfully(c, name, withExternalBuildContext(ctx))

+	id1 := getIDByName(c, name)

 	// 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)

-	}

+	buildImageSuccessfully(c, name, withExternalBuildContext(ctx))

+	id2 := getIDByName(c, name)

 	if id1 != id2 {

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

@@ -871,20 +810,16 @@ RUN [ $(ls -l /exists | awk '{print $3":"$4}') = 'dockerio:dockerio' ]`, expecte

 // Issue #3960: "ADD src ." hangs - adapted for COPY

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

 	name := "testcopysinglefiletoworkdir"

-	ctx, err := fakeContext(`FROM busybox

+	ctx := fakeContext(c, `FROM busybox

 COPY 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

+		errChan <- buildImage(name, withExternalBuildContext(ctx)).Error

 		close(errChan)

 	}()

 	select {

@@ -985,10 +920,7 @@ func (s *DockerSuite) TestBuildAddBadLinks(c *check.C) {

 	var (

 		name = "test-link-absolute"

 	)

-	ctx, err := fakeContext(dockerfile, nil)

-	if err != nil {

-		c.Fatal(err)

-	}

+	ctx := fakeContext(c, dockerfile, nil)

 	defer ctx.Close()

 	tempDir, err := ioutil.TempDir("", "test-link-absolute-temp-")

@@ -1049,10 +981,7 @@ func (s *DockerSuite) TestBuildAddBadLinks(c *check.C) {

 		c.Fatal(err)

 	}

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

-		c.Fatal(err)

-	}

-

+	buildImageSuccessfully(c, name, withExternalBuildContext(ctx))

 	if _, err := os.Stat(nonExistingFile); err == nil || err != nil && !os.IsNotExist(err) {

 		c.Fatalf("%s shouldn't have been written and it shouldn't exist", nonExistingFile)

 	}

@@ -1083,10 +1012,7 @@ func (s *DockerSuite) TestBuildAddBadLinksVolume(c *check.C) {

 	dockerfile = fmt.Sprintf(dockerfileTemplate, tempDir)

 	nonExistingFile := filepath.Join(tempDir, targetFile)

-	ctx, err := fakeContext(dockerfile, nil)

-	if err != nil {

-		c.Fatal(err)

-	}

+	ctx := fakeContext(c, dockerfile, nil)

 	defer ctx.Close()

 	fooPath := filepath.Join(ctx.Dir, targetFile)

@@ -1100,10 +1026,7 @@ func (s *DockerSuite) TestBuildAddBadLinksVolume(c *check.C) {

 		c.Fatal(err)

 	}

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

-		c.Fatal(err)

-	}

-

+	buildImageSuccessfully(c, name, withExternalBuildContext(ctx))

 	if _, err := os.Stat(nonExistingFile); err == nil || err != nil && !os.IsNotExist(err) {

 		c.Fatalf("%s shouldn't have been written and it shouldn't exist", nonExistingFile)

 	}

@@ -1117,18 +1040,15 @@ func (s *DockerSuite) TestBuildWithInaccessibleFilesInContext(c *check.C) {

 	{

 		name := "testbuildinaccessiblefiles"

-		ctx, err := fakeContext("FROM scratch\nADD . /foo/", map[string]string{"fileWithoutReadAccess": "foo"})

-		if err != nil {

-			c.Fatal(err)

-		}

+		ctx := fakeContext(c, "FROM scratch\nADD . /foo/", map[string]string{"fileWithoutReadAccess": "foo"})

 		defer ctx.Close()

 		// This is used to ensure we detect inaccessible files early during build in the cli client

 		pathToFileWithoutReadAccess := filepath.Join(ctx.Dir, "fileWithoutReadAccess")

-		if err = os.Chown(pathToFileWithoutReadAccess, 0, 0); err != nil {

+		if err := os.Chown(pathToFileWithoutReadAccess, 0, 0); err != nil {

 			c.Fatalf("failed to chown file to root: %s", err)

 		}

-		if err = os.Chmod(pathToFileWithoutReadAccess, 0700); err != nil {

+		if err := os.Chmod(pathToFileWithoutReadAccess, 0700); err != nil {

 			c.Fatalf("failed to chmod file to 700: %s", err)

 		}

 		result := icmd.RunCmd(icmd.Cmd{

@@ -1150,22 +1070,19 @@ func (s *DockerSuite) TestBuildWithInaccessibleFilesInContext(c *check.C) {

 	}

 	{

 		name := "testbuildinaccessibledirectory"

-		ctx, err := fakeContext("FROM scratch\nADD . /foo/", map[string]string{"directoryWeCantStat/bar": "foo"})

-		if err != nil {

-			c.Fatal(err)

-		}

+		ctx := fakeContext(c, "FROM scratch\nADD . /foo/", map[string]string{"directoryWeCantStat/bar": "foo"})

 		defer ctx.Close()

 		// This is used to ensure we detect inaccessible directories early during build in the cli client

 		pathToDirectoryWithoutReadAccess := filepath.Join(ctx.Dir, "directoryWeCantStat")

 		pathToFileInDirectoryWithoutReadAccess := filepath.Join(pathToDirectoryWithoutReadAccess, "bar")

-		if err = os.Chown(pathToDirectoryWithoutReadAccess, 0, 0); err != nil {

+		if err := os.Chown(pathToDirectoryWithoutReadAccess, 0, 0); err != nil {

 			c.Fatalf("failed to chown directory to root: %s", err)

 		}

-		if err = os.Chmod(pathToDirectoryWithoutReadAccess, 0444); err != nil {

+		if err := os.Chmod(pathToDirectoryWithoutReadAccess, 0444); err != nil {

 			c.Fatalf("failed to chmod directory to 444: %s", err)

 		}

-		if err = os.Chmod(pathToFileInDirectoryWithoutReadAccess, 0700); err != nil {

+		if err := os.Chmod(pathToFileInDirectoryWithoutReadAccess, 0700); err != nil {

 			c.Fatalf("failed to chmod file to 700: %s", err)

 		}

@@ -1189,10 +1106,7 @@ func (s *DockerSuite) TestBuildWithInaccessibleFilesInContext(c *check.C) {

 	}

 	{

 		name := "testlinksok"

-		ctx, err := fakeContext("FROM scratch\nADD . /foo/", nil)

-		if err != nil {

-			c.Fatal(err)

-		}

+		ctx := fakeContext(c, "FROM scratch\nADD . /foo/", nil)

 		defer ctx.Close()

 		target := "../../../../../../../../../../../../../../../../../../../azA"

@@ -1202,31 +1116,26 @@ func (s *DockerSuite) TestBuildWithInaccessibleFilesInContext(c *check.C) {

 		defer os.Remove(target)

 		// This is used to ensure we don't follow links when checking if everything in the context is accessible

 		// This test doesn't require that we run commands as an unprivileged user

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

-			c.Fatal(err)

-		}

+		buildImageSuccessfully(c, name, withExternalBuildContext(ctx))

 	}

 	{

 		name := "testbuildignoredinaccessible"

-		ctx, err := fakeContext("FROM scratch\nADD . /foo/",

+		ctx := fakeContext(c, "FROM scratch\nADD . /foo/",

 			map[string]string{

 				"directoryWeCantStat/bar": "foo",

 				".dockerignore":           "directoryWeCantStat",

 			})

-		if err != nil {

-			c.Fatal(err)

-		}

 		defer ctx.Close()

 		// This is used to ensure we don't try to add inaccessible files when they are ignored by a .dockerignore pattern

 		pathToDirectoryWithoutReadAccess := filepath.Join(ctx.Dir, "directoryWeCantStat")

 		pathToFileInDirectoryWithoutReadAccess := filepath.Join(pathToDirectoryWithoutReadAccess, "bar")

-		if err = os.Chown(pathToDirectoryWithoutReadAccess, 0, 0); err != nil {

+		if err := os.Chown(pathToDirectoryWithoutReadAccess, 0, 0); err != nil {

 			c.Fatalf("failed to chown directory to root: %s", err)

 		}

-		if err = os.Chmod(pathToDirectoryWithoutReadAccess, 0444); err != nil {

+		if err := os.Chmod(pathToDirectoryWithoutReadAccess, 0444); err != nil {

 			c.Fatalf("failed to chmod directory to 444: %s", err)

 		}

-		if err = os.Chmod(pathToFileInDirectoryWithoutReadAccess, 0700); err != nil {

+		if err := os.Chmod(pathToFileInDirectoryWithoutReadAccess, 0700); err != nil {

 			c.Fatalf("failed to chmod file to 700: %s", err)

 		}

@@ -1246,7 +1155,7 @@ func (s *DockerSuite) TestBuildForceRm(c *check.C) {

 	}

 	name := "testbuildforcerm"

-	buildImageNew(name, withBuildFlags("--force-rm"), withBuildContext(c,

+	buildImage(name, withBuildFlags("--force-rm"), withBuildContext(c,

 		withFile("Dockerfile", `FROM `+minimalBaseImage()+`

 	RUN true

 	RUN thiswillfail`))).Assert(c, icmd.Expected{

@@ -1542,7 +1451,7 @@ func (s *DockerSuite) TestBuildBlankName(c *check.C) {

 	}

 	for _, tc := range testCases {

-		buildImageNew(name, withDockerfile(fmt.Sprintf(`FROM busybox

+		buildImage(name, withDockerfile(fmt.Sprintf(`FROM busybox

 		%s`, tc.expression))).Assert(c, icmd.Expected{

 			ExitCode: 1,

 			Err:      tc.expectedStderr,

@@ -1624,7 +1533,7 @@ func (s *DockerSuite) TestBuildContextCleanupFailedBuild(c *check.C) {

 		c.Fatalf("failed to list contents of tmp dir: %s", err)

 	}

-	buildImageNew(name, withDockerfile(`FROM `+minimalBaseImage()+`

+	buildImage(name, withDockerfile(`FROM `+minimalBaseImage()+`

 	RUN /non/existing/command`)).Assert(c, icmd.Expected{

 		ExitCode: 1,

 	})

@@ -1802,11 +1711,11 @@ func (s *DockerSuite) TestBuildOnBuildLimitedInheritence(c *check.C) {

 		ONBUILD RUN echo "ONBUILD PARENT"

 		`))

 	// ONBUILD should be run in second build.

-	buildImageNew("testonbuildtrigger2", withDockerfile("FROM testonbuildtrigger1")).Assert(c, icmd.Expected{

+	buildImage("testonbuildtrigger2", withDockerfile("FROM testonbuildtrigger1")).Assert(c, icmd.Expected{

 		Out: "ONBUILD PARENT",

 	})

 	// ONBUILD should *not* be run in third build.

-	result := buildImageNew("testonbuildtrigger3", withDockerfile("FROM testonbuildtrigger2"))

+	result := buildImage("testonbuildtrigger3", withDockerfile("FROM testonbuildtrigger2"))

 	result.Assert(c, icmd.Success)

 	if strings.Contains(result.Combined(), "ONBUILD PARENT") {

 		c.Fatalf("ONBUILD instruction ran in grandchild of ONBUILD parent")

@@ -1821,14 +1730,11 @@ func (s *DockerSuite) TestBuildSameDockerfileWithAndWithoutCache(c *check.C) {

 		EXPOSE 5432

         ENTRYPOINT ["/bin/echo"]`

 	buildImageSuccessfully(c, name, withDockerfile(dockerfile))

-	id1, err := getIDByName(name)

-	c.Assert(err, checker.IsNil)

+	id1 := getIDByName(c, name)

 	buildImageSuccessfully(c, name, withDockerfile(dockerfile))

-	id2, err := getIDByName(name)

-	c.Assert(err, checker.IsNil)

+	id2 := getIDByName(c, name)

 	buildImageSuccessfully(c, name, withoutCache, withDockerfile(dockerfile))

-	id3, err := getIDByName(name)

-	c.Assert(err, checker.IsNil)

+	id3 := getIDByName(c, name)

 	if id1 != id2 {

 		c.Fatal("The cache should have been used but hasn't.")

 	}

@@ -1844,36 +1750,27 @@ func (s *DockerSuite) TestBuildConditionalCache(c *check.C) {

 	dockerfile := `

 		FROM busybox

         ADD foo /tmp/`

-	ctx, err := fakeContext(dockerfile, map[string]string{

+	ctx := fakeContext(c, dockerfile, map[string]string{

 		"foo": "hello",

 	})

-	if err != nil {

-		c.Fatal(err)

-	}

 	defer ctx.Close()

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

-	if err != nil {

-		c.Fatalf("Error building #1: %s", err)

-	}

+	buildImageSuccessfully(c, name, withExternalBuildContext(ctx))

+	id1 := getIDByName(c, name)

 	if err := ctx.Add("foo", "bye"); err != nil {

 		c.Fatalf("Error modifying foo: %s", err)

 	}

 	// Updating a file should invalidate the cache

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

-	if err != nil {

-		c.Fatalf("Error building #2: %s", err)

-	}

+	buildImageSuccessfully(c, name, withExternalBuildContext(ctx))

+	id2 := getIDByName(c, name)

 	if id2 == id1 {

 		c.Fatal("Should not have used the cache")

 	}

-	id3, err := buildImageFromContext(name, ctx, true)

-	if err != nil {

-		c.Fatalf("Error building #3: %s", err)

-	}

+	buildImageSuccessfully(c, name, withExternalBuildContext(ctx))

+	id3 := getIDByName(c, name)

 	if id3 != id2 {

 		c.Fatal("Should have used the cache")

 	}

@@ -1887,25 +1784,16 @@ func (s *DockerSuite) TestBuildAddMultipleLocalFileWithAndWithoutCache(c *check.

         MAINTAINER dockerio

         ADD foo Dockerfile /usr/lib/bla/

 		RUN sh -c "[ $(cat /usr/lib/bla/foo) = "hello" ]"`

-	ctx, err := fakeContext(dockerfile, map[string]string{

+	ctx := fakeContext(c, dockerfile, map[string]string{

 		"foo": "hello",

 	})

-	if err != nil {

-		c.Fatal(err)

-	}

 	defer ctx.Close()

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

-	if err != nil {

-		c.Fatal(err)

-	}

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

-	if err != nil {

-		c.Fatal(err)

-	}

-	id3, err := buildImageFromContext(name, ctx, false)

-	if err != nil {

-		c.Fatal(err)

-	}

+	buildImageSuccessfully(c, name, withExternalBuildContext(ctx))

+	id1 := getIDByName(c, name)

+	buildImageSuccessfully(c, name, withExternalBuildContext(ctx))

+	id2 := getIDByName(c, name)

+	buildImageSuccessfully(c, name, withoutCache, withExternalBuildContext(ctx))

+	id3 := getIDByName(c, name)

 	if id1 != id2 {

 		c.Fatal("The cache should have been used but hasn't.")

 	}

@@ -1921,25 +1809,18 @@ func (s *DockerSuite) TestBuildCopyDirButNotFile(c *check.C) {

 	dockerfile := `

         FROM ` + minimalBaseImage() + `

         COPY dir /tmp/`

-	ctx, err := fakeContext(dockerfile, map[string]string{

+	ctx := fakeContext(c, dockerfile, map[string]string{

 		"dir/foo": "hello",

 	})

-	if err != nil {

-		c.Fatal(err)

-	}

 	defer ctx.Close()

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

-	if err != nil {

-		c.Fatal(err)

-	}

+	buildImageSuccessfully(c, name, withExternalBuildContext(ctx))

+	id1 := getIDByName(c, name)

 	// Check that adding file with similar name doesn't mess with cache

 	if err := ctx.Add("dir_file", "hello2"); err != nil {

 		c.Fatal(err)

 	}

-	id2, err := buildImageFromContext(name2, ctx, true)

-	if err != nil {

-		c.Fatal(err)

-	}

+	buildImageSuccessfully(c, name2, withExternalBuildContext(ctx))

+	id2 := getIDByName(c, name2)

 	if id1 != id2 {

 		c.Fatal("The cache should have been used but wasn't")

 	}

@@ -1954,25 +1835,18 @@ func (s *DockerSuite) TestBuildAddCurrentDirWithCache(c *check.C) {

         FROM ` + minimalBaseImage() + `

         MAINTAINER dockerio

         ADD . /usr/lib/bla`

-	ctx, err := fakeContext(dockerfile, map[string]string{

+	ctx := fakeContext(c, dockerfile, map[string]string{

 		"foo": "hello",

 	})

-	if err != nil {

-		c.Fatal(err)

-	}

 	defer ctx.Close()

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

-	if err != nil {

-		c.Fatal(err)

-	}

+	buildImageSuccessfully(c, name, withExternalBuildContext(ctx))

+	id1 := getIDByName(c, name)

 	// Check that adding file invalidate cache of "ADD ."

 	if err := ctx.Add("bar", "hello2"); err != nil {

 		c.Fatal(err)

 	}

-	id2, err := buildImageFromContext(name2, ctx, true)

-	if err != nil {

-		c.Fatal(err)

-	}

+	buildImageSuccessfully(c, name2, withExternalBuildContext(ctx))

+	id2 := getIDByName(c, name2)

 	if id1 == id2 {

 		c.Fatal("The cache should have been invalided but hasn't.")

 	}

@@ -1980,10 +1854,8 @@ func (s *DockerSuite) TestBuildAddCurrentDirWithCache(c *check.C) {

 	if err := ctx.Add("foo", "hello1"); err != nil {

 		c.Fatal(err)

 	}

-	id3, err := buildImageFromContext(name3, ctx, true)

-	if err != nil {

-		c.Fatal(err)

-	}

+	buildImageSuccessfully(c, name3, withExternalBuildContext(ctx))

+	id3 := getIDByName(c, name3)

 	if id2 == id3 {

 		c.Fatal("The cache should have been invalided but hasn't.")

 	}

@@ -1993,10 +1865,8 @@ func (s *DockerSuite) TestBuildAddCurrentDirWithCache(c *check.C) {

 	if err := ctx.Add("foo", "hello1"); err != nil {

 		c.Fatal(err)

 	}

-	id4, err := buildImageFromContext(name4, ctx, true)

-	if err != nil {

-		c.Fatal(err)

-	}

+	buildImageSuccessfully(c, name4, withExternalBuildContext(ctx))

+	id4 := getIDByName(c, name4)

 	if id3 != id4 {

 		c.Fatal("The cache should have been used but hasn't.")

 	}

@@ -2009,21 +1879,14 @@ func (s *DockerSuite) TestBuildAddCurrentDirWithoutCache(c *check.C) {

         FROM ` + minimalBaseImage() + `

         MAINTAINER dockerio

         ADD . /usr/lib/bla`

-	ctx, err := fakeContext(dockerfile, map[string]string{

+	ctx := fakeContext(c, dockerfile, map[string]string{

 		"foo": "hello",

 	})

-	if err != nil {

-		c.Fatal(err)

-	}

 	defer ctx.Close()

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

-	if err != nil {

-		c.Fatal(err)

-	}

-	id2, err := buildImageFromContext(name, ctx, false)

-	if err != nil {

-		c.Fatal(err)

-	}

+	buildImageSuccessfully(c, name, withExternalBuildContext(ctx))

+	id1 := getIDByName(c, name)

+	buildImageSuccessfully(c, name, withoutCache, withExternalBuildContext(ctx))

+	id2 := getIDByName(c, name)

 	if id1 == id2 {

 		c.Fatal("The cache should have been invalided but hasn't.")

 	}

@@ -2031,26 +1894,20 @@ func (s *DockerSuite) TestBuildAddCurrentDirWithoutCache(c *check.C) {

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

 	name := "testbuildaddremotefilewithcache"

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

+	server := fakeStorage(c, map[string]string{

 		"baz": "hello",

 	})

-	if err != nil {

-		c.Fatal(err)

-	}

 	defer server.Close()

 	dockerfile := fmt.Sprintf(`FROM `+minimalBaseImage()+`

         MAINTAINER dockerio

         ADD %s/baz /usr/lib/baz/quux`, server.URL())

 	buildImageSuccessfully(c, name, withDockerfile(dockerfile))

-	id1, err := getIDByName(name)

-	c.Assert(err, checker.IsNil)

+	id1 := getIDByName(c, name)

 	buildImageSuccessfully(c, name, withDockerfile(dockerfile))

-	id2, err := getIDByName(name)

-	c.Assert(err, checker.IsNil)

+	id2 := getIDByName(c, name)

 	buildImageSuccessfully(c, name, withoutCache, withDockerfile(dockerfile))

-	id3, err := getIDByName(name)

-	c.Assert(err, checker.IsNil)

+	id3 := getIDByName(c, name)

 	if id1 != id2 {

 		c.Fatal("The cache should have been used but hasn't.")

@@ -2066,29 +1923,18 @@ func (s *DockerSuite) TestBuildAddRemoteFileMTime(c *check.C) {

 	name3 := name + "3"

 	files := map[string]string{"baz": "hello"}

-	server, err := fakeStorage(files)

-	if err != nil {

-		c.Fatal(err)

-	}

+	server := fakeStorage(c, files)

 	defer server.Close()

-	ctx, err := fakeContext(fmt.Sprintf(`FROM `+minimalBaseImage()+`

+	ctx := fakeContext(c, fmt.Sprintf(`FROM `+minimalBaseImage()+`

         MAINTAINER dockerio

         ADD %s/baz /usr/lib/baz/quux`, server.URL()), nil)

-	if err != nil {

-		c.Fatal(err)

-	}

 	defer ctx.Close()