From 35cb4ab87eb492de142050bb1dca7836a74ef559 Mon Sep 17 00:00:00 2001 From: vicentepinto98 Date: Mon, 27 May 2024 14:47:44 +0100 Subject: [PATCH 1/4] Add sqlserverflex options command --- docs/stackit_sqlserverflex.md | 1 + docs/stackit_sqlserverflex_options.md | 50 +++ internal/cmd/sqlserverflex/options/options.go | 273 +++++++++++++++ .../cmd/sqlserverflex/options/options_test.go | 324 ++++++++++++++++++ internal/cmd/sqlserverflex/sqlserverflex.go | 2 + 5 files changed, 650 insertions(+) create mode 100644 docs/stackit_sqlserverflex_options.md create mode 100644 internal/cmd/sqlserverflex/options/options.go create mode 100644 internal/cmd/sqlserverflex/options/options_test.go diff --git a/docs/stackit_sqlserverflex.md b/docs/stackit_sqlserverflex.md index f047e2b07..050f6f338 100644 --- a/docs/stackit_sqlserverflex.md +++ b/docs/stackit_sqlserverflex.md @@ -30,4 +30,5 @@ stackit sqlserverflex [flags] * [stackit](./stackit.md) - Manage STACKIT resources using the command line * [stackit sqlserverflex instance](./stackit_sqlserverflex_instance.md) - Provides functionality for SQLServer Flex instances +* [stackit sqlserverflex options](./stackit_sqlserverflex_options.md) - Lists SQL Server Flex options diff --git a/docs/stackit_sqlserverflex_options.md b/docs/stackit_sqlserverflex_options.md new file mode 100644 index 000000000..25c48fdaa --- /dev/null +++ b/docs/stackit_sqlserverflex_options.md @@ -0,0 +1,50 @@ +## stackit sqlserverflex options + +Lists SQL Server Flex options + +### Synopsis + +Lists SQL Server Flex options (flavors, versions and storages for a given flavor) +Pass one or more flags to filter what categories are shown. + +``` +stackit sqlserverflex options [flags] +``` + +### Examples + +``` + List SQL Server Flex flavors options + $ stackit sqlserverflex options --flavors + + List SQL Server Flex available versions + $ stackit sqlserverflex options --versions + + List SQL Server Flex storage options for a given flavor. The flavor ID can be retrieved by running "$ stackit sqlserverflex options --flavors" + $ stackit sqlserverflex options --storages --flavor-id +``` + +### Options + +``` + --flavor-id string The flavor ID to show storages for. Only relevant when "--storages" is passed + --flavors Lists supported flavors + -h, --help Help for "stackit sqlserverflex options" + --storages Lists supported storages for a given flavor + --versions Lists supported versions +``` + +### Options inherited from parent commands + +``` + -y, --assume-yes If set, skips all confirmation prompts + --async If set, runs the command asynchronously + -o, --output-format string Output format, one of ["json" "pretty" "none" "yaml"] + -p, --project-id string Project ID + --verbosity string Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info") +``` + +### SEE ALSO + +* [stackit sqlserverflex](./stackit_sqlserverflex.md) - Provides functionality for SQLServer Flex + diff --git a/internal/cmd/sqlserverflex/options/options.go b/internal/cmd/sqlserverflex/options/options.go new file mode 100644 index 000000000..8091f59ac --- /dev/null +++ b/internal/cmd/sqlserverflex/options/options.go @@ -0,0 +1,273 @@ +package options + +import ( + "context" + "encoding/json" + "fmt" + + "github.com/goccy/go-yaml" + "github.com/stackitcloud/stackit-cli/internal/pkg/args" + "github.com/stackitcloud/stackit-cli/internal/pkg/examples" + "github.com/stackitcloud/stackit-cli/internal/pkg/flags" + "github.com/stackitcloud/stackit-cli/internal/pkg/globalflags" + "github.com/stackitcloud/stackit-cli/internal/pkg/print" + "github.com/stackitcloud/stackit-cli/internal/pkg/services/sqlserverflex/client" + "github.com/stackitcloud/stackit-cli/internal/pkg/tables" + + "github.com/spf13/cobra" + "github.com/stackitcloud/stackit-sdk-go/services/sqlserverflex" +) + +const ( + flavorsFlag = "flavors" + versionsFlag = "versions" + storagesFlag = "storages" + flavorIdFlag = "flavor-id" +) + +type inputModel struct { + *globalflags.GlobalFlagModel + + Flavors bool + Versions bool + Storages bool + FlavorId *string +} + +type options struct { + Flavors *[]sqlserverflex.InstanceFlavorEntry `json:"flavors,omitempty"` + Versions *[]string `json:"versions,omitempty"` + Storages *flavorStorages `json:"flavorStorages,omitempty"` +} + +type flavorStorages struct { + FlavorId string `json:"flavorId"` + Storages *sqlserverflex.ListStoragesResponse `json:"storages"` +} + +func NewCmd(p *print.Printer) *cobra.Command { + cmd := &cobra.Command{ + Use: "options", + Short: "Lists SQL Server Flex options", + Long: "Lists SQL Server Flex options (flavors, versions and storages for a given flavor)\nPass one or more flags to filter what categories are shown.", + Args: args.NoArgs, + Example: examples.Build( + examples.NewExample( + `List SQL Server Flex flavors options`, + "$ stackit sqlserverflex options --flavors"), + examples.NewExample( + `List SQL Server Flex available versions`, + "$ stackit sqlserverflex options --versions"), + examples.NewExample( + `List SQL Server Flex storage options for a given flavor. The flavor ID can be retrieved by running "$ stackit sqlserverflex options --flavors"`, + "$ stackit sqlserverflex options --storages --flavor-id "), + ), + RunE: func(cmd *cobra.Command, args []string) error { + ctx := context.Background() + model, err := parseInput(p, cmd) + if err != nil { + return err + } + + // Configure API client + apiClient, err := client.ConfigureClient(p) + if err != nil { + return err + } + + // Call API + err = buildAndExecuteRequest(ctx, p, model, apiClient) + if err != nil { + return fmt.Errorf("get SQL Server Flex options: %w", err) + } + + return nil + }, + } + configureFlags(cmd) + return cmd +} + +func configureFlags(cmd *cobra.Command) { + cmd.Flags().Bool(flavorsFlag, false, "Lists supported flavors") + cmd.Flags().Bool(versionsFlag, false, "Lists supported versions") + cmd.Flags().Bool(storagesFlag, false, "Lists supported storages for a given flavor") + cmd.Flags().String(flavorIdFlag, "", `The flavor ID to show storages for. Only relevant when "--storages" is passed`) +} + +func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { + globalFlags := globalflags.Parse(p, cmd) + flavors := flags.FlagToBoolValue(p, cmd, flavorsFlag) + versions := flags.FlagToBoolValue(p, cmd, versionsFlag) + storages := flags.FlagToBoolValue(p, cmd, storagesFlag) + flavorId := flags.FlagToStringPointer(p, cmd, flavorIdFlag) + + if !flavors && !versions && !storages { + return nil, fmt.Errorf("%s\n\n%s", + "please specify at least one category for which to list the available options.", + "Get details on the available flags by re-running your command with the --help flag.") + } + + if storages && flavorId == nil { + return nil, fmt.Errorf("%s\n\n%s\n%s", + `please specify a flavor ID to show storages for by setting the flag "--flavor-id ".`, + "You can get the available flavor IDs by running:", + " $ stackit sqlserverflex options --flavors") + } + + model := inputModel{ + GlobalFlagModel: globalFlags, + Flavors: flavors, + Versions: versions, + Storages: storages, + FlavorId: flags.FlagToStringPointer(p, cmd, flavorIdFlag), + } + + if p.IsVerbosityDebug() { + modelStr, err := print.BuildDebugStrFromInputModel(model) + if err != nil { + p.Debug(print.ErrorLevel, "convert model to string for debugging: %v", err) + } else { + p.Debug(print.DebugLevel, "parsed input values: %s", modelStr) + } + } + + return &model, nil +} + +type mongoDBFlexOptionsClient interface { + ListFlavorsExecute(ctx context.Context, projectId string) (*sqlserverflex.ListFlavorsResponse, error) + ListVersionsExecute(ctx context.Context, projectId string) (*sqlserverflex.ListVersionsResponse, error) + ListStoragesExecute(ctx context.Context, projectId, flavorId string) (*sqlserverflex.ListStoragesResponse, error) +} + +func buildAndExecuteRequest(ctx context.Context, p *print.Printer, model *inputModel, apiClient mongoDBFlexOptionsClient) error { + var flavors *sqlserverflex.ListFlavorsResponse + var versions *sqlserverflex.ListVersionsResponse + var storages *sqlserverflex.ListStoragesResponse + var err error + + if model.Flavors { + flavors, err = apiClient.ListFlavorsExecute(ctx, model.ProjectId) + if err != nil { + return fmt.Errorf("get SQL Server Flex flavors: %w", err) + } + } + if model.Versions { + versions, err = apiClient.ListVersionsExecute(ctx, model.ProjectId) + if err != nil { + return fmt.Errorf("get SQL Server Flex versions: %w", err) + } + } + if model.Storages { + storages, err = apiClient.ListStoragesExecute(ctx, model.ProjectId, *model.FlavorId) + if err != nil { + return fmt.Errorf("get SQL Server Flex storages: %w", err) + } + } + + return outputResult(p, model, flavors, versions, storages) +} + +func outputResult(p *print.Printer, model *inputModel, flavors *sqlserverflex.ListFlavorsResponse, versions *sqlserverflex.ListVersionsResponse, storages *sqlserverflex.ListStoragesResponse) error { + options := &options{} + if flavors != nil { + options.Flavors = flavors.Flavors + } + if versions != nil { + options.Versions = versions.Versions + } + if storages != nil && model.FlavorId != nil { + options.Storages = &flavorStorages{ + FlavorId: *model.FlavorId, + Storages: storages, + } + } + + switch model.OutputFormat { + case print.JSONOutputFormat: + details, err := json.MarshalIndent(options, "", " ") + if err != nil { + return fmt.Errorf("marshal SQL Server Flex options: %w", err) + } + p.Outputln(string(details)) + return nil + case print.YAMLOutputFormat: + details, err := yaml.MarshalWithOptions(options, yaml.IndentSequence(true)) + if err != nil { + return fmt.Errorf("marshal SQL Server Flex options: %w", err) + } + p.Outputln(string(details)) + + return nil + default: + return outputResultAsTable(p, model, options) + } +} + +func outputResultAsTable(p *print.Printer, model *inputModel, options *options) error { + content := "" + if model.Flavors { + content += renderFlavors(*options.Flavors) + } + if model.Versions { + content += renderVersions(*options.Versions) + } + if model.Storages { + content += renderStorages(options.Storages.Storages) + } + + err := p.PagerDisplay(content) + if err != nil { + return fmt.Errorf("display output: %w", err) + } + + return nil +} + +func renderFlavors(flavors []sqlserverflex.InstanceFlavorEntry) string { + if len(flavors) == 0 { + return "" + } + + table := tables.NewTable() + table.SetTitle("Flavors") + table.SetHeader("ID", "CPU", "MEMORY", "DESCRIPTION", "VALID INSTANCE TYPES") + for i := range flavors { + f := flavors[i] + table.AddRow(*f.Id, *f.Cpu, *f.Memory, *f.Description, *f.Categories) + } + return table.Render() +} + +func renderVersions(versions []string) string { + if len(versions) == 0 { + return "" + } + + table := tables.NewTable() + table.SetTitle("Versions") + table.SetHeader("VERSION") + for i := range versions { + v := versions[i] + table.AddRow(v) + } + return table.Render() +} + +func renderStorages(resp *sqlserverflex.ListStoragesResponse) string { + if resp.StorageClasses == nil || len(*resp.StorageClasses) == 0 { + return "" + } + storageClasses := *resp.StorageClasses + + table := tables.NewTable() + table.SetTitle("Storages") + table.SetHeader("MINIMUM", "MAXIMUM", "STORAGE CLASS") + for i := range storageClasses { + sc := storageClasses[i] + table.AddRow(*resp.StorageRange.Min, *resp.StorageRange.Max, sc) + } + table.EnableAutoMergeOnColumns(1, 2, 3) + return table.Render() +} diff --git a/internal/cmd/sqlserverflex/options/options_test.go b/internal/cmd/sqlserverflex/options/options_test.go new file mode 100644 index 000000000..b29cd499e --- /dev/null +++ b/internal/cmd/sqlserverflex/options/options_test.go @@ -0,0 +1,324 @@ +package options + +import ( + "context" + "fmt" + "testing" + + "github.com/stackitcloud/stackit-cli/internal/pkg/globalflags" + "github.com/stackitcloud/stackit-cli/internal/pkg/print" + "github.com/stackitcloud/stackit-cli/internal/pkg/utils" + + "github.com/google/go-cmp/cmp" + "github.com/stackitcloud/stackit-sdk-go/services/sqlserverflex" +) + +type testCtxKey struct{} + +var testCtx = context.WithValue(context.Background(), testCtxKey{}, "foo") + +type mongoDBFlexClientMocked struct { + listFlavorsFails bool + listVersionsFails bool + listStoragesFails bool + + listFlavorsCalled bool + listVersionsCalled bool + listStoragesCalled bool +} + +func (c *mongoDBFlexClientMocked) ListFlavorsExecute(_ context.Context, _ string) (*sqlserverflex.ListFlavorsResponse, error) { + c.listFlavorsCalled = true + if c.listFlavorsFails { + return nil, fmt.Errorf("list flavors failed") + } + return utils.Ptr(sqlserverflex.ListFlavorsResponse{ + Flavors: utils.Ptr([]sqlserverflex.InstanceFlavorEntry{}), + }), nil +} + +func (c *mongoDBFlexClientMocked) ListVersionsExecute(_ context.Context, _ string) (*sqlserverflex.ListVersionsResponse, error) { + c.listVersionsCalled = true + if c.listVersionsFails { + return nil, fmt.Errorf("list versions failed") + } + return utils.Ptr(sqlserverflex.ListVersionsResponse{ + Versions: utils.Ptr([]string{}), + }), nil +} + +func (c *mongoDBFlexClientMocked) ListStoragesExecute(_ context.Context, _, _ string) (*sqlserverflex.ListStoragesResponse, error) { + c.listStoragesCalled = true + if c.listStoragesFails { + return nil, fmt.Errorf("list storages failed") + } + return utils.Ptr(sqlserverflex.ListStoragesResponse{ + StorageClasses: utils.Ptr([]string{}), + StorageRange: &sqlserverflex.StorageRange{ + Min: utils.Ptr(int64(10)), + Max: utils.Ptr(int64(100)), + }, + }), nil +} + +func fixtureFlagValues(mods ...func(flagValues map[string]string)) map[string]string { + flagValues := map[string]string{ + flavorsFlag: "true", + versionsFlag: "true", + storagesFlag: "true", + flavorIdFlag: "2.4", + } + for _, mod := range mods { + mod(flagValues) + } + return flagValues +} + +func fixtureInputModelAllFalse(mods ...func(model *inputModel)) *inputModel { + model := &inputModel{ + GlobalFlagModel: &globalflags.GlobalFlagModel{Verbosity: globalflags.VerbosityDefault}, + Flavors: false, + Versions: false, + Storages: false, + } + for _, mod := range mods { + mod(model) + } + return model +} + +func fixtureInputModelAllTrue(mods ...func(model *inputModel)) *inputModel { + model := &inputModel{ + GlobalFlagModel: &globalflags.GlobalFlagModel{Verbosity: globalflags.VerbosityDefault}, + Flavors: true, + Versions: true, + Storages: true, + FlavorId: utils.Ptr("2.4"), + } + for _, mod := range mods { + mod(model) + } + return model +} + +func TestParseInput(t *testing.T) { + tests := []struct { + description string + flagValues map[string]string + isValid bool + expectedModel *inputModel + }{ + { + description: "all values", + flagValues: fixtureFlagValues(), + isValid: true, + expectedModel: fixtureInputModelAllTrue(), + }, + { + description: "no values", + flagValues: map[string]string{}, + isValid: false, + }, + { + description: "some values 1", + flagValues: fixtureFlagValues(func(flagValues map[string]string) { + flagValues[storagesFlag] = "false" + delete(flagValues, flavorIdFlag) + }), + isValid: true, + expectedModel: fixtureInputModelAllFalse(func(model *inputModel) { + model.Flavors = true + model.Versions = true + }), + }, + { + description: "some values 2", + flagValues: fixtureFlagValues(func(flagValues map[string]string) { + delete(flagValues, flavorsFlag) + delete(flagValues, versionsFlag) + flagValues[storagesFlag] = "true" + flagValues[flavorIdFlag] = "2.4" + }), + isValid: true, + expectedModel: fixtureInputModelAllFalse(func(model *inputModel) { + model.Storages = true + model.FlavorId = utils.Ptr("2.4") + }), + }, + { + description: "storages without flavor-id", + flagValues: fixtureFlagValues(func(flagValues map[string]string) { + delete(flagValues, flavorIdFlag) + }), + isValid: false, + }, + { + description: "flavor-id without storage", + flagValues: fixtureFlagValues(func(flagValues map[string]string) { + delete(flagValues, storagesFlag) + }), + isValid: true, + expectedModel: fixtureInputModelAllTrue(func(model *inputModel) { + model.Storages = false + }), + }, + } + + for _, tt := range tests { + t.Run(tt.description, func(t *testing.T) { + p := print.NewPrinter() + cmd := NewCmd(p) + err := globalflags.Configure(cmd.Flags()) + if err != nil { + t.Fatalf("configure global flags: %v", err) + } + + for flag, value := range tt.flagValues { + err := cmd.Flags().Set(flag, value) + if err != nil { + if !tt.isValid { + return + } + t.Fatalf("setting flag --%s=%s: %v", flag, value, err) + } + } + + err = cmd.ValidateRequiredFlags() + if err != nil { + if !tt.isValid { + return + } + t.Fatalf("error validating flags: %v", err) + } + + model, err := parseInput(p, cmd) + if err != nil { + if !tt.isValid { + return + } + t.Fatalf("error parsing flags: %v", err) + } + + if !tt.isValid { + t.Fatalf("did not fail on invalid input") + } + diff := cmp.Diff(model, tt.expectedModel) + if diff != "" { + t.Fatalf("Data does not match: %s", diff) + } + }) + } +} + +func TestBuildAndExecuteRequest(t *testing.T) { + tests := []struct { + description string + model *inputModel + isValid bool + listFlavorsFails bool + listVersionsFails bool + listStoragesFails bool + expectListFlavorsCalled bool + expectListVersionsCalled bool + expectListStoragesCalled bool + }{ + { + description: "all values", + model: fixtureInputModelAllTrue(), + isValid: true, + expectListFlavorsCalled: true, + expectListVersionsCalled: true, + expectListStoragesCalled: true, + }, + { + description: "no values", + model: fixtureInputModelAllFalse(), + isValid: true, + expectListFlavorsCalled: false, + expectListVersionsCalled: false, + expectListStoragesCalled: false, + }, + { + description: "only flavors", + model: fixtureInputModelAllFalse(func(model *inputModel) { model.Flavors = true }), + isValid: true, + expectListFlavorsCalled: true, + }, + { + description: "only versions", + model: fixtureInputModelAllFalse(func(model *inputModel) { model.Versions = true }), + isValid: true, + expectListVersionsCalled: true, + }, + { + description: "only storages", + model: fixtureInputModelAllFalse(func(model *inputModel) { + model.Storages = true + model.FlavorId = utils.Ptr("2.4") + }), + isValid: true, + expectListStoragesCalled: true, + }, + { + description: "list flavors fails", + model: fixtureInputModelAllTrue(), + isValid: false, + listFlavorsFails: true, + expectListFlavorsCalled: true, + expectListVersionsCalled: false, + expectListStoragesCalled: false, + }, + { + description: "list versions fails", + model: fixtureInputModelAllTrue(), + isValid: false, + listVersionsFails: true, + expectListFlavorsCalled: true, + expectListVersionsCalled: true, + expectListStoragesCalled: false, + }, + { + description: "list storages fails", + model: fixtureInputModelAllTrue(), + isValid: false, + listStoragesFails: true, + expectListFlavorsCalled: true, + expectListVersionsCalled: true, + expectListStoragesCalled: true, + }, + } + + for _, tt := range tests { + t.Run(tt.description, func(t *testing.T) { + p := &print.Printer{} + cmd := NewCmd(p) + p.Cmd = cmd + client := &mongoDBFlexClientMocked{ + listFlavorsFails: tt.listFlavorsFails, + listVersionsFails: tt.listVersionsFails, + listStoragesFails: tt.listStoragesFails, + } + + err := buildAndExecuteRequest(testCtx, p, tt.model, client) + if err != nil && tt.isValid { + t.Fatalf("error building and executing request: %v", err) + } + if err == nil && !tt.isValid { + t.Fatalf("did not fail on invalid input") + } + if !tt.isValid { + return + } + + if tt.expectListFlavorsCalled != client.listFlavorsCalled { + t.Fatalf("expected listFlavorsCalled to be %v, got %v", tt.expectListFlavorsCalled, client.listFlavorsCalled) + } + if tt.expectListVersionsCalled != client.listVersionsCalled { + t.Fatalf("expected listVersionsCalled to be %v, got %v", tt.expectListVersionsCalled, client.listVersionsCalled) + } + if tt.expectListStoragesCalled != client.listStoragesCalled { + t.Fatalf("expected listStoragesCalled to be %v, got %v", tt.expectListStoragesCalled, client.listStoragesCalled) + } + }) + } +} diff --git a/internal/cmd/sqlserverflex/sqlserverflex.go b/internal/cmd/sqlserverflex/sqlserverflex.go index ac441c137..a095de0ad 100644 --- a/internal/cmd/sqlserverflex/sqlserverflex.go +++ b/internal/cmd/sqlserverflex/sqlserverflex.go @@ -2,6 +2,7 @@ package sqlserverflex import ( "github.com/stackitcloud/stackit-cli/internal/cmd/sqlserverflex/instance" + "github.com/stackitcloud/stackit-cli/internal/cmd/sqlserverflex/options" "github.com/stackitcloud/stackit-cli/internal/pkg/args" "github.com/stackitcloud/stackit-cli/internal/pkg/print" "github.com/stackitcloud/stackit-cli/internal/pkg/utils" @@ -23,4 +24,5 @@ func NewCmd(p *print.Printer) *cobra.Command { func addSubcommands(cmd *cobra.Command, p *print.Printer) { cmd.AddCommand(instance.NewCmd(p)) + cmd.AddCommand(options.NewCmd(p)) } From 9779f6251669fd342e171aafb01491ff6e09e7c4 Mon Sep 17 00:00:00 2001 From: Vicente Pinto Date: Mon, 27 May 2024 15:59:11 +0100 Subject: [PATCH 2/4] Update internal/cmd/beta/sqlserverflex/options/options.go MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Diogo Ferrão --- internal/cmd/beta/sqlserverflex/options/options.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/internal/cmd/beta/sqlserverflex/options/options.go b/internal/cmd/beta/sqlserverflex/options/options.go index 8091f59ac..77add773a 100644 --- a/internal/cmd/beta/sqlserverflex/options/options.go +++ b/internal/cmd/beta/sqlserverflex/options/options.go @@ -135,7 +135,7 @@ func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { return &model, nil } -type mongoDBFlexOptionsClient interface { +type SQLServerFlexOptionsClient interface { ListFlavorsExecute(ctx context.Context, projectId string) (*sqlserverflex.ListFlavorsResponse, error) ListVersionsExecute(ctx context.Context, projectId string) (*sqlserverflex.ListVersionsResponse, error) ListStoragesExecute(ctx context.Context, projectId, flavorId string) (*sqlserverflex.ListStoragesResponse, error) From 52634387411daa1c49eadb74145f81e499e483b7 Mon Sep 17 00:00:00 2001 From: vicentepinto98 Date: Mon, 27 May 2024 16:01:18 +0100 Subject: [PATCH 3/4] Rename clients --- internal/cmd/beta/sqlserverflex/options/options.go | 4 ++-- .../cmd/beta/sqlserverflex/options/options_test.go | 10 +++++----- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/internal/cmd/beta/sqlserverflex/options/options.go b/internal/cmd/beta/sqlserverflex/options/options.go index 77add773a..2e7fdf612 100644 --- a/internal/cmd/beta/sqlserverflex/options/options.go +++ b/internal/cmd/beta/sqlserverflex/options/options.go @@ -135,13 +135,13 @@ func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { return &model, nil } -type SQLServerFlexOptionsClient interface { +type sqlServerFlexOptionsClient interface { ListFlavorsExecute(ctx context.Context, projectId string) (*sqlserverflex.ListFlavorsResponse, error) ListVersionsExecute(ctx context.Context, projectId string) (*sqlserverflex.ListVersionsResponse, error) ListStoragesExecute(ctx context.Context, projectId, flavorId string) (*sqlserverflex.ListStoragesResponse, error) } -func buildAndExecuteRequest(ctx context.Context, p *print.Printer, model *inputModel, apiClient mongoDBFlexOptionsClient) error { +func buildAndExecuteRequest(ctx context.Context, p *print.Printer, model *inputModel, apiClient sqlServerFlexOptionsClient) error { var flavors *sqlserverflex.ListFlavorsResponse var versions *sqlserverflex.ListVersionsResponse var storages *sqlserverflex.ListStoragesResponse diff --git a/internal/cmd/beta/sqlserverflex/options/options_test.go b/internal/cmd/beta/sqlserverflex/options/options_test.go index b29cd499e..bece7beb0 100644 --- a/internal/cmd/beta/sqlserverflex/options/options_test.go +++ b/internal/cmd/beta/sqlserverflex/options/options_test.go @@ -17,7 +17,7 @@ type testCtxKey struct{} var testCtx = context.WithValue(context.Background(), testCtxKey{}, "foo") -type mongoDBFlexClientMocked struct { +type sqlServerFlexClientMocked struct { listFlavorsFails bool listVersionsFails bool listStoragesFails bool @@ -27,7 +27,7 @@ type mongoDBFlexClientMocked struct { listStoragesCalled bool } -func (c *mongoDBFlexClientMocked) ListFlavorsExecute(_ context.Context, _ string) (*sqlserverflex.ListFlavorsResponse, error) { +func (c *sqlServerFlexClientMocked) ListFlavorsExecute(_ context.Context, _ string) (*sqlserverflex.ListFlavorsResponse, error) { c.listFlavorsCalled = true if c.listFlavorsFails { return nil, fmt.Errorf("list flavors failed") @@ -37,7 +37,7 @@ func (c *mongoDBFlexClientMocked) ListFlavorsExecute(_ context.Context, _ string }), nil } -func (c *mongoDBFlexClientMocked) ListVersionsExecute(_ context.Context, _ string) (*sqlserverflex.ListVersionsResponse, error) { +func (c *sqlServerFlexClientMocked) ListVersionsExecute(_ context.Context, _ string) (*sqlserverflex.ListVersionsResponse, error) { c.listVersionsCalled = true if c.listVersionsFails { return nil, fmt.Errorf("list versions failed") @@ -47,7 +47,7 @@ func (c *mongoDBFlexClientMocked) ListVersionsExecute(_ context.Context, _ strin }), nil } -func (c *mongoDBFlexClientMocked) ListStoragesExecute(_ context.Context, _, _ string) (*sqlserverflex.ListStoragesResponse, error) { +func (c *sqlServerFlexClientMocked) ListStoragesExecute(_ context.Context, _, _ string) (*sqlserverflex.ListStoragesResponse, error) { c.listStoragesCalled = true if c.listStoragesFails { return nil, fmt.Errorf("list storages failed") @@ -293,7 +293,7 @@ func TestBuildAndExecuteRequest(t *testing.T) { p := &print.Printer{} cmd := NewCmd(p) p.Cmd = cmd - client := &mongoDBFlexClientMocked{ + client := &sqlServerFlexClientMocked{ listFlavorsFails: tt.listFlavorsFails, listVersionsFails: tt.listVersionsFails, listStoragesFails: tt.listStoragesFails, From efdb97d57378295cd27e85e111d519eee60e9397 Mon Sep 17 00:00:00 2001 From: vicentepinto98 Date: Mon, 27 May 2024 16:14:35 +0100 Subject: [PATCH 4/4] Update client name --- internal/cmd/beta/sqlserverflex/instance/create/create.go | 4 ++-- internal/cmd/beta/sqlserverflex/instance/update/update.go | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/internal/cmd/beta/sqlserverflex/instance/create/create.go b/internal/cmd/beta/sqlserverflex/instance/create/create.go index ba4ba4730..48341000b 100644 --- a/internal/cmd/beta/sqlserverflex/instance/create/create.go +++ b/internal/cmd/beta/sqlserverflex/instance/create/create.go @@ -193,13 +193,13 @@ func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) { return &model, nil } -type SQLServerFlexClient interface { +type sqlServerFlexClient interface { CreateInstance(ctx context.Context, projectId string) sqlserverflex.ApiCreateInstanceRequest ListFlavorsExecute(ctx context.Context, projectId string) (*sqlserverflex.ListFlavorsResponse, error) ListStoragesExecute(ctx context.Context, projectId, flavorId string) (*sqlserverflex.ListStoragesResponse, error) } -func buildRequest(ctx context.Context, model *inputModel, apiClient SQLServerFlexClient) (sqlserverflex.ApiCreateInstanceRequest, error) { +func buildRequest(ctx context.Context, model *inputModel, apiClient sqlServerFlexClient) (sqlserverflex.ApiCreateInstanceRequest, error) { req := apiClient.CreateInstance(ctx, model.ProjectId) var flavorId *string diff --git a/internal/cmd/beta/sqlserverflex/instance/update/update.go b/internal/cmd/beta/sqlserverflex/instance/update/update.go index 587aa4d22..f3ad4527c 100644 --- a/internal/cmd/beta/sqlserverflex/instance/update/update.go +++ b/internal/cmd/beta/sqlserverflex/instance/update/update.go @@ -181,14 +181,14 @@ func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inpu return &model, nil } -type SQLServerFlexClient interface { +type sqlServerFlexClient interface { PartialUpdateInstance(ctx context.Context, projectId, instanceId string) sqlserverflex.ApiPartialUpdateInstanceRequest GetInstanceExecute(ctx context.Context, projectId, instanceId string) (*sqlserverflex.GetInstanceResponse, error) ListFlavorsExecute(ctx context.Context, projectId string) (*sqlserverflex.ListFlavorsResponse, error) ListStoragesExecute(ctx context.Context, projectId, flavorId string) (*sqlserverflex.ListStoragesResponse, error) } -func buildRequest(ctx context.Context, model *inputModel, apiClient SQLServerFlexClient) (sqlserverflex.ApiPartialUpdateInstanceRequest, error) { +func buildRequest(ctx context.Context, model *inputModel, apiClient sqlServerFlexClient) (sqlserverflex.ApiPartialUpdateInstanceRequest, error) { req := apiClient.PartialUpdateInstance(ctx, model.ProjectId, model.InstanceId) var flavorId *string