Initial commit

vendor/github.com/hyperhq/hypercli/integration-cli/future/api/hyper_api_images_test.go

@@ -0,0 +1,118 @@
+package main
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/url"
+	"strings"
+
+	"github.com/docker/docker/pkg/integration/checker"
+	"github.com/docker/engine-api/types"
+	"github.com/go-check/check"
+)
+
+func (s *DockerSuite) TestApiImagesFilter(c *check.C) {
+	name := "utest:tag1"
+	name2 := "utest/docker:tag2"
+	name3 := "utest:5000/docker:tag3"
+	for _, n := range []string{name, name2, name3} {
+		dockerCmd(c, "tag", "busybox", n)
+	}
+	type image types.Image
+	getImages := func(filter string) []image {
+		v := url.Values{}
+		v.Set("filter", filter)
+		status, b, err := sockRequest("GET", "/images/json?"+v.Encode(), nil)
+		c.Assert(err, checker.IsNil)
+		c.Assert(status, checker.Equals, http.StatusOK)
+
+		var images []image
+		err = json.Unmarshal(b, &images)
+		c.Assert(err, checker.IsNil)
+
+		return images
+	}
+
+	//incorrect number of matches returned
+	images := getImages("utest*/*")
+	c.Assert(images[0].RepoTags, checker.HasLen, 2)
+
+	images = getImages("utest")
+	c.Assert(images[0].RepoTags, checker.HasLen, 1)
+
+	images = getImages("utest*")
+	c.Assert(images[0].RepoTags, checker.HasLen, 1)
+
+	images = getImages("*5000*/*")
+	c.Assert(images[0].RepoTags, checker.HasLen, 1)
+}
+
+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)
+
+	res, body, err := sockRequestRaw("GET", "/images/"+id+"/get", nil, "")
+	c.Assert(err, checker.IsNil)
+	defer body.Close()
+	c.Assert(res.StatusCode, checker.Equals, http.StatusOK)
+
+	dockerCmd(c, "rmi", id)
+
+	res, loadBody, err := sockRequestRaw("POST", "/images/load", body, "application/x-tar")
+	c.Assert(err, checker.IsNil)
+	defer loadBody.Close()
+	c.Assert(res.StatusCode, checker.Equals, http.StatusOK)
+
+	inspectOut := inspectField(c, id, "Id")
+	c.Assert(strings.TrimSpace(string(inspectOut)), checker.Equals, id, check.Commentf("load did not work properly"))
+}
+
+func (s *DockerSuite) TestApiImagesDelete(c *check.C) {
+	if daemonPlatform != "windows" {
+		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)
+
+	dockerCmd(c, "tag", name, "test:tag1")
+
+	status, _, err := sockRequest("DELETE", "/images/"+id, nil)
+	c.Assert(err, checker.IsNil)
+	c.Assert(status, checker.Equals, http.StatusConflict)
+
+	status, _, err = sockRequest("DELETE", "/images/test:noexist", nil)
+	c.Assert(err, checker.IsNil)
+	c.Assert(status, checker.Equals, http.StatusNotFound) //Status Codes:404 – no such image
+
+	status, _, err = sockRequest("DELETE", "/images/test:tag1", nil)
+	c.Assert(err, checker.IsNil)
+	c.Assert(status, checker.Equals, http.StatusOK)
+}
+
+func (s *DockerSuite) TestApiImagesHistory(c *check.C) {
+	if daemonPlatform != "windows" {
+		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)
+
+	status, body, err := sockRequest("GET", "/images/"+id+"/history", nil)
+	c.Assert(err, checker.IsNil)
+	c.Assert(status, checker.Equals, http.StatusOK)
+
+	var historydata []types.ImageHistory
+	err = json.Unmarshal(body, &historydata)
+	c.Assert(err, checker.IsNil, check.Commentf("Error on unmarshal"))
+
+	c.Assert(historydata, checker.Not(checker.HasLen), 0)
+	c.Assert(historydata[0].Tags[0], checker.Equals, "test-api-images-history:latest")
+}

vendor/github.com/hyperhq/hypercli/integration-cli/future/api/hyper_api_volume_init_test.go

