0ba14fde41
cli/registry/client/endpoint.go:128:34: fmt.Sprintf can be replaced with string concatenation (perfsprint)
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", th.token))
^
cli/command/telemetry_docker.go:88:14: fmt.Sprintf can be replaced with string concatenation (perfsprint)
endpoint = fmt.Sprintf("unix://%s", path.Join(u.Host, u.Path))
^
cli/command/cli_test.go:195:47: fmt.Sprintf can be replaced with string concatenation (perfsprint)
opts := &flags.ClientOptions{Hosts: []string{fmt.Sprintf("unix://%s", socket)}}
^
cli/command/registry_test.go:59:24: fmt.Sprintf can be replaced with string concatenation (perfsprint)
inputServerAddress: fmt.Sprintf("https://%s", testAuthConfigs[1].ServerAddress),
^
cli/command/container/opts_test.go:338:35: fmt.Sprintf can be replaced with string concatenation (perfsprint)
if config, _, _ := mustParse(t, fmt.Sprintf("--hostname=%s", hostname)); config.Hostname != expectedHostname {
^
cli/command/context/options.go:79:24: fmt.Sprintf can be replaced with string concatenation (perfsprint)
errs = append(errs, fmt.Sprintf("%s: unrecognized config key", k))
^
cli/command/image/build.go:461:68: fmt.Sprintf can be replaced with string concatenation (perfsprint)
line = dockerfileFromLinePattern.ReplaceAllLiteralString(line, fmt.Sprintf("FROM %s", reference.FamiliarString(trustedRef)))
^
cli/command/image/remove_test.go:21:9: fmt.Sprintf can be replaced with string concatenation (perfsprint)
return fmt.Sprintf("Error: No such image: %s", n.imageID)
^
cli/command/image/build/context.go:229:102: fmt.Sprintf can be replaced with string concatenation (perfsprint)
progReader := progress.NewProgressReader(response.Body, progressOutput, response.ContentLength, "", fmt.Sprintf("Downloading build context from remote url: %s", remoteURL))
^
cli/command/service/logs.go:215:16: fmt.Sprintf can be replaced with string concatenation (perfsprint)
taskName += fmt.Sprintf(".%s", task.ID)
^
cli/command/service/logs.go:217:16: fmt.Sprintf can be replaced with string concatenation (perfsprint)
taskName += fmt.Sprintf(".%s", stringid.TruncateID(task.ID))
^
cli/command/service/progress/progress_test.go:877:18: fmt.Sprintf can be replaced with string concatenation (perfsprint)
ID: fmt.Sprintf("task%s", nodeID),
^
cli/command/stack/swarm/remove.go:61:24: fmt.Sprintf can be replaced with string concatenation (perfsprint)
errs = append(errs, fmt.Sprintf("Failed to remove some resources from stack: %s", namespace))
^
cli/command/swarm/ipnet_slice_test.go:32:9: fmt.Sprintf can be replaced with string concatenation (perfsprint)
arg := fmt.Sprintf("--cidrs=%s", strings.Join(vals, ","))
^
cli/command/swarm/ipnet_slice_test.go:137:30: fmt.Sprintf can be replaced with string concatenation (perfsprint)
if err := f.Parse([]string{fmt.Sprintf("--cidrs=%s", strings.Join(test.FlagArg, ","))}); err != nil {
^
cli/compose/schema/schema.go:105:11: fmt.Sprintf can be replaced with string concatenation (perfsprint)
return fmt.Sprintf("must be a %s", humanReadableType(expectedType))
^
cli/manifest/store/store.go:165:9: fmt.Sprintf can be replaced with string concatenation (perfsprint)
return fmt.Sprintf("No such manifest: %s", n.object)
^
e2e/image/push_test.go:340:4: fmt.Sprintf can be replaced with string concatenation (perfsprint)
fmt.Sprintf("NOTARY_ROOT_PASSPHRASE=%s", pwd),
^
e2e/image/push_test.go:341:4: fmt.Sprintf can be replaced with string concatenation (perfsprint)
fmt.Sprintf("NOTARY_TARGETS_PASSPHRASE=%s", pwd),
^
e2e/image/push_test.go:342:4: fmt.Sprintf can be replaced with string concatenation (perfsprint)
fmt.Sprintf("NOTARY_SNAPSHOT_PASSPHRASE=%s", pwd),
^
e2e/image/push_test.go:343:4: fmt.Sprintf can be replaced with string concatenation (perfsprint)
fmt.Sprintf("NOTARY_DELEGATION_PASSPHRASE=%s", pwd),
^
e2e/plugin/trust_test.go:23:16: fmt.Sprintf can be replaced with string concatenation (perfsprint)
pluginName := fmt.Sprintf("%s/plugin-content-trust", registryPrefix)
^
e2e/plugin/trust_test.go:53:8: fmt.Sprintf can be replaced with string concatenation (perfsprint)
Out: fmt.Sprintf("Installed plugin %s", pluginName),
^
e2e/trust/revoke_test.go:62:57: fmt.Sprintf can be replaced with string concatenation (perfsprint)
icmd.RunCommand("docker", "tag", fixtures.AlpineImage, fmt.Sprintf("%s:v1", revokeRepo)).Assert(t, icmd.Success)
^
e2e/trust/revoke_test.go:64:49: fmt.Sprintf can be replaced with string concatenation (perfsprint)
icmd.Command("docker", "-D", "trust", "sign", fmt.Sprintf("%s:v1", revokeRepo)),
^
e2e/trust/revoke_test.go:68:58: fmt.Sprintf can be replaced with string concatenation (perfsprint)
icmd.RunCommand("docker", "tag", fixtures.BusyboxImage, fmt.Sprintf("%s:v2", revokeRepo)).Assert(t, icmd.Success)
^
e2e/trust/revoke_test.go:70:49: fmt.Sprintf can be replaced with string concatenation (perfsprint)
icmd.Command("docker", "-D", "trust", "sign", fmt.Sprintf("%s:v2", revokeRepo)),
^
e2e/trust/sign_test.go:36:47: fmt.Sprintf can be replaced with string concatenation (perfsprint)
assert.Check(t, is.Contains(result.Stdout(), fmt.Sprintf("v1: digest: sha256:%s", fixtures.AlpineSha)))
^
e2e/trust/sign_test.go:53:47: fmt.Sprintf can be replaced with string concatenation (perfsprint)
assert.Check(t, is.Contains(result.Stdout(), fmt.Sprintf("v1: digest: sha256:%s", fixtures.BusyboxSha)))
^
e2e/trust/sign_test.go:65:47: fmt.Sprintf can be replaced with string concatenation (perfsprint)
assert.Check(t, is.Contains(result.Stdout(), fmt.Sprintf("v1: digest: sha256:%s", fixtures.AlpineSha)))
^
opts/file.go:21:9: fmt.Sprintf can be replaced with string concatenation (perfsprint)
return fmt.Sprintf("poorly formatted environment: %s", e.msg)
^
opts/hosts_test.go:26:31: fmt.Sprintf can be replaced with string concatenation (perfsprint)
"tcp://host:": fmt.Sprintf("tcp://host:%s", defaultHTTPPort),
^
Signed-off-by: Sebastiaan van Stijn <github@gone.nl>
300 lines
11 KiB
Go
300 lines
11 KiB
Go
package opts
|
|
|
|
import (
|
|
"fmt"
|
|
"testing"
|
|
|
|
"gotest.tools/v3/assert"
|
|
is "gotest.tools/v3/assert/cmp"
|
|
)
|
|
|
|
func TestParseHost(t *testing.T) {
|
|
invalid := []string{
|
|
"something with spaces",
|
|
"://",
|
|
"unknown://",
|
|
"tcp://:port",
|
|
"tcp://invalid:port",
|
|
}
|
|
|
|
valid := map[string]string{
|
|
"": defaultHost,
|
|
" ": defaultHost,
|
|
" ": defaultHost,
|
|
"fd://": "fd://",
|
|
"fd://something": "fd://something",
|
|
"tcp://host:": "tcp://host:" + defaultHTTPPort,
|
|
"tcp://": defaultTCPHost,
|
|
"tcp://:2375": fmt.Sprintf("tcp://%s:%s", defaultHTTPHost, defaultHTTPPort),
|
|
"tcp://:2376": fmt.Sprintf("tcp://%s:%s", defaultHTTPHost, defaultTLSHTTPPort),
|
|
"tcp://0.0.0.0:8080": "tcp://0.0.0.0:8080",
|
|
"tcp://192.168.0.0:12000": "tcp://192.168.0.0:12000",
|
|
"tcp://192.168:8080": "tcp://192.168:8080",
|
|
"tcp://0.0.0.0:1234567890": "tcp://0.0.0.0:1234567890", // yeah it's valid :P
|
|
" tcp://:7777/path ": fmt.Sprintf("tcp://%s:7777/path", defaultHTTPHost),
|
|
"tcp://docker.com:2375": "tcp://docker.com:2375",
|
|
"unix://": "unix://" + defaultUnixSocket,
|
|
"unix://path/to/socket": "unix://path/to/socket",
|
|
"npipe://": "npipe://" + defaultNamedPipe,
|
|
"npipe:////./pipe/foo": "npipe:////./pipe/foo",
|
|
}
|
|
|
|
for _, value := range invalid {
|
|
if _, err := ParseHost(false, value); err == nil {
|
|
t.Errorf("Expected an error for %v, got [nil]", value)
|
|
}
|
|
}
|
|
|
|
for value, expected := range valid {
|
|
if actual, err := ParseHost(false, value); err != nil || actual != expected {
|
|
t.Errorf("Expected for %v [%v], got [%v, %v]", value, expected, actual, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestParseDockerDaemonHost(t *testing.T) {
|
|
invalids := map[string]string{
|
|
"tcp:a.b.c.d": "",
|
|
"tcp:a.b.c.d/path": "",
|
|
"udp://127.0.0.1": "invalid bind address format: udp://127.0.0.1",
|
|
"udp://127.0.0.1:2375": "invalid bind address format: udp://127.0.0.1:2375",
|
|
"tcp://unix:///run/docker.sock": "invalid proto, expected tcp: unix:///run/docker.sock",
|
|
" tcp://:7777/path ": "invalid bind address format: tcp://:7777/path ", //nolint:gocritic // ignore mapKey: suspucious whitespace
|
|
"": "invalid bind address format: ",
|
|
}
|
|
valids := map[string]string{
|
|
"0.0.0.1:": "tcp://0.0.0.1:2375",
|
|
"0.0.0.1:5555": "tcp://0.0.0.1:5555",
|
|
"0.0.0.1:5555/path": "tcp://0.0.0.1:5555/path",
|
|
"[::1]:": "tcp://[::1]:2375",
|
|
"[::1]:5555/path": "tcp://[::1]:5555/path",
|
|
"[0:0:0:0:0:0:0:1]:": "tcp://[0:0:0:0:0:0:0:1]:2375",
|
|
"[0:0:0:0:0:0:0:1]:5555/path": "tcp://[0:0:0:0:0:0:0:1]:5555/path",
|
|
":6666": fmt.Sprintf("tcp://%s:6666", defaultHTTPHost),
|
|
":6666/path": fmt.Sprintf("tcp://%s:6666/path", defaultHTTPHost),
|
|
"tcp://": defaultTCPHost,
|
|
"tcp://:7777": fmt.Sprintf("tcp://%s:7777", defaultHTTPHost),
|
|
"tcp://:7777/path": fmt.Sprintf("tcp://%s:7777/path", defaultHTTPHost),
|
|
"unix:///run/docker.sock": "unix:///run/docker.sock",
|
|
"unix://": "unix://" + defaultUnixSocket,
|
|
"fd://": "fd://",
|
|
"fd://something": "fd://something",
|
|
"localhost:": "tcp://localhost:2375",
|
|
"localhost:5555": "tcp://localhost:5555",
|
|
"localhost:5555/path": "tcp://localhost:5555/path",
|
|
}
|
|
for invalidAddr, expectedError := range invalids {
|
|
if addr, err := parseDockerDaemonHost(invalidAddr); err == nil || expectedError != "" && err.Error() != expectedError {
|
|
t.Errorf("tcp %v address expected error %q return, got %q and addr %v", invalidAddr, expectedError, err, addr)
|
|
}
|
|
}
|
|
for validAddr, expectedAddr := range valids {
|
|
if addr, err := parseDockerDaemonHost(validAddr); err != nil || addr != expectedAddr {
|
|
t.Errorf("%v -> expected %v, got (%v) addr (%v)", validAddr, expectedAddr, err, addr)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestParseTCP(t *testing.T) {
|
|
defaultHTTPHost := "tcp://127.0.0.1:2376"
|
|
invalids := map[string]string{
|
|
"tcp:a.b.c.d": "",
|
|
"tcp:a.b.c.d/path": "",
|
|
"udp://127.0.0.1": "invalid proto, expected tcp: udp://127.0.0.1",
|
|
"udp://127.0.0.1:2375": "invalid proto, expected tcp: udp://127.0.0.1:2375",
|
|
}
|
|
valids := map[string]string{
|
|
"": defaultHTTPHost,
|
|
"tcp://": defaultHTTPHost,
|
|
"0.0.0.1:": "tcp://0.0.0.1:2376",
|
|
"0.0.0.1:5555": "tcp://0.0.0.1:5555",
|
|
"0.0.0.1:5555/path": "tcp://0.0.0.1:5555/path",
|
|
":6666": "tcp://127.0.0.1:6666",
|
|
":6666/path": "tcp://127.0.0.1:6666/path",
|
|
"tcp://:7777": "tcp://127.0.0.1:7777",
|
|
"tcp://:7777/path": "tcp://127.0.0.1:7777/path",
|
|
"[::1]:": "tcp://[::1]:2376",
|
|
"[::1]:5555": "tcp://[::1]:5555",
|
|
"[::1]:5555/path": "tcp://[::1]:5555/path",
|
|
"[0:0:0:0:0:0:0:1]:": "tcp://[0:0:0:0:0:0:0:1]:2376",
|
|
"[0:0:0:0:0:0:0:1]:5555": "tcp://[0:0:0:0:0:0:0:1]:5555",
|
|
"[0:0:0:0:0:0:0:1]:5555/path": "tcp://[0:0:0:0:0:0:0:1]:5555/path",
|
|
"localhost:": "tcp://localhost:2376",
|
|
"localhost:5555": "tcp://localhost:5555",
|
|
"localhost:5555/path": "tcp://localhost:5555/path",
|
|
}
|
|
for invalidAddr, expectedError := range invalids {
|
|
if addr, err := ParseTCPAddr(invalidAddr, defaultHTTPHost); err == nil || expectedError != "" && err.Error() != expectedError {
|
|
t.Errorf("tcp %v address expected error %v return, got %s and addr %v", invalidAddr, expectedError, err, addr)
|
|
}
|
|
}
|
|
for validAddr, expectedAddr := range valids {
|
|
if addr, err := ParseTCPAddr(validAddr, defaultHTTPHost); err != nil || addr != expectedAddr {
|
|
t.Errorf("%v -> expected %v, got %v and addr %v", validAddr, expectedAddr, err, addr)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestParseInvalidUnixAddrInvalid(t *testing.T) {
|
|
if _, err := parseSimpleProtoAddr("unix", "tcp://127.0.0.1", "unix:///var/run/docker.sock"); err == nil || err.Error() != "invalid proto, expected unix: tcp://127.0.0.1" {
|
|
t.Fatalf("Expected an error, got %v", err)
|
|
}
|
|
if _, err := parseSimpleProtoAddr("unix", "unix://tcp://127.0.0.1", "/var/run/docker.sock"); err == nil || err.Error() != "invalid proto, expected unix: tcp://127.0.0.1" {
|
|
t.Fatalf("Expected an error, got %v", err)
|
|
}
|
|
if v, err := parseSimpleProtoAddr("unix", "", "/var/run/docker.sock"); err != nil || v != "unix:///var/run/docker.sock" {
|
|
t.Fatalf("Expected an %v, got %v", v, "unix:///var/run/docker.sock")
|
|
}
|
|
}
|
|
|
|
func TestValidateExtraHosts(t *testing.T) {
|
|
tests := []struct {
|
|
doc string
|
|
input string
|
|
expectedOut string // Expect output==input if not set.
|
|
expectedErr string // Expect success if not set.
|
|
}{
|
|
{
|
|
doc: "IPv4, colon sep",
|
|
input: `myhost:192.168.0.1`,
|
|
},
|
|
{
|
|
doc: "IPv4, eq sep",
|
|
input: `myhost=192.168.0.1`,
|
|
expectedOut: `myhost:192.168.0.1`,
|
|
},
|
|
{
|
|
doc: "Weird but permitted, IPv4 with brackets",
|
|
input: `myhost=[192.168.0.1]`,
|
|
expectedOut: `myhost:192.168.0.1`,
|
|
},
|
|
{
|
|
doc: "Host and domain",
|
|
input: `host.and.domain.invalid:10.0.2.1`,
|
|
},
|
|
{
|
|
doc: "IPv6, colon sep",
|
|
input: `anipv6host:2003:ab34:e::1`,
|
|
},
|
|
{
|
|
doc: "IPv6, colon sep, brackets",
|
|
input: `anipv6host:[2003:ab34:e::1]`,
|
|
expectedOut: `anipv6host:2003:ab34:e::1`,
|
|
},
|
|
{
|
|
doc: "IPv6, eq sep, brackets",
|
|
input: `anipv6host=[2003:ab34:e::1]`,
|
|
expectedOut: `anipv6host:2003:ab34:e::1`,
|
|
},
|
|
{
|
|
doc: "IPv6 localhost, colon sep",
|
|
input: `ipv6local:::1`,
|
|
},
|
|
{
|
|
doc: "IPv6 localhost, eq sep",
|
|
input: `ipv6local=::1`,
|
|
expectedOut: `ipv6local:::1`,
|
|
},
|
|
{
|
|
doc: "IPv6 localhost, eq sep, brackets",
|
|
input: `ipv6local=[::1]`,
|
|
expectedOut: `ipv6local:::1`,
|
|
},
|
|
{
|
|
doc: "IPv6 localhost, non-canonical, colon sep",
|
|
input: `ipv6local:0:0:0:0:0:0:0:1`,
|
|
},
|
|
{
|
|
doc: "IPv6 localhost, non-canonical, eq sep",
|
|
input: `ipv6local=0:0:0:0:0:0:0:1`,
|
|
expectedOut: `ipv6local:0:0:0:0:0:0:0:1`,
|
|
},
|
|
{
|
|
doc: "IPv6 localhost, non-canonical, eq sep, brackets",
|
|
input: `ipv6local=[0:0:0:0:0:0:0:1]`,
|
|
expectedOut: `ipv6local:0:0:0:0:0:0:0:1`,
|
|
},
|
|
{
|
|
doc: "host-gateway special case, colon sep",
|
|
input: `host.docker.internal:host-gateway`,
|
|
},
|
|
{
|
|
doc: "host-gateway special case, eq sep",
|
|
input: `host.docker.internal=host-gateway`,
|
|
expectedOut: `host.docker.internal:host-gateway`,
|
|
},
|
|
{
|
|
doc: "Bad address, colon sep",
|
|
input: `myhost:192.notanipaddress.1`,
|
|
expectedErr: `invalid IP address in add-host: "192.notanipaddress.1"`,
|
|
},
|
|
{
|
|
doc: "Bad address, eq sep",
|
|
input: `myhost=192.notanipaddress.1`,
|
|
expectedErr: `invalid IP address in add-host: "192.notanipaddress.1"`,
|
|
},
|
|
{
|
|
doc: "No sep",
|
|
input: `thathost-nosemicolon10.0.0.1`,
|
|
expectedErr: `bad format for add-host: "thathost-nosemicolon10.0.0.1"`,
|
|
},
|
|
{
|
|
doc: "Bad IPv6",
|
|
input: `anipv6host:::::1`,
|
|
expectedErr: `invalid IP address in add-host: "::::1"`,
|
|
},
|
|
{
|
|
doc: "Bad IPv6, trailing colons",
|
|
input: `ipv6local:::0::`,
|
|
expectedErr: `invalid IP address in add-host: "::0::"`,
|
|
},
|
|
{
|
|
doc: "Bad IPv6, missing close bracket",
|
|
input: `ipv6addr=[::1`,
|
|
expectedErr: `invalid IP address in add-host: "[::1"`,
|
|
},
|
|
{
|
|
doc: "Bad IPv6, missing open bracket",
|
|
input: `ipv6addr=::1]`,
|
|
expectedErr: `invalid IP address in add-host: "::1]"`,
|
|
},
|
|
{
|
|
doc: "Missing address, colon sep",
|
|
input: `myhost.invalid:`,
|
|
expectedErr: `invalid IP address in add-host: ""`,
|
|
},
|
|
{
|
|
doc: "Missing address, eq sep",
|
|
input: `myhost.invalid=`,
|
|
expectedErr: `invalid IP address in add-host: ""`,
|
|
},
|
|
{
|
|
doc: "IPv6 localhost, bad name",
|
|
input: `:=::1`,
|
|
expectedErr: `bad format for add-host: ":=::1"`,
|
|
},
|
|
{
|
|
doc: "No input",
|
|
input: ``,
|
|
expectedErr: `bad format for add-host: ""`,
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
tc := tc
|
|
if tc.expectedOut == "" {
|
|
tc.expectedOut = tc.input
|
|
}
|
|
t.Run(tc.input, func(t *testing.T) {
|
|
actualOut, actualErr := ValidateExtraHost(tc.input)
|
|
if tc.expectedErr == "" {
|
|
assert.Check(t, is.Equal(tc.expectedOut, actualOut))
|
|
assert.NilError(t, actualErr)
|
|
} else {
|
|
assert.Check(t, actualOut == "")
|
|
assert.Check(t, is.Error(actualErr, tc.expectedErr))
|
|
}
|
|
})
|
|
}
|
|
}
|