mirror of
https://github.com/moby/moby.git
synced 2022-11-09 12:21:53 -05:00
414 lines
12 KiB
Go
414 lines
12 KiB
Go
package client // import "github.com/docker/docker/client"
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"os"
|
|
"runtime"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/docker/docker/api"
|
|
"github.com/docker/docker/api/types"
|
|
"gotest.tools/v3/assert"
|
|
is "gotest.tools/v3/assert/cmp"
|
|
"gotest.tools/v3/env"
|
|
"gotest.tools/v3/skip"
|
|
)
|
|
|
|
func TestNewClientWithOpsFromEnv(t *testing.T) {
|
|
skip.If(t, runtime.GOOS == "windows")
|
|
|
|
testcases := []struct {
|
|
doc string
|
|
envs map[string]string
|
|
expectedError string
|
|
expectedVersion string
|
|
}{
|
|
{
|
|
doc: "default api version",
|
|
envs: map[string]string{},
|
|
expectedVersion: api.DefaultVersion,
|
|
},
|
|
{
|
|
doc: "invalid cert path",
|
|
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",
|
|
},
|
|
{
|
|
doc: "default api version with cert path",
|
|
envs: map[string]string{
|
|
"DOCKER_CERT_PATH": "testdata/",
|
|
},
|
|
expectedVersion: api.DefaultVersion,
|
|
},
|
|
{
|
|
doc: "default api version with cert path and tls verify",
|
|
envs: map[string]string{
|
|
"DOCKER_CERT_PATH": "testdata/",
|
|
"DOCKER_TLS_VERIFY": "1",
|
|
},
|
|
expectedVersion: api.DefaultVersion,
|
|
},
|
|
{
|
|
doc: "default api version with cert path and host",
|
|
envs: map[string]string{
|
|
"DOCKER_CERT_PATH": "testdata/",
|
|
"DOCKER_HOST": "https://notaunixsocket",
|
|
},
|
|
expectedVersion: api.DefaultVersion,
|
|
},
|
|
{
|
|
doc: "invalid docker host",
|
|
envs: map[string]string{
|
|
"DOCKER_HOST": "host",
|
|
},
|
|
expectedError: "unable to parse docker host `host`",
|
|
},
|
|
{
|
|
doc: "invalid docker host, with good format",
|
|
envs: map[string]string{
|
|
"DOCKER_HOST": "invalid://url",
|
|
},
|
|
expectedVersion: api.DefaultVersion,
|
|
},
|
|
{
|
|
doc: "override api version",
|
|
envs: map[string]string{
|
|
"DOCKER_API_VERSION": "1.22",
|
|
},
|
|
expectedVersion: "1.22",
|
|
},
|
|
}
|
|
|
|
defer env.PatchAll(t, nil)()
|
|
for _, tc := range testcases {
|
|
env.PatchAll(t, tc.envs)
|
|
client, err := NewClientWithOpts(FromEnv)
|
|
if tc.expectedError != "" {
|
|
assert.Check(t, is.Error(err, tc.expectedError), tc.doc)
|
|
} else {
|
|
assert.Check(t, err, tc.doc)
|
|
assert.Check(t, is.Equal(client.ClientVersion(), tc.expectedVersion), tc.doc)
|
|
}
|
|
|
|
if tc.envs["DOCKER_TLS_VERIFY"] != "" {
|
|
// pedantic checking that this is handled correctly
|
|
tr := client.client.Transport.(*http.Transport)
|
|
assert.Assert(t, tr.TLSClientConfig != nil, tc.doc)
|
|
assert.Check(t, is.Equal(tr.TLSClientConfig.InsecureSkipVerify, false), tc.doc)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestGetAPIPath(t *testing.T) {
|
|
testcases := []struct {
|
|
version string
|
|
path string
|
|
query url.Values
|
|
expected string
|
|
}{
|
|
{"", "/containers/json", nil, "/v" + api.DefaultVersion + "/containers/json"},
|
|
{"", "/containers/json", url.Values{}, "/v" + api.DefaultVersion + "/containers/json"},
|
|
{"", "/containers/json", url.Values{"s": []string{"c"}}, "/v" + api.DefaultVersion + "/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"},
|
|
}
|
|
|
|
ctx := context.TODO()
|
|
for _, tc := range testcases {
|
|
client, err := NewClientWithOpts(
|
|
WithVersion(tc.version),
|
|
WithHost("tcp://localhost:2375"),
|
|
)
|
|
assert.NilError(t, err)
|
|
actual := client.getAPIPath(ctx, tc.path, tc.query)
|
|
assert.Check(t, is.Equal(actual, tc.expected))
|
|
}
|
|
}
|
|
|
|
func TestParseHostURL(t *testing.T) {
|
|
testcases := []struct {
|
|
host string
|
|
expected *url.URL
|
|
expectedErr string
|
|
}{
|
|
{
|
|
host: "",
|
|
expectedErr: "unable to parse docker host",
|
|
},
|
|
{
|
|
host: "foobar",
|
|
expectedErr: "unable to parse docker host",
|
|
},
|
|
{
|
|
host: "foo://bar",
|
|
expected: &url.URL{Scheme: "foo", Host: "bar"},
|
|
},
|
|
{
|
|
host: "tcp://localhost:2476",
|
|
expected: &url.URL{Scheme: "tcp", Host: "localhost:2476"},
|
|
},
|
|
{
|
|
host: "tcp://localhost:2476/path",
|
|
expected: &url.URL{Scheme: "tcp", Host: "localhost:2476", Path: "/path"},
|
|
},
|
|
}
|
|
|
|
for _, testcase := range testcases {
|
|
actual, err := ParseHostURL(testcase.host)
|
|
if testcase.expectedErr != "" {
|
|
assert.Check(t, is.ErrorContains(err, testcase.expectedErr))
|
|
}
|
|
assert.Check(t, is.DeepEqual(actual, testcase.expected))
|
|
}
|
|
}
|
|
|
|
func TestNewClientWithOpsFromEnvSetsDefaultVersion(t *testing.T) {
|
|
defer env.PatchAll(t, map[string]string{
|
|
"DOCKER_HOST": "",
|
|
"DOCKER_API_VERSION": "",
|
|
"DOCKER_TLS_VERIFY": "",
|
|
"DOCKER_CERT_PATH": "",
|
|
})()
|
|
|
|
client, err := NewClientWithOpts(FromEnv)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
assert.Check(t, is.Equal(client.ClientVersion(), api.DefaultVersion))
|
|
|
|
const expected = "1.22"
|
|
_ = os.Setenv("DOCKER_API_VERSION", expected)
|
|
client, err = NewClientWithOpts(FromEnv)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
assert.Check(t, is.Equal(client.ClientVersion(), expected))
|
|
}
|
|
|
|
// TestNegotiateAPIVersionEmpty asserts that client.Client version negotiation
|
|
// downgrades to the correct API version if the API's ping response does not
|
|
// return an API version.
|
|
func TestNegotiateAPIVersionEmpty(t *testing.T) {
|
|
defer env.PatchAll(t, map[string]string{"DOCKER_API_VERSION": ""})()
|
|
|
|
client, err := NewClientWithOpts(FromEnv)
|
|
assert.NilError(t, err)
|
|
|
|
// set our version to something new
|
|
client.version = "1.25"
|
|
|
|
// if no version from server, expect the earliest
|
|
// version before APIVersion was implemented
|
|
const expected = "1.24"
|
|
|
|
// test downgrade
|
|
client.NegotiateAPIVersionPing(types.Ping{})
|
|
assert.Equal(t, client.ClientVersion(), expected)
|
|
}
|
|
|
|
// TestNegotiateAPIVersion asserts that client.Client can
|
|
// negotiate a compatible APIVersion with the server
|
|
func TestNegotiateAPIVersion(t *testing.T) {
|
|
tests := []struct {
|
|
doc string
|
|
clientVersion string
|
|
pingVersion string
|
|
expectedVersion string
|
|
}{
|
|
{
|
|
// client should downgrade to the version reported by the daemon.
|
|
doc: "downgrade from default",
|
|
pingVersion: "1.21",
|
|
expectedVersion: "1.21",
|
|
},
|
|
{
|
|
// client should not downgrade to the version reported by the
|
|
// daemon if a custom version was set.
|
|
doc: "no downgrade from custom version",
|
|
clientVersion: "1.25",
|
|
pingVersion: "1.21",
|
|
expectedVersion: "1.25",
|
|
},
|
|
{
|
|
// client should downgrade to the last version before version
|
|
// negotiation was added (1.24) if the daemon does not report
|
|
// a version.
|
|
doc: "downgrade legacy",
|
|
pingVersion: "",
|
|
expectedVersion: "1.24",
|
|
},
|
|
{
|
|
// client should downgrade to the version reported by the daemon.
|
|
// version negotiation was added in API 1.25, so this is theoretical,
|
|
// but it should negotiate to versions before that if the daemon
|
|
// gives that as a response.
|
|
doc: "downgrade old",
|
|
pingVersion: "1.19",
|
|
expectedVersion: "1.19",
|
|
},
|
|
{
|
|
// client should not upgrade to a newer version if a version was set,
|
|
// even if both the daemon and the client support it.
|
|
doc: "no upgrade",
|
|
clientVersion: "1.20",
|
|
pingVersion: "1.21",
|
|
expectedVersion: "1.20",
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
tc := tc
|
|
t.Run(tc.doc, func(t *testing.T) {
|
|
opts := make([]Opt, 0)
|
|
if tc.clientVersion != "" {
|
|
// Note that this check is redundant, as WithVersion() considers
|
|
// an empty version equivalent to "not setting a version", but
|
|
// doing this just to be explicit we are using the default.
|
|
opts = append(opts, WithVersion(tc.clientVersion))
|
|
}
|
|
client, err := NewClientWithOpts(opts...)
|
|
assert.NilError(t, err)
|
|
client.NegotiateAPIVersionPing(types.Ping{APIVersion: tc.pingVersion})
|
|
assert.Equal(t, tc.expectedVersion, client.ClientVersion())
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestNegotiateAPIVersionOverride asserts that we honor the DOCKER_API_VERSION
|
|
// environment variable when negotiating versions.
|
|
func TestNegotiateAPVersionOverride(t *testing.T) {
|
|
const expected = "9.99"
|
|
defer env.PatchAll(t, map[string]string{"DOCKER_API_VERSION": expected})()
|
|
|
|
client, err := NewClientWithOpts(FromEnv)
|
|
assert.NilError(t, err)
|
|
|
|
// test that we honored the env var
|
|
client.NegotiateAPIVersionPing(types.Ping{APIVersion: "1.24"})
|
|
assert.Equal(t, client.ClientVersion(), expected)
|
|
}
|
|
|
|
func TestNegotiateAPIVersionAutomatic(t *testing.T) {
|
|
var pingVersion string
|
|
httpClient := newMockClient(func(req *http.Request) (*http.Response, error) {
|
|
resp := &http.Response{StatusCode: http.StatusOK, Header: http.Header{}}
|
|
resp.Header.Set("API-Version", pingVersion)
|
|
resp.Body = io.NopCloser(strings.NewReader("OK"))
|
|
return resp, nil
|
|
})
|
|
|
|
ctx := context.Background()
|
|
client, err := NewClientWithOpts(
|
|
WithHTTPClient(httpClient),
|
|
WithAPIVersionNegotiation(),
|
|
)
|
|
assert.NilError(t, err)
|
|
|
|
// Client defaults to use api.DefaultVersion before version-negotiation.
|
|
expected := api.DefaultVersion
|
|
assert.Equal(t, client.ClientVersion(), expected)
|
|
|
|
// First request should trigger negotiation
|
|
pingVersion = "1.35"
|
|
expected = "1.35"
|
|
_, _ = client.Info(ctx)
|
|
assert.Equal(t, client.ClientVersion(), expected)
|
|
|
|
// Once successfully negotiated, subsequent requests should not re-negotiate
|
|
pingVersion = "1.25"
|
|
expected = "1.35"
|
|
_, _ = client.Info(ctx)
|
|
assert.Equal(t, client.ClientVersion(), expected)
|
|
}
|
|
|
|
// TestNegotiateAPIVersionWithEmptyVersion asserts that initializing a client
|
|
// with an empty version string does still allow API-version negotiation
|
|
func TestNegotiateAPIVersionWithEmptyVersion(t *testing.T) {
|
|
client, err := NewClientWithOpts(WithVersion(""))
|
|
assert.NilError(t, err)
|
|
|
|
const expected = "1.35"
|
|
client.NegotiateAPIVersionPing(types.Ping{APIVersion: expected})
|
|
assert.Equal(t, client.ClientVersion(), expected)
|
|
}
|
|
|
|
// TestNegotiateAPIVersionWithFixedVersion asserts that initializing a client
|
|
// with a fixed version disables API-version negotiation
|
|
func TestNegotiateAPIVersionWithFixedVersion(t *testing.T) {
|
|
const customVersion = "1.35"
|
|
client, err := NewClientWithOpts(WithVersion(customVersion))
|
|
assert.NilError(t, err)
|
|
|
|
client.NegotiateAPIVersionPing(types.Ping{APIVersion: "1.31"})
|
|
assert.Equal(t, client.ClientVersion(), customVersion)
|
|
}
|
|
|
|
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 *url.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 {
|
|
tc := tc
|
|
t.Run(tc.httpMethod, func(t *testing.T) {
|
|
req, err := http.NewRequest(tc.httpMethod, "/redirectme", nil)
|
|
assert.Check(t, err)
|
|
resp, err := client.Do(req)
|
|
assert.Check(t, is.Equal(resp.StatusCode, tc.statusCode))
|
|
if tc.expectedErr == nil {
|
|
assert.NilError(t, err)
|
|
} else {
|
|
urlError, ok := err.(*url.Error)
|
|
assert.Assert(t, ok, "%T is not *url.Error", err)
|
|
assert.Check(t, is.Equal(*urlError, *tc.expectedErr))
|
|
}
|
|
})
|
|
}
|
|
}
|