From a5f93f7a10e510682e1958ed4fad6fce2ea52792 Mon Sep 17 00:00:00 2001 From: Keepers Date: Thu, 28 Sep 2023 17:20:44 -0600 Subject: [PATCH] correctly attach store/provider flags (#4391) corrects the storage and provider flag positioning to attach to the child command instead of the parent. Also corrects unit tests for flags to ensure flags are preset as expected. --- #### Does this PR need a docs update or release note? - [x] :no_entry: No #### Type of change - [x] :bug: Bugfix #### Test Plan - [x] :zap: Unit test - [x] :green_heart: E2E --- src/cli/backup/backup.go | 6 +- src/cli/backup/exchange_test.go | 212 ++++++++++------------------ src/cli/backup/groups_test.go | 219 +++++++++-------------------- src/cli/backup/onedrive_test.go | 186 +++++++++--------------- src/cli/backup/sharepoint_test.go | 188 +++++++++---------------- src/cli/export/export.go | 4 +- src/cli/export/groups_test.go | 72 ++++------ src/cli/export/onedrive_test.go | 86 +++++------ src/cli/export/sharepoint_test.go | 97 +++++-------- src/cli/flags/testdata/flags.go | 17 ++- src/cli/restore/exchange_test.go | 108 ++++++-------- src/cli/restore/groups_test.go | 100 ++++++------- src/cli/restore/onedrive_test.go | 89 +++++------- src/cli/restore/restore.go | 6 +- src/cli/restore/sharepoint_test.go | 101 ++++++------- src/cli/testdata/cli.go | 88 ++++++++++++ 16 files changed, 651 insertions(+), 928 deletions(-) diff --git a/src/cli/backup/backup.go b/src/cli/backup/backup.go index 71cb4595c..8b6808a01 100644 --- a/src/cli/backup/backup.go +++ b/src/cli/backup/backup.go @@ -48,12 +48,12 @@ func AddCommands(cmd *cobra.Command) { for _, sc := range subCommandFuncs { subCommand := sc() - flags.AddAllProviderFlags(subCommand) - flags.AddAllStorageFlags(subCommand) backupC.AddCommand(subCommand) for _, addBackupTo := range serviceCommands { - addBackupTo(subCommand) + sc := addBackupTo(subCommand) + flags.AddAllProviderFlags(sc) + flags.AddAllStorageFlags(sc) } } } diff --git a/src/cli/backup/exchange_test.go b/src/cli/backup/exchange_test.go index b04f27f07..87b6f49c8 100644 --- a/src/cli/backup/exchange_test.go +++ b/src/cli/backup/exchange_test.go @@ -1,7 +1,6 @@ package backup import ( - "bytes" "fmt" "strconv" "testing" @@ -14,6 +13,7 @@ import ( "github.com/alcionai/corso/src/cli/flags" flagsTD "github.com/alcionai/corso/src/cli/flags/testdata" + cliTD "github.com/alcionai/corso/src/cli/testdata" "github.com/alcionai/corso/src/cli/utils" utilsTD "github.com/alcionai/corso/src/cli/utils/testdata" "github.com/alcionai/corso/src/internal/tester" @@ -92,76 +92,46 @@ func (suite *ExchangeUnitSuite) TestAddExchangeCommands() { func (suite *ExchangeUnitSuite) TestBackupCreateFlags() { t := suite.T() - cmd := &cobra.Command{Use: createCommand} - - // persistent flags not added by addCommands - flags.AddRunModeFlag(cmd, true) - - c := addExchangeCommands(cmd) - require.NotNil(t, c) - - // non-persistent flags not added by addCommands - flags.AddAllProviderFlags(c) - flags.AddAllStorageFlags(c) - - flagsTD.WithFlags( - cmd, - exchangeServiceCommand, - []string{ - "--" + flags.RunModeFN, flags.RunModeFlagTest, - "--" + flags.BackupFN, flagsTD.BackupInput, + cmd := cliTD.SetUpCmdHasFlags( + t, + &cobra.Command{Use: createCommand}, + addExchangeCommands, + []cliTD.UseCobraCommandFn{ + flags.AddAllProviderFlags, + flags.AddAllStorageFlags, }, - flagsTD.PreparedProviderFlags(), - flagsTD.PreparedStorageFlags()) + flagsTD.WithFlags( + exchangeServiceCommand, + []string{ + "--" + flags.RunModeFN, flags.RunModeFlagTest, + "--" + flags.MailBoxFN, flagsTD.FlgInputs(flagsTD.MailboxInput), + "--" + flags.CategoryDataFN, flagsTD.FlgInputs(flagsTD.ExchangeCategoryDataInput), + "--" + flags.FetchParallelismFN, flagsTD.FetchParallelism, + "--" + flags.DeltaPageSizeFN, flagsTD.DeltaPageSize, - // Test arg parsing for few args - args := []string{ - exchangeServiceCommand, - "--" + flags.RunModeFN, flags.RunModeFlagTest, - - "--" + flags.MailBoxFN, flagsTD.FlgInputs(flagsTD.MailboxInput), - "--" + flags.CategoryDataFN, flagsTD.FlgInputs(flagsTD.ExchangeCategoryDataInput), - - "--" + flags.FetchParallelismFN, flagsTD.FetchParallelism, - "--" + flags.DeltaPageSizeFN, flagsTD.DeltaPageSize, - - // bool flags - "--" + flags.FailFastFN, - "--" + flags.DisableIncrementalsFN, - "--" + flags.ForceItemDataDownloadFN, - "--" + flags.DisableDeltaFN, - "--" + flags.EnableImmutableIDFN, - "--" + flags.DisableConcurrencyLimiterFN, - } - - args = append(args, flagsTD.PreparedProviderFlags()...) - args = append(args, flagsTD.PreparedStorageFlags()...) - - cmd.SetArgs(args) - - cmd.SetOut(new(bytes.Buffer)) // drop output - cmd.SetErr(new(bytes.Buffer)) // drop output - - err := cmd.Execute() - assert.NoError(t, err, clues.ToCore(err)) + // bool flags + "--" + flags.FailFastFN, + "--" + flags.DisableIncrementalsFN, + "--" + flags.ForceItemDataDownloadFN, + "--" + flags.DisableDeltaFN, + "--" + flags.EnableImmutableIDFN, + "--" + flags.DisableConcurrencyLimiterFN, + }, + flagsTD.PreparedProviderFlags(), + flagsTD.PreparedStorageFlags())) opts := utils.MakeExchangeOpts(cmd) co := utils.Control() assert.ElementsMatch(t, flagsTD.MailboxInput, opts.Users) - // no assertion for category data input - assert.Equal(t, flagsTD.FetchParallelism, strconv.Itoa(co.Parallelism.ItemFetch)) assert.Equal(t, flagsTD.DeltaPageSize, strconv.Itoa(int(co.DeltaPageSize))) - - // bool flags assert.Equal(t, control.FailFast, co.FailureHandling) assert.True(t, co.ToggleFeatures.DisableIncrementals) assert.True(t, co.ToggleFeatures.ForceItemDataDownload) assert.True(t, co.ToggleFeatures.DisableDelta) assert.True(t, co.ToggleFeatures.ExchangeImmutableIDs) assert.True(t, co.ToggleFeatures.DisableConcurrencyLimiter) - flagsTD.AssertProviderFlags(t, cmd) flagsTD.AssertStorageFlags(t, cmd) } @@ -169,36 +139,25 @@ func (suite *ExchangeUnitSuite) TestBackupCreateFlags() { func (suite *ExchangeUnitSuite) TestBackupListFlags() { t := suite.T() - cmd := &cobra.Command{Use: listCommand} - - // persistent flags not added by addCommands - flags.AddRunModeFlag(cmd, true) - - c := addExchangeCommands(cmd) - require.NotNil(t, c) - - // non-persistent flags not added by addCommands - flags.AddAllProviderFlags(c) - flags.AddAllStorageFlags(c) - - flagsTD.WithFlags( - cmd, - exchangeServiceCommand, []string{ - "--" + flags.RunModeFN, flags.RunModeFlagTest, - "--" + flags.BackupFN, flagsTD.BackupInput, + cmd := cliTD.SetUpCmdHasFlags( + t, + &cobra.Command{Use: listCommand}, + addExchangeCommands, + []cliTD.UseCobraCommandFn{ + flags.AddAllProviderFlags, + flags.AddAllStorageFlags, }, - flagsTD.PreparedBackupListFlags(), - flagsTD.PreparedProviderFlags(), - flagsTD.PreparedStorageFlags()) - - cmd.SetOut(new(bytes.Buffer)) // drop output - cmd.SetErr(new(bytes.Buffer)) // drop output - - err := cmd.Execute() - assert.NoError(t, err, clues.ToCore(err)) + flagsTD.WithFlags( + exchangeServiceCommand, + []string{ + "--" + flags.RunModeFN, flags.RunModeFlagTest, + "--" + flags.BackupFN, flagsTD.BackupInput, + }, + flagsTD.PreparedBackupListFlags(), + flagsTD.PreparedProviderFlags(), + flagsTD.PreparedStorageFlags())) assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) - flagsTD.AssertBackupListFlags(t, cmd) flagsTD.AssertProviderFlags(t, cmd) flagsTD.AssertStorageFlags(t, cmd) @@ -207,41 +166,28 @@ func (suite *ExchangeUnitSuite) TestBackupListFlags() { func (suite *ExchangeUnitSuite) TestBackupDetailsFlags() { t := suite.T() - cmd := &cobra.Command{Use: detailsCommand} - - // persistent flags not added by addCommands - flags.AddRunModeFlag(cmd, true) - - c := addExchangeCommands(cmd) - require.NotNil(t, c) - - // non-persistent flags not added by addCommands - flags.AddAllProviderFlags(c) - flags.AddAllStorageFlags(c) - - flagsTD.WithFlags( - cmd, - exchangeServiceCommand, - []string{ - "--" + flags.RunModeFN, flags.RunModeFlagTest, - "--" + flags.BackupFN, flagsTD.BackupInput, - "--" + flags.SkipReduceFN, + cmd := cliTD.SetUpCmdHasFlags( + t, + &cobra.Command{Use: detailsCommand}, + addExchangeCommands, + []cliTD.UseCobraCommandFn{ + flags.AddAllProviderFlags, + flags.AddAllStorageFlags, }, - flagsTD.PreparedProviderFlags(), - flagsTD.PreparedStorageFlags()) - - cmd.SetOut(new(bytes.Buffer)) // drop output - cmd.SetErr(new(bytes.Buffer)) // drop output - - err := cmd.Execute() - assert.NoError(t, err, clues.ToCore(err)) + flagsTD.WithFlags( + exchangeServiceCommand, + []string{ + "--" + flags.RunModeFN, flags.RunModeFlagTest, + "--" + flags.BackupFN, flagsTD.BackupInput, + "--" + flags.SkipReduceFN, + }, + flagsTD.PreparedProviderFlags(), + flagsTD.PreparedStorageFlags())) co := utils.Control() assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) - assert.True(t, co.SkipReduce) - flagsTD.AssertProviderFlags(t, cmd) flagsTD.AssertStorageFlags(t, cmd) } @@ -249,36 +195,24 @@ func (suite *ExchangeUnitSuite) TestBackupDetailsFlags() { func (suite *ExchangeUnitSuite) TestBackupDeleteFlags() { t := suite.T() - cmd := &cobra.Command{Use: deleteCommand} - - // persistent flags not added by addCommands - flags.AddRunModeFlag(cmd, true) - - c := addExchangeCommands(cmd) - require.NotNil(t, c) - - // non-persistent flags not added by addCommands - flags.AddAllProviderFlags(c) - flags.AddAllStorageFlags(c) - - flagsTD.WithFlags( - cmd, - exchangeServiceCommand, - []string{ - "--" + flags.RunModeFN, flags.RunModeFlagTest, - "--" + flags.BackupFN, flagsTD.BackupInput, + cmd := cliTD.SetUpCmdHasFlags( + t, + &cobra.Command{Use: deleteCommand}, + addExchangeCommands, + []cliTD.UseCobraCommandFn{ + flags.AddAllProviderFlags, + flags.AddAllStorageFlags, }, - flagsTD.PreparedProviderFlags(), - flagsTD.PreparedStorageFlags()) - - cmd.SetOut(new(bytes.Buffer)) // drop output - cmd.SetErr(new(bytes.Buffer)) // drop output - - err := cmd.Execute() - assert.NoError(t, err, clues.ToCore(err)) + flagsTD.WithFlags( + exchangeServiceCommand, + []string{ + "--" + flags.RunModeFN, flags.RunModeFlagTest, + "--" + flags.BackupFN, flagsTD.BackupInput, + }, + flagsTD.PreparedProviderFlags(), + flagsTD.PreparedStorageFlags())) assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) - flagsTD.AssertProviderFlags(t, cmd) flagsTD.AssertStorageFlags(t, cmd) } diff --git a/src/cli/backup/groups_test.go b/src/cli/backup/groups_test.go index 8829915c4..996a9126f 100644 --- a/src/cli/backup/groups_test.go +++ b/src/cli/backup/groups_test.go @@ -1,7 +1,6 @@ package backup import ( - "bytes" "strconv" "testing" @@ -13,6 +12,7 @@ import ( "github.com/alcionai/corso/src/cli/flags" flagsTD "github.com/alcionai/corso/src/cli/flags/testdata" + cliTD "github.com/alcionai/corso/src/cli/testdata" "github.com/alcionai/corso/src/cli/utils" "github.com/alcionai/corso/src/internal/tester" "github.com/alcionai/corso/src/pkg/control" @@ -128,70 +128,38 @@ func (suite *GroupsUnitSuite) TestValidateGroupsBackupCreateFlags() { func (suite *GroupsUnitSuite) TestBackupCreateFlags() { t := suite.T() - cmd := &cobra.Command{Use: createCommand} - - // persistent flags not added by addCommands - flags.AddRunModeFlag(cmd, true) - - c := addGroupsCommands(cmd) - require.NotNil(t, c) - - // non-persistent flags not added by addCommands - flags.AddAllProviderFlags(c) - flags.AddAllStorageFlags(c) - - flagsTD.WithFlags( - cmd, - groupsServiceCommand, - []string{ - "--" + flags.RunModeFN, flags.RunModeFlagTest, - "--" + flags.BackupFN, flagsTD.BackupInput, + cmd := cliTD.SetUpCmdHasFlags( + t, + &cobra.Command{Use: createCommand}, + addGroupsCommands, + []cliTD.UseCobraCommandFn{ + flags.AddAllProviderFlags, + flags.AddAllStorageFlags, }, - flagsTD.PreparedProviderFlags(), - flagsTD.PreparedStorageFlags()) - - // Test arg parsing for few args - args := []string{ - groupsServiceCommand, - "--" + flags.RunModeFN, flags.RunModeFlagTest, - - "--" + flags.GroupFN, flagsTD.FlgInputs(flagsTD.GroupsInput), - "--" + flags.CategoryDataFN, flagsTD.FlgInputs(flagsTD.GroupsCategoryDataInput), - - "--" + flags.FetchParallelismFN, flagsTD.FetchParallelism, - - // bool flags - "--" + flags.FailFastFN, - "--" + flags.DisableIncrementalsFN, - "--" + flags.ForceItemDataDownloadFN, - "--" + flags.DisableDeltaFN, - } - - args = append(args, flagsTD.PreparedProviderFlags()...) - args = append(args, flagsTD.PreparedStorageFlags()...) - - cmd.SetArgs(args) - - cmd.SetOut(new(bytes.Buffer)) // drop output - cmd.SetErr(new(bytes.Buffer)) // drop output - - err := cmd.Execute() - assert.NoError(t, err, clues.ToCore(err)) + flagsTD.WithFlags( + groupsServiceCommand, + []string{ + "--" + flags.RunModeFN, flags.RunModeFlagTest, + "--" + flags.GroupFN, flagsTD.FlgInputs(flagsTD.GroupsInput), + "--" + flags.CategoryDataFN, flagsTD.FlgInputs(flagsTD.GroupsCategoryDataInput), + "--" + flags.FetchParallelismFN, flagsTD.FetchParallelism, + "--" + flags.FailFastFN, + "--" + flags.DisableIncrementalsFN, + "--" + flags.ForceItemDataDownloadFN, + "--" + flags.DisableDeltaFN, + }, + flagsTD.PreparedProviderFlags(), + flagsTD.PreparedStorageFlags())) opts := utils.MakeGroupsOpts(cmd) co := utils.Control() assert.ElementsMatch(t, flagsTD.GroupsInput, opts.Groups) - // no assertion for category data input - assert.Equal(t, flagsTD.FetchParallelism, strconv.Itoa(co.Parallelism.ItemFetch)) - - // bool flags assert.Equal(t, control.FailFast, co.FailureHandling) assert.True(t, co.ToggleFeatures.DisableIncrementals) assert.True(t, co.ToggleFeatures.ForceItemDataDownload) assert.True(t, co.ToggleFeatures.DisableDelta) - flagsTD.AssertProviderFlags(t, cmd) flagsTD.AssertStorageFlags(t, cmd) } @@ -199,37 +167,25 @@ func (suite *GroupsUnitSuite) TestBackupCreateFlags() { func (suite *GroupsUnitSuite) TestBackupListFlags() { t := suite.T() - cmd := &cobra.Command{Use: listCommand} - - // persistent flags not added by addCommands - flags.AddRunModeFlag(cmd, true) - - c := addGroupsCommands(cmd) - require.NotNil(t, c) - - // non-persistent flags not added by addCommands - flags.AddAllProviderFlags(c) - flags.AddAllStorageFlags(c) - - flagsTD.WithFlags( - cmd, - groupsServiceCommand, - []string{ - "--" + flags.RunModeFN, flags.RunModeFlagTest, - "--" + flags.BackupFN, flagsTD.BackupInput, + cmd := cliTD.SetUpCmdHasFlags( + t, + &cobra.Command{Use: listCommand}, + addGroupsCommands, + []cliTD.UseCobraCommandFn{ + flags.AddAllProviderFlags, + flags.AddAllStorageFlags, }, - flagsTD.PreparedBackupListFlags(), - flagsTD.PreparedProviderFlags(), - flagsTD.PreparedStorageFlags()) - - cmd.SetOut(new(bytes.Buffer)) // drop output - cmd.SetErr(new(bytes.Buffer)) // drop output - - err := cmd.Execute() - assert.NoError(t, err, clues.ToCore(err)) + flagsTD.WithFlags( + groupsServiceCommand, + []string{ + "--" + flags.RunModeFN, flags.RunModeFlagTest, + "--" + flags.BackupFN, flagsTD.BackupInput, + }, + flagsTD.PreparedBackupListFlags(), + flagsTD.PreparedProviderFlags(), + flagsTD.PreparedStorageFlags())) assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) - flagsTD.AssertBackupListFlags(t, cmd) flagsTD.AssertProviderFlags(t, cmd) flagsTD.AssertStorageFlags(t, cmd) @@ -238,41 +194,28 @@ func (suite *GroupsUnitSuite) TestBackupListFlags() { func (suite *GroupsUnitSuite) TestBackupDetailsFlags() { t := suite.T() - cmd := &cobra.Command{Use: detailsCommand} - - // persistent flags not added by addCommands - flags.AddRunModeFlag(cmd, true) - - c := addGroupsCommands(cmd) - require.NotNil(t, c) - - // non-persistent flags not added by addCommands - flags.AddAllProviderFlags(c) - flags.AddAllStorageFlags(c) - - flagsTD.WithFlags( - cmd, - groupsServiceCommand, - []string{ - "--" + flags.RunModeFN, flags.RunModeFlagTest, - "--" + flags.BackupFN, flagsTD.BackupInput, - "--" + flags.SkipReduceFN, + cmd := cliTD.SetUpCmdHasFlags( + t, + &cobra.Command{Use: detailsCommand}, + addGroupsCommands, + []cliTD.UseCobraCommandFn{ + flags.AddAllProviderFlags, + flags.AddAllStorageFlags, }, - flagsTD.PreparedProviderFlags(), - flagsTD.PreparedStorageFlags()) - - cmd.SetOut(new(bytes.Buffer)) // drop output - cmd.SetErr(new(bytes.Buffer)) // drop output - - err := cmd.Execute() - assert.NoError(t, err, clues.ToCore(err)) + flagsTD.WithFlags( + groupsServiceCommand, + []string{ + "--" + flags.RunModeFN, flags.RunModeFlagTest, + "--" + flags.BackupFN, flagsTD.BackupInput, + "--" + flags.SkipReduceFN, + }, + flagsTD.PreparedProviderFlags(), + flagsTD.PreparedStorageFlags())) co := utils.Control() assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) - assert.True(t, co.SkipReduce) - flagsTD.AssertProviderFlags(t, cmd) flagsTD.AssertStorageFlags(t, cmd) } @@ -280,48 +223,24 @@ func (suite *GroupsUnitSuite) TestBackupDetailsFlags() { func (suite *GroupsUnitSuite) TestBackupDeleteFlags() { t := suite.T() - cmd := &cobra.Command{Use: deleteCommand} - - // persistent flags not added by addCommands - flags.AddRunModeFlag(cmd, true) - - c := addGroupsCommands(cmd) - require.NotNil(t, c) - - // non-persistent flags not added by addCommands - flags.AddAllProviderFlags(c) - flags.AddAllStorageFlags(c) - - flagsTD.WithFlags( - cmd, - groupsServiceCommand, - []string{ - "--" + flags.RunModeFN, flags.RunModeFlagTest, - "--" + flags.BackupFN, flagsTD.BackupInput, + cmd := cliTD.SetUpCmdHasFlags( + t, + &cobra.Command{Use: deleteCommand}, + addGroupsCommands, + []cliTD.UseCobraCommandFn{ + flags.AddAllProviderFlags, + flags.AddAllStorageFlags, }, - flagsTD.PreparedProviderFlags(), - flagsTD.PreparedStorageFlags()) - - // Test arg parsing for few args - args := []string{ - groupsServiceCommand, - "--" + flags.RunModeFN, flags.RunModeFlagTest, - "--" + flags.BackupFN, flagsTD.BackupInput, - } - - args = append(args, flagsTD.PreparedProviderFlags()...) - args = append(args, flagsTD.PreparedStorageFlags()...) - - cmd.SetArgs(args) - - cmd.SetOut(new(bytes.Buffer)) // drop output - cmd.SetErr(new(bytes.Buffer)) // drop output - - err := cmd.Execute() - assert.NoError(t, err, clues.ToCore(err)) + flagsTD.WithFlags( + groupsServiceCommand, + []string{ + "--" + flags.RunModeFN, flags.RunModeFlagTest, + "--" + flags.BackupFN, flagsTD.BackupInput, + }, + flagsTD.PreparedProviderFlags(), + flagsTD.PreparedStorageFlags())) assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) - flagsTD.AssertProviderFlags(t, cmd) flagsTD.AssertStorageFlags(t, cmd) } diff --git a/src/cli/backup/onedrive_test.go b/src/cli/backup/onedrive_test.go index 340f598dc..6d0e0b202 100644 --- a/src/cli/backup/onedrive_test.go +++ b/src/cli/backup/onedrive_test.go @@ -1,7 +1,6 @@ package backup import ( - "bytes" "fmt" "testing" @@ -13,6 +12,7 @@ import ( "github.com/alcionai/corso/src/cli/flags" flagsTD "github.com/alcionai/corso/src/cli/flags/testdata" + cliTD "github.com/alcionai/corso/src/cli/testdata" "github.com/alcionai/corso/src/cli/utils" utilsTD "github.com/alcionai/corso/src/cli/utils/testdata" "github.com/alcionai/corso/src/internal/tester" @@ -92,48 +92,33 @@ func (suite *OneDriveUnitSuite) TestAddOneDriveCommands() { func (suite *OneDriveUnitSuite) TestBackupCreateFlags() { t := suite.T() - cmd := &cobra.Command{Use: createCommand} - - // persistent flags not added by addCommands - flags.AddRunModeFlag(cmd, true) - - c := addOneDriveCommands(cmd) - require.NotNil(t, c) - - // non-persistent flags not added by addCommands - flags.AddAllProviderFlags(c) - flags.AddAllStorageFlags(c) - - flagsTD.WithFlags( - cmd, - oneDriveServiceCommand, - []string{ - "--" + flags.RunModeFN, flags.RunModeFlagTest, - "--" + flags.UserFN, flagsTD.FlgInputs(flagsTD.UsersInput), - "--" + flags.FailFastFN, - "--" + flags.DisableIncrementalsFN, - "--" + flags.ForceItemDataDownloadFN, + cmd := cliTD.SetUpCmdHasFlags( + t, + &cobra.Command{Use: createCommand}, + addOneDriveCommands, + []cliTD.UseCobraCommandFn{ + flags.AddAllProviderFlags, + flags.AddAllStorageFlags, }, - flagsTD.PreparedProviderFlags(), - flagsTD.PreparedStorageFlags()) - - cmd.SetOut(new(bytes.Buffer)) // drop output - cmd.SetErr(new(bytes.Buffer)) // drop output - - err := cmd.Execute() - assert.NoError(t, err, clues.ToCore(err)) + flagsTD.WithFlags( + oneDriveServiceCommand, + []string{ + "--" + flags.RunModeFN, flags.RunModeFlagTest, + "--" + flags.UserFN, flagsTD.FlgInputs(flagsTD.UsersInput), + "--" + flags.FailFastFN, + "--" + flags.DisableIncrementalsFN, + "--" + flags.ForceItemDataDownloadFN, + }, + flagsTD.PreparedProviderFlags(), + flagsTD.PreparedStorageFlags())) opts := utils.MakeOneDriveOpts(cmd) co := utils.Control() assert.ElementsMatch(t, flagsTD.UsersInput, opts.Users) - // no assertion for category data input - - // bool flags assert.Equal(t, control.FailFast, co.FailureHandling) assert.True(t, co.ToggleFeatures.DisableIncrementals) assert.True(t, co.ToggleFeatures.ForceItemDataDownload) - flagsTD.AssertProviderFlags(t, cmd) flagsTD.AssertStorageFlags(t, cmd) } @@ -141,37 +126,25 @@ func (suite *OneDriveUnitSuite) TestBackupCreateFlags() { func (suite *OneDriveUnitSuite) TestBackupListFlags() { t := suite.T() - cmd := &cobra.Command{Use: listCommand} - - // persistent flags not added by addCommands - flags.AddRunModeFlag(cmd, true) - - c := addOneDriveCommands(cmd) - require.NotNil(t, c) - - // non-persistent flags not added by addCommands - flags.AddAllProviderFlags(c) - flags.AddAllStorageFlags(c) - - flagsTD.WithFlags( - cmd, - oneDriveServiceCommand, - []string{ - "--" + flags.RunModeFN, flags.RunModeFlagTest, - "--" + flags.BackupFN, flagsTD.BackupInput, + cmd := cliTD.SetUpCmdHasFlags( + t, + &cobra.Command{Use: listCommand}, + addOneDriveCommands, + []cliTD.UseCobraCommandFn{ + flags.AddAllProviderFlags, + flags.AddAllStorageFlags, }, - flagsTD.PreparedBackupListFlags(), - flagsTD.PreparedProviderFlags(), - flagsTD.PreparedStorageFlags()) - - cmd.SetOut(new(bytes.Buffer)) // drop output - cmd.SetErr(new(bytes.Buffer)) // drop output - - err := cmd.Execute() - assert.NoError(t, err, clues.ToCore(err)) + flagsTD.WithFlags( + oneDriveServiceCommand, + []string{ + "--" + flags.RunModeFN, flags.RunModeFlagTest, + "--" + flags.BackupFN, flagsTD.BackupInput, + }, + flagsTD.PreparedBackupListFlags(), + flagsTD.PreparedProviderFlags(), + flagsTD.PreparedStorageFlags())) assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) - flagsTD.AssertBackupListFlags(t, cmd) flagsTD.AssertProviderFlags(t, cmd) flagsTD.AssertStorageFlags(t, cmd) @@ -180,41 +153,28 @@ func (suite *OneDriveUnitSuite) TestBackupListFlags() { func (suite *OneDriveUnitSuite) TestBackupDetailsFlags() { t := suite.T() - cmd := &cobra.Command{Use: detailsCommand} - - // persistent flags not added by addCommands - flags.AddRunModeFlag(cmd, true) - - c := addOneDriveCommands(cmd) - require.NotNil(t, c) - - // non-persistent flags not added by addCommands - flags.AddAllProviderFlags(c) - flags.AddAllStorageFlags(c) - - flagsTD.WithFlags( - cmd, - oneDriveServiceCommand, - []string{ - "--" + flags.RunModeFN, flags.RunModeFlagTest, - "--" + flags.BackupFN, flagsTD.BackupInput, - "--" + flags.SkipReduceFN, + cmd := cliTD.SetUpCmdHasFlags( + t, + &cobra.Command{Use: detailsCommand}, + addOneDriveCommands, + []cliTD.UseCobraCommandFn{ + flags.AddAllProviderFlags, + flags.AddAllStorageFlags, }, - flagsTD.PreparedProviderFlags(), - flagsTD.PreparedStorageFlags()) - - cmd.SetOut(new(bytes.Buffer)) // drop output - cmd.SetErr(new(bytes.Buffer)) // drop output - - err := cmd.Execute() - assert.NoError(t, err, clues.ToCore(err)) + flagsTD.WithFlags( + oneDriveServiceCommand, + []string{ + "--" + flags.RunModeFN, flags.RunModeFlagTest, + "--" + flags.BackupFN, flagsTD.BackupInput, + "--" + flags.SkipReduceFN, + }, + flagsTD.PreparedProviderFlags(), + flagsTD.PreparedStorageFlags())) co := utils.Control() - assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) - assert.True(t, co.SkipReduce) - + assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) flagsTD.AssertProviderFlags(t, cmd) flagsTD.AssertStorageFlags(t, cmd) } @@ -222,36 +182,24 @@ func (suite *OneDriveUnitSuite) TestBackupDetailsFlags() { func (suite *OneDriveUnitSuite) TestBackupDeleteFlags() { t := suite.T() - cmd := &cobra.Command{Use: deleteCommand} - - // persistent flags not added by addCommands - flags.AddRunModeFlag(cmd, true) - - c := addOneDriveCommands(cmd) - require.NotNil(t, c) - - // non-persistent flags not added by addCommands - flags.AddAllProviderFlags(c) - flags.AddAllStorageFlags(c) - - flagsTD.WithFlags( - cmd, - oneDriveServiceCommand, - []string{ - "--" + flags.RunModeFN, flags.RunModeFlagTest, - "--" + flags.BackupFN, flagsTD.BackupInput, + cmd := cliTD.SetUpCmdHasFlags( + t, + &cobra.Command{Use: deleteCommand}, + addOneDriveCommands, + []cliTD.UseCobraCommandFn{ + flags.AddAllProviderFlags, + flags.AddAllStorageFlags, }, - flagsTD.PreparedProviderFlags(), - flagsTD.PreparedStorageFlags()) - - cmd.SetOut(new(bytes.Buffer)) // drop output - cmd.SetErr(new(bytes.Buffer)) // drop output - - err := cmd.Execute() - assert.NoError(t, err, clues.ToCore(err)) + flagsTD.WithFlags( + oneDriveServiceCommand, + []string{ + "--" + flags.RunModeFN, flags.RunModeFlagTest, + "--" + flags.BackupFN, flagsTD.BackupInput, + }, + flagsTD.PreparedProviderFlags(), + flagsTD.PreparedStorageFlags())) assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) - flagsTD.AssertProviderFlags(t, cmd) flagsTD.AssertStorageFlags(t, cmd) } diff --git a/src/cli/backup/sharepoint_test.go b/src/cli/backup/sharepoint_test.go index fd724d83b..f09bbe878 100644 --- a/src/cli/backup/sharepoint_test.go +++ b/src/cli/backup/sharepoint_test.go @@ -1,7 +1,6 @@ package backup import ( - "bytes" "fmt" "strings" "testing" @@ -14,6 +13,7 @@ import ( "github.com/alcionai/corso/src/cli/flags" flagsTD "github.com/alcionai/corso/src/cli/flags/testdata" + cliTD "github.com/alcionai/corso/src/cli/testdata" "github.com/alcionai/corso/src/cli/utils" utilsTD "github.com/alcionai/corso/src/cli/utils/testdata" "github.com/alcionai/corso/src/internal/common/idname" @@ -94,51 +94,36 @@ func (suite *SharePointUnitSuite) TestAddSharePointCommands() { func (suite *SharePointUnitSuite) TestBackupCreateFlags() { t := suite.T() - cmd := &cobra.Command{Use: createCommand} - - // persistent flags not added by addCommands - flags.AddRunModeFlag(cmd, true) - - c := addSharePointCommands(cmd) - require.NotNil(t, c) - - // non-persistent flags not added by addCommands - flags.AddAllProviderFlags(c) - flags.AddAllStorageFlags(c) - - flagsTD.WithFlags( - cmd, - sharePointServiceCommand, - []string{ - "--" + flags.RunModeFN, flags.RunModeFlagTest, - "--" + flags.SiteIDFN, flagsTD.FlgInputs(flagsTD.SiteIDInput), - "--" + flags.SiteFN, flagsTD.FlgInputs(flagsTD.WebURLInput), - "--" + flags.CategoryDataFN, flagsTD.FlgInputs(flagsTD.SharepointCategoryDataInput), - "--" + flags.FailFastFN, - "--" + flags.DisableIncrementalsFN, - "--" + flags.ForceItemDataDownloadFN, + cmd := cliTD.SetUpCmdHasFlags( + t, + &cobra.Command{Use: createCommand}, + addSharePointCommands, + []cliTD.UseCobraCommandFn{ + flags.AddAllProviderFlags, + flags.AddAllStorageFlags, }, - flagsTD.PreparedProviderFlags(), - flagsTD.PreparedStorageFlags()) - - cmd.SetOut(new(bytes.Buffer)) // drop output - cmd.SetErr(new(bytes.Buffer)) // drop output - - err := cmd.Execute() - assert.NoError(t, err, clues.ToCore(err)) + flagsTD.WithFlags( + sharePointServiceCommand, + []string{ + "--" + flags.RunModeFN, flags.RunModeFlagTest, + "--" + flags.SiteIDFN, flagsTD.FlgInputs(flagsTD.SiteIDInput), + "--" + flags.SiteFN, flagsTD.FlgInputs(flagsTD.WebURLInput), + "--" + flags.CategoryDataFN, flagsTD.FlgInputs(flagsTD.SharepointCategoryDataInput), + "--" + flags.FailFastFN, + "--" + flags.DisableIncrementalsFN, + "--" + flags.ForceItemDataDownloadFN, + }, + flagsTD.PreparedProviderFlags(), + flagsTD.PreparedStorageFlags())) opts := utils.MakeSharePointOpts(cmd) co := utils.Control() assert.ElementsMatch(t, []string{strings.Join(flagsTD.SiteIDInput, ",")}, opts.SiteID) assert.ElementsMatch(t, flagsTD.WebURLInput, opts.WebURL) - // no assertion for category data input - - // bool flags assert.Equal(t, control.FailFast, co.FailureHandling) assert.True(t, co.ToggleFeatures.DisableIncrementals) assert.True(t, co.ToggleFeatures.ForceItemDataDownload) - flagsTD.AssertProviderFlags(t, cmd) flagsTD.AssertStorageFlags(t, cmd) } @@ -146,37 +131,25 @@ func (suite *SharePointUnitSuite) TestBackupCreateFlags() { func (suite *SharePointUnitSuite) TestBackupListFlags() { t := suite.T() - cmd := &cobra.Command{Use: listCommand} - - // persistent flags not added by addCommands - flags.AddRunModeFlag(cmd, true) - - c := addSharePointCommands(cmd) - require.NotNil(t, c) - - // non-persistent flags not added by addCommands - flags.AddAllProviderFlags(c) - flags.AddAllStorageFlags(c) - - flagsTD.WithFlags( - cmd, - sharePointServiceCommand, - []string{ - "--" + flags.RunModeFN, flags.RunModeFlagTest, - "--" + flags.BackupFN, flagsTD.BackupInput, + cmd := cliTD.SetUpCmdHasFlags( + t, + &cobra.Command{Use: listCommand}, + addSharePointCommands, + []cliTD.UseCobraCommandFn{ + flags.AddAllProviderFlags, + flags.AddAllStorageFlags, }, - flagsTD.PreparedBackupListFlags(), - flagsTD.PreparedProviderFlags(), - flagsTD.PreparedStorageFlags()) - - cmd.SetOut(new(bytes.Buffer)) // drop output - cmd.SetErr(new(bytes.Buffer)) // drop output - - err := cmd.Execute() - assert.NoError(t, err, clues.ToCore(err)) + flagsTD.WithFlags( + sharePointServiceCommand, + []string{ + "--" + flags.RunModeFN, flags.RunModeFlagTest, + "--" + flags.BackupFN, flagsTD.BackupInput, + }, + flagsTD.PreparedBackupListFlags(), + flagsTD.PreparedProviderFlags(), + flagsTD.PreparedStorageFlags())) assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) - flagsTD.AssertBackupListFlags(t, cmd) flagsTD.AssertProviderFlags(t, cmd) flagsTD.AssertStorageFlags(t, cmd) @@ -185,41 +158,28 @@ func (suite *SharePointUnitSuite) TestBackupListFlags() { func (suite *SharePointUnitSuite) TestBackupDetailsFlags() { t := suite.T() - cmd := &cobra.Command{Use: detailsCommand} - - // persistent flags not added by addCommands - flags.AddRunModeFlag(cmd, true) - - c := addSharePointCommands(cmd) - require.NotNil(t, c) - - // non-persistent flags not added by addCommands - flags.AddAllProviderFlags(c) - flags.AddAllStorageFlags(c) - - flagsTD.WithFlags( - cmd, - sharePointServiceCommand, - []string{ - "--" + flags.RunModeFN, flags.RunModeFlagTest, - "--" + flags.BackupFN, flagsTD.BackupInput, - "--" + flags.SkipReduceFN, + cmd := cliTD.SetUpCmdHasFlags( + t, + &cobra.Command{Use: detailsCommand}, + addSharePointCommands, + []cliTD.UseCobraCommandFn{ + flags.AddAllProviderFlags, + flags.AddAllStorageFlags, }, - flagsTD.PreparedProviderFlags(), - flagsTD.PreparedStorageFlags()) - - cmd.SetOut(new(bytes.Buffer)) // drop output - cmd.SetErr(new(bytes.Buffer)) // drop output - - err := cmd.Execute() - assert.NoError(t, err, clues.ToCore(err)) + flagsTD.WithFlags( + sharePointServiceCommand, + []string{ + "--" + flags.RunModeFN, flags.RunModeFlagTest, + "--" + flags.BackupFN, flagsTD.BackupInput, + "--" + flags.SkipReduceFN, + }, + flagsTD.PreparedProviderFlags(), + flagsTD.PreparedStorageFlags())) co := utils.Control() assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) - assert.True(t, co.SkipReduce) - flagsTD.AssertProviderFlags(t, cmd) flagsTD.AssertStorageFlags(t, cmd) } @@ -227,36 +187,24 @@ func (suite *SharePointUnitSuite) TestBackupDetailsFlags() { func (suite *SharePointUnitSuite) TestBackupDeleteFlags() { t := suite.T() - cmd := &cobra.Command{Use: deleteCommand} - - // persistent flags not added by addCommands - flags.AddRunModeFlag(cmd, true) - - c := addSharePointCommands(cmd) - require.NotNil(t, c) - - // non-persistent flags not added by addCommands - flags.AddAllProviderFlags(c) - flags.AddAllStorageFlags(c) - - flagsTD.WithFlags( - cmd, - sharePointServiceCommand, - []string{ - "--" + flags.RunModeFN, flags.RunModeFlagTest, - "--" + flags.BackupFN, flagsTD.BackupInput, + cmd := cliTD.SetUpCmdHasFlags( + t, + &cobra.Command{Use: deleteCommand}, + addSharePointCommands, + []cliTD.UseCobraCommandFn{ + flags.AddAllProviderFlags, + flags.AddAllStorageFlags, }, - flagsTD.PreparedProviderFlags(), - flagsTD.PreparedStorageFlags()) - - cmd.SetOut(new(bytes.Buffer)) // drop output - cmd.SetErr(new(bytes.Buffer)) // drop output - - err := cmd.Execute() - assert.NoError(t, err, clues.ToCore(err)) + flagsTD.WithFlags( + sharePointServiceCommand, + []string{ + "--" + flags.RunModeFN, flags.RunModeFlagTest, + "--" + flags.BackupFN, flagsTD.BackupInput, + }, + flagsTD.PreparedProviderFlags(), + flagsTD.PreparedStorageFlags())) assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) - flagsTD.AssertProviderFlags(t, cmd) flagsTD.AssertStorageFlags(t, cmd) } diff --git a/src/cli/export/export.go b/src/cli/export/export.go index db48f466a..8415caea3 100644 --- a/src/cli/export/export.go +++ b/src/cli/export/export.go @@ -27,11 +27,11 @@ var exportCommands = []func(cmd *cobra.Command) *cobra.Command{ // AddCommands attaches all `corso export * *` commands to the parent. func AddCommands(cmd *cobra.Command) { subCommand := exportCmd() - flags.AddAllStorageFlags(subCommand) cmd.AddCommand(subCommand) for _, addExportTo := range exportCommands { - addExportTo(subCommand) + sc := addExportTo(subCommand) + flags.AddAllStorageFlags(sc) } } diff --git a/src/cli/export/groups_test.go b/src/cli/export/groups_test.go index 0f53bb6f8..3b75f0252 100644 --- a/src/cli/export/groups_test.go +++ b/src/cli/export/groups_test.go @@ -1,17 +1,15 @@ package export import ( - "bytes" "testing" - "github.com/alcionai/clues" "github.com/spf13/cobra" "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" "github.com/alcionai/corso/src/cli/flags" flagsTD "github.com/alcionai/corso/src/cli/flags/testdata" + cliTD "github.com/alcionai/corso/src/cli/testdata" "github.com/alcionai/corso/src/cli/utils" "github.com/alcionai/corso/src/internal/tester" ) @@ -39,55 +37,41 @@ func (suite *GroupsUnitSuite) TestAddGroupsCommands() { for _, test := range table { suite.Run(test.name, func() { t := suite.T() + parent := &cobra.Command{Use: exportCommand} - cmd := &cobra.Command{Use: test.use} - - // persistent flags not added by addCommands - flags.AddRunModeFlag(cmd, true) - - c := addGroupsCommands(cmd) - require.NotNil(t, c) - - // non-persistent flags not added by addCommands - flags.AddAllProviderFlags(c) - flags.AddAllStorageFlags(c) - - cmds := cmd.Commands() - require.Len(t, cmds, 1) - - child := cmds[0] - assert.Equal(t, test.expectUse, child.Use) - assert.Equal(t, test.expectShort, child.Short) - tester.AreSameFunc(t, test.expectRunE, child.RunE) - - flagsTD.WithFlags( - cmd, - groupsServiceCommand, - []string{ - flagsTD.RestoreDestination, - "--" + flags.RunModeFN, flags.RunModeFlagTest, - "--" + flags.BackupFN, flagsTD.BackupInput, - - "--" + flags.FormatFN, flagsTD.FormatType, - - // bool flags - "--" + flags.ArchiveFN, + cmd := cliTD.SetUpCmdHasFlags( + t, + parent, + addGroupsCommands, + []cliTD.UseCobraCommandFn{ + flags.AddAllProviderFlags, + flags.AddAllStorageFlags, }, - flagsTD.PreparedProviderFlags(), - flagsTD.PreparedStorageFlags()) + flagsTD.WithFlags( + groupsServiceCommand, + []string{ + flagsTD.RestoreDestination, + "--" + flags.RunModeFN, flags.RunModeFlagTest, + "--" + flags.BackupFN, flagsTD.BackupInput, + "--" + flags.FormatFN, flagsTD.FormatType, + "--" + flags.ArchiveFN, + }, + flagsTD.PreparedProviderFlags(), + flagsTD.PreparedStorageFlags())) - cmd.SetOut(new(bytes.Buffer)) // drop output - cmd.SetErr(new(bytes.Buffer)) // drop output - - err := cmd.Execute() - assert.NoError(t, err, clues.ToCore(err)) + cliTD.CheckCmdChild( + t, + parent, + 3, + test.expectUse, + test.expectShort, + test.expectRunE) opts := utils.MakeGroupsOpts(cmd) - assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) + assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) assert.Equal(t, flagsTD.Archive, opts.ExportCfg.Archive) assert.Equal(t, flagsTD.FormatType, opts.ExportCfg.Format) - flagsTD.AssertStorageFlags(t, cmd) }) } diff --git a/src/cli/export/onedrive_test.go b/src/cli/export/onedrive_test.go index 2049234ae..0afe6c437 100644 --- a/src/cli/export/onedrive_test.go +++ b/src/cli/export/onedrive_test.go @@ -1,17 +1,15 @@ package export import ( - "bytes" "testing" - "github.com/alcionai/clues" "github.com/spf13/cobra" "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" "github.com/alcionai/corso/src/cli/flags" flagsTD "github.com/alcionai/corso/src/cli/flags/testdata" + cliTD "github.com/alcionai/corso/src/cli/testdata" "github.com/alcionai/corso/src/cli/utils" "github.com/alcionai/corso/src/internal/tester" ) @@ -39,67 +37,55 @@ func (suite *OneDriveUnitSuite) TestAddOneDriveCommands() { for _, test := range table { suite.Run(test.name, func() { t := suite.T() + parent := &cobra.Command{Use: exportCommand} - cmd := &cobra.Command{Use: test.use} - - // persistent flags not added by addCommands - flags.AddRunModeFlag(cmd, true) - - c := addOneDriveCommands(cmd) - require.NotNil(t, c) - - // non-persistent flags not added by addCommands - flags.AddAllProviderFlags(c) - flags.AddAllStorageFlags(c) - - cmds := cmd.Commands() - require.Len(t, cmds, 1) - - child := cmds[0] - assert.Equal(t, test.expectUse, child.Use) - assert.Equal(t, test.expectShort, child.Short) - tester.AreSameFunc(t, test.expectRunE, child.RunE) - - flagsTD.WithFlags( - cmd, - oneDriveServiceCommand, - []string{ - flagsTD.RestoreDestination, - "--" + flags.RunModeFN, flags.RunModeFlagTest, - "--" + flags.BackupFN, flagsTD.BackupInput, - "--" + flags.FileFN, flagsTD.FlgInputs(flagsTD.FileNameInput), - "--" + flags.FolderFN, flagsTD.FlgInputs(flagsTD.FolderPathInput), - "--" + flags.FileCreatedAfterFN, flagsTD.FileCreatedAfterInput, - "--" + flags.FileCreatedBeforeFN, flagsTD.FileCreatedBeforeInput, - "--" + flags.FileModifiedAfterFN, flagsTD.FileModifiedAfterInput, - "--" + flags.FileModifiedBeforeFN, flagsTD.FileModifiedBeforeInput, - - "--" + flags.FormatFN, flagsTD.FormatType, - - // bool flags - "--" + flags.ArchiveFN, + cmd := cliTD.SetUpCmdHasFlags( + t, + parent, + addOneDriveCommands, + []cliTD.UseCobraCommandFn{ + flags.AddAllProviderFlags, + flags.AddAllStorageFlags, }, - flagsTD.PreparedProviderFlags(), - flagsTD.PreparedStorageFlags()) + flagsTD.WithFlags( + oneDriveServiceCommand, + []string{ + flagsTD.RestoreDestination, + "--" + flags.RunModeFN, flags.RunModeFlagTest, + "--" + flags.BackupFN, flagsTD.BackupInput, + "--" + flags.FileFN, flagsTD.FlgInputs(flagsTD.FileNameInput), + "--" + flags.FolderFN, flagsTD.FlgInputs(flagsTD.FolderPathInput), + "--" + flags.FileCreatedAfterFN, flagsTD.FileCreatedAfterInput, + "--" + flags.FileCreatedBeforeFN, flagsTD.FileCreatedBeforeInput, + "--" + flags.FileModifiedAfterFN, flagsTD.FileModifiedAfterInput, + "--" + flags.FileModifiedBeforeFN, flagsTD.FileModifiedBeforeInput, - cmd.SetOut(new(bytes.Buffer)) // drop output - cmd.SetErr(new(bytes.Buffer)) // drop output + "--" + flags.FormatFN, flagsTD.FormatType, - err := cmd.Execute() - assert.NoError(t, err, clues.ToCore(err)) + // bool flags + "--" + flags.ArchiveFN, + }, + flagsTD.PreparedProviderFlags(), + flagsTD.PreparedStorageFlags())) + + cliTD.CheckCmdChild( + t, + parent, + 3, + test.expectUse, + test.expectShort, + test.expectRunE) opts := utils.MakeOneDriveOpts(cmd) - assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) + assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) assert.ElementsMatch(t, flagsTD.FileNameInput, opts.FileName) assert.ElementsMatch(t, flagsTD.FolderPathInput, opts.FolderPath) assert.Equal(t, flagsTD.FileCreatedAfterInput, opts.FileCreatedAfter) assert.Equal(t, flagsTD.FileCreatedBeforeInput, opts.FileCreatedBefore) assert.Equal(t, flagsTD.FileModifiedAfterInput, opts.FileModifiedAfter) assert.Equal(t, flagsTD.FileModifiedBeforeInput, opts.FileModifiedBefore) - assert.Equal(t, flagsTD.CorsoPassphrase, flags.CorsoPassphraseFV) - flagsTD.AssertStorageFlags(t, cmd) }) } diff --git a/src/cli/export/sharepoint_test.go b/src/cli/export/sharepoint_test.go index affb060e1..4850173ca 100644 --- a/src/cli/export/sharepoint_test.go +++ b/src/cli/export/sharepoint_test.go @@ -1,17 +1,15 @@ package export import ( - "bytes" "testing" - "github.com/alcionai/clues" "github.com/spf13/cobra" "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" "github.com/alcionai/corso/src/cli/flags" flagsTD "github.com/alcionai/corso/src/cli/flags/testdata" + cliTD "github.com/alcionai/corso/src/cli/testdata" "github.com/alcionai/corso/src/cli/utils" "github.com/alcionai/corso/src/internal/tester" ) @@ -39,63 +37,50 @@ func (suite *SharePointUnitSuite) TestAddSharePointCommands() { for _, test := range table { suite.Run(test.name, func() { t := suite.T() + parent := &cobra.Command{Use: exportCommand} - cmd := &cobra.Command{Use: test.use} - - // persistent flags not added by addCommands - flags.AddRunModeFlag(cmd, true) - - c := addSharePointCommands(cmd) - require.NotNil(t, c) - - // non-persistent flags not added by addCommands - flags.AddAllProviderFlags(c) - flags.AddAllStorageFlags(c) - - cmds := cmd.Commands() - require.Len(t, cmds, 1) - - child := cmds[0] - assert.Equal(t, test.expectUse, child.Use) - assert.Equal(t, test.expectShort, child.Short) - tester.AreSameFunc(t, test.expectRunE, child.RunE) - - flagsTD.WithFlags( - cmd, - sharePointServiceCommand, - []string{ - flagsTD.RestoreDestination, - "--" + flags.RunModeFN, flags.RunModeFlagTest, - "--" + flags.BackupFN, flagsTD.BackupInput, - "--" + flags.LibraryFN, flagsTD.LibraryInput, - "--" + flags.FileFN, flagsTD.FlgInputs(flagsTD.FileNameInput), - "--" + flags.FolderFN, flagsTD.FlgInputs(flagsTD.FolderPathInput), - "--" + flags.FileCreatedAfterFN, flagsTD.FileCreatedAfterInput, - "--" + flags.FileCreatedBeforeFN, flagsTD.FileCreatedBeforeInput, - "--" + flags.FileModifiedAfterFN, flagsTD.FileModifiedAfterInput, - "--" + flags.FileModifiedBeforeFN, flagsTD.FileModifiedBeforeInput, - "--" + flags.ListItemFN, flagsTD.FlgInputs(flagsTD.ListItemInput), - "--" + flags.ListFolderFN, flagsTD.FlgInputs(flagsTD.ListFolderInput), - "--" + flags.PageFN, flagsTD.FlgInputs(flagsTD.PageInput), - "--" + flags.PageFolderFN, flagsTD.FlgInputs(flagsTD.PageFolderInput), - - "--" + flags.FormatFN, flagsTD.FormatType, - - // bool flags - "--" + flags.ArchiveFN, + cmd := cliTD.SetUpCmdHasFlags( + t, + parent, + addSharePointCommands, + []cliTD.UseCobraCommandFn{ + flags.AddAllProviderFlags, + flags.AddAllStorageFlags, }, - flagsTD.PreparedProviderFlags(), - flagsTD.PreparedStorageFlags()) + flagsTD.WithFlags( + sharePointServiceCommand, + []string{ + flagsTD.RestoreDestination, + "--" + flags.RunModeFN, flags.RunModeFlagTest, + "--" + flags.BackupFN, flagsTD.BackupInput, + "--" + flags.LibraryFN, flagsTD.LibraryInput, + "--" + flags.FileFN, flagsTD.FlgInputs(flagsTD.FileNameInput), + "--" + flags.FolderFN, flagsTD.FlgInputs(flagsTD.FolderPathInput), + "--" + flags.FileCreatedAfterFN, flagsTD.FileCreatedAfterInput, + "--" + flags.FileCreatedBeforeFN, flagsTD.FileCreatedBeforeInput, + "--" + flags.FileModifiedAfterFN, flagsTD.FileModifiedAfterInput, + "--" + flags.FileModifiedBeforeFN, flagsTD.FileModifiedBeforeInput, + "--" + flags.ListItemFN, flagsTD.FlgInputs(flagsTD.ListItemInput), + "--" + flags.ListFolderFN, flagsTD.FlgInputs(flagsTD.ListFolderInput), + "--" + flags.PageFN, flagsTD.FlgInputs(flagsTD.PageInput), + "--" + flags.PageFolderFN, flagsTD.FlgInputs(flagsTD.PageFolderInput), + "--" + flags.FormatFN, flagsTD.FormatType, + "--" + flags.ArchiveFN, + }, + flagsTD.PreparedProviderFlags(), + flagsTD.PreparedStorageFlags())) - cmd.SetOut(new(bytes.Buffer)) // drop output - cmd.SetErr(new(bytes.Buffer)) // drop output - - err := cmd.Execute() - assert.NoError(t, err, clues.ToCore(err)) + cliTD.CheckCmdChild( + t, + parent, + 3, + test.expectUse, + test.expectShort, + test.expectRunE) opts := utils.MakeSharePointOpts(cmd) - assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) + assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) assert.Equal(t, flagsTD.LibraryInput, opts.Library) assert.ElementsMatch(t, flagsTD.FileNameInput, opts.FileName) assert.ElementsMatch(t, flagsTD.FolderPathInput, opts.FolderPath) @@ -103,16 +88,12 @@ func (suite *SharePointUnitSuite) TestAddSharePointCommands() { assert.Equal(t, flagsTD.FileCreatedBeforeInput, opts.FileCreatedBefore) assert.Equal(t, flagsTD.FileModifiedAfterInput, opts.FileModifiedAfter) assert.Equal(t, flagsTD.FileModifiedBeforeInput, opts.FileModifiedBefore) - assert.ElementsMatch(t, flagsTD.ListItemInput, opts.ListItem) assert.ElementsMatch(t, flagsTD.ListFolderInput, opts.ListFolder) - assert.ElementsMatch(t, flagsTD.PageInput, opts.Page) assert.ElementsMatch(t, flagsTD.PageFolderInput, opts.PageFolder) - assert.Equal(t, flagsTD.Archive, opts.ExportCfg.Archive) assert.Equal(t, flagsTD.FormatType, opts.ExportCfg.Format) - flagsTD.AssertStorageFlags(t, cmd) }) } diff --git a/src/cli/flags/testdata/flags.go b/src/cli/flags/testdata/flags.go index c8339cf73..7dec134f4 100644 --- a/src/cli/flags/testdata/flags.go +++ b/src/cli/flags/testdata/flags.go @@ -86,7 +86,7 @@ var ( DisableConcurrencyLimiter = true ) -func WithFlags( +func WithFlags2( cc *cobra.Command, command string, flagSets ...[]string, @@ -99,3 +99,18 @@ func WithFlags( cc.SetArgs(args) } + +func WithFlags( + command string, + flagSets ...[]string, +) func(*cobra.Command) { + return func(cc *cobra.Command) { + args := []string{command} + + for _, sl := range flagSets { + args = append(args, sl...) + } + + cc.SetArgs(args) + } +} diff --git a/src/cli/restore/exchange_test.go b/src/cli/restore/exchange_test.go index d7ffb1b98..c16eac331 100644 --- a/src/cli/restore/exchange_test.go +++ b/src/cli/restore/exchange_test.go @@ -1,17 +1,15 @@ package restore import ( - "bytes" "testing" - "github.com/alcionai/clues" "github.com/spf13/cobra" "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" "github.com/alcionai/corso/src/cli/flags" flagsTD "github.com/alcionai/corso/src/cli/flags/testdata" + cliTD "github.com/alcionai/corso/src/cli/testdata" "github.com/alcionai/corso/src/cli/utils" "github.com/alcionai/corso/src/internal/tester" ) @@ -39,80 +37,64 @@ func (suite *ExchangeUnitSuite) TestAddExchangeCommands() { for _, test := range table { suite.Run(test.name, func() { t := suite.T() + parent := &cobra.Command{Use: restoreCommand} - cmd := &cobra.Command{Use: test.use} - - // persistent flags not added by addCommands - flags.AddRunModeFlag(cmd, true) - - c := addExchangeCommands(cmd) - require.NotNil(t, c) - - // non-persistent flags not added by addCommands - flags.AddAllProviderFlags(c) - flags.AddAllStorageFlags(c) - - cmds := cmd.Commands() - require.Len(t, cmds, 1) - - child := cmds[0] - assert.Equal(t, test.expectUse, child.Use) - assert.Equal(t, test.expectShort, child.Short) - tester.AreSameFunc(t, test.expectRunE, child.RunE) - - flagsTD.WithFlags( - cmd, - exchangeServiceCommand, - []string{ - "--" + flags.RunModeFN, flags.RunModeFlagTest, - "--" + flags.BackupFN, flagsTD.BackupInput, - - "--" + flags.ContactFN, flagsTD.FlgInputs(flagsTD.ContactInput), - "--" + flags.ContactFolderFN, flagsTD.FlgInputs(flagsTD.ContactFldInput), - "--" + flags.ContactNameFN, flagsTD.ContactNameInput, - - "--" + flags.EmailFN, flagsTD.FlgInputs(flagsTD.EmailInput), - "--" + flags.EmailFolderFN, flagsTD.FlgInputs(flagsTD.EmailFldInput), - "--" + flags.EmailReceivedAfterFN, flagsTD.EmailReceivedAfterInput, - "--" + flags.EmailReceivedBeforeFN, flagsTD.EmailReceivedBeforeInput, - "--" + flags.EmailSenderFN, flagsTD.EmailSenderInput, - "--" + flags.EmailSubjectFN, flagsTD.EmailSubjectInput, - - "--" + flags.EventFN, flagsTD.FlgInputs(flagsTD.EventInput), - "--" + flags.EventCalendarFN, flagsTD.FlgInputs(flagsTD.EventCalInput), - "--" + flags.EventOrganizerFN, flagsTD.EventOrganizerInput, - "--" + flags.EventRecursFN, flagsTD.EventRecursInput, - "--" + flags.EventStartsAfterFN, flagsTD.EventStartsAfterInput, - "--" + flags.EventStartsBeforeFN, flagsTD.EventStartsBeforeInput, - "--" + flags.EventSubjectFN, flagsTD.EventSubjectInput, - - "--" + flags.CollisionsFN, flagsTD.Collisions, - "--" + flags.DestinationFN, flagsTD.Destination, - "--" + flags.ToResourceFN, flagsTD.ToResource, + cmd := cliTD.SetUpCmdHasFlags( + t, + parent, + addExchangeCommands, + []cliTD.UseCobraCommandFn{ + flags.AddAllProviderFlags, + flags.AddAllStorageFlags, }, - flagsTD.PreparedProviderFlags(), - flagsTD.PreparedStorageFlags()) + flagsTD.WithFlags( + exchangeServiceCommand, + []string{ + "--" + flags.RunModeFN, flags.RunModeFlagTest, + "--" + flags.BackupFN, flagsTD.BackupInput, + "--" + flags.ContactFN, flagsTD.FlgInputs(flagsTD.ContactInput), + "--" + flags.ContactFolderFN, flagsTD.FlgInputs(flagsTD.ContactFldInput), + "--" + flags.ContactNameFN, flagsTD.ContactNameInput, + "--" + flags.EmailFN, flagsTD.FlgInputs(flagsTD.EmailInput), + "--" + flags.EmailFolderFN, flagsTD.FlgInputs(flagsTD.EmailFldInput), + "--" + flags.EmailReceivedAfterFN, flagsTD.EmailReceivedAfterInput, + "--" + flags.EmailReceivedBeforeFN, flagsTD.EmailReceivedBeforeInput, + "--" + flags.EmailSenderFN, flagsTD.EmailSenderInput, + "--" + flags.EmailSubjectFN, flagsTD.EmailSubjectInput, + "--" + flags.EventFN, flagsTD.FlgInputs(flagsTD.EventInput), + "--" + flags.EventCalendarFN, flagsTD.FlgInputs(flagsTD.EventCalInput), + "--" + flags.EventOrganizerFN, flagsTD.EventOrganizerInput, + "--" + flags.EventRecursFN, flagsTD.EventRecursInput, + "--" + flags.EventStartsAfterFN, flagsTD.EventStartsAfterInput, + "--" + flags.EventStartsBeforeFN, flagsTD.EventStartsBeforeInput, + "--" + flags.EventSubjectFN, flagsTD.EventSubjectInput, + "--" + flags.CollisionsFN, flagsTD.Collisions, + "--" + flags.DestinationFN, flagsTD.Destination, + "--" + flags.ToResourceFN, flagsTD.ToResource, + }, + flagsTD.PreparedProviderFlags(), + flagsTD.PreparedStorageFlags())) - cmd.SetOut(new(bytes.Buffer)) // drop output - cmd.SetErr(new(bytes.Buffer)) // drop output - - err := cmd.Execute() - assert.NoError(t, err, clues.ToCore(err)) + cliTD.CheckCmdChild( + t, + parent, + 3, + test.expectUse, + test.expectShort, + test.expectRunE) opts := utils.MakeExchangeOpts(cmd) - assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) + assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) assert.ElementsMatch(t, flagsTD.ContactInput, opts.Contact) assert.ElementsMatch(t, flagsTD.ContactFldInput, opts.ContactFolder) assert.Equal(t, flagsTD.ContactNameInput, opts.ContactName) - assert.ElementsMatch(t, flagsTD.EmailInput, opts.Email) assert.ElementsMatch(t, flagsTD.EmailFldInput, opts.EmailFolder) assert.Equal(t, flagsTD.EmailReceivedAfterInput, opts.EmailReceivedAfter) assert.Equal(t, flagsTD.EmailReceivedBeforeInput, opts.EmailReceivedBefore) assert.Equal(t, flagsTD.EmailSenderInput, opts.EmailSender) assert.Equal(t, flagsTD.EmailSubjectInput, opts.EmailSubject) - assert.ElementsMatch(t, flagsTD.EventInput, opts.Event) assert.ElementsMatch(t, flagsTD.EventCalInput, opts.EventCalendar) assert.Equal(t, flagsTD.EventOrganizerInput, opts.EventOrganizer) @@ -120,11 +102,9 @@ func (suite *ExchangeUnitSuite) TestAddExchangeCommands() { assert.Equal(t, flagsTD.EventStartsAfterInput, opts.EventStartsAfter) assert.Equal(t, flagsTD.EventStartsBeforeInput, opts.EventStartsBefore) assert.Equal(t, flagsTD.EventSubjectInput, opts.EventSubject) - assert.Equal(t, flagsTD.Collisions, opts.RestoreCfg.Collisions) assert.Equal(t, flagsTD.Destination, opts.RestoreCfg.Destination) assert.Equal(t, flagsTD.ToResource, opts.RestoreCfg.ProtectedResource) - flagsTD.AssertProviderFlags(t, cmd) flagsTD.AssertStorageFlags(t, cmd) }) diff --git a/src/cli/restore/groups_test.go b/src/cli/restore/groups_test.go index f2045e53c..c6753170b 100644 --- a/src/cli/restore/groups_test.go +++ b/src/cli/restore/groups_test.go @@ -1,17 +1,15 @@ package restore import ( - "bytes" "testing" - "github.com/alcionai/clues" "github.com/spf13/cobra" "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" "github.com/alcionai/corso/src/cli/flags" flagsTD "github.com/alcionai/corso/src/cli/flags/testdata" + cliTD "github.com/alcionai/corso/src/cli/testdata" "github.com/alcionai/corso/src/cli/utils" "github.com/alcionai/corso/src/internal/tester" ) @@ -39,65 +37,51 @@ func (suite *GroupsUnitSuite) TestAddGroupsCommands() { for _, test := range table { suite.Run(test.name, func() { t := suite.T() + parent := &cobra.Command{Use: restoreCommand} - cmd := &cobra.Command{Use: test.use} - - // persistent flags not added by addCommands - flags.AddRunModeFlag(cmd, true) - - c := addGroupsCommands(cmd) - require.NotNil(t, c) - - // non-persistent flags not added by addCommands - flags.AddAllProviderFlags(c) - flags.AddAllStorageFlags(c) - - cmds := cmd.Commands() - require.Len(t, cmds, 1) - - child := cmds[0] - assert.Equal(t, test.expectUse, child.Use) - assert.Equal(t, test.expectShort, child.Short) - tester.AreSameFunc(t, test.expectRunE, child.RunE) - - flagsTD.WithFlags( - cmd, - groupsServiceCommand, - []string{ - "--" + flags.RunModeFN, flags.RunModeFlagTest, - "--" + flags.BackupFN, flagsTD.BackupInput, - - "--" + flags.LibraryFN, flagsTD.LibraryInput, - "--" + flags.FileFN, flagsTD.FlgInputs(flagsTD.FileNameInput), - "--" + flags.FolderFN, flagsTD.FlgInputs(flagsTD.FolderPathInput), - "--" + flags.FileCreatedAfterFN, flagsTD.FileCreatedAfterInput, - "--" + flags.FileCreatedBeforeFN, flagsTD.FileCreatedBeforeInput, - "--" + flags.FileModifiedAfterFN, flagsTD.FileModifiedAfterInput, - "--" + flags.FileModifiedBeforeFN, flagsTD.FileModifiedBeforeInput, - "--" + flags.ListItemFN, flagsTD.FlgInputs(flagsTD.ListItemInput), - "--" + flags.ListFolderFN, flagsTD.FlgInputs(flagsTD.ListFolderInput), - "--" + flags.PageFN, flagsTD.FlgInputs(flagsTD.PageInput), - "--" + flags.PageFolderFN, flagsTD.FlgInputs(flagsTD.PageFolderInput), - - "--" + flags.CollisionsFN, flagsTD.Collisions, - "--" + flags.DestinationFN, flagsTD.Destination, - "--" + flags.ToResourceFN, flagsTD.ToResource, - - // bool flags - "--" + flags.NoPermissionsFN, + cmd := cliTD.SetUpCmdHasFlags( + t, + parent, + addGroupsCommands, + []cliTD.UseCobraCommandFn{ + flags.AddAllProviderFlags, + flags.AddAllStorageFlags, }, - flagsTD.PreparedProviderFlags(), - flagsTD.PreparedStorageFlags()) + flagsTD.WithFlags( + groupsServiceCommand, + []string{ + "--" + flags.RunModeFN, flags.RunModeFlagTest, + "--" + flags.BackupFN, flagsTD.BackupInput, + "--" + flags.LibraryFN, flagsTD.LibraryInput, + "--" + flags.FileFN, flagsTD.FlgInputs(flagsTD.FileNameInput), + "--" + flags.FolderFN, flagsTD.FlgInputs(flagsTD.FolderPathInput), + "--" + flags.FileCreatedAfterFN, flagsTD.FileCreatedAfterInput, + "--" + flags.FileCreatedBeforeFN, flagsTD.FileCreatedBeforeInput, + "--" + flags.FileModifiedAfterFN, flagsTD.FileModifiedAfterInput, + "--" + flags.FileModifiedBeforeFN, flagsTD.FileModifiedBeforeInput, + "--" + flags.ListItemFN, flagsTD.FlgInputs(flagsTD.ListItemInput), + "--" + flags.ListFolderFN, flagsTD.FlgInputs(flagsTD.ListFolderInput), + "--" + flags.PageFN, flagsTD.FlgInputs(flagsTD.PageInput), + "--" + flags.PageFolderFN, flagsTD.FlgInputs(flagsTD.PageFolderInput), + "--" + flags.CollisionsFN, flagsTD.Collisions, + "--" + flags.DestinationFN, flagsTD.Destination, + "--" + flags.ToResourceFN, flagsTD.ToResource, + "--" + flags.NoPermissionsFN, + }, + flagsTD.PreparedProviderFlags(), + flagsTD.PreparedStorageFlags())) - cmd.SetOut(new(bytes.Buffer)) // drop output - cmd.SetErr(new(bytes.Buffer)) // drop output - - err := cmd.Execute() - assert.NoError(t, err, clues.ToCore(err)) + cliTD.CheckCmdChild( + t, + parent, + 3, + test.expectUse, + test.expectShort, + test.expectRunE) opts := utils.MakeGroupsOpts(cmd) - assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) + assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) assert.Equal(t, flagsTD.LibraryInput, opts.Library) assert.ElementsMatch(t, flagsTD.FileNameInput, opts.FileName) assert.ElementsMatch(t, flagsTD.FolderPathInput, opts.FolderPath) @@ -105,14 +89,10 @@ func (suite *GroupsUnitSuite) TestAddGroupsCommands() { assert.Equal(t, flagsTD.FileCreatedBeforeInput, opts.FileCreatedBefore) assert.Equal(t, flagsTD.FileModifiedAfterInput, opts.FileModifiedAfter) assert.Equal(t, flagsTD.FileModifiedBeforeInput, opts.FileModifiedBefore) - assert.Equal(t, flagsTD.Collisions, opts.RestoreCfg.Collisions) assert.Equal(t, flagsTD.Destination, opts.RestoreCfg.Destination) assert.Equal(t, flagsTD.ToResource, opts.RestoreCfg.ProtectedResource) - - // bool flags assert.True(t, flags.NoPermissionsFV) - flagsTD.AssertProviderFlags(t, cmd) flagsTD.AssertStorageFlags(t, cmd) }) diff --git a/src/cli/restore/onedrive_test.go b/src/cli/restore/onedrive_test.go index 5a94705d8..77fb49c65 100644 --- a/src/cli/restore/onedrive_test.go +++ b/src/cli/restore/onedrive_test.go @@ -1,17 +1,15 @@ package restore import ( - "bytes" "testing" - "github.com/alcionai/clues" "github.com/spf13/cobra" "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" "github.com/alcionai/corso/src/cli/flags" flagsTD "github.com/alcionai/corso/src/cli/flags/testdata" + cliTD "github.com/alcionai/corso/src/cli/testdata" "github.com/alcionai/corso/src/cli/utils" "github.com/alcionai/corso/src/internal/tester" ) @@ -39,73 +37,56 @@ func (suite *OneDriveUnitSuite) TestAddOneDriveCommands() { for _, test := range table { suite.Run(test.name, func() { t := suite.T() + parent := &cobra.Command{Use: restoreCommand} - cmd := &cobra.Command{Use: test.use} - - // persistent flags not added by addCommands - flags.AddRunModeFlag(cmd, true) - - c := addOneDriveCommands(cmd) - require.NotNil(t, c) - - // non-persistent flags not added by addCommands - flags.AddAllProviderFlags(c) - flags.AddAllStorageFlags(c) - - cmds := cmd.Commands() - require.Len(t, cmds, 1) - - child := cmds[0] - assert.Equal(t, test.expectUse, child.Use) - assert.Equal(t, test.expectShort, child.Short) - tester.AreSameFunc(t, test.expectRunE, child.RunE) - - flagsTD.WithFlags( - cmd, - oneDriveServiceCommand, - []string{ - "--" + flags.RunModeFN, flags.RunModeFlagTest, - "--" + flags.BackupFN, flagsTD.BackupInput, - "--" + flags.FileFN, flagsTD.FlgInputs(flagsTD.FileNameInput), - "--" + flags.FolderFN, flagsTD.FlgInputs(flagsTD.FolderPathInput), - "--" + flags.FileCreatedAfterFN, flagsTD.FileCreatedAfterInput, - "--" + flags.FileCreatedBeforeFN, flagsTD.FileCreatedBeforeInput, - "--" + flags.FileModifiedAfterFN, flagsTD.FileModifiedAfterInput, - "--" + flags.FileModifiedBeforeFN, flagsTD.FileModifiedBeforeInput, - - "--" + flags.CollisionsFN, flagsTD.Collisions, - "--" + flags.DestinationFN, flagsTD.Destination, - "--" + flags.ToResourceFN, flagsTD.ToResource, - - // bool flags - "--" + flags.NoPermissionsFN, + cmd := cliTD.SetUpCmdHasFlags( + t, + parent, + addOneDriveCommands, + []cliTD.UseCobraCommandFn{ + flags.AddAllProviderFlags, + flags.AddAllStorageFlags, }, - flagsTD.PreparedProviderFlags(), - flagsTD.PreparedStorageFlags()) + flagsTD.WithFlags( + oneDriveServiceCommand, + []string{ + "--" + flags.RunModeFN, flags.RunModeFlagTest, + "--" + flags.BackupFN, flagsTD.BackupInput, + "--" + flags.FileFN, flagsTD.FlgInputs(flagsTD.FileNameInput), + "--" + flags.FolderFN, flagsTD.FlgInputs(flagsTD.FolderPathInput), + "--" + flags.FileCreatedAfterFN, flagsTD.FileCreatedAfterInput, + "--" + flags.FileCreatedBeforeFN, flagsTD.FileCreatedBeforeInput, + "--" + flags.FileModifiedAfterFN, flagsTD.FileModifiedAfterInput, + "--" + flags.FileModifiedBeforeFN, flagsTD.FileModifiedBeforeInput, + "--" + flags.CollisionsFN, flagsTD.Collisions, + "--" + flags.DestinationFN, flagsTD.Destination, + "--" + flags.ToResourceFN, flagsTD.ToResource, + "--" + flags.NoPermissionsFN, + }, + flagsTD.PreparedProviderFlags(), + flagsTD.PreparedStorageFlags())) - cmd.SetOut(new(bytes.Buffer)) // drop output - cmd.SetErr(new(bytes.Buffer)) // drop output - - err := cmd.Execute() - assert.NoError(t, err, clues.ToCore(err)) + cliTD.CheckCmdChild( + t, + parent, + 3, + test.expectUse, + test.expectShort, + test.expectRunE) opts := utils.MakeOneDriveOpts(cmd) - assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) + assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) assert.ElementsMatch(t, flagsTD.FileNameInput, opts.FileName) assert.ElementsMatch(t, flagsTD.FolderPathInput, opts.FolderPath) assert.Equal(t, flagsTD.FileCreatedAfterInput, opts.FileCreatedAfter) assert.Equal(t, flagsTD.FileCreatedBeforeInput, opts.FileCreatedBefore) assert.Equal(t, flagsTD.FileModifiedAfterInput, opts.FileModifiedAfter) assert.Equal(t, flagsTD.FileModifiedBeforeInput, opts.FileModifiedBefore) - assert.Equal(t, flagsTD.Collisions, opts.RestoreCfg.Collisions) assert.Equal(t, flagsTD.Destination, opts.RestoreCfg.Destination) assert.Equal(t, flagsTD.ToResource, opts.RestoreCfg.ProtectedResource) - - // bool flags assert.True(t, flags.NoPermissionsFV) - flagsTD.AssertProviderFlags(t, cmd) flagsTD.AssertStorageFlags(t, cmd) }) diff --git a/src/cli/restore/restore.go b/src/cli/restore/restore.go index 9dad4ca1c..7db7dc5a7 100644 --- a/src/cli/restore/restore.go +++ b/src/cli/restore/restore.go @@ -25,12 +25,12 @@ var restoreCommands = []func(cmd *cobra.Command) *cobra.Command{ // AddCommands attaches all `corso restore * *` commands to the parent. func AddCommands(cmd *cobra.Command) { subCommand := restoreCmd() - flags.AddAllProviderFlags(subCommand) - flags.AddAllStorageFlags(subCommand) cmd.AddCommand(subCommand) for _, addRestoreTo := range restoreCommands { - addRestoreTo(subCommand) + sc := addRestoreTo(subCommand) + flags.AddAllProviderFlags(sc) + flags.AddAllStorageFlags(sc) } } diff --git a/src/cli/restore/sharepoint_test.go b/src/cli/restore/sharepoint_test.go index 638b03bee..ef28f399a 100644 --- a/src/cli/restore/sharepoint_test.go +++ b/src/cli/restore/sharepoint_test.go @@ -1,17 +1,15 @@ package restore import ( - "bytes" "testing" - "github.com/alcionai/clues" "github.com/spf13/cobra" "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" "github.com/alcionai/corso/src/cli/flags" flagsTD "github.com/alcionai/corso/src/cli/flags/testdata" + cliTD "github.com/alcionai/corso/src/cli/testdata" "github.com/alcionai/corso/src/cli/utils" "github.com/alcionai/corso/src/internal/tester" ) @@ -39,64 +37,51 @@ func (suite *SharePointUnitSuite) TestAddSharePointCommands() { for _, test := range table { suite.Run(test.name, func() { t := suite.T() + parent := &cobra.Command{Use: restoreCommand} - cmd := &cobra.Command{Use: test.use} - - // persistent flags not added by addCommands - flags.AddRunModeFlag(cmd, true) - - c := addSharePointCommands(cmd) - require.NotNil(t, c) - - // non-persistent flags not added by addCommands - flags.AddAllProviderFlags(c) - flags.AddAllStorageFlags(c) - - cmds := cmd.Commands() - require.Len(t, cmds, 1) - - child := cmds[0] - assert.Equal(t, test.expectUse, child.Use) - assert.Equal(t, test.expectShort, child.Short) - tester.AreSameFunc(t, test.expectRunE, child.RunE) - - flagsTD.WithFlags( - cmd, - sharePointServiceCommand, - []string{ - "--" + flags.RunModeFN, flags.RunModeFlagTest, - "--" + flags.BackupFN, flagsTD.BackupInput, - "--" + flags.LibraryFN, flagsTD.LibraryInput, - "--" + flags.FileFN, flagsTD.FlgInputs(flagsTD.FileNameInput), - "--" + flags.FolderFN, flagsTD.FlgInputs(flagsTD.FolderPathInput), - "--" + flags.FileCreatedAfterFN, flagsTD.FileCreatedAfterInput, - "--" + flags.FileCreatedBeforeFN, flagsTD.FileCreatedBeforeInput, - "--" + flags.FileModifiedAfterFN, flagsTD.FileModifiedAfterInput, - "--" + flags.FileModifiedBeforeFN, flagsTD.FileModifiedBeforeInput, - "--" + flags.ListItemFN, flagsTD.FlgInputs(flagsTD.ListItemInput), - "--" + flags.ListFolderFN, flagsTD.FlgInputs(flagsTD.ListFolderInput), - "--" + flags.PageFN, flagsTD.FlgInputs(flagsTD.PageInput), - "--" + flags.PageFolderFN, flagsTD.FlgInputs(flagsTD.PageFolderInput), - - "--" + flags.CollisionsFN, flagsTD.Collisions, - "--" + flags.DestinationFN, flagsTD.Destination, - "--" + flags.ToResourceFN, flagsTD.ToResource, - - // bool flags - "--" + flags.NoPermissionsFN, + cmd := cliTD.SetUpCmdHasFlags( + t, + parent, + addSharePointCommands, + []cliTD.UseCobraCommandFn{ + flags.AddAllProviderFlags, + flags.AddAllStorageFlags, }, - flagsTD.PreparedProviderFlags(), - flagsTD.PreparedStorageFlags()) + flagsTD.WithFlags( + sharePointServiceCommand, + []string{ + "--" + flags.RunModeFN, flags.RunModeFlagTest, + "--" + flags.BackupFN, flagsTD.BackupInput, + "--" + flags.LibraryFN, flagsTD.LibraryInput, + "--" + flags.FileFN, flagsTD.FlgInputs(flagsTD.FileNameInput), + "--" + flags.FolderFN, flagsTD.FlgInputs(flagsTD.FolderPathInput), + "--" + flags.FileCreatedAfterFN, flagsTD.FileCreatedAfterInput, + "--" + flags.FileCreatedBeforeFN, flagsTD.FileCreatedBeforeInput, + "--" + flags.FileModifiedAfterFN, flagsTD.FileModifiedAfterInput, + "--" + flags.FileModifiedBeforeFN, flagsTD.FileModifiedBeforeInput, + "--" + flags.ListItemFN, flagsTD.FlgInputs(flagsTD.ListItemInput), + "--" + flags.ListFolderFN, flagsTD.FlgInputs(flagsTD.ListFolderInput), + "--" + flags.PageFN, flagsTD.FlgInputs(flagsTD.PageInput), + "--" + flags.PageFolderFN, flagsTD.FlgInputs(flagsTD.PageFolderInput), + "--" + flags.CollisionsFN, flagsTD.Collisions, + "--" + flags.DestinationFN, flagsTD.Destination, + "--" + flags.ToResourceFN, flagsTD.ToResource, + "--" + flags.NoPermissionsFN, + }, + flagsTD.PreparedProviderFlags(), + flagsTD.PreparedStorageFlags())) - cmd.SetOut(new(bytes.Buffer)) // drop output - cmd.SetErr(new(bytes.Buffer)) // drop output - - err := cmd.Execute() - assert.NoError(t, err, clues.ToCore(err)) + cliTD.CheckCmdChild( + t, + parent, + 3, + test.expectUse, + test.expectShort, + test.expectRunE) opts := utils.MakeSharePointOpts(cmd) - assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) + assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) assert.Equal(t, flagsTD.LibraryInput, opts.Library) assert.ElementsMatch(t, flagsTD.FileNameInput, opts.FileName) assert.ElementsMatch(t, flagsTD.FolderPathInput, opts.FolderPath) @@ -104,20 +89,14 @@ func (suite *SharePointUnitSuite) TestAddSharePointCommands() { assert.Equal(t, flagsTD.FileCreatedBeforeInput, opts.FileCreatedBefore) assert.Equal(t, flagsTD.FileModifiedAfterInput, opts.FileModifiedAfter) assert.Equal(t, flagsTD.FileModifiedBeforeInput, opts.FileModifiedBefore) - assert.ElementsMatch(t, flagsTD.ListItemInput, opts.ListItem) assert.ElementsMatch(t, flagsTD.ListFolderInput, opts.ListFolder) - assert.ElementsMatch(t, flagsTD.PageInput, opts.Page) assert.ElementsMatch(t, flagsTD.PageFolderInput, opts.PageFolder) - assert.Equal(t, flagsTD.Collisions, opts.RestoreCfg.Collisions) assert.Equal(t, flagsTD.Destination, opts.RestoreCfg.Destination) assert.Equal(t, flagsTD.ToResource, opts.RestoreCfg.ProtectedResource) - - // bool flags assert.True(t, flags.NoPermissionsFV) - flagsTD.AssertProviderFlags(t, cmd) flagsTD.AssertStorageFlags(t, cmd) }) diff --git a/src/cli/testdata/cli.go b/src/cli/testdata/cli.go index 1c955165f..16a983360 100644 --- a/src/cli/testdata/cli.go +++ b/src/cli/testdata/cli.go @@ -1,11 +1,20 @@ package testdata import ( + "bytes" "fmt" + "strings" + "testing" "time" + "github.com/alcionai/clues" "github.com/google/uuid" "github.com/spf13/cobra" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + "github.com/alcionai/corso/src/cli/flags" + "github.com/alcionai/corso/src/internal/tester" ) // StubRootCmd builds a stub cobra command to be used as @@ -27,3 +36,82 @@ func StubRootCmd(args ...string) *cobra.Command { return c } + +type UseCobraCommandFn func(*cobra.Command) + +func SetUpCmdHasFlags( + t *testing.T, + parentCmd *cobra.Command, + addChildCommand func(*cobra.Command) *cobra.Command, + addFlags []UseCobraCommandFn, + setArgs UseCobraCommandFn, +) *cobra.Command { + parentCmd.PersistentPreRun = func(c *cobra.Command, args []string) { + t.Log("testing args:") + + for _, arg := range args { + t.Log(arg) + } + } + + // persistent flags not added by addCommands + flags.AddRunModeFlag(parentCmd, true) + + cmd := addChildCommand(parentCmd) + require.NotNil(t, cmd) + + cul := cmd.UseLine() + require.Truef( + t, + strings.HasPrefix(cul, parentCmd.Use+" "+cmd.Use), + "child command has expected usage format 'parent child', got %q", + cul) + + for _, af := range addFlags { + af(cmd) + } + + setArgs(parentCmd) + + parentCmd.SetOut(new(bytes.Buffer)) // drop output + parentCmd.SetErr(new(bytes.Buffer)) // drop output + + err := parentCmd.Execute() + assert.NoError(t, err, clues.ToCore(err)) + + return cmd +} + +type CobraRunEFn func(cmd *cobra.Command, args []string) error + +func CheckCmdChild( + t *testing.T, + cmd *cobra.Command, + expectChildCount int, + expectUse string, + expectShort string, + expectRunE CobraRunEFn, +) { + var ( + cmds = cmd.Commands() + child *cobra.Command + ) + + for _, cc := range cmds { + if cc.Use == expectUse { + child = cc + break + } + } + + require.Len( + t, + cmds, + expectChildCount, + "parent command should have the correct child command count") + + require.NotNil(t, child, "should have found expected child command") + + assert.Equal(t, expectShort, child.Short) + tester.AreSameFunc(t, expectRunE, child.RunE) +}