From 1239a795a038774163a9268dd7d29277e7bd9e38 Mon Sep 17 00:00:00 2001 From: Danny Olson Date: Thu, 11 Apr 2024 10:36:53 -0700 Subject: [PATCH 1/5] WIP --- cmd/flags/create.go | 18 ++++++++++++------ cmd/flags/flags.go | 5 +++-- cmd/quickstart.go | 14 ++++++++++---- cmd/root.go | 21 +++++++++++++++++++-- cmd/validators/validators.go | 13 +++++++++++++ 5 files changed, 57 insertions(+), 14 deletions(-) diff --git a/cmd/flags/create.go b/cmd/flags/create.go index a8bc0bbf..dae74ba8 100644 --- a/cmd/flags/create.go +++ b/cmd/flags/create.go @@ -13,13 +13,14 @@ import ( "ldcli/internal/flags" ) -func NewCreateCmd(client flags.Client) (*cobra.Command, error) { +func NewCreateCmd(client flags.Client, rebindFn func() func(*cobra.Command, []string)) (*cobra.Command, error) { cmd := &cobra.Command{ - Args: validators.Validate(), - Long: "Create a new flag", - RunE: runCreate(client), - Short: "Create a new flag", - Use: "create", + Args: validators.Validate(), + Long: "Create a new flag", + RunE: runCreate(client), + Short: "Create a new flag", + Use: "create", + PreRun: rebindFn(), } cmd.Flags().StringP(cliflags.DataFlag, "d", "", "Input data in JSON") @@ -52,6 +53,11 @@ type inputData struct { func runCreate(client flags.Client) func(*cobra.Command, []string) error { return func(cmd *cobra.Command, args []string) error { + fmt.Println( + ">>> runCreate", + viper.GetString(cliflags.AccessTokenFlag), + viper.GetString(cliflags.BaseURIFlag), + ) // rebind flags used in other subcommands _ = viper.BindPFlag(cliflags.DataFlag, cmd.Flags().Lookup(cliflags.DataFlag)) _ = viper.BindPFlag(cliflags.ProjectFlag, cmd.Flags().Lookup(cliflags.ProjectFlag)) diff --git a/cmd/flags/flags.go b/cmd/flags/flags.go index 7e1b6cd7..36c1eede 100644 --- a/cmd/flags/flags.go +++ b/cmd/flags/flags.go @@ -6,14 +6,15 @@ import ( "ldcli/internal/flags" ) -func NewFlagsCmd(client flags.Client) (*cobra.Command, error) { +func NewFlagsCmd(client flags.Client, rebindFn func() func(*cobra.Command, []string)) (*cobra.Command, error) { cmd := &cobra.Command{ Use: "flags", Short: "Make requests (list, create, etc.) on flags", Long: "Make requests (list, create, etc.) on flags", + // PreRun: rebindFn(), } - createCmd, err := NewCreateCmd(client) + createCmd, err := NewCreateCmd(client, rebindFn) if err != nil { return nil, err } diff --git a/cmd/quickstart.go b/cmd/quickstart.go index 23b27eba..bca8b1c7 100644 --- a/cmd/quickstart.go +++ b/cmd/quickstart.go @@ -20,10 +20,11 @@ func NewQuickStartCmd( flagsClient flags.Client, ) *cobra.Command { return &cobra.Command{ - Long: "", - RunE: runQuickStart(environmentsClient, flagsClient), - Short: "Setup guide to create your first feature flag", - Use: "setup", + Long: "", + PreRun: RebindFlags(), + RunE: runQuickStart(environmentsClient, flagsClient), + Short: "Setup guide to create your first feature flag", + Use: "setup", } } @@ -38,6 +39,11 @@ func runQuickStart( os.Exit(1) } defer f.Close() + fmt.Println( + ">>> runQuickStart", + viper.GetString(cliflags.AccessTokenFlag), + viper.GetString(cliflags.BaseURIFlag), + ) _, err = tea.NewProgram(quickstart.NewContainerModel( environmentsClient, diff --git a/cmd/root.go b/cmd/root.go index 6da950f7..cfe55309 100644 --- a/cmd/root.go +++ b/cmd/root.go @@ -4,6 +4,7 @@ import ( "fmt" "log" "os" + "strings" "github.com/spf13/cobra" "github.com/spf13/viper" @@ -39,7 +40,6 @@ func NewRootCommand( cmd.DisableFlagParsing = true } }, - // Handle errors differently based on type. // We don't want to show the usage if the user has the right structure but invalid data such as // the wrong key. @@ -47,6 +47,11 @@ func NewRootCommand( SilenceUsage: true, } + viper.SetEnvPrefix("LD") + replacer := strings.NewReplacer("-", "_") + viper.SetEnvKeyReplacer(replacer) + viper.AutomaticEnv() + cmd.PersistentFlags().String( cliflags.AccessTokenFlag, "", @@ -75,7 +80,7 @@ func NewRootCommand( if err != nil { return nil, err } - flagsCmd, err := flagscmd.NewFlagsCmd(flagsClient) + flagsCmd, err := flagscmd.NewFlagsCmd(flagsClient, RebindFlags) if err != nil { return nil, err } @@ -115,3 +120,15 @@ func Execute(analyticsTracker analytics.Tracker, version string) { fmt.Fprintln(os.Stderr, err.Error()) } } + +func RebindFlags() func(*cobra.Command, []string) { + return func(cmd *cobra.Command, args []string) { + // fmt.Println(">>> RebindFlags", cmd.Name()) + // _ = viper.BindPFlags(cmd.Flags()) + // cmd.Flags().VisitAll(func(f *pflag.Flag) { + // if viper.IsSet(f.Name) && viper.GetString(f.Name) != "" { + // _ = cmd.Flags().Set(f.Name, viper.GetString(f.Name)) + // } + // }) + } +} diff --git a/cmd/validators/validators.go b/cmd/validators/validators.go index f527cc53..0ecce005 100644 --- a/cmd/validators/validators.go +++ b/cmd/validators/validators.go @@ -6,15 +6,28 @@ import ( "net/url" "github.com/spf13/cobra" + "github.com/spf13/pflag" "github.com/spf13/viper" "ldcli/cmd/cliflags" errs "ldcli/internal/errors" ) +func RebindFlags(cmd *cobra.Command, args []string) { + fmt.Println(">>> RebindFlags", cmd.Name()) + _ = viper.BindPFlags(cmd.Flags()) + cmd.Flags().VisitAll(func(f *pflag.Flag) { + if viper.IsSet(f.Name) && viper.GetString(f.Name) != "" { + _ = cmd.Flags().Set(f.Name, viper.GetString(f.Name)) + } + }) +} + // Validate is a validator for commands to print an error when the user input is invalid. func Validate() cobra.PositionalArgs { return func(cmd *cobra.Command, args []string) error { + fmt.Println(">>> Validate()") + RebindFlags(cmd, cmd.ValidArgs) commandPath := getCommandPath(cmd) _, err := url.ParseRequestURI(viper.GetString(cliflags.BaseURIFlag)) From e98b4ec69f04634b3e6cfcc0d202ba51aa6db3c9 Mon Sep 17 00:00:00 2001 From: Danny Olson Date: Fri, 12 Apr 2024 04:48:43 -0700 Subject: [PATCH 2/5] Rebind flags before validating commands --- cmd/flags/create.go | 13 ++++++------- cmd/flags/flags.go | 5 ++--- cmd/quickstart.go | 11 ++++++----- cmd/root.go | 14 +------------- cmd/validators/validators.go | 24 ++++++++++++------------ 5 files changed, 27 insertions(+), 40 deletions(-) diff --git a/cmd/flags/create.go b/cmd/flags/create.go index dae74ba8..ec560e90 100644 --- a/cmd/flags/create.go +++ b/cmd/flags/create.go @@ -13,14 +13,13 @@ import ( "ldcli/internal/flags" ) -func NewCreateCmd(client flags.Client, rebindFn func() func(*cobra.Command, []string)) (*cobra.Command, error) { +func NewCreateCmd(client flags.Client) (*cobra.Command, error) { cmd := &cobra.Command{ - Args: validators.Validate(), - Long: "Create a new flag", - RunE: runCreate(client), - Short: "Create a new flag", - Use: "create", - PreRun: rebindFn(), + Args: validators.Validate(), + Long: "Create a new flag", + RunE: runCreate(client), + Short: "Create a new flag", + Use: "create", } cmd.Flags().StringP(cliflags.DataFlag, "d", "", "Input data in JSON") diff --git a/cmd/flags/flags.go b/cmd/flags/flags.go index 36c1eede..7e1b6cd7 100644 --- a/cmd/flags/flags.go +++ b/cmd/flags/flags.go @@ -6,15 +6,14 @@ import ( "ldcli/internal/flags" ) -func NewFlagsCmd(client flags.Client, rebindFn func() func(*cobra.Command, []string)) (*cobra.Command, error) { +func NewFlagsCmd(client flags.Client) (*cobra.Command, error) { cmd := &cobra.Command{ Use: "flags", Short: "Make requests (list, create, etc.) on flags", Long: "Make requests (list, create, etc.) on flags", - // PreRun: rebindFn(), } - createCmd, err := NewCreateCmd(client, rebindFn) + createCmd, err := NewCreateCmd(client) if err != nil { return nil, err } diff --git a/cmd/quickstart.go b/cmd/quickstart.go index bca8b1c7..0601ceeb 100644 --- a/cmd/quickstart.go +++ b/cmd/quickstart.go @@ -10,6 +10,7 @@ import ( "github.com/spf13/viper" "ldcli/cmd/cliflags" + "ldcli/cmd/validators" "ldcli/internal/environments" "ldcli/internal/flags" "ldcli/internal/quickstart" @@ -20,11 +21,11 @@ func NewQuickStartCmd( flagsClient flags.Client, ) *cobra.Command { return &cobra.Command{ - Long: "", - PreRun: RebindFlags(), - RunE: runQuickStart(environmentsClient, flagsClient), - Short: "Setup guide to create your first feature flag", - Use: "setup", + Args: validators.Validate(), + Long: "", + RunE: runQuickStart(environmentsClient, flagsClient), + Short: "Setup guide to create your first feature flag", + Use: "setup", } } diff --git a/cmd/root.go b/cmd/root.go index cfe55309..82089c3d 100644 --- a/cmd/root.go +++ b/cmd/root.go @@ -80,7 +80,7 @@ func NewRootCommand( if err != nil { return nil, err } - flagsCmd, err := flagscmd.NewFlagsCmd(flagsClient, RebindFlags) + flagsCmd, err := flagscmd.NewFlagsCmd(flagsClient) if err != nil { return nil, err } @@ -120,15 +120,3 @@ func Execute(analyticsTracker analytics.Tracker, version string) { fmt.Fprintln(os.Stderr, err.Error()) } } - -func RebindFlags() func(*cobra.Command, []string) { - return func(cmd *cobra.Command, args []string) { - // fmt.Println(">>> RebindFlags", cmd.Name()) - // _ = viper.BindPFlags(cmd.Flags()) - // cmd.Flags().VisitAll(func(f *pflag.Flag) { - // if viper.IsSet(f.Name) && viper.GetString(f.Name) != "" { - // _ = cmd.Flags().Set(f.Name, viper.GetString(f.Name)) - // } - // }) - } -} diff --git a/cmd/validators/validators.go b/cmd/validators/validators.go index 0ecce005..7e96c79a 100644 --- a/cmd/validators/validators.go +++ b/cmd/validators/validators.go @@ -13,21 +13,10 @@ import ( errs "ldcli/internal/errors" ) -func RebindFlags(cmd *cobra.Command, args []string) { - fmt.Println(">>> RebindFlags", cmd.Name()) - _ = viper.BindPFlags(cmd.Flags()) - cmd.Flags().VisitAll(func(f *pflag.Flag) { - if viper.IsSet(f.Name) && viper.GetString(f.Name) != "" { - _ = cmd.Flags().Set(f.Name, viper.GetString(f.Name)) - } - }) -} - // Validate is a validator for commands to print an error when the user input is invalid. func Validate() cobra.PositionalArgs { return func(cmd *cobra.Command, args []string) error { - fmt.Println(">>> Validate()") - RebindFlags(cmd, cmd.ValidArgs) + rebindFlags(cmd, cmd.ValidArgs) // rebind flags before validating them below commandPath := getCommandPath(cmd) _, err := url.ParseRequestURI(viper.GetString(cliflags.BaseURIFlag)) @@ -65,3 +54,14 @@ func getCommandPath(cmd *cobra.Command) string { return commandPath } + +// rebindFlags sets the command's flags based on the values stored in viper because they may not +// be set yet when they (the flags) are set from environment variables or a configuration file. +func rebindFlags(cmd *cobra.Command, _ []string) { + _ = viper.BindPFlags(cmd.Flags()) + cmd.Flags().VisitAll(func(f *pflag.Flag) { + if viper.IsSet(f.Name) && viper.GetString(f.Name) != "" { + _ = cmd.Flags().Set(f.Name, viper.GetString(f.Name)) + } + }) +} From c28eb5f40dd28532e2345b55ef38df35409fbc2d Mon Sep 17 00:00:00 2001 From: Danny Olson Date: Fri, 12 Apr 2024 05:03:10 -0700 Subject: [PATCH 3/5] Test env var support --- cmd/cmdtest.go | 12 ++++++++++++ cmd/flags/create_test.go | 22 +++++++++++++++++++++- 2 files changed, 33 insertions(+), 1 deletion(-) diff --git a/cmd/cmdtest.go b/cmd/cmdtest.go index 9ac56658..4000e2d4 100644 --- a/cmd/cmdtest.go +++ b/cmd/cmdtest.go @@ -3,6 +3,7 @@ package cmd import ( "bytes" "io" + "os" "testing" "github.com/stretchr/testify/require" @@ -47,3 +48,14 @@ func CallCmd( return out, nil } + +// SetupTestEnvVars sets up and tears down tests for checking that environment variables are set. +func SetupTestEnvVars(_ *testing.T) func(t *testing.T) { + os.Setenv("LD_ACCESS_TOKEN", "testAccessToken") + os.Setenv("LD_BASE_URI", "http://test.com") + + return func(t *testing.T) { + os.Unsetenv("LD_ACCESS_TOKEN") + os.Unsetenv("LD_BASE_URI") + } +} diff --git a/cmd/flags/create_test.go b/cmd/flags/create_test.go index 3f242472..398dd089 100644 --- a/cmd/flags/create_test.go +++ b/cmd/flags/create_test.go @@ -1,12 +1,12 @@ package flags_test import ( - "ldcli/cmd" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + "ldcli/cmd" "ldcli/internal/errors" "ldcli/internal/flags" ) @@ -20,6 +20,7 @@ func TestCreate(t *testing.T) { "test-key", "test-proj-key", } + t.Run("with valid flags calls projects API", func(t *testing.T) { client := flags.MockClient{} client. @@ -39,6 +40,25 @@ func TestCreate(t *testing.T) { assert.JSONEq(t, `{"valid": true}`, string(output)) }) + t.Run("with valid flags from environment variables calls projects API", func(t *testing.T) { + teardownTest := cmd.SetupTestEnvVars(t) + defer teardownTest(t) + client := flags.MockClient{} + client. + On("Create", mockArgs...). + Return([]byte(cmd.ValidResponse), nil) + args := []string{ + "flags", "create", + "-d", `{"key": "test-key", "name": "test-name"}`, + "--project", "test-proj-key", + } + + output, err := cmd.CallCmd(t, nil, &client, nil, nil, args) + + require.NoError(t, err) + assert.JSONEq(t, `{"valid": true}`, string(output)) + }) + t.Run("with an error response is an error", func(t *testing.T) { client := flags.MockClient{} client. From e15b0dca88533e5c111b8bbf5018eb913cda6e35 Mon Sep 17 00:00:00 2001 From: Danny Olson Date: Fri, 12 Apr 2024 05:23:34 -0700 Subject: [PATCH 4/5] Backfill tests --- cmd/environments/get_test.go | 26 +++++++++++++++++++++++-- cmd/flags/create_test.go | 4 ++-- cmd/flags/update_test.go | 24 +++++++++++++++++++++-- cmd/members/create_test.go | 36 +++++++++++++++++++++++++++-------- cmd/members/invite_test.go | 37 ++++++++++++++++++++++++++++-------- cmd/projects/create_test.go | 29 +++++++++++++++++++++++----- cmd/projects/list_test.go | 20 ++++++++++++++++++- 7 files changed, 148 insertions(+), 28 deletions(-) diff --git a/cmd/environments/get_test.go b/cmd/environments/get_test.go index 173fb58d..2bd2c461 100644 --- a/cmd/environments/get_test.go +++ b/cmd/environments/get_test.go @@ -15,11 +15,12 @@ func TestGet(t *testing.T) { errorHelp := ". See `ldcli environments get --help` for supported flags and usage." mockArgs := []interface{}{ "testAccessToken", - "https://app.launchdarkly.com", + "http://test.com", "test-env", "test-proj", } - t.Run("with valid environments calls projects API", func(t *testing.T) { + + t.Run("with valid environments calls API", func(t *testing.T) { client := environments.MockClient{} client. On("Get", mockArgs...). @@ -27,6 +28,26 @@ func TestGet(t *testing.T) { args := []string{ "environments", "get", "--access-token", "testAccessToken", + "--base-uri", "http://test.com", + "--environment", "test-env", + "--project", "test-proj", + } + + output, err := cmd.CallCmd(t, &client, nil, nil, nil, args) + + require.NoError(t, err) + assert.JSONEq(t, `{"valid": true}`, string(output)) + }) + + t.Run("with valid flags from environment variables calls API", func(t *testing.T) { + teardownTest := cmd.SetupTestEnvVars(t) + defer teardownTest(t) + client := environments.MockClient{} + client. + On("Get", mockArgs...). + Return([]byte(cmd.ValidResponse), nil) + args := []string{ + "environments", "get", "--environment", "test-env", "--project", "test-proj", } @@ -45,6 +66,7 @@ func TestGet(t *testing.T) { args := []string{ "environments", "get", "--access-token", "testAccessToken", + "--base-uri", "http://test.com", "--environment", "test-env", "--project", "test-proj", } diff --git a/cmd/flags/create_test.go b/cmd/flags/create_test.go index 398dd089..80e798b0 100644 --- a/cmd/flags/create_test.go +++ b/cmd/flags/create_test.go @@ -21,7 +21,7 @@ func TestCreate(t *testing.T) { "test-proj-key", } - t.Run("with valid flags calls projects API", func(t *testing.T) { + t.Run("with valid flags calls API", func(t *testing.T) { client := flags.MockClient{} client. On("Create", mockArgs...). @@ -40,7 +40,7 @@ func TestCreate(t *testing.T) { assert.JSONEq(t, `{"valid": true}`, string(output)) }) - t.Run("with valid flags from environment variables calls projects API", func(t *testing.T) { + t.Run("with valid flags from environment variables calls API", func(t *testing.T) { teardownTest := cmd.SetupTestEnvVars(t) defer teardownTest(t) client := flags.MockClient{} diff --git a/cmd/flags/update_test.go b/cmd/flags/update_test.go index 1c30e29f..8c2c1072 100644 --- a/cmd/flags/update_test.go +++ b/cmd/flags/update_test.go @@ -26,7 +26,7 @@ func TestUpdate(t *testing.T) { }, }, } - t.Run("with valid flags calls projects API", func(t *testing.T) { + t.Run("with valid flags calls API", func(t *testing.T) { client := flags.MockClient{} client. On("Update", mockArgs...). @@ -46,6 +46,26 @@ func TestUpdate(t *testing.T) { assert.JSONEq(t, `{"valid": true}`, string(output)) }) + t.Run("with valid flags from environment variables calls API", func(t *testing.T) { + teardownTest := cmd.SetupTestEnvVars(t) + defer teardownTest(t) + client := flags.MockClient{} + client. + On("Update", mockArgs...). + Return([]byte(cmd.ValidResponse), nil) + args := []string{ + "flags", "update", + "-d", `[{"op": "replace", "path": "/name", "value": "new-name"}]`, + "--flag", "test-key", + "--project", "test-proj-key", + } + + output, err := cmd.CallCmd(t, nil, &client, nil, nil, args) + + require.NoError(t, err) + assert.JSONEq(t, `{"valid": true}`, string(output)) + }) + t.Run("with an error response is an error", func(t *testing.T) { client := flags.MockClient{} client. @@ -105,7 +125,7 @@ func TestToggle(t *testing.T) { }, }, } - t.Run("with valid flags calls projects API", func(t *testing.T) { + t.Run("with valid flags calls API", func(t *testing.T) { client := flags.MockClient{} client. On("Update", mockArgs...). diff --git a/cmd/members/create_test.go b/cmd/members/create_test.go index 3777aa16..f48ed688 100644 --- a/cmd/members/create_test.go +++ b/cmd/members/create_test.go @@ -19,6 +19,7 @@ func TestCreate(t *testing.T) { "http://test.com", []members.MemberInput{{Email: "testemail@test.com", Role: role}}, } + t.Run("with valid flags calls members API", func(t *testing.T) { client := members.MockClient{} client. @@ -27,10 +28,31 @@ func TestCreate(t *testing.T) { args := []string{ "members", "create", - "--access-token", - "testAccessToken", - "--base-uri", - "http://test.com", + "--access-token", "testAccessToken", + "--base-uri", "http://test.com", + "-d", + `[{"email": "testemail@test.com", "role": "writer"}]`, + } + + output, err := cmd.CallCmd(t, nil, nil, &client, nil, args) + + require.NoError(t, err) + assert.JSONEq(t, `{"valid": true}`, string(output)) + }) + + t.Run("with valid flags from environment variables calls API", func(t *testing.T) { + teardownTest := cmd.SetupTestEnvVars(t) + defer teardownTest(t) + client := members.MockClient{} + client. + On("Update", mockArgs...). + Return([]byte(cmd.ValidResponse), nil) + client. + On("Create", mockArgs...). + Return([]byte(cmd.ValidResponse), nil) + args := []string{ + "members", + "create", "-d", `[{"email": "testemail@test.com", "role": "writer"}]`, } @@ -49,10 +71,8 @@ func TestCreate(t *testing.T) { args := []string{ "members", "create", - "--access-token", - "testAccessToken", - "--base-uri", - "http://test.com", + "--access-token", "testAccessToken", + "--base-uri", "http://test.com", "-d", `[{"email": "testemail@test.com", "role": "writer"}]`, } diff --git a/cmd/members/invite_test.go b/cmd/members/invite_test.go index dca67ebc..becd88c5 100644 --- a/cmd/members/invite_test.go +++ b/cmd/members/invite_test.go @@ -22,6 +22,7 @@ func TestInvite(t *testing.T) { {Email: "testemail2@test.com", Role: readerRole}, }, } + t.Run("with valid flags calls members API", func(t *testing.T) { client := members.MockClient{} client. @@ -30,10 +31,31 @@ func TestInvite(t *testing.T) { args := []string{ "members", "invite", - "--access-token", - "testAccessToken", - "--base-uri", - "http://test.com", + "--access-token", "testAccessToken", + "--base-uri", "http://test.com", + "-e", + `testemail1@test.com,testemail2@test.com`, + } + + output, err := cmd.CallCmd(t, nil, nil, &client, nil, args) + + require.NoError(t, err) + assert.JSONEq(t, `{"valid": true}`, string(output)) + }) + + t.Run("with valid flags from environment variables calls API", func(t *testing.T) { + teardownTest := cmd.SetupTestEnvVars(t) + defer teardownTest(t) + client := members.MockClient{} + client. + On("Update", mockArgs...). + Return([]byte(cmd.ValidResponse), nil) + client. + On("Create", mockArgs...). + Return([]byte(cmd.ValidResponse), nil) + args := []string{ + "members", + "invite", "-e", `testemail1@test.com,testemail2@test.com`, } @@ -52,10 +74,8 @@ func TestInvite(t *testing.T) { args := []string{ "members", "invite", - "--access-token", - "testAccessToken", - "--base-uri", - "http://test.com", + "--access-token", "testAccessToken", + "--base-uri", "http://test.com", "-e", `testemail1@test.com,testemail2@test.com`, } @@ -99,6 +119,7 @@ func TestInviteWithOptionalRole(t *testing.T) { {Email: "testemail2@test.com", Role: writerRole}, }, } + t.Run("with valid optional long form flag calls members API", func(t *testing.T) { client := members.MockClient{} client. diff --git a/cmd/projects/create_test.go b/cmd/projects/create_test.go index 9082f476..c74b1c39 100644 --- a/cmd/projects/create_test.go +++ b/cmd/projects/create_test.go @@ -19,7 +19,30 @@ func TestCreate(t *testing.T) { "test-name", "test-key", } - t.Run("with valid flags calls projects API", func(t *testing.T) { + + t.Run("with valid flags calls API", func(t *testing.T) { + client := projects.MockClient{} + client. + On("Create", mockArgs...). + Return([]byte(cmd.ValidResponse), nil) + args := []string{ + "projects", + "create", + "--access-token", "testAccessToken", + "--base-uri", "http://test.com", + "-d", + `{"key": "test-key", "name": "test-name"}`, + } + + output, err := cmd.CallCmd(t, nil, nil, nil, &client, args) + + require.NoError(t, err) + assert.JSONEq(t, `{"valid": true}`, string(output)) + }) + + t.Run("with valid flags from environment variables calls API", func(t *testing.T) { + teardownTest := cmd.SetupTestEnvVars(t) + defer teardownTest(t) client := projects.MockClient{} client. On("Create", mockArgs...). @@ -27,10 +50,6 @@ func TestCreate(t *testing.T) { args := []string{ "projects", "create", - "--access-token", - "testAccessToken", - "--base-uri", - "http://test.com", "-d", `{"key": "test-key", "name": "test-name"}`, } diff --git a/cmd/projects/list_test.go b/cmd/projects/list_test.go index 718b08c3..ca3c4728 100644 --- a/cmd/projects/list_test.go +++ b/cmd/projects/list_test.go @@ -17,7 +17,7 @@ func TestList(t *testing.T) { "testAccessToken", "http://test.com", } - t.Run("with valid flags calls projects API", func(t *testing.T) { + t.Run("with valid flags calls API", func(t *testing.T) { client := projects.MockClient{} client. On("List", mockArgs...). @@ -34,6 +34,24 @@ func TestList(t *testing.T) { assert.JSONEq(t, `{"valid": true}`, string(output)) }) + t.Run("with valid flags from environment variables calls API", func(t *testing.T) { + teardownTest := cmd.SetupTestEnvVars(t) + defer teardownTest(t) + client := projects.MockClient{} + client. + On("List", mockArgs...). + Return([]byte(cmd.ValidResponse), nil) + args := []string{ + "projects", + "list", + } + + output, err := cmd.CallCmd(t, nil, nil, nil, &client, args) + + require.NoError(t, err) + assert.JSONEq(t, `{"valid": true}`, string(output)) + }) + t.Run("with an error response is an error", func(t *testing.T) { client := projects.MockClient{} client. From ff3109b7fd05354e4a748dc4361954ba74e8e3f7 Mon Sep 17 00:00:00 2001 From: Danny Olson Date: Fri, 12 Apr 2024 05:34:40 -0700 Subject: [PATCH 5/5] Remove debugging --- cmd/flags/create.go | 5 ----- cmd/quickstart.go | 5 ----- 2 files changed, 10 deletions(-) diff --git a/cmd/flags/create.go b/cmd/flags/create.go index ec560e90..a8bc0bbf 100644 --- a/cmd/flags/create.go +++ b/cmd/flags/create.go @@ -52,11 +52,6 @@ type inputData struct { func runCreate(client flags.Client) func(*cobra.Command, []string) error { return func(cmd *cobra.Command, args []string) error { - fmt.Println( - ">>> runCreate", - viper.GetString(cliflags.AccessTokenFlag), - viper.GetString(cliflags.BaseURIFlag), - ) // rebind flags used in other subcommands _ = viper.BindPFlag(cliflags.DataFlag, cmd.Flags().Lookup(cliflags.DataFlag)) _ = viper.BindPFlag(cliflags.ProjectFlag, cmd.Flags().Lookup(cliflags.ProjectFlag)) diff --git a/cmd/quickstart.go b/cmd/quickstart.go index 0601ceeb..51a38f67 100644 --- a/cmd/quickstart.go +++ b/cmd/quickstart.go @@ -40,11 +40,6 @@ func runQuickStart( os.Exit(1) } defer f.Close() - fmt.Println( - ">>> runQuickStart", - viper.GetString(cliflags.AccessTokenFlag), - viper.GetString(cliflags.BaseURIFlag), - ) _, err = tea.NewProgram(quickstart.NewContainerModel( environmentsClient,