[integration-test] update test case for load from local/url

Author: Jimmy-Xu

integration-cli/final/cli/hyper_cli_load_basic_test.go

@@ -1,57 +1,61 @@
 package main
 
 import (
-	"time"
-	"os"
 	"fmt"
 	"github.com/docker/docker/pkg/integration/checker"
 	"github.com/go-check/check"
+	"os"
+	"time"
 )
 
 /// test invalid url //////////////////////////////////////////////////////////////////////////
 func (s *DockerSuite) TestLoadFromInvalidUrlProtocal(c *check.C) {
-	printTestCaseName(); defer printTestDuration(time.Now())
+	printTestCaseName()
+	defer printTestDuration(time.Now())
 	testRequires(c, DaemonIsLinux)
 	invalidURL := "ftp://image-tarball.s3.amazonaws.com/test/public/helloworld.tar"
 	output, exitCode, err := dockerCmdWithError("load", "-i", invalidURL)
-	c.Assert(output, checker.Equals, "Error response from daemon: Get " + invalidURL + ": unsupported protocol scheme \"ftp\"\n")
+	c.Assert(output, checker.Equals, "Error response from daemon: Bad request parameters: Get "+invalidURL+": unsupported protocol scheme \"ftp\"\n")
 	c.Assert(exitCode, checker.Equals, 1)
 	c.Assert(err, checker.NotNil)
 }
 
 func (s *DockerSuite) TestLoadFromInvalidUrlHost(c *check.C) {
-	printTestCaseName(); defer printTestDuration(time.Now())
+	printTestCaseName()
+	defer printTestDuration(time.Now())
 	testRequires(c, DaemonIsLinux)
 	invalidHost := "invalidhost"
 	invalidURL := "http://" + invalidHost + "/test/public/helloworld.tar"
 	output, exitCode, err := dockerCmdWithError("load", "-i", invalidURL)
-	c.Assert(output, checker.Equals, "Error response from daemon: Get " + invalidURL + ": dial tcp: lookup invalidhost: no such host\n")
+	c.Assert(output, checker.Equals, "Error response from daemon: Bad request parameters: Get "+invalidURL+": dial tcp: lookup invalidhost: no such host\n")
 	c.Assert(exitCode, checker.Equals, 1)
 	c.Assert(err, checker.NotNil)
 }
 
 func (s *DockerSuite) TestLoadFromInvalidUrlPath(c *check.C) {
-	printTestCaseName(); defer printTestDuration(time.Now())
+	printTestCaseName()
+	defer printTestDuration(time.Now())
 	testRequires(c, DaemonIsLinux)
 	output, exitCode, err := dockerCmdWithError("load", "-i", "http://image-tarball.s3.amazonaws.com/test/public/notexist.tar")
-	c.Assert(output, checker.Equals, "Error response from daemon: Got HTTP status code >= 400: 403 Forbidden\n")
+	c.Assert(output, checker.Equals, "Error response from daemon: Bad request parameters: Got HTTP status code >= 400: 403 Forbidden\n")
 	c.Assert(exitCode, checker.Equals, 1)
 	c.Assert(err, checker.NotNil)
 }
 
