fix(tests): report errors from docker pull on main goroutine

See http://golang.org/pkg/testing/#T.FailNow

builder/tests/builderComponent_test.go → builder/tests/builder_test.go

@@ -14,7 +14,10 @@ func runDeisBuilderTest(
 	t *testing.T, testSessionUID string, etcdPort string, servicePort string) {
 	cli, stdout, stdoutPipe := dockercliutils.GetNewClient()
 	done := make(chan bool, 1)
-	dockercliutils.BuildDockerfile(t, "../", "deis/builder:"+testSessionUID)
+	err := dockercliutils.BuildImage(t, "../", "deis/builder:"+testSessionUID)
+	if err != nil {
+		t.Fatal(err)
+	}
 	dockercliutils.RunDeisDataTest(t, "--name", "deis-builder-data",
 		"-v", "/var/lib/docker", "deis/base", "/bin/true")
 	//docker run --name deis-builder -p 2223:22 -e PUBLISH=22
@@ -24,7 +27,7 @@ func runDeisBuilderTest(
 	done <- true
 	go func() {
 		<-done
-		dockercliutils.RunContainer(t, cli,
+		err = dockercliutils.RunContainer(cli,
 			"--name", "deis-builder-"+testSessionUID,
 			"--rm",
 			"-p", servicePort+":22",
@@ -38,9 +41,12 @@ func runDeisBuilderTest(
 	}()
 	time.Sleep(5000 * time.Millisecond)
 	dockercliutils.PrintToStdout(t, stdout, stdoutPipe, "deis-builder running")
+	if err != nil {
+		t.Fatal(err)
+	}
 }
 
-func TestBuild(t *testing.T) {
+func TestBuilder(t *testing.T) {
 	setkeys := []string{"/deis/registry/protocol",
 		"deis/registry/host",
 		"/deis/registry/port",

cache/tests/cacheComponent_test.go → cache/tests/cache_test.go

@@ -11,26 +11,30 @@ import (
 func runDeisCacheTest(t *testing.T, testSessionUID string, etcdPort string, servicePort string) {
 	cli, stdout, stdoutPipe := dockercliutils.GetNewClient()
 	done := make(chan bool, 1)
-	dockercliutils.BuildDockerfile(t, "../", "deis/cache:"+testSessionUID)
-	IPAddress := utils.GetHostIPAddress()
+	err := dockercliutils.BuildImage(t, "../", "deis/cache:"+testSessionUID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ipaddr := utils.GetHostIPAddress()
 	done <- true
 	go func() {
 		<-done
-		//docker run --name deis-cache -p 6379:6379 -e PUBLISH=6379
-		// -e HOST=${COREOS_PRIVATE_IPV4} deis/cache
-		dockercliutils.RunContainer(t, cli,
+		err = dockercliutils.RunContainer(cli,
 			"--name", "deis-cache-"+testSessionUID,
 			"--rm",
 			"-p", servicePort+":6379",
 			"-e", "PUBLISH="+servicePort,
-			"-e", "HOST="+IPAddress,
+			"-e", "HOST="+ipaddr,
 			"-e", "ETCD_PORT="+etcdPort,
 			"deis/cache:"+testSessionUID)
 	}()
 	dockercliutils.PrintToStdout(t, stdout, stdoutPipe, "started")
+	if err != nil {
+		t.Fatal(err)
+	}
 }
 
-func TestBuild(t *testing.T) {
+func TestCache(t *testing.T) {
 	var testSessionUID = utils.NewUuid()
 	fmt.Println("UUID for the session Cache Test :" + testSessionUID)
 	etcdPort := utils.GetRandomPort()

controller/tests/controllerComponent_test.go → controller/tests/controller_test.go

@@ -14,28 +14,31 @@ import (
 func runDeisControllerTest(t *testing.T, testSessionUID string, etcdPort string, servicePort string) {
 	cli, stdout, stdoutPipe := dockercliutils.GetNewClient()
 	done := make(chan bool, 1)
-	dockercliutils.BuildDockerfile(t, "../", "deis/controller:"+testSessionUID)
-	//docker run --name deis-controller -p 8000:8000 -e PUBLISH=8000
-	// -e HOST=${COREOS_PRIVATE_IPV4} --volumes-from=deis-logger deis/controller
-	IPAddress := utils.GetHostIPAddress()
+	err := dockercliutils.BuildImage(t, "../", "deis/controller:"+testSessionUID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ipaddr := utils.GetHostIPAddress()
 	done <- true
 	go func() {
 		<-done
-		dockercliutils.RunContainer(t, cli,
+		err = dockercliutils.RunContainer(cli,
 			"--name", "deis-controller-"+testSessionUID,
 			"--rm",
 			"-p", servicePort+":8000",
 			"-e", "PUBLISH="+servicePort,
-			"-e", "HOST="+IPAddress,
+			"-e", "HOST="+ipaddr,
 			"-e", "ETCD_PORT="+etcdPort,
 			"deis/controller:"+testSessionUID)
 	}()
 	time.Sleep(5000 * time.Millisecond)
 	dockercliutils.PrintToStdout(t, stdout, stdoutPipe, "Booting")
-
+	if err != nil {
+		t.Fatal(err)
+	}
 }
 
-func TestBuild(t *testing.T) {
+func TestController(t *testing.T) {
 	setkeys := []string{"/deis/registry/protocol",
 		"deis/registry/host",
 		"/deis/registry/port",

database/tests/databaseComponent_test.go → database/tests/database_test.go

@@ -12,7 +12,10 @@ func runDeisDatabaseTest(
 	t *testing.T, testSessionUID string, etcdPort string, servicePort string) {
 	cli, stdout, stdoutPipe := dockercliutils.GetNewClient()
 	done := make(chan bool, 1)
-	dockercliutils.BuildDockerfile(t, "../", "deis/database:"+testSessionUID)
+	err := dockercliutils.BuildImage(t, "../", "deis/database:"+testSessionUID)
+	if err != nil {
+		t.Fatal(err)
+	}
 	dockercliutils.RunDeisDataTest(t, "--name", "deis-database-data",
 		"-v", "/var/lib/postgresql", "deis/base", "true")
 	IPAddress := utils.GetHostIPAddress()
@@ -22,7 +25,7 @@ func runDeisDatabaseTest(
 		//docker run --name deis-database -p 5432:5432 -e PUBLISH=5432
 		// -e HOST=${COREOS_PRIVATE_IPV4}
 		// --volumes-from deis-database-data deis/database
-		dockercliutils.RunContainer(t, cli,
+		err = dockercliutils.RunContainer(cli,
 			"--name", "deis-database-"+testSessionUID,
 			"--rm",
 			"-p", servicePort+":5432",
@@ -33,9 +36,12 @@ func runDeisDatabaseTest(
 			"deis/database:"+testSessionUID)
 	}()
 	dockercliutils.PrintToStdout(t, stdout, stdoutPipe, "deis-database running")
+	if err != nil {
+		t.Fatal(err)
+	}
 }
 
-func TestBuild(t *testing.T) {
+func TestDatabase(t *testing.T) {
 	var testSessionUID = utils.NewUuid()
 	fmt.Println("UUID for the session Cache Test :" + testSessionUID)
 	etcdPort := utils.GetRandomPort()

logger/tests/loggerComponent_test.go → logger/tests/logger_test.go

@@ -12,14 +12,17 @@ func runDeisLoggerTest(
 	t *testing.T, testSessionUID string, etcdPort string, servicePort string) {
 	cli, stdout, stdoutPipe := dockercliutils.GetNewClient()
 	done := make(chan bool, 1)
-	dockercliutils.BuildDockerfile(t, "../", "deis/logger:"+testSessionUID)
+	err := dockercliutils.BuildImage(t, "../", "deis/logger:"+testSessionUID)
+	if err != nil {
+		t.Fatal(err)
+	}
 	dockercliutils.RunDeisDataTest(t, "--name", "deis-logger-data",
 		"-v", "/var/log/deis", "deis/base", "true")
 	IPAddress := utils.GetHostIPAddress()
 	done <- true
 	go func() {
 		<-done
-		dockercliutils.RunContainer(t, cli,
+		err = dockercliutils.RunContainer(cli,
 			"--name", "deis-logger-"+testSessionUID,
 			"--rm",
 			"-p", servicePort+":514/udp",
@@ -30,9 +33,12 @@ func runDeisLoggerTest(
 			"deis/logger:"+testSessionUID)
 	}()
 	dockercliutils.PrintToStdout(t, stdout, stdoutPipe, "deis-logger running")
+	if err != nil {
+		t.Fatal(err)
+	}
 }
 
-func TestBuild(t *testing.T) {
+func TestLogger(t *testing.T) {
 	var testSessionUID = utils.NewUuid()
 	etcdPort := utils.GetRandomPort()
 	servicePort := utils.GetRandomPort()

registry/tests/registryComponent_test.go → registry/tests/registry_test.go

@@ -13,28 +13,34 @@ func runDeisRegistryTest(
 	t *testing.T, testSessionUID string, etcdPort string, servicePort string) {
 	cli, stdout, stdoutPipe := dockercliutils.GetNewClient()
 	done := make(chan bool, 1)
-	dockercliutils.BuildDockerfile(t, "../", "deis/registry:"+testSessionUID)
+	err := dockercliutils.BuildImage(t, "../", "deis/registry:"+testSessionUID)
+	if err != nil {
+		t.Fatal(err)
+	}
 	dockercliutils.RunDeisDataTest(t, "--name", "deis-registry-data",
 		"-v", "/data", "deis/base", "/bin/true")
-	IPAddress := utils.GetHostIPAddress()
+	ipaddr := utils.GetHostIPAddress()
 	done <- true
 	go func() {
 		<-done
-		dockercliutils.RunContainer(t, cli,
+		err = dockercliutils.RunContainer(cli,
 			"--name", "deis-registry-"+testSessionUID,
 			"--rm",
 			"-p", servicePort+":5000",
 			"-e", "PUBLISH="+servicePort,
-			"-e", "HOST="+IPAddress,
+			"-e", "HOST="+ipaddr,
 			"-e", "ETCD_PORT="+etcdPort,
 			"--volumes-from", "deis-registry-data",
 			"deis/registry:"+testSessionUID)
 	}()
 	time.Sleep(2000 * time.Millisecond)
 	dockercliutils.PrintToStdout(t, stdout, stdoutPipe, "Booting")
+	if err != nil {
+		t.Fatal(err)
+	}
 }
 
-func TestBuild(t *testing.T) {
+func TestRegistry(t *testing.T) {
 	var testSessionUID = utils.NewUuid()
 	fmt.Println("UUID for the session registry Test :" + testSessionUID)
 	etcdPort := utils.GetRandomPort()

router/tests/routerComponent_test.go → router/tests/router_test.go

@@ -14,29 +14,32 @@ func runDeisRouterTest(
 	t *testing.T, testSessionID string, etcdPort string, servicePort string) {
 	cli, stdout, stdoutPipe := dockercliutils.GetNewClient()
 	done := make(chan bool, 1)
-	dockercliutils.BuildDockerfile(t, "../", "deis/router:"+testSessionID)
-
-	//ocker run --name deis-router -p 80:80 -p 2222:2222 -e PUBLISH=80
-	// -e HOST=${COREOS_PRIVATE_IPV4} deis/router
-	IPAddress := utils.GetHostIPAddress()
+	err := dockercliutils.BuildImage(t, "../", "deis/router:"+testSessionID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ipaddr := utils.GetHostIPAddress()
 	done <- true
 	go func() {
 		<-done
-		dockercliutils.RunContainer(t, cli,
+		err = dockercliutils.RunContainer(cli,
 			"--name", "deis-router-"+testSessionID,
 			"--rm",
 			"-p", servicePort+":80",
 			"-p", "2222:2222",
 			"-e", "PUBLISH="+servicePort,
-			"-e", "HOST="+IPAddress,
+			"-e", "HOST="+ipaddr,
 			"-e", "ETCD_PORT="+etcdPort,
 			"deis/router:"+testSessionID)
 	}()
 	time.Sleep(2000 * time.Millisecond)
 	dockercliutils.PrintToStdout(t, stdout, stdoutPipe, "deis-router running")
+	if err != nil {
+		t.Fatal(err)
+	}
 }
 
-func TestBuild(t *testing.T) {
+func TestRouter(t *testing.T) {
 	setkeys := []string{"deis/controller/host",
 		"/deis/controller/port",
 		"/deis/builder/host",

tests/dockercliutils/dockercliutils.go

@@ -103,37 +103,36 @@ func GetNewClient() (
 func PrintToStdout(t *testing.T, stdout *io.PipeReader,
 	stdoutPipe *io.PipeWriter, stoptag string) string {
 	var result string
+	r := bufio.NewReader(stdout)
 	for {
-		if cmdBytes, err := bufio.NewReader(stdout).ReadString('\n'); err == nil {
-			result = cmdBytes
-			fmt.Print(cmdBytes)
-			if strings.Contains(cmdBytes, stoptag) == true {
-				if err := CloseWrap(stdout, stdoutPipe); err != nil {
-					t.Fatalf("Closewraps %s", err)
-				}
-			}
-		} else {
+		cmdBytes, err := r.ReadString('\n')
+		if err != nil {
 			break
 		}
+		result = cmdBytes
+		fmt.Print(cmdBytes)
+		if strings.Contains(cmdBytes, stoptag) == true {
+			if err := CloseWrap(stdout, stdoutPipe); err != nil {
+				t.Fatal(err)
+			}
+		}
 	}
 	return result
 }
 
-// BuildDockerfile builds and tags a docker image from a Dockerfile.
-func BuildDockerfile(t *testing.T, path string, tag string) {
+// BuildImage builds and tags a docker image from a Dockerfile.
+func BuildImage(t *testing.T, path string, tag string) error {
+	var err error
 	cli, stdout, stdoutPipe := GetNewClient()
-	fmt.Println("Building docker file :" + tag)
+	fmt.Println("Building docker image", tag)
 	go func() {
-		err := cli.CmdBuild("--tag="+tag, path)
-		if err != nil {
-			t.Fatalf(" %s", err)
-		}
-		if err = CloseWrap(stdout, stdoutPipe); err != nil {
-			t.Fatalf("buildDockerfile %s", err)
+		if err = cli.CmdBuild("--tag="+tag, path); err != nil {
+			return
 		}
+		err =  CloseWrap(stdout, stdoutPipe)
 	}()
-	time.Sleep(1000 * time.Millisecond)
-	PrintToStdout(t, stdout, stdoutPipe, "build docker file")
+ 	PrintToStdout(t, stdout, stdoutPipe, "build docker file")
+	return err
 }
 
 // GetInspectData prints and returns `docker inspect` data for a container.
@@ -171,22 +170,21 @@ func PullImage(t *testing.T, cli *client.DockerCli, args ...string) {
 }
 
 // RunContainer runs a docker image with the given arguments.
-func RunContainer(t *testing.T, cli *client.DockerCli, args ...string) {
-	fmt.Println("Running docker container :" + args[1])
+func RunContainer(cli *client.DockerCli, args ...string) error {
+	fmt.Println("Running docker container", args[1])
 	err := cli.CmdRun(args...)
 	if err != nil {
 		// Ignore certain errors we see in io handling.
 		switch msg := err.Error(); {
 		case strings.Contains(msg, "read/write on closed pipe"):
-			return
+			err = nil
 		case strings.Contains(msg, "Code: -1"):
-			return
+			err = nil
 		case strings.Contains(msg, "Code: 2"):
-			return
-		default:
-			t.Fatalf("RunContainer failed: %v", err)
+			err = nil
 		}
 	}
+	return err
 }
 
 // RunDeisDataTest starts a data container as a prerequisite for a service.
@@ -201,7 +199,9 @@ func RunDeisDataTest(t *testing.T, args ...string) {
 	if strings.Contains(hostname, "Error") {
 		go func() {
 			<-done
-			RunContainer(t, cli, args...)
+			if err := RunContainer(cli, args...); err != nil {
+				t.Fatal(err)
+			}
 		}()
 		go func() {
 			fmt.Println("closing read/write pipe")
@@ -331,17 +331,18 @@ func GetImageID(t *testing.T, repo string) string {
 
 // RunEtcdTest starts an etcd docker container for testing.
 func RunEtcdTest(t *testing.T, uid string, port string) {
-	//docker run -t -i --name=deis-etcd -p 4001:4001  -e HOST_IP=172.17.8.100
-	// -e ETCD_ADDR=172.17.8.100:4001
-	// --entrypoint=/bin/bash phife.atribecalledchris.com:5000/deis/etcd:0.3.0
-	// -c /usr/local/bin/etcd
+	var err error
 	cli, stdout, stdoutPipe := GetNewClient()
 	done2 := make(chan bool, 1)
 	IPAddress := utils.GetHostIPAddress()
 	go func() {
-		PullImage(t, cli, "deis/test-etcd:latest")
+		if err = cli.CmdPull("deis/test-etcd:latest"); err != nil {
+			CloseWrap(stdout, stdoutPipe)
+			return
+		}
+		// PullImage(t, cli, "deis/test-etcd:latest")
 		done2 <- true
-		RunContainer(t, cli,
+		err = RunContainer(cli,
 			"--name", "deis-etcd-"+uid,
 			"--rm",
 			"-p", port+":"+port,
@@ -359,4 +360,7 @@ func RunEtcdTest(t *testing.T, uid string, port string) {
 	}()
 	time.Sleep(1000 * time.Millisecond)
 	PrintToStdout(t, stdout, stdoutPipe, "pulling etcd")
+	if err != nil {
+		t.Fatal(err)
+	}
 }