From a61bba3a5628fffb74295843bac5c6f9a351c915 Mon Sep 17 00:00:00 2001 From: Henning Fleischhauer <18215579+CaptainStandby@users.noreply.github.com> Date: Wed, 21 Dec 2022 16:27:27 +0100 Subject: [PATCH 01/18] removed dead code --- cmd/cloudx/client/handler.go | 5 ----- 1 file changed, 5 deletions(-) diff --git a/cmd/cloudx/client/handler.go b/cmd/cloudx/client/handler.go index a94dc23e..67584885 100644 --- a/cmd/cloudx/client/handler.go +++ b/cmd/cloudx/client/handler.go @@ -455,11 +455,6 @@ func (h *CommandHelper) Authenticate() (*AuthContext, error) { return nil, err } - var retry bool - if retry { - _, _ = fmt.Fprintln(h.VerboseErrWriter, "Unable to Authenticate you, please try again.") - } - if signIn { ac, err = h.signin(c, "") if err != nil { From 83393d8316718ce4ce41fedc59143c6e6b809fc9 Mon Sep 17 00:00:00 2001 From: Henning Fleischhauer <18215579+CaptainStandby@users.noreply.github.com> Date: Fri, 23 Dec 2022 15:46:43 +0100 Subject: [PATCH 02/18] add tests --- cmd/cloudx/client/handler_test.go | 97 +++++++++++++++++++++++++++++++ 1 file changed, 97 insertions(+) diff --git a/cmd/cloudx/client/handler_test.go b/cmd/cloudx/client/handler_test.go index 1352b092..8933596d 100644 --- a/cmd/cloudx/client/handler_test.go +++ b/cmd/cloudx/client/handler_test.go @@ -58,6 +58,103 @@ func TestCommandHelper(t *testing.T) { return ¬YetLoggedIn } + t.Run("func=Authenticate", func(t *testing.T) { + cmd_base := &client.CommandHelper{ + ConfigLocation: testhelpers.NewConfigDir(t), + NoConfirm: true, + IsQuiet: false, + VerboseWriter: io.Discard, + VerboseErrWriter: io.Discard, + Ctx: context.Background(), + } + + t.Run("create new account", func(t *testing.T) { + cmd := *cmd_base + + name := testhelpers.FakeName() + email := testhelpers.FakeEmail() + var r bytes.Buffer + _, _ = r.WriteString("n\n") // Do you want to sign in to an existing Ory Network account? [y/n]: n + _, _ = r.WriteString(email + "\n") // Email: FakeEmail() + _, _ = r.WriteString(name + "\n") // Name: FakeName() + _, _ = r.WriteString("n\n") // Subscribe to the Ory Security Newsletter to get platform and security updates? [y/n]: n + _, _ = r.WriteString("y\n") // I accept the Terms of Service [y/n]: y + cmd.Stdin = bufio.NewReader(&r) + + password := testhelpers.FakePassword() + cmd.PwReader = func() ([]byte, error) { return []byte(password), nil } + + auth_ctx, err := cmd.Authenticate() + + require.NoError(t, err) + require.NotNil(t, auth_ctx) + require.Equal(t, auth_ctx.IdentityTraits.Email, email) + }) + + t.Run("log into existing account", func(t *testing.T) { + cmd := *cmd_base + + var r bytes.Buffer + _, _ = r.WriteString("y\n") // Do you want to sign in to an existing Ory Network account? [y/n]: y + _, _ = r.WriteString(email + "\n") // Email: FakeEmail() + cmd.Stdin = bufio.NewReader(&r) + + cmd.PwReader = func() ([]byte, error) { return []byte(password), nil } + + auth_ctx, err := cmd.Authenticate() + + require.NoError(t, err) + require.NotNil(t, auth_ctx) + require.Equal(t, auth_ctx.IdentityTraits.Email, email) + }) + + t.Run("retry login after wrong password", func(t *testing.T) { + cmd := *cmd_base + + var r bytes.Buffer + _, _ = r.WriteString("y\n") // Do you want to sign in to an existing Ory Network account? [y/n]: y + _, _ = r.WriteString(email + "\n") // Email: FakeEmail() + _, _ = r.WriteString(email + "\n") // Email: FakeEmail() [RETRY] + cmd.Stdin = bufio.NewReader(&r) + + var retry = false + cmd.PwReader = func() ([]byte, error) { + if retry { + return []byte(password), nil + } + retry = true + return []byte("wrong"), nil + } + + auth_ctx, err := cmd.Authenticate() + + require.NoError(t, err) + require.NotNil(t, auth_ctx) + require.Equal(t, auth_ctx.IdentityTraits.Email, email) + }) + + t.Run("switch logged in account", func(t *testing.T) { + cmd := *loggedIn + + cmd.NoConfirm = false + cmd.IsQuiet = false + + var r bytes.Buffer + _, _ = r.WriteString("y\n") // You are signed in as \"%s\" already. Do you wish to authenticate with another account?: y + _, _ = r.WriteString("y\n") // Do you want to sign in to an existing Ory Network account? [y/n]: y + _, _ = r.WriteString(email + "\n") // Email: FakeEmail() + cmd.Stdin = bufio.NewReader(&r) + + cmd.PwReader = func() ([]byte, error) { return []byte(password), nil } + + auth_ctx, err := cmd.Authenticate() + + require.NoError(t, err) + require.NotNil(t, auth_ctx) + require.Equal(t, auth_ctx.IdentityTraits.Email, email) + }) + }) + t.Run("func=CreateAPIKey and DeleteApiKey", func(t *testing.T) { t.Run("is able to get project", func(t *testing.T) { name := "a test key" From 9ff923eb6282221bbf7041ff44333f9b3b248c1a Mon Sep 17 00:00:00 2001 From: Henning Fleischhauer <18215579+CaptainStandby@users.noreply.github.com> Date: Wed, 28 Dec 2022 12:31:43 +0100 Subject: [PATCH 03/18] add more tests --- cmd/cloudx/client/handler.go | 13 +++++ cmd/cloudx/client/handler_test.go | 90 +++++++++++++++++++++++++++++++ 2 files changed, 103 insertions(+) diff --git a/cmd/cloudx/client/handler.go b/cmd/cloudx/client/handler.go index 67584885..ab1fcc02 100644 --- a/cmd/cloudx/client/handler.go +++ b/cmd/cloudx/client/handler.go @@ -152,6 +152,19 @@ func NewCommandHelper(cmd *cobra.Command) (*CommandHelper, error) { }, nil } +func (h *CommandHelper) GetDefaultProjectID() (string, error) { + conf, err := h.readConfig() + if err != nil { + return "", err + } + + if conf.SelectedProject != uuid.Nil { + return conf.SelectedProject.String(), nil + } + + return "", errors.New("No valid default project was specified") +} + func (h *CommandHelper) SetDefaultProject(id string) error { conf, err := h.readConfig() if err != nil { diff --git a/cmd/cloudx/client/handler_test.go b/cmd/cloudx/client/handler_test.go index 8933596d..ef84da22 100644 --- a/cmd/cloudx/client/handler_test.go +++ b/cmd/cloudx/client/handler_test.go @@ -58,6 +58,96 @@ func TestCommandHelper(t *testing.T) { return ¬YetLoggedIn } + t.Run("func=ListProjects", func(t *testing.T) { + configDir := testhelpers.NewConfigDir(t) + testhelpers.RegisterAccount(t, configDir) + + cmd_base := &client.CommandHelper{ + ConfigLocation: configDir, + NoConfirm: true, + IsQuiet: false, + VerboseWriter: io.Discard, + VerboseErrWriter: io.Discard, + Ctx: context.Background(), + } + + t.Run("With no projects returns empty list", func(t *testing.T) { + cmd := *cmd_base + + projects, err := cmd.ListProjects() + + require.NoError(t, err) + require.Empty(t, projects) + }) + + t.Run("With some projects returns list of projects", func(t *testing.T) { + cmd := *cmd_base + project_name1 := "new_project_name1" + project_name2 := "new_project_name2" + + project1, err := cmd.CreateProject(project_name1) + require.NoError(t, err) + project2, err := cmd.CreateProject(project_name2) + require.NoError(t, err) + + projects, err := cmd.ListProjects() + + require.NoError(t, err) + assert.Len(t, projects, 2) + listedIds := [2]string{projects[0].Id, projects[1].Id} + assert.Contains(t, listedIds, project1.Id) + assert.Contains(t, listedIds, project2.Id) + }) + + }) + + t.Run("func=CreateProject", func(t *testing.T) { + configDir := testhelpers.NewConfigDir(t) + testhelpers.RegisterAccount(t, configDir) + + cmd_base := &client.CommandHelper{ + ConfigLocation: configDir, + NoConfirm: true, + IsQuiet: false, + VerboseWriter: io.Discard, + VerboseErrWriter: io.Discard, + Ctx: context.Background(), + } + + t.Run("creates project and sets default project", func(t *testing.T) { + cmd := *cmd_base + project_name := "new_project_name" + + project, err := cmd.CreateProject(project_name) + require.NoError(t, err) + assert.Equal(t, project.Name, project_name) + + defaultId, err := cmd.GetDefaultProjectID() + require.NoError(t, err) + assert.Equal(t, project.Id, defaultId) + }) + + t.Run("creates two projects with different names", func(t *testing.T) { + cmd := *cmd_base + project_name1 := "new_project_name1" + project_name2 := "new_project_name2" + + project1, err := cmd.CreateProject(project_name1) + require.NoError(t, err) + + project2, err := cmd.CreateProject(project_name2) + require.NoError(t, err) + + assert.NotEqual(t, project1.Id, project2.Id) + assert.NotEqual(t, project1.Name, project2.Name) + assert.NotEqual(t, project1.Slug, project2.Slug) + + defaultId, err := cmd.GetDefaultProjectID() + require.NoError(t, err) + assert.Equal(t, project2.Id, defaultId) + }) + }) + t.Run("func=Authenticate", func(t *testing.T) { cmd_base := &client.CommandHelper{ ConfigLocation: testhelpers.NewConfigDir(t), From 216f231c893d08cca235ad87b7329114f81808fc Mon Sep 17 00:00:00 2001 From: Henning Fleischhauer <18215579+CaptainStandby@users.noreply.github.com> Date: Wed, 28 Dec 2022 18:04:53 +0100 Subject: [PATCH 04/18] change some default assets --- cmd/cloudx/identity/main_test.go | 2 +- cmd/cloudx/oauth2/main_test.go | 2 +- cmd/cloudx/project/main_test.go | 6 +++--- cmd/cloudx/relationtuples/relationtuples_test.go | 2 +- cmd/cloudx/testhelpers/testmain.go | 3 ++- 5 files changed, 8 insertions(+), 7 deletions(-) diff --git a/cmd/cloudx/identity/main_test.go b/cmd/cloudx/identity/main_test.go index bc87c619..d8f1ef3f 100644 --- a/cmd/cloudx/identity/main_test.go +++ b/cmd/cloudx/identity/main_test.go @@ -16,6 +16,6 @@ var ( ) func TestMain(m *testing.M) { - defaultConfig, defaultEmail, defaultPassword, defaultProject, defaultCmd = testhelpers.CreateDefaultAssets() + defaultConfig, defaultEmail, defaultPassword, _, defaultProject, defaultCmd = testhelpers.CreateDefaultAssets() testhelpers.RunAgainstStaging(m) } diff --git a/cmd/cloudx/oauth2/main_test.go b/cmd/cloudx/oauth2/main_test.go index 0612835c..0c9029ac 100644 --- a/cmd/cloudx/oauth2/main_test.go +++ b/cmd/cloudx/oauth2/main_test.go @@ -16,6 +16,6 @@ var ( ) func TestMain(m *testing.M) { - defaultConfig, defaultEmail, defaultPassword, defaultProject, defaultCmd = testhelpers.CreateDefaultAssets() + defaultConfig, defaultEmail, defaultPassword, _, defaultProject, defaultCmd = testhelpers.CreateDefaultAssets() testhelpers.RunAgainstStaging(m) } diff --git a/cmd/cloudx/project/main_test.go b/cmd/cloudx/project/main_test.go index edbb8bc9..8d070b99 100644 --- a/cmd/cloudx/project/main_test.go +++ b/cmd/cloudx/project/main_test.go @@ -11,11 +11,11 @@ import ( ) var ( - defaultProject, defaultConfig, defaultEmail, defaultPassword string - defaultCmd *cmdx.CommandExecuter + extraProject, defaultProject, defaultConfig, defaultEmail, defaultPassword string + defaultCmd *cmdx.CommandExecuter ) func TestMain(m *testing.M) { - defaultConfig, defaultEmail, defaultPassword, defaultProject, defaultCmd = testhelpers.CreateDefaultAssets() + defaultConfig, defaultEmail, defaultPassword, extraProject, defaultProject, defaultCmd = testhelpers.CreateDefaultAssets() testhelpers.RunAgainstStaging(m) } diff --git a/cmd/cloudx/relationtuples/relationtuples_test.go b/cmd/cloudx/relationtuples/relationtuples_test.go index 5c8808d6..6fd90571 100644 --- a/cmd/cloudx/relationtuples/relationtuples_test.go +++ b/cmd/cloudx/relationtuples/relationtuples_test.go @@ -24,7 +24,7 @@ var ( ) func TestMain(m *testing.M) { - _, defaultEmail, defaultPassword, project, defaultCmd = testhelpers.CreateDefaultAssets() + _, defaultEmail, defaultPassword, _, project, defaultCmd = testhelpers.CreateDefaultAssets() testhelpers.RunAgainstStaging(m) } diff --git a/cmd/cloudx/testhelpers/testmain.go b/cmd/cloudx/testhelpers/testmain.go index 6b217ab3..11939f24 100644 --- a/cmd/cloudx/testhelpers/testmain.go +++ b/cmd/cloudx/testhelpers/testmain.go @@ -25,7 +25,7 @@ func UseStaging() { setEnvIfUnset("ORY_CLOUD_ORYAPIS_URL", "https://staging.oryapis.dev:443") } -func CreateDefaultAssets() (defaultConfig, defaultEmail, defaultPassword, defaultProject string, defaultCmd *cmdx.CommandExecuter) { +func CreateDefaultAssets() (defaultConfig, defaultEmail, defaultPassword, extraProject, defaultProject string, defaultCmd *cmdx.CommandExecuter) { UseStaging() t := testingT{} @@ -33,6 +33,7 @@ func CreateDefaultAssets() (defaultConfig, defaultEmail, defaultPassword, defaul defaultConfig = NewConfigDir(t) defaultEmail, defaultPassword = RegisterAccount(t, defaultConfig) + extraProject = CreateProject(t, defaultConfig) defaultProject = CreateProject(t, defaultConfig) defaultCmd = ConfigAwareCmd(defaultConfig) return From 50ca9c888bf2b4acff0c71860df2c2da1288b04c Mon Sep 17 00:00:00 2001 From: Henning Fleischhauer <18215579+CaptainStandby@users.noreply.github.com> Date: Wed, 28 Dec 2022 18:07:37 +0100 Subject: [PATCH 05/18] add use command --- cmd/cloudx/project/use.go | 73 +++++++++++++++++++++++++++++++++++++++ cmd/cloudx/use.go | 30 ++++++++++++++++ cmd/root.go | 1 + 3 files changed, 104 insertions(+) create mode 100644 cmd/cloudx/project/use.go create mode 100644 cmd/cloudx/use.go diff --git a/cmd/cloudx/project/use.go b/cmd/cloudx/project/use.go new file mode 100644 index 00000000..571297e8 --- /dev/null +++ b/cmd/cloudx/project/use.go @@ -0,0 +1,73 @@ +// Copyright © 2022 Ory Corp +// SPDX-License-Identifier: Apache-2.0 + +package project + +import ( + "github.com/spf13/cobra" + + "github.com/ory/cli/cmd/cloudx/client" + "github.com/ory/x/cmdx" +) + +func NewUseProjectCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: "project [id]", + Args: cobra.MaximumNArgs(1), + Short: "Set the project as the default. When no id is provided, prints the currently used default project.", + Example: `$ ory use project ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 + +ID ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 +SLUG good-wright-t7kzy3vugf +STATE running +NAME Example Project + +$ ory use project ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 --format json + +{ + "name": "Example Project", + "identity": { + "services": { + "config": { + "courier": { + "smtp": { + "from_name": "..." + } + // ... + } + } + } + } +}`, + RunE: func(cmd *cobra.Command, args []string) error { + h, err := client.NewCommandHelper(cmd) + if err != nil { + return err + } + + var id string + if len(args) == 0 { + if id, err = h.GetDefaultProjectID(); err != nil { + return cmdx.PrintOpenAPIError(cmd, err) + } + } else { + id = args[0] + err = h.SetDefaultProject(id) + if err != nil { + return cmdx.PrintOpenAPIError(cmd, err) + } + } + + project, err := h.GetProject(id) + if err != nil { + return cmdx.PrintOpenAPIError(cmd, err) + } + + cmdx.PrintRow(cmd, (*outputProject)(project)) + return nil + }, + } + + cmdx.RegisterFormatFlags(cmd.Flags()) + return cmd +} diff --git a/cmd/cloudx/use.go b/cmd/cloudx/use.go new file mode 100644 index 00000000..ceadccd5 --- /dev/null +++ b/cmd/cloudx/use.go @@ -0,0 +1,30 @@ +// Copyright © 2022 Ory Corp +// SPDX-License-Identifier: Apache-2.0 + +package cloudx + +import ( + "github.com/spf13/cobra" + + "github.com/ory/cli/cmd/cloudx/client" + "github.com/ory/cli/cmd/cloudx/project" + "github.com/ory/x/cmdx" +) + +func NewUseCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: "use", + Short: "Use a resource", + } + + cmd.AddCommand( + project.NewUseProjectCmd(), + ) + + client.RegisterConfigFlag(cmd.PersistentFlags()) + client.RegisterYesFlag(cmd.PersistentFlags()) + cmdx.RegisterNoiseFlags(cmd.PersistentFlags()) + cmdx.RegisterJSONFormatFlags(cmd.PersistentFlags()) + + return cmd +} diff --git a/cmd/root.go b/cmd/root.go index d588f87d..4749ed4b 100644 --- a/cmd/root.go +++ b/cmd/root.go @@ -33,6 +33,7 @@ func NewRootCmd() *cobra.Command { jsonnet.NewLintCmd(), cloudx.NewDeleteCmd(), cloudx.NewGetCmd(), + cloudx.NewUseCmd(), cloudx.NewListCmd(), cloudx.NewImportCmd(), cloudx.NewPatchCmd(), From 97e13dd1bb7f5a4dc65d49d714206176c5fdd92e Mon Sep 17 00:00:00 2001 From: Henning Fleischhauer <18215579+CaptainStandby@users.noreply.github.com> Date: Wed, 28 Dec 2022 18:10:26 +0100 Subject: [PATCH 06/18] add tests --- cmd/cloudx/client/client.go | 21 ++- cmd/cloudx/project/get.go | 14 +- cmd/cloudx/project/get_identity_config.go | 14 +- cmd/cloudx/project/get_oauth2_config.go | 14 +- cmd/cloudx/project/get_permission_config.go | 14 +- cmd/cloudx/project/get_test.go | 52 ++++-- cmd/cloudx/project/patch.go | 14 +- cmd/cloudx/project/patch_identity_config.go | 4 +- .../project/patch_identity_config_test.go | 55 +++++-- cmd/cloudx/project/patch_oauth2_config.go | 4 +- .../project/patch_oauth2_config_test.go | 55 +++++-- cmd/cloudx/project/patch_permission_config.go | 4 +- .../project/patch_permission_config_test.go | 55 +++++-- cmd/cloudx/project/patch_test.go | 148 +++++++++++++----- cmd/cloudx/project/update.go | 14 +- cmd/cloudx/project/update_identity_config.go | 4 +- cmd/cloudx/project/update_namespace_config.go | 6 +- .../project/update_namespace_config_test.go | 36 +++-- cmd/cloudx/project/update_oauth2_config.go | 4 +- .../project/update_permission_config.go | 4 +- cmd/cloudx/testhelpers/testhelpers.go | 10 ++ 21 files changed, 415 insertions(+), 131 deletions(-) diff --git a/cmd/cloudx/client/client.go b/cmd/cloudx/client/client.go index b8b69487..c8fd9253 100644 --- a/cmd/cloudx/client/client.go +++ b/cmd/cloudx/client/client.go @@ -30,6 +30,21 @@ func RegisterProjectFlag(f *flag.FlagSet) { f.String(projectFlag, "", "The project to use, either project ID or a (partial) slug.") } +// ProjectOrDefault returns the slug or ID the user set with the `--project` flag, or the default project, or prints a warning and returns an error +// if none was set. +func ProjectOrDefault(cmd *cobra.Command, h *CommandHelper) (string, error) { + if flag := flagx.MustGetString(cmd, projectFlag); flag == "" { + if id, err := h.GetDefaultProjectID(); err == nil { + return id, nil + } else { + _, _ = fmt.Fprintf(os.Stderr, "No project selected! Please use the flag --%s to specify one.\n", projectFlag) + return "", cmdx.FailSilently(cmd) + } + } else { + return flag, nil + } +} + func Client(cmd *cobra.Command) (*retryablehttp.Client, *AuthContext, *cloud.Project, error) { sc, err := NewCommandHelper(cmd) if err != nil { @@ -42,7 +57,11 @@ func Client(cmd *cobra.Command) (*retryablehttp.Client, *AuthContext, *cloud.Pro return nil, nil, nil, err } - projectOrSlug := flagx.MustGetString(cmd, projectFlag) + projectOrSlug, err := ProjectOrDefault(cmd, sc) + if err != nil { + return nil, nil, nil, cmdx.FailSilently(cmd) + } + p, err := sc.GetProject(projectOrSlug) if err != nil { return nil, nil, nil, err diff --git a/cmd/cloudx/project/get.go b/cmd/cloudx/project/get.go index 21e8650e..d7e15dac 100644 --- a/cmd/cloudx/project/get.go +++ b/cmd/cloudx/project/get.go @@ -12,8 +12,8 @@ import ( func NewGetProjectCmd() *cobra.Command { cmd := &cobra.Command{ - Use: "project ", - Args: cobra.ExactArgs(1), + Use: "project [id]", + Args: cobra.MaximumNArgs(1), Short: "Get the complete configuration of an Ory Network project.", Example: `$ ory get project ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 @@ -45,7 +45,15 @@ $ ory get project ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 --format json return err } - project, err := h.GetProject(args[0]) + var id string + if len(args) == 0 { + if id, err = h.GetDefaultProjectID(); err != nil { + return cmdx.PrintOpenAPIError(cmd, err) + } + } else { + id = args[0] + } + project, err := h.GetProject(id) if err != nil { return cmdx.PrintOpenAPIError(cmd, err) } diff --git a/cmd/cloudx/project/get_identity_config.go b/cmd/cloudx/project/get_identity_config.go index b4ea7f08..1095c958 100644 --- a/cmd/cloudx/project/get_identity_config.go +++ b/cmd/cloudx/project/get_identity_config.go @@ -12,9 +12,9 @@ import ( func NewGetKratosConfigCmd() *cobra.Command { cmd := &cobra.Command{ - Use: "identity-config ", + Use: "identity-config [project-id]", Aliases: []string{"ic", "kratos-config"}, - Args: cobra.ExactArgs(1), + Args: cobra.MaximumNArgs(1), Short: "Get Ory Identities configuration.", Long: "Get the Ory Identities configuration for the specified Ory Network project.", Example: `$ ory get identity-config ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 --format yaml > identity-config.yaml @@ -35,7 +35,15 @@ $ ory get identity-config ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 --format json return err } - project, err := h.GetProject(args[0]) + var id string + if len(args) == 0 { + if id, err = h.GetDefaultProjectID(); err != nil { + return cmdx.PrintOpenAPIError(cmd, err) + } + } else { + id = args[0] + } + project, err := h.GetProject(id) if err != nil { return cmdx.PrintOpenAPIError(cmd, err) } diff --git a/cmd/cloudx/project/get_oauth2_config.go b/cmd/cloudx/project/get_oauth2_config.go index 681447f4..c9c6748f 100644 --- a/cmd/cloudx/project/get_oauth2_config.go +++ b/cmd/cloudx/project/get_oauth2_config.go @@ -12,9 +12,9 @@ import ( func NewGetOAuth2ConfigCmd() *cobra.Command { cmd := &cobra.Command{ - Use: "oauth2-config ", + Use: "oauth2-config [project-id]", Aliases: []string{"oc", "oauth2-config"}, - Args: cobra.ExactArgs(1), + Args: cobra.MaximumNArgs(1), Short: "Get Ory OAuth2 & OpenID Connect configuration.", Long: "Get the Ory OAuth2 & OpenID Connect configuration for the specified Ory Network project.", Example: `$ ory get oauth2-config ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 --format yaml > oauth2-config.yaml @@ -43,7 +43,15 @@ $ ory get oauth2-config ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 --format json return err } - project, err := h.GetProject(args[0]) + var id string + if len(args) == 0 { + if id, err = h.GetDefaultProjectID(); err != nil { + return cmdx.PrintOpenAPIError(cmd, err) + } + } else { + id = args[0] + } + project, err := h.GetProject(id) if err != nil { return cmdx.PrintOpenAPIError(cmd, err) } diff --git a/cmd/cloudx/project/get_permission_config.go b/cmd/cloudx/project/get_permission_config.go index c7e2303b..0c1d5397 100644 --- a/cmd/cloudx/project/get_permission_config.go +++ b/cmd/cloudx/project/get_permission_config.go @@ -12,9 +12,9 @@ import ( func NewGetKetoConfigCmd() *cobra.Command { cmd := &cobra.Command{ - Use: "permission-config ", + Use: "permission-config [project-id]", Aliases: []string{"pc", "keto-config"}, - Args: cobra.ExactArgs(1), + Args: cobra.MaximumNArgs(1), Short: "Get Ory Permissions configuration.", Long: "Get the Ory Permissions configuration for the specified Ory Network project.", Example: `$ ory get permission-config ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 --format yaml > permission-config.yaml @@ -36,7 +36,15 @@ $ ory get permission-config ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 --format json return err } - project, err := h.GetProject(args[0]) + var id string + if len(args) == 0 { + if id, err = h.GetDefaultProjectID(); err != nil { + return cmdx.PrintOpenAPIError(cmd, err) + } + } else { + id = args[0] + } + project, err := h.GetProject(id) if err != nil { return cmdx.PrintOpenAPIError(cmd, err) } diff --git a/cmd/cloudx/project/get_test.go b/cmd/cloudx/project/get_test.go index 7763ab64..62f3f131 100644 --- a/cmd/cloudx/project/get_test.go +++ b/cmd/cloudx/project/get_test.go @@ -6,14 +6,22 @@ package project_test import ( "testing" + "github.com/ory/cli/cmd/cloudx/testhelpers" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "github.com/tidwall/gjson" ) func TestGetProject(t *testing.T) { + testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) t.Run("is able to get project", func(t *testing.T) { - stdout, _, err := defaultCmd.Exec(nil, "get", "project", defaultProject, "--format", "json") + stdout, _, err := defaultCmd.Exec(nil, "get", "project", extraProject, "--format", "json") + require.NoError(t, err) + assert.Equal(t, extraProject, gjson.Get(stdout, "id").String()) + assert.NotEmpty(t, gjson.Get(stdout, "slug").String()) + }) + t.Run("is able to get default project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "get", "project", "--format", "json") require.NoError(t, err) assert.Equal(t, defaultProject, gjson.Get(stdout, "id").String()) assert.NotEmpty(t, gjson.Get(stdout, "slug").String()) @@ -22,20 +30,44 @@ func TestGetProject(t *testing.T) { func TestGetServiceConfig(t *testing.T) { t.Run("service=kratos", func(t *testing.T) { - stdout, _, err := defaultCmd.Exec(nil, "get", "kratos-config", defaultProject, "--format", "json") - require.NoError(t, err) - assert.True(t, gjson.Get(stdout, "selfservice.flows.error.ui_url").Exists()) + testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) + t.Run("explicit project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "get", "kratos-config", defaultProject, "--format", "json") + require.NoError(t, err) + assert.True(t, gjson.Get(stdout, "selfservice.flows.error.ui_url").Exists()) + }) + t.Run("default project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "get", "kratos-config", "--format", "json") + require.NoError(t, err) + assert.True(t, gjson.Get(stdout, "selfservice.flows.error.ui_url").Exists()) + }) }) t.Run("service=keto", func(t *testing.T) { - stdout, _, err := defaultCmd.Exec(nil, "get", "keto-config", defaultProject, "--format", "json") - require.NoError(t, err) - assert.True(t, gjson.Get(stdout, "namespaces").Exists(), stdout) + testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) + t.Run("explicit project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "get", "keto-config", defaultProject, "--format", "json") + require.NoError(t, err) + assert.True(t, gjson.Get(stdout, "namespaces").Exists(), stdout) + }) + t.Run("default project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "get", "keto-config", "--format", "json") + require.NoError(t, err) + assert.True(t, gjson.Get(stdout, "namespaces").Exists(), stdout) + }) }) t.Run("service=hydra", func(t *testing.T) { - stdout, _, err := defaultCmd.Exec(nil, "get", "oauth2-config", defaultProject, "--format", "json") - require.NoError(t, err) - assert.True(t, gjson.Get(stdout, "oauth2").Exists(), stdout) + testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) + t.Run("explicit project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "get", "oauth2-config", defaultProject, "--format", "json") + require.NoError(t, err) + assert.True(t, gjson.Get(stdout, "oauth2").Exists(), stdout) + }) + t.Run("default project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "get", "oauth2-config", "--format", "json") + require.NoError(t, err) + assert.True(t, gjson.Get(stdout, "oauth2").Exists(), stdout) + }) }) } diff --git a/cmd/cloudx/project/patch.go b/cmd/cloudx/project/patch.go index c9c6f0f4..ebdad947 100644 --- a/cmd/cloudx/project/patch.go +++ b/cmd/cloudx/project/patch.go @@ -17,8 +17,8 @@ import ( func NewProjectsPatchCmd() *cobra.Command { cmd := &cobra.Command{ - Use: "project ", - Args: cobra.ExactArgs(1), + Use: "project [id]", + Args: cobra.MaximumNArgs(1), Short: "Patch the Ory Network project configuration.", Example: `ory patch project ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 \ --replace '/name="My new project name"' \ @@ -81,7 +81,15 @@ func runPatch(patchPrefixer func([]string) []string, filePrefixer func([]json.Ra return err } - p, err := h.PatchProject(args[0], configs, add, replace, remove) + var id string + if len(args) == 0 { + if id, err = h.GetDefaultProjectID(); err != nil { + return cmdx.PrintOpenAPIError(cmd, err) + } + } else { + id = args[0] + } + p, err := h.PatchProject(id, configs, add, replace, remove) if err != nil { return cmdx.PrintOpenAPIError(cmd, err) } diff --git a/cmd/cloudx/project/patch_identity_config.go b/cmd/cloudx/project/patch_identity_config.go index bcf86a79..84b1a5d0 100644 --- a/cmd/cloudx/project/patch_identity_config.go +++ b/cmd/cloudx/project/patch_identity_config.go @@ -12,9 +12,9 @@ import ( func NewPatchKratosConfigCmd() *cobra.Command { cmd := &cobra.Command{ - Use: "identity-config ", + Use: "identity-config [project-id]", Aliases: []string{"ic", "kratos-config"}, - Args: cobra.ExactArgs(1), + Args: cobra.MaximumNArgs(1), Short: "Patch the Ory Identities configuration of the defined Ory Network project.", Example: `$ ory patch identity-config ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 \ --add '/courier/smtp={"from_name":"My new email name"}' \ diff --git a/cmd/cloudx/project/patch_identity_config_test.go b/cmd/cloudx/project/patch_identity_config_test.go index b803e4ad..ba2d4f44 100644 --- a/cmd/cloudx/project/patch_identity_config_test.go +++ b/cmd/cloudx/project/patch_identity_config_test.go @@ -7,34 +7,63 @@ import ( "testing" "github.com/ory/cli/cmd/cloudx/testhelpers" - "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "github.com/tidwall/gjson" ) func TestPatchKratosConfig(t *testing.T) { - project := testhelpers.CreateProject(t, defaultConfig) t.Run("is able to replace a key", func(t *testing.T) { - stdout, _, err := defaultCmd.Exec(nil, "patch", "kratos-config", project, "--format", "json", "--replace", `/selfservice/methods/password/enabled=false`) - require.NoError(t, err) - assert.False(t, gjson.Get(stdout, "selfservice.methods.password.enabled").Bool()) + testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) + t.Run("explicit project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "kratos-config", extraProject, "--format", "json", "--replace", `/selfservice/methods/password/enabled=false`) + require.NoError(t, err) + assert.False(t, gjson.Get(stdout, "selfservice.methods.password.enabled").Bool()) + }) + t.Run("default project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "kratos-config", "--format", "json", "--replace", `/selfservice/methods/password/enabled=false`) + require.NoError(t, err) + assert.False(t, gjson.Get(stdout, "selfservice.methods.password.enabled").Bool()) + }) }) t.Run("is able to add a key", func(t *testing.T) { - stdout, _, err := defaultCmd.Exec(nil, "patch", "identity-config", project, "--format", "json", "--add", `/selfservice/methods/password/enabled=false`) - require.NoError(t, err) - assert.False(t, gjson.Get(stdout, "selfservice.methods.password.enabled").Bool()) + testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) + t.Run("explicit project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "identity-config", extraProject, "--format", "json", "--add", `/selfservice/methods/password/enabled=false`) + require.NoError(t, err) + assert.False(t, gjson.Get(stdout, "selfservice.methods.password.enabled").Bool()) + }) + t.Run("default project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "identity-config", "--format", "json", "--add", `/selfservice/methods/password/enabled=false`) + require.NoError(t, err) + assert.False(t, gjson.Get(stdout, "selfservice.methods.password.enabled").Bool()) + }) }) t.Run("is able to add a key with string", func(t *testing.T) { - stdout, _, err := defaultCmd.Exec(nil, "patch", "ic", project, "--format", "json", "--replace", "/selfservice/flows/error/ui_url=\"https://example.com/error-ui\"") - require.NoError(t, err) - assert.Equal(t, "https://example.com/error-ui", gjson.Get(stdout, "selfservice.flows.error.ui_url").String()) + testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) + t.Run("explicit project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "ic", extraProject, "--format", "json", "--replace", "/selfservice/flows/error/ui_url=\"https://example.com/error-ui\"") + require.NoError(t, err) + assert.Equal(t, "https://example.com/error-ui", gjson.Get(stdout, "selfservice.flows.error.ui_url").String()) + }) + t.Run("default project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "ic", "--format", "json", "--replace", "/selfservice/flows/error/ui_url=\"https://example.com/error-ui\"") + require.NoError(t, err) + assert.Equal(t, "https://example.com/error-ui", gjson.Get(stdout, "selfservice.flows.error.ui_url").String()) + }) }) t.Run("fails if no opts are given", func(t *testing.T) { - stdout, _, err := defaultCmd.Exec(nil, "patch", "ic", project, "--format", "json") - require.Error(t, err, stdout) + testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) + t.Run("explicit project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "ic", extraProject, "--format", "json") + require.Error(t, err, stdout) + }) + t.Run("default project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "ic", "--format", "json") + require.Error(t, err, stdout) + }) }) } diff --git a/cmd/cloudx/project/patch_oauth2_config.go b/cmd/cloudx/project/patch_oauth2_config.go index 1b564f12..52bb59d2 100644 --- a/cmd/cloudx/project/patch_oauth2_config.go +++ b/cmd/cloudx/project/patch_oauth2_config.go @@ -13,9 +13,9 @@ import ( func NewPatchOAuth2ConfigCmd() *cobra.Command { cmd := &cobra.Command{ - Use: "oauth2-config ", + Use: "oauth2-config [project-id]", Aliases: []string{"oc", "hydra-config"}, - Args: cobra.ExactArgs(1), + Args: cobra.MaximumNArgs(1), Short: "Patch the Ory OAuth2 & OpenID Connect configuration of the specified Ory Network project.", Example: `$ ory patch oauth2-config ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 \ --replace '/strategies/access_token="jwt"' \ diff --git a/cmd/cloudx/project/patch_oauth2_config_test.go b/cmd/cloudx/project/patch_oauth2_config_test.go index d34f52ea..490d6ed3 100644 --- a/cmd/cloudx/project/patch_oauth2_config_test.go +++ b/cmd/cloudx/project/patch_oauth2_config_test.go @@ -7,34 +7,63 @@ import ( "testing" "github.com/ory/cli/cmd/cloudx/testhelpers" - "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "github.com/tidwall/gjson" ) func TestPatchHydraConfig(t *testing.T) { - project := testhelpers.CreateProject(t, defaultConfig) t.Run("is able to replace a key", func(t *testing.T) { - stdout, _, err := defaultCmd.Exec(nil, "patch", "hydra-config", project, "--format", "json", "--replace", `/strategies/access_token="jwt"`) - require.NoError(t, err) - assert.Equal(t, "jwt", gjson.Get(stdout, "strategies.access_token").String()) + testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) + t.Run("explicit project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "hydra-config", extraProject, "--format", "json", "--replace", `/strategies/access_token="jwt"`) + require.NoError(t, err) + assert.Equal(t, "jwt", gjson.Get(stdout, "strategies.access_token").String()) + }) + t.Run("default project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "hydra-config", "--format", "json", "--replace", `/strategies/access_token="jwt"`) + require.NoError(t, err) + assert.Equal(t, "jwt", gjson.Get(stdout, "strategies.access_token").String()) + }) }) t.Run("is able to add a key", func(t *testing.T) { - stdout, _, err := defaultCmd.Exec(nil, "patch", "oauth2-config", project, "--format", "json", "--add", `/ttl/login_consent_request="1h"`) - require.NoError(t, err) - assert.Equal(t, "1h0m0s", gjson.Get(stdout, "ttl.login_consent_request").String()) + testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) + t.Run("explicit project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "oauth2-config", extraProject, "--format", "json", "--add", `/ttl/login_consent_request="1h"`) + require.NoError(t, err) + assert.Equal(t, "1h0m0s", gjson.Get(stdout, "ttl.login_consent_request").String()) + }) + t.Run("default project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "oauth2-config", "--format", "json", "--add", `/ttl/login_consent_request="1h"`) + require.NoError(t, err) + assert.Equal(t, "1h0m0s", gjson.Get(stdout, "ttl.login_consent_request").String()) + }) }) t.Run("is able to add a key with string", func(t *testing.T) { - stdout, _, err := defaultCmd.Exec(nil, "patch", "oc", project, "--format", "json", "--replace", `/ttl/refresh_token="2h"`) - require.NoError(t, err) - assert.Equal(t, "2h0m0s", gjson.Get(stdout, "ttl.refresh_token").String()) + testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) + t.Run("explicit project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "oc", extraProject, "--format", "json", "--replace", `/ttl/refresh_token="2h"`) + require.NoError(t, err) + assert.Equal(t, "2h0m0s", gjson.Get(stdout, "ttl.refresh_token").String()) + }) + t.Run("default project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "oc", "--format", "json", "--replace", `/ttl/refresh_token="2h"`) + require.NoError(t, err) + assert.Equal(t, "2h0m0s", gjson.Get(stdout, "ttl.refresh_token").String()) + }) }) t.Run("fails if no opts are given", func(t *testing.T) { - stdout, _, err := defaultCmd.Exec(nil, "patch", "oc", project, "--format", "json") - require.Error(t, err, stdout) + testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) + t.Run("explicit project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "oc", extraProject, "--format", "json") + require.Error(t, err, stdout) + }) + t.Run("default project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "oc", "--format", "json") + require.Error(t, err, stdout) + }) }) } diff --git a/cmd/cloudx/project/patch_permission_config.go b/cmd/cloudx/project/patch_permission_config.go index f01fc413..798726c3 100644 --- a/cmd/cloudx/project/patch_permission_config.go +++ b/cmd/cloudx/project/patch_permission_config.go @@ -12,9 +12,9 @@ import ( func NewPatchKetoConfigCmd() *cobra.Command { cmd := &cobra.Command{ - Use: "permission-config ", + Use: "permission-config [project-id]", Aliases: []string{"pc", "keto-config"}, - Args: cobra.ExactArgs(1), + Args: cobra.MaximumNArgs(1), Short: "Patch the Ory Permissions configuration of the specified Ory Network project.", Example: `$ ory patch permission-config ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 \ --add '/namespaces=[{"name":"files", "id": 2}]' \ diff --git a/cmd/cloudx/project/patch_permission_config_test.go b/cmd/cloudx/project/patch_permission_config_test.go index 43e7f118..c0906d96 100644 --- a/cmd/cloudx/project/patch_permission_config_test.go +++ b/cmd/cloudx/project/patch_permission_config_test.go @@ -7,34 +7,63 @@ import ( "testing" "github.com/ory/cli/cmd/cloudx/testhelpers" - "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "github.com/tidwall/gjson" ) func TestPatchPermissionConfig(t *testing.T) { - project := testhelpers.CreateProject(t, defaultConfig) t.Run("is able to replace a key", func(t *testing.T) { - stdout, _, err := defaultCmd.Exec(nil, "patch", "keto-config", project, "--format", "json", "--add", `/namespaces=[{"name":"files", "id": 2}]`) - require.NoError(t, err) - assert.Equal(t, "files", gjson.Get(stdout, "namespaces.0.name").String(), stdout) + testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) + t.Run("explicit project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "keto-config", extraProject, "--format", "json", "--add", `/namespaces=[{"name":"files", "id": 2}]`) + require.NoError(t, err) + assert.Equal(t, "files", gjson.Get(stdout, "namespaces.0.name").String(), stdout) + }) + t.Run("default project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "keto-config", "--format", "json", "--add", `/namespaces=[{"name":"files", "id": 2}]`) + require.NoError(t, err) + assert.Equal(t, "files", gjson.Get(stdout, "namespaces.0.name").String(), stdout) + }) }) t.Run("is able to add a key using permission-config", func(t *testing.T) { - stdout, _, err := defaultCmd.Exec(nil, "patch", "permission-config", project, "--format", "json", "--add", `/namespaces/1={"name":"docs", "id": 3}`) - require.NoError(t, err) - assert.Equal(t, "docs", gjson.Get(stdout, "namespaces.1.name").String(), stdout) + testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) + t.Run("explicit project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "permission-config", extraProject, "--format", "json", "--add", `/namespaces/1={"name":"docs", "id": 3}`) + require.NoError(t, err) + assert.Equal(t, "docs", gjson.Get(stdout, "namespaces.1.name").String(), stdout) + }) + t.Run("default project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "permission-config", "--format", "json", "--add", `/namespaces/1={"name":"docs", "id": 3}`) + require.NoError(t, err) + assert.Equal(t, "docs", gjson.Get(stdout, "namespaces.1.name").String(), stdout) + }) }) t.Run("is able to replace a key", func(t *testing.T) { - stdout, _, err := defaultCmd.Exec(nil, "patch", "pc", project, "--format", "json", "--replace", `/namespaces=[{"name":"people", "id": 4}]`) - require.NoError(t, err) - assert.Equal(t, "people", gjson.Get(stdout, "namespaces.0.name").String(), stdout) + testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) + t.Run("explicit project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "pc", extraProject, "--format", "json", "--replace", `/namespaces=[{"name":"people", "id": 4}]`) + require.NoError(t, err) + assert.Equal(t, "people", gjson.Get(stdout, "namespaces.0.name").String(), stdout) + }) + t.Run("default project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "pc", "--format", "json", "--replace", `/namespaces=[{"name":"people", "id": 4}]`) + require.NoError(t, err) + assert.Equal(t, "people", gjson.Get(stdout, "namespaces.0.name").String(), stdout) + }) }) t.Run("fails if no opts are given", func(t *testing.T) { - stdout, _, err := defaultCmd.Exec(nil, "patch", "pc", project, "--format", "json") - require.Error(t, err, stdout) + testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) + t.Run("explicit project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "pc", extraProject, "--format", "json") + require.Error(t, err, stdout) + }) + t.Run("default project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "pc", "--format", "json") + require.Error(t, err, stdout) + }) }) } diff --git a/cmd/cloudx/project/patch_test.go b/cmd/cloudx/project/patch_test.go index 471115b2..26804c60 100644 --- a/cmd/cloudx/project/patch_test.go +++ b/cmd/cloudx/project/patch_test.go @@ -7,69 +7,139 @@ import ( "testing" "github.com/ory/cli/cmd/cloudx/testhelpers" - "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "github.com/tidwall/gjson" ) func TestPatchProject(t *testing.T) { - project := testhelpers.CreateProject(t, defaultConfig) t.Run("is able to replace a key", func(t *testing.T) { - stdout, _, err := defaultCmd.Exec(nil, "patch", "project", project, "--format", "json", "--replace", `/services/identity/config/selfservice/methods/password/enabled=false`) - require.NoError(t, err) - assert.False(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.password.enabled").Bool()) + testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) + t.Run("explicit project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "project", extraProject, "--format", "json", "--replace", `/services/identity/config/selfservice/methods/password/enabled=false`) + require.NoError(t, err) + assert.False(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.password.enabled").Bool()) + }) + t.Run("default project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "project", "--format", "json", "--replace", `/services/identity/config/selfservice/methods/password/enabled=false`) + require.NoError(t, err) + assert.False(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.password.enabled").Bool()) + }) }) t.Run("is able to add a key", func(t *testing.T) { - stdout, _, err := defaultCmd.Exec(nil, "patch", "project", project, "--format", "json", "--add", `/services/identity/config/selfservice/methods/password/enabled=false`) - require.NoError(t, err) - assert.False(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.password.enabled").Bool()) + testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) + t.Run("explicit project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "project", extraProject, "--format", "json", "--add", `/services/identity/config/selfservice/methods/password/enabled=false`) + require.NoError(t, err) + assert.False(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.password.enabled").Bool()) + }) + t.Run("default project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "project", "--format", "json", "--add", `/services/identity/config/selfservice/methods/password/enabled=false`) + require.NoError(t, err) + assert.False(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.password.enabled").Bool()) + }) }) t.Run("is able to add a key with string", func(t *testing.T) { - stdout, _, err := defaultCmd.Exec(nil, "patch", "project", project, "--format", "json", "--replace", "/services/identity/config/selfservice/flows/error/ui_url=\"https://example.com/error-ui\"") - require.NoError(t, err) - assert.Equal(t, "https://example.com/error-ui", gjson.Get(stdout, "services.identity.config.selfservice.flows.error.ui_url").String()) + testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) + t.Run("explicit project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "project", extraProject, "--format", "json", "--replace", "/services/identity/config/selfservice/flows/error/ui_url=\"https://example.com/error-ui\"") + require.NoError(t, err) + assert.Equal(t, "https://example.com/error-ui", gjson.Get(stdout, "services.identity.config.selfservice.flows.error.ui_url").String()) + }) + t.Run("default project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "project", "--format", "json", "--replace", "/services/identity/config/selfservice/flows/error/ui_url=\"https://example.com/error-ui\"") + require.NoError(t, err) + assert.Equal(t, "https://example.com/error-ui", gjson.Get(stdout, "services.identity.config.selfservice.flows.error.ui_url").String()) + }) }) t.Run("is able to add a key with raw json", func(t *testing.T) { - stdout, _, err := defaultCmd.Exec(nil, "patch", "project", project, "--format", "json", "--replace", `/services/identity/config/selfservice/flows/error={"ui_url":"https://example.org/error-ui"}`) - require.NoError(t, err) - assert.Equal(t, "https://example.org/error-ui", gjson.Get(stdout, "services.identity.config.selfservice.flows.error.ui_url").String()) + testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) + t.Run("explicit project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "project", extraProject, "--format", "json", "--replace", `/services/identity/config/selfservice/flows/error={"ui_url":"https://example.org/error-ui"}`) + require.NoError(t, err) + assert.Equal(t, "https://example.org/error-ui", gjson.Get(stdout, "services.identity.config.selfservice.flows.error.ui_url").String()) + }) + t.Run("default project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "project", "--format", "json", "--replace", `/services/identity/config/selfservice/flows/error={"ui_url":"https://example.org/error-ui"}`) + require.NoError(t, err) + assert.Equal(t, "https://example.org/error-ui", gjson.Get(stdout, "services.identity.config.selfservice.flows.error.ui_url").String()) + }) }) t.Run("is able to remove a key", func(t *testing.T) { - stdout, _, err := defaultCmd.Exec(nil, "patch", "project", project, "--format", "json", "--remove", `/services/identity/config/selfservice/methods/password/enabled`) - require.NoError(t, err) - assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.password.enabled").Bool()) + testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) + t.Run("explicit project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "project", extraProject, "--format", "json", "--remove", `/services/identity/config/selfservice/methods/password/enabled`) + require.NoError(t, err) + assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.password.enabled").Bool()) + }) + t.Run("default project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "project", "--format", "json", "--remove", `/services/identity/config/selfservice/methods/password/enabled`) + require.NoError(t, err) + assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.password.enabled").Bool()) + }) }) t.Run("fails if no opts are given", func(t *testing.T) { - stdout, _, err := defaultCmd.Exec(nil, "patch", "project", project, "--format", "json") - require.Error(t, err, stdout) + testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) + t.Run("explicit project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "project", extraProject, "--format", "json") + require.Error(t, err, stdout) + }) + t.Run("default project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "project", "--format", "json") + require.Error(t, err, stdout) + }) }) t.Run("is able to update several keys", func(t *testing.T) { - stdout, _, err := defaultCmd.Exec(nil, "patch", "project", project, "--format", "json", - "--replace", `/services/identity/config/selfservice/methods/link/enabled=true`, - "--replace", `/services/identity/config/selfservice/methods/oidc/enabled=true`, - "--remove", `/services/identity/config/selfservice/methods/profile/enabled`, - "--remove", `/services/identity/config/selfservice/methods/password/enabled`, - "--add", `/services/identity/config/selfservice/methods/totp/enabled=true`, - "--add", `/services/identity/config/selfservice/methods/lookup_secret/enabled=true`, - "-f", "fixtures/patch/1.json", - "-f", "fixtures/patch/2.json", - ) - require.NoError(t, err) - assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.password.enabled").Bool()) - assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.profile.enabled").Bool()) - assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.link.enabled").Bool()) - assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.oidc.enabled").Bool()) - assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.totp.enabled").Bool()) - assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.lookup_secret.enabled").Bool()) - assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.webauthn.enabled").Bool()) - assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.webauthn.config.passwordless").Bool()) - assert.Equal(t, "some value", gjson.Get(stdout, "services.identity.config.selfservice.methods.webauthn.config.rp.display_name").String()) + testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) + t.Run("explicit project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "project", extraProject, "--format", "json", + "--replace", `/services/identity/config/selfservice/methods/link/enabled=true`, + "--replace", `/services/identity/config/selfservice/methods/oidc/enabled=true`, + "--remove", `/services/identity/config/selfservice/methods/profile/enabled`, + "--remove", `/services/identity/config/selfservice/methods/password/enabled`, + "--add", `/services/identity/config/selfservice/methods/totp/enabled=true`, + "--add", `/services/identity/config/selfservice/methods/lookup_secret/enabled=true`, + "-f", "fixtures/patch/1.json", + "-f", "fixtures/patch/2.json", + ) + require.NoError(t, err) + assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.password.enabled").Bool()) + assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.profile.enabled").Bool()) + assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.link.enabled").Bool()) + assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.oidc.enabled").Bool()) + assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.totp.enabled").Bool()) + assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.lookup_secret.enabled").Bool()) + assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.webauthn.enabled").Bool()) + assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.webauthn.config.passwordless").Bool()) + assert.Equal(t, "some value", gjson.Get(stdout, "services.identity.config.selfservice.methods.webauthn.config.rp.display_name").String()) + }) + t.Run("default project", func(t *testing.T) { + stdout, _, err := defaultCmd.Exec(nil, "patch", "project", "--format", "json", + "--replace", `/services/identity/config/selfservice/methods/link/enabled=true`, + "--replace", `/services/identity/config/selfservice/methods/oidc/enabled=true`, + "--remove", `/services/identity/config/selfservice/methods/profile/enabled`, + "--remove", `/services/identity/config/selfservice/methods/password/enabled`, + "--add", `/services/identity/config/selfservice/methods/totp/enabled=true`, + "--add", `/services/identity/config/selfservice/methods/lookup_secret/enabled=true`, + "-f", "fixtures/patch/1.json", + "-f", "fixtures/patch/2.json", + ) + require.NoError(t, err) + assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.password.enabled").Bool()) + assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.profile.enabled").Bool()) + assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.link.enabled").Bool()) + assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.oidc.enabled").Bool()) + assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.totp.enabled").Bool()) + assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.lookup_secret.enabled").Bool()) + assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.webauthn.enabled").Bool()) + assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.webauthn.config.passwordless").Bool()) + assert.Equal(t, "some value", gjson.Get(stdout, "services.identity.config.selfservice.methods.webauthn.config.rp.display_name").String()) + }) }) } diff --git a/cmd/cloudx/project/update.go b/cmd/cloudx/project/update.go index 7738ebc6..14b1a75c 100644 --- a/cmd/cloudx/project/update.go +++ b/cmd/cloudx/project/update.go @@ -18,8 +18,8 @@ import ( func NewProjectsUpdateCmd() *cobra.Command { cmd := &cobra.Command{ - Use: "project ", - Args: cobra.ExactArgs(1), + Use: "project [id]", + Args: cobra.MaximumNArgs(1), Short: "Update Ory Network project service configuration", Example: `$ ory update project ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 \ --name \"my updated name\" \ @@ -121,7 +121,15 @@ func runUpdate(filePrefixer func([]json.RawMessage) ([]json.RawMessage, error), if n := cmd.Flags().Lookup("name"); n != nil { name = n.Value.String() } - p, err := h.UpdateProject(args[0], name, configs) + var id string + if len(args) == 0 { + if id, err = h.GetDefaultProjectID(); err != nil { + return cmdx.PrintOpenAPIError(cmd, err) + } + } else { + id = args[0] + } + p, err := h.UpdateProject(id, name, configs) if err != nil { return cmdx.PrintOpenAPIError(cmd, err) } diff --git a/cmd/cloudx/project/update_identity_config.go b/cmd/cloudx/project/update_identity_config.go index 042070a2..0e8cbace 100644 --- a/cmd/cloudx/project/update_identity_config.go +++ b/cmd/cloudx/project/update_identity_config.go @@ -12,12 +12,12 @@ import ( func NewUpdateIdentityConfigCmd() *cobra.Command { cmd := &cobra.Command{ - Use: "identity-config ", + Use: "identity-config [project-id]", Aliases: []string{ "ic", "kratos-config", }, - Args: cobra.ExactArgs(1), + Args: cobra.MaximumNArgs(1), Short: "Update the Ory Identities configuration of the specified Ory Network project.", Example: `$ ory update identity-config ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 \ --file /path/to/config.json \ diff --git a/cmd/cloudx/project/update_namespace_config.go b/cmd/cloudx/project/update_namespace_config.go index c3e8d265..aef59115 100644 --- a/cmd/cloudx/project/update_namespace_config.go +++ b/cmd/cloudx/project/update_namespace_config.go @@ -44,7 +44,11 @@ class Example implements Namespace {} patch := fmt.Sprintf(`/services/permission/config/namespaces={"location": "base64://%s"}`, base64.StdEncoding.EncodeToString(data)) - project, err := h.GetProject(flagx.MustGetString(cmd, "project")) + projectOrSlug, err := client.ProjectOrDefault(cmd, h) + if err != nil { + return err + } + project, err := h.GetProject(projectOrSlug) if err != nil { return err } diff --git a/cmd/cloudx/project/update_namespace_config_test.go b/cmd/cloudx/project/update_namespace_config_test.go index 6e92ed95..2b8d5b67 100644 --- a/cmd/cloudx/project/update_namespace_config_test.go +++ b/cmd/cloudx/project/update_namespace_config_test.go @@ -33,23 +33,37 @@ func writeFile(t *testing.T, content string) (path string) { } func TestUpdateNamespaceConfig(t *testing.T) { - project := testhelpers.CreateProject(t, defaultConfig) content := `class Default implements Namespace {}` config := writeFile(t, content) verbs := []string{"update", "patch"} for _, verb := range verbs { t.Run(fmt.Sprintf("is able to %q the namespace config", verb), func(t *testing.T) { - stdout, stderr, err := defaultCmd.Exec(nil, verb, "opl", "--project", project, "--format", "json", "--file", config) - require.NoError(t, err, stderr) - - if !testing.Short() { - // Don't download and compare the config in short mode, might not have internet everywhere - url := gjson.Get(stdout, "namespaces.location").String() - data, err := fetcher.NewFetcher().Fetch(url) - require.NoError(t, err, "could not download the config") - assert.Equal(t, content, data.String(), "the downloaded file does not match what we uploaded") - } + testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) + t.Run("explicit project", func(t *testing.T) { + stdout, stderr, err := defaultCmd.Exec(nil, verb, "opl", "--project", extraProject, "--format", "json", "--file", config) + require.NoError(t, err, stderr) + + if !testing.Short() { + // Don't download and compare the config in short mode, might not have internet everywhere + url := gjson.Get(stdout, "namespaces.location").String() + data, err := fetcher.NewFetcher().Fetch(url) + require.NoError(t, err, "could not download the config") + assert.Equal(t, content, data.String(), "the downloaded file does not match what we uploaded") + } + }) + t.Run("default project", func(t *testing.T) { + stdout, stderr, err := defaultCmd.Exec(nil, verb, "opl", "--format", "json", "--file", config) + require.NoError(t, err, stderr) + + if !testing.Short() { + // Don't download and compare the config in short mode, might not have internet everywhere + url := gjson.Get(stdout, "namespaces.location").String() + data, err := fetcher.NewFetcher().Fetch(url) + require.NoError(t, err, "could not download the config") + assert.Equal(t, content, data.String(), "the downloaded file does not match what we uploaded") + } + }) }) } } diff --git a/cmd/cloudx/project/update_oauth2_config.go b/cmd/cloudx/project/update_oauth2_config.go index 0d1db9a2..bdfcf7fa 100644 --- a/cmd/cloudx/project/update_oauth2_config.go +++ b/cmd/cloudx/project/update_oauth2_config.go @@ -13,12 +13,12 @@ import ( func NewUpdateOAuth2ConfigCmd() *cobra.Command { cmd := &cobra.Command{ - Use: "oauth2-config ", + Use: "oauth2-config [project-id]", Aliases: []string{ "oc", "hydra-config", }, - Args: cobra.ExactArgs(1), + Args: cobra.MaximumNArgs(1), Short: "Update the Ory OAuth2 & OpenID Connect configuration of the specified Ory Network project.", Example: `$ ory update oauth2-config ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 \ --file /path/to/config.json \ diff --git a/cmd/cloudx/project/update_permission_config.go b/cmd/cloudx/project/update_permission_config.go index 190a92b9..ff270624 100644 --- a/cmd/cloudx/project/update_permission_config.go +++ b/cmd/cloudx/project/update_permission_config.go @@ -12,12 +12,12 @@ import ( func NewUpdatePermissionConfigCmd() *cobra.Command { cmd := &cobra.Command{ - Use: "permission-config ", + Use: "permission-config [project-id]", Aliases: []string{ "pc", "keto-config", }, - Args: cobra.ExactArgs(1), + Args: cobra.MaximumNArgs(1), Short: "Update Ory Permissions configuration of the specified Ory Network project.", Example: `$ ory update permission-config ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 \ --file /path/to/config.json \ diff --git a/cmd/cloudx/testhelpers/testhelpers.go b/cmd/cloudx/testhelpers/testhelpers.go index f20e1529..da201275 100644 --- a/cmd/cloudx/testhelpers/testhelpers.go +++ b/cmd/cloudx/testhelpers/testhelpers.go @@ -168,6 +168,16 @@ func CreateProject(t require.TestingT, configDir string) string { return id } +func SetDefaultProject(t require.TestingT, configDir string, projectId string) { + cmd := ConfigAwareCmd(configDir) + stdout, stderr, err := cmd.Exec(nil, "use", "project", projectId, "--format", "json") + require.NoError(t, err, "stdout: %s\nstderr: %s", stderr) + ac := ReadConfig(t, configDir) + id := gjson.Get(stdout, "id").String() + assert.Equal(t, ac.SelectedProject.String(), id) + assert.Equal(t, projectId, id) +} + func MakeRandomIdentity(t require.TestingT, email string) string { homeDir, err := os.MkdirTemp(os.TempDir(), "cloudx-*") require.NoError(t, err) From 14ad4ba8237123c5eaca5fef516505e1a5ff3eb5 Mon Sep 17 00:00:00 2001 From: Henning Fleischhauer <18215579+CaptainStandby@users.noreply.github.com> Date: Wed, 28 Dec 2022 19:20:54 +0100 Subject: [PATCH 07/18] tests --- cmd/cloudx/client/handler_test.go | 31 ++++++++++++++++++- cmd/cloudx/project/get_test.go | 16 ++++++++++ cmd/cloudx/project/output.go | 26 ++++++++++++++++ .../project/patch_identity_config_test.go | 16 ++++++++++ .../project/patch_oauth2_config_test.go | 16 ++++++++++ .../project/patch_permission_config_test.go | 16 ++++++++++ cmd/cloudx/project/patch_test.go | 28 +++++++++++++++++ .../project/update_namespace_config_test.go | 4 +++ cmd/cloudx/project/use.go | 24 ++------------ cmd/cloudx/project/use_test.go | 30 ++++++++++++++++++ cmd/cloudx/testhelpers/testhelpers.go | 10 ++++++ 11 files changed, 194 insertions(+), 23 deletions(-) create mode 100644 cmd/cloudx/project/use_test.go diff --git a/cmd/cloudx/client/handler_test.go b/cmd/cloudx/client/handler_test.go index ef84da22..a4b25027 100644 --- a/cmd/cloudx/client/handler_test.go +++ b/cmd/cloudx/client/handler_test.go @@ -58,6 +58,36 @@ func TestCommandHelper(t *testing.T) { return ¬YetLoggedIn } + t.Run("func=SetDefaultProject", func(t *testing.T) { + configDir := testhelpers.NewConfigDir(t) + testhelpers.RegisterAccount(t, configDir) + otherId := testhelpers.CreateProject(t, configDir) + defaultId := testhelpers.CreateProject(t, configDir) + testhelpers.SetDefaultProject(t, configDir, defaultId) + + cmd_base := &client.CommandHelper{ + ConfigLocation: configDir, + NoConfirm: true, + IsQuiet: false, + VerboseWriter: io.Discard, + VerboseErrWriter: io.Discard, + Ctx: context.Background(), + } + + t.Run("can change the selected project", func(t *testing.T) { + cmd := *cmd_base + current, _ := cmd.GetDefaultProjectID() + assert.Equal(t, current, defaultId) + + err := cmd.SetDefaultProject(otherId) + assert.NoError(t, err) + + selected, err := cmd.GetDefaultProjectID() + assert.NoError(t, err) + assert.Equal(t, selected, otherId) + }) + }) + t.Run("func=ListProjects", func(t *testing.T) { configDir := testhelpers.NewConfigDir(t) testhelpers.RegisterAccount(t, configDir) @@ -98,7 +128,6 @@ func TestCommandHelper(t *testing.T) { assert.Contains(t, listedIds, project1.Id) assert.Contains(t, listedIds, project2.Id) }) - }) t.Run("func=CreateProject", func(t *testing.T) { diff --git a/cmd/cloudx/project/get_test.go b/cmd/cloudx/project/get_test.go index 62f3f131..caf3ce87 100644 --- a/cmd/cloudx/project/get_test.go +++ b/cmd/cloudx/project/get_test.go @@ -15,12 +15,16 @@ import ( func TestGetProject(t *testing.T) { testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) t.Run("is able to get project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "get", "project", extraProject, "--format", "json") require.NoError(t, err) assert.Equal(t, extraProject, gjson.Get(stdout, "id").String()) assert.NotEmpty(t, gjson.Get(stdout, "slug").String()) }) t.Run("is able to get default project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "get", "project", "--format", "json") require.NoError(t, err) assert.Equal(t, defaultProject, gjson.Get(stdout, "id").String()) @@ -32,11 +36,15 @@ func TestGetServiceConfig(t *testing.T) { t.Run("service=kratos", func(t *testing.T) { testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) t.Run("explicit project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "get", "kratos-config", defaultProject, "--format", "json") require.NoError(t, err) assert.True(t, gjson.Get(stdout, "selfservice.flows.error.ui_url").Exists()) }) t.Run("default project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "get", "kratos-config", "--format", "json") require.NoError(t, err) assert.True(t, gjson.Get(stdout, "selfservice.flows.error.ui_url").Exists()) @@ -46,11 +54,15 @@ func TestGetServiceConfig(t *testing.T) { t.Run("service=keto", func(t *testing.T) { testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) t.Run("explicit project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "get", "keto-config", defaultProject, "--format", "json") require.NoError(t, err) assert.True(t, gjson.Get(stdout, "namespaces").Exists(), stdout) }) t.Run("default project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "get", "keto-config", "--format", "json") require.NoError(t, err) assert.True(t, gjson.Get(stdout, "namespaces").Exists(), stdout) @@ -60,11 +72,15 @@ func TestGetServiceConfig(t *testing.T) { t.Run("service=hydra", func(t *testing.T) { testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) t.Run("explicit project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "get", "oauth2-config", defaultProject, "--format", "json") require.NoError(t, err) assert.True(t, gjson.Get(stdout, "oauth2").Exists(), stdout) }) t.Run("default project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "get", "oauth2-config", "--format", "json") require.NoError(t, err) assert.True(t, gjson.Get(stdout, "oauth2").Exists(), stdout) diff --git a/cmd/cloudx/project/output.go b/cmd/cloudx/project/output.go index 16900e26..9549d926 100644 --- a/cmd/cloudx/project/output.go +++ b/cmd/cloudx/project/output.go @@ -71,3 +71,29 @@ func (c *outputProjectCollection) Interface() interface{} { func (c *outputProjectCollection) Len() int { return len(c.projects) } + +type selectedProject struct { + Id string `json:"id"` +} + +func (i selectedProject) String() string { + return i.Id +} + +func (i *selectedProject) ID() string { + return i.Id +} + +func (*selectedProject) Header() []string { + return []string{"ID"} +} + +func (i *selectedProject) Columns() []string { + return []string{ + i.Id, + } +} + +func (i *selectedProject) Interface() interface{} { + return i +} diff --git a/cmd/cloudx/project/patch_identity_config_test.go b/cmd/cloudx/project/patch_identity_config_test.go index ba2d4f44..1e578a1e 100644 --- a/cmd/cloudx/project/patch_identity_config_test.go +++ b/cmd/cloudx/project/patch_identity_config_test.go @@ -16,11 +16,15 @@ func TestPatchKratosConfig(t *testing.T) { t.Run("is able to replace a key", func(t *testing.T) { testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) t.Run("explicit project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "kratos-config", extraProject, "--format", "json", "--replace", `/selfservice/methods/password/enabled=false`) require.NoError(t, err) assert.False(t, gjson.Get(stdout, "selfservice.methods.password.enabled").Bool()) }) t.Run("default project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "kratos-config", "--format", "json", "--replace", `/selfservice/methods/password/enabled=false`) require.NoError(t, err) assert.False(t, gjson.Get(stdout, "selfservice.methods.password.enabled").Bool()) @@ -30,11 +34,15 @@ func TestPatchKratosConfig(t *testing.T) { t.Run("is able to add a key", func(t *testing.T) { testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) t.Run("explicit project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "identity-config", extraProject, "--format", "json", "--add", `/selfservice/methods/password/enabled=false`) require.NoError(t, err) assert.False(t, gjson.Get(stdout, "selfservice.methods.password.enabled").Bool()) }) t.Run("default project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "identity-config", "--format", "json", "--add", `/selfservice/methods/password/enabled=false`) require.NoError(t, err) assert.False(t, gjson.Get(stdout, "selfservice.methods.password.enabled").Bool()) @@ -44,11 +52,15 @@ func TestPatchKratosConfig(t *testing.T) { t.Run("is able to add a key with string", func(t *testing.T) { testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) t.Run("explicit project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "ic", extraProject, "--format", "json", "--replace", "/selfservice/flows/error/ui_url=\"https://example.com/error-ui\"") require.NoError(t, err) assert.Equal(t, "https://example.com/error-ui", gjson.Get(stdout, "selfservice.flows.error.ui_url").String()) }) t.Run("default project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "ic", "--format", "json", "--replace", "/selfservice/flows/error/ui_url=\"https://example.com/error-ui\"") require.NoError(t, err) assert.Equal(t, "https://example.com/error-ui", gjson.Get(stdout, "selfservice.flows.error.ui_url").String()) @@ -58,10 +70,14 @@ func TestPatchKratosConfig(t *testing.T) { t.Run("fails if no opts are given", func(t *testing.T) { testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) t.Run("explicit project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "ic", extraProject, "--format", "json") require.Error(t, err, stdout) }) t.Run("default project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "ic", "--format", "json") require.Error(t, err, stdout) }) diff --git a/cmd/cloudx/project/patch_oauth2_config_test.go b/cmd/cloudx/project/patch_oauth2_config_test.go index 490d6ed3..683c10f5 100644 --- a/cmd/cloudx/project/patch_oauth2_config_test.go +++ b/cmd/cloudx/project/patch_oauth2_config_test.go @@ -16,11 +16,15 @@ func TestPatchHydraConfig(t *testing.T) { t.Run("is able to replace a key", func(t *testing.T) { testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) t.Run("explicit project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "hydra-config", extraProject, "--format", "json", "--replace", `/strategies/access_token="jwt"`) require.NoError(t, err) assert.Equal(t, "jwt", gjson.Get(stdout, "strategies.access_token").String()) }) t.Run("default project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "hydra-config", "--format", "json", "--replace", `/strategies/access_token="jwt"`) require.NoError(t, err) assert.Equal(t, "jwt", gjson.Get(stdout, "strategies.access_token").String()) @@ -30,11 +34,15 @@ func TestPatchHydraConfig(t *testing.T) { t.Run("is able to add a key", func(t *testing.T) { testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) t.Run("explicit project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "oauth2-config", extraProject, "--format", "json", "--add", `/ttl/login_consent_request="1h"`) require.NoError(t, err) assert.Equal(t, "1h0m0s", gjson.Get(stdout, "ttl.login_consent_request").String()) }) t.Run("default project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "oauth2-config", "--format", "json", "--add", `/ttl/login_consent_request="1h"`) require.NoError(t, err) assert.Equal(t, "1h0m0s", gjson.Get(stdout, "ttl.login_consent_request").String()) @@ -44,11 +52,15 @@ func TestPatchHydraConfig(t *testing.T) { t.Run("is able to add a key with string", func(t *testing.T) { testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) t.Run("explicit project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "oc", extraProject, "--format", "json", "--replace", `/ttl/refresh_token="2h"`) require.NoError(t, err) assert.Equal(t, "2h0m0s", gjson.Get(stdout, "ttl.refresh_token").String()) }) t.Run("default project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "oc", "--format", "json", "--replace", `/ttl/refresh_token="2h"`) require.NoError(t, err) assert.Equal(t, "2h0m0s", gjson.Get(stdout, "ttl.refresh_token").String()) @@ -58,10 +70,14 @@ func TestPatchHydraConfig(t *testing.T) { t.Run("fails if no opts are given", func(t *testing.T) { testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) t.Run("explicit project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "oc", extraProject, "--format", "json") require.Error(t, err, stdout) }) t.Run("default project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "oc", "--format", "json") require.Error(t, err, stdout) }) diff --git a/cmd/cloudx/project/patch_permission_config_test.go b/cmd/cloudx/project/patch_permission_config_test.go index c0906d96..07ae5c6f 100644 --- a/cmd/cloudx/project/patch_permission_config_test.go +++ b/cmd/cloudx/project/patch_permission_config_test.go @@ -16,11 +16,15 @@ func TestPatchPermissionConfig(t *testing.T) { t.Run("is able to replace a key", func(t *testing.T) { testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) t.Run("explicit project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "keto-config", extraProject, "--format", "json", "--add", `/namespaces=[{"name":"files", "id": 2}]`) require.NoError(t, err) assert.Equal(t, "files", gjson.Get(stdout, "namespaces.0.name").String(), stdout) }) t.Run("default project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "keto-config", "--format", "json", "--add", `/namespaces=[{"name":"files", "id": 2}]`) require.NoError(t, err) assert.Equal(t, "files", gjson.Get(stdout, "namespaces.0.name").String(), stdout) @@ -30,11 +34,15 @@ func TestPatchPermissionConfig(t *testing.T) { t.Run("is able to add a key using permission-config", func(t *testing.T) { testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) t.Run("explicit project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "permission-config", extraProject, "--format", "json", "--add", `/namespaces/1={"name":"docs", "id": 3}`) require.NoError(t, err) assert.Equal(t, "docs", gjson.Get(stdout, "namespaces.1.name").String(), stdout) }) t.Run("default project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "permission-config", "--format", "json", "--add", `/namespaces/1={"name":"docs", "id": 3}`) require.NoError(t, err) assert.Equal(t, "docs", gjson.Get(stdout, "namespaces.1.name").String(), stdout) @@ -44,11 +52,15 @@ func TestPatchPermissionConfig(t *testing.T) { t.Run("is able to replace a key", func(t *testing.T) { testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) t.Run("explicit project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "pc", extraProject, "--format", "json", "--replace", `/namespaces=[{"name":"people", "id": 4}]`) require.NoError(t, err) assert.Equal(t, "people", gjson.Get(stdout, "namespaces.0.name").String(), stdout) }) t.Run("default project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "pc", "--format", "json", "--replace", `/namespaces=[{"name":"people", "id": 4}]`) require.NoError(t, err) assert.Equal(t, "people", gjson.Get(stdout, "namespaces.0.name").String(), stdout) @@ -58,10 +70,14 @@ func TestPatchPermissionConfig(t *testing.T) { t.Run("fails if no opts are given", func(t *testing.T) { testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) t.Run("explicit project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "pc", extraProject, "--format", "json") require.Error(t, err, stdout) }) t.Run("default project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "pc", "--format", "json") require.Error(t, err, stdout) }) diff --git a/cmd/cloudx/project/patch_test.go b/cmd/cloudx/project/patch_test.go index 26804c60..9676634c 100644 --- a/cmd/cloudx/project/patch_test.go +++ b/cmd/cloudx/project/patch_test.go @@ -16,11 +16,15 @@ func TestPatchProject(t *testing.T) { t.Run("is able to replace a key", func(t *testing.T) { testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) t.Run("explicit project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "project", extraProject, "--format", "json", "--replace", `/services/identity/config/selfservice/methods/password/enabled=false`) require.NoError(t, err) assert.False(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.password.enabled").Bool()) }) t.Run("default project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "project", "--format", "json", "--replace", `/services/identity/config/selfservice/methods/password/enabled=false`) require.NoError(t, err) assert.False(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.password.enabled").Bool()) @@ -30,11 +34,15 @@ func TestPatchProject(t *testing.T) { t.Run("is able to add a key", func(t *testing.T) { testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) t.Run("explicit project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "project", extraProject, "--format", "json", "--add", `/services/identity/config/selfservice/methods/password/enabled=false`) require.NoError(t, err) assert.False(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.password.enabled").Bool()) }) t.Run("default project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "project", "--format", "json", "--add", `/services/identity/config/selfservice/methods/password/enabled=false`) require.NoError(t, err) assert.False(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.password.enabled").Bool()) @@ -44,11 +52,15 @@ func TestPatchProject(t *testing.T) { t.Run("is able to add a key with string", func(t *testing.T) { testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) t.Run("explicit project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "project", extraProject, "--format", "json", "--replace", "/services/identity/config/selfservice/flows/error/ui_url=\"https://example.com/error-ui\"") require.NoError(t, err) assert.Equal(t, "https://example.com/error-ui", gjson.Get(stdout, "services.identity.config.selfservice.flows.error.ui_url").String()) }) t.Run("default project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "project", "--format", "json", "--replace", "/services/identity/config/selfservice/flows/error/ui_url=\"https://example.com/error-ui\"") require.NoError(t, err) assert.Equal(t, "https://example.com/error-ui", gjson.Get(stdout, "services.identity.config.selfservice.flows.error.ui_url").String()) @@ -58,11 +70,15 @@ func TestPatchProject(t *testing.T) { t.Run("is able to add a key with raw json", func(t *testing.T) { testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) t.Run("explicit project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "project", extraProject, "--format", "json", "--replace", `/services/identity/config/selfservice/flows/error={"ui_url":"https://example.org/error-ui"}`) require.NoError(t, err) assert.Equal(t, "https://example.org/error-ui", gjson.Get(stdout, "services.identity.config.selfservice.flows.error.ui_url").String()) }) t.Run("default project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "project", "--format", "json", "--replace", `/services/identity/config/selfservice/flows/error={"ui_url":"https://example.org/error-ui"}`) require.NoError(t, err) assert.Equal(t, "https://example.org/error-ui", gjson.Get(stdout, "services.identity.config.selfservice.flows.error.ui_url").String()) @@ -72,11 +88,15 @@ func TestPatchProject(t *testing.T) { t.Run("is able to remove a key", func(t *testing.T) { testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) t.Run("explicit project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "project", extraProject, "--format", "json", "--remove", `/services/identity/config/selfservice/methods/password/enabled`) require.NoError(t, err) assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.password.enabled").Bool()) }) t.Run("default project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "project", "--format", "json", "--remove", `/services/identity/config/selfservice/methods/password/enabled`) require.NoError(t, err) assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.password.enabled").Bool()) @@ -86,10 +106,14 @@ func TestPatchProject(t *testing.T) { t.Run("fails if no opts are given", func(t *testing.T) { testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) t.Run("explicit project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "project", extraProject, "--format", "json") require.Error(t, err, stdout) }) t.Run("default project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "project", "--format", "json") require.Error(t, err, stdout) }) @@ -98,6 +122,8 @@ func TestPatchProject(t *testing.T) { t.Run("is able to update several keys", func(t *testing.T) { testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) t.Run("explicit project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "project", extraProject, "--format", "json", "--replace", `/services/identity/config/selfservice/methods/link/enabled=true`, "--replace", `/services/identity/config/selfservice/methods/oidc/enabled=true`, @@ -120,6 +146,8 @@ func TestPatchProject(t *testing.T) { assert.Equal(t, "some value", gjson.Get(stdout, "services.identity.config.selfservice.methods.webauthn.config.rp.display_name").String()) }) t.Run("default project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, _, err := defaultCmd.Exec(nil, "patch", "project", "--format", "json", "--replace", `/services/identity/config/selfservice/methods/link/enabled=true`, "--replace", `/services/identity/config/selfservice/methods/oidc/enabled=true`, diff --git a/cmd/cloudx/project/update_namespace_config_test.go b/cmd/cloudx/project/update_namespace_config_test.go index 2b8d5b67..2ae0fe1c 100644 --- a/cmd/cloudx/project/update_namespace_config_test.go +++ b/cmd/cloudx/project/update_namespace_config_test.go @@ -41,6 +41,8 @@ func TestUpdateNamespaceConfig(t *testing.T) { t.Run(fmt.Sprintf("is able to %q the namespace config", verb), func(t *testing.T) { testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) t.Run("explicit project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, stderr, err := defaultCmd.Exec(nil, verb, "opl", "--project", extraProject, "--format", "json", "--file", config) require.NoError(t, err, stderr) @@ -53,6 +55,8 @@ func TestUpdateNamespaceConfig(t *testing.T) { } }) t.Run("default project", func(t *testing.T) { + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + stdout, stderr, err := defaultCmd.Exec(nil, verb, "opl", "--format", "json", "--file", config) require.NoError(t, err, stderr) diff --git a/cmd/cloudx/project/use.go b/cmd/cloudx/project/use.go index 571297e8..4116b1be 100644 --- a/cmd/cloudx/project/use.go +++ b/cmd/cloudx/project/use.go @@ -18,26 +18,11 @@ func NewUseProjectCmd() *cobra.Command { Example: `$ ory use project ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 ID ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 -SLUG good-wright-t7kzy3vugf -STATE running -NAME Example Project $ ory use project ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 --format json { - "name": "Example Project", - "identity": { - "services": { - "config": { - "courier": { - "smtp": { - "from_name": "..." - } - // ... - } - } - } - } + "id": "ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 }`, RunE: func(cmd *cobra.Command, args []string) error { h, err := client.NewCommandHelper(cmd) @@ -58,12 +43,7 @@ $ ory use project ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 --format json } } - project, err := h.GetProject(id) - if err != nil { - return cmdx.PrintOpenAPIError(cmd, err) - } - - cmdx.PrintRow(cmd, (*outputProject)(project)) + cmdx.PrintRow(cmd, &selectedProject{Id: id}) return nil }, } diff --git a/cmd/cloudx/project/use_test.go b/cmd/cloudx/project/use_test.go new file mode 100644 index 00000000..0fe942ff --- /dev/null +++ b/cmd/cloudx/project/use_test.go @@ -0,0 +1,30 @@ +// Copyright © 2022 Ory Corp +// SPDX-License-Identifier: Apache-2.0 + +package project_test + +import ( + "testing" + + "github.com/ory/cli/cmd/cloudx/testhelpers" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "github.com/tidwall/gjson" +) + +func TestUseProject(t *testing.T) { + t.Run("is able to use project", func(t *testing.T) { + testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) + + stdout, _, err := defaultCmd.Exec(nil, "use", "project", extraProject, "--format", "json") + require.NoError(t, err) + assert.Equal(t, extraProject, gjson.Get(stdout, "id").String()) + }) + t.Run("is able to print default project", func(t *testing.T) { + testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) + + stdout, _, err := defaultCmd.Exec(nil, "use", "project", "--format", "json") + require.NoError(t, err) + assert.Equal(t, defaultProject, gjson.Get(stdout, "id").String()) + }) +} diff --git a/cmd/cloudx/testhelpers/testhelpers.go b/cmd/cloudx/testhelpers/testhelpers.go index da201275..37ffff48 100644 --- a/cmd/cloudx/testhelpers/testhelpers.go +++ b/cmd/cloudx/testhelpers/testhelpers.go @@ -178,6 +178,16 @@ func SetDefaultProject(t require.TestingT, configDir string, projectId string) { assert.Equal(t, projectId, id) } +func GetDefaultProject(t require.TestingT, configDir string) string { + cmd := ConfigAwareCmd(configDir) + stdout, stderr, err := cmd.Exec(nil, "use", "project", "--format", "json") + require.NoError(t, err, "stdout: %s\nstderr: %s", stderr) + ac := ReadConfig(t, configDir) + id := gjson.Get(stdout, "id").String() + assert.Equal(t, ac.SelectedProject.String(), id) + return id +} + func MakeRandomIdentity(t require.TestingT, email string) string { homeDir, err := os.MkdirTemp(os.TempDir(), "cloudx-*") require.NoError(t, err) From cdc207c4a43c34a467f5cda5b6a9ac9a8f90b13c Mon Sep 17 00:00:00 2001 From: Henning Fleischhauer <18215579+CaptainStandby@users.noreply.github.com> Date: Wed, 28 Dec 2022 20:03:15 +0100 Subject: [PATCH 08/18] explicit set default project on create --- cmd/cloudx/client/handler.go | 24 ++++++++++++++++++++--- cmd/cloudx/client/handler_test.go | 12 ++++++------ cmd/cloudx/project/create.go | 4 +++- cmd/cloudx/project/create_test.go | 28 +++++++++++++++++++++++---- cmd/cloudx/testhelpers/testhelpers.go | 9 +++++++++ 5 files changed, 63 insertions(+), 14 deletions(-) diff --git a/cmd/cloudx/client/handler.go b/cmd/cloudx/client/handler.go index ab1fcc02..e8c863f8 100644 --- a/cmd/cloudx/client/handler.go +++ b/cmd/cloudx/client/handler.go @@ -515,6 +515,10 @@ func (h *CommandHelper) ListProjects() ([]cloud.ProjectMetadata, error) { return nil, handleError("unable to list projects", res, err) } + if def, _ := h.GetDefaultProjectID(); def == "" && len(projects) > 0 { + h.SetDefaultProject(projects[0].Id) + } + return projects, nil } @@ -560,10 +564,14 @@ func (h *CommandHelper) GetProject(projectOrSlug string) (*cloud.Project, error) return nil, handleError("unable to get project", res, err) } + if def, _ := h.GetDefaultProjectID(); def == "" { + h.SetDefaultProject(project.Id) + } + return project, nil } -func (h *CommandHelper) CreateProject(name string) (*cloud.Project, error) { +func (h *CommandHelper) CreateProject(name string, setDefault bool) (*cloud.Project, error) { ac, err := h.EnsureContext() if err != nil { return nil, err @@ -579,8 +587,8 @@ func (h *CommandHelper) CreateProject(name string) (*cloud.Project, error) { return nil, handleError("unable to list projects", res, err) } - if err := h.SetDefaultProject(project.Id); err != nil { - return nil, err + if def, _ := h.GetDefaultProjectID(); setDefault || def == "" { + h.SetDefaultProject(project.Id) } return project, nil @@ -670,6 +678,11 @@ func (h *CommandHelper) PatchProject(id string, raw []json.RawMessage, add, repl if err != nil { return nil, err } + + if def, _ := h.GetDefaultProjectID(); def == "" { + h.SetDefaultProject(id) + } + return res, nil } @@ -740,6 +753,11 @@ func (h *CommandHelper) UpdateProject(id string, name string, configs []json.Raw if err != nil { return nil, err } + + if def, _ := h.GetDefaultProjectID(); def == "" { + h.SetDefaultProject(id) + } + return res, nil } diff --git a/cmd/cloudx/client/handler_test.go b/cmd/cloudx/client/handler_test.go index a4b25027..905676b5 100644 --- a/cmd/cloudx/client/handler_test.go +++ b/cmd/cloudx/client/handler_test.go @@ -115,9 +115,9 @@ func TestCommandHelper(t *testing.T) { project_name1 := "new_project_name1" project_name2 := "new_project_name2" - project1, err := cmd.CreateProject(project_name1) + project1, err := cmd.CreateProject(project_name1, false) require.NoError(t, err) - project2, err := cmd.CreateProject(project_name2) + project2, err := cmd.CreateProject(project_name2, false) require.NoError(t, err) projects, err := cmd.ListProjects() @@ -147,7 +147,7 @@ func TestCommandHelper(t *testing.T) { cmd := *cmd_base project_name := "new_project_name" - project, err := cmd.CreateProject(project_name) + project, err := cmd.CreateProject(project_name, true) require.NoError(t, err) assert.Equal(t, project.Name, project_name) @@ -161,10 +161,10 @@ func TestCommandHelper(t *testing.T) { project_name1 := "new_project_name1" project_name2 := "new_project_name2" - project1, err := cmd.CreateProject(project_name1) + project1, err := cmd.CreateProject(project_name1, true) require.NoError(t, err) - project2, err := cmd.CreateProject(project_name2) + project2, err := cmd.CreateProject(project_name2, false) require.NoError(t, err) assert.NotEqual(t, project1.Id, project2.Id) @@ -173,7 +173,7 @@ func TestCommandHelper(t *testing.T) { defaultId, err := cmd.GetDefaultProjectID() require.NoError(t, err) - assert.Equal(t, project2.Id, defaultId) + assert.Equal(t, project1.Id, defaultId) }) }) diff --git a/cmd/cloudx/project/create.go b/cmd/cloudx/project/create.go index 7d5a960f..0f995321 100644 --- a/cmd/cloudx/project/create.go +++ b/cmd/cloudx/project/create.go @@ -39,7 +39,8 @@ func NewCreateProjectCmd() *cobra.Command { } } - p, err := h.CreateProject(name) + use := flagx.MustGetBool(cmd, "use-project") + p, err := h.CreateProject(name, use) if err != nil { return cmdx.PrintOpenAPIError(cmd, err) } @@ -51,6 +52,7 @@ func NewCreateProjectCmd() *cobra.Command { } cmd.Flags().StringP("name", "n", "", "The name of the project, required when quiet mode is used") + cmd.Flags().BoolP("use-project", "", false, "Uses the created project as default.") cmdx.RegisterFormatFlags(cmd.Flags()) return cmd } diff --git a/cmd/cloudx/project/create_test.go b/cmd/cloudx/project/create_test.go index 2409206b..b55dfd38 100644 --- a/cmd/cloudx/project/create_test.go +++ b/cmd/cloudx/project/create_test.go @@ -16,18 +16,38 @@ import ( ) func TestCreateProject(t *testing.T) { + parseOutput := func(stdout string) (id string, slug string, name string) { + id = gjson.Get(stdout, "id").String() + slug = gjson.Get(stdout, "slug").String() + name = gjson.Get(stdout, "name").String() + return + } assertResult := func(t *testing.T, configDir string, stdout string, expectedName string) { - ac := testhelpers.ReadConfig(t, configDir) - assert.Equal(t, gjson.Get(stdout, "id").String(), ac.SelectedProject.String(), stdout) - assert.NotEmpty(t, gjson.Get(stdout, "slug").String(), stdout) - assert.Equal(t, expectedName, gjson.Get(stdout, "name").String(), stdout) + _, slug, name := parseOutput(stdout) + assert.NotEmpty(t, slug, stdout) + assert.Equal(t, expectedName, name, stdout) } t.Run("is able to create a project", func(t *testing.T) { + testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) + name := testhelpers.TestProjectName() stdout, _, err := defaultCmd.Exec(nil, "create", "project", "--name", name, "--format", "json") require.NoError(t, err) assertResult(t, defaultConfig, stdout, name) + + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + }) + + t.Run("is able to create a project and use the project as default", func(t *testing.T) { + name := testhelpers.TestProjectName() + + stdout, _, err := defaultCmd.Exec(nil, "create", "project", "--name", name, "--use-project", "--format", "json") + require.NoError(t, err) + assertResult(t, defaultConfig, stdout, name) + + id, _, _ := parseOutput(stdout) + assert.Equal(t, id, testhelpers.GetDefaultProject(t, defaultConfig)) }) t.Run("is able to create a project and use name from stdin", func(t *testing.T) { diff --git a/cmd/cloudx/testhelpers/testhelpers.go b/cmd/cloudx/testhelpers/testhelpers.go index 37ffff48..738a629a 100644 --- a/cmd/cloudx/testhelpers/testhelpers.go +++ b/cmd/cloudx/testhelpers/testhelpers.go @@ -162,6 +162,15 @@ func CreateProject(t require.TestingT, configDir string) string { name := TestProjectName() stdout, stderr, err := cmd.Exec(nil, "create", "project", "--name", name, "--format", "json") require.NoError(t, err, "stdout: %s\nstderr: %s", stderr) + id := gjson.Get(stdout, "id").String() + return id +} + +func CreateAndUseProject(t require.TestingT, configDir string) string { + cmd := ConfigAwareCmd(configDir) + name := TestProjectName() + stdout, stderr, err := cmd.Exec(nil, "create", "project", "--name", name, "--use-project", "--format", "json") + require.NoError(t, err, "stdout: %s\nstderr: %s", stderr) ac := ReadConfig(t, configDir) id := gjson.Get(stdout, "id").String() assert.Equal(t, ac.SelectedProject.String(), id) From 37975f282e970f7aaa2a00500b71130f4d60b1c6 Mon Sep 17 00:00:00 2001 From: Henning Fleischhauer <18215579+CaptainStandby@users.noreply.github.com> Date: Wed, 28 Dec 2022 20:03:22 +0100 Subject: [PATCH 09/18] make format --- cmd/cloudx/project/get_test.go | 3 ++- cmd/cloudx/project/patch_identity_config_test.go | 3 ++- cmd/cloudx/project/patch_oauth2_config_test.go | 3 ++- cmd/cloudx/project/patch_permission_config_test.go | 3 ++- cmd/cloudx/project/patch_test.go | 3 ++- cmd/cloudx/project/use_test.go | 3 ++- 6 files changed, 12 insertions(+), 6 deletions(-) diff --git a/cmd/cloudx/project/get_test.go b/cmd/cloudx/project/get_test.go index caf3ce87..ac76a49a 100644 --- a/cmd/cloudx/project/get_test.go +++ b/cmd/cloudx/project/get_test.go @@ -6,10 +6,11 @@ package project_test import ( "testing" - "github.com/ory/cli/cmd/cloudx/testhelpers" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "github.com/tidwall/gjson" + + "github.com/ory/cli/cmd/cloudx/testhelpers" ) func TestGetProject(t *testing.T) { diff --git a/cmd/cloudx/project/patch_identity_config_test.go b/cmd/cloudx/project/patch_identity_config_test.go index 1e578a1e..459d92cf 100644 --- a/cmd/cloudx/project/patch_identity_config_test.go +++ b/cmd/cloudx/project/patch_identity_config_test.go @@ -6,10 +6,11 @@ package project_test import ( "testing" - "github.com/ory/cli/cmd/cloudx/testhelpers" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "github.com/tidwall/gjson" + + "github.com/ory/cli/cmd/cloudx/testhelpers" ) func TestPatchKratosConfig(t *testing.T) { diff --git a/cmd/cloudx/project/patch_oauth2_config_test.go b/cmd/cloudx/project/patch_oauth2_config_test.go index 683c10f5..e581b682 100644 --- a/cmd/cloudx/project/patch_oauth2_config_test.go +++ b/cmd/cloudx/project/patch_oauth2_config_test.go @@ -6,10 +6,11 @@ package project_test import ( "testing" - "github.com/ory/cli/cmd/cloudx/testhelpers" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "github.com/tidwall/gjson" + + "github.com/ory/cli/cmd/cloudx/testhelpers" ) func TestPatchHydraConfig(t *testing.T) { diff --git a/cmd/cloudx/project/patch_permission_config_test.go b/cmd/cloudx/project/patch_permission_config_test.go index 07ae5c6f..a8e0c503 100644 --- a/cmd/cloudx/project/patch_permission_config_test.go +++ b/cmd/cloudx/project/patch_permission_config_test.go @@ -6,10 +6,11 @@ package project_test import ( "testing" - "github.com/ory/cli/cmd/cloudx/testhelpers" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "github.com/tidwall/gjson" + + "github.com/ory/cli/cmd/cloudx/testhelpers" ) func TestPatchPermissionConfig(t *testing.T) { diff --git a/cmd/cloudx/project/patch_test.go b/cmd/cloudx/project/patch_test.go index 9676634c..f521063e 100644 --- a/cmd/cloudx/project/patch_test.go +++ b/cmd/cloudx/project/patch_test.go @@ -6,10 +6,11 @@ package project_test import ( "testing" - "github.com/ory/cli/cmd/cloudx/testhelpers" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "github.com/tidwall/gjson" + + "github.com/ory/cli/cmd/cloudx/testhelpers" ) func TestPatchProject(t *testing.T) { diff --git a/cmd/cloudx/project/use_test.go b/cmd/cloudx/project/use_test.go index 0fe942ff..8628de2e 100644 --- a/cmd/cloudx/project/use_test.go +++ b/cmd/cloudx/project/use_test.go @@ -6,10 +6,11 @@ package project_test import ( "testing" - "github.com/ory/cli/cmd/cloudx/testhelpers" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "github.com/tidwall/gjson" + + "github.com/ory/cli/cmd/cloudx/testhelpers" ) func TestUseProject(t *testing.T) { From d034ab7962f9d47c225123c4bc33d847cbe8da86 Mon Sep 17 00:00:00 2001 From: Henning Fleischhauer <18215579+CaptainStandby@users.noreply.github.com> Date: Wed, 28 Dec 2022 20:45:43 +0100 Subject: [PATCH 10/18] suppress error --- cmd/cloudx/client/handler.go | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/cmd/cloudx/client/handler.go b/cmd/cloudx/client/handler.go index e8c863f8..6ed6691a 100644 --- a/cmd/cloudx/client/handler.go +++ b/cmd/cloudx/client/handler.go @@ -516,7 +516,7 @@ func (h *CommandHelper) ListProjects() ([]cloud.ProjectMetadata, error) { } if def, _ := h.GetDefaultProjectID(); def == "" && len(projects) > 0 { - h.SetDefaultProject(projects[0].Id) + _ = h.SetDefaultProject(projects[0].Id) } return projects, nil @@ -565,7 +565,7 @@ func (h *CommandHelper) GetProject(projectOrSlug string) (*cloud.Project, error) } if def, _ := h.GetDefaultProjectID(); def == "" { - h.SetDefaultProject(project.Id) + _ = h.SetDefaultProject(project.Id) } return project, nil @@ -588,7 +588,7 @@ func (h *CommandHelper) CreateProject(name string, setDefault bool) (*cloud.Proj } if def, _ := h.GetDefaultProjectID(); setDefault || def == "" { - h.SetDefaultProject(project.Id) + _ = h.SetDefaultProject(project.Id) } return project, nil @@ -680,7 +680,7 @@ func (h *CommandHelper) PatchProject(id string, raw []json.RawMessage, add, repl } if def, _ := h.GetDefaultProjectID(); def == "" { - h.SetDefaultProject(id) + _ = h.SetDefaultProject(id) } return res, nil @@ -755,7 +755,7 @@ func (h *CommandHelper) UpdateProject(id string, name string, configs []json.Raw } if def, _ := h.GetDefaultProjectID(); def == "" { - h.SetDefaultProject(id) + _ = h.SetDefaultProject(id) } return res, nil From cca5fb2a54e40eff61ca6a64e6745273a2939f86 Mon Sep 17 00:00:00 2001 From: Henning Fleischhauer <18215579+CaptainStandby@users.noreply.github.com> Date: Tue, 3 Jan 2023 16:07:27 +0100 Subject: [PATCH 11/18] only set default project implicitly on first create --- cmd/cloudx/client/handler.go | 16 ---------------- 1 file changed, 16 deletions(-) diff --git a/cmd/cloudx/client/handler.go b/cmd/cloudx/client/handler.go index 6ed6691a..ed99536e 100644 --- a/cmd/cloudx/client/handler.go +++ b/cmd/cloudx/client/handler.go @@ -515,10 +515,6 @@ func (h *CommandHelper) ListProjects() ([]cloud.ProjectMetadata, error) { return nil, handleError("unable to list projects", res, err) } - if def, _ := h.GetDefaultProjectID(); def == "" && len(projects) > 0 { - _ = h.SetDefaultProject(projects[0].Id) - } - return projects, nil } @@ -564,10 +560,6 @@ func (h *CommandHelper) GetProject(projectOrSlug string) (*cloud.Project, error) return nil, handleError("unable to get project", res, err) } - if def, _ := h.GetDefaultProjectID(); def == "" { - _ = h.SetDefaultProject(project.Id) - } - return project, nil } @@ -679,10 +671,6 @@ func (h *CommandHelper) PatchProject(id string, raw []json.RawMessage, add, repl return nil, err } - if def, _ := h.GetDefaultProjectID(); def == "" { - _ = h.SetDefaultProject(id) - } - return res, nil } @@ -754,10 +742,6 @@ func (h *CommandHelper) UpdateProject(id string, name string, configs []json.Raw return nil, err } - if def, _ := h.GetDefaultProjectID(); def == "" { - _ = h.SetDefaultProject(id) - } - return res, nil } From 4044533b4045cfa92d4e5aa64a3004455df0871b Mon Sep 17 00:00:00 2001 From: Henning Fleischhauer <18215579+CaptainStandby@users.noreply.github.com> Date: Mon, 9 Jan 2023 10:09:02 +0100 Subject: [PATCH 12/18] cleanup --- cmd/cloudx/client/handler_test.go | 54 ++++++++++++------------------- 1 file changed, 20 insertions(+), 34 deletions(-) diff --git a/cmd/cloudx/client/handler_test.go b/cmd/cloudx/client/handler_test.go index 905676b5..ab6cc042 100644 --- a/cmd/cloudx/client/handler_test.go +++ b/cmd/cloudx/client/handler_test.go @@ -59,23 +59,19 @@ func TestCommandHelper(t *testing.T) { } t.Run("func=SetDefaultProject", func(t *testing.T) { + t.Parallel() configDir := testhelpers.NewConfigDir(t) testhelpers.RegisterAccount(t, configDir) otherId := testhelpers.CreateProject(t, configDir) defaultId := testhelpers.CreateProject(t, configDir) testhelpers.SetDefaultProject(t, configDir, defaultId) - cmd_base := &client.CommandHelper{ - ConfigLocation: configDir, - NoConfirm: true, - IsQuiet: false, - VerboseWriter: io.Discard, - VerboseErrWriter: io.Discard, - Ctx: context.Background(), + cmdBase := client.CommandHelper{ + ConfigLocation: configDir, } t.Run("can change the selected project", func(t *testing.T) { - cmd := *cmd_base + cmd := cmdBase current, _ := cmd.GetDefaultProjectID() assert.Equal(t, current, defaultId) @@ -89,20 +85,16 @@ func TestCommandHelper(t *testing.T) { }) t.Run("func=ListProjects", func(t *testing.T) { + t.Parallel() configDir := testhelpers.NewConfigDir(t) testhelpers.RegisterAccount(t, configDir) - cmd_base := &client.CommandHelper{ - ConfigLocation: configDir, - NoConfirm: true, - IsQuiet: false, - VerboseWriter: io.Discard, - VerboseErrWriter: io.Discard, - Ctx: context.Background(), + cmdBase := client.CommandHelper{ + ConfigLocation: configDir, } t.Run("With no projects returns empty list", func(t *testing.T) { - cmd := *cmd_base + cmd := cmdBase projects, err := cmd.ListProjects() @@ -111,7 +103,7 @@ func TestCommandHelper(t *testing.T) { }) t.Run("With some projects returns list of projects", func(t *testing.T) { - cmd := *cmd_base + cmd := cmdBase project_name1 := "new_project_name1" project_name2 := "new_project_name2" @@ -124,27 +116,21 @@ func TestCommandHelper(t *testing.T) { require.NoError(t, err) assert.Len(t, projects, 2) - listedIds := [2]string{projects[0].Id, projects[1].Id} - assert.Contains(t, listedIds, project1.Id) - assert.Contains(t, listedIds, project2.Id) + assert.ElementsMatch(t, []string{projects[0].Id, projects[1].Id}, []string{project1.Id, project2.Id}) }) }) t.Run("func=CreateProject", func(t *testing.T) { + t.Parallel() configDir := testhelpers.NewConfigDir(t) testhelpers.RegisterAccount(t, configDir) - cmd_base := &client.CommandHelper{ - ConfigLocation: configDir, - NoConfirm: true, - IsQuiet: false, - VerboseWriter: io.Discard, - VerboseErrWriter: io.Discard, - Ctx: context.Background(), + cmdBase := client.CommandHelper{ + ConfigLocation: configDir, } t.Run("creates project and sets default project", func(t *testing.T) { - cmd := *cmd_base + cmd := cmdBase project_name := "new_project_name" project, err := cmd.CreateProject(project_name, true) @@ -157,7 +143,7 @@ func TestCommandHelper(t *testing.T) { }) t.Run("creates two projects with different names", func(t *testing.T) { - cmd := *cmd_base + cmd := cmdBase project_name1 := "new_project_name1" project_name2 := "new_project_name2" @@ -178,17 +164,17 @@ func TestCommandHelper(t *testing.T) { }) t.Run("func=Authenticate", func(t *testing.T) { - cmd_base := &client.CommandHelper{ + t.Parallel() + cmdBase := client.CommandHelper{ ConfigLocation: testhelpers.NewConfigDir(t), NoConfirm: true, IsQuiet: false, VerboseWriter: io.Discard, VerboseErrWriter: io.Discard, - Ctx: context.Background(), } t.Run("create new account", func(t *testing.T) { - cmd := *cmd_base + cmd := cmdBase name := testhelpers.FakeName() email := testhelpers.FakeEmail() @@ -211,7 +197,7 @@ func TestCommandHelper(t *testing.T) { }) t.Run("log into existing account", func(t *testing.T) { - cmd := *cmd_base + cmd := cmdBase var r bytes.Buffer _, _ = r.WriteString("y\n") // Do you want to sign in to an existing Ory Network account? [y/n]: y @@ -228,7 +214,7 @@ func TestCommandHelper(t *testing.T) { }) t.Run("retry login after wrong password", func(t *testing.T) { - cmd := *cmd_base + cmd := cmdBase var r bytes.Buffer _, _ = r.WriteString("y\n") // Do you want to sign in to an existing Ory Network account? [y/n]: y From b5a7e7eb4de176b3b31275d31586128537572aaf Mon Sep 17 00:00:00 2001 From: Henning Fleischhauer <18215579+CaptainStandby@users.noreply.github.com> Date: Mon, 9 Jan 2023 18:28:02 +0100 Subject: [PATCH 13/18] renaming --- cmd/cloudx/client/handler_test.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/cmd/cloudx/client/handler_test.go b/cmd/cloudx/client/handler_test.go index ab6cc042..9cbb2335 100644 --- a/cmd/cloudx/client/handler_test.go +++ b/cmd/cloudx/client/handler_test.go @@ -189,11 +189,11 @@ func TestCommandHelper(t *testing.T) { password := testhelpers.FakePassword() cmd.PwReader = func() ([]byte, error) { return []byte(password), nil } - auth_ctx, err := cmd.Authenticate() + authCtx, err := cmd.Authenticate() require.NoError(t, err) - require.NotNil(t, auth_ctx) - require.Equal(t, auth_ctx.IdentityTraits.Email, email) + require.NotNil(t, authCtx) + require.Equal(t, authCtx.IdentityTraits.Email, email) }) t.Run("log into existing account", func(t *testing.T) { From 8da7e2fc6992525dfc3f71803d20bebc8a0c160d Mon Sep 17 00:00:00 2001 From: Henning Fleischhauer <18215579+CaptainStandby@users.noreply.github.com> Date: Mon, 9 Jan 2023 18:28:50 +0100 Subject: [PATCH 14/18] reduce duplication --- cmd/cloudx/project/get.go | 8 ++------ cmd/cloudx/project/get_identity_config.go | 8 ++------ cmd/cloudx/project/get_oauth2_config.go | 8 ++------ cmd/cloudx/project/get_permission_config.go | 8 ++------ cmd/cloudx/project/patch.go | 8 ++------ cmd/cloudx/project/update.go | 8 ++------ cmd/cloudx/project/utils.go | 13 +++++++++++++ 7 files changed, 25 insertions(+), 36 deletions(-) diff --git a/cmd/cloudx/project/get.go b/cmd/cloudx/project/get.go index d7e15dac..cbfffc25 100644 --- a/cmd/cloudx/project/get.go +++ b/cmd/cloudx/project/get.go @@ -46,12 +46,8 @@ $ ory get project ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 --format json } var id string - if len(args) == 0 { - if id, err = h.GetDefaultProjectID(); err != nil { - return cmdx.PrintOpenAPIError(cmd, err) - } - } else { - id = args[0] + if id, err = getSelectedProjectId(h, args); err != nil { + return cmdx.PrintOpenAPIError(cmd, err) } project, err := h.GetProject(id) if err != nil { diff --git a/cmd/cloudx/project/get_identity_config.go b/cmd/cloudx/project/get_identity_config.go index 1095c958..09d7313d 100644 --- a/cmd/cloudx/project/get_identity_config.go +++ b/cmd/cloudx/project/get_identity_config.go @@ -36,12 +36,8 @@ $ ory get identity-config ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 --format json } var id string - if len(args) == 0 { - if id, err = h.GetDefaultProjectID(); err != nil { - return cmdx.PrintOpenAPIError(cmd, err) - } - } else { - id = args[0] + if id, err = getSelectedProjectId(h, args); err != nil { + return cmdx.PrintOpenAPIError(cmd, err) } project, err := h.GetProject(id) if err != nil { diff --git a/cmd/cloudx/project/get_oauth2_config.go b/cmd/cloudx/project/get_oauth2_config.go index c9c6748f..d78fb1fd 100644 --- a/cmd/cloudx/project/get_oauth2_config.go +++ b/cmd/cloudx/project/get_oauth2_config.go @@ -44,12 +44,8 @@ $ ory get oauth2-config ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 --format json } var id string - if len(args) == 0 { - if id, err = h.GetDefaultProjectID(); err != nil { - return cmdx.PrintOpenAPIError(cmd, err) - } - } else { - id = args[0] + if id, err = getSelectedProjectId(h, args); err != nil { + return cmdx.PrintOpenAPIError(cmd, err) } project, err := h.GetProject(id) if err != nil { diff --git a/cmd/cloudx/project/get_permission_config.go b/cmd/cloudx/project/get_permission_config.go index 0c1d5397..1d5cc074 100644 --- a/cmd/cloudx/project/get_permission_config.go +++ b/cmd/cloudx/project/get_permission_config.go @@ -37,12 +37,8 @@ $ ory get permission-config ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 --format json } var id string - if len(args) == 0 { - if id, err = h.GetDefaultProjectID(); err != nil { - return cmdx.PrintOpenAPIError(cmd, err) - } - } else { - id = args[0] + if id, err = getSelectedProjectId(h, args); err != nil { + return cmdx.PrintOpenAPIError(cmd, err) } project, err := h.GetProject(id) if err != nil { diff --git a/cmd/cloudx/project/patch.go b/cmd/cloudx/project/patch.go index ebdad947..5a26f900 100644 --- a/cmd/cloudx/project/patch.go +++ b/cmd/cloudx/project/patch.go @@ -82,12 +82,8 @@ func runPatch(patchPrefixer func([]string) []string, filePrefixer func([]json.Ra } var id string - if len(args) == 0 { - if id, err = h.GetDefaultProjectID(); err != nil { - return cmdx.PrintOpenAPIError(cmd, err) - } - } else { - id = args[0] + if id, err = getSelectedProjectId(h, args); err != nil { + return cmdx.PrintOpenAPIError(cmd, err) } p, err := h.PatchProject(id, configs, add, replace, remove) if err != nil { diff --git a/cmd/cloudx/project/update.go b/cmd/cloudx/project/update.go index 14b1a75c..1ca38ce8 100644 --- a/cmd/cloudx/project/update.go +++ b/cmd/cloudx/project/update.go @@ -122,12 +122,8 @@ func runUpdate(filePrefixer func([]json.RawMessage) ([]json.RawMessage, error), name = n.Value.String() } var id string - if len(args) == 0 { - if id, err = h.GetDefaultProjectID(); err != nil { - return cmdx.PrintOpenAPIError(cmd, err) - } - } else { - id = args[0] + if id, err = getSelectedProjectId(h, args); err != nil { + return cmdx.PrintOpenAPIError(cmd, err) } p, err := h.UpdateProject(id, name, configs) if err != nil { diff --git a/cmd/cloudx/project/utils.go b/cmd/cloudx/project/utils.go index 09ca1502..3a516e2f 100644 --- a/cmd/cloudx/project/utils.go +++ b/cmd/cloudx/project/utils.go @@ -9,10 +9,23 @@ import ( "github.com/spf13/cobra" "github.com/tidwall/sjson" + "github.com/ory/cli/cmd/cloudx/client" cloud "github.com/ory/client-go" "github.com/ory/x/cmdx" ) +func getSelectedProjectId(h *client.CommandHelper, args []string) (string, error) { + if len(args) == 0 { + if id, err := h.GetDefaultProjectID(); err != nil { + return "", err + } else { + return id, nil + } + } else { + return args[0], nil + } +} + func prefixConfig(prefix string, s []string) []string { for k := range s { s[k] = prefix + s[k] From 2cb545dbb4a71f11be501ea2105ced0de9e04899 Mon Sep 17 00:00:00 2001 From: Henning Fleischhauer <18215579+CaptainStandby@users.noreply.github.com> Date: Wed, 11 Jan 2023 18:11:01 +0100 Subject: [PATCH 15/18] refactoring --- cmd/cloudx/client/client.go | 2 +- cmd/cloudx/client/handler.go | 10 +- cmd/cloudx/client/handler_test.go | 11 +- cmd/cloudx/project/create.go | 6 +- cmd/cloudx/project/get.go | 4 +- cmd/cloudx/project/get_oauth2_config.go | 4 +- cmd/cloudx/project/get_test.go | 69 ++-------- cmd/cloudx/project/helper_test.go | 64 +++++++++ cmd/cloudx/project/output.go | 10 +- .../project/patch_identity_config_test.go | 65 ++------- .../project/patch_oauth2_config_test.go | 65 ++------- .../project/patch_permission_config_test.go | 65 ++------- cmd/cloudx/project/patch_test.go | 130 +++--------------- .../project/update_namespace_config_test.go | 24 +--- cmd/cloudx/project/use.go | 9 +- cmd/cloudx/project/utils.go | 7 +- 16 files changed, 171 insertions(+), 374 deletions(-) create mode 100644 cmd/cloudx/project/helper_test.go diff --git a/cmd/cloudx/client/client.go b/cmd/cloudx/client/client.go index c8fd9253..98ca663b 100644 --- a/cmd/cloudx/client/client.go +++ b/cmd/cloudx/client/client.go @@ -34,7 +34,7 @@ func RegisterProjectFlag(f *flag.FlagSet) { // if none was set. func ProjectOrDefault(cmd *cobra.Command, h *CommandHelper) (string, error) { if flag := flagx.MustGetString(cmd, projectFlag); flag == "" { - if id, err := h.GetDefaultProjectID(); err == nil { + if id := h.GetDefaultProjectID(); id != "" { return id, nil } else { _, _ = fmt.Fprintf(os.Stderr, "No project selected! Please use the flag --%s to specify one.\n", projectFlag) diff --git a/cmd/cloudx/client/handler.go b/cmd/cloudx/client/handler.go index ed99536e..fcd43d9a 100644 --- a/cmd/cloudx/client/handler.go +++ b/cmd/cloudx/client/handler.go @@ -152,17 +152,17 @@ func NewCommandHelper(cmd *cobra.Command) (*CommandHelper, error) { }, nil } -func (h *CommandHelper) GetDefaultProjectID() (string, error) { +func (h *CommandHelper) GetDefaultProjectID() string { conf, err := h.readConfig() if err != nil { - return "", err + return "" } if conf.SelectedProject != uuid.Nil { - return conf.SelectedProject.String(), nil + return conf.SelectedProject.String() } - return "", errors.New("No valid default project was specified") + return "" } func (h *CommandHelper) SetDefaultProject(id string) error { @@ -579,7 +579,7 @@ func (h *CommandHelper) CreateProject(name string, setDefault bool) (*cloud.Proj return nil, handleError("unable to list projects", res, err) } - if def, _ := h.GetDefaultProjectID(); setDefault || def == "" { + if def := h.GetDefaultProjectID(); setDefault || def == "" { _ = h.SetDefaultProject(project.Id) } diff --git a/cmd/cloudx/client/handler_test.go b/cmd/cloudx/client/handler_test.go index 9cbb2335..bb5bf716 100644 --- a/cmd/cloudx/client/handler_test.go +++ b/cmd/cloudx/client/handler_test.go @@ -72,14 +72,13 @@ func TestCommandHelper(t *testing.T) { t.Run("can change the selected project", func(t *testing.T) { cmd := cmdBase - current, _ := cmd.GetDefaultProjectID() + current := cmd.GetDefaultProjectID() assert.Equal(t, current, defaultId) err := cmd.SetDefaultProject(otherId) assert.NoError(t, err) - selected, err := cmd.GetDefaultProjectID() - assert.NoError(t, err) + selected := cmd.GetDefaultProjectID() assert.Equal(t, selected, otherId) }) }) @@ -137,8 +136,7 @@ func TestCommandHelper(t *testing.T) { require.NoError(t, err) assert.Equal(t, project.Name, project_name) - defaultId, err := cmd.GetDefaultProjectID() - require.NoError(t, err) + defaultId := cmd.GetDefaultProjectID() assert.Equal(t, project.Id, defaultId) }) @@ -157,8 +155,7 @@ func TestCommandHelper(t *testing.T) { assert.NotEqual(t, project1.Name, project2.Name) assert.NotEqual(t, project1.Slug, project2.Slug) - defaultId, err := cmd.GetDefaultProjectID() - require.NoError(t, err) + defaultId := cmd.GetDefaultProjectID() assert.Equal(t, project1.Id, defaultId) }) }) diff --git a/cmd/cloudx/project/create.go b/cmd/cloudx/project/create.go index 0f995321..ba4e4f34 100644 --- a/cmd/cloudx/project/create.go +++ b/cmd/cloudx/project/create.go @@ -15,6 +15,8 @@ import ( "github.com/ory/x/flagx" ) +const useProjectFlag = "use-project" + func NewCreateProjectCmd() *cobra.Command { cmd := &cobra.Command{ Use: "project", @@ -39,7 +41,7 @@ func NewCreateProjectCmd() *cobra.Command { } } - use := flagx.MustGetBool(cmd, "use-project") + use := flagx.MustGetBool(cmd, useProjectFlag) p, err := h.CreateProject(name, use) if err != nil { return cmdx.PrintOpenAPIError(cmd, err) @@ -52,7 +54,7 @@ func NewCreateProjectCmd() *cobra.Command { } cmd.Flags().StringP("name", "n", "", "The name of the project, required when quiet mode is used") - cmd.Flags().BoolP("use-project", "", false, "Uses the created project as default.") + cmd.Flags().Bool(useProjectFlag, false, "Set the created project as the default.") cmdx.RegisterFormatFlags(cmd.Flags()) return cmd } diff --git a/cmd/cloudx/project/get.go b/cmd/cloudx/project/get.go index cbfffc25..84254234 100644 --- a/cmd/cloudx/project/get.go +++ b/cmd/cloudx/project/get.go @@ -45,8 +45,8 @@ $ ory get project ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 --format json return err } - var id string - if id, err = getSelectedProjectId(h, args); err != nil { + id, err := getSelectedProjectId(h, args) + if err != nil { return cmdx.PrintOpenAPIError(cmd, err) } project, err := h.GetProject(id) diff --git a/cmd/cloudx/project/get_oauth2_config.go b/cmd/cloudx/project/get_oauth2_config.go index d78fb1fd..258f6897 100644 --- a/cmd/cloudx/project/get_oauth2_config.go +++ b/cmd/cloudx/project/get_oauth2_config.go @@ -43,8 +43,8 @@ $ ory get oauth2-config ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 --format json return err } - var id string - if id, err = getSelectedProjectId(h, args); err != nil { + id, err := getSelectedProjectId(h, args) + if err != nil { return cmdx.PrintOpenAPIError(cmd, err) } project, err := h.GetProject(id) diff --git a/cmd/cloudx/project/get_test.go b/cmd/cloudx/project/get_test.go index ac76a49a..1275c5a7 100644 --- a/cmd/cloudx/project/get_test.go +++ b/cmd/cloudx/project/get_test.go @@ -9,82 +9,39 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "github.com/tidwall/gjson" - - "github.com/ory/cli/cmd/cloudx/testhelpers" ) func TestGetProject(t *testing.T) { - testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) - t.Run("is able to get project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "get", "project", extraProject, "--format", "json") - require.NoError(t, err) - assert.Equal(t, extraProject, gjson.Get(stdout, "id").String()) - assert.NotEmpty(t, gjson.Get(stdout, "slug").String()) - }) - t.Run("is able to get default project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "get", "project", "--format", "json") + runWithProject(t, func(t *testing.T, exec execFunc, projectID string) { + stdout, _, err := exec(nil, "get", "project", "--format", "json") require.NoError(t, err) - assert.Equal(t, defaultProject, gjson.Get(stdout, "id").String()) + assert.Equal(t, projectID, gjson.Get(stdout, "id").String()) assert.NotEmpty(t, gjson.Get(stdout, "slug").String()) - }) + }, DefaultProject|PositionalProject) } func TestGetServiceConfig(t *testing.T) { t.Run("service=kratos", func(t *testing.T) { - testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) - t.Run("explicit project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "get", "kratos-config", defaultProject, "--format", "json") + runWithProject(t, func(t *testing.T, exec execFunc, _ string) { + stdout, _, err := exec(nil, "get", "kratos-config", "--format", "json") require.NoError(t, err) assert.True(t, gjson.Get(stdout, "selfservice.flows.error.ui_url").Exists()) - }) - t.Run("default project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "get", "kratos-config", "--format", "json") - require.NoError(t, err) - assert.True(t, gjson.Get(stdout, "selfservice.flows.error.ui_url").Exists()) - }) + }, DefaultProject|PositionalProject) }) t.Run("service=keto", func(t *testing.T) { - testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) - t.Run("explicit project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "get", "keto-config", defaultProject, "--format", "json") - require.NoError(t, err) - assert.True(t, gjson.Get(stdout, "namespaces").Exists(), stdout) - }) - t.Run("default project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "get", "keto-config", "--format", "json") + runWithProject(t, func(t *testing.T, exec execFunc, _ string) { + stdout, _, err := exec(nil, "get", "keto-config", "--format", "json") require.NoError(t, err) assert.True(t, gjson.Get(stdout, "namespaces").Exists(), stdout) - }) + }, DefaultProject|PositionalProject) }) t.Run("service=hydra", func(t *testing.T) { - testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) - t.Run("explicit project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "get", "oauth2-config", defaultProject, "--format", "json") - require.NoError(t, err) - assert.True(t, gjson.Get(stdout, "oauth2").Exists(), stdout) - }) - t.Run("default project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "get", "oauth2-config", "--format", "json") + runWithProject(t, func(t *testing.T, exec execFunc, _ string) { + stdout, _, err := exec(nil, "get", "oauth2-config", "--format", "json") require.NoError(t, err) assert.True(t, gjson.Get(stdout, "oauth2").Exists(), stdout) - }) + }, DefaultProject|PositionalProject) }) } diff --git a/cmd/cloudx/project/helper_test.go b/cmd/cloudx/project/helper_test.go new file mode 100644 index 00000000..de720140 --- /dev/null +++ b/cmd/cloudx/project/helper_test.go @@ -0,0 +1,64 @@ +// Copyright © 2023 Ory Corp +// SPDX-License-Identifier: Apache-2.0 + +package project_test + +import ( + "io" + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/ory/cli/cmd/cloudx/testhelpers" +) + +type execFunc func(stdin io.Reader, args ...string) (string, string, error) + +type bits uint8 + +const ( + DefaultProject bits = 1 << iota + PositionalProject + FlagProject +) + +func runWithProject(t *testing.T, test func(t *testing.T, exec execFunc, projectID string), argPosition bits) { + if argPosition&DefaultProject != 0 { + t.Run("project via configured default", func(t *testing.T) { + testhelpers.SetDefaultProject(t, defaultConfig, extraProject) + + test(t, func(stdin io.Reader, args ...string) (string, string, error) { + return defaultCmd.Exec(stdin, args...) + }, extraProject) + + // make sure, the default wasn't changed implicitly + assert.Equal(t, extraProject, testhelpers.GetDefaultProject(t, defaultConfig)) + }) + } + + if argPosition&PositionalProject != 0 { + t.Run("explicit project via positional argument", func(t *testing.T) { + testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) + + test(t, func(stdin io.Reader, args ...string) (string, string, error) { + return defaultCmd.Exec(stdin, append(args, extraProject)...) + }, extraProject) + + // make sure, the default wasn't changed implicitly + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + }) + } + + if argPosition&FlagProject != 0 { + t.Run("explicit project via `--project` flag", func(t *testing.T) { + testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) + + test(t, func(stdin io.Reader, args ...string) (string, string, error) { + return defaultCmd.Exec(stdin, append(args, "--project", extraProject)...) + }, extraProject) + + // make sure, the default wasn't changed implicitly + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + }) + } +} diff --git a/cmd/cloudx/project/output.go b/cmd/cloudx/project/output.go index 9549d926..bee413b8 100644 --- a/cmd/cloudx/project/output.go +++ b/cmd/cloudx/project/output.go @@ -73,15 +73,15 @@ func (c *outputProjectCollection) Len() int { } type selectedProject struct { - Id string `json:"id"` + ID string `json:"id"` } func (i selectedProject) String() string { - return i.Id + return i.ID } -func (i *selectedProject) ID() string { - return i.Id +func (i *selectedProject) ProjectID() string { + return i.ID } func (*selectedProject) Header() []string { @@ -90,7 +90,7 @@ func (*selectedProject) Header() []string { func (i *selectedProject) Columns() []string { return []string{ - i.Id, + i.ID, } } diff --git a/cmd/cloudx/project/patch_identity_config_test.go b/cmd/cloudx/project/patch_identity_config_test.go index 459d92cf..14b20525 100644 --- a/cmd/cloudx/project/patch_identity_config_test.go +++ b/cmd/cloudx/project/patch_identity_config_test.go @@ -9,78 +9,37 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "github.com/tidwall/gjson" - - "github.com/ory/cli/cmd/cloudx/testhelpers" ) func TestPatchKratosConfig(t *testing.T) { t.Run("is able to replace a key", func(t *testing.T) { - testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) - t.Run("explicit project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "kratos-config", extraProject, "--format", "json", "--replace", `/selfservice/methods/password/enabled=false`) - require.NoError(t, err) - assert.False(t, gjson.Get(stdout, "selfservice.methods.password.enabled").Bool()) - }) - t.Run("default project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "kratos-config", "--format", "json", "--replace", `/selfservice/methods/password/enabled=false`) + runWithProject(t, func(t *testing.T, exec execFunc, _ string) { + stdout, _, err := exec(nil, "patch", "kratos-config", "--format", "json", "--replace", `/selfservice/methods/password/enabled=false`) require.NoError(t, err) assert.False(t, gjson.Get(stdout, "selfservice.methods.password.enabled").Bool()) - }) + }, DefaultProject|PositionalProject) }) t.Run("is able to add a key", func(t *testing.T) { - testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) - t.Run("explicit project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "identity-config", extraProject, "--format", "json", "--add", `/selfservice/methods/password/enabled=false`) - require.NoError(t, err) - assert.False(t, gjson.Get(stdout, "selfservice.methods.password.enabled").Bool()) - }) - t.Run("default project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "identity-config", "--format", "json", "--add", `/selfservice/methods/password/enabled=false`) + runWithProject(t, func(t *testing.T, exec execFunc, _ string) { + stdout, _, err := exec(nil, "patch", "identity-config", "--format", "json", "--add", `/selfservice/methods/password/enabled=false`) require.NoError(t, err) assert.False(t, gjson.Get(stdout, "selfservice.methods.password.enabled").Bool()) - }) + }, DefaultProject|PositionalProject) }) t.Run("is able to add a key with string", func(t *testing.T) { - testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) - t.Run("explicit project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "ic", extraProject, "--format", "json", "--replace", "/selfservice/flows/error/ui_url=\"https://example.com/error-ui\"") - require.NoError(t, err) - assert.Equal(t, "https://example.com/error-ui", gjson.Get(stdout, "selfservice.flows.error.ui_url").String()) - }) - t.Run("default project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "ic", "--format", "json", "--replace", "/selfservice/flows/error/ui_url=\"https://example.com/error-ui\"") + runWithProject(t, func(t *testing.T, exec execFunc, _ string) { + stdout, _, err := exec(nil, "patch", "ic", "--format", "json", "--replace", "/selfservice/flows/error/ui_url=\"https://example.com/error-ui\"") require.NoError(t, err) assert.Equal(t, "https://example.com/error-ui", gjson.Get(stdout, "selfservice.flows.error.ui_url").String()) - }) + }, DefaultProject|PositionalProject) }) t.Run("fails if no opts are given", func(t *testing.T) { - testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) - t.Run("explicit project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "ic", extraProject, "--format", "json") - require.Error(t, err, stdout) - }) - t.Run("default project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "ic", "--format", "json") + runWithProject(t, func(t *testing.T, exec execFunc, _ string) { + stdout, _, err := exec(nil, "patch", "ic", "--format", "json") require.Error(t, err, stdout) - }) + }, DefaultProject|PositionalProject|FlagProject) }) } diff --git a/cmd/cloudx/project/patch_oauth2_config_test.go b/cmd/cloudx/project/patch_oauth2_config_test.go index e581b682..747f3475 100644 --- a/cmd/cloudx/project/patch_oauth2_config_test.go +++ b/cmd/cloudx/project/patch_oauth2_config_test.go @@ -9,78 +9,37 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "github.com/tidwall/gjson" - - "github.com/ory/cli/cmd/cloudx/testhelpers" ) func TestPatchHydraConfig(t *testing.T) { t.Run("is able to replace a key", func(t *testing.T) { - testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) - t.Run("explicit project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "hydra-config", extraProject, "--format", "json", "--replace", `/strategies/access_token="jwt"`) - require.NoError(t, err) - assert.Equal(t, "jwt", gjson.Get(stdout, "strategies.access_token").String()) - }) - t.Run("default project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "hydra-config", "--format", "json", "--replace", `/strategies/access_token="jwt"`) + runWithProject(t, func(t *testing.T, exec execFunc, _ string) { + stdout, _, err := exec(nil, "patch", "hydra-config", "--format", "json", "--replace", `/strategies/access_token="jwt"`) require.NoError(t, err) assert.Equal(t, "jwt", gjson.Get(stdout, "strategies.access_token").String()) - }) + }, DefaultProject|PositionalProject) }) t.Run("is able to add a key", func(t *testing.T) { - testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) - t.Run("explicit project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "oauth2-config", extraProject, "--format", "json", "--add", `/ttl/login_consent_request="1h"`) - require.NoError(t, err) - assert.Equal(t, "1h0m0s", gjson.Get(stdout, "ttl.login_consent_request").String()) - }) - t.Run("default project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "oauth2-config", "--format", "json", "--add", `/ttl/login_consent_request="1h"`) + runWithProject(t, func(t *testing.T, exec execFunc, _ string) { + stdout, _, err := exec(nil, "patch", "oauth2-config", "--format", "json", "--add", `/ttl/login_consent_request="1h"`) require.NoError(t, err) assert.Equal(t, "1h0m0s", gjson.Get(stdout, "ttl.login_consent_request").String()) - }) + }, DefaultProject|PositionalProject) }) t.Run("is able to add a key with string", func(t *testing.T) { - testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) - t.Run("explicit project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "oc", extraProject, "--format", "json", "--replace", `/ttl/refresh_token="2h"`) - require.NoError(t, err) - assert.Equal(t, "2h0m0s", gjson.Get(stdout, "ttl.refresh_token").String()) - }) - t.Run("default project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "oc", "--format", "json", "--replace", `/ttl/refresh_token="2h"`) + runWithProject(t, func(t *testing.T, exec execFunc, _ string) { + stdout, _, err := exec(nil, "patch", "oc", "--format", "json", "--replace", `/ttl/refresh_token="2h"`) require.NoError(t, err) assert.Equal(t, "2h0m0s", gjson.Get(stdout, "ttl.refresh_token").String()) - }) + }, DefaultProject|PositionalProject) }) t.Run("fails if no opts are given", func(t *testing.T) { - testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) - t.Run("explicit project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "oc", extraProject, "--format", "json") - require.Error(t, err, stdout) - }) - t.Run("default project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "oc", "--format", "json") + runWithProject(t, func(t *testing.T, exec execFunc, _ string) { + stdout, _, err := exec(nil, "patch", "oc", "--format", "json") require.Error(t, err, stdout) - }) + }, DefaultProject|PositionalProject|FlagProject) }) } diff --git a/cmd/cloudx/project/patch_permission_config_test.go b/cmd/cloudx/project/patch_permission_config_test.go index a8e0c503..8818d32b 100644 --- a/cmd/cloudx/project/patch_permission_config_test.go +++ b/cmd/cloudx/project/patch_permission_config_test.go @@ -9,78 +9,37 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "github.com/tidwall/gjson" - - "github.com/ory/cli/cmd/cloudx/testhelpers" ) func TestPatchPermissionConfig(t *testing.T) { t.Run("is able to replace a key", func(t *testing.T) { - testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) - t.Run("explicit project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "keto-config", extraProject, "--format", "json", "--add", `/namespaces=[{"name":"files", "id": 2}]`) - require.NoError(t, err) - assert.Equal(t, "files", gjson.Get(stdout, "namespaces.0.name").String(), stdout) - }) - t.Run("default project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "keto-config", "--format", "json", "--add", `/namespaces=[{"name":"files", "id": 2}]`) + runWithProject(t, func(t *testing.T, exec execFunc, _ string) { + stdout, _, err := exec(nil, "patch", "keto-config", "--format", "json", "--add", `/namespaces=[{"name":"files", "id": 2}]`) require.NoError(t, err) assert.Equal(t, "files", gjson.Get(stdout, "namespaces.0.name").String(), stdout) - }) + }, DefaultProject|PositionalProject) }) t.Run("is able to add a key using permission-config", func(t *testing.T) { - testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) - t.Run("explicit project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "permission-config", extraProject, "--format", "json", "--add", `/namespaces/1={"name":"docs", "id": 3}`) - require.NoError(t, err) - assert.Equal(t, "docs", gjson.Get(stdout, "namespaces.1.name").String(), stdout) - }) - t.Run("default project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "permission-config", "--format", "json", "--add", `/namespaces/1={"name":"docs", "id": 3}`) + runWithProject(t, func(t *testing.T, exec execFunc, _ string) { + stdout, _, err := exec(nil, "patch", "permission-config", "--format", "json", "--add", `/namespaces/1={"name":"docs", "id": 3}`) require.NoError(t, err) assert.Equal(t, "docs", gjson.Get(stdout, "namespaces.1.name").String(), stdout) - }) + }, DefaultProject|PositionalProject) }) t.Run("is able to replace a key", func(t *testing.T) { - testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) - t.Run("explicit project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "pc", extraProject, "--format", "json", "--replace", `/namespaces=[{"name":"people", "id": 4}]`) - require.NoError(t, err) - assert.Equal(t, "people", gjson.Get(stdout, "namespaces.0.name").String(), stdout) - }) - t.Run("default project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "pc", "--format", "json", "--replace", `/namespaces=[{"name":"people", "id": 4}]`) + runWithProject(t, func(t *testing.T, exec execFunc, _ string) { + stdout, _, err := exec(nil, "patch", "pc", "--format", "json", "--replace", `/namespaces=[{"name":"people", "id": 4}]`) require.NoError(t, err) assert.Equal(t, "people", gjson.Get(stdout, "namespaces.0.name").String(), stdout) - }) + }, DefaultProject|PositionalProject) }) t.Run("fails if no opts are given", func(t *testing.T) { - testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) - t.Run("explicit project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "pc", extraProject, "--format", "json") - require.Error(t, err, stdout) - }) - t.Run("default project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "pc", "--format", "json") + runWithProject(t, func(t *testing.T, exec execFunc, _ string) { + stdout, _, err := exec(nil, "patch", "pc", "--format", "json") require.Error(t, err, stdout) - }) + }, DefaultProject|PositionalProject|FlagProject) }) } diff --git a/cmd/cloudx/project/patch_test.go b/cmd/cloudx/project/patch_test.go index f521063e..03eb17cd 100644 --- a/cmd/cloudx/project/patch_test.go +++ b/cmd/cloudx/project/patch_test.go @@ -9,147 +9,59 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "github.com/tidwall/gjson" - - "github.com/ory/cli/cmd/cloudx/testhelpers" ) func TestPatchProject(t *testing.T) { t.Run("is able to replace a key", func(t *testing.T) { - testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) - t.Run("explicit project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "project", extraProject, "--format", "json", "--replace", `/services/identity/config/selfservice/methods/password/enabled=false`) - require.NoError(t, err) - assert.False(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.password.enabled").Bool()) - }) - t.Run("default project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "project", "--format", "json", "--replace", `/services/identity/config/selfservice/methods/password/enabled=false`) + runWithProject(t, func(t *testing.T, exec execFunc, _ string) { + stdout, _, err := exec(nil, "patch", "project", "--format", "json", "--replace", `/services/identity/config/selfservice/methods/password/enabled=false`) require.NoError(t, err) assert.False(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.password.enabled").Bool()) - }) + }, DefaultProject|PositionalProject) }) t.Run("is able to add a key", func(t *testing.T) { - testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) - t.Run("explicit project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "project", extraProject, "--format", "json", "--add", `/services/identity/config/selfservice/methods/password/enabled=false`) + runWithProject(t, func(t *testing.T, exec execFunc, _ string) { + stdout, _, err := exec(nil, "patch", "project", "--format", "json", "--add", `/services/identity/config/selfservice/methods/password/enabled=false`) require.NoError(t, err) assert.False(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.password.enabled").Bool()) - }) - t.Run("default project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "project", "--format", "json", "--add", `/services/identity/config/selfservice/methods/password/enabled=false`) - require.NoError(t, err) - assert.False(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.password.enabled").Bool()) - }) + }, DefaultProject|PositionalProject) }) t.Run("is able to add a key with string", func(t *testing.T) { - testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) - t.Run("explicit project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "project", extraProject, "--format", "json", "--replace", "/services/identity/config/selfservice/flows/error/ui_url=\"https://example.com/error-ui\"") + runWithProject(t, func(t *testing.T, exec execFunc, _ string) { + stdout, _, err := exec(nil, "patch", "project", "--format", "json", "--replace", "/services/identity/config/selfservice/flows/error/ui_url=\"https://example.com/error-ui\"") require.NoError(t, err) assert.Equal(t, "https://example.com/error-ui", gjson.Get(stdout, "services.identity.config.selfservice.flows.error.ui_url").String()) - }) - t.Run("default project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "project", "--format", "json", "--replace", "/services/identity/config/selfservice/flows/error/ui_url=\"https://example.com/error-ui\"") - require.NoError(t, err) - assert.Equal(t, "https://example.com/error-ui", gjson.Get(stdout, "services.identity.config.selfservice.flows.error.ui_url").String()) - }) + }, DefaultProject|PositionalProject) }) t.Run("is able to add a key with raw json", func(t *testing.T) { - testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) - t.Run("explicit project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "project", extraProject, "--format", "json", "--replace", `/services/identity/config/selfservice/flows/error={"ui_url":"https://example.org/error-ui"}`) - require.NoError(t, err) - assert.Equal(t, "https://example.org/error-ui", gjson.Get(stdout, "services.identity.config.selfservice.flows.error.ui_url").String()) - }) - t.Run("default project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "project", "--format", "json", "--replace", `/services/identity/config/selfservice/flows/error={"ui_url":"https://example.org/error-ui"}`) + runWithProject(t, func(t *testing.T, exec execFunc, _ string) { + stdout, _, err := exec(nil, "patch", "project", "--format", "json", "--replace", `/services/identity/config/selfservice/flows/error={"ui_url":"https://example.org/error-ui"}`) require.NoError(t, err) assert.Equal(t, "https://example.org/error-ui", gjson.Get(stdout, "services.identity.config.selfservice.flows.error.ui_url").String()) - }) + }, DefaultProject|PositionalProject) }) t.Run("is able to remove a key", func(t *testing.T) { - testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) - t.Run("explicit project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "project", extraProject, "--format", "json", "--remove", `/services/identity/config/selfservice/methods/password/enabled`) + runWithProject(t, func(t *testing.T, exec execFunc, _ string) { + stdout, _, err := exec(nil, "patch", "project", "--format", "json", "--remove", `/services/identity/config/selfservice/methods/password/enabled`) require.NoError(t, err) assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.password.enabled").Bool()) - }) - t.Run("default project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "project", "--format", "json", "--remove", `/services/identity/config/selfservice/methods/password/enabled`) - require.NoError(t, err) - assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.password.enabled").Bool()) - }) + }, DefaultProject|PositionalProject) }) t.Run("fails if no opts are given", func(t *testing.T) { - testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) - t.Run("explicit project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "project", extraProject, "--format", "json") + runWithProject(t, func(t *testing.T, exec execFunc, _ string) { + stdout, _, err := exec(nil, "patch", "project", "--format", "json") require.Error(t, err, stdout) - }) - t.Run("default project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "project", "--format", "json") - require.Error(t, err, stdout) - }) + }, DefaultProject|PositionalProject|FlagProject) }) t.Run("is able to update several keys", func(t *testing.T) { - testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) - t.Run("explicit project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "project", extraProject, "--format", "json", - "--replace", `/services/identity/config/selfservice/methods/link/enabled=true`, - "--replace", `/services/identity/config/selfservice/methods/oidc/enabled=true`, - "--remove", `/services/identity/config/selfservice/methods/profile/enabled`, - "--remove", `/services/identity/config/selfservice/methods/password/enabled`, - "--add", `/services/identity/config/selfservice/methods/totp/enabled=true`, - "--add", `/services/identity/config/selfservice/methods/lookup_secret/enabled=true`, - "-f", "fixtures/patch/1.json", - "-f", "fixtures/patch/2.json", - ) - require.NoError(t, err) - assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.password.enabled").Bool()) - assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.profile.enabled").Bool()) - assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.link.enabled").Bool()) - assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.oidc.enabled").Bool()) - assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.totp.enabled").Bool()) - assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.lookup_secret.enabled").Bool()) - assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.webauthn.enabled").Bool()) - assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.webauthn.config.passwordless").Bool()) - assert.Equal(t, "some value", gjson.Get(stdout, "services.identity.config.selfservice.methods.webauthn.config.rp.display_name").String()) - }) - t.Run("default project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, _, err := defaultCmd.Exec(nil, "patch", "project", "--format", "json", + runWithProject(t, func(t *testing.T, exec execFunc, _ string) { + stdout, _, err := exec(nil, "patch", "project", "--format", "json", "--replace", `/services/identity/config/selfservice/methods/link/enabled=true`, "--replace", `/services/identity/config/selfservice/methods/oidc/enabled=true`, "--remove", `/services/identity/config/selfservice/methods/profile/enabled`, @@ -169,6 +81,6 @@ func TestPatchProject(t *testing.T) { assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.webauthn.enabled").Bool()) assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.webauthn.config.passwordless").Bool()) assert.Equal(t, "some value", gjson.Get(stdout, "services.identity.config.selfservice.methods.webauthn.config.rp.display_name").String()) - }) + }, DefaultProject|PositionalProject) }) } diff --git a/cmd/cloudx/project/update_namespace_config_test.go b/cmd/cloudx/project/update_namespace_config_test.go index 2ae0fe1c..cf4cd7da 100644 --- a/cmd/cloudx/project/update_namespace_config_test.go +++ b/cmd/cloudx/project/update_namespace_config_test.go @@ -12,7 +12,6 @@ import ( "github.com/stretchr/testify/require" "github.com/tidwall/gjson" - "github.com/ory/cli/cmd/cloudx/testhelpers" "github.com/ory/x/fetcher" ) @@ -39,25 +38,8 @@ func TestUpdateNamespaceConfig(t *testing.T) { for _, verb := range verbs { t.Run(fmt.Sprintf("is able to %q the namespace config", verb), func(t *testing.T) { - testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) - t.Run("explicit project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, stderr, err := defaultCmd.Exec(nil, verb, "opl", "--project", extraProject, "--format", "json", "--file", config) - require.NoError(t, err, stderr) - - if !testing.Short() { - // Don't download and compare the config in short mode, might not have internet everywhere - url := gjson.Get(stdout, "namespaces.location").String() - data, err := fetcher.NewFetcher().Fetch(url) - require.NoError(t, err, "could not download the config") - assert.Equal(t, content, data.String(), "the downloaded file does not match what we uploaded") - } - }) - t.Run("default project", func(t *testing.T) { - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - - stdout, stderr, err := defaultCmd.Exec(nil, verb, "opl", "--format", "json", "--file", config) + runWithProject(t, func(t *testing.T, exec execFunc, _ string) { + stdout, stderr, err := exec(nil, verb, "opl", "--format", "json", "--file", config) require.NoError(t, err, stderr) if !testing.Short() { @@ -67,7 +49,7 @@ func TestUpdateNamespaceConfig(t *testing.T) { require.NoError(t, err, "could not download the config") assert.Equal(t, content, data.String(), "the downloaded file does not match what we uploaded") } - }) + }, DefaultProject|FlagProject) }) } } diff --git a/cmd/cloudx/project/use.go b/cmd/cloudx/project/use.go index 4116b1be..5aec7319 100644 --- a/cmd/cloudx/project/use.go +++ b/cmd/cloudx/project/use.go @@ -4,6 +4,8 @@ package project import ( + "fmt" + "github.com/spf13/cobra" "github.com/ory/cli/cmd/cloudx/client" @@ -32,8 +34,9 @@ $ ory use project ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 --format json var id string if len(args) == 0 { - if id, err = h.GetDefaultProjectID(); err != nil { - return cmdx.PrintOpenAPIError(cmd, err) + if id = h.GetDefaultProjectID(); id == "" { + _, _ = fmt.Println("No default project selected") + return nil } } else { id = args[0] @@ -43,7 +46,7 @@ $ ory use project ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 --format json } } - cmdx.PrintRow(cmd, &selectedProject{Id: id}) + cmdx.PrintRow(cmd, &selectedProject{ID: id}) return nil }, } diff --git a/cmd/cloudx/project/utils.go b/cmd/cloudx/project/utils.go index 3a516e2f..2d42a2a1 100644 --- a/cmd/cloudx/project/utils.go +++ b/cmd/cloudx/project/utils.go @@ -6,6 +6,7 @@ package project import ( "encoding/json" + "github.com/pkg/errors" "github.com/spf13/cobra" "github.com/tidwall/sjson" @@ -14,10 +15,12 @@ import ( "github.com/ory/x/cmdx" ) +var defaultProjectNotSetError = errors.New("no project was specified") + func getSelectedProjectId(h *client.CommandHelper, args []string) (string, error) { if len(args) == 0 { - if id, err := h.GetDefaultProjectID(); err != nil { - return "", err + if id := h.GetDefaultProjectID(); id == "" { + return "", defaultProjectNotSetError } else { return id, nil } From 315884c2c8362a5866894d32ed132165f5b3a7c8 Mon Sep 17 00:00:00 2001 From: Henning Fleischhauer <18215579+CaptainStandby@users.noreply.github.com> Date: Thu, 12 Jan 2023 10:04:51 +0100 Subject: [PATCH 16/18] cleanup --- cmd/cloudx/project/get_identity_config.go | 4 ++-- cmd/cloudx/project/get_permission_config.go | 4 ++-- cmd/cloudx/project/patch.go | 4 ++-- cmd/cloudx/project/update.go | 4 ++-- 4 files changed, 8 insertions(+), 8 deletions(-) diff --git a/cmd/cloudx/project/get_identity_config.go b/cmd/cloudx/project/get_identity_config.go index 09d7313d..72e1e76c 100644 --- a/cmd/cloudx/project/get_identity_config.go +++ b/cmd/cloudx/project/get_identity_config.go @@ -35,8 +35,8 @@ $ ory get identity-config ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 --format json return err } - var id string - if id, err = getSelectedProjectId(h, args); err != nil { + id, err := getSelectedProjectId(h, args) + if err != nil { return cmdx.PrintOpenAPIError(cmd, err) } project, err := h.GetProject(id) diff --git a/cmd/cloudx/project/get_permission_config.go b/cmd/cloudx/project/get_permission_config.go index 1d5cc074..76455948 100644 --- a/cmd/cloudx/project/get_permission_config.go +++ b/cmd/cloudx/project/get_permission_config.go @@ -36,8 +36,8 @@ $ ory get permission-config ecaaa3cb-0730-4ee8-a6df-9553cdfeef89 --format json return err } - var id string - if id, err = getSelectedProjectId(h, args); err != nil { + id, err := getSelectedProjectId(h, args) + if err != nil { return cmdx.PrintOpenAPIError(cmd, err) } project, err := h.GetProject(id) diff --git a/cmd/cloudx/project/patch.go b/cmd/cloudx/project/patch.go index 5a26f900..3a8cd6a7 100644 --- a/cmd/cloudx/project/patch.go +++ b/cmd/cloudx/project/patch.go @@ -81,8 +81,8 @@ func runPatch(patchPrefixer func([]string) []string, filePrefixer func([]json.Ra return err } - var id string - if id, err = getSelectedProjectId(h, args); err != nil { + id, err := getSelectedProjectId(h, args) + if err != nil { return cmdx.PrintOpenAPIError(cmd, err) } p, err := h.PatchProject(id, configs, add, replace, remove) diff --git a/cmd/cloudx/project/update.go b/cmd/cloudx/project/update.go index 1ca38ce8..b7ecd4d8 100644 --- a/cmd/cloudx/project/update.go +++ b/cmd/cloudx/project/update.go @@ -121,8 +121,8 @@ func runUpdate(filePrefixer func([]json.RawMessage) ([]json.RawMessage, error), if n := cmd.Flags().Lookup("name"); n != nil { name = n.Value.String() } - var id string - if id, err = getSelectedProjectId(h, args); err != nil { + id, err := getSelectedProjectId(h, args) + if err != nil { return cmdx.PrintOpenAPIError(cmd, err) } p, err := h.UpdateProject(id, name, configs) From 6f605e1ddc6290788fe8690944b18ef4b281370f Mon Sep 17 00:00:00 2001 From: Henning Fleischhauer <18215579+CaptainStandby@users.noreply.github.com> Date: Thu, 12 Jan 2023 18:53:16 +0100 Subject: [PATCH 17/18] fix tests --- cmd/cloudx/project/patch_permission_config_test.go | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/cmd/cloudx/project/patch_permission_config_test.go b/cmd/cloudx/project/patch_permission_config_test.go index 8818d32b..6a9c335f 100644 --- a/cmd/cloudx/project/patch_permission_config_test.go +++ b/cmd/cloudx/project/patch_permission_config_test.go @@ -12,9 +12,9 @@ import ( ) func TestPatchPermissionConfig(t *testing.T) { - t.Run("is able to replace a key", func(t *testing.T) { + t.Run("is able to replace a key using keto-config", func(t *testing.T) { runWithProject(t, func(t *testing.T, exec execFunc, _ string) { - stdout, _, err := exec(nil, "patch", "keto-config", "--format", "json", "--add", `/namespaces=[{"name":"files", "id": 2}]`) + stdout, _, err := exec(nil, "patch", "keto-config", "--format", "json", "--replace", `/namespaces=[{"name":"files", "id": 2}]`) require.NoError(t, err) assert.Equal(t, "files", gjson.Get(stdout, "namespaces.0.name").String(), stdout) }, DefaultProject|PositionalProject) @@ -22,13 +22,16 @@ func TestPatchPermissionConfig(t *testing.T) { t.Run("is able to add a key using permission-config", func(t *testing.T) { runWithProject(t, func(t *testing.T, exec execFunc, _ string) { - stdout, _, err := exec(nil, "patch", "permission-config", "--format", "json", "--add", `/namespaces/1={"name":"docs", "id": 3}`) + _, _, err := exec(nil, "patch", "permission-config", "--format", "json", "--replace", `/namespaces=[]`) require.NoError(t, err) - assert.Equal(t, "docs", gjson.Get(stdout, "namespaces.1.name").String(), stdout) + + stdout, _, err := exec(nil, "patch", "permission-config", "--format", "json", "--add", `/namespaces/0={"name":"docs", "id": 3}`) + require.NoError(t, err) + assert.Equal(t, "docs", gjson.Get(stdout, "namespaces.0.name").String(), stdout) }, DefaultProject|PositionalProject) }) - t.Run("is able to replace a key", func(t *testing.T) { + t.Run("is able to replace a key using pc", func(t *testing.T) { runWithProject(t, func(t *testing.T, exec execFunc, _ string) { stdout, _, err := exec(nil, "patch", "pc", "--format", "json", "--replace", `/namespaces=[{"name":"people", "id": 4}]`) require.NoError(t, err) From 9c229cd97696cc2ad1faed053168949154f7e62f Mon Sep 17 00:00:00 2001 From: Henning Fleischhauer <18215579+CaptainStandby@users.noreply.github.com> Date: Wed, 18 Jan 2023 08:49:05 +0100 Subject: [PATCH 18/18] more idiomatic go --- cmd/cloudx/project/get_test.go | 8 +- cmd/cloudx/project/helper_test.go | 83 +++++++++---------- .../project/patch_identity_config_test.go | 8 +- .../project/patch_oauth2_config_test.go | 8 +- .../project/patch_permission_config_test.go | 8 +- cmd/cloudx/project/patch_test.go | 14 ++-- .../project/update_namespace_config_test.go | 2 +- 7 files changed, 65 insertions(+), 66 deletions(-) diff --git a/cmd/cloudx/project/get_test.go b/cmd/cloudx/project/get_test.go index 1275c5a7..0ef6c1b4 100644 --- a/cmd/cloudx/project/get_test.go +++ b/cmd/cloudx/project/get_test.go @@ -17,7 +17,7 @@ func TestGetProject(t *testing.T) { require.NoError(t, err) assert.Equal(t, projectID, gjson.Get(stdout, "id").String()) assert.NotEmpty(t, gjson.Get(stdout, "slug").String()) - }, DefaultProject|PositionalProject) + }, WithDefaultProject, WithPositionalProject) } func TestGetServiceConfig(t *testing.T) { @@ -26,7 +26,7 @@ func TestGetServiceConfig(t *testing.T) { stdout, _, err := exec(nil, "get", "kratos-config", "--format", "json") require.NoError(t, err) assert.True(t, gjson.Get(stdout, "selfservice.flows.error.ui_url").Exists()) - }, DefaultProject|PositionalProject) + }, WithDefaultProject, WithPositionalProject) }) t.Run("service=keto", func(t *testing.T) { @@ -34,7 +34,7 @@ func TestGetServiceConfig(t *testing.T) { stdout, _, err := exec(nil, "get", "keto-config", "--format", "json") require.NoError(t, err) assert.True(t, gjson.Get(stdout, "namespaces").Exists(), stdout) - }, DefaultProject|PositionalProject) + }, WithDefaultProject, WithPositionalProject) }) t.Run("service=hydra", func(t *testing.T) { @@ -42,6 +42,6 @@ func TestGetServiceConfig(t *testing.T) { stdout, _, err := exec(nil, "get", "oauth2-config", "--format", "json") require.NoError(t, err) assert.True(t, gjson.Get(stdout, "oauth2").Exists(), stdout) - }, DefaultProject|PositionalProject) + }, WithDefaultProject, WithPositionalProject) }) } diff --git a/cmd/cloudx/project/helper_test.go b/cmd/cloudx/project/helper_test.go index de720140..50caf4e7 100644 --- a/cmd/cloudx/project/helper_test.go +++ b/cmd/cloudx/project/helper_test.go @@ -14,51 +14,50 @@ import ( type execFunc func(stdin io.Reader, args ...string) (string, string, error) -type bits uint8 +type RunWithProjectOption uint8 const ( - DefaultProject bits = 1 << iota - PositionalProject - FlagProject + WithDefaultProject RunWithProjectOption = 1 << iota + WithPositionalProject + WithFlagProject ) -func runWithProject(t *testing.T, test func(t *testing.T, exec execFunc, projectID string), argPosition bits) { - if argPosition&DefaultProject != 0 { - t.Run("project via configured default", func(t *testing.T) { - testhelpers.SetDefaultProject(t, defaultConfig, extraProject) - - test(t, func(stdin io.Reader, args ...string) (string, string, error) { - return defaultCmd.Exec(stdin, args...) - }, extraProject) - - // make sure, the default wasn't changed implicitly - assert.Equal(t, extraProject, testhelpers.GetDefaultProject(t, defaultConfig)) - }) - } - - if argPosition&PositionalProject != 0 { - t.Run("explicit project via positional argument", func(t *testing.T) { - testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) - - test(t, func(stdin io.Reader, args ...string) (string, string, error) { - return defaultCmd.Exec(stdin, append(args, extraProject)...) - }, extraProject) - - // make sure, the default wasn't changed implicitly - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - }) - } - - if argPosition&FlagProject != 0 { - t.Run("explicit project via `--project` flag", func(t *testing.T) { - testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) - - test(t, func(stdin io.Reader, args ...string) (string, string, error) { - return defaultCmd.Exec(stdin, append(args, "--project", extraProject)...) - }, extraProject) - - // make sure, the default wasn't changed implicitly - assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) - }) +func runWithProject(t *testing.T, test func(t *testing.T, exec execFunc, projectID string), opts ...RunWithProjectOption) { + for _, v := range opts { + switch v { + case WithDefaultProject: + t.Run("project via configured default", func(t *testing.T) { + testhelpers.SetDefaultProject(t, defaultConfig, extraProject) + + test(t, func(stdin io.Reader, args ...string) (string, string, error) { + return defaultCmd.Exec(stdin, args...) + }, extraProject) + + // make sure, the default wasn't changed implicitly + assert.Equal(t, extraProject, testhelpers.GetDefaultProject(t, defaultConfig)) + }) + case WithPositionalProject: + t.Run("explicit project via positional argument", func(t *testing.T) { + testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) + + test(t, func(stdin io.Reader, args ...string) (string, string, error) { + return defaultCmd.Exec(stdin, append(args, extraProject)...) + }, extraProject) + + // make sure, the default wasn't changed implicitly + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + }) + case WithFlagProject: + t.Run("explicit project via `--project` flag", func(t *testing.T) { + testhelpers.SetDefaultProject(t, defaultConfig, defaultProject) + + test(t, func(stdin io.Reader, args ...string) (string, string, error) { + return defaultCmd.Exec(stdin, append(args, "--project", extraProject)...) + }, extraProject) + + // make sure, the default wasn't changed implicitly + assert.Equal(t, defaultProject, testhelpers.GetDefaultProject(t, defaultConfig)) + }) + } } } diff --git a/cmd/cloudx/project/patch_identity_config_test.go b/cmd/cloudx/project/patch_identity_config_test.go index 14b20525..8a1c79cb 100644 --- a/cmd/cloudx/project/patch_identity_config_test.go +++ b/cmd/cloudx/project/patch_identity_config_test.go @@ -17,7 +17,7 @@ func TestPatchKratosConfig(t *testing.T) { stdout, _, err := exec(nil, "patch", "kratos-config", "--format", "json", "--replace", `/selfservice/methods/password/enabled=false`) require.NoError(t, err) assert.False(t, gjson.Get(stdout, "selfservice.methods.password.enabled").Bool()) - }, DefaultProject|PositionalProject) + }, WithDefaultProject, WithPositionalProject) }) t.Run("is able to add a key", func(t *testing.T) { @@ -25,7 +25,7 @@ func TestPatchKratosConfig(t *testing.T) { stdout, _, err := exec(nil, "patch", "identity-config", "--format", "json", "--add", `/selfservice/methods/password/enabled=false`) require.NoError(t, err) assert.False(t, gjson.Get(stdout, "selfservice.methods.password.enabled").Bool()) - }, DefaultProject|PositionalProject) + }, WithDefaultProject, WithPositionalProject) }) t.Run("is able to add a key with string", func(t *testing.T) { @@ -33,13 +33,13 @@ func TestPatchKratosConfig(t *testing.T) { stdout, _, err := exec(nil, "patch", "ic", "--format", "json", "--replace", "/selfservice/flows/error/ui_url=\"https://example.com/error-ui\"") require.NoError(t, err) assert.Equal(t, "https://example.com/error-ui", gjson.Get(stdout, "selfservice.flows.error.ui_url").String()) - }, DefaultProject|PositionalProject) + }, WithDefaultProject, WithPositionalProject) }) t.Run("fails if no opts are given", func(t *testing.T) { runWithProject(t, func(t *testing.T, exec execFunc, _ string) { stdout, _, err := exec(nil, "patch", "ic", "--format", "json") require.Error(t, err, stdout) - }, DefaultProject|PositionalProject|FlagProject) + }, WithDefaultProject, WithPositionalProject, WithFlagProject) }) } diff --git a/cmd/cloudx/project/patch_oauth2_config_test.go b/cmd/cloudx/project/patch_oauth2_config_test.go index 747f3475..18576afe 100644 --- a/cmd/cloudx/project/patch_oauth2_config_test.go +++ b/cmd/cloudx/project/patch_oauth2_config_test.go @@ -17,7 +17,7 @@ func TestPatchHydraConfig(t *testing.T) { stdout, _, err := exec(nil, "patch", "hydra-config", "--format", "json", "--replace", `/strategies/access_token="jwt"`) require.NoError(t, err) assert.Equal(t, "jwt", gjson.Get(stdout, "strategies.access_token").String()) - }, DefaultProject|PositionalProject) + }, WithDefaultProject, WithPositionalProject) }) t.Run("is able to add a key", func(t *testing.T) { @@ -25,7 +25,7 @@ func TestPatchHydraConfig(t *testing.T) { stdout, _, err := exec(nil, "patch", "oauth2-config", "--format", "json", "--add", `/ttl/login_consent_request="1h"`) require.NoError(t, err) assert.Equal(t, "1h0m0s", gjson.Get(stdout, "ttl.login_consent_request").String()) - }, DefaultProject|PositionalProject) + }, WithDefaultProject, WithPositionalProject) }) t.Run("is able to add a key with string", func(t *testing.T) { @@ -33,13 +33,13 @@ func TestPatchHydraConfig(t *testing.T) { stdout, _, err := exec(nil, "patch", "oc", "--format", "json", "--replace", `/ttl/refresh_token="2h"`) require.NoError(t, err) assert.Equal(t, "2h0m0s", gjson.Get(stdout, "ttl.refresh_token").String()) - }, DefaultProject|PositionalProject) + }, WithDefaultProject, WithPositionalProject) }) t.Run("fails if no opts are given", func(t *testing.T) { runWithProject(t, func(t *testing.T, exec execFunc, _ string) { stdout, _, err := exec(nil, "patch", "oc", "--format", "json") require.Error(t, err, stdout) - }, DefaultProject|PositionalProject|FlagProject) + }, WithDefaultProject, WithPositionalProject, WithFlagProject) }) } diff --git a/cmd/cloudx/project/patch_permission_config_test.go b/cmd/cloudx/project/patch_permission_config_test.go index 6a9c335f..09e18aee 100644 --- a/cmd/cloudx/project/patch_permission_config_test.go +++ b/cmd/cloudx/project/patch_permission_config_test.go @@ -17,7 +17,7 @@ func TestPatchPermissionConfig(t *testing.T) { stdout, _, err := exec(nil, "patch", "keto-config", "--format", "json", "--replace", `/namespaces=[{"name":"files", "id": 2}]`) require.NoError(t, err) assert.Equal(t, "files", gjson.Get(stdout, "namespaces.0.name").String(), stdout) - }, DefaultProject|PositionalProject) + }, WithDefaultProject, WithPositionalProject) }) t.Run("is able to add a key using permission-config", func(t *testing.T) { @@ -28,7 +28,7 @@ func TestPatchPermissionConfig(t *testing.T) { stdout, _, err := exec(nil, "patch", "permission-config", "--format", "json", "--add", `/namespaces/0={"name":"docs", "id": 3}`) require.NoError(t, err) assert.Equal(t, "docs", gjson.Get(stdout, "namespaces.0.name").String(), stdout) - }, DefaultProject|PositionalProject) + }, WithDefaultProject, WithPositionalProject) }) t.Run("is able to replace a key using pc", func(t *testing.T) { @@ -36,13 +36,13 @@ func TestPatchPermissionConfig(t *testing.T) { stdout, _, err := exec(nil, "patch", "pc", "--format", "json", "--replace", `/namespaces=[{"name":"people", "id": 4}]`) require.NoError(t, err) assert.Equal(t, "people", gjson.Get(stdout, "namespaces.0.name").String(), stdout) - }, DefaultProject|PositionalProject) + }, WithDefaultProject, WithPositionalProject) }) t.Run("fails if no opts are given", func(t *testing.T) { runWithProject(t, func(t *testing.T, exec execFunc, _ string) { stdout, _, err := exec(nil, "patch", "pc", "--format", "json") require.Error(t, err, stdout) - }, DefaultProject|PositionalProject|FlagProject) + }, WithDefaultProject, WithPositionalProject, WithFlagProject) }) } diff --git a/cmd/cloudx/project/patch_test.go b/cmd/cloudx/project/patch_test.go index 03eb17cd..ea06b57d 100644 --- a/cmd/cloudx/project/patch_test.go +++ b/cmd/cloudx/project/patch_test.go @@ -17,7 +17,7 @@ func TestPatchProject(t *testing.T) { stdout, _, err := exec(nil, "patch", "project", "--format", "json", "--replace", `/services/identity/config/selfservice/methods/password/enabled=false`) require.NoError(t, err) assert.False(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.password.enabled").Bool()) - }, DefaultProject|PositionalProject) + }, WithDefaultProject, WithPositionalProject) }) t.Run("is able to add a key", func(t *testing.T) { @@ -25,7 +25,7 @@ func TestPatchProject(t *testing.T) { stdout, _, err := exec(nil, "patch", "project", "--format", "json", "--add", `/services/identity/config/selfservice/methods/password/enabled=false`) require.NoError(t, err) assert.False(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.password.enabled").Bool()) - }, DefaultProject|PositionalProject) + }, WithDefaultProject, WithPositionalProject) }) t.Run("is able to add a key with string", func(t *testing.T) { @@ -33,7 +33,7 @@ func TestPatchProject(t *testing.T) { stdout, _, err := exec(nil, "patch", "project", "--format", "json", "--replace", "/services/identity/config/selfservice/flows/error/ui_url=\"https://example.com/error-ui\"") require.NoError(t, err) assert.Equal(t, "https://example.com/error-ui", gjson.Get(stdout, "services.identity.config.selfservice.flows.error.ui_url").String()) - }, DefaultProject|PositionalProject) + }, WithDefaultProject, WithPositionalProject) }) t.Run("is able to add a key with raw json", func(t *testing.T) { @@ -41,7 +41,7 @@ func TestPatchProject(t *testing.T) { stdout, _, err := exec(nil, "patch", "project", "--format", "json", "--replace", `/services/identity/config/selfservice/flows/error={"ui_url":"https://example.org/error-ui"}`) require.NoError(t, err) assert.Equal(t, "https://example.org/error-ui", gjson.Get(stdout, "services.identity.config.selfservice.flows.error.ui_url").String()) - }, DefaultProject|PositionalProject) + }, WithDefaultProject, WithPositionalProject) }) t.Run("is able to remove a key", func(t *testing.T) { @@ -49,14 +49,14 @@ func TestPatchProject(t *testing.T) { stdout, _, err := exec(nil, "patch", "project", "--format", "json", "--remove", `/services/identity/config/selfservice/methods/password/enabled`) require.NoError(t, err) assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.password.enabled").Bool()) - }, DefaultProject|PositionalProject) + }, WithDefaultProject, WithPositionalProject) }) t.Run("fails if no opts are given", func(t *testing.T) { runWithProject(t, func(t *testing.T, exec execFunc, _ string) { stdout, _, err := exec(nil, "patch", "project", "--format", "json") require.Error(t, err, stdout) - }, DefaultProject|PositionalProject|FlagProject) + }, WithDefaultProject, WithPositionalProject, WithFlagProject) }) t.Run("is able to update several keys", func(t *testing.T) { @@ -81,6 +81,6 @@ func TestPatchProject(t *testing.T) { assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.webauthn.enabled").Bool()) assert.True(t, gjson.Get(stdout, "services.identity.config.selfservice.methods.webauthn.config.passwordless").Bool()) assert.Equal(t, "some value", gjson.Get(stdout, "services.identity.config.selfservice.methods.webauthn.config.rp.display_name").String()) - }, DefaultProject|PositionalProject) + }, WithDefaultProject, WithPositionalProject) }) } diff --git a/cmd/cloudx/project/update_namespace_config_test.go b/cmd/cloudx/project/update_namespace_config_test.go index cf4cd7da..f9a41694 100644 --- a/cmd/cloudx/project/update_namespace_config_test.go +++ b/cmd/cloudx/project/update_namespace_config_test.go @@ -49,7 +49,7 @@ func TestUpdateNamespaceConfig(t *testing.T) { require.NoError(t, err, "could not download the config") assert.Equal(t, content, data.String(), "the downloaded file does not match what we uploaded") } - }, DefaultProject|FlagProject) + }, WithDefaultProject, WithFlagProject) }) } }