mirror of
https://github.com/moby/moby.git
synced 2022-11-09 12:21:53 -05:00
344 lines
7.9 KiB
Go
344 lines
7.9 KiB
Go
package client
|
|
|
|
import (
|
|
"bytes"
|
|
"net/http"
|
|
"net/url"
|
|
"os"
|
|
"runtime"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/docker/docker/api"
|
|
"github.com/docker/docker/api/types"
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func TestNewEnvClient(t *testing.T) {
|
|
if runtime.GOOS == "windows" {
|
|
t.Skip("skipping unix only test for windows")
|
|
}
|
|
cases := []struct {
|
|
envs map[string]string
|
|
expectedError string
|
|
expectedVersion string
|
|
}{
|
|
{
|
|
envs: map[string]string{},
|
|
expectedVersion: api.DefaultVersion,
|
|
},
|
|
{
|
|
envs: map[string]string{
|
|
"DOCKER_CERT_PATH": "invalid/path",
|
|
},
|
|
expectedError: "Could not load X509 key pair: open invalid/path/cert.pem: no such file or directory",
|
|
},
|
|
{
|
|
envs: map[string]string{
|
|
"DOCKER_CERT_PATH": "testdata/",
|
|
},
|
|
expectedVersion: api.DefaultVersion,
|
|
},
|
|
{
|
|
envs: map[string]string{
|
|
"DOCKER_CERT_PATH": "testdata/",
|
|
"DOCKER_TLS_VERIFY": "1",
|
|
},
|
|
expectedVersion: api.DefaultVersion,
|
|
},
|
|
{
|
|
envs: map[string]string{
|
|
"DOCKER_CERT_PATH": "testdata/",
|
|
"DOCKER_HOST": "https://notaunixsocket",
|
|
},
|
|
expectedVersion: api.DefaultVersion,
|
|
},
|
|
{
|
|
envs: map[string]string{
|
|
"DOCKER_HOST": "host",
|
|
},
|
|
expectedError: "unable to parse docker host `host`",
|
|
},
|
|
{
|
|
envs: map[string]string{
|
|
"DOCKER_HOST": "invalid://url",
|
|
},
|
|
expectedVersion: api.DefaultVersion,
|
|
},
|
|
{
|
|
envs: map[string]string{
|
|
"DOCKER_API_VERSION": "anything",
|
|
},
|
|
expectedVersion: "anything",
|
|
},
|
|
{
|
|
envs: map[string]string{
|
|
"DOCKER_API_VERSION": "1.22",
|
|
},
|
|
expectedVersion: "1.22",
|
|
},
|
|
}
|
|
|
|
env := envToMap()
|
|
defer mapToEnv(env)
|
|
for _, c := range cases {
|
|
mapToEnv(env)
|
|
mapToEnv(c.envs)
|
|
apiclient, err := NewEnvClient()
|
|
if c.expectedError != "" {
|
|
assert.Error(t, err)
|
|
assert.Equal(t, c.expectedError, err.Error())
|
|
} else {
|
|
assert.NoError(t, err)
|
|
version := apiclient.ClientVersion()
|
|
assert.Equal(t, c.expectedVersion, version)
|
|
}
|
|
|
|
if c.envs["DOCKER_TLS_VERIFY"] != "" {
|
|
// pedantic checking that this is handled correctly
|
|
tr := apiclient.client.Transport.(*http.Transport)
|
|
assert.NotNil(t, tr.TLSClientConfig)
|
|
assert.Equal(t, tr.TLSClientConfig.InsecureSkipVerify, false)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestGetAPIPath(t *testing.T) {
|
|
cases := []struct {
|
|
v string
|
|
p string
|
|
q url.Values
|
|
e string
|
|
}{
|
|
{"", "/containers/json", nil, "/containers/json"},
|
|
{"", "/containers/json", url.Values{}, "/containers/json"},
|
|
{"", "/containers/json", url.Values{"s": []string{"c"}}, "/containers/json?s=c"},
|
|
{"1.22", "/containers/json", nil, "/v1.22/containers/json"},
|
|
{"1.22", "/containers/json", url.Values{}, "/v1.22/containers/json"},
|
|
{"1.22", "/containers/json", url.Values{"s": []string{"c"}}, "/v1.22/containers/json?s=c"},
|
|
{"v1.22", "/containers/json", nil, "/v1.22/containers/json"},
|
|
{"v1.22", "/containers/json", url.Values{}, "/v1.22/containers/json"},
|
|
{"v1.22", "/containers/json", url.Values{"s": []string{"c"}}, "/v1.22/containers/json?s=c"},
|
|
{"v1.22", "/networks/kiwl$%^", nil, "/v1.22/networks/kiwl$%25%5E"},
|
|
}
|
|
|
|
for _, cs := range cases {
|
|
c, err := NewClient("unix:///var/run/docker.sock", cs.v, nil, nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
g := c.getAPIPath(cs.p, cs.q)
|
|
assert.Equal(t, g, cs.e)
|
|
|
|
err = c.Close()
|
|
assert.NoError(t, err)
|
|
}
|
|
}
|
|
|
|
func TestParseHost(t *testing.T) {
|
|
cases := []struct {
|
|
host string
|
|
proto string
|
|
addr string
|
|
base string
|
|
err bool
|
|
}{
|
|
{"", "", "", "", true},
|
|
{"foobar", "", "", "", true},
|
|
{"foo://bar", "foo", "bar", "", false},
|
|
{"tcp://localhost:2476", "tcp", "localhost:2476", "", false},
|
|
{"tcp://localhost:2476/path", "tcp", "localhost:2476", "/path", false},
|
|
}
|
|
|
|
for _, cs := range cases {
|
|
p, a, b, e := ParseHost(cs.host)
|
|
// if we expected an error to be returned...
|
|
if cs.err {
|
|
assert.Error(t, e)
|
|
}
|
|
assert.Equal(t, cs.proto, p)
|
|
assert.Equal(t, cs.addr, a)
|
|
assert.Equal(t, cs.base, b)
|
|
}
|
|
}
|
|
|
|
func TestNewEnvClientSetsDefaultVersion(t *testing.T) {
|
|
env := envToMap()
|
|
defer mapToEnv(env)
|
|
|
|
envMap := map[string]string{
|
|
"DOCKER_HOST": "",
|
|
"DOCKER_API_VERSION": "",
|
|
"DOCKER_TLS_VERIFY": "",
|
|
"DOCKER_CERT_PATH": "",
|
|
}
|
|
mapToEnv(envMap)
|
|
|
|
client, err := NewEnvClient()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
assert.Equal(t, client.version, api.DefaultVersion)
|
|
|
|
expected := "1.22"
|
|
os.Setenv("DOCKER_API_VERSION", expected)
|
|
client, err = NewEnvClient()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
assert.Equal(t, expected, client.version)
|
|
}
|
|
|
|
// TestNegotiateAPIVersionEmpty asserts that client.Client can
|
|
// negotiate a compatible APIVersion when omitted
|
|
func TestNegotiateAPIVersionEmpty(t *testing.T) {
|
|
env := envToMap()
|
|
defer mapToEnv(env)
|
|
|
|
envMap := map[string]string{
|
|
"DOCKER_API_VERSION": "",
|
|
}
|
|
mapToEnv(envMap)
|
|
|
|
client, err := NewEnvClient()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
ping := types.Ping{
|
|
APIVersion: "",
|
|
OSType: "linux",
|
|
Experimental: false,
|
|
}
|
|
|
|
// set our version to something new
|
|
client.version = "1.25"
|
|
|
|
// if no version from server, expect the earliest
|
|
// version before APIVersion was implemented
|
|
expected := "1.24"
|
|
|
|
// test downgrade
|
|
client.NegotiateAPIVersionPing(ping)
|
|
assert.Equal(t, expected, client.version)
|
|
}
|
|
|
|
// TestNegotiateAPIVersion asserts that client.Client can
|
|
// negotiate a compatible APIVersion with the server
|
|
func TestNegotiateAPIVersion(t *testing.T) {
|
|
client, err := NewEnvClient()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
expected := "1.21"
|
|
|
|
ping := types.Ping{
|
|
APIVersion: expected,
|
|
OSType: "linux",
|
|
Experimental: false,
|
|
}
|
|
|
|
// set our version to something new
|
|
client.version = "1.22"
|
|
|
|
// test downgrade
|
|
client.NegotiateAPIVersionPing(ping)
|
|
assert.Equal(t, expected, client.version)
|
|
}
|
|
|
|
// TestNegotiateAPIVersionOverride asserts that we honor
|
|
// the environment variable DOCKER_API_VERSION when negotianing versions
|
|
func TestNegotiateAPVersionOverride(t *testing.T) {
|
|
env := envToMap()
|
|
defer mapToEnv(env)
|
|
|
|
envMap := map[string]string{
|
|
"DOCKER_API_VERSION": "9.99",
|
|
}
|
|
mapToEnv(envMap)
|
|
|
|
client, err := NewEnvClient()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
ping := types.Ping{
|
|
APIVersion: "1.24",
|
|
OSType: "linux",
|
|
Experimental: false,
|
|
}
|
|
|
|
expected := envMap["DOCKER_API_VERSION"]
|
|
|
|
// test that we honored the env var
|
|
client.NegotiateAPIVersionPing(ping)
|
|
assert.Equal(t, expected, client.version)
|
|
}
|
|
|
|
// mapToEnv takes a map of environment variables and sets them
|
|
func mapToEnv(env map[string]string) {
|
|
for k, v := range env {
|
|
os.Setenv(k, v)
|
|
}
|
|
}
|
|
|
|
// envToMap returns a map of environment variables
|
|
func envToMap() map[string]string {
|
|
env := make(map[string]string)
|
|
for _, e := range os.Environ() {
|
|
kv := strings.SplitAfterN(e, "=", 2)
|
|
env[kv[0]] = kv[1]
|
|
}
|
|
|
|
return env
|
|
}
|
|
|
|
type roundTripFunc func(*http.Request) (*http.Response, error)
|
|
|
|
func (rtf roundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {
|
|
return rtf(req)
|
|
}
|
|
|
|
type bytesBufferClose struct {
|
|
*bytes.Buffer
|
|
}
|
|
|
|
func (bbc bytesBufferClose) Close() error {
|
|
return nil
|
|
}
|
|
|
|
func TestClientRedirect(t *testing.T) {
|
|
client := &http.Client{
|
|
CheckRedirect: CheckRedirect,
|
|
Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
|
|
if req.URL.String() == "/bla" {
|
|
return &http.Response{StatusCode: 404}, nil
|
|
}
|
|
return &http.Response{
|
|
StatusCode: 301,
|
|
Header: map[string][]string{"Location": {"/bla"}},
|
|
Body: bytesBufferClose{bytes.NewBuffer(nil)},
|
|
}, nil
|
|
}),
|
|
}
|
|
|
|
cases := []struct {
|
|
httpMethod string
|
|
expectedErr error
|
|
statusCode int
|
|
}{
|
|
{http.MethodGet, nil, 301},
|
|
{http.MethodPost, &url.Error{Op: "Post", URL: "/bla", Err: ErrRedirect}, 301},
|
|
{http.MethodPut, &url.Error{Op: "Put", URL: "/bla", Err: ErrRedirect}, 301},
|
|
{http.MethodDelete, &url.Error{Op: "Delete", URL: "/bla", Err: ErrRedirect}, 301},
|
|
}
|
|
|
|
for _, tc := range cases {
|
|
req, err := http.NewRequest(tc.httpMethod, "/redirectme", nil)
|
|
assert.NoError(t, err)
|
|
resp, err := client.Do(req)
|
|
assert.Equal(t, tc.expectedErr, err)
|
|
assert.Equal(t, tc.statusCode, resp.StatusCode)
|
|
}
|
|
}
|