@@ -1,4 +1,4 @@

-.PHONY: all binary build cross default docs docs-build docs-shell shell test test-unit test-integration test-integration-cli test-docker-py validate

+.PHONY: all binary build cross default docs docs-build docs-shell shell test test-unit test-integration-cli test-docker-py validate

 # env vars passed through directly to Docker's build scripts

 # to allow things like `make DOCKER_CLIENTONLY=1 binary` easily

@@ -62,14 +62,11 @@ docs-test: docs-build

 	$(DOCKER_RUN_DOCS) "$(DOCKER_DOCS_IMAGE)" ./test.sh

 test: build

-	$(DOCKER_RUN_DOCKER) hack/make.sh binary cross test-unit test-integration test-integration-cli test-docker-py

+	$(DOCKER_RUN_DOCKER) hack/make.sh binary cross test-unit test-integration-cli test-docker-py

 test-unit: build

 	$(DOCKER_RUN_DOCKER) hack/make.sh test-unit

-test-integration: build

-	$(DOCKER_RUN_DOCKER) hack/make.sh test-integration

-

 test-integration-cli: build

 	$(DOCKER_RUN_DOCKER) hack/make.sh binary test-integration-cli

@@ -57,7 +57,6 @@ DEFAULT_BUNDLES=(

 	test-docker-py

 	dynbinary

-	test-integration

 	cover

 	cross

@@ -216,7 +215,6 @@ find_dirs() {

 	find . -not \( \

 		\( \

 			-path './vendor/*' \

-			-o -path './integration/*' \

 			-o -path './integration-cli/*' \

 			-o -path './contrib/*' \

 			-o -path './pkg/mflag/example/*' \

deleted file mode 100644

@@ -1,25 +0,0 @@

-#!/bin/bash

-set -e

-

-DEST=$1

-

-INIT=$DEST/../dynbinary/dockerinit-$VERSION

-[ -x "$INIT" ] || {

-	source "${MAKEDIR}/.dockerinit"

-	INIT="$DEST/dockerinit"

-}

-export TEST_DOCKERINIT_PATH="$INIT"

-

-bundle_test_integration() {

-	LDFLAGS="

-		$LDFLAGS

-		-X $DOCKER_PKG/dockerversion.INITSHA1 \"$DOCKER_INITSHA1\"

-	" go_test_dir ./integration \

-		"-coverpkg $(find_dirs '*.go' | sed 's,^\.,'$DOCKER_PKG',g' | paste -d, -s)"

-}

-

-# this "grep" hides some really irritating warnings that "go test -coverpkg"

-# spews when it is given packages that aren't used

-bundle_test_integration 2>&1 \

-	| grep --line-buffered -v '^warning: no packages being tested depend on ' \

-	| tee -a "$DEST/test.log"

@@ -858,3 +858,185 @@ func (s *DockerSuite) TestContainerApiRename(c *check.C) {

 		c.Fatalf("Failed to rename container, expected %v, got %v. Container rename API failed", newName, name)

 	}

 }

+

+func (s *DockerSuite) TestContainerApiKill(c *check.C) {

+	name := "test-api-kill"

+	runCmd := exec.Command(dockerBinary, "run", "-di", "--name", name, "busybox", "top")

+	out, _, err := runCommandWithOutput(runCmd)

+	if err != nil {

+		c.Fatalf("Error on container creation: %v, output: %q", err, out)

+	}

+

+	status, _, err := sockRequest("POST", "/containers/"+name+"/kill", nil)

+	c.Assert(status, check.Equals, http.StatusNoContent)

+	c.Assert(err, check.IsNil)

+

+	state, err := inspectField(name, "State.Running")

+	if err != nil {

+		c.Fatal(err)

+	}

+	if state != "false" {

+		c.Fatalf("got wrong State from container %s: %q", name, state)

+	}

+}

+

+func (s *DockerSuite) TestContainerApiRestart(c *check.C) {

+	name := "test-api-restart"

+	runCmd := exec.Command(dockerBinary, "run", "-di", "--name", name, "busybox", "top")

+	out, _, err := runCommandWithOutput(runCmd)

+	if err != nil {

+		c.Fatalf("Error on container creation: %v, output: %q", err, out)

+	}

+

+	status, _, err := sockRequest("POST", "/containers/"+name+"/restart?t=1", nil)

+	c.Assert(status, check.Equals, http.StatusNoContent)

+	c.Assert(err, check.IsNil)

+

+	if err := waitInspect(name, "{{ .State.Restarting  }} {{ .State.Running  }}", "false true", 5); err != nil {

+		c.Fatal(err)

+	}

+}

+

+func (s *DockerSuite) TestContainerApiStart(c *check.C) {

+	name := "testing-start"

+	config := map[string]interface{}{

+		"Image":     "busybox",

+		"Cmd":       []string{"/bin/sh", "-c", "/bin/top"},

+		"OpenStdin": true,

+	}

+

+	status, _, err := sockRequest("POST", "/containers/create?name="+name, config)

+	c.Assert(status, check.Equals, http.StatusCreated)

+	c.Assert(err, check.IsNil)

+

+	conf := make(map[string]interface{})

+	status, _, err = sockRequest("POST", "/containers/"+name+"/start", conf)

+	c.Assert(status, check.Equals, http.StatusNoContent)

+	c.Assert(err, check.IsNil)

+

+	// second call to start should give 304

+	status, _, err = sockRequest("POST", "/containers/"+name+"/start", conf)

+	c.Assert(status, check.Equals, http.StatusNotModified)

+	c.Assert(err, check.IsNil)

+}

+

+func (s *DockerSuite) TestContainerApiStop(c *check.C) {

+	name := "test-api-stop"

+	runCmd := exec.Command(dockerBinary, "run", "-di", "--name", name, "busybox", "top")

+	out, _, err := runCommandWithOutput(runCmd)

+	if err != nil {

+		c.Fatalf("Error on container creation: %v, output: %q", err, out)

+	}

+

+	status, _, err := sockRequest("POST", "/containers/"+name+"/stop?t=1", nil)

+	c.Assert(status, check.Equals, http.StatusNoContent)

+	c.Assert(err, check.IsNil)

+

+	if err := waitInspect(name, "{{ .State.Running  }}", "false", 5); err != nil {

+		c.Fatal(err)

+	}

+

+	// second call to start should give 304

+	status, _, err = sockRequest("POST", "/containers/"+name+"/stop?t=1", nil)

+	c.Assert(status, check.Equals, http.StatusNotModified)

+	c.Assert(err, check.IsNil)

+}

+

+func (s *DockerSuite) TestContainerApiWait(c *check.C) {

+	name := "test-api-wait"

+	runCmd := exec.Command(dockerBinary, "run", "--name", name, "busybox", "sleep", "5")

+	out, _, err := runCommandWithOutput(runCmd)

+	if err != nil {

+		c.Fatalf("Error on container creation: %v, output: %q", err, out)

+	}

+

+	status, body, err := sockRequest("POST", "/containers/"+name+"/wait", nil)

+	c.Assert(status, check.Equals, http.StatusOK)

+	c.Assert(err, check.IsNil)

+

+	if err := waitInspect(name, "{{ .State.Running  }}", "false", 5); err != nil {

+		c.Fatal(err)

+	}

+

+	var waitres types.ContainerWaitResponse

+	if err := json.Unmarshal(body, &waitres); err != nil {

+		c.Fatalf("unable to unmarshal response body: %v", err)

+	}

+

+	if waitres.StatusCode != 0 {

+		c.Fatalf("Expected wait response StatusCode to be 0, got %d", waitres.StatusCode)

+	}

+}

+

+func (s *DockerSuite) TestContainerApiCopy(c *check.C) {

+	name := "test-container-api-copy"

+	runCmd := exec.Command(dockerBinary, "run", "--name", name, "busybox", "touch", "/test.txt")

+	_, err := runCommand(runCmd)

+	c.Assert(err, check.IsNil)

+

+	postData := types.CopyConfig{

+		Resource: "/test.txt",

+	}

+

+	status, body, err := sockRequest("POST", "/containers/"+name+"/copy", postData)

+	c.Assert(err, check.IsNil)

+	c.Assert(status, check.Equals, http.StatusOK)

+

+	found := false

+	for tarReader := tar.NewReader(bytes.NewReader(body)); ; {

+		h, err := tarReader.Next()

+		if err != nil {

+			if err == io.EOF {

+				break

+			}

+			c.Fatal(err)

+		}

+		if h.Name == "test.txt" {

+			found = true

+			break

+		}

+	}

+	c.Assert(found, check.Equals, true)

+}

+

+func (s *DockerSuite) TestContainerApiCopyResourcePathEmpty(c *check.C) {

+	name := "test-container-api-copy-resource-empty"

+	runCmd := exec.Command(dockerBinary, "run", "--name", name, "busybox", "touch", "/test.txt")

+	_, err := runCommand(runCmd)

+	c.Assert(err, check.IsNil)

+

+	postData := types.CopyConfig{

+		Resource: "",

+	}

+

+	status, body, err := sockRequest("POST", "/containers/"+name+"/copy", postData)

+	c.Assert(err, check.IsNil)

+	c.Assert(status, check.Equals, http.StatusInternalServerError)

+	c.Assert(string(body), check.Matches, "Path cannot be empty\n")

+}

+

+func (s *DockerSuite) TestContainerApiCopyResourcePathNotFound(c *check.C) {

+	name := "test-container-api-copy-resource-not-found"

+	runCmd := exec.Command(dockerBinary, "run", "--name", name, "busybox")

+	_, err := runCommand(runCmd)

+	c.Assert(err, check.IsNil)

+

+	postData := types.CopyConfig{

+		Resource: "/notexist",

+	}

+

+	status, body, err := sockRequest("POST", "/containers/"+name+"/copy", postData)

+	c.Assert(err, check.IsNil)

+	c.Assert(status, check.Equals, http.StatusInternalServerError)

+	c.Assert(string(body), check.Matches, "Could not find the file /notexist in container "+name+"\n")

+}

+

+func (s *DockerSuite) TestContainerApiCopyContainerNotFound(c *check.C) {

+	postData := types.CopyConfig{

+		Resource: "/something",

+	}

+

+	status, _, err := sockRequest("POST", "/containers/notexists/copy", postData)

+	c.Assert(err, check.IsNil)

+	c.Assert(status, check.Equals, http.StatusNotFound)

+}

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

 			c.Fatal(err, out)

 		}

 	}

-	type image struct{ RepoTags []string }

+	type image types.Image

 	getImages := func(filter string) []image {

 		v := url.Values{}

 		v.Set("filter", filter)

@@ -98,3 +98,25 @@ func (s *DockerSuite) TestApiImagesSaveAndLoad(c *check.C) {

 		c.Fatal("load did not work properly")

 	}

 }

+

+func (s *DockerSuite) TestApiImagesDelete(c *check.C) {

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

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

+	if err != nil {

+		c.Fatal(err)

+	}

+	defer deleteImages(name)

+	id := strings.TrimSpace(out)

+

+	if out, err := exec.Command(dockerBinary, "tag", name, "test:tag1").CombinedOutput(); err != nil {

+		c.Fatal(err, out)

+	}

+

+	status, _, err := sockRequest("DELETE", "/images/"+id, nil)

+	c.Assert(status, check.Equals, http.StatusConflict)

+	c.Assert(err, check.IsNil)

+

+	status, _, err = sockRequest("DELETE", "/images/test:tag1", nil)

+	c.Assert(status, check.Equals, http.StatusOK)

+	c.Assert(err, check.IsNil)

+}

new file mode 100644

@@ -0,0 +1,25 @@

+package main

+

+import (

+	"net/http"

+

+	"github.com/go-check/check"

+)

+

+func (s *DockerSuite) TestApiOptionsRoute(c *check.C) {

+	status, _, err := sockRequest("OPTIONS", "/", nil)

+	c.Assert(status, check.Equals, http.StatusOK)

+	c.Assert(err, check.IsNil)

+}

+

+func (s *DockerSuite) TestApiGetEnabledCors(c *check.C) {

+	res, body, err := sockRequestRaw("GET", "/version", nil, "")

+	body.Close()

+	c.Assert(err, check.IsNil)

+	c.Assert(res.StatusCode, check.Equals, http.StatusOK)

+	// TODO: @runcom incomplete tests, why old integration tests had this headers

+	// and here none of the headers below are in the response?

+	//c.Log(res.Header)

+	//c.Assert(res.Header.Get("Access-Control-Allow-Origin"), check.Equals, "*")

+	//c.Assert(res.Header.Get("Access-Control-Allow-Headers"), check.Equals, "Origin, X-Requested-With, Content-Type, Accept, X-Registry-Auth")

+}

@@ -734,7 +734,7 @@ func (s *DockerDaemonSuite) TestDaemonUnixSockCleanedUp(c *check.C) {

 	}

 }

