Sebastiaan van Stijn
416c061000
internal/test/cli.go:175:14: fmt.Errorf can be replaced with errors.New (perfsprint)
return nil, fmt.Errorf("no notary client available unless defined")
^
cli/command/cli.go:318:29: fmt.Errorf can be replaced with errors.New (perfsprint)
return docker.Endpoint{}, fmt.Errorf("no context store initialized")
^
cli/command/container/attach.go:161:11: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf(result.Error.Message)
^
cli/command/container/opts.go:577:16: fmt.Errorf can be replaced with errors.New (perfsprint)
return nil, fmt.Errorf("--health-start-period cannot be negative")
^
cli/command/container/opts.go:580:16: fmt.Errorf can be replaced with errors.New (perfsprint)
return nil, fmt.Errorf("--health-start-interval cannot be negative")
^
cli/command/container/stats.go:221:11: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("filtering is not supported when specifying a list of containers")
^
cli/command/container/attach_test.go:82:17: fmt.Errorf can be replaced with errors.New (perfsprint)
expectedErr = fmt.Errorf("unexpected error")
^
cli/command/container/create_test.go:234:40: fmt.Errorf can be replaced with errors.New (perfsprint)
return container.CreateResponse{}, fmt.Errorf("shouldn't try to pull image")
^
cli/command/container/list_test.go:150:17: fmt.Errorf can be replaced with errors.New (perfsprint)
return nil, fmt.Errorf("error listing containers")
^
cli/command/container/rm_test.go:40:31: fmt.Errorf can be replaced with errors.New (perfsprint)
return errdefs.NotFound(fmt.Errorf("Error: no such container: " + container))
^
cli/command/container/run_test.go:138:40: fmt.Errorf can be replaced with errors.New (perfsprint)
return container.CreateResponse{}, fmt.Errorf("shouldn't try to pull image")
^
cli/command/image/pull_test.go:115:49: fmt.Errorf can be replaced with errors.New (perfsprint)
return io.NopCloser(strings.NewReader("")), fmt.Errorf("shouldn't try to pull image")
^
cli/command/network/connect.go:88:16: fmt.Errorf can be replaced with errors.New (perfsprint)
return nil, fmt.Errorf("invalid key/value pair format in driver options")
^
cli/command/plugin/create_test.go:96:11: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("Error creating plugin")
^
cli/command/plugin/disable_test.go:32:12: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("Error disabling plugin")
^
cli/command/plugin/enable_test.go:32:12: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("failed to enable plugin")
^
cli/command/plugin/inspect_test.go:55:22: fmt.Errorf can be replaced with errors.New (perfsprint)
return nil, nil, fmt.Errorf("error inspecting plugin")
^
cli/command/plugin/install_test.go:43:17: fmt.Errorf can be replaced with errors.New (perfsprint)
return nil, fmt.Errorf("Error installing plugin")
^
cli/command/plugin/install_test.go:51:17: fmt.Errorf can be replaced with errors.New (perfsprint)
return nil, fmt.Errorf("(image) when fetching")
^
cli/command/plugin/install_test.go:95:17: fmt.Errorf can be replaced with errors.New (perfsprint)
return nil, fmt.Errorf("should not try to install plugin")
^
cli/command/plugin/list_test.go:35:41: fmt.Errorf can be replaced with errors.New (perfsprint)
return types.PluginsListResponse{}, fmt.Errorf("error listing plugins")
^
cli/command/plugin/remove_test.go:27:12: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("Error removing plugin")
^
cli/command/registry/login_test.go:36:46: fmt.Errorf can be replaced with errors.New (perfsprint)
return registrytypes.AuthenticateOKBody{}, fmt.Errorf("Invalid Username or Password")
^
cli/command/registry/login_test.go:44:46: fmt.Errorf can be replaced with errors.New (perfsprint)
return registrytypes.AuthenticateOKBody{}, fmt.Errorf(errUnknownUser)
^
cli/command/system/info.go:190:10: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("errors pretty printing info")
^
cli/command/system/prune.go:77:10: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf(`ERROR: The "until" filter is not supported with "--volumes"`)
^
cli/command/system/version_test.go:19:28: fmt.Errorf can be replaced with errors.New (perfsprint)
return types.Version{}, fmt.Errorf("no server")
^
cli/command/trust/key_load.go:112:22: fmt.Errorf can be replaced with errors.New (perfsprint)
return []byte{}, fmt.Errorf("could not decrypt key")
^
cli/command/trust/revoke.go:44:10: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("cannot use a digest reference for IMAGE:TAG")
^
cli/command/trust/revoke.go:105:10: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("no signed tags to remove")
^
cli/command/trust/signer_add.go:56:10: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("releases is a reserved keyword, please use a different signer name")
^
cli/command/trust/signer_add.go:60:10: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("path to a public key must be provided using the `--key` flag")
^
opts/config.go:71:10: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("source is required")
^
opts/mount.go:168:10: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("type is required")
^
opts/mount.go:172:10: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("target is required")
^
opts/network.go:90:11: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("network name/id is not specified")
^
opts/network.go:129:18: fmt.Errorf can be replaced with errors.New (perfsprint)
return "", "", fmt.Errorf("invalid key value pair format in driver options")
^
opts/opts.go:404:13: fmt.Errorf can be replaced with errors.New (perfsprint)
return 0, fmt.Errorf("value is too precise")
^
opts/opts.go:412:18: fmt.Errorf can be replaced with errors.New (perfsprint)
return "", "", fmt.Errorf("empty string specified for links")
^
opts/parse.go:84:37: fmt.Errorf can be replaced with errors.New (perfsprint)
return container.RestartPolicy{}, fmt.Errorf("invalid restart policy format: no policy provided before colon")
^
opts/parse.go:89:38: fmt.Errorf can be replaced with errors.New (perfsprint)
return container.RestartPolicy{}, fmt.Errorf("invalid restart policy format: maximum retry count must be an integer")
^
opts/port.go:105:13: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("hostip is not supported")
^
opts/secret.go:70:10: fmt.Errorf can be replaced with errors.New (perfsprint)
return fmt.Errorf("source is required")
^
opts/env_test.go:57:11: fmt.Errorf can be replaced with errors.New (perfsprint)
err: fmt.Errorf("invalid environment variable: =a"),
^
opts/env_test.go:93:11: fmt.Errorf can be replaced with errors.New (perfsprint)
err: fmt.Errorf("invalid environment variable: ="),
^
cli-plugins/manager/error_test.go:16:11: fmt.Errorf can be replaced with errors.New (perfsprint)
inner := fmt.Errorf("testing")
^
Signed-off-by: Sebastiaan van Stijn <github@gone.nl>
(cherry picked from commit dfec976e84)
Signed-off-by: Cory Snider <csnider@mirantis.com>
186 lines
4.9 KiB
Go
186 lines
4.9 KiB
Go
package registry
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"testing"
|
|
|
|
configtypes "github.com/docker/cli/cli/config/types"
|
|
"github.com/docker/cli/internal/test"
|
|
"github.com/docker/docker/api/types"
|
|
registrytypes "github.com/docker/docker/api/types/registry"
|
|
"github.com/docker/docker/client"
|
|
"gotest.tools/v3/assert"
|
|
is "gotest.tools/v3/assert/cmp"
|
|
"gotest.tools/v3/fs"
|
|
)
|
|
|
|
const (
|
|
userErr = "userunknownError"
|
|
testAuthErrMsg = "UNKNOWN_ERR"
|
|
)
|
|
|
|
var testAuthErrors = map[string]error{
|
|
userErr: fmt.Errorf(testAuthErrMsg),
|
|
}
|
|
|
|
var (
|
|
expiredPassword = "I_M_EXPIRED"
|
|
useToken = "I_M_TOKEN"
|
|
)
|
|
|
|
type fakeClient struct {
|
|
client.Client
|
|
}
|
|
|
|
func (c fakeClient) Info(context.Context) (types.Info, error) {
|
|
return types.Info{}, nil
|
|
}
|
|
|
|
func (c fakeClient) RegistryLogin(_ context.Context, auth types.AuthConfig) (registrytypes.AuthenticateOKBody, error) {
|
|
if auth.Password == expiredPassword {
|
|
return registrytypes.AuthenticateOKBody{}, errors.New("Invalid Username or Password")
|
|
}
|
|
if auth.Password == useToken {
|
|
return registrytypes.AuthenticateOKBody{
|
|
IdentityToken: auth.Password,
|
|
}, nil
|
|
}
|
|
err := testAuthErrors[auth.Username]
|
|
return registrytypes.AuthenticateOKBody{}, err
|
|
}
|
|
|
|
func TestLoginWithCredStoreCreds(t *testing.T) {
|
|
testCases := []struct {
|
|
inputAuthConfig types.AuthConfig
|
|
expectedMsg string
|
|
expectedErr string
|
|
}{
|
|
{
|
|
inputAuthConfig: types.AuthConfig{},
|
|
expectedMsg: "Authenticating with existing credentials...\n",
|
|
},
|
|
{
|
|
inputAuthConfig: types.AuthConfig{
|
|
Username: userErr,
|
|
},
|
|
expectedMsg: "Authenticating with existing credentials...\n",
|
|
expectedErr: fmt.Sprintf("Login did not succeed, error: %s\n", testAuthErrMsg),
|
|
},
|
|
}
|
|
ctx := context.Background()
|
|
for _, tc := range testCases {
|
|
cli := test.NewFakeCli(&fakeClient{})
|
|
errBuf := new(bytes.Buffer)
|
|
cli.SetErr(errBuf)
|
|
loginWithCredStoreCreds(ctx, cli, &tc.inputAuthConfig)
|
|
outputString := cli.OutBuffer().String()
|
|
assert.Check(t, is.Equal(tc.expectedMsg, outputString))
|
|
errorString := errBuf.String()
|
|
assert.Check(t, is.Equal(tc.expectedErr, errorString))
|
|
}
|
|
}
|
|
|
|
func TestRunLogin(t *testing.T) {
|
|
const storedServerAddress = "reg1"
|
|
const validUsername = "u1"
|
|
const validPassword = "p1"
|
|
const validPassword2 = "p2"
|
|
|
|
validAuthConfig := configtypes.AuthConfig{
|
|
ServerAddress: storedServerAddress,
|
|
Username: validUsername,
|
|
Password: validPassword,
|
|
}
|
|
expiredAuthConfig := configtypes.AuthConfig{
|
|
ServerAddress: storedServerAddress,
|
|
Username: validUsername,
|
|
Password: expiredPassword,
|
|
}
|
|
validIdentityToken := configtypes.AuthConfig{
|
|
ServerAddress: storedServerAddress,
|
|
Username: validUsername,
|
|
IdentityToken: useToken,
|
|
}
|
|
testCases := []struct {
|
|
inputLoginOption loginOptions
|
|
inputStoredCred *configtypes.AuthConfig
|
|
expectedErr string
|
|
expectedSavedCred configtypes.AuthConfig
|
|
}{
|
|
{
|
|
inputLoginOption: loginOptions{
|
|
serverAddress: storedServerAddress,
|
|
},
|
|
inputStoredCred: &validAuthConfig,
|
|
expectedErr: "",
|
|
expectedSavedCred: validAuthConfig,
|
|
},
|
|
{
|
|
inputLoginOption: loginOptions{
|
|
serverAddress: storedServerAddress,
|
|
},
|
|
inputStoredCred: &expiredAuthConfig,
|
|
expectedErr: "Error: Cannot perform an interactive login from a non TTY device",
|
|
},
|
|
{
|
|
inputLoginOption: loginOptions{
|
|
serverAddress: storedServerAddress,
|
|
user: validUsername,
|
|
password: validPassword2,
|
|
},
|
|
inputStoredCred: &validAuthConfig,
|
|
expectedErr: "",
|
|
expectedSavedCred: configtypes.AuthConfig{
|
|
ServerAddress: storedServerAddress,
|
|
Username: validUsername,
|
|
Password: validPassword2,
|
|
},
|
|
},
|
|
{
|
|
inputLoginOption: loginOptions{
|
|
serverAddress: storedServerAddress,
|
|
user: userErr,
|
|
password: validPassword,
|
|
},
|
|
inputStoredCred: &validAuthConfig,
|
|
expectedErr: testAuthErrMsg,
|
|
},
|
|
{
|
|
inputLoginOption: loginOptions{
|
|
serverAddress: storedServerAddress,
|
|
user: validUsername,
|
|
password: useToken,
|
|
},
|
|
inputStoredCred: &validIdentityToken,
|
|
expectedErr: "",
|
|
expectedSavedCred: validIdentityToken,
|
|
},
|
|
}
|
|
for i, tc := range testCases {
|
|
t.Run(fmt.Sprintf("%d", i), func(t *testing.T) {
|
|
tmpFile := fs.NewFile(t, "test-run-login")
|
|
defer tmpFile.Remove()
|
|
cli := test.NewFakeCli(&fakeClient{})
|
|
configfile := cli.ConfigFile()
|
|
configfile.Filename = tmpFile.Path()
|
|
|
|
if tc.inputStoredCred != nil {
|
|
cred := *tc.inputStoredCred
|
|
assert.NilError(t, configfile.GetCredentialsStore(cred.ServerAddress).Store(cred))
|
|
}
|
|
loginErr := runLogin(cli, tc.inputLoginOption)
|
|
if tc.expectedErr != "" {
|
|
assert.Error(t, loginErr, tc.expectedErr)
|
|
return
|
|
}
|
|
assert.NilError(t, loginErr)
|
|
savedCred, credStoreErr := configfile.GetCredentialsStore(tc.inputStoredCred.ServerAddress).Get(tc.inputStoredCred.ServerAddress)
|
|
assert.Check(t, credStoreErr)
|
|
assert.DeepEqual(t, tc.expectedSavedCred, savedCred)
|
|
})
|
|
}
|
|
}
|