@@ -0,0 +1,39 @@
+package main
+
+import (
+	"net/http"
+
+	"github.com/docker/engine-api/types"
+	"github.com/go-check/check"
+)
+
+func (s *DockerSuite) TestApiVolumeInit(c *check.C) {
+	source := "https://raw.githubusercontent.com/hyperhq/hypercli/master/README.md"
+	volName := "hyperclitestvol"
+	dockerCmd(c, "volume", "create", "--name="+volName)
+	options := types.VolumesInitializeRequest{
+		Reload: false,
+		Volume: make([]types.VolumeInitDesc, 0),
+	}
+	options.Volume = append(options.Volume, types.VolumeInitDesc{Name: volName, Source: source})
+	status, b, err := sockRequest("POST", "/volumes/initialize", options)
+	c.Assert(err, check.IsNil)
+	c.Assert(status, check.Equals, http.StatusOK, check.Commentf(string(b)))
+	dockerCmd(c, "volume", "rm", volName)
+}
+
+func (s *DockerSuite) TestApiVolumeReload(c *check.C) {
+	source := "https://raw.githubusercontent.com/hyperhq/hypercli/master/README.md"
+	volName := "hyperclitestvol"
+	dockerCmd(c, "volume", "create", "--name="+volName)
+	dockerCmd(c, "volume", "init", source+":"+volName)
+	options := types.VolumesInitializeRequest{
+		Reload: true,
+		Volume: make([]types.VolumeInitDesc, 0),
+	}
+	options.Volume = append(options.Volume, types.VolumeInitDesc{Name: volName, Source: source})
+	status, b, err := sockRequest("POST", "/volumes/initialize", options)
+	c.Assert(err, check.IsNil)
+	c.Assert(status, check.Equals, http.StatusOK, check.Commentf(string(b)))
+	dockerCmd(c, "volume", "rm", volName)
+}

vendor/github.com/hyperhq/hypercli/integration-cli/future/cli/hyper_cli_images_test.go