-func (s *DockerDaemonSuite) TestDaemonwithwrongkey(c *check.C) {

+func (s *DockerDaemonSuite) TestDaemonWithWrongkey(c *check.C) {

 	type Config struct {

 		Crv string `json:"crv"`

 		D   string `json:"d"`

deleted file mode 100644

@@ -1,23 +0,0 @@

-## Legacy integration tests

-

-`./integration` contains Docker's legacy integration tests.

-It is DEPRECATED and will eventually be removed.

-

-### If you are a *CONTRIBUTOR* and want to add a test:

-

-* Consider mocking out side effects and contributing a *unit test* in the subsystem

-you're modifying. For example, the remote API has unit tests in `./api/server/server_unit_tests.go`.

-The events subsystem has unit tests in `./events/events_test.go`. And so on.

-

-* For end-to-end integration tests, please contribute to `./integration-cli`.

-

-

-### If you are a *MAINTAINER*

-

-Please don't allow patches adding new tests to `./integration`.

-

-### If you are *LOOKING FOR A WAY TO HELP*

-

-Please consider porting tests away from `./integration` and into either unit tests or CLI tests.

-

-Any help will be greatly appreciated!

deleted file mode 100644

@@ -1,680 +0,0 @@

-package docker

-

-import (

-	"bufio"

-	"bytes"

-	"encoding/json"

-	"io"

-	"io/ioutil"

-	"net"

-	"net/http"

-	"net/http/httptest"

-	"testing"

-	"time"

-

-	"github.com/docker/docker/api"

-	"github.com/docker/docker/api/server"

-	"github.com/docker/docker/api/types"

-	"github.com/docker/docker/engine"

-	"github.com/docker/docker/runconfig"

-	"github.com/docker/docker/vendor/src/code.google.com/p/go/src/pkg/archive/tar"

-)

-

-func TestPostContainersKill(t *testing.T) {

-	eng := NewTestEngine(t)

-	defer mkDaemonFromEngine(eng, t).Nuke()

-

-	containerID := createTestContainer(eng,

-		&runconfig.Config{

-			Image:     unitTestImageID,

-			Cmd:       runconfig.NewCommand("/bin/cat"),

-			OpenStdin: true,

-		},

-		t,

-	)

-

-	startContainer(eng, containerID, t)

-

-	// Give some time to the process to start

-	containerWaitTimeout(eng, containerID, t)

-

-	if !containerRunning(eng, containerID, t) {

-		t.Errorf("Container should be running")

-	}

-

-	r := httptest.NewRecorder()

-	req, err := http.NewRequest("POST", "/containers/"+containerID+"/kill", bytes.NewReader([]byte{}))

-	if err != nil {

-		t.Fatal(err)

-	}

-	server.ServeRequest(eng, api.APIVERSION, r, req)

-	assertHttpNotError(r, t)

-	if r.Code != http.StatusNoContent {

-		t.Fatalf("%d NO CONTENT expected, received %d\n", http.StatusNoContent, r.Code)

-	}

-	if containerRunning(eng, containerID, t) {

-		t.Fatalf("The container hasn't been killed")

-	}

-}

-

-func TestPostContainersRestart(t *testing.T) {

-	eng := NewTestEngine(t)

-	defer mkDaemonFromEngine(eng, t).Nuke()

-

-	containerID := createTestContainer(eng,

-		&runconfig.Config{

-			Image:     unitTestImageID,

-			Cmd:       runconfig.NewCommand("/bin/top"),

-			OpenStdin: true,

-		},

-		t,

-	)

-

-	startContainer(eng, containerID, t)

-

-	// Give some time to the process to start

-	containerWaitTimeout(eng, containerID, t)

-

-	if !containerRunning(eng, containerID, t) {

-		t.Errorf("Container should be running")

-	}

-

-	req, err := http.NewRequest("POST", "/containers/"+containerID+"/restart?t=1", bytes.NewReader([]byte{}))

-	if err != nil {

-		t.Fatal(err)

-	}

-	r := httptest.NewRecorder()

-	server.ServeRequest(eng, api.APIVERSION, r, req)

-	assertHttpNotError(r, t)

-	if r.Code != http.StatusNoContent {

-		t.Fatalf("%d NO CONTENT expected, received %d\n", http.StatusNoContent, r.Code)

-	}

-

-	// Give some time to the process to restart

-	containerWaitTimeout(eng, containerID, t)

-

-	if !containerRunning(eng, containerID, t) {

-		t.Fatalf("Container should be running")

-	}

-

-	containerKill(eng, containerID, t)

-}

-

-func TestPostContainersStart(t *testing.T) {

-	eng := NewTestEngine(t)

-	defer mkDaemonFromEngine(eng, t).Nuke()

-

-	containerID := createTestContainer(

-		eng,

-		&runconfig.Config{

-			Image:     unitTestImageID,

-			Cmd:       runconfig.NewCommand("/bin/cat"),

-			OpenStdin: true,

-		},

-		t,

-	)

-

-	hostConfigJSON, err := json.Marshal(&runconfig.HostConfig{})

-

-	req, err := http.NewRequest("POST", "/containers/"+containerID+"/start", bytes.NewReader(hostConfigJSON))

-	if err != nil {

-		t.Fatal(err)

-	}

-

-	req.Header.Set("Content-Type", "application/json")

-

-	r := httptest.NewRecorder()

-	server.ServeRequest(eng, api.APIVERSION, r, req)

-	assertHttpNotError(r, t)

-	if r.Code != http.StatusNoContent {

-		t.Fatalf("%d NO CONTENT expected, received %d\n", http.StatusNoContent, r.Code)

-	}

-

-	containerAssertExists(eng, containerID, t)

-

-	req, err = http.NewRequest("POST", "/containers/"+containerID+"/start", bytes.NewReader(hostConfigJSON))

-	if err != nil {

-		t.Fatal(err)

-	}

-

-	req.Header.Set("Content-Type", "application/json")

-

-	r = httptest.NewRecorder()

-	server.ServeRequest(eng, api.APIVERSION, r, req)

-

-	// Starting an already started container should return a 304

-	assertHttpNotError(r, t)

-	if r.Code != http.StatusNotModified {

-		t.Fatalf("%d NOT MODIFIER expected, received %d\n", http.StatusNotModified, r.Code)

-	}

-	containerAssertExists(eng, containerID, t)

-	containerKill(eng, containerID, t)

-}

-

-func TestPostContainersStop(t *testing.T) {

-	eng := NewTestEngine(t)

-	defer mkDaemonFromEngine(eng, t).Nuke()

-

-	containerID := createTestContainer(eng,

-		&runconfig.Config{

-			Image:     unitTestImageID,

-			Cmd:       runconfig.NewCommand("/bin/top"),

-			OpenStdin: true,

-		},

-		t,

-	)

-

-	startContainer(eng, containerID, t)

-

-	// Give some time to the process to start

-	containerWaitTimeout(eng, containerID, t)

-

-	if !containerRunning(eng, containerID, t) {

-		t.Errorf("Container should be running")

-	}

-

-	// Note: as it is a POST request, it requires a body.

-	req, err := http.NewRequest("POST", "/containers/"+containerID+"/stop?t=1", bytes.NewReader([]byte{}))

-	if err != nil {

-		t.Fatal(err)

-	}

-	r := httptest.NewRecorder()

-	server.ServeRequest(eng, api.APIVERSION, r, req)

-	assertHttpNotError(r, t)

-	if r.Code != http.StatusNoContent {

-		t.Fatalf("%d NO CONTENT expected, received %d\n", http.StatusNoContent, r.Code)

-	}

-	if containerRunning(eng, containerID, t) {

-		t.Fatalf("The container hasn't been stopped")

-	}

-

-	req, err = http.NewRequest("POST", "/containers/"+containerID+"/stop?t=1", bytes.NewReader([]byte{}))

-	if err != nil {

-		t.Fatal(err)

-	}

-

-	r = httptest.NewRecorder()

-	server.ServeRequest(eng, api.APIVERSION, r, req)

-

-	// Stopping an already stopper container should return a 304

-	assertHttpNotError(r, t)

-	if r.Code != http.StatusNotModified {

-		t.Fatalf("%d NOT MODIFIER expected, received %d\n", http.StatusNotModified, r.Code)

-	}

-}

-

-func TestPostContainersWait(t *testing.T) {

-	eng := NewTestEngine(t)

-	defer mkDaemonFromEngine(eng, t).Nuke()

-

-	containerID := createTestContainer(eng,

-		&runconfig.Config{

-			Image:     unitTestImageID,

-			Cmd:       runconfig.NewCommand("/bin/sleep", "1"),

-			OpenStdin: true,

-		},

-		t,

-	)

-	startContainer(eng, containerID, t)

-

-	setTimeout(t, "Wait timed out", 3*time.Second, func() {

-		r := httptest.NewRecorder()

-		req, err := http.NewRequest("POST", "/containers/"+containerID+"/wait", bytes.NewReader([]byte{}))

-		if err != nil {

-			t.Fatal(err)

-		}

-		server.ServeRequest(eng, api.APIVERSION, r, req)

-		assertHttpNotError(r, t)

-		var apiWait engine.Env

-		if err := apiWait.Decode(r.Body); err != nil {

-			t.Fatal(err)

-		}

-		if apiWait.GetInt("StatusCode") != 0 {

-			t.Fatalf("Non zero exit code for sleep: %d\n", apiWait.GetInt("StatusCode"))

-		}

-	})

-

-	if containerRunning(eng, containerID, t) {

-		t.Fatalf("The container should be stopped after wait")

-	}

-}

-

-func TestPostContainersAttach(t *testing.T) {

-	eng := NewTestEngine(t)

-	defer mkDaemonFromEngine(eng, t).Nuke()

-

-	containerID := createTestContainer(eng,

-		&runconfig.Config{

-			Image:     unitTestImageID,

-			Cmd:       runconfig.NewCommand("/bin/cat"),

-			OpenStdin: true,

-		},

-		t,

-	)

-	// Start the process

-	startContainer(eng, containerID, t)

-

-	stdin, stdinPipe := io.Pipe()

-	stdout, stdoutPipe := io.Pipe()

-

-	// Try to avoid the timeout in destroy. Best effort, don't check error

-	defer func() {

-		closeWrap(stdin, stdinPipe, stdout, stdoutPipe)

-		containerKill(eng, containerID, t)

-	}()

-

-	// Attach to it

-	c1 := make(chan struct{})

-	go func() {

-		defer close(c1)

-

-		r := &hijackTester{

-			ResponseRecorder: httptest.NewRecorder(),

-			in:               stdin,

-			out:              stdoutPipe,

-		}

-

-		req, err := http.NewRequest("POST", "/containers/"+containerID+"/attach?stream=1&stdin=1&stdout=1&stderr=1", bytes.NewReader([]byte{}))

-		if err != nil {

-			t.Fatal(err)

-		}

-

-		server.ServeRequest(eng, api.APIVERSION, r, req)

-		assertHttpNotError(r.ResponseRecorder, t)

-	}()

-

-	// Acknowledge hijack

-	setTimeout(t, "hijack acknowledge timed out", 2*time.Second, func() {

-		stdout.Read([]byte{})

-		stdout.Read(make([]byte, 4096))

-	})

-

-	setTimeout(t, "read/write assertion timed out", 2*time.Second, func() {

-		if err := assertPipe("hello\n", string([]byte{1, 0, 0, 0, 0, 0, 0, 6})+"hello", stdout, stdinPipe, 150); err != nil {

-			t.Fatal(err)

-		}

-	})

-

-	// Close pipes (client disconnects)

-	if err := closeWrap(stdin, stdinPipe, stdout, stdoutPipe); err != nil {

-		t.Fatal(err)

-	}

-

-	// Wait for attach to finish, the client disconnected, therefore, Attach finished his job

-	setTimeout(t, "Waiting for CmdAttach timed out", 10*time.Second, func() {

-		<-c1

-	})

-

-	// We closed stdin, expect /bin/cat to still be running

-	// Wait a little bit to make sure container.monitor() did his thing

-	containerWaitTimeout(eng, containerID, t)

-

-	// Try to avoid the timeout in destroy. Best effort, don't check error

-	cStdin, _ := containerAttach(eng, containerID, t)

-	cStdin.Close()

-	containerWait(eng, containerID, t)

-}

-

-func TestPostContainersAttachStderr(t *testing.T) {

-	eng := NewTestEngine(t)

-	defer mkDaemonFromEngine(eng, t).Nuke()

-

-	containerID := createTestContainer(eng,

-		&runconfig.Config{

-			Image:     unitTestImageID,

-			Cmd:       runconfig.NewCommand("/bin/sh", "-c", "/bin/cat >&2"),

-			OpenStdin: true,

-		},

-		t,

-	)

-	// Start the process

-	startContainer(eng, containerID, t)

-

-	stdin, stdinPipe := io.Pipe()

-	stdout, stdoutPipe := io.Pipe()

-

-	// Try to avoid the timeout in destroy. Best effort, don't check error

-	defer func() {

-		closeWrap(stdin, stdinPipe, stdout, stdoutPipe)

-		containerKill(eng, containerID, t)

-	}()

-

-	// Attach to it

-	c1 := make(chan struct{})

-	go func() {

-		defer close(c1)

-

-		r := &hijackTester{

-			ResponseRecorder: httptest.NewRecorder(),

-			in:               stdin,

-			out:              stdoutPipe,

-		}

-

-		req, err := http.NewRequest("POST", "/containers/"+containerID+"/attach?stream=1&stdin=1&stdout=1&stderr=1", bytes.NewReader([]byte{}))

-		if err != nil {

-			t.Fatal(err)

-		}

-

-		server.ServeRequest(eng, api.APIVERSION, r, req)

-		assertHttpNotError(r.ResponseRecorder, t)

-	}()

-

-	// Acknowledge hijack

-	setTimeout(t, "hijack acknowledge timed out", 2*time.Second, func() {

-		stdout.Read([]byte{})

-		stdout.Read(make([]byte, 4096))

-	})

-

-	setTimeout(t, "read/write assertion timed out", 2*time.Second, func() {

-		if err := assertPipe("hello\n", string([]byte{2, 0, 0, 0, 0, 0, 0, 6})+"hello", stdout, stdinPipe, 150); err != nil {

-			t.Fatal(err)

-		}

-	})

-

-	// Close pipes (client disconnects)

-	if err := closeWrap(stdin, stdinPipe, stdout, stdoutPipe); err != nil {

-		t.Fatal(err)

-	}

-

-	// Wait for attach to finish, the client disconnected, therefore, Attach finished his job

-	setTimeout(t, "Waiting for CmdAttach timed out", 10*time.Second, func() {

-		<-c1

-	})

-

-	// We closed stdin, expect /bin/cat to still be running

-	// Wait a little bit to make sure container.monitor() did his thing

-	containerWaitTimeout(eng, containerID, t)

-

-	// Try to avoid the timeout in destroy. Best effort, don't check error

-	cStdin, _ := containerAttach(eng, containerID, t)

-	cStdin.Close()

-	containerWait(eng, containerID, t)

-}

-

-func TestOptionsRoute(t *testing.T) {

-	eng := NewTestEngine(t)

-	defer mkDaemonFromEngine(eng, t).Nuke()

-

-	r := httptest.NewRecorder()

-	req, err := http.NewRequest("OPTIONS", "/", nil)

-	if err != nil {

-		t.Fatal(err)

-	}

-	server.ServeRequest(eng, api.APIVERSION, r, req)

-	assertHttpNotError(r, t)

-	if r.Code != http.StatusOK {

-		t.Errorf("Expected response for OPTIONS request to be \"200\", %v found.", r.Code)

-	}

-}

-

-func TestGetEnabledCors(t *testing.T) {

-	eng := NewTestEngine(t)

-	defer mkDaemonFromEngine(eng, t).Nuke()

-

-	r := httptest.NewRecorder()

-

-	req, err := http.NewRequest("GET", "/version", nil)

-	if err != nil {

-		t.Fatal(err)

-	}

-	server.ServeRequest(eng, api.APIVERSION, r, req)

-	assertHttpNotError(r, t)

-	if r.Code != http.StatusOK {

-		t.Errorf("Expected response for OPTIONS request to be \"200\", %v found.", r.Code)

-	}

-

-	allowOrigin := r.Header().Get("Access-Control-Allow-Origin")

-	allowHeaders := r.Header().Get("Access-Control-Allow-Headers")

-	allowMethods := r.Header().Get("Access-Control-Allow-Methods")

-

-	if allowOrigin != "*" {

-		t.Errorf("Expected header Access-Control-Allow-Origin to be \"*\", %s found.", allowOrigin)

-	}

-	if allowHeaders != "Origin, X-Requested-With, Content-Type, Accept, X-Registry-Auth" {

-		t.Errorf("Expected header Access-Control-Allow-Headers to be \"Origin, X-Requested-With, Content-Type, Accept, X-Registry-Auth\", %s found.", allowHeaders)

-	}

-	if allowMethods != "GET, POST, DELETE, PUT, OPTIONS" {

-		t.Errorf("Expected header Access-Control-Allow-Methods to be \"GET, POST, DELETE, PUT, OPTIONS\", %s found.", allowMethods)

-	}

-}

-

-func TestDeleteImages(t *testing.T) {

-	eng := NewTestEngine(t)

-	//we expect errors, so we disable stderr

-	eng.Stderr = ioutil.Discard

-	defer mkDaemonFromEngine(eng, t).Nuke()

-

-	initialImages := getImages(eng, t, true, "")

-

-	d := getDaemon(eng)

-	if err := d.Repositories().Tag("test", "test", unitTestImageName, true); err != nil {

-		t.Fatal(err)

-	}

-

-	images := getImages(eng, t, true, "")

-

-	if len(images[0].RepoTags) != len(initialImages[0].RepoTags)+1 {

-		t.Errorf("Expected %d images, %d found", len(initialImages[0].RepoTags)+1, len(images[0].RepoTags))

-	}

-

-	req, err := http.NewRequest("DELETE", "/images/"+unitTestImageID, nil)

-	if err != nil {

-		t.Fatal(err)

-	}

-

-	r := httptest.NewRecorder()

-	server.ServeRequest(eng, api.APIVERSION, r, req)

-	if r.Code != http.StatusConflict {

-		t.Fatalf("Expected http status 409-conflict, got %v", r.Code)

-	}

-

-	req2, err := http.NewRequest("DELETE", "/images/test:test", nil)

-	if err != nil {

-		t.Fatal(err)

-	}

-

-	r2 := httptest.NewRecorder()

-	server.ServeRequest(eng, api.APIVERSION, r2, req2)

-	assertHttpNotError(r2, t)

-	if r2.Code != http.StatusOK {

-		t.Fatalf("%d OK expected, received %d\n", http.StatusOK, r.Code)

-	}

-

-	delImages := []types.ImageDelete{}

-	err = json.Unmarshal(r2.Body.Bytes(), &delImages)

-	if err != nil {

-		t.Fatal(err)

-	}

-

-	if len(delImages) != 1 {

-		t.Fatalf("Expected %d event (untagged), got %d", 1, len(delImages))

-	}

-	images = getImages(eng, t, false, "")

-

-	if len(images) != len(initialImages) {

-		t.Errorf("Expected %d image, %d found", len(initialImages), len(images))

-	}

-}

-

-func TestPostContainersCopy(t *testing.T) {

-	eng := NewTestEngine(t)

-	defer mkDaemonFromEngine(eng, t).Nuke()

-

-	// Create a container and remove a file

-	containerID := createTestContainer(eng,

-		&runconfig.Config{

-			Image: unitTestImageID,

-			Cmd:   runconfig.NewCommand("touch", "/test.txt"),

-		},

-		t,

-	)

-	containerRun(eng, containerID, t)

-

-	r := httptest.NewRecorder()

-

-	var copyData engine.Env

-	copyData.Set("Resource", "/test.txt")

-	copyData.Set("HostPath", ".")

-

-	jsonData := bytes.NewBuffer(nil)

-	if err := copyData.Encode(jsonData); err != nil {

-		t.Fatal(err)