-
 //test invalid ContentType and ContentLength///////////////////////////////////////////////////////////////////////////
 func (s *DockerSuite) TestLoadFromInvalidContentType(c *check.C) {
-	printTestCaseName(); defer printTestDuration(time.Now())
+	printTestCaseName()
+	defer printTestDuration(time.Now())
 	testRequires(c, DaemonIsLinux)
 	output, exitCode, err := dockerCmdWithError("load", "-i", "http://image-tarball.s3.amazonaws.com/test/public/readme.txt")
-	c.Assert(output, checker.Equals, "Error response from daemon: Download failed: image archive format should be tar, gzip, bzip, or xz\n")
+	c.Assert(output, checker.Equals, "Error response from daemon: Download failed: URL MIME type should be one of: binary/octet-stream, application/octet-stream, application/x-tar, application/x-gzip, application/x-bzip, application/x-xz, but now is text/plain\n")
 	c.Assert(exitCode, checker.Equals, 1)
 	c.Assert(err, checker.NotNil)
 }
 
 func (s *DockerSuite) TestLoadFromInvalidContentLengthTooLarge(c *check.C) {
-	printTestCaseName(); defer printTestDuration(time.Now())
+	printTestCaseName()
+	defer printTestDuration(time.Now())
 	testRequires(c, DaemonIsLinux)
 
 	const MAX_LENGTH = 4294967295
@@ -63,18 +67,20 @@ func (s *DockerSuite) TestLoadFromInvalidContentLengthTooLarge(c *check.C) {
 
 //test invalid content///////////////////////////////////////////////////////////////////////////
 func (s *DockerSuite) TestLoadFromInvalidContentLengthZero(c *check.C) {
-	printTestCaseName(); defer printTestDuration(time.Now())
+	printTestCaseName()
+	defer printTestDuration(time.Now())
 	testRequires(c, DaemonIsLinux)
 
 	const MAX_LENGTH = 4294967295
 	output, exitCode, err := dockerCmdWithError("load", "-i", "http://image-tarball.s3.amazonaws.com/test/public/emptyfile.tar")
-	c.Assert(output, checker.Equals, fmt.Sprintf("Error response from daemon: The size of the image archive file is 0, should be greater than zero and less than or equal to %v\n", MAX_LENGTH))
+	c.Assert(output, checker.Equals, fmt.Sprintf("Error response from daemon: Bad request parameters: The size of the image archive file is 0, should be greater than zero and less than or equal to %v\n", MAX_LENGTH))
 	c.Assert(exitCode, checker.Equals, 1)
 	c.Assert(err, checker.NotNil)
 }
 
 func (s *DockerSuite) TestLoadFromInvalidContentUnrelated(c *check.C) {
-	printTestCaseName(); defer printTestDuration(time.Now())
+	printTestCaseName()
+	defer printTestDuration(time.Now())
 	testRequires(c, DaemonIsLinux)
 
 	output, exitCode, err := dockerCmdWithError("load", "-i", "http://image-tarball.s3.amazonaws.com/test/public/readme.tar")
@@ -84,7 +90,8 @@ func (s *DockerSuite) TestLoadFromInvalidContentUnrelated(c *check.C) {
 }
 
 func (s *DockerSuite) TestLoadFromInvalidUntarFail(c *check.C) {
-	printTestCaseName(); defer printTestDuration(time.Now())
+	printTestCaseName()
+	defer printTestDuration(time.Now())
 	testRequires(c, DaemonIsLinux)
 
 	output, exitCode, err := dockerCmdWithError("load", "-i", "http://image-tarball.s3.amazonaws.com/test/public/nottar.tar")
@@ -94,7 +101,8 @@ func (s *DockerSuite) TestLoadFromInvalidUntarFail(c *check.C) {
 }
 
 func (s *DockerSuite) TestLoadFromInvalidContentIncomplete(c *check.C) {
-	printTestCaseName(); defer printTestDuration(time.Now())
+	printTestCaseName()
+	defer printTestDuration(time.Now())
 	testRequires(c, DaemonIsLinux)
 
 	deleteAllImages()
@@ -109,7 +117,6 @@ func (s *DockerSuite) TestLoadFromInvalidContentIncomplete(c *check.C) {
 
 	deleteAllImages()
 
-
 	//// load this image will be OK, but after delete this image, there is a residual image with <none> tag occur.
 	//url = "http://image-tarball.s3.amazonaws.com/test/public/helloworld-no-manifest.tgz"
 	//output, exitCode, err = dockerCmdWithError("load", "-i", url)
@@ -122,7 +129,6 @@ func (s *DockerSuite) TestLoadFromInvalidContentIncomplete(c *check.C) {
 	//
 	//deleteAllImages()
 
-
 	url = "http://image-tarball.s3.amazonaws.com/test/public/helloworld-no-layer.tgz"
 	output, exitCode, err = dockerCmdWithError("load", "-i", url)
 	c.Assert(output, checker.Contains, "json: no such file or directory")
@@ -137,13 +143,14 @@ func (s *DockerSuite) TestLoadFromInvalidContentIncomplete(c *check.C) {
 
 //test normal///////////////////////////////////////////////////////////////////////////
 func (s *DockerSuite) TestLoadFromPublicURL(c *check.C) {
-	printTestCaseName(); defer printTestDuration(time.Now())
+	printTestCaseName()
+	defer printTestDuration(time.Now())
 	testRequires(c, DaemonIsLinux)
 
 	publicURL := "http://image-tarball.s3.amazonaws.com/test/public/helloworld.tar"
 	output, exitCode, err := dockerCmdWithError("load", "-i", publicURL)
 	c.Assert(output, checker.Contains, "hello-world:latest(sha256:")
-	c.Assert(output, checker.HasSuffix, "has been loaded.\n")
+	c.Assert(output, checker.Contains, "has been loaded.\n")
 	c.Assert(exitCode, checker.Equals, 0)
 	c.Assert(err, checker.IsNil)
 
@@ -152,7 +159,8 @@ func (s *DockerSuite) TestLoadFromPublicURL(c *check.C) {
 }
 
 func (s *DockerSuite) TestLoadFromCompressedArchive(c *check.C) {
-	printTestCaseName(); defer printTestDuration(time.Now())
+	printTestCaseName()
+	defer printTestDuration(time.Now())
 	testRequires(c, DaemonIsLinux)
 
 	extAry := [...]string{"tar.gz", "tgz", "tar.bz2", "tar.xz"}
@@ -161,7 +169,7 @@ func (s *DockerSuite) TestLoadFromCompressedArchive(c *check.C) {
 		publicURL := "http://image-tarball.s3.amazonaws.com/test/public/helloworld." + val
 		output, exitCode, err := dockerCmdWithError("load", "-i", publicURL)
 		c.Assert(output, checker.Contains, "hello-world:latest(sha256:")
-		c.Assert(output, checker.HasSuffix, "has been loaded.\n")
+		c.Assert(output, checker.Contains, "has been loaded.\n")
 		c.Assert(exitCode, checker.Equals, 0)
 		c.Assert(err, checker.IsNil)
 
@@ -170,7 +178,8 @@ func (s *DockerSuite) TestLoadFromCompressedArchive(c *check.C) {
 }
 
 func (s *DockerSuite) TestLoadFromPublicURLWithQuiet(c *check.C) {
-	printTestCaseName(); defer printTestDuration(time.Now())
+	printTestCaseName()
+	defer printTestDuration(time.Now())
 	testRequires(c, DaemonIsLinux)
 
 	publicURL := "http://image-tarball.s3.amazonaws.com/test/public/helloworld.tar"
@@ -182,7 +191,8 @@ func (s *DockerSuite) TestLoadFromPublicURLWithQuiet(c *check.C) {
 }
 
 func (s *DockerSuite) TestLoadFromPublicURLMultipeImage(c *check.C) {
-	printTestCaseName(); defer printTestDuration(time.Now())
+	printTestCaseName()
+	defer printTestDuration(time.Now())
 	testRequires(c, DaemonIsLinux)
 
 	multiImgURL := "http://image-tarball.s3.amazonaws.com/test/public/busybox_alpine.tar"
@@ -196,7 +206,8 @@ func (s *DockerSuite) TestLoadFromPublicURLMultipeImage(c *check.C) {
 }
 
 func (s *DockerSuite) TestLoadFromBasicAuthURL(c *check.C) {
-	printTestCaseName(); defer printTestDuration(time.Now())
+	printTestCaseName()
+	defer printTestDuration(time.Now())
 	testRequires(c, DaemonIsLinux)
 
 	urlWithAuth := os.Getenv("URL_WITH_BASIC_AUTH")
@@ -209,7 +220,8 @@ func (s *DockerSuite) TestLoadFromBasicAuthURL(c *check.C) {
 }
 
 func (s *DockerSuite) TestLoadFromAWSS3PreSignedURL(c *check.C) {
-	printTestCaseName(); defer printTestDuration(time.Now())
+	printTestCaseName()
+	defer printTestDuration(time.Now())
 	testRequires(c, DaemonIsLinux)
 
 	deleteAllImages()
@@ -232,37 +244,41 @@ func (s *DockerSuite) TestLoadFromAWSS3PreSignedURL(c *check.C) {
 	checkImage(c, true, "cirros")
 }
 
-//Prerequisite: update image balance to 1 in tenant collection of hypernetes in mongodb
+//Prerequisite: update image balance to 2 in tenant collection of hypernetes in mongodb
 //db.tenant.update({tenantid:"<tenant_id>"},{$set:{"resourceinfo.balance.images":2}})
 func (s *DockerSuite) TestLoadFromPublicURLWithQuota(c *check.C) {
-	printTestCaseName(); defer printTestDuration(time.Now())
+	printTestCaseName()
+	defer printTestDuration(time.Now())
 	testRequires(c, DaemonIsLinux)
 
 	deleteAllImages()
 
 	helloworldURL := "http://image-tarball.s3.amazonaws.com/test/public/helloworld.tar"
 	multiImgURL := "http://image-tarball.s3.amazonaws.com/test/public/busybox_alpine.tar"
 	ubuntuURL := "http://image-tarball.s3.amazonaws.com/test/public/ubuntu.tar.gz"
-	exceedQuotaMsg := "Exceeded quota, please either delete images, or email support@hyper.sh to request increased quota"
+	//exceedQuotaMsg := "Exceeded quota, please either delete images, or email support@hyper.sh to request increased quota"
+	exceedQuotaMsg := "you do not have enough quota"
 
 	///// [init] /////
-	// balance 2, images 0
+	// balance 3, images 0
 	out, _ := dockerCmd(c, "info")
 	c.Assert(out, checker.Contains, "Images: 0")
 
-
 	///// [step 1] load new hello-world image /////
-	// balance 2 -> 1, image: 0 -> 1
-	dockerCmd(c, "load", "-i", helloworldURL)
-	images, _ := dockerCmd(c, "images", "hello-world")
-	c.Assert(images, checker.Contains, "hello-world")
+	// balance 3 -> 2, image: 0 -> 1
+	output, exitCode, err := dockerCmdWithError("load", "-i", helloworldURL)
+	c.Assert(output, checker.Contains, "has been loaded.")
+	c.Assert(exitCode, checker.Equals, 0)
+	c.Assert(err, checker.IsNil)
+
+	checkImage(c, true, "hello-world")
+
 	out, _ = dockerCmd(c, "info")
 	c.Assert(out, checker.Contains, "Images: 1")
 
-
 	///// [step 2] load hello-world image again /////
-	// balance 1 -> 1, image 1 -> 1
-	output, exitCode, err := dockerCmdWithError("load", "-i", helloworldURL)
+	// balance 2 -> 2, image 1 -> 1
+	output, exitCode, err = dockerCmdWithError("load", "-i", helloworldURL)
 	c.Assert(output, checker.Contains, "has been loaded.")
 	c.Assert(exitCode, checker.Equals, 0)
 	c.Assert(err, checker.IsNil)
@@ -272,87 +288,53 @@ func (s *DockerSuite) TestLoadFromPublicURLWithQuota(c *check.C) {
 	out, _ = dockerCmd(c, "info")
 	c.Assert(out, checker.Contains, "Images: 1")
 
-
 	///// [step 3] load multiple image(busybox+alpine) /////
-	// balance 1 -> 0, image 1 -> 2
+	// balance 2 -> 2, image 1 -> 1
 	output, exitCode, err = dockerCmdWithError("load", "-i", multiImgURL)
-	c.Assert(output, checker.Contains, "has been loaded.")
 	c.Assert(output, checker.Contains, exceedQuotaMsg)
 	c.Assert(exitCode, checker.Equals, 1)
 	c.Assert(err, checker.NotNil)
 
-	checkImage(c, true, "busybox")
+	checkImage(c, false, "busybox")
 	checkImage(c, false, "alpine")
 
 	out, _ = dockerCmd(c, "info")
-	c.Assert(out, checker.Contains, "Images: 2")
-
-
-	///// [step 4] load hello-world image again /////
-	// balance 0 -> 0, image 2 -> 2
-	output, exitCode, err = dockerCmdWithError("load", "-i", helloworldURL)
-	c.Assert(output, checker.Contains, exceedQuotaMsg)
-	c.Assert(exitCode, checker.Equals, 1)
-	c.Assert(err, checker.NotNil)
-
-	checkImage(c, true, "hello-world")
-
-	out, _ = dockerCmd(c, "info")
-	c.Assert(out, checker.Contains, "Images: 2")
-
+	c.Assert(out, checker.Contains, "Images: 1")
 
-	///// [step 5] load new ubuntu image /////
-	// balance 0 -> 0, image 2 -> 2
+	///// [step 4] load new ubuntu image /////
+	// balance 2 -> 1, image 1 -> 2
 	output, exitCode, err = dockerCmdWithError("load", "-i", ubuntuURL)
-	c.Assert(output, checker.Contains, exceedQuotaMsg)
-	c.Assert(exitCode, checker.Equals, 1)
-	c.Assert(err, checker.NotNil)
+	c.Assert(output, checker.Contains, "has been loaded.")
+	c.Assert(exitCode, checker.Equals, 0)
+	c.Assert(err, checker.IsNil)
 
-	checkImage(c, false, "ubuntu")
+	checkImage(c, true, "ubuntu")
 
 	out, _ = dockerCmd(c, "info")
 	c.Assert(out, checker.Contains, "Images: 2")
 
-
-	///// [step 6] remove hello-world image /////
-	// balance 0 -> 1, image 2 -> 1
-	images, _ = dockerCmd(c, "rmi", "-f", "hello-world")
+	///// [step 5] remove hello-world image /////
+	// balance 1 -> 2, image 2 -> 1
+	images, _ := dockerCmd(c, "rmi", "-f", "hello-world")
 	c.Assert(images, checker.Contains, "Untagged: hello-world:latest")
 
 	checkImage(c, false, "hello-world")
 
 	out, _ = dockerCmd(c, "info")
 	c.Assert(out, checker.Contains, "Images: 1")
 
+	///// [step 6] remove busybox and ubuntu image /////
+	// balance 2 -> 3, image 1 -> 0
+	images, _ = dockerCmd(c, "rmi", "-f", "ubuntu:latest")
+	c.Assert(images, checker.Contains, "Untagged: ubuntu:latest")
 
-	///// [step 7] load new ubuntu image again /////
-	//balance 1 -> 0, image 1 -> 2
-	output, exitCode, err = dockerCmdWithError("load", "-i", ubuntuURL)
-	c.Assert(output, checker.Contains, "has been loaded.")
-	c.Assert(exitCode, checker.Equals, 0)
-	c.Assert(err, checker.IsNil)
-
-	checkImage(c, true, "ubuntu")
-
-	out, _ = dockerCmd(c, "info")
-	c.Assert(out, checker.Contains, "Images: 2")
-
-
-	///// [step 8] remove busybox and ubuntu image /////
-	// balance 0 -> 2, image 2 -> 0
-	images, _ = dockerCmd(c, "rmi", "-f", "busybox", "ubuntu:14.04")
-	c.Assert(images, checker.Contains, "Untagged: busybox:latest")
-	c.Assert(images, checker.Contains, "Untagged: ubuntu:14.04")
-
-	checkImage(c, false, "busybox")
 	checkImage(c, false, "ubuntu")
 
 	out, _ = dockerCmd(c, "info")
 	c.Assert(out, checker.Contains, "Images: 0")
 
-
-	///// [step 9] load multiple image(busybox+alpine) again /////
-	// balance 2 -> 0, image 0 -> 2
+	///// [step 7] load multiple image(busybox+alpine) again /////
+	// balance 3 -> 0, image 0 -> 3
 	output, exitCode, err = dockerCmdWithError("load", "-i", multiImgURL)
 	c.Assert(output, checker.Contains, "has been loaded.")
 	c.Assert(exitCode, checker.Equals, 0)
@@ -362,5 +344,5 @@ func (s *DockerSuite) TestLoadFromPublicURLWithQuota(c *check.C) {
 	checkImage(c, true, "alpine")
 
 	out, _ = dockerCmd(c, "info")
-	c.Assert(out, checker.Contains, "Images: 2")
+	c.Assert(out, checker.Contains, "Images: 3")
 }