@@ -0,0 +1,290 @@
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/docker/docker/pkg/integration/checker"
+	"github.com/docker/docker/pkg/stringid"
+	"github.com/go-check/check"
+)
+
+func (s *DockerSuite) TestImagesEnsureImageIsListed(c *check.C) {
+	testRequires(c, DaemonIsLinux)
+	imagesOut, _ := dockerCmd(c, "images")
+	c.Assert(imagesOut, checker.Contains, "busybox")
+}
+
+func (s *DockerSuite) TestImagesEnsureImageWithTagIsListed(c *check.C) {
+	testRequires(c, DaemonIsLinux)
+
+	name := "imagewithtag"
+	dockerCmd(c, "tag", "busybox", name+":v1")
+	dockerCmd(c, "tag", "busybox", name+":v1v1")
+	dockerCmd(c, "tag", "busybox", name+":v2")
+
+	imagesOut, _ := dockerCmd(c, "images", name+":v1")
+	c.Assert(imagesOut, checker.Contains, name)
+	c.Assert(imagesOut, checker.Contains, "v1")
+	c.Assert(imagesOut, checker.Not(checker.Contains), "v2")
+	c.Assert(imagesOut, checker.Not(checker.Contains), "v1v1")
+
+	imagesOut, _ = dockerCmd(c, "images", name)
+	c.Assert(imagesOut, checker.Contains, name)
+	c.Assert(imagesOut, checker.Contains, "v1")
+	c.Assert(imagesOut, checker.Contains, "v1v1")
+	c.Assert(imagesOut, checker.Contains, "v2")
+}
+
+func (s *DockerSuite) TestImagesEnsureImageWithBadTagIsNotListed(c *check.C) {
+	imagesOut, _ := dockerCmd(c, "images", "busybox:nonexistent")
+	c.Assert(imagesOut, checker.Not(checker.Contains), "busybox")
+}
+
+func (s *DockerSuite) TestImagesOrderedByCreationDate(c *check.C) {
+	testRequires(c, DaemonIsLinux)
+	id1, err := buildImage("order:test_a",
+		`FROM scratch
+                MAINTAINER dockerio1`, true)
+	c.Assert(err, checker.IsNil)
+	time.Sleep(1 * time.Second)
+	id2, err := buildImage("order:test_c",
+		`FROM scratch
+                MAINTAINER dockerio2`, true)
+	c.Assert(err, checker.IsNil)
+	time.Sleep(1 * time.Second)
+	id3, err := buildImage("order:test_b",
+		`FROM scratch
+                MAINTAINER dockerio3`, true)
+	c.Assert(err, checker.IsNil)
+
+	out, _ := dockerCmd(c, "images", "-q", "--no-trunc")
+	imgs := strings.Split(out, "\n")
+	c.Assert(imgs[0], checker.Equals, id3, check.Commentf("First image must be %s, got %s", id3, imgs[0]))
+	c.Assert(imgs[1], checker.Equals, id2, check.Commentf("First image must be %s, got %s", id2, imgs[1]))
+	c.Assert(imgs[2], checker.Equals, id1, check.Commentf("First image must be %s, got %s", id1, imgs[2]))
+}
+
+func (s *DockerSuite) TestImagesErrorWithInvalidFilterNameTest(c *check.C) {
+	out, _, err := dockerCmdWithError("images", "-f", "FOO=123")
+	c.Assert(err, checker.NotNil)
+	c.Assert(out, checker.Contains, "Invalid filter")
+}
+
+func (s *DockerSuite) TestImagesFilterLabelMatch(c *check.C) {
+	testRequires(c, DaemonIsLinux)
+	imageName1 := "images_filter_test1"
+	imageName2 := "images_filter_test2"
+	imageName3 := "images_filter_test3"
+	image1ID, err := buildImage(imageName1,
+		`FROM scratch
+                 LABEL match me`, true)
+	c.Assert(err, check.IsNil)
+
+	image2ID, err := buildImage(imageName2,
+		`FROM scratch
+                 LABEL match="me too"`, true)
+	c.Assert(err, check.IsNil)
+
+	image3ID, err := buildImage(imageName3,
+		`FROM scratch
+                 LABEL nomatch me`, true)
+	c.Assert(err, check.IsNil)
+
+	out, _ := dockerCmd(c, "images", "--no-trunc", "-q", "-f", "label=match")
+	out = strings.TrimSpace(out)
+	c.Assert(out, check.Matches, fmt.Sprintf("[\\s\\w:]*%s[\\s\\w:]*", image1ID))
+	c.Assert(out, check.Matches, fmt.Sprintf("[\\s\\w:]*%s[\\s\\w:]*", image2ID))
+	c.Assert(out, check.Not(check.Matches), fmt.Sprintf("[\\s\\w:]*%s[\\s\\w:]*", image3ID))
+
+	out, _ = dockerCmd(c, "images", "--no-trunc", "-q", "-f", "label=match=me too")
+	out = strings.TrimSpace(out)
+	c.Assert(out, check.Equals, image2ID)
+}
+
+// Regression : #15659
+func (s *DockerSuite) TestImagesFilterLabelWithCommit(c *check.C) {
+	// Create a container
+	dockerCmd(c, "run", "--name", "bar", "busybox", "/bin/sh")
+	// Commit with labels "using changes"
+	out, _ := dockerCmd(c, "commit", "-c", "LABEL foo.version=1.0.0-1", "-c", "LABEL foo.name=bar", "-c", "LABEL foo.author=starlord", "bar", "bar:1.0.0-1")
+	imageID := strings.TrimSpace(out)
+
+	out, _ = dockerCmd(c, "images", "--no-trunc", "-q", "-f", "label=foo.version=1.0.0-1")
+	out = strings.TrimSpace(out)
+	c.Assert(out, check.Equals, imageID)
+}
+
+func (s *DockerSuite) TestImagesFilterSpaceTrimCase(c *check.C) {
+	testRequires(c, DaemonIsLinux)
+	imageName := "images_filter_test"
+	buildImage(imageName,
+		`FROM scratch
+                 RUN touch /test/foo
+                 RUN touch /test/bar
+                 RUN touch /test/baz`, true)
+
+	filters := []string{
+		"dangling=true",
+		"Dangling=true",
+		" dangling=true",
+		"dangling=true ",
+		"dangling = true",
+	}
+
+	imageListings := make([][]string, 5, 5)
+	for idx, filter := range filters {
+		out, _ := dockerCmd(c, "images", "-q", "-f", filter)
+		listing := strings.Split(out, "\n")
+		sort.Strings(listing)
+		imageListings[idx] = listing
+	}
+
+	for idx, listing := range imageListings {
+		if idx < 4 && !reflect.DeepEqual(listing, imageListings[idx+1]) {
+			for idx, errListing := range imageListings {
+				fmt.Printf("out %d", idx)
+				for _, image := range errListing {
+					fmt.Print(image)
+				}
+				fmt.Print("")
+			}
+			c.Fatalf("All output must be the same")
+		}
+	}
+}
+
+func (s *DockerSuite) TestImagesEnsureDanglingImageOnlyListedOnce(c *check.C) {
+	testRequires(c, DaemonIsLinux)
+	// create container 1
+	out, _ := dockerCmd(c, "run", "-d", "busybox", "true")
+	containerID1 := strings.TrimSpace(out)
+
+	// tag as foobox
+	out, _ = dockerCmd(c, "commit", containerID1, "foobox")
+	imageID := stringid.TruncateID(strings.TrimSpace(out))
+
+	// overwrite the tag, making the previous image dangling
+	dockerCmd(c, "tag", "-f", "busybox", "foobox")
+
+	out, _ = dockerCmd(c, "images", "-q", "-f", "dangling=true")
+	// Expect one dangling image
+	c.Assert(strings.Count(out, imageID), checker.Equals, 1)
+
+	out, _ = dockerCmd(c, "images", "-q", "-f", "dangling=false")
+	//dangling=false would not include dangling images
+	c.Assert(out, checker.Not(checker.Contains), imageID)
+
+	out, _ = dockerCmd(c, "images")
+	//docker images still include dangling images
+	c.Assert(out, checker.Contains, imageID)
+
+}
+
+func (s *DockerSuite) TestImagesWithIncorrectFilter(c *check.C) {
+	out, _, err := dockerCmdWithError("images", "-f", "dangling=invalid")
+	c.Assert(err, check.NotNil)
+	c.Assert(out, checker.Contains, "Invalid filter")
+}
+
+func (s *DockerSuite) TestImagesEnsureOnlyHeadsImagesShown(c *check.C) {
+	testRequires(c, DaemonIsLinux)
+
+	dockerfile := `
+        FROM scratch
+        MAINTAINER docker
+        ENV foo bar`
+
+	head, out, err := buildImageWithOut("scratch-image", dockerfile, false)
+	c.Assert(err, check.IsNil)
+
+	// this is just the output of docker build
+	// we're interested in getting the image id of the MAINTAINER instruction
+	// and that's located at output, line 5, from 7 to end
+	split := strings.Split(out, "\n")
+	intermediate := strings.TrimSpace(split[5][7:])
+
+	out, _ = dockerCmd(c, "images")
+	// images shouldn't show non-heads images
+	c.Assert(out, checker.Not(checker.Contains), intermediate)
+	// images should contain final built images
+	c.Assert(out, checker.Contains, stringid.TruncateID(head))
+}
+
+func (s *DockerSuite) TestImagesEnsureImagesFromScratchShown(c *check.C) {
+	testRequires(c, DaemonIsLinux)
+
+	dockerfile := `
+        FROM scratch
+        MAINTAINER docker`
+
+	id, _, err := buildImageWithOut("scratch-image", dockerfile, false)
+	c.Assert(err, check.IsNil)
+
+	out, _ := dockerCmd(c, "images")
+	// images should contain images built from scratch
+	c.Assert(out, checker.Contains, stringid.TruncateID(id))
+}
+
+// #18181
+func (s *DockerSuite) TestImagesFilterNameWithPort(c *check.C) {
+	tag := "a.b.c.d:5000/hello"
+	dockerCmd(c, "tag", "busybox", tag)
+	out, _ := dockerCmd(c, "images", tag)
+	c.Assert(out, checker.Contains, tag)
+
+	out, _ = dockerCmd(c, "images", tag+":latest")
+	c.Assert(out, checker.Contains, tag)
+
+	out, _ = dockerCmd(c, "images", tag+":no-such-tag")
+	c.Assert(out, checker.Not(checker.Contains), tag)
+}
+
+func (s *DockerSuite) TestImagesFormat(c *check.C) {
+	// testRequires(c, DaemonIsLinux)
+	tag := "myimage"
+	dockerCmd(c, "tag", "busybox", tag+":v1")
+	dockerCmd(c, "tag", "busybox", tag+":v2")
+
+	out, _ := dockerCmd(c, "images", "--format", "{{.Repository}}", tag)
+	lines := strings.Split(strings.TrimSpace(string(out)), "\n")
+
+	expected := []string{"myimage", "myimage"}
+	var names []string
+	for _, l := range lines {
+		names = append(names, l)
+	}
+	c.Assert(expected, checker.DeepEquals, names, check.Commentf("Expected array with truncated names: %v, got: %v", expected, names))
+}
+
+// ImagesDefaultFormatAndQuiet
+func (s *DockerSuite) TestImagesFormatDefaultFormat(c *check.C) {
+	testRequires(c, DaemonIsLinux)
+
+	// create container 1
+	out, _ := dockerCmd(c, "run", "-d", "busybox", "true")
+	containerID1 := strings.TrimSpace(out)
+
+	// tag as foobox
+	out, _ = dockerCmd(c, "commit", containerID1, "myimage")
+	imageID := stringid.TruncateID(strings.TrimSpace(out))
+
+	config := `{
+		"imagesFormat": "{{ .ID }} default"
+}`
+	d, err := ioutil.TempDir("", "integration-cli-")
+	c.Assert(err, checker.IsNil)
+	defer os.RemoveAll(d)
+
+	err = ioutil.WriteFile(filepath.Join(d, "config.json"), []byte(config), 0644)
+	c.Assert(err, checker.IsNil)
+
+	out, _ = dockerCmd(c, "--config", d, "images", "-q", "myimage")
+	c.Assert(out, checker.Equals, imageID+"\n", check.Commentf("Expected to print only the image id, got %v\n", out))
+}

