Move TestRunDetach to integration-cli

Signed-off-by: Brian Goff <cpuguy83@gmail.com>

integration-cli/docker_cli_run_unix_test.go

@@ -3,6 +3,7 @@
 package main
 
 import (
+	"bufio"
 	"fmt"
 	"io/ioutil"
 	"os"
@@ -201,3 +202,73 @@ func TestRunDeviceDirectory(t *testing.T) {
 
 	logDone("run - test --device directory mounts all internal devices")
 }
+
+// TestRunDetach checks attaching and detaching with the escape sequence.
+func TestRunAttachDetach(t *testing.T) {
+	defer deleteAllContainers()
+	name := "attach-detach"
+	cmd := exec.Command(dockerBinary, "run", "--name", name, "-it", "busybox", "cat")
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		t.Fatal(err)
+	}
+	cpty, tty, err := pty.Open()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer cpty.Close()
+	cmd.Stdin = tty
+	if err := cmd.Start(); err != nil {
+		t.Fatal(err)
+	}
+	if err := waitRun(name); err != nil {
+		t.Fatal(err)
+	}
+
+	if _, err := cpty.Write([]byte("hello\n")); err != nil {
+		t.Fatal(err)
+	}
+
+	out, err := bufio.NewReader(stdout).ReadString('\n')
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.TrimSpace(out) != "hello" {
+		t.Fatalf("exepected 'hello', got %q", out)
+	}
+
+	// escape sequence
+	if _, err := cpty.Write([]byte{16}); err != nil {
+		t.Fatal(err)
+	}
+	time.Sleep(100 * time.Millisecond)
+	if _, err := cpty.Write([]byte{17}); err != nil {
+		t.Fatal(err)
+	}
+
+	ch := make(chan struct{})
+	go func() {
+		cmd.Wait()
+		ch <- struct{}{}
+	}()
+
+	running, err := inspectField(name, "State.Running")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if running != "true" {
+		t.Fatal("exepected container to still be running")
+	}
+
+	go func() {
+		dockerCmd(t, "kill", name)
+	}()
+
+	select {
+	case <-ch:
+	case <-time.After(10 * time.Millisecond):
+		t.Fatal("timed out waiting for container to exit")
+	}
+
+	logDone("run - attach detach")
+}

integration-cli/utils.go

@@ -213,7 +213,16 @@ func waitInspect(name, expr, expected string, timeout int) error {
 		cmd := exec.Command(dockerBinary, "inspect", "-f", expr, name)
 		out, _, err := runCommandWithOutput(cmd)
 		if err != nil {
-			return fmt.Errorf("error executing docker inspect: %v", err)
+			if !strings.Contains(out, "No such") {
+				return fmt.Errorf("error executing docker inspect: %v\n%s", err, out)
+			}
+			select {
+			case <-after:
+				return err
+			default:
+				time.Sleep(10 * time.Millisecond)
+				continue
+			}
 		}
 
 		out = strings.TrimSpace(out)

integration/commands_test.go

@@ -113,56 +113,6 @@ func assertPipe(input, output string, r io.Reader, w io.Writer, count int) error
 	return nil
 }
 
-// TestRunDetach checks attaching and detaching with the escape sequence.
-func TestRunDetach(t *testing.T) {
-	stdout, stdoutPipe := io.Pipe()
-	cpty, tty, err := pty.Open()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	cli := client.NewDockerCli(tty, stdoutPipe, ioutil.Discard, "", testDaemonProto, testDaemonAddr, nil)
-	defer cleanup(globalEngine, t)
-
-	ch := make(chan struct{})
-	go func() {
-		defer close(ch)
-		cli.CmdRun("-i", "-t", unitTestImageID, "cat")
-	}()
-
-	container := waitContainerStart(t, 10*time.Second)
-
-	state := setRaw(t, container)
-	defer unsetRaw(t, container, state)
-
-	setTimeout(t, "First read/write assertion timed out", 2*time.Second, func() {
-		if err := assertPipe("hello\n", "hello", stdout, cpty, 150); err != nil {
-			t.Fatal(err)
-		}
-	})
-
-	setTimeout(t, "Escape sequence timeout", 5*time.Second, func() {
-		cpty.Write([]byte{16})
-		time.Sleep(100 * time.Millisecond)
-		cpty.Write([]byte{17})
-	})
-
-	// wait for CmdRun to return
-	setTimeout(t, "Waiting for CmdRun timed out", 15*time.Second, func() {
-		<-ch
-	})
-	closeWrap(cpty, stdout, stdoutPipe)
-
-	time.Sleep(500 * time.Millisecond)
-	if !container.IsRunning() {
-		t.Fatal("The detached container should be still running")
-	}
-
-	setTimeout(t, "Waiting for container to die timed out", 20*time.Second, func() {
-		container.Kill()
-	})
-}
-
 // TestAttachDetach checks that attach in tty mode can be detached using the long container ID
 func TestAttachDetach(t *testing.T) {
 	stdout, stdoutPipe := io.Pipe()