| package docker |
| |
| import ( |
| "archive/tar" |
| "bufio" |
| "bytes" |
| "encoding/json" |
| "github.com/dotcloud/docker/auth" |
| "github.com/dotcloud/docker/utils" |
| "io" |
| "net" |
| "net/http" |
| "net/http/httptest" |
| "os" |
| "path" |
| "testing" |
| "time" |
| ) |
| |
| func TestPostAuth(t *testing.T) { |
| runtime, err := newTestRuntime() |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer nuke(runtime) |
| |
| srv := &Server{ |
| runtime: runtime, |
| } |
| |
| r := httptest.NewRecorder() |
| |
| authConfig := &auth.AuthConfig{ |
| Username: "utest", |
| Password: "utest", |
| Email: "utest@yopmail.com", |
| } |
| |
| authConfigJSON, err := json.Marshal(authConfig) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| req, err := http.NewRequest("POST", "/auth", bytes.NewReader(authConfigJSON)) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| if err := postAuth(srv, APIVERSION, r, req, nil); err != nil { |
| t.Fatal(err) |
| } |
| |
| if r.Code != http.StatusOK && r.Code != 0 { |
| t.Fatalf("%d OK or 0 expected, received %d\n", http.StatusOK, r.Code) |
| } |
| } |
| |
| func TestGetVersion(t *testing.T) { |
| runtime, err := newTestRuntime() |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer nuke(runtime) |
| |
| srv := &Server{runtime: runtime} |
| |
| r := httptest.NewRecorder() |
| |
| if err := getVersion(srv, APIVERSION, r, nil, nil); err != nil { |
| t.Fatal(err) |
| } |
| |
| v := &APIVersion{} |
| if err = json.Unmarshal(r.Body.Bytes(), v); err != nil { |
| t.Fatal(err) |
| } |
| if v.Version != VERSION { |
| t.Errorf("Excepted version %s, %s found", VERSION, v.Version) |
| } |
| } |
| |
| func TestGetInfo(t *testing.T) { |
| runtime, err := newTestRuntime() |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer nuke(runtime) |
| |
| srv := &Server{runtime: runtime} |
| |
| r := httptest.NewRecorder() |
| |
| if err := getInfo(srv, APIVERSION, r, nil, nil); err != nil { |
| t.Fatal(err) |
| } |
| |
| infos := &APIInfo{} |
| err = json.Unmarshal(r.Body.Bytes(), infos) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if infos.Images != 1 { |
| t.Errorf("Excepted images: %d, %d found", 1, infos.Images) |
| } |
| } |
| |
| func TestGetImagesJSON(t *testing.T) { |
| runtime, err := newTestRuntime() |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer nuke(runtime) |
| |
| srv := &Server{runtime: runtime} |
| |
| // all=0 |
| req, err := http.NewRequest("GET", "/images/json?all=0", nil) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| r := httptest.NewRecorder() |
| |
| if err := getImagesJSON(srv, APIVERSION, r, req, nil); err != nil { |
| t.Fatal(err) |
| } |
| |
| images := []APIImages{} |
| if err := json.Unmarshal(r.Body.Bytes(), &images); err != nil { |
| t.Fatal(err) |
| } |
| |
| if len(images) != 1 { |
| t.Errorf("Excepted 1 image, %d found", len(images)) |
| } |
| |
| if images[0].Repository != unitTestImageName { |
| t.Errorf("Excepted image %s, %s found", unitTestImageName, images[0].Repository) |
| } |
| |
| r2 := httptest.NewRecorder() |
| |
| // all=1 |
| req2, err := http.NewRequest("GET", "/images/json?all=true", nil) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| if err := getImagesJSON(srv, APIVERSION, r2, req2, nil); err != nil { |
| t.Fatal(err) |
| } |
| |
| images2 := []APIImages{} |
| if err := json.Unmarshal(r2.Body.Bytes(), &images2); err != nil { |
| t.Fatal(err) |
| } |
| |
| if len(images2) != 1 { |
| t.Errorf("Excepted 1 image, %d found", len(images2)) |
| } |
| |
| if images2[0].ID != GetTestImage(runtime).ID { |
| t.Errorf("Retrieved image Id differs, expected %s, received %s", GetTestImage(runtime).ID, images2[0].ID) |
| } |
| |
| r3 := httptest.NewRecorder() |
| |
| // filter=a |
| req3, err := http.NewRequest("GET", "/images/json?filter=a", nil) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| if err := getImagesJSON(srv, APIVERSION, r3, req3, nil); err != nil { |
| t.Fatal(err) |
| } |
| |
| images3 := []APIImages{} |
| if err := json.Unmarshal(r3.Body.Bytes(), &images3); err != nil { |
| t.Fatal(err) |
| } |
| |
| if len(images3) != 0 { |
| t.Errorf("Excepted 1 image, %d found", len(images3)) |
| } |
| |
| r4 := httptest.NewRecorder() |
| |
| // all=foobar |
| req4, err := http.NewRequest("GET", "/images/json?all=foobar", nil) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| err = getImagesJSON(srv, APIVERSION, r4, req4, nil) |
| if err == nil { |
| t.Fatalf("Error expected, received none") |
| } |
| |
| httpError(r4, err) |
| if r4.Code != http.StatusBadRequest { |
| t.Fatalf("%d Bad Request expected, received %d\n", http.StatusBadRequest, r4.Code) |
| } |
| } |
| |
| func TestGetImagesViz(t *testing.T) { |
| runtime, err := newTestRuntime() |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer nuke(runtime) |
| |
| srv := &Server{runtime: runtime} |
| |
| r := httptest.NewRecorder() |
| if err := getImagesViz(srv, APIVERSION, r, nil, nil); err != nil { |
| t.Fatal(err) |
| } |
| |
| if r.Code != http.StatusOK { |
| t.Fatalf("%d OK expected, received %d\n", http.StatusOK, r.Code) |
| } |
| |
| reader := bufio.NewReader(r.Body) |
| line, err := reader.ReadString('\n') |
| if err != nil { |
| t.Fatal(err) |
| } |
| if line != "digraph docker {\n" { |
| t.Errorf("Excepted digraph docker {\n, %s found", line) |
| } |
| } |
| |
| func TestGetImagesSearch(t *testing.T) { |
| runtime, err := newTestRuntime() |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer nuke(runtime) |
| |
| srv := &Server{ |
| runtime: runtime, |
| } |
| |
| r := httptest.NewRecorder() |
| |
| req, err := http.NewRequest("GET", "/images/search?term=redis", nil) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| if err := getImagesSearch(srv, APIVERSION, r, req, nil); err != nil { |
| t.Fatal(err) |
| } |
| |
| results := []APISearch{} |
| if err := json.Unmarshal(r.Body.Bytes(), &results); err != nil { |
| t.Fatal(err) |
| } |
| if len(results) < 2 { |
| t.Errorf("Excepted at least 2 lines, %d found", len(results)) |
| } |
| } |
| |
| func TestGetImagesHistory(t *testing.T) { |
| runtime, err := newTestRuntime() |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer nuke(runtime) |
| |
| srv := &Server{runtime: runtime} |
| |
| r := httptest.NewRecorder() |
| |
| if err := getImagesHistory(srv, APIVERSION, r, nil, map[string]string{"name": unitTestImageName}); err != nil { |
| t.Fatal(err) |
| } |
| |
| history := []APIHistory{} |
| if err := json.Unmarshal(r.Body.Bytes(), &history); err != nil { |
| t.Fatal(err) |
| } |
| if len(history) != 1 { |
| t.Errorf("Excepted 1 line, %d found", len(history)) |
| } |
| } |
| |
| func TestGetImagesByName(t *testing.T) { |
| runtime, err := newTestRuntime() |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer nuke(runtime) |
| |
| srv := &Server{runtime: runtime} |
| |
| r := httptest.NewRecorder() |
| if err := getImagesByName(srv, APIVERSION, r, nil, map[string]string{"name": unitTestImageName}); err != nil { |
| t.Fatal(err) |
| } |
| |
| img := &Image{} |
| if err := json.Unmarshal(r.Body.Bytes(), img); err != nil { |
| t.Fatal(err) |
| } |
| if img.ID != GetTestImage(runtime).ID || img.Comment != "Imported from http://get.docker.io/images/busybox" { |
| t.Errorf("Error inspecting image") |
| } |
| } |
| |
| func TestGetContainersJSON(t *testing.T) { |
| runtime, err := newTestRuntime() |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer nuke(runtime) |
| |
| srv := &Server{runtime: runtime} |
| |
| container, err := NewBuilder(runtime).Create(&Config{ |
| Image: GetTestImage(runtime).ID, |
| Cmd: []string{"echo", "test"}, |
| }) |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer runtime.Destroy(container) |
| |
| req, err := http.NewRequest("GET", "/containers/json?all=1", nil) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| r := httptest.NewRecorder() |
| if err := getContainersJSON(srv, APIVERSION, r, req, nil); err != nil { |
| t.Fatal(err) |
| } |
| containers := []APIContainers{} |
| if err := json.Unmarshal(r.Body.Bytes(), &containers); err != nil { |
| t.Fatal(err) |
| } |
| if len(containers) != 1 { |
| t.Fatalf("Excepted %d container, %d found", 1, len(containers)) |
| } |
| if containers[0].ID != container.ID { |
| t.Fatalf("Container ID mismatch. Expected: %s, received: %s\n", container.ID, containers[0].ID) |
| } |
| } |
| |
| func TestGetContainersExport(t *testing.T) { |
| runtime, err := newTestRuntime() |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer nuke(runtime) |
| |
| srv := &Server{runtime: runtime} |
| |
| builder := NewBuilder(runtime) |
| |
| // Create a container and remove a file |
| container, err := builder.Create( |
| &Config{ |
| Image: GetTestImage(runtime).ID, |
| Cmd: []string{"touch", "/test"}, |
| }, |
| ) |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer runtime.Destroy(container) |
| |
| if err := container.Run(); err != nil { |
| t.Fatal(err) |
| } |
| |
| r := httptest.NewRecorder() |
| if err = getContainersExport(srv, APIVERSION, r, nil, map[string]string{"name": container.ID}); err != nil { |
| t.Fatal(err) |
| } |
| |
| if r.Code != http.StatusOK { |
| t.Fatalf("%d OK expected, received %d\n", http.StatusOK, r.Code) |
| } |
| |
| found := false |
| for tarReader := tar.NewReader(r.Body); ; { |
| h, err := tarReader.Next() |
| if err != nil { |
| if err == io.EOF { |
| break |
| } |
| t.Fatal(err) |
| } |
| if h.Name == "./test" { |
| found = true |
| break |
| } |
| } |
| if !found { |
| t.Fatalf("The created test file has not been found in the exported image") |
| } |
| } |
| |
| func TestGetContainersChanges(t *testing.T) { |
| runtime, err := newTestRuntime() |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer nuke(runtime) |
| |
| srv := &Server{runtime: runtime} |
| |
| builder := NewBuilder(runtime) |
| |
| // Create a container and remove a file |
| container, err := builder.Create( |
| &Config{ |
| Image: GetTestImage(runtime).ID, |
| Cmd: []string{"/bin/rm", "/etc/passwd"}, |
| }, |
| ) |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer runtime.Destroy(container) |
| |
| if err := container.Run(); err != nil { |
| t.Fatal(err) |
| } |
| |
| r := httptest.NewRecorder() |
| if err := getContainersChanges(srv, APIVERSION, r, nil, map[string]string{"name": container.ID}); err != nil { |
| t.Fatal(err) |
| } |
| changes := []Change{} |
| if err := json.Unmarshal(r.Body.Bytes(), &changes); err != nil { |
| t.Fatal(err) |
| } |
| |
| // Check the changelog |
| success := false |
| for _, elem := range changes { |
| if elem.Path == "/etc/passwd" && elem.Kind == 2 { |
| success = true |
| } |
| } |
| if !success { |
| t.Fatalf("/etc/passwd as been removed but is not present in the diff") |
| } |
| } |
| |
| func TestGetContainersByName(t *testing.T) { |
| runtime, err := newTestRuntime() |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer nuke(runtime) |
| |
| srv := &Server{runtime: runtime} |
| |
| builder := NewBuilder(runtime) |
| |
| // Create a container and remove a file |
| container, err := builder.Create( |
| &Config{ |
| Image: GetTestImage(runtime).ID, |
| Cmd: []string{"echo", "test"}, |
| }, |
| ) |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer runtime.Destroy(container) |
| |
| r := httptest.NewRecorder() |
| if err := getContainersByName(srv, APIVERSION, r, nil, map[string]string{"name": container.ID}); err != nil { |
| t.Fatal(err) |
| } |
| outContainer := &Container{} |
| if err := json.Unmarshal(r.Body.Bytes(), outContainer); err != nil { |
| t.Fatal(err) |
| } |
| if outContainer.ID != container.ID { |
| t.Fatalf("Wrong containers retrieved. Expected %s, recieved %s", container.ID, outContainer.ID) |
| } |
| } |
| |
| func TestPostCommit(t *testing.T) { |
| runtime, err := newTestRuntime() |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer nuke(runtime) |
| |
| srv := &Server{runtime: runtime} |
| |
| builder := NewBuilder(runtime) |
| |
| // Create a container and remove a file |
| container, err := builder.Create( |
| &Config{ |
| Image: GetTestImage(runtime).ID, |
| Cmd: []string{"touch", "/test"}, |
| }, |
| ) |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer runtime.Destroy(container) |
| |
| if err := container.Run(); err != nil { |
| t.Fatal(err) |
| } |
| |
| req, err := http.NewRequest("POST", "/commit?repo=testrepo&testtag=tag&container="+container.ID, bytes.NewReader([]byte{})) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| r := httptest.NewRecorder() |
| if err := postCommit(srv, APIVERSION, r, req, nil); err != nil { |
| t.Fatal(err) |
| } |
| if r.Code != http.StatusCreated { |
| t.Fatalf("%d Created expected, received %d\n", http.StatusCreated, r.Code) |
| } |
| |
| apiID := &APIID{} |
| if err := json.Unmarshal(r.Body.Bytes(), apiID); err != nil { |
| t.Fatal(err) |
| } |
| if _, err := runtime.graph.Get(apiID.ID); err != nil { |
| t.Fatalf("The image has not been commited") |
| } |
| } |
| |
| func TestPostImagesCreate(t *testing.T) { |
| // FIXME: Use the staging in order to perform tests |
| |
| // runtime, err := newTestRuntime() |
| // if err != nil { |
| // t.Fatal(err) |
| // } |
| // defer nuke(runtime) |
| |
| // srv := &Server{runtime: runtime} |
| |
| // stdin, stdinPipe := io.Pipe() |
| // stdout, stdoutPipe := io.Pipe() |
| |
| // c1 := make(chan struct{}) |
| // go func() { |
| // defer close(c1) |
| |
| // r := &hijackTester{ |
| // ResponseRecorder: httptest.NewRecorder(), |
| // in: stdin, |
| // out: stdoutPipe, |
| // } |
| |
| // req, err := http.NewRequest("POST", "/images/create?fromImage="+unitTestImageName, bytes.NewReader([]byte{})) |
| // if err != nil { |
| // t.Fatal(err) |
| // } |
| |
| // body, err := postImagesCreate(srv, r, req, nil) |
| // if err != nil { |
| // t.Fatal(err) |
| // } |
| // if body != nil { |
| // t.Fatalf("No body expected, received: %s\n", body) |
| // } |
| // }() |
| |
| // // Acknowledge hijack |
| // setTimeout(t, "hijack acknowledge timed out", 2*time.Second, func() { |
| // stdout.Read([]byte{}) |
| // stdout.Read(make([]byte, 4096)) |
| // }) |
| |
| // setTimeout(t, "Waiting for imagesCreate output", 5*time.Second, func() { |
| // reader := bufio.NewReader(stdout) |
| // line, err := reader.ReadString('\n') |
| // if err != nil { |
| // t.Fatal(err) |
| // } |
| // if !strings.HasPrefix(line, "Pulling repository d from") { |
| // t.Fatalf("Expected Pulling repository docker-ut from..., found %s", line) |
| // } |
| // }) |
| |
| // // Close pipes (client disconnects) |
| // if err := closeWrap(stdin, stdinPipe, stdout, stdoutPipe); err != nil { |
| // t.Fatal(err) |
| // } |
| |
| // // Wait for imagesCreate to finish, the client disconnected, therefore, Create finished his job |
| // setTimeout(t, "Waiting for imagesCreate timed out", 10*time.Second, func() { |
| // <-c1 |
| // }) |
| } |
| |
| func TestPostImagesInsert(t *testing.T) { |
| // runtime, err := newTestRuntime() |
| // if err != nil { |
| // t.Fatal(err) |
| // } |
| // defer nuke(runtime) |
| |
| // srv := &Server{runtime: runtime} |
| |
| // stdin, stdinPipe := io.Pipe() |
| // stdout, stdoutPipe := io.Pipe() |
| |
| // // 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", "/images/"+unitTestImageName+"/insert?path=%2Ftest&url=https%3A%2F%2Fraw.github.com%2Fdotcloud%2Fdocker%2Fmaster%2FREADME.md", bytes.NewReader([]byte{})) |
| // if err != nil { |
| // t.Fatal(err) |
| // } |
| // if err := postContainersCreate(srv, r, req, nil); err != nil { |
| // t.Fatal(err) |
| // } |
| // }() |
| |
| // // Acknowledge hijack |
| // setTimeout(t, "hijack acknowledge timed out", 5*time.Second, func() { |
| // stdout.Read([]byte{}) |
| // stdout.Read(make([]byte, 4096)) |
| // }) |
| |
| // id := "" |
| // setTimeout(t, "Waiting for imagesInsert output", 10*time.Second, func() { |
| // for { |
| // reader := bufio.NewReader(stdout) |
| // id, err = reader.ReadString('\n') |
| // if 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", 2*time.Second, func() { |
| // <-c1 |
| // }) |
| |
| // img, err := srv.runtime.repositories.LookupImage(id) |
| // if err != nil { |
| // t.Fatalf("New image %s expected but not found", id) |
| // } |
| |
| // layer, err := img.layer() |
| // if err != nil { |
| // t.Fatal(err) |
| // } |
| |
| // if _, err := os.Stat(path.Join(layer, "test")); err != nil { |
| // t.Fatalf("The test file has not been found") |
| // } |
| |
| // if err := srv.runtime.graph.Delete(img.ID); err != nil { |
| // t.Fatal(err) |
| // } |
| } |
| |
| func TestPostImagesPush(t *testing.T) { |
| //FIXME: Use staging in order to perform tests |
| // runtime, err := newTestRuntime() |
| // if err != nil { |
| // t.Fatal(err) |
| // } |
| // defer nuke(runtime) |
| |
| // srv := &Server{runtime: runtime} |
| |
| // stdin, stdinPipe := io.Pipe() |
| // stdout, stdoutPipe := io.Pipe() |
| |
| // c1 := make(chan struct{}) |
| // go func() { |
| // r := &hijackTester{ |
| // ResponseRecorder: httptest.NewRecorder(), |
| // in: stdin, |
| // out: stdoutPipe, |
| // } |
| |
| // req, err := http.NewRequest("POST", "/images/docker-ut/push", bytes.NewReader([]byte{})) |
| // if err != nil { |
| // t.Fatal(err) |
| // } |
| |
| // body, err := postImagesPush(srv, r, req, map[string]string{"name": "docker-ut"}) |
| // close(c1) |
| // if err != nil { |
| // t.Fatal(err) |
| // } |
| // if body != nil { |
| // t.Fatalf("No body expected, received: %s\n", body) |
| // } |
| // }() |
| |
| // // Acknowledge hijack |
| // setTimeout(t, "hijack acknowledge timed out", 2*time.Second, func() { |
| // stdout.Read([]byte{}) |
| // stdout.Read(make([]byte, 4096)) |
| // }) |
| |
| // setTimeout(t, "Waiting for imagesCreate output", 5*time.Second, func() { |
| // reader := bufio.NewReader(stdout) |
| // line, err := reader.ReadString('\n') |
| // if err != nil { |
| // t.Fatal(err) |
| // } |
| // if !strings.HasPrefix(line, "Processing checksum") { |
| // t.Fatalf("Processing checksum..., found %s", line) |
| // } |
| // }) |
| |
| // // Close pipes (client disconnects) |
| // if err := closeWrap(stdin, stdinPipe, stdout, stdoutPipe); err != nil { |
| // t.Fatal(err) |
| // } |
| |
| // // Wait for imagesPush to finish, the client disconnected, therefore, Push finished his job |
| // setTimeout(t, "Waiting for imagesPush timed out", 10*time.Second, func() { |
| // <-c1 |
| // }) |
| } |
| |
| func TestPostImagesTag(t *testing.T) { |
| // FIXME: Use staging in order to perform tests |
| |
| // runtime, err := newTestRuntime() |
| // if err != nil { |
| // t.Fatal(err) |
| // } |
| // defer nuke(runtime) |
| |
| // srv := &Server{runtime: runtime} |
| |
| // r := httptest.NewRecorder() |
| |
| // req, err := http.NewRequest("POST", "/images/docker-ut/tag?repo=testrepo&tag=testtag", bytes.NewReader([]byte{})) |
| // if err != nil { |
| // t.Fatal(err) |
| // } |
| |
| // body, err := postImagesTag(srv, r, req, map[string]string{"name": "docker-ut"}) |
| // if err != nil { |
| // t.Fatal(err) |
| // } |
| |
| // if body != nil { |
| // t.Fatalf("No body expected, received: %s\n", body) |
| // } |
| // if r.Code != http.StatusCreated { |
| // t.Fatalf("%d Created expected, received %d\n", http.StatusCreated, r.Code) |
| // } |
| } |
| |
| func TestPostContainersCreate(t *testing.T) { |
| runtime, err := newTestRuntime() |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer nuke(runtime) |
| |
| srv := &Server{runtime: runtime} |
| |
| configJSON, err := json.Marshal(&Config{ |
| Image: GetTestImage(runtime).ID, |
| Memory: 33554432, |
| Cmd: []string{"touch", "/test"}, |
| }) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| req, err := http.NewRequest("POST", "/containers/create", bytes.NewReader(configJSON)) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| r := httptest.NewRecorder() |
| if err := postContainersCreate(srv, APIVERSION, r, req, nil); err != nil { |
| t.Fatal(err) |
| } |
| if r.Code != http.StatusCreated { |
| t.Fatalf("%d Created expected, received %d\n", http.StatusCreated, r.Code) |
| } |
| |
| apiRun := &APIRun{} |
| if err := json.Unmarshal(r.Body.Bytes(), apiRun); err != nil { |
| t.Fatal(err) |
| } |
| |
| container := srv.runtime.Get(apiRun.ID) |
| if container == nil { |
| t.Fatalf("Container not created") |
| } |
| |
| if err := container.Run(); err != nil { |
| t.Fatal(err) |
| } |
| |
| if _, err := os.Stat(path.Join(container.rwPath(), "test")); err != nil { |
| if os.IsNotExist(err) { |
| utils.Debugf("Err: %s", err) |
| t.Fatalf("The test file has not been created") |
| } |
| t.Fatal(err) |
| } |
| } |
| |
| func TestPostContainersKill(t *testing.T) { |
| runtime, err := newTestRuntime() |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer nuke(runtime) |
| |
| srv := &Server{runtime: runtime} |
| |
| container, err := NewBuilder(runtime).Create( |
| &Config{ |
| Image: GetTestImage(runtime).ID, |
| Cmd: []string{"/bin/cat"}, |
| OpenStdin: true, |
| }, |
| ) |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer runtime.Destroy(container) |
| |
| if err := container.Start(); err != nil { |
| t.Fatal(err) |
| } |
| |
| // Give some time to the process to start |
| container.WaitTimeout(500 * time.Millisecond) |
| |
| if !container.State.Running { |
| t.Errorf("Container should be running") |
| } |
| |
| r := httptest.NewRecorder() |
| if err := postContainersKill(srv, APIVERSION, r, nil, map[string]string{"name": container.ID}); err != nil { |
| t.Fatal(err) |
| } |
| if r.Code != http.StatusNoContent { |
| t.Fatalf("%d NO CONTENT expected, received %d\n", http.StatusNoContent, r.Code) |
| } |
| if container.State.Running { |
| t.Fatalf("The container hasn't been killed") |
| } |
| } |
| |
| func TestPostContainersRestart(t *testing.T) { |
| runtime, err := newTestRuntime() |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer nuke(runtime) |
| |
| srv := &Server{runtime: runtime} |
| |
| container, err := NewBuilder(runtime).Create( |
| &Config{ |
| Image: GetTestImage(runtime).ID, |
| Cmd: []string{"/bin/cat"}, |
| OpenStdin: true, |
| }, |
| ) |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer runtime.Destroy(container) |
| |
| if err := container.Start(); err != nil { |
| t.Fatal(err) |
| } |
| |
| // Give some time to the process to start |
| container.WaitTimeout(500 * time.Millisecond) |
| |
| if !container.State.Running { |
| t.Errorf("Container should be running") |
| } |
| |
| req, err := http.NewRequest("POST", "/containers/"+container.ID+"/restart?t=1", bytes.NewReader([]byte{})) |
| if err != nil { |
| t.Fatal(err) |
| } |
| r := httptest.NewRecorder() |
| if err := postContainersRestart(srv, APIVERSION, r, req, map[string]string{"name": container.ID}); err != nil { |
| t.Fatal(err) |
| } |
| 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 |
| container.WaitTimeout(500 * time.Millisecond) |
| |
| if !container.State.Running { |
| t.Fatalf("Container should be running") |
| } |
| |
| if err := container.Kill(); err != nil { |
| t.Fatal(err) |
| } |
| } |
| |
| func TestPostContainersStart(t *testing.T) { |
| runtime, err := newTestRuntime() |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer nuke(runtime) |
| |
| srv := &Server{runtime: runtime} |
| |
| container, err := NewBuilder(runtime).Create( |
| &Config{ |
| Image: GetTestImage(runtime).ID, |
| Cmd: []string{"/bin/cat"}, |
| OpenStdin: true, |
| }, |
| ) |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer runtime.Destroy(container) |
| |
| r := httptest.NewRecorder() |
| if err := postContainersStart(srv, APIVERSION, r, nil, map[string]string{"name": container.ID}); err != nil { |
| t.Fatal(err) |
| } |
| 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 start |
| container.WaitTimeout(500 * time.Millisecond) |
| |
| if !container.State.Running { |
| t.Errorf("Container should be running") |
| } |
| |
| r = httptest.NewRecorder() |
| if err = postContainersStart(srv, APIVERSION, r, nil, map[string]string{"name": container.ID}); err == nil { |
| t.Fatalf("A running containter should be able to be started") |
| } |
| |
| if err := container.Kill(); err != nil { |
| t.Fatal(err) |
| } |
| } |
| |
| func TestPostContainersStop(t *testing.T) { |
| runtime, err := newTestRuntime() |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer nuke(runtime) |
| |
| srv := &Server{runtime: runtime} |
| |
| container, err := NewBuilder(runtime).Create( |
| &Config{ |
| Image: GetTestImage(runtime).ID, |
| Cmd: []string{"/bin/cat"}, |
| OpenStdin: true, |
| }, |
| ) |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer runtime.Destroy(container) |
| |
| if err := container.Start(); err != nil { |
| t.Fatal(err) |
| } |
| |
| // Give some time to the process to start |
| container.WaitTimeout(500 * time.Millisecond) |
| |
| if !container.State.Running { |
| t.Errorf("Container should be running") |
| } |
| |
| // Note: as it is a POST request, it requires a body. |
| req, err := http.NewRequest("POST", "/containers/"+container.ID+"/stop?t=1", bytes.NewReader([]byte{})) |
| if err != nil { |
| t.Fatal(err) |
| } |
| r := httptest.NewRecorder() |
| if err := postContainersStop(srv, APIVERSION, r, req, map[string]string{"name": container.ID}); err != nil { |
| t.Fatal(err) |
| } |
| if r.Code != http.StatusNoContent { |
| t.Fatalf("%d NO CONTENT expected, received %d\n", http.StatusNoContent, r.Code) |
| } |
| if container.State.Running { |
| t.Fatalf("The container hasn't been stopped") |
| } |
| } |
| |
| func TestPostContainersWait(t *testing.T) { |
| runtime, err := newTestRuntime() |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer nuke(runtime) |
| |
| srv := &Server{runtime: runtime} |
| |
| container, err := NewBuilder(runtime).Create( |
| &Config{ |
| Image: GetTestImage(runtime).ID, |
| Cmd: []string{"/bin/sleep", "1"}, |
| OpenStdin: true, |
| }, |
| ) |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer runtime.Destroy(container) |
| |
| if err := container.Start(); err != nil { |
| t.Fatal(err) |
| } |
| |
| setTimeout(t, "Wait timed out", 3*time.Second, func() { |
| r := httptest.NewRecorder() |
| if err := postContainersWait(srv, APIVERSION, r, nil, map[string]string{"name": container.ID}); err != nil { |
| t.Fatal(err) |
| } |
| apiWait := &APIWait{} |
| if err := json.Unmarshal(r.Body.Bytes(), apiWait); err != nil { |
| t.Fatal(err) |
| } |
| if apiWait.StatusCode != 0 { |
| t.Fatalf("Non zero exit code for sleep: %d\n", apiWait.StatusCode) |
| } |
| }) |
| |
| if container.State.Running { |
| t.Fatalf("The container should be stopped after wait") |
| } |
| } |
| |
| func TestPostContainersAttach(t *testing.T) { |
| runtime, err := newTestRuntime() |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer nuke(runtime) |
| |
| srv := &Server{runtime: runtime} |
| |
| container, err := NewBuilder(runtime).Create( |
| &Config{ |
| Image: GetTestImage(runtime).ID, |
| Cmd: []string{"/bin/cat"}, |
| OpenStdin: true, |
| }, |
| ) |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer runtime.Destroy(container) |
| |
| // Start the process |
| if err := container.Start(); err != nil { |
| t.Fatal(err) |
| } |
| |
| stdin, stdinPipe := io.Pipe() |
| stdout, stdoutPipe := io.Pipe() |
| |
| // 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/"+container.ID+"/attach?stream=1&stdin=1&stdout=1&stderr=1", bytes.NewReader([]byte{})) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| if err := postContainersAttach(srv, APIVERSION, r, req, map[string]string{"name": container.ID}); err != nil { |
| t.Fatal(err) |
| } |
| }() |
| |
| // 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", "hello", stdout, stdinPipe, 15); 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", 2*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 |
| err = container.WaitTimeout(500 * time.Millisecond) |
| if err == nil || !container.State.Running { |
| t.Fatalf("/bin/cat is not running after closing stdin") |
| } |
| |
| // Try to avoid the timeoout in destroy. Best effort, don't check error |
| cStdin, _ := container.StdinPipe() |
| cStdin.Close() |
| container.Wait() |
| } |
| |
| // FIXME: Test deleting running container |
| // FIXME: Test deleting container with volume |
| // FIXME: Test deleting volume in use by other container |
| func TestDeleteContainers(t *testing.T) { |
| runtime, err := newTestRuntime() |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer nuke(runtime) |
| |
| srv := &Server{runtime: runtime} |
| |
| container, err := NewBuilder(runtime).Create(&Config{ |
| Image: GetTestImage(runtime).ID, |
| Cmd: []string{"touch", "/test"}, |
| }) |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer runtime.Destroy(container) |
| |
| if err := container.Run(); err != nil { |
| t.Fatal(err) |
| } |
| |
| req, err := http.NewRequest("DELETE", "/containers/"+container.ID, nil) |
| if err != nil { |
| t.Fatal(err) |
| } |
| r := httptest.NewRecorder() |
| if err := deleteContainers(srv, APIVERSION, r, req, map[string]string{"name": container.ID}); err != nil { |
| t.Fatal(err) |
| } |
| if r.Code != http.StatusNoContent { |
| t.Fatalf("%d NO CONTENT expected, received %d\n", http.StatusNoContent, r.Code) |
| } |
| |
| if c := runtime.Get(container.ID); c != nil { |
| t.Fatalf("The container as not been deleted") |
| } |
| |
| if _, err := os.Stat(path.Join(container.rwPath(), "test")); err == nil { |
| t.Fatalf("The test file has not been deleted") |
| } |
| } |
| |
| func TestOptionsRoute(t *testing.T) { |
| runtime, err := newTestRuntime() |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer nuke(runtime) |
| |
| srv := &Server{runtime: runtime, enableCors: true} |
| |
| r := httptest.NewRecorder() |
| router, err := createRouter(srv, false) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| req, err := http.NewRequest("OPTIONS", "/", nil) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| router.ServeHTTP(r, req) |
| if r.Code != http.StatusOK { |
| t.Errorf("Expected response for OPTIONS request to be \"200\", %v found.", r.Code) |
| } |
| } |
| |
| func TestGetEnabledCors(t *testing.T) { |
| runtime, err := newTestRuntime() |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer nuke(runtime) |
| |
| srv := &Server{runtime: runtime, enableCors: true} |
| |
| r := httptest.NewRecorder() |
| |
| router, err := createRouter(srv, false) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| req, err := http.NewRequest("GET", "/version", nil) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| router.ServeHTTP(r, req) |
| 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" { |
| t.Errorf("Expected header Access-Control-Allow-Headers to be \"Origin, X-Requested-With, Content-Type, Accept\", %s found.", allowHeaders) |
| } |
| if allowMethods != "GET, POST, DELETE, PUT, OPTIONS" { |
| t.Errorf("Expected hearder Access-Control-Allow-Methods to be \"GET, POST, DELETE, PUT, OPTIONS\", %s found.", allowMethods) |
| } |
| } |
| |
| func TestDeleteImages(t *testing.T) { |
| runtime, err := newTestRuntime() |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer nuke(runtime) |
| |
| srv := &Server{runtime: runtime} |
| |
| if err := srv.runtime.repositories.Set("test", "test", unitTestImageName, true); err != nil { |
| t.Fatal(err) |
| } |
| |
| images, err := srv.Images(false, "") |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| if len(images) != 2 { |
| t.Errorf("Excepted 2 images, %d found", len(images)) |
| } |
| |
| req, err := http.NewRequest("DELETE", "/images/test:test", nil) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| r := httptest.NewRecorder() |
| if err := deleteImages(srv, APIVERSION, r, req, map[string]string{"name": "test:test"}); err != nil { |
| t.Fatal(err) |
| } |
| if r.Code != http.StatusOK { |
| t.Fatalf("%d OK expected, received %d\n", http.StatusOK, r.Code) |
| } |
| |
| var outs []APIRmi |
| if err := json.Unmarshal(r.Body.Bytes(), &outs); err != nil { |
| t.Fatal(err) |
| } |
| if len(outs) != 1 { |
| t.Fatalf("Expected %d event (untagged), got %d", 1, len(outs)) |
| } |
| images, err = srv.Images(false, "") |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| if len(images) != 1 { |
| t.Errorf("Excepted 1 image, %d found", len(images)) |
| } |
| |
| /* if c := runtime.Get(container.Id); c != nil { |
| t.Fatalf("The container as not been deleted") |
| } |
| |
| if _, err := os.Stat(path.Join(container.rwPath(), "test")); err == nil { |
| t.Fatalf("The test file has not been deleted") |
| } */ |
| } |
| |
| // Mocked types for tests |
| type NopConn struct { |
| io.ReadCloser |
| io.Writer |
| } |
| |
| func (c *NopConn) LocalAddr() net.Addr { return nil } |
| func (c *NopConn) RemoteAddr() net.Addr { return nil } |
| func (c *NopConn) SetDeadline(t time.Time) error { return nil } |
| func (c *NopConn) SetReadDeadline(t time.Time) error { return nil } |
| func (c *NopConn) SetWriteDeadline(t time.Time) error { return nil } |
| |
| type hijackTester struct { |
| *httptest.ResponseRecorder |
| in io.ReadCloser |
| out io.Writer |
| } |
| |
| func (t *hijackTester) Hijack() (net.Conn, *bufio.ReadWriter, error) { |
| bufrw := bufio.NewReadWriter(bufio.NewReader(t.in), bufio.NewWriter(t.out)) |
| conn := &NopConn{ |
| ReadCloser: t.in, |
| Writer: t.out, |
| } |
| return conn, bufrw, nil |
| } |