vendor/github.com/hyperhq/hypercli/integration-cli/future/cli/hyper_cli_run_noauto_volume_test.go

@@ -0,0 +1,69 @@
+package main
+
+import (
+	"strings"
+	"time"
+
+	"github.com/docker/docker/pkg/integration/checker"
+	"github.com/go-check/check"
+)
+
+// Image volume mounted at directory "/data1"
+func (s *DockerSuite) TestVerifyNoautoVolumeBaseImage(c *check.C) {
+	printTestCaseName()
+	defer printTestDuration(time.Now())
+	_, err := dockerCmd(c, "run", "-d", "--name=voltest", "hyperhq/noauto_volume_test")
+	c.Assert(err, checker.Equals, 0)
+	out, err := dockerCmd(c, "exec", "voltest", "df", "/data1")
+	c.Assert(err, checker.Equals, 0)
+	c.Assert(strings.Contains(string(out), "data1"), checker.True, check.Commentf("got df results: %s", string(out)))
+	dockerCmd(c, "rm", "-fv", "voltest")
+}
+
+// No volume mounted at directory "/data1"
+func (s *DockerSuite) TestNoautoVolume(c *check.C) {
+	printTestCaseName()
+	defer printTestDuration(time.Now())
+	_, err := dockerCmd(c, "run", "-d", "--noauto-volume", "--name=voltest", "hyperhq/noauto_volume_test")
+	c.Assert(err, checker.Equals, 0)
+	_, exitCode, _ := dockerCmdWithError("exec", "voltest", "ls", "/data1")
+	c.Assert(exitCode, checker.GreaterThan, 0)
+	dockerCmd(c, "rm", "-fv", "voltest")
+}
+
+func (s *DockerSuite) TestImplicitOverwriteNoautoVolume(c *check.C) {
+	printTestCaseName()
+	defer printTestDuration(time.Now())
+	_, err := dockerCmd(c, "run", "-d", "--noauto-volume", "--name=voltest", "-v", "/data1", "hyperhq/noauto_volume_test")
+	c.Assert(err, checker.Equals, 0)
+	out, err := dockerCmd(c, "exec", "voltest", "df", "/data1")
+	c.Assert(err, checker.Equals, 0)
+	c.Assert(strings.Contains(string(out), "data1"), checker.True, check.Commentf("got df results: %s", string(out)))
+	dockerCmd(c, "rm", "-fv", "voltest")
+}
+
+func (s *DockerSuite) TestNamedOverwriteNoautoVolume(c *check.C) {
+	printTestCaseName()
+	defer printTestDuration(time.Now())
+	volName := "testvolume"
+	_, err := dockerCmd(c, "run", "-d", "--noauto-volume", "--name=voltest", "-v", volName+":/data1", "hyperhq/noauto_volume_test")
+	c.Assert(err, checker.Equals, 0)
+	out, err := dockerCmd(c, "exec", "voltest", "df", "/data1")
+	c.Assert(err, checker.Equals, 0)
+	c.Assert(strings.Contains(string(out), "data1"), checker.True, check.Commentf("got df results: %s", string(out)))
+	dockerCmd(c, "rm", "-fv", "voltest")
+}
+
+func (s *DockerSuite) TestNoautoAndNormalVolume(c *check.C) {
+	printTestCaseName()
+	defer printTestDuration(time.Now())
+	volName := "testvolume"
+	_, err := dockerCmd(c, "run", "-d", "--noauto-volume", "--name=voltest", "-v", volName+":/vol/data", "hyperhq/noauto_volume_test")
+	c.Assert(err, checker.Equals, 0)
+	_, exitCode, _ := dockerCmdWithError("exec", "voltest", "ls", "/data1")
+	c.Assert(exitCode, checker.GreaterThan, 0)
+	out, err := dockerCmd(c, "exec", "voltest", "df", "/vol/data")
+	c.Assert(err, checker.Equals, 0)
+	c.Assert(strings.Contains(string(out), "data"), checker.True, check.Commentf("got df /vol/data results: %s", string(out)))
+	dockerCmd(c, "rm", "-fv", "voltest")
+}

