| package server |
| |
| import ( |
| "bytes" |
| "encoding/json" |
| "fmt" |
| "io" |
| "net/http" |
| "net/http/httptest" |
| "reflect" |
| "strings" |
| "testing" |
| |
| "github.com/docker/docker/api" |
| "github.com/docker/docker/engine" |
| "github.com/docker/docker/pkg/version" |
| ) |
| |
| func TestGetBoolParam(t *testing.T) { |
| if ret, err := getBoolParam("true"); err != nil || !ret { |
| t.Fatalf("true -> true, nil | got %t %s", ret, err) |
| } |
| if ret, err := getBoolParam("True"); err != nil || !ret { |
| t.Fatalf("True -> true, nil | got %t %s", ret, err) |
| } |
| if ret, err := getBoolParam("1"); err != nil || !ret { |
| t.Fatalf("1 -> true, nil | got %t %s", ret, err) |
| } |
| if ret, err := getBoolParam(""); err != nil || ret { |
| t.Fatalf("\"\" -> false, nil | got %t %s", ret, err) |
| } |
| if ret, err := getBoolParam("false"); err != nil || ret { |
| t.Fatalf("false -> false, nil | got %t %s", ret, err) |
| } |
| if ret, err := getBoolParam("0"); err != nil || ret { |
| t.Fatalf("0 -> false, nil | got %t %s", ret, err) |
| } |
| if ret, err := getBoolParam("faux"); err == nil || ret { |
| t.Fatalf("faux -> false, err | got %t %s", ret, err) |
| |
| } |
| } |
| |
| func TesthttpError(t *testing.T) { |
| r := httptest.NewRecorder() |
| |
| httpError(r, fmt.Errorf("No such method")) |
| if r.Code != http.StatusNotFound { |
| t.Fatalf("Expected %d, got %d", http.StatusNotFound, r.Code) |
| } |
| |
| httpError(r, fmt.Errorf("This accound hasn't been activated")) |
| if r.Code != http.StatusForbidden { |
| t.Fatalf("Expected %d, got %d", http.StatusForbidden, r.Code) |
| } |
| |
| httpError(r, fmt.Errorf("Some error")) |
| if r.Code != http.StatusInternalServerError { |
| t.Fatalf("Expected %d, got %d", http.StatusInternalServerError, r.Code) |
| } |
| } |
| |
| func TestGetVersion(t *testing.T) { |
| eng := engine.New() |
| var called bool |
| eng.Register("version", func(job *engine.Job) engine.Status { |
| called = true |
| v := &engine.Env{} |
| v.SetJson("Version", "42.1") |
| v.Set("ApiVersion", "1.1.1.1.1") |
| v.Set("GoVersion", "2.42") |
| v.Set("Os", "Linux") |
| v.Set("Arch", "x86_64") |
| if _, err := v.WriteTo(job.Stdout); err != nil { |
| return job.Error(err) |
| } |
| return engine.StatusOK |
| }) |
| r := serveRequest("GET", "/version", nil, eng, t) |
| if !called { |
| t.Fatalf("handler was not called") |
| } |
| v := readEnv(r.Body, t) |
| if v.Get("Version") != "42.1" { |
| t.Fatalf("%#v\n", v) |
| } |
| if r.HeaderMap.Get("Content-Type") != "application/json" { |
| t.Fatalf("%#v\n", r) |
| } |
| } |
| |
| func TestGetInfo(t *testing.T) { |
| eng := engine.New() |
| var called bool |
| eng.Register("info", func(job *engine.Job) engine.Status { |
| called = true |
| v := &engine.Env{} |
| v.SetInt("Containers", 1) |
| v.SetInt("Images", 42000) |
| if _, err := v.WriteTo(job.Stdout); err != nil { |
| return job.Error(err) |
| } |
| return engine.StatusOK |
| }) |
| r := serveRequest("GET", "/info", nil, eng, t) |
| if !called { |
| t.Fatalf("handler was not called") |
| } |
| v := readEnv(r.Body, t) |
| if v.GetInt("Images") != 42000 { |
| t.Fatalf("%#v\n", v) |
| } |
| if v.GetInt("Containers") != 1 { |
| t.Fatalf("%#v\n", v) |
| } |
| assertContentType(r, "application/json", t) |
| } |
| |
| func TestGetImagesJSON(t *testing.T) { |
| eng := engine.New() |
| var called bool |
| eng.Register("images", func(job *engine.Job) engine.Status { |
| called = true |
| v := createEnvFromGetImagesJSONStruct(sampleImage) |
| if _, err := v.WriteTo(job.Stdout); err != nil { |
| return job.Error(err) |
| } |
| return engine.StatusOK |
| }) |
| r := serveRequest("GET", "/images/json", nil, eng, t) |
| if !called { |
| t.Fatal("handler was not called") |
| } |
| assertHttpNotError(r, t) |
| assertContentType(r, "application/json", t) |
| var observed getImagesJSONStruct |
| if err := json.Unmarshal(r.Body.Bytes(), &observed); err != nil { |
| t.Fatal(err) |
| } |
| if !reflect.DeepEqual(observed, sampleImage) { |
| t.Errorf("Expected %#v but got %#v", sampleImage, observed) |
| } |
| } |
| |
| func TestGetImagesJSONFilter(t *testing.T) { |
| eng := engine.New() |
| filter := "nothing" |
| eng.Register("images", func(job *engine.Job) engine.Status { |
| filter = job.Getenv("filter") |
| return engine.StatusOK |
| }) |
| serveRequest("GET", "/images/json?filter=aaaa", nil, eng, t) |
| if filter != "aaaa" { |
| t.Errorf("%#v", filter) |
| } |
| } |
| |
| func TestGetImagesJSONFilters(t *testing.T) { |
| eng := engine.New() |
| filter := "nothing" |
| eng.Register("images", func(job *engine.Job) engine.Status { |
| filter = job.Getenv("filters") |
| return engine.StatusOK |
| }) |
| serveRequest("GET", "/images/json?filters=nnnn", nil, eng, t) |
| if filter != "nnnn" { |
| t.Errorf("%#v", filter) |
| } |
| } |
| |
| func TestGetImagesJSONAll(t *testing.T) { |
| eng := engine.New() |
| allFilter := "-1" |
| eng.Register("images", func(job *engine.Job) engine.Status { |
| allFilter = job.Getenv("all") |
| return engine.StatusOK |
| }) |
| serveRequest("GET", "/images/json?all=1", nil, eng, t) |
| if allFilter != "1" { |
| t.Errorf("%#v", allFilter) |
| } |
| } |
| |
| func TestGetImagesJSONLegacyFormat(t *testing.T) { |
| eng := engine.New() |
| var called bool |
| eng.Register("images", func(job *engine.Job) engine.Status { |
| called = true |
| outsLegacy := engine.NewTable("Created", 0) |
| outsLegacy.Add(createEnvFromGetImagesJSONStruct(sampleImage)) |
| if _, err := outsLegacy.WriteListTo(job.Stdout); err != nil { |
| return job.Error(err) |
| } |
| return engine.StatusOK |
| }) |
| r := serveRequestUsingVersion("GET", "/images/json", "1.6", nil, eng, t) |
| if !called { |
| t.Fatal("handler was not called") |
| } |
| assertHttpNotError(r, t) |
| assertContentType(r, "application/json", t) |
| images := engine.NewTable("Created", 0) |
| if _, err := images.ReadListFrom(r.Body.Bytes()); err != nil { |
| t.Fatal(err) |
| } |
| if images.Len() != 1 { |
| t.Fatalf("Expected 1 image, %d found", images.Len()) |
| } |
| image := images.Data[0] |
| if image.Get("Tag") != "test-tag" { |
| t.Errorf("Expected tag 'test-tag', found '%s'", image.Get("Tag")) |
| } |
| if image.Get("Repository") != "test-name" { |
| t.Errorf("Expected repository 'test-name', found '%s'", image.Get("Repository")) |
| } |
| } |
| |
| func TestGetContainersByName(t *testing.T) { |
| eng := engine.New() |
| name := "container_name" |
| var called bool |
| eng.Register("container_inspect", func(job *engine.Job) engine.Status { |
| called = true |
| if job.Args[0] != name { |
| t.Errorf("name != '%s': %#v", name, job.Args[0]) |
| } |
| if api.APIVERSION.LessThan("1.12") && !job.GetenvBool("dirty") { |
| t.Errorf("dirty env variable not set") |
| } else if api.APIVERSION.GreaterThanOrEqualTo("1.12") && job.GetenvBool("dirty") { |
| t.Errorf("dirty env variable set when it shouldn't") |
| } |
| v := &engine.Env{} |
| v.SetBool("dirty", true) |
| if _, err := v.WriteTo(job.Stdout); err != nil { |
| return job.Error(err) |
| } |
| return engine.StatusOK |
| }) |
| r := serveRequest("GET", "/containers/"+name+"/json", nil, eng, t) |
| if !called { |
| t.Fatal("handler was not called") |
| } |
| assertContentType(r, "application/json", t) |
| var stdoutJson interface{} |
| if err := json.Unmarshal(r.Body.Bytes(), &stdoutJson); err != nil { |
| t.Fatalf("%#v", err) |
| } |
| if stdoutJson.(map[string]interface{})["dirty"].(float64) != 1 { |
| t.Fatalf("%#v", stdoutJson) |
| } |
| } |
| |
| func TestGetEvents(t *testing.T) { |
| eng := engine.New() |
| var called bool |
| eng.Register("events", func(job *engine.Job) engine.Status { |
| called = true |
| since := job.Getenv("since") |
| if since != "1" { |
| t.Fatalf("'since' should be 1, found %#v instead", since) |
| } |
| until := job.Getenv("until") |
| if until != "0" { |
| t.Fatalf("'until' should be 0, found %#v instead", until) |
| } |
| v := &engine.Env{} |
| v.Set("since", since) |
| v.Set("until", until) |
| if _, err := v.WriteTo(job.Stdout); err != nil { |
| return job.Error(err) |
| } |
| return engine.StatusOK |
| }) |
| r := serveRequest("GET", "/events?since=1&until=0", nil, eng, t) |
| if !called { |
| t.Fatal("handler was not called") |
| } |
| assertContentType(r, "application/json", t) |
| var stdout_json struct { |
| Since int |
| Until int |
| } |
| if err := json.Unmarshal(r.Body.Bytes(), &stdout_json); err != nil { |
| t.Fatal(err) |
| } |
| if stdout_json.Since != 1 { |
| t.Errorf("since != 1: %#v", stdout_json.Since) |
| } |
| if stdout_json.Until != 0 { |
| t.Errorf("until != 0: %#v", stdout_json.Until) |
| } |
| } |
| |
| func TestLogs(t *testing.T) { |
| eng := engine.New() |
| var inspect bool |
| var logs bool |
| eng.Register("container_inspect", func(job *engine.Job) engine.Status { |
| inspect = true |
| if len(job.Args) == 0 { |
| t.Fatal("Job arguments is empty") |
| } |
| if job.Args[0] != "test" { |
| t.Fatalf("Container name %s, must be test", job.Args[0]) |
| } |
| return engine.StatusOK |
| }) |
| expected := "logs" |
| eng.Register("logs", func(job *engine.Job) engine.Status { |
| logs = true |
| if len(job.Args) == 0 { |
| t.Fatal("Job arguments is empty") |
| } |
| if job.Args[0] != "test" { |
| t.Fatalf("Container name %s, must be test", job.Args[0]) |
| } |
| follow := job.Getenv("follow") |
| if follow != "1" { |
| t.Fatalf("follow: %s, must be 1", follow) |
| } |
| stdout := job.Getenv("stdout") |
| if stdout != "1" { |
| t.Fatalf("stdout %s, must be 1", stdout) |
| } |
| stderr := job.Getenv("stderr") |
| if stderr != "" { |
| t.Fatalf("stderr %s, must be empty", stderr) |
| } |
| timestamps := job.Getenv("timestamps") |
| if timestamps != "1" { |
| t.Fatalf("timestamps %s, must be 1", timestamps) |
| } |
| job.Stdout.Write([]byte(expected)) |
| return engine.StatusOK |
| }) |
| r := serveRequest("GET", "/containers/test/logs?follow=1&stdout=1×tamps=1", nil, eng, t) |
| if r.Code != http.StatusOK { |
| t.Fatalf("Got status %d, expected %d", r.Code, http.StatusOK) |
| } |
| if !inspect { |
| t.Fatal("container_inspect job was not called") |
| } |
| if !logs { |
| t.Fatal("logs job was not called") |
| } |
| res := r.Body.String() |
| if res != expected { |
| t.Fatalf("Output %s, expected %s", res, expected) |
| } |
| } |
| |
| func TestLogsNoStreams(t *testing.T) { |
| eng := engine.New() |
| var inspect bool |
| var logs bool |
| eng.Register("container_inspect", func(job *engine.Job) engine.Status { |
| inspect = true |
| if len(job.Args) == 0 { |
| t.Fatal("Job arguments is empty") |
| } |
| if job.Args[0] != "test" { |
| t.Fatalf("Container name %s, must be test", job.Args[0]) |
| } |
| return engine.StatusOK |
| }) |
| eng.Register("logs", func(job *engine.Job) engine.Status { |
| logs = true |
| return engine.StatusOK |
| }) |
| r := serveRequest("GET", "/containers/test/logs", nil, eng, t) |
| if r.Code != http.StatusBadRequest { |
| t.Fatalf("Got status %d, expected %d", r.Code, http.StatusBadRequest) |
| } |
| if inspect { |
| t.Fatal("container_inspect job was called, but it shouldn't") |
| } |
| if logs { |
| t.Fatal("logs job was called, but it shouldn't") |
| } |
| res := strings.TrimSpace(r.Body.String()) |
| expected := "Bad parameters: you must choose at least one stream" |
| if !strings.Contains(res, expected) { |
| t.Fatalf("Output %s, expected %s in it", res, expected) |
| } |
| } |
| |
| func TestGetImagesHistory(t *testing.T) { |
| eng := engine.New() |
| imageName := "docker-test-image" |
| var called bool |
| eng.Register("history", func(job *engine.Job) engine.Status { |
| called = true |
| if len(job.Args) == 0 { |
| t.Fatal("Job arguments is empty") |
| } |
| if job.Args[0] != imageName { |
| t.Fatalf("name != '%s': %#v", imageName, job.Args[0]) |
| } |
| v := &engine.Env{} |
| if _, err := v.WriteTo(job.Stdout); err != nil { |
| return job.Error(err) |
| } |
| return engine.StatusOK |
| }) |
| r := serveRequest("GET", "/images/"+imageName+"/history", nil, eng, t) |
| if !called { |
| t.Fatalf("handler was not called") |
| } |
| if r.Code != http.StatusOK { |
| t.Fatalf("Got status %d, expected %d", r.Code, http.StatusOK) |
| } |
| if r.HeaderMap.Get("Content-Type") != "application/json" { |
| t.Fatalf("%#v\n", r) |
| } |
| } |
| |
| func TestGetImagesByName(t *testing.T) { |
| eng := engine.New() |
| name := "image_name" |
| var called bool |
| eng.Register("image_inspect", func(job *engine.Job) engine.Status { |
| called = true |
| if job.Args[0] != name { |
| t.Fatalf("name != '%s': %#v", name, job.Args[0]) |
| } |
| if api.APIVERSION.LessThan("1.12") && !job.GetenvBool("dirty") { |
| t.Fatal("dirty env variable not set") |
| } else if api.APIVERSION.GreaterThanOrEqualTo("1.12") && job.GetenvBool("dirty") { |
| t.Fatal("dirty env variable set when it shouldn't") |
| } |
| v := &engine.Env{} |
| v.SetBool("dirty", true) |
| if _, err := v.WriteTo(job.Stdout); err != nil { |
| return job.Error(err) |
| } |
| return engine.StatusOK |
| }) |
| r := serveRequest("GET", "/images/"+name+"/json", nil, eng, t) |
| if !called { |
| t.Fatal("handler was not called") |
| } |
| if r.HeaderMap.Get("Content-Type") != "application/json" { |
| t.Fatalf("%#v\n", r) |
| } |
| var stdoutJson interface{} |
| if err := json.Unmarshal(r.Body.Bytes(), &stdoutJson); err != nil { |
| t.Fatalf("%#v", err) |
| } |
| if stdoutJson.(map[string]interface{})["dirty"].(float64) != 1 { |
| t.Fatalf("%#v", stdoutJson) |
| } |
| } |
| |
| func TestDeleteContainers(t *testing.T) { |
| eng := engine.New() |
| name := "foo" |
| var called bool |
| eng.Register("rm", func(job *engine.Job) engine.Status { |
| called = true |
| if len(job.Args) == 0 { |
| t.Fatalf("Job arguments is empty") |
| } |
| if job.Args[0] != name { |
| t.Fatalf("name != '%s': %#v", name, job.Args[0]) |
| } |
| return engine.StatusOK |
| }) |
| r := serveRequest("DELETE", "/containers/"+name, nil, eng, t) |
| if !called { |
| t.Fatalf("handler was not called") |
| } |
| if r.Code != http.StatusNoContent { |
| t.Fatalf("Got status %d, expected %d", r.Code, http.StatusNoContent) |
| } |
| } |
| |
| func serveRequest(method, target string, body io.Reader, eng *engine.Engine, t *testing.T) *httptest.ResponseRecorder { |
| return serveRequestUsingVersion(method, target, api.APIVERSION, body, eng, t) |
| } |
| |
| func serveRequestUsingVersion(method, target string, version version.Version, body io.Reader, eng *engine.Engine, t *testing.T) *httptest.ResponseRecorder { |
| r := httptest.NewRecorder() |
| req, err := http.NewRequest(method, target, body) |
| if err != nil { |
| t.Fatal(err) |
| } |
| ServeRequest(eng, version, r, req) |
| return r |
| } |
| |
| func readEnv(src io.Reader, t *testing.T) *engine.Env { |
| out := engine.NewOutput() |
| v, err := out.AddEnv() |
| if err != nil { |
| t.Fatal(err) |
| } |
| if _, err := io.Copy(out, src); err != nil { |
| t.Fatal(err) |
| } |
| out.Close() |
| return v |
| } |
| |
| func toJson(data interface{}, t *testing.T) io.Reader { |
| var buf bytes.Buffer |
| if err := json.NewEncoder(&buf).Encode(data); err != nil { |
| t.Fatal(err) |
| } |
| return &buf |
| } |
| |
| func assertContentType(recorder *httptest.ResponseRecorder, content_type string, t *testing.T) { |
| if recorder.HeaderMap.Get("Content-Type") != content_type { |
| t.Fatalf("%#v\n", recorder) |
| } |
| } |
| |
| // XXX: Duplicated from integration/utils_test.go, but maybe that's OK as that |
| // should die as soon as we converted all integration tests? |
| // assertHttpNotError expect the given response to not have an error. |
| // Otherwise the it causes the test to fail. |
| func assertHttpNotError(r *httptest.ResponseRecorder, t *testing.T) { |
| // Non-error http status are [200, 400) |
| if r.Code < http.StatusOK || r.Code >= http.StatusBadRequest { |
| t.Fatal(fmt.Errorf("Unexpected http error: %v", r.Code)) |
| } |
| } |
| |
| func createEnvFromGetImagesJSONStruct(data getImagesJSONStruct) *engine.Env { |
| v := &engine.Env{} |
| v.SetList("RepoTags", data.RepoTags) |
| v.Set("Id", data.Id) |
| v.SetInt64("Created", data.Created) |
| v.SetInt64("Size", data.Size) |
| v.SetInt64("VirtualSize", data.VirtualSize) |
| return v |
| } |
| |
| type getImagesJSONStruct struct { |
| RepoTags []string |
| Id string |
| Created int64 |
| Size int64 |
| VirtualSize int64 |
| } |
| |
| var sampleImage getImagesJSONStruct = getImagesJSONStruct{ |
| RepoTags: []string{"test-name:test-tag"}, |
| Id: "ID", |
| Created: 999, |
| Size: 777, |
| VirtualSize: 666, |
| } |
