From c64e8df84cec9bc892d372d1eba3df77f85be4e4 Mon Sep 17 00:00:00 2001 From: pasha-codefresh Date: Thu, 9 Sep 2021 18:58:46 +0300 Subject: [PATCH] feat: ability to switch user during test execution (#7164) feat: ability to switch user during test execution (#7164) Signed-off-by: pashavictorovich --- test/e2e/accounts_test.go | 23 +++++++++ test/e2e/fixture/account/actions.go | 49 +++++++++++++++++++ test/e2e/fixture/account/consequences.go | 60 +++++++++++++++++++++++ test/e2e/fixture/account/context.go | 45 +++++++++++++++++ test/e2e/fixture/fixture.go | 62 +++++++++++++++--------- 5 files changed, 216 insertions(+), 23 deletions(-) create mode 100644 test/e2e/fixture/account/actions.go create mode 100644 test/e2e/fixture/account/consequences.go create mode 100644 test/e2e/fixture/account/context.go diff --git a/test/e2e/accounts_test.go b/test/e2e/accounts_test.go index af623763d377e..b5f9a4160555a 100644 --- a/test/e2e/accounts_test.go +++ b/test/e2e/accounts_test.go @@ -4,6 +4,8 @@ import ( "context" "testing" + "github.com/argoproj/argo-cd/v2/pkg/apiclient/account" + "github.com/argoproj/pkg/errors" "github.com/stretchr/testify/assert" "google.golang.org/grpc/codes" @@ -12,10 +14,31 @@ import ( argocdclient "github.com/argoproj/argo-cd/v2/pkg/apiclient" "github.com/argoproj/argo-cd/v2/pkg/apiclient/session" . "github.com/argoproj/argo-cd/v2/test/e2e/fixture" + accountFixture "github.com/argoproj/argo-cd/v2/test/e2e/fixture/account" "github.com/argoproj/argo-cd/v2/util/io" ) func TestCreateAndUseAccount(t *testing.T) { + ctx := accountFixture.Given(t) + ctx. + Name("test"). + When(). + Create(). + Then(). + And(func(account *account.Account, err error) { + assert.Equal(t, account.Name, ctx.GetName()) + assert.Equal(t, account.Capabilities, []string{"login"}) + }). + When(). + Login(). + Then(). + CurrentUser(func(user *session.GetUserInfoResponse, err error) { + assert.Equal(t, user.LoggedIn, true) + assert.Equal(t, user.Username, ctx.GetName()) + }) +} + +func TestCreateAndUseAccountCLI(t *testing.T) { EnsureCleanState(t) output, err := RunCli("account", "list") diff --git a/test/e2e/fixture/account/actions.go b/test/e2e/fixture/account/actions.go new file mode 100644 index 0000000000000..1966bdf8bcc26 --- /dev/null +++ b/test/e2e/fixture/account/actions.go @@ -0,0 +1,49 @@ +package project + +import ( + "github.com/argoproj/argo-cd/v2/test/e2e/fixture" +) + +// this implements the "when" part of given/when/then +// +// none of the func implement error checks, and that is complete intended, you should check for errors +// using the Then() +type Actions struct { + context *Context + ignoreErrors bool +} + +func (a *Actions) IgnoreErrors() *Actions { + a.ignoreErrors = true + return a +} + +func (a *Actions) DoNotIgnoreErrors() *Actions { + a.ignoreErrors = false + return a +} + +func (a *Actions) prepareSetPasswordArgs(account string) []string { + a.context.t.Helper() + return []string{ + "account", "update-password", "--account", account, "--current-password", fixture.AdminPassword, "--new-password", fixture.DefaultTestUserPassword, "--plaintext", + } +} + +func (a *Actions) Create() *Actions { + fixture.SetAccounts(map[string][]string{ + a.context.name: {"login"}, + }) + _, _ = fixture.RunCli(a.prepareSetPasswordArgs(a.context.name)...) + return a +} + +func (a *Actions) Login() *Actions { + fixture.LoginAs(a.context.name) + return a +} + +func (a *Actions) Then() *Consequences { + a.context.t.Helper() + return &Consequences{a.context, a} +} diff --git a/test/e2e/fixture/account/consequences.go b/test/e2e/fixture/account/consequences.go new file mode 100644 index 0000000000000..20b0677f78821 --- /dev/null +++ b/test/e2e/fixture/account/consequences.go @@ -0,0 +1,60 @@ +package project + +import ( + "context" + "errors" + + "github.com/argoproj/argo-cd/v2/pkg/apiclient/session" + + "github.com/argoproj/argo-cd/v2/pkg/apiclient/account" + "github.com/argoproj/argo-cd/v2/test/e2e/fixture" + . "github.com/argoproj/argo-cd/v2/util/errors" + "github.com/argoproj/argo-cd/v2/util/io" +) + +// this implements the "then" part of given/when/then +type Consequences struct { + context *Context + actions *Actions +} + +func (c *Consequences) And(block func(account *account.Account, err error)) *Consequences { + c.context.t.Helper() + block(c.get()) + return c +} + +func (c *Consequences) CurrentUser(block func(user *session.GetUserInfoResponse, err error)) *Consequences { + c.context.t.Helper() + block(c.getCurrentUser()) + return c +} + +func (c *Consequences) get() (*account.Account, error) { + _, accountClient, _ := fixture.ArgoCDClientset.NewAccountClient() + accList, err := accountClient.ListAccounts(context.Background(), &account.ListAccountRequest{}) + if err != nil { + return nil, err + } + for _, acc := range accList.Items { + if acc.Name == c.context.name { + return acc, nil + } + } + return nil, errors.New("account not found") +} + +func (c *Consequences) getCurrentUser() (*session.GetUserInfoResponse, error) { + closer, client, err := fixture.ArgoCDClientset.NewSessionClient() + CheckError(err) + defer io.Close(closer) + return client.GetUserInfo(context.Background(), &session.GetUserInfoRequest{}) +} + +func (c *Consequences) Given() *Context { + return c.context +} + +func (c *Consequences) When() *Actions { + return c.actions +} diff --git a/test/e2e/fixture/account/context.go b/test/e2e/fixture/account/context.go new file mode 100644 index 0000000000000..99f3adb92d7fd --- /dev/null +++ b/test/e2e/fixture/account/context.go @@ -0,0 +1,45 @@ +package project + +import ( + "testing" + "time" + + "github.com/argoproj/argo-cd/v2/test/e2e/fixture" + "github.com/argoproj/argo-cd/v2/util/env" +) + +// this implements the "given" part of given/when/then +type Context struct { + t *testing.T + // seconds + timeout int + name string +} + +func Given(t *testing.T) *Context { + fixture.EnsureCleanState(t) + // ARGOCE_E2E_DEFAULT_TIMEOUT can be used to override the default timeout + // for any context. + timeout := env.ParseNumFromEnv("ARGOCD_E2E_DEFAULT_TIMEOUT", 10, 0, 180) + return &Context{t: t, name: fixture.Name(), timeout: timeout} +} + +func (c *Context) GetName() string { + return c.name +} + +func (c *Context) Name(name string) *Context { + c.name = name + return c +} + +func (c *Context) And(block func()) *Context { + block() + return c +} + +func (c *Context) When() *Actions { + // in case any settings have changed, pause for 1s, not great, but fine + time.Sleep(1 * time.Second) + return &Actions{context: c} +} diff --git a/test/e2e/fixture/fixture.go b/test/e2e/fixture/fixture.go index 1b607e02d7bf4..5f340e96189a7 100644 --- a/test/e2e/fixture/fixture.go +++ b/test/e2e/fixture/fixture.go @@ -38,11 +38,12 @@ import ( ) const ( - defaultApiServer = "localhost:8080" - defaultAdminPassword = "password" - defaultAdminUsername = "admin" - testingLabel = "e2e.argoproj.io" - ArgoCDNamespace = "argocd-e2e" + defaultApiServer = "localhost:8080" + defaultAdminPassword = "password" + defaultAdminUsername = "admin" + DefaultTestUserPassword = "password" + testingLabel = "e2e.argoproj.io" + ArgoCDNamespace = "argocd-e2e" // ensure all repos are in one directory tree, so we can easily clean them up TmpDir = "/tmp/argo-e2e" @@ -69,7 +70,7 @@ var ( AppClientset appclientset.Interface ArgoCDClientset argocdclient.Client adminUsername string - adminPassword string + AdminPassword string apiServerAddress string token string plainText bool @@ -146,7 +147,7 @@ func init() { apiServerAddress = GetEnvWithDefault(argocdclient.EnvArgoCDServer, defaultApiServer) adminUsername = GetEnvWithDefault(EnvAdminUsername, defaultAdminUsername) - adminPassword = GetEnvWithDefault(EnvAdminPassword, defaultAdminPassword) + AdminPassword = GetEnvWithDefault(EnvAdminPassword, defaultAdminPassword) tlsTestResult, err := grpcutil.TestTLS(apiServerAddress) CheckError(err) @@ -154,24 +155,10 @@ func init() { ArgoCDClientset, err = argocdclient.NewClient(&argocdclient.ClientOptions{Insecure: true, ServerAddr: apiServerAddress, PlainText: !tlsTestResult.TLS}) CheckError(err) - closer, client, err := ArgoCDClientset.NewSessionClient() - CheckError(err) - defer io.Close(closer) - - sessionResponse, err := client.Create(context.Background(), &sessionpkg.SessionCreateRequest{Username: adminUsername, Password: adminPassword}) - CheckError(err) - - ArgoCDClientset, err = argocdclient.NewClient(&argocdclient.ClientOptions{ - Insecure: true, - ServerAddr: apiServerAddress, - AuthToken: sessionResponse.Token, - PlainText: !tlsTestResult.TLS, - }) - CheckError(err) - - token = sessionResponse.Token plainText = !tlsTestResult.TLS + LoginAs(adminUsername) + log.WithFields(log.Fields{"apiServerAddress": apiServerAddress}).Info("initialized") // Preload a list of tests that should be skipped @@ -196,6 +183,32 @@ func init() { } +func loginAs(username, password string) { + closer, client, err := ArgoCDClientset.NewSessionClient() + CheckError(err) + defer io.Close(closer) + + sessionResponse, err := client.Create(context.Background(), &sessionpkg.SessionCreateRequest{Username: username, Password: password}) + CheckError(err) + token = sessionResponse.Token + + ArgoCDClientset, err = argocdclient.NewClient(&argocdclient.ClientOptions{ + Insecure: true, + ServerAddr: apiServerAddress, + AuthToken: token, + PlainText: plainText, + }) + CheckError(err) +} + +func LoginAs(username string) { + password := DefaultTestUserPassword + if username == "admin" { + password = AdminPassword + } + loginAs(username, password) +} + func Name() string { return name } @@ -455,6 +468,9 @@ func EnsureCleanState(t *testing.T) { return nil }) + // We can switch user and as result in previous state we will have non-admin user, this case should be reset + LoginAs(adminUsername) + // reset gpg-keys config map updateGenericConfigMap(common.ArgoCDGPGKeysConfigMapName, func(cm *corev1.ConfigMap) error { cm.Data = map[string]string{}