vendor/github.com/hyperhq/hypercli/integration-cli/future/cli/hyper_cli_run_volume_init_test.go

@@ -0,0 +1,178 @@
+package main
+
+import (
+	"io/ioutil"
+	"os/exec"
+	"time"
+
+	"github.com/docker/docker/pkg/integration/checker"
+	"github.com/go-check/check"
+)
+
+func (s *DockerSuite) TestRunGitVolumeBinding(c *check.C) {
+	printTestCaseName()
+	defer printTestDuration(time.Now())
+	source := "git://git.kernel.org/pub/scm/utils/util-linux/util-linux.git"
+	_, err := dockerCmd(c, "run", "-d", "--name=voltest", "-v", source+":/data", "busybox")
+	c.Assert(err, checker.Equals, 0)
+	out, err := dockerCmd(c, "exec", "voltest", "cat", "/data/README")
+	c.Assert(err, checker.Equals, 0)
+	c.Assert(out, checker.Contains, "util-linux")
+	dockerCmd(c, "rm", "-fv", "voltest")
+
+	source = "git://git.kernel.org/pub/scm/utils/util-linux/util-linux.git:stable/v2.13.0"
+	_, err = dockerCmd(c, "run", "-d", "--name=voltest", "-v", source+":/data", "busybox")
+	c.Assert(err, checker.Equals, 0)
+	out, err = dockerCmd(c, "exec", "voltest", "cat", "/data/configure.ac")
+	c.Assert(err, checker.Equals, 0)
+	c.Assert(out, checker.Contains, "2.13.0")
+	dockerCmd(c, "rm", "-fv", "voltest")
+}
+
+func (s *DockerSuite) TestRunHttpGitVolumeBinding(c *check.C) {
+	printTestCaseName()
+	defer printTestDuration(time.Now())
+	source := "http://git.kernel.org/pub/scm/utils/util-linux/util-linux.git"
+	_, err := dockerCmd(c, "run", "-d", "--name=voltest", "-v", source+":/data", "busybox")
+	c.Assert(err, checker.Equals, 0)
+	out, err := dockerCmd(c, "exec", "voltest", "cat", "/data/README")
+	c.Assert(err, checker.Equals, 0)
+	c.Assert(out, checker.Contains, "util-linux")
+	dockerCmd(c, "rm", "-fv", "voltest")
+
+	source = "http://git.kernel.org/pub/scm/utils/util-linux/util-linux.git:stable/v2.13.0"
+	_, err = dockerCmd(c, "run", "-d", "--name=voltest", "-v", source+":/data", "busybox")
+	c.Assert(err, checker.Equals, 0)
+	out, err = dockerCmd(c, "exec", "voltest", "cat", "/data/configure.ac")
+	c.Assert(err, checker.Equals, 0)
+	c.Assert(out, checker.Contains, "2.13.0")
+	dockerCmd(c, "rm", "-fv", "voltest")
+}
+
+func (s *DockerSuite) TestRunHttpsGitVolumeBinding(c *check.C) {
+	printTestCaseName()
+	defer printTestDuration(time.Now())
+	source := "https://git.kernel.org/pub/scm/utils/util-linux/util-linux.git"
+	_, err := dockerCmd(c, "run", "-d", "--name=voltest", "-v", source+":/data", "busybox")
+	c.Assert(err, checker.Equals, 0)
+	out, err := dockerCmd(c, "exec", "voltest", "cat", "/data/README")
+	c.Assert(err, checker.Equals, 0)
+	c.Assert(out, checker.Contains, "util-linux")
+	dockerCmd(c, "rm", "-fv", "voltest")
+
+	source = "http://git.kernel.org/pub/scm/utils/util-linux/util-linux.git:stable/v2.13.0"
+	_, err = dockerCmd(c, "run", "-d", "--name=voltest", "-v", source+":/data", "busybox")
+	c.Assert(err, checker.Equals, 0)
+	out, err = dockerCmd(c, "exec", "voltest", "cat", "/data/README")
+	c.Assert(err, checker.Equals, 0)
+	c.Assert(out, checker.Contains, "util-linux")
+	dockerCmd(c, "rm", "-fv", "voltest")
+}
+
+func (s *DockerSuite) TestRunHttpFileVolumeBinding(c *check.C) {
+	printTestCaseName()
+	defer printTestDuration(time.Now())
+	source := "https://raw.githubusercontent.com/hyperhq/hypercli/master/README.md"
+	_, err := dockerCmd(c, "run", "-d", "--name=voltest", "-v", source+":/data", "busybox")
+	c.Assert(err, checker.Equals, 0)
+	out, err := dockerCmd(c, "exec", "voltest", "stat", "/data")
+	c.Assert(err, checker.Equals, 0)
+	c.Assert(out, checker.Contains, "regular file")
+	dockerCmd(c, "rm", "-fv", "voltest")
+
+	source = "https://raw.githubusercontent.com/hyperhq/hypercli/master/README.md"
+	_, err = dockerCmd(c, "run", "-d", "--name=voltest", "-v", source+":/data", "busybox")
+	c.Assert(err, checker.Equals, 0)
+	out, err = dockerCmd(c, "exec", "voltest", "stat", "/data")
+	c.Assert(err, checker.Equals, 0)
+	c.Assert(out, checker.Contains, "regular file")
+	dockerCmd(c, "rm", "-fv", "voltest")
+
+	source = "https://raw.githubusercontent.com/nosuchuser/nosuchrepo/masterbeta/README.md"
+	_, _, cmdErr := dockerCmdWithError("run", "-d", "--name=voltest", "-v", source+":/data", "busybox")
+	c.Assert(cmdErr, checker.NotNil)
+}
+
+func (s *DockerSuite) TestRunLocalFileVolumeBinding(c *check.C) {
+	printTestCaseName()
+	defer printTestDuration(time.Now())
+	source := "/tmp/hyper_integration_test_local_file_volume_file"
+	ioutil.WriteFile(source, []byte("foo"), 0644)
+
+	_, err := dockerCmd(c, "run", "-d", "--name=voltest", "-v", source+":/volume/data", "busybox")
+	c.Assert(err, checker.Equals, 0)
+	out, err := dockerCmd(c, "exec", "voltest", "cat", "/volume/data")
+	c.Assert(err, checker.Equals, 0)
+	c.Assert(out, checker.Equals, "foo")
+	dockerCmd(c, "rm", "-fv", "voltest")
+
+	// Dir destination as a file
+	_, err = dockerCmd(c, "run", "-d", "--name=voltest", "-v", source+":/volume/data/", "busybox")
+	c.Assert(err, checker.Equals, 0)
+	out, err = dockerCmd(c, "exec", "voltest", "cat", "/volume/data")
+	c.Assert(err, checker.Equals, 0)
+	c.Assert(out, checker.Equals, "foo")
+	dockerCmd(c, "rm", "-fv", "voltest")
+	exec.Command("rm", "-f", source).CombinedOutput()
+
+	// NonexistingVolumeBinding
+	dir := "/tmp/nosuchfile"
+	_, _, realErr := dockerCmdWithError("run", "-d", "--name=voltest", "-v", dir+":/data", "busybox")
+	c.Assert(realErr, checker.NotNil)
+}
+
+func (s *DockerSuite) TestRunLocalDirVolumeBinding(c *check.C) {
+	printTestCaseName()
+	defer printTestDuration(time.Now())
+	dir := "/tmp/hyper_integration_test_local_dir_volume_dir"
+	file := "datafile"
+	exec.Command("mkdir", "-p", dir).CombinedOutput()
+	ioutil.WriteFile(dir+"/"+file, []byte("foo"), 0644)
+
+	_, err := dockerCmd(c, "run", "-d", "--name=voltest", "-v", dir+":/data", "busybox")
+	c.Assert(err, checker.Equals, 0)
+	out, err := dockerCmd(c, "exec", "voltest", "cat", "/data/"+file)
+	c.Assert(err, checker.Equals, 0)
+	c.Assert(out, checker.Equals, "foo")
+	dockerCmd(c, "rm", "-fv", "voltest")
+
+	exec.Command("rm", "-r", dir).CombinedOutput()
+
+	// Deep dir binding
+	dir = "/tmp/hyper_integration_test_local_dir_volume_dir"
+	middle_dir := "/dir1/dir2/dir3/dir4/dir5"
+	file = "datafile"
+	exec.Command("mkdir", "-p", dir+"/"+middle_dir).CombinedOutput()
+	ioutil.WriteFile(dir+"/"+middle_dir+"/"+file, []byte("foo"), 0644)
+
+	_, err = dockerCmd(c, "run", "-d", "--name=voltest", "-v", dir+":/data", "busybox")
+	c.Assert(err, checker.Equals, 0)
+	out, err = dockerCmd(c, "exec", "voltest", "cat", "/data/"+middle_dir+"/"+file)
+	c.Assert(err, checker.Equals, 0)
+	c.Assert(out, checker.Equals, "foo")
+	dockerCmd(c, "rm", "-fv", "voltest")
+
+	exec.Command("rm", "-r", dir).CombinedOutput()
+}
+
+func (s *DockerSuite) TestRunExceptionVolumeBinding(c *check.C) {
+	printTestCaseName()
+	defer printTestDuration(time.Now())
+
+	// NonexistingVolumeBinding
+	source := "/tmp/nosuchfile"
+	_, _, err := dockerCmdWithError("run", "-d", "--name=voltest", "-v", source+":/data", "busybox")
+	c.Assert(err, checker.NotNil)
+
+	source = "http://nosuchdomain"
+	_, _, err = dockerCmdWithError("run", "-d", "--name=voltest", "-v", source+":/data", "busybox")
+	c.Assert(err, checker.NotNil)
+
+	source = "git://nosuchdomain.git"
+	_, _, err = dockerCmdWithError("run", "-d", "--name=voltest", "-v", source+":/data", "busybox")
+	c.Assert(err, checker.NotNil)
+
+	source = "git://git.kernel.org/pub/scm/utils/util-linux/util-linux.git:nosuchbranch"
+	_, _, err = dockerCmdWithError("run", "-d", "--name=voltest", "-v", source+":/data", "busybox")
+	c.Assert(err, checker.NotNil)
+}

vendor/github.com/hyperhq/hypercli/integration-cli/future/cli/hyper_cli_single_volume_multimount_test.go

@@ -0,0 +1,28 @@
+package main
+
+import (
+	"time"
+
+	"github.com/docker/docker/pkg/integration/checker"
+	"github.com/go-check/check"
+)
+
+func (s *DockerSuite) TestMultiMountImplicitVolume(c *check.C) {
+	printTestCaseName()
+	defer printTestDuration(time.Now())
+	volName := "testvolume"
+	_, err := dockerCmd(c, "run", "-d", "--name=voltest", "-v", volName+":/data1", "-v", volName+":/vol/data", "busybox")
+	c.Assert(err, checker.Equals, 0)
+	dockerCmd(c, "rm", "-fv", "voltest")
+}
+
+func (s *DockerSuite) TestMultiMountNamedVolume(c *check.C) {
+	printTestCaseName()
+	defer printTestDuration(time.Now())
+	volName := "testvolume"
+	_, err := dockerCmd(c, "volume", "create", "--name", volName)
+	c.Assert(err, checker.Equals, 0)
+	_, err = dockerCmd(c, "run", "-d", "--name=voltest", "-v", volName+":/data1", "-v", volName+":/vol/data", "busybox")
+	c.Assert(err, checker.Equals, 0)
+	dockerCmd(c, "rm", "-fv", "voltest")
+}

vendor/github.com/hyperhq/hypercli/integration-cli/future/cli/hyper_cli_volume_populate_test.go

@@ -0,0 +1,83 @@
+package main
+
+import (
+	"time"
+
+	"github.com/docker/docker/pkg/integration/checker"
+	"github.com/go-check/check"
+)
+
+func (s *DockerSuite) TestPopulateImplicitVolume(c *check.C) {
+	printTestCaseName()
+	defer printTestDuration(time.Now())
+	volName := "testvolume"
+	_, err := dockerCmd(c, "run", "-d", "--name=voltest", "-v", volName+":/etc", "busybox")
+	c.Assert(err, checker.Equals, 0)
+	out, err := dockerCmd(c, "exec", "voltest", "ls", "/etc")
+	c.Assert(err, checker.Equals, 0)
+	c.Assert(out, checker.Contains, "passwd")
+	dockerCmd(c, "rm", "-fv", "voltest")
+}
+
+func (s *DockerSuite) TestPopulateNamedVolume(c *check.C) {
+	printTestCaseName()
+	defer printTestDuration(time.Now())
+	volName := "testvolume"
+	_, err := dockerCmd(c, "volume", "create", "--name", volName)
+	c.Assert(err, checker.Equals, 0)
+	_, err = dockerCmd(c, "run", "-d", "--name=voltest", "-v", volName+":/etc", "busybox")
+	c.Assert(err, checker.Equals, 0)
+	out, err := dockerCmd(c, "exec", "voltest", "ls", "/etc")
+	c.Assert(err, checker.Equals, 0)
+	c.Assert(out, checker.Contains, "passwd")
+	dockerCmd(c, "rm", "-fv", "voltest")
+}
+
+func (s *DockerSuite) TestPopulateMultiMountImplicitVolume(c *check.C) {
+	printTestCaseName()
+	defer printTestDuration(time.Now())
+	volName := "testvolume"
+	_, err := dockerCmd(c, "run", "-d", "--name=voltest", "-v", volName+":/lib/modules/", "-v", volName+":/tmp", "busybox")
+	c.Assert(err, checker.Equals, 0)
+	out, err := dockerCmd(c, "exec", "voltest", "ls", "/lib/modules")
+	c.Assert(err, checker.Equals, 0)
+	c.Assert(string(out), checker.HasLen, 0)
+	dockerCmd(c, "rm", "-fv", "voltest")
+}
+
+func (s *DockerSuite) TestPopulateMultiMountNamedVolume(c *check.C) {
+	printTestCaseName()
+	defer printTestDuration(time.Now())
+	volName := "testvolume"
+	_, err := dockerCmd(c, "volume", "create", "--name", volName)
+	c.Assert(err, checker.Equals, 0)
+	_, err = dockerCmd(c, "run", "-d", "--name=voltest", "-v", volName+":/lib/modules/", "-v", volName+":/tmp", "busybox")
+	c.Assert(err, checker.Equals, 0)
+	out, err := dockerCmd(c, "exec", "voltest", "ls", "/lib/modules")
+	c.Assert(err, checker.Equals, 0)
+	c.Assert(string(out), checker.HasLen, 0)
+	dockerCmd(c, "rm", "-fv", "voltest")
+}
+
+func (s *DockerSuite) TestPopulateImageVolume(c *check.C) {
+	printTestCaseName()
+	defer printTestDuration(time.Now())
+	_, err := dockerCmd(c, "run", "-d", "--name=voltest", "--size=l1", "neo4j")
+	c.Assert(err, checker.Equals, 0)
+	out, err := dockerCmd(c, "exec", "voltest", "ls", "/data")
+	c.Assert(err, checker.Equals, 0)
+	c.Assert(string(out), checker.Contains, "databases")
+	dockerCmd(c, "rm", "-fv", "voltest")
+}
+
+func (s *DockerSuite) TestPopulateNamedImageVolume(c *check.C) {
+	printTestCaseName()
+	defer printTestDuration(time.Now())
+	volName := "testvolume"
+	_, err := dockerCmd(c, "run", "-d", "--name=voltest", "--size=l1", "-v", volName+":/data", "neo4j")
+	c.Assert(err, checker.Equals, 0)
+	out, err := dockerCmd(c, "exec", "voltest", "ls", "/data")
+	c.Assert(err, checker.Equals, 0)
+	c.Assert(string(out), checker.Contains, "databases")
+	dockerCmd(c, "rm", "-fv", "voltest")
+}