diff --git a/src/cli/backup/backup.go b/src/cli/backup/backup.go index b0497b844..bf936c5ea 100644 --- a/src/cli/backup/backup.go +++ b/src/cli/backup/backup.go @@ -48,6 +48,8 @@ func AddCommands(cmd *cobra.Command) { for _, sc := range subCommandFuncs { subCommand := sc() + flags.AddAllProviderFlags(subCommand) + flags.AddAllStorageFlags(subCommand) backupC.AddCommand(subCommand) for _, addBackupTo := range serviceCommands { @@ -56,28 +58,6 @@ func AddCommands(cmd *cobra.Command) { } } -// --------------------------------------------------------------------------- -// common flags and flag attachers for commands -// --------------------------------------------------------------------------- - -func addFailedItemsFN(cmd *cobra.Command) { - cmd.Flags().StringVar( - &flags.ListFailedItemsFV, flags.FailedItemsFN, "show", - "Toggles showing or hiding the list of items that failed.") -} - -func addSkippedItemsFN(cmd *cobra.Command) { - cmd.Flags().StringVar( - &flags.ListSkippedItemsFV, flags.SkippedItemsFN, "show", - "Toggles showing or hiding the list of items that were skipped.") -} - -func addRecoveredErrorsFN(cmd *cobra.Command) { - cmd.Flags().StringVar( - &flags.ListRecoveredErrorsFV, flags.RecoveredErrorsFN, "show", - "Toggles showing or hiding the list of errors which corso recovered from.") -} - // --------------------------------------------------------------------------- // commands // --------------------------------------------------------------------------- @@ -279,6 +259,10 @@ func genericDeleteCommand( return nil } + if flags.RunModeFV == flags.RunModeFlagTest { + return nil + } + ctx := clues.Add(cmd.Context(), "delete_backup_id", bID) r, _, _, _, err := utils.GetAccountAndConnectWithOverrides( @@ -310,6 +294,10 @@ func genericListCommand( ) error { ctx := cmd.Context() + if flags.RunModeFV == flags.RunModeFlagTest { + return nil + } + r, _, _, _, err := utils.GetAccountAndConnectWithOverrides( ctx, cmd, diff --git a/src/cli/backup/exchange.go b/src/cli/backup/exchange.go index c01c1e530..4a37c032b 100644 --- a/src/cli/backup/exchange.go +++ b/src/cli/backup/exchange.go @@ -84,9 +84,6 @@ func addExchangeCommands(cmd *cobra.Command) *cobra.Command { // More generic (ex: --user) and more frequently used flags take precedence. flags.AddMailBoxFlag(c) flags.AddDataFlag(c, []string{dataEmail, dataContacts, dataEvents}, false) - flags.AddCorsoPassphaseFlags(c) - flags.AddAWSCredsFlags(c) - flags.AddAzureCredsFlags(c) flags.AddFetchParallelismFlag(c) flags.AddFailFastFlag(c) flags.AddDisableIncrementalsFlag(c) @@ -101,12 +98,7 @@ func addExchangeCommands(cmd *cobra.Command) *cobra.Command { fs.SortFlags = false flags.AddBackupIDFlag(c, false) - flags.AddCorsoPassphaseFlags(c) - flags.AddAWSCredsFlags(c) - flags.AddAzureCredsFlags(c) - addFailedItemsFN(c) - addSkippedItemsFN(c) - addRecoveredErrorsFN(c) + flags.AddAllBackupListFlags(c) case detailsCommand: c, fs = utils.AddCommand(cmd, exchangeDetailsCmd()) @@ -120,9 +112,6 @@ func addExchangeCommands(cmd *cobra.Command) *cobra.Command { // Flags addition ordering should follow the order we want them to appear in help and docs: // More generic (ex: --user) and more frequently used flags take precedence. flags.AddBackupIDFlag(c, true) - flags.AddCorsoPassphaseFlags(c) - flags.AddAWSCredsFlags(c) - flags.AddAzureCredsFlags(c) flags.AddExchangeDetailsAndRestoreFlags(c) case deleteCommand: @@ -133,9 +122,6 @@ func addExchangeCommands(cmd *cobra.Command) *cobra.Command { c.Example = exchangeServiceCommandDeleteExamples flags.AddBackupIDFlag(c, true) - flags.AddCorsoPassphaseFlags(c) - flags.AddAWSCredsFlags(c) - flags.AddAzureCredsFlags(c) } return c @@ -163,6 +149,10 @@ func createExchangeCmd(cmd *cobra.Command, args []string) error { return nil } + if flags.RunModeFV == flags.RunModeFlagTest { + return nil + } + if err := validateExchangeBackupCreateFlags(flags.UserFV, flags.CategoryDataFV); err != nil { return err } @@ -276,6 +266,10 @@ func detailsExchangeCmd(cmd *cobra.Command, args []string) error { return nil } + if flags.RunModeFV == flags.RunModeFlagTest { + return nil + } + ctx := cmd.Context() opts := utils.MakeExchangeOpts(cmd) diff --git a/src/cli/backup/exchange_test.go b/src/cli/backup/exchange_test.go index d260ca290..b04f27f07 100644 --- a/src/cli/backup/exchange_test.go +++ b/src/cli/backup/exchange_test.go @@ -1,7 +1,9 @@ package backup import ( + "bytes" "fmt" + "strconv" "testing" "github.com/alcionai/clues" @@ -11,10 +13,13 @@ import ( "github.com/stretchr/testify/suite" "github.com/alcionai/corso/src/cli/flags" - "github.com/alcionai/corso/src/cli/utils/testdata" + flagsTD "github.com/alcionai/corso/src/cli/flags/testdata" + "github.com/alcionai/corso/src/cli/utils" + utilsTD "github.com/alcionai/corso/src/cli/utils/testdata" "github.com/alcionai/corso/src/internal/tester" "github.com/alcionai/corso/src/internal/version" dtd "github.com/alcionai/corso/src/pkg/backup/details/testdata" + "github.com/alcionai/corso/src/pkg/control" ) type ExchangeUnitSuite struct { @@ -33,7 +38,6 @@ func (suite *ExchangeUnitSuite) TestAddExchangeCommands() { use string expectUse string expectShort string - flags []string expectRunE func(*cobra.Command, []string) error }{ { @@ -41,65 +45,28 @@ func (suite *ExchangeUnitSuite) TestAddExchangeCommands() { use: createCommand, expectUse: expectUse + " " + exchangeServiceCommandCreateUseSuffix, expectShort: exchangeCreateCmd().Short, - flags: []string{ - flags.UserFN, - flags.CategoryDataFN, - flags.DisableIncrementalsFN, - flags.DisableDeltaFN, - flags.FailFastFN, - flags.FetchParallelismFN, - flags.SkipReduceFN, - flags.NoStatsFN, - flags.DeltaPageSizeFN, - }, - expectRunE: createExchangeCmd, + expectRunE: createExchangeCmd, }, { name: "list exchange", use: listCommand, expectUse: expectUse, expectShort: exchangeListCmd().Short, - flags: []string{ - flags.BackupFN, - flags.FailedItemsFN, - flags.SkippedItemsFN, - flags.RecoveredErrorsFN, - }, - expectRunE: listExchangeCmd, + expectRunE: listExchangeCmd, }, { name: "details exchange", use: detailsCommand, expectUse: expectUse + " " + exchangeServiceCommandDetailsUseSuffix, expectShort: exchangeDetailsCmd().Short, - flags: []string{ - flags.BackupFN, - flags.ContactFN, - flags.ContactFolderFN, - flags.ContactNameFN, - flags.EmailFN, - flags.EmailFolderFN, - flags.EmailReceivedAfterFN, - flags.EmailReceivedBeforeFN, - flags.EmailSenderFN, - flags.EmailSubjectFN, - flags.EventFN, - flags.EventCalendarFN, - flags.EventOrganizerFN, - flags.EventRecursFN, - flags.EventStartsAfterFN, - flags.EventStartsBeforeFN, - flags.EventSubjectFN, - }, - expectRunE: detailsExchangeCmd, + expectRunE: detailsExchangeCmd, }, { - "delete exchange", - deleteCommand, - expectUse + " " + exchangeServiceCommandDeleteUseSuffix, - exchangeDeleteCmd().Short, - []string{flags.BackupFN}, - deleteExchangeCmd, + name: "delete exchange", + use: deleteCommand, + expectUse: expectUse + " " + exchangeServiceCommandDeleteUseSuffix, + expectShort: exchangeDeleteCmd().Short, + expectRunE: deleteExchangeCmd, }, } for _, test := range table { @@ -122,6 +89,200 @@ 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, + }, + flagsTD.PreparedProviderFlags(), + flagsTD.PreparedStorageFlags()) + + // 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)) + + 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) +} + +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, + }, + 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)) + + assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) + + flagsTD.AssertBackupListFlags(t, cmd) + flagsTD.AssertProviderFlags(t, cmd) + flagsTD.AssertStorageFlags(t, cmd) +} + +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, + }, + 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)) + + co := utils.Control() + + assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) + + assert.True(t, co.SkipReduce) + + flagsTD.AssertProviderFlags(t, cmd) + flagsTD.AssertStorageFlags(t, cmd) +} + +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, + }, + 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)) + + assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) + + flagsTD.AssertProviderFlags(t, cmd) + flagsTD.AssertStorageFlags(t, cmd) +} + func (suite *ExchangeUnitSuite) TestValidateBackupCreateFlags() { table := []struct { name string @@ -277,14 +438,14 @@ func (suite *ExchangeUnitSuite) TestExchangeBackupCreateSelectors() { func (suite *ExchangeUnitSuite) TestExchangeBackupDetailsSelectors() { for v := 0; v <= version.Backup; v++ { suite.Run(fmt.Sprintf("version%d", v), func() { - for _, test := range testdata.ExchangeOptionDetailLookups { + for _, test := range utilsTD.ExchangeOptionDetailLookups { suite.Run(test.Name, func() { t := suite.T() ctx, flush := tester.NewContext(t) defer flush() - bg := testdata.VersionedBackupGetter{ + bg := utilsTD.VersionedBackupGetter{ Details: dtd.GetDetailsSetForVersion(t, v), } @@ -303,7 +464,7 @@ func (suite *ExchangeUnitSuite) TestExchangeBackupDetailsSelectors() { } func (suite *ExchangeUnitSuite) TestExchangeBackupDetailsSelectorsBadFormats() { - for _, test := range testdata.BadExchangeOptionsFormats { + for _, test := range utilsTD.BadExchangeOptionsFormats { suite.Run(test.Name, func() { t := suite.T() diff --git a/src/cli/backup/groups.go b/src/cli/backup/groups.go index faffe76e1..7e3e041db 100644 --- a/src/cli/backup/groups.go +++ b/src/cli/backup/groups.go @@ -75,11 +75,9 @@ func addGroupsCommands(cmd *cobra.Command) *cobra.Command { // Flags addition ordering should follow the order we want them to appear in help and docs: flags.AddGroupFlag(c) flags.AddDataFlag(c, []string{flags.DataLibraries, flags.DataMessages}, false) - flags.AddCorsoPassphaseFlags(c) - flags.AddAWSCredsFlags(c) - flags.AddAzureCredsFlags(c) flags.AddFetchParallelismFlag(c) flags.AddFailFastFlag(c) + flags.AddDisableDeltaFlag(c) flags.AddDisableIncrementalsFlag(c) flags.AddForceItemDataDownloadFlag(c) @@ -88,12 +86,7 @@ func addGroupsCommands(cmd *cobra.Command) *cobra.Command { fs.SortFlags = false flags.AddBackupIDFlag(c, false) - flags.AddCorsoPassphaseFlags(c) - flags.AddAWSCredsFlags(c) - flags.AddAzureCredsFlags(c) - addFailedItemsFN(c) - addSkippedItemsFN(c) - addRecoveredErrorsFN(c) + flags.AddAllBackupListFlags(c) case detailsCommand: c, fs = utils.AddCommand(cmd, groupsDetailsCmd(), utils.MarkPreviewCommand()) @@ -108,9 +101,6 @@ func addGroupsCommands(cmd *cobra.Command) *cobra.Command { // More generic (ex: --user) and more frequently used flags take precedence. flags.AddBackupIDFlag(c, true) flags.AddGroupDetailsAndRestoreFlags(c) - flags.AddCorsoPassphaseFlags(c) - flags.AddAWSCredsFlags(c) - flags.AddAzureCredsFlags(c) flags.AddSharePointDetailsAndRestoreFlags(c) case deleteCommand: @@ -121,9 +111,6 @@ func addGroupsCommands(cmd *cobra.Command) *cobra.Command { c.Example = groupsServiceCommandDeleteExamples flags.AddBackupIDFlag(c, true) - flags.AddCorsoPassphaseFlags(c) - flags.AddAWSCredsFlags(c) - flags.AddAzureCredsFlags(c) } return c @@ -152,6 +139,10 @@ func createGroupsCmd(cmd *cobra.Command, args []string) error { return nil } + if flags.RunModeFV == flags.RunModeFlagTest { + return nil + } + if err := validateGroupsBackupCreateFlags(flags.GroupFV, flags.CategoryDataFV); err != nil { return err } @@ -228,6 +219,10 @@ func detailsGroupsCmd(cmd *cobra.Command, args []string) error { return nil } + if flags.RunModeFV == flags.RunModeFlagTest { + return nil + } + ctx := cmd.Context() opts := utils.MakeGroupsOpts(cmd) diff --git a/src/cli/backup/groups_test.go b/src/cli/backup/groups_test.go index be4a7f217..8829915c4 100644 --- a/src/cli/backup/groups_test.go +++ b/src/cli/backup/groups_test.go @@ -1,6 +1,8 @@ package backup import ( + "bytes" + "strconv" "testing" "github.com/alcionai/clues" @@ -10,7 +12,10 @@ import ( "github.com/stretchr/testify/suite" "github.com/alcionai/corso/src/cli/flags" + flagsTD "github.com/alcionai/corso/src/cli/flags/testdata" + "github.com/alcionai/corso/src/cli/utils" "github.com/alcionai/corso/src/internal/tester" + "github.com/alcionai/corso/src/pkg/control" ) type GroupsUnitSuite struct { @@ -29,62 +34,35 @@ func (suite *GroupsUnitSuite) TestAddGroupsCommands() { use string expectUse string expectShort string - flags []string expectRunE func(*cobra.Command, []string) error }{ { - "create groups", - createCommand, - expectUse + " " + groupsServiceCommandCreateUseSuffix, - groupsCreateCmd().Short, - []string{ - flags.CategoryDataFN, - flags.FailFastFN, - flags.FetchParallelismFN, - flags.SkipReduceFN, - flags.NoStatsFN, - flags.DisableIncrementalsFN, - flags.ForceItemDataDownloadFN, - }, - createGroupsCmd, + name: "create groups", + use: createCommand, + expectUse: expectUse + " " + groupsServiceCommandCreateUseSuffix, + expectShort: groupsCreateCmd().Short, + expectRunE: createGroupsCmd, }, { - "list groups", - listCommand, - expectUse, - groupsListCmd().Short, - []string{ - flags.BackupFN, - flags.FailedItemsFN, - flags.SkippedItemsFN, - flags.RecoveredErrorsFN, - }, - listGroupsCmd, + name: "list groups", + use: listCommand, + expectUse: expectUse, + expectShort: groupsListCmd().Short, + expectRunE: listGroupsCmd, }, { - "details groups", - detailsCommand, - expectUse + " " + groupsServiceCommandDetailsUseSuffix, - groupsDetailsCmd().Short, - []string{ - flags.BackupFN, - flags.LibraryFN, - flags.FolderFN, - flags.FileFN, - flags.FileCreatedAfterFN, - flags.FileCreatedBeforeFN, - flags.FileModifiedAfterFN, - flags.FileModifiedBeforeFN, - }, - detailsGroupsCmd, + name: "details groups", + use: detailsCommand, + expectUse: expectUse + " " + groupsServiceCommandDetailsUseSuffix, + expectShort: groupsDetailsCmd().Short, + expectRunE: detailsGroupsCmd, }, { - "delete groups", - deleteCommand, - expectUse + " " + groupsServiceCommandDeleteUseSuffix, - groupsDeleteCmd().Short, - []string{flags.BackupFN}, - deleteGroupsCmd, + name: "delete groups", + use: deleteCommand, + expectUse: expectUse + " " + groupsServiceCommandDeleteUseSuffix, + expectShort: groupsDeleteCmd().Short, + expectRunE: deleteGroupsCmd, }, } for _, test := range table { @@ -146,3 +124,204 @@ 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, + }, + 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)) + + 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) +} + +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, + }, + 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)) + + assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) + + flagsTD.AssertBackupListFlags(t, cmd) + flagsTD.AssertProviderFlags(t, cmd) + flagsTD.AssertStorageFlags(t, cmd) +} + +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, + }, + 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)) + + co := utils.Control() + + assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) + + assert.True(t, co.SkipReduce) + + flagsTD.AssertProviderFlags(t, cmd) + flagsTD.AssertStorageFlags(t, cmd) +} + +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, + }, + 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)) + + assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) + + flagsTD.AssertProviderFlags(t, cmd) + flagsTD.AssertStorageFlags(t, cmd) +} diff --git a/src/cli/backup/onedrive.go b/src/cli/backup/onedrive.go index c1fb87291..c870f84ee 100644 --- a/src/cli/backup/onedrive.go +++ b/src/cli/backup/onedrive.go @@ -71,10 +71,6 @@ func addOneDriveCommands(cmd *cobra.Command) *cobra.Command { c.Example = oneDriveServiceCommandCreateExamples flags.AddUserFlag(c) - flags.AddCorsoPassphaseFlags(c) - flags.AddAWSCredsFlags(c) - flags.AddAzureCredsFlags(c) - flags.AddFailFastFlag(c) flags.AddDisableIncrementalsFlag(c) flags.AddForceItemDataDownloadFlag(c) @@ -84,12 +80,7 @@ func addOneDriveCommands(cmd *cobra.Command) *cobra.Command { fs.SortFlags = false flags.AddBackupIDFlag(c, false) - flags.AddCorsoPassphaseFlags(c) - flags.AddAWSCredsFlags(c) - flags.AddAzureCredsFlags(c) - addFailedItemsFN(c) - addSkippedItemsFN(c) - addRecoveredErrorsFN(c) + flags.AddAllBackupListFlags(c) case detailsCommand: c, fs = utils.AddCommand(cmd, oneDriveDetailsCmd()) @@ -100,9 +91,6 @@ func addOneDriveCommands(cmd *cobra.Command) *cobra.Command { flags.AddSkipReduceFlag(c) flags.AddBackupIDFlag(c, true) - flags.AddCorsoPassphaseFlags(c) - flags.AddAWSCredsFlags(c) - flags.AddAzureCredsFlags(c) flags.AddOneDriveDetailsAndRestoreFlags(c) case deleteCommand: @@ -113,9 +101,6 @@ func addOneDriveCommands(cmd *cobra.Command) *cobra.Command { c.Example = oneDriveServiceCommandDeleteExamples flags.AddBackupIDFlag(c, true) - flags.AddCorsoPassphaseFlags(c) - flags.AddAWSCredsFlags(c) - flags.AddAzureCredsFlags(c) } return c @@ -144,6 +129,10 @@ func createOneDriveCmd(cmd *cobra.Command, args []string) error { return nil } + if flags.RunModeFV == flags.RunModeFlagTest { + return nil + } + if err := validateOneDriveBackupCreateFlags(flags.UserFV); err != nil { return err } @@ -234,6 +223,10 @@ func detailsOneDriveCmd(cmd *cobra.Command, args []string) error { return nil } + if flags.RunModeFV == flags.RunModeFlagTest { + return nil + } + ctx := cmd.Context() opts := utils.MakeOneDriveOpts(cmd) diff --git a/src/cli/backup/onedrive_test.go b/src/cli/backup/onedrive_test.go index 3ac476aa7..340f598dc 100644 --- a/src/cli/backup/onedrive_test.go +++ b/src/cli/backup/onedrive_test.go @@ -1,6 +1,7 @@ package backup import ( + "bytes" "fmt" "testing" @@ -11,10 +12,13 @@ import ( "github.com/stretchr/testify/suite" "github.com/alcionai/corso/src/cli/flags" - "github.com/alcionai/corso/src/cli/utils/testdata" + flagsTD "github.com/alcionai/corso/src/cli/flags/testdata" + "github.com/alcionai/corso/src/cli/utils" + utilsTD "github.com/alcionai/corso/src/cli/utils/testdata" "github.com/alcionai/corso/src/internal/tester" "github.com/alcionai/corso/src/internal/version" dtd "github.com/alcionai/corso/src/pkg/backup/details/testdata" + "github.com/alcionai/corso/src/pkg/control" ) type OneDriveUnitSuite struct { @@ -33,57 +37,35 @@ func (suite *OneDriveUnitSuite) TestAddOneDriveCommands() { use string expectUse string expectShort string - flags []string expectRunE func(*cobra.Command, []string) error }{ { - "create onedrive", - createCommand, - expectUse + " " + oneDriveServiceCommandCreateUseSuffix, - oneDriveCreateCmd().Short, - []string{ - flags.UserFN, - flags.DisableIncrementalsFN, - flags.FailFastFN, - }, - createOneDriveCmd, + name: "create onedrive", + use: createCommand, + expectUse: expectUse + " " + oneDriveServiceCommandCreateUseSuffix, + expectShort: oneDriveCreateCmd().Short, + expectRunE: createOneDriveCmd, }, { - "list onedrive", - listCommand, - expectUse, - oneDriveListCmd().Short, - []string{ - flags.BackupFN, - flags.FailedItemsFN, - flags.SkippedItemsFN, - flags.RecoveredErrorsFN, - }, - listOneDriveCmd, + name: "list onedrive", + use: listCommand, + expectUse: expectUse, + expectShort: oneDriveListCmd().Short, + expectRunE: listOneDriveCmd, }, { - "details onedrive", - detailsCommand, - expectUse + " " + oneDriveServiceCommandDetailsUseSuffix, - oneDriveDetailsCmd().Short, - []string{ - flags.BackupFN, - flags.FolderFN, - flags.FileFN, - flags.FileCreatedAfterFN, - flags.FileCreatedBeforeFN, - flags.FileModifiedAfterFN, - flags.FileModifiedBeforeFN, - }, - detailsOneDriveCmd, + name: "details onedrive", + use: detailsCommand, + expectUse: expectUse + " " + oneDriveServiceCommandDetailsUseSuffix, + expectShort: oneDriveDetailsCmd().Short, + expectRunE: detailsOneDriveCmd, }, { - "delete onedrive", - deleteCommand, - expectUse + " " + oneDriveServiceCommandDeleteUseSuffix, - oneDriveDeleteCmd().Short, - []string{flags.BackupFN}, - deleteOneDriveCmd, + name: "delete onedrive", + use: deleteCommand, + expectUse: expectUse + " " + oneDriveServiceCommandDeleteUseSuffix, + expectShort: oneDriveDeleteCmd().Short, + expectRunE: deleteOneDriveCmd, }, } @@ -103,14 +85,177 @@ func (suite *OneDriveUnitSuite) TestAddOneDriveCommands() { assert.Equal(t, test.expectUse, child.Use) assert.Equal(t, test.expectShort, child.Short) tester.AreSameFunc(t, test.expectRunE, child.RunE) - - for _, f := range test.flags { - assert.NotNil(t, c.Flag(f), f+" flag") - } }) } } +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, + }, + 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)) + + 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) +} + +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, + }, + 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)) + + assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) + + flagsTD.AssertBackupListFlags(t, cmd) + flagsTD.AssertProviderFlags(t, cmd) + flagsTD.AssertStorageFlags(t, cmd) +} + +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, + }, + 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)) + + co := utils.Control() + + assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) + + assert.True(t, co.SkipReduce) + + flagsTD.AssertProviderFlags(t, cmd) + flagsTD.AssertStorageFlags(t, cmd) +} + +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, + }, + 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)) + + assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) + + flagsTD.AssertProviderFlags(t, cmd) + flagsTD.AssertStorageFlags(t, cmd) +} + func (suite *OneDriveUnitSuite) TestValidateOneDriveBackupCreateFlags() { table := []struct { name string @@ -138,14 +283,14 @@ func (suite *OneDriveUnitSuite) TestValidateOneDriveBackupCreateFlags() { func (suite *OneDriveUnitSuite) TestOneDriveBackupDetailsSelectors() { for v := 0; v <= version.Backup; v++ { suite.Run(fmt.Sprintf("version%d", v), func() { - for _, test := range testdata.OneDriveOptionDetailLookups { + for _, test := range utilsTD.OneDriveOptionDetailLookups { suite.Run(test.Name, func() { t := suite.T() ctx, flush := tester.NewContext(t) defer flush() - bg := testdata.VersionedBackupGetter{ + bg := utilsTD.VersionedBackupGetter{ Details: dtd.GetDetailsSetForVersion(t, v), } @@ -164,7 +309,7 @@ func (suite *OneDriveUnitSuite) TestOneDriveBackupDetailsSelectors() { } func (suite *OneDriveUnitSuite) TestOneDriveBackupDetailsSelectorsBadFormats() { - for _, test := range testdata.BadOneDriveOptionsFormats { + for _, test := range utilsTD.BadOneDriveOptionsFormats { suite.Run(test.Name, func() { t := suite.T() diff --git a/src/cli/backup/sharepoint.go b/src/cli/backup/sharepoint.go index 8f79ed6be..2b154573e 100644 --- a/src/cli/backup/sharepoint.go +++ b/src/cli/backup/sharepoint.go @@ -81,9 +81,6 @@ func addSharePointCommands(cmd *cobra.Command) *cobra.Command { flags.AddSiteFlag(c) flags.AddSiteIDFlag(c) - flags.AddCorsoPassphaseFlags(c) - flags.AddAWSCredsFlags(c) - flags.AddAzureCredsFlags(c) flags.AddDataFlag(c, []string{flags.DataLibraries}, true) flags.AddFailFastFlag(c) flags.AddDisableIncrementalsFlag(c) @@ -94,12 +91,7 @@ func addSharePointCommands(cmd *cobra.Command) *cobra.Command { fs.SortFlags = false flags.AddBackupIDFlag(c, false) - flags.AddCorsoPassphaseFlags(c) - flags.AddAWSCredsFlags(c) - flags.AddAzureCredsFlags(c) - addFailedItemsFN(c) - addSkippedItemsFN(c) - addRecoveredErrorsFN(c) + flags.AddAllBackupListFlags(c) case detailsCommand: c, fs = utils.AddCommand(cmd, sharePointDetailsCmd()) @@ -110,9 +102,6 @@ func addSharePointCommands(cmd *cobra.Command) *cobra.Command { flags.AddSkipReduceFlag(c) flags.AddBackupIDFlag(c, true) - flags.AddCorsoPassphaseFlags(c) - flags.AddAWSCredsFlags(c) - flags.AddAzureCredsFlags(c) flags.AddSharePointDetailsAndRestoreFlags(c) case deleteCommand: @@ -123,9 +112,6 @@ func addSharePointCommands(cmd *cobra.Command) *cobra.Command { c.Example = sharePointServiceCommandDeleteExamples flags.AddBackupIDFlag(c, true) - flags.AddCorsoPassphaseFlags(c) - flags.AddAWSCredsFlags(c) - flags.AddAzureCredsFlags(c) } return c @@ -154,6 +140,10 @@ func createSharePointCmd(cmd *cobra.Command, args []string) error { return nil } + if flags.RunModeFV == flags.RunModeFlagTest { + return nil + } + if err := validateSharePointBackupCreateFlags(flags.SiteIDFV, flags.WebURLFV, flags.CategoryDataFV); err != nil { return err } @@ -318,6 +308,10 @@ func detailsSharePointCmd(cmd *cobra.Command, args []string) error { return nil } + if flags.RunModeFV == flags.RunModeFlagTest { + return nil + } + ctx := cmd.Context() opts := utils.MakeSharePointOpts(cmd) diff --git a/src/cli/backup/sharepoint_test.go b/src/cli/backup/sharepoint_test.go index 0a4956583..fd724d83b 100644 --- a/src/cli/backup/sharepoint_test.go +++ b/src/cli/backup/sharepoint_test.go @@ -1,7 +1,9 @@ package backup import ( + "bytes" "fmt" + "strings" "testing" "github.com/alcionai/clues" @@ -11,11 +13,14 @@ import ( "github.com/stretchr/testify/suite" "github.com/alcionai/corso/src/cli/flags" - "github.com/alcionai/corso/src/cli/utils/testdata" + flagsTD "github.com/alcionai/corso/src/cli/flags/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" "github.com/alcionai/corso/src/internal/tester" "github.com/alcionai/corso/src/internal/version" dtd "github.com/alcionai/corso/src/pkg/backup/details/testdata" + "github.com/alcionai/corso/src/pkg/control" "github.com/alcionai/corso/src/pkg/selectors" ) @@ -35,58 +40,35 @@ func (suite *SharePointUnitSuite) TestAddSharePointCommands() { use string expectUse string expectShort string - flags []string expectRunE func(*cobra.Command, []string) error }{ { - "create sharepoint", - createCommand, - expectUse + " " + sharePointServiceCommandCreateUseSuffix, - sharePointCreateCmd().Short, - []string{ - flags.SiteFN, - flags.DisableIncrementalsFN, - flags.FailFastFN, - }, - createSharePointCmd, + name: "create sharepoint", + use: createCommand, + expectUse: expectUse + " " + sharePointServiceCommandCreateUseSuffix, + expectShort: sharePointCreateCmd().Short, + expectRunE: createSharePointCmd, }, { - "list sharepoint", - listCommand, - expectUse, - sharePointListCmd().Short, - []string{ - flags.BackupFN, - flags.FailedItemsFN, - flags.SkippedItemsFN, - flags.RecoveredErrorsFN, - }, - listSharePointCmd, + name: "list sharepoint", + use: listCommand, + expectUse: expectUse, + expectShort: sharePointListCmd().Short, + expectRunE: listSharePointCmd, }, { - "details sharepoint", - detailsCommand, - expectUse + " " + sharePointServiceCommandDetailsUseSuffix, - sharePointDetailsCmd().Short, - []string{ - flags.BackupFN, - flags.LibraryFN, - flags.FolderFN, - flags.FileFN, - flags.FileCreatedAfterFN, - flags.FileCreatedBeforeFN, - flags.FileModifiedAfterFN, - flags.FileModifiedBeforeFN, - }, - detailsSharePointCmd, + name: "details sharepoint", + use: detailsCommand, + expectUse: expectUse + " " + sharePointServiceCommandDetailsUseSuffix, + expectShort: sharePointDetailsCmd().Short, + expectRunE: detailsSharePointCmd, }, { - "delete sharepoint", - deleteCommand, - expectUse + " " + sharePointServiceCommandDeleteUseSuffix, - sharePointDeleteCmd().Short, - []string{flags.BackupFN}, - deleteSharePointCmd, + name: "delete sharepoint", + use: deleteCommand, + expectUse: expectUse + " " + sharePointServiceCommandDeleteUseSuffix, + expectShort: sharePointDeleteCmd().Short, + expectRunE: deleteSharePointCmd, }, } for _, test := range table { @@ -105,14 +87,180 @@ func (suite *SharePointUnitSuite) TestAddSharePointCommands() { assert.Equal(t, test.expectUse, child.Use) assert.Equal(t, test.expectShort, child.Short) tester.AreSameFunc(t, test.expectRunE, child.RunE) - - for _, f := range test.flags { - assert.NotNil(t, c.Flag(f), f+" flag") - } }) } } +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, + }, + 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)) + + 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) +} + +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, + }, + 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)) + + assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) + + flagsTD.AssertBackupListFlags(t, cmd) + flagsTD.AssertProviderFlags(t, cmd) + flagsTD.AssertStorageFlags(t, cmd) +} + +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, + }, + 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)) + + co := utils.Control() + + assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) + + assert.True(t, co.SkipReduce) + + flagsTD.AssertProviderFlags(t, cmd) + flagsTD.AssertStorageFlags(t, cmd) +} + +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, + }, + 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)) + + assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) + + flagsTD.AssertProviderFlags(t, cmd) + flagsTD.AssertStorageFlags(t, cmd) +} + func (suite *SharePointUnitSuite) TestValidateSharePointBackupCreateFlags() { table := []struct { name string @@ -247,14 +395,14 @@ func (suite *SharePointUnitSuite) TestSharePointBackupCreateSelectors() { func (suite *SharePointUnitSuite) TestSharePointBackupDetailsSelectors() { for v := 0; v <= version.Backup; v++ { suite.Run(fmt.Sprintf("version%d", v), func() { - for _, test := range testdata.SharePointOptionDetailLookups { + for _, test := range utilsTD.SharePointOptionDetailLookups { suite.Run(test.Name, func() { t := suite.T() ctx, flush := tester.NewContext(t) defer flush() - bg := testdata.VersionedBackupGetter{ + bg := utilsTD.VersionedBackupGetter{ Details: dtd.GetDetailsSetForVersion(t, v), } @@ -273,7 +421,7 @@ func (suite *SharePointUnitSuite) TestSharePointBackupDetailsSelectors() { } func (suite *SharePointUnitSuite) TestSharePointBackupDetailsSelectorsBadFormats() { - for _, test := range testdata.BadSharePointOptionsFormats { + for _, test := range utilsTD.BadSharePointOptionsFormats { suite.Run(test.Name, func() { t := suite.T() diff --git a/src/cli/export/export.go b/src/cli/export/export.go index 0a1463d2b..f106f87bc 100644 --- a/src/cli/export/export.go +++ b/src/cli/export/export.go @@ -7,6 +7,7 @@ import ( "github.com/alcionai/clues" "github.com/spf13/cobra" + "github.com/alcionai/corso/src/cli/flags" . "github.com/alcionai/corso/src/cli/print" "github.com/alcionai/corso/src/cli/utils" "github.com/alcionai/corso/src/internal/common/dttm" @@ -25,11 +26,12 @@ var exportCommands = []func(cmd *cobra.Command) *cobra.Command{ // AddCommands attaches all `corso export * *` commands to the parent. func AddCommands(cmd *cobra.Command) { - exportC := exportCmd() - cmd.AddCommand(exportC) + subCommand := exportCmd() + flags.AddAllStorageFlags(subCommand) + cmd.AddCommand(subCommand) for _, addExportTo := range exportCommands { - addExportTo(exportC) + addExportTo(subCommand) } } diff --git a/src/cli/export/groups.go b/src/cli/export/groups.go index 30e85fdaf..54add842c 100644 --- a/src/cli/export/groups.go +++ b/src/cli/export/groups.go @@ -30,8 +30,6 @@ func addGroupsCommands(cmd *cobra.Command) *cobra.Command { flags.AddGroupDetailsAndRestoreFlags(c) flags.AddExportConfigFlags(c) flags.AddFailFastFlag(c) - flags.AddCorsoPassphaseFlags(c) - flags.AddAWSCredsFlags(c) } return c diff --git a/src/cli/export/groups_test.go b/src/cli/export/groups_test.go index 3f664db08..0f53bb6f8 100644 --- a/src/cli/export/groups_test.go +++ b/src/cli/export/groups_test.go @@ -11,8 +11,8 @@ import ( "github.com/stretchr/testify/suite" "github.com/alcionai/corso/src/cli/flags" + flagsTD "github.com/alcionai/corso/src/cli/flags/testdata" "github.com/alcionai/corso/src/cli/utils" - "github.com/alcionai/corso/src/cli/utils/testdata" "github.com/alcionai/corso/src/internal/tester" ) @@ -42,13 +42,16 @@ func (suite *GroupsUnitSuite) TestAddGroupsCommands() { cmd := &cobra.Command{Use: test.use} - // normally a persistent flag from the root. - // required to ensure a dry run. + // 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) @@ -57,40 +60,35 @@ func (suite *GroupsUnitSuite) TestAddGroupsCommands() { assert.Equal(t, test.expectShort, child.Short) tester.AreSameFunc(t, test.expectRunE, child.RunE) - cmd.SetArgs([]string{ - "groups", - testdata.RestoreDestination, - "--" + flags.RunModeFN, flags.RunModeFlagTest, - "--" + flags.BackupFN, testdata.BackupInput, + flagsTD.WithFlags( + cmd, + groupsServiceCommand, + []string{ + flagsTD.RestoreDestination, + "--" + flags.RunModeFN, flags.RunModeFlagTest, + "--" + flags.BackupFN, flagsTD.BackupInput, - "--" + flags.AWSAccessKeyFN, testdata.AWSAccessKeyID, - "--" + flags.AWSSecretAccessKeyFN, testdata.AWSSecretAccessKey, - "--" + flags.AWSSessionTokenFN, testdata.AWSSessionToken, + "--" + flags.FormatFN, flagsTD.FormatType, - "--" + flags.CorsoPassphraseFN, testdata.CorsoPassphrase, - - "--" + flags.FormatFN, testdata.FormatType, - - // bool flags - "--" + flags.ArchiveFN, - }) + // bool flags + "--" + 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)) opts := utils.MakeGroupsOpts(cmd) - assert.Equal(t, testdata.BackupInput, flags.BackupIDFV) + assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) - assert.Equal(t, testdata.Archive, opts.ExportCfg.Archive) - assert.Equal(t, testdata.FormatType, opts.ExportCfg.Format) + assert.Equal(t, flagsTD.Archive, opts.ExportCfg.Archive) + assert.Equal(t, flagsTD.FormatType, opts.ExportCfg.Format) - assert.Equal(t, testdata.AWSAccessKeyID, flags.AWSAccessKeyFV) - assert.Equal(t, testdata.AWSSecretAccessKey, flags.AWSSecretAccessKeyFV) - assert.Equal(t, testdata.AWSSessionToken, flags.AWSSessionTokenFV) - - assert.Equal(t, testdata.CorsoPassphrase, flags.CorsoPassphraseFV) + flagsTD.AssertStorageFlags(t, cmd) }) } } diff --git a/src/cli/export/onedrive.go b/src/cli/export/onedrive.go index 3ebf5bdbf..cc22ed4ce 100644 --- a/src/cli/export/onedrive.go +++ b/src/cli/export/onedrive.go @@ -30,8 +30,6 @@ func addOneDriveCommands(cmd *cobra.Command) *cobra.Command { flags.AddOneDriveDetailsAndRestoreFlags(c) flags.AddExportConfigFlags(c) flags.AddFailFastFlag(c) - flags.AddCorsoPassphaseFlags(c) - flags.AddAWSCredsFlags(c) } return c diff --git a/src/cli/export/onedrive_test.go b/src/cli/export/onedrive_test.go index 6ba079f4a..2049234ae 100644 --- a/src/cli/export/onedrive_test.go +++ b/src/cli/export/onedrive_test.go @@ -11,8 +11,8 @@ import ( "github.com/stretchr/testify/suite" "github.com/alcionai/corso/src/cli/flags" + flagsTD "github.com/alcionai/corso/src/cli/flags/testdata" "github.com/alcionai/corso/src/cli/utils" - "github.com/alcionai/corso/src/cli/utils/testdata" "github.com/alcionai/corso/src/internal/tester" ) @@ -42,13 +42,16 @@ func (suite *OneDriveUnitSuite) TestAddOneDriveCommands() { cmd := &cobra.Command{Use: test.use} - // normally a persistent flag from the root. - // required to ensure a dry run. + // 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) @@ -57,53 +60,47 @@ func (suite *OneDriveUnitSuite) TestAddOneDriveCommands() { assert.Equal(t, test.expectShort, child.Short) tester.AreSameFunc(t, test.expectRunE, child.RunE) - cmd.SetArgs([]string{ - "onedrive", - testdata.RestoreDestination, - "--" + flags.RunModeFN, flags.RunModeFlagTest, - "--" + flags.BackupFN, testdata.BackupInput, - "--" + flags.FileFN, testdata.FlgInputs(testdata.FileNameInput), - "--" + flags.FolderFN, testdata.FlgInputs(testdata.FolderPathInput), - "--" + flags.FileCreatedAfterFN, testdata.FileCreatedAfterInput, - "--" + flags.FileCreatedBeforeFN, testdata.FileCreatedBeforeInput, - "--" + flags.FileModifiedAfterFN, testdata.FileModifiedAfterInput, - "--" + flags.FileModifiedBeforeFN, testdata.FileModifiedBeforeInput, + 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.AWSAccessKeyFN, testdata.AWSAccessKeyID, - "--" + flags.AWSSecretAccessKeyFN, testdata.AWSSecretAccessKey, - "--" + flags.AWSSessionTokenFN, testdata.AWSSessionToken, + "--" + flags.FormatFN, flagsTD.FormatType, - "--" + flags.CorsoPassphraseFN, testdata.CorsoPassphrase, - - "--" + flags.FormatFN, testdata.FormatType, - - // bool flags - "--" + flags.ArchiveFN, - }) + // bool flags + "--" + 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)) opts := utils.MakeOneDriveOpts(cmd) - assert.Equal(t, testdata.BackupInput, flags.BackupIDFV) + assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) - assert.ElementsMatch(t, testdata.FileNameInput, opts.FileName) - assert.ElementsMatch(t, testdata.FolderPathInput, opts.FolderPath) - assert.Equal(t, testdata.FileCreatedAfterInput, opts.FileCreatedAfter) - assert.Equal(t, testdata.FileCreatedBeforeInput, opts.FileCreatedBefore) - assert.Equal(t, testdata.FileModifiedAfterInput, opts.FileModifiedAfter) - assert.Equal(t, testdata.FileModifiedBeforeInput, opts.FileModifiedBefore) + 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, testdata.Archive, opts.ExportCfg.Archive) - assert.Equal(t, testdata.FormatType, opts.ExportCfg.Format) + assert.Equal(t, flagsTD.CorsoPassphrase, flags.CorsoPassphraseFV) - assert.Equal(t, testdata.AWSAccessKeyID, flags.AWSAccessKeyFV) - assert.Equal(t, testdata.AWSSecretAccessKey, flags.AWSSecretAccessKeyFV) - assert.Equal(t, testdata.AWSSessionToken, flags.AWSSessionTokenFV) - - assert.Equal(t, testdata.CorsoPassphrase, flags.CorsoPassphraseFV) + flagsTD.AssertStorageFlags(t, cmd) }) } } diff --git a/src/cli/export/sharepoint.go b/src/cli/export/sharepoint.go index 9d9a36367..7e4fd3ae7 100644 --- a/src/cli/export/sharepoint.go +++ b/src/cli/export/sharepoint.go @@ -30,8 +30,6 @@ func addSharePointCommands(cmd *cobra.Command) *cobra.Command { flags.AddSharePointDetailsAndRestoreFlags(c) flags.AddExportConfigFlags(c) flags.AddFailFastFlag(c) - flags.AddCorsoPassphaseFlags(c) - flags.AddAWSCredsFlags(c) } return c diff --git a/src/cli/export/sharepoint_test.go b/src/cli/export/sharepoint_test.go index 4f33d92a3..affb060e1 100644 --- a/src/cli/export/sharepoint_test.go +++ b/src/cli/export/sharepoint_test.go @@ -11,8 +11,8 @@ import ( "github.com/stretchr/testify/suite" "github.com/alcionai/corso/src/cli/flags" + flagsTD "github.com/alcionai/corso/src/cli/flags/testdata" "github.com/alcionai/corso/src/cli/utils" - "github.com/alcionai/corso/src/cli/utils/testdata" "github.com/alcionai/corso/src/internal/tester" ) @@ -42,13 +42,16 @@ func (suite *SharePointUnitSuite) TestAddSharePointCommands() { cmd := &cobra.Command{Use: test.use} - // normally a persistent flag from the root. - // required to ensure a dry run. + // 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) @@ -57,65 +60,60 @@ func (suite *SharePointUnitSuite) TestAddSharePointCommands() { assert.Equal(t, test.expectShort, child.Short) tester.AreSameFunc(t, test.expectRunE, child.RunE) - cmd.SetArgs([]string{ - "sharepoint", - testdata.RestoreDestination, - "--" + flags.RunModeFN, flags.RunModeFlagTest, - "--" + flags.BackupFN, testdata.BackupInput, - "--" + flags.LibraryFN, testdata.LibraryInput, - "--" + flags.FileFN, testdata.FlgInputs(testdata.FileNameInput), - "--" + flags.FolderFN, testdata.FlgInputs(testdata.FolderPathInput), - "--" + flags.FileCreatedAfterFN, testdata.FileCreatedAfterInput, - "--" + flags.FileCreatedBeforeFN, testdata.FileCreatedBeforeInput, - "--" + flags.FileModifiedAfterFN, testdata.FileModifiedAfterInput, - "--" + flags.FileModifiedBeforeFN, testdata.FileModifiedBeforeInput, - "--" + flags.ListItemFN, testdata.FlgInputs(testdata.ListItemInput), - "--" + flags.ListFolderFN, testdata.FlgInputs(testdata.ListFolderInput), - "--" + flags.PageFN, testdata.FlgInputs(testdata.PageInput), - "--" + flags.PageFolderFN, testdata.FlgInputs(testdata.PageFolderInput), + 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.AWSAccessKeyFN, testdata.AWSAccessKeyID, - "--" + flags.AWSSecretAccessKeyFN, testdata.AWSSecretAccessKey, - "--" + flags.AWSSessionTokenFN, testdata.AWSSessionToken, + "--" + flags.FormatFN, flagsTD.FormatType, - "--" + flags.CorsoPassphraseFN, testdata.CorsoPassphrase, - - "--" + flags.FormatFN, testdata.FormatType, - - // bool flags - "--" + flags.ArchiveFN, - }) + // bool flags + "--" + 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)) opts := utils.MakeSharePointOpts(cmd) - assert.Equal(t, testdata.BackupInput, flags.BackupIDFV) + assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) - assert.Equal(t, testdata.LibraryInput, opts.Library) - assert.ElementsMatch(t, testdata.FileNameInput, opts.FileName) - assert.ElementsMatch(t, testdata.FolderPathInput, opts.FolderPath) - assert.Equal(t, testdata.FileCreatedAfterInput, opts.FileCreatedAfter) - assert.Equal(t, testdata.FileCreatedBeforeInput, opts.FileCreatedBefore) - assert.Equal(t, testdata.FileModifiedAfterInput, opts.FileModifiedAfter) - assert.Equal(t, testdata.FileModifiedBeforeInput, opts.FileModifiedBefore) + assert.Equal(t, flagsTD.LibraryInput, opts.Library) + 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.ElementsMatch(t, testdata.ListItemInput, opts.ListItem) - assert.ElementsMatch(t, testdata.ListFolderInput, opts.ListFolder) + assert.ElementsMatch(t, flagsTD.ListItemInput, opts.ListItem) + assert.ElementsMatch(t, flagsTD.ListFolderInput, opts.ListFolder) - assert.ElementsMatch(t, testdata.PageInput, opts.Page) - assert.ElementsMatch(t, testdata.PageFolderInput, opts.PageFolder) + assert.ElementsMatch(t, flagsTD.PageInput, opts.Page) + assert.ElementsMatch(t, flagsTD.PageFolderInput, opts.PageFolder) - assert.Equal(t, testdata.Archive, opts.ExportCfg.Archive) - assert.Equal(t, testdata.FormatType, opts.ExportCfg.Format) + assert.Equal(t, flagsTD.Archive, opts.ExportCfg.Archive) + assert.Equal(t, flagsTD.FormatType, opts.ExportCfg.Format) - assert.Equal(t, testdata.AWSAccessKeyID, flags.AWSAccessKeyFV) - assert.Equal(t, testdata.AWSSecretAccessKey, flags.AWSSecretAccessKeyFV) - assert.Equal(t, testdata.AWSSessionToken, flags.AWSSessionTokenFV) - - assert.Equal(t, testdata.CorsoPassphrase, flags.CorsoPassphraseFV) + flagsTD.AssertStorageFlags(t, cmd) }) } } diff --git a/src/cli/flags/backup_list.go b/src/cli/flags/backup_list.go new file mode 100644 index 000000000..495120dac --- /dev/null +++ b/src/cli/flags/backup_list.go @@ -0,0 +1,29 @@ +package flags + +import "github.com/spf13/cobra" + +const Show = "show" + +func AddAllBackupListFlags(cmd *cobra.Command) { + AddFailedItemsFN(cmd) + AddSkippedItemsFN(cmd) + AddRecoveredErrorsFN(cmd) +} + +func AddFailedItemsFN(cmd *cobra.Command) { + cmd.Flags().StringVar( + &ListFailedItemsFV, FailedItemsFN, Show, + "Toggles showing or hiding the list of items that failed.") +} + +func AddSkippedItemsFN(cmd *cobra.Command) { + cmd.Flags().StringVar( + &ListSkippedItemsFV, SkippedItemsFN, Show, + "Toggles showing or hiding the list of items that were skipped.") +} + +func AddRecoveredErrorsFN(cmd *cobra.Command) { + cmd.Flags().StringVar( + &ListRecoveredErrorsFV, RecoveredErrorsFN, Show, + "Toggles showing or hiding the list of errors which Corso recovered from.") +} diff --git a/src/cli/flags/options.go b/src/cli/flags/options.go index dbc31ca76..ba127092c 100644 --- a/src/cli/flags/options.go +++ b/src/cli/flags/options.go @@ -62,8 +62,8 @@ func AddFailFastFlag(cmd *cobra.Command) { cobra.CheckErr(fs.MarkHidden(FailFastFN)) } -// AddSkipPermissionsFlag adds OneDrive flag for skipping restoring permissions -func AddSkipPermissionsFlag(cmd *cobra.Command) { +// AddNoPermissionsFlag adds OneDrive flag for skipping restoring permissions +func AddNoPermissionsFlag(cmd *cobra.Command) { fs := cmd.Flags() fs.BoolVar(&NoPermissionsFV, NoPermissionsFN, false, "don't restore file and folder permissions") } diff --git a/src/cli/flags/repo.go b/src/cli/flags/repo.go index c0dfd9e4c..44bc3a2a3 100644 --- a/src/cli/flags/repo.go +++ b/src/cli/flags/repo.go @@ -33,6 +33,16 @@ func AddBackupIDFlag(cmd *cobra.Command, require bool) { } } +// --------------------------------------------------------------------------- +// storage +// --------------------------------------------------------------------------- + +func AddAllStorageFlags(cmd *cobra.Command) { + AddCorsoPassphaseFlags(cmd) + // AddAzureCredsFlags is added by ProviderFlags + AddAWSCredsFlags(cmd) +} + func AddAWSCredsFlags(cmd *cobra.Command) { fs := cmd.Flags() fs.StringVar(&AWSAccessKeyFV, AWSAccessKeyFN, "", "S3 access key") @@ -48,3 +58,11 @@ func AddCorsoPassphaseFlags(cmd *cobra.Command) { "", "Passphrase to protect encrypted repository contents") } + +// --------------------------------------------------------------------------- +// Provider +// --------------------------------------------------------------------------- + +func AddAllProviderFlags(cmd *cobra.Command) { + AddAzureCredsFlags(cmd) +} diff --git a/src/cli/flags/testdata/backup_list.go b/src/cli/flags/testdata/backup_list.go new file mode 100644 index 000000000..911a6b450 --- /dev/null +++ b/src/cli/flags/testdata/backup_list.go @@ -0,0 +1,23 @@ +package testdata + +import ( + "testing" + + "github.com/alcionai/corso/src/cli/flags" + "github.com/spf13/cobra" + "gotest.tools/v3/assert" +) + +func PreparedBackupListFlags() []string { + return []string{ + "--" + flags.FailedItemsFN, flags.Show, + "--" + flags.SkippedItemsFN, flags.Show, + "--" + flags.RecoveredErrorsFN, flags.Show, + } +} + +func AssertBackupListFlags(t *testing.T, cmd *cobra.Command) { + assert.Equal(t, flags.Show, flags.ListFailedItemsFV) + assert.Equal(t, flags.Show, flags.ListSkippedItemsFV) + assert.Equal(t, flags.Show, flags.ListRecoveredErrorsFV) +} diff --git a/src/cli/utils/testdata/flags.go b/src/cli/flags/testdata/flags.go similarity index 67% rename from src/cli/utils/testdata/flags.go rename to src/cli/flags/testdata/flags.go index fc4608694..c8339cf73 100644 --- a/src/cli/utils/testdata/flags.go +++ b/src/cli/flags/testdata/flags.go @@ -1,15 +1,25 @@ package testdata -import "strings" +import ( + "strings" + + "github.com/spf13/cobra" +) func FlgInputs(in []string) string { return strings.Join(in, ",") } var ( BackupInput = "backup-id" - UsersInput = []string{"users1", "users2"} - SiteIDInput = []string{"siteID1", "siteID2"} - WebURLInput = []string{"webURL1", "webURL2"} + GroupsInput = []string{"team1", "group2"} + MailboxInput = []string{"mailbox1", "mailbox2"} + UsersInput = []string{"users1", "users2"} + SiteIDInput = []string{"siteID1", "siteID2"} + WebURLInput = []string{"webURL1", "webURL2"} + + ExchangeCategoryDataInput = []string{"email", "events", "contacts"} + SharepointCategoryDataInput = []string{"files", "lists", "pages"} + GroupsCategoryDataInput = []string{"files", "lists", "pages", "messages"} ContactInput = []string{"contact1", "contact2"} ContactFldInput = []string{"contactFld1", "contactFld2"} @@ -49,7 +59,7 @@ var ( ToResource = "toResource" SkipPermissions = false - DeltaPageSize = "deltaPageSize" + DeltaPageSize = "7" Archive = true FormatType = "json" @@ -65,4 +75,27 @@ var ( CorsoPassphrase = "testCorsoPassphrase" RestoreDestination = "test-restore-destination" + + FetchParallelism = "3" + + FailFast = true + DisableIncrementals = true + ForceItemDataDownload = true + DisableDelta = true + EnableImmutableID = true + DisableConcurrencyLimiter = true ) + +func WithFlags( + cc *cobra.Command, + command string, + flagSets ...[]string, +) { + args := []string{command} + + for _, sl := range flagSets { + args = append(args, sl...) + } + + cc.SetArgs(args) +} diff --git a/src/cli/flags/testdata/repo.go b/src/cli/flags/testdata/repo.go new file mode 100644 index 000000000..9ac0481f0 --- /dev/null +++ b/src/cli/flags/testdata/repo.go @@ -0,0 +1,42 @@ +package testdata + +import ( + "testing" + + "github.com/spf13/cobra" + "gotest.tools/v3/assert" + + "github.com/alcionai/corso/src/cli/flags" +) + +func PreparedStorageFlags() []string { + return []string{ + "--" + flags.AWSAccessKeyFN, AWSAccessKeyID, + "--" + flags.AWSSecretAccessKeyFN, AWSSecretAccessKey, + "--" + flags.AWSSessionTokenFN, AWSSessionToken, + + "--" + flags.CorsoPassphraseFN, CorsoPassphrase, + } +} + +func AssertStorageFlags(t *testing.T, cmd *cobra.Command) { + assert.Equal(t, AWSAccessKeyID, flags.AWSAccessKeyFV) + assert.Equal(t, AWSSecretAccessKey, flags.AWSSecretAccessKeyFV) + assert.Equal(t, AWSSessionToken, flags.AWSSessionTokenFV) + + assert.Equal(t, CorsoPassphrase, flags.CorsoPassphraseFV) +} + +func PreparedProviderFlags() []string { + return []string{ + "--" + flags.AzureClientIDFN, AzureClientID, + "--" + flags.AzureClientTenantFN, AzureTenantID, + "--" + flags.AzureClientSecretFN, AzureClientSecret, + } +} + +func AssertProviderFlags(t *testing.T, cmd *cobra.Command) { + assert.Equal(t, AzureClientID, flags.AzureClientIDFV) + assert.Equal(t, AzureTenantID, flags.AzureClientTenantFV) + assert.Equal(t, AzureClientSecret, flags.AzureClientSecretFV) +} diff --git a/src/cli/repo/s3.go b/src/cli/repo/s3.go index fa46715bd..1f3762320 100644 --- a/src/cli/repo/s3.go +++ b/src/cli/repo/s3.go @@ -33,9 +33,8 @@ func addS3Commands(cmd *cobra.Command) *cobra.Command { c.Use = c.Use + " " + s3ProviderCommandUseSuffix c.SetUsageTemplate(cmd.UsageTemplate()) - flags.AddAWSCredsFlags(c) - flags.AddAzureCredsFlags(c) flags.AddCorsoPassphaseFlags(c) + flags.AddAWSCredsFlags(c) flags.AddS3BucketFlags(c) return c diff --git a/src/cli/restore/exchange.go b/src/cli/restore/exchange.go index 0a1f99971..b1115e5a9 100644 --- a/src/cli/restore/exchange.go +++ b/src/cli/restore/exchange.go @@ -30,9 +30,6 @@ func addExchangeCommands(cmd *cobra.Command) *cobra.Command { flags.AddExchangeDetailsAndRestoreFlags(c) flags.AddRestoreConfigFlags(c) flags.AddFailFastFlag(c) - flags.AddCorsoPassphaseFlags(c) - flags.AddAWSCredsFlags(c) - flags.AddAzureCredsFlags(c) } return c diff --git a/src/cli/restore/exchange_test.go b/src/cli/restore/exchange_test.go index a257fff7a..d7ffb1b98 100644 --- a/src/cli/restore/exchange_test.go +++ b/src/cli/restore/exchange_test.go @@ -11,8 +11,8 @@ import ( "github.com/stretchr/testify/suite" "github.com/alcionai/corso/src/cli/flags" + flagsTD "github.com/alcionai/corso/src/cli/flags/testdata" "github.com/alcionai/corso/src/cli/utils" - "github.com/alcionai/corso/src/cli/utils/testdata" "github.com/alcionai/corso/src/internal/tester" ) @@ -42,13 +42,16 @@ func (suite *ExchangeUnitSuite) TestAddExchangeCommands() { cmd := &cobra.Command{Use: test.use} - // normally a persistent flag from the root. - // required to ensure a dry run. + // 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) @@ -57,86 +60,73 @@ func (suite *ExchangeUnitSuite) TestAddExchangeCommands() { assert.Equal(t, test.expectShort, child.Short) tester.AreSameFunc(t, test.expectRunE, child.RunE) - // Test arg parsing for few args - cmd.SetArgs([]string{ - "exchange", - "--" + flags.RunModeFN, flags.RunModeFlagTest, - "--" + flags.BackupFN, testdata.BackupInput, + flagsTD.WithFlags( + cmd, + exchangeServiceCommand, + []string{ + "--" + flags.RunModeFN, flags.RunModeFlagTest, + "--" + flags.BackupFN, flagsTD.BackupInput, - "--" + flags.ContactFN, testdata.FlgInputs(testdata.ContactInput), - "--" + flags.ContactFolderFN, testdata.FlgInputs(testdata.ContactFldInput), - "--" + flags.ContactNameFN, testdata.ContactNameInput, + "--" + flags.ContactFN, flagsTD.FlgInputs(flagsTD.ContactInput), + "--" + flags.ContactFolderFN, flagsTD.FlgInputs(flagsTD.ContactFldInput), + "--" + flags.ContactNameFN, flagsTD.ContactNameInput, - "--" + flags.EmailFN, testdata.FlgInputs(testdata.EmailInput), - "--" + flags.EmailFolderFN, testdata.FlgInputs(testdata.EmailFldInput), - "--" + flags.EmailReceivedAfterFN, testdata.EmailReceivedAfterInput, - "--" + flags.EmailReceivedBeforeFN, testdata.EmailReceivedBeforeInput, - "--" + flags.EmailSenderFN, testdata.EmailSenderInput, - "--" + flags.EmailSubjectFN, testdata.EmailSubjectInput, + "--" + 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, testdata.FlgInputs(testdata.EventInput), - "--" + flags.EventCalendarFN, testdata.FlgInputs(testdata.EventCalInput), - "--" + flags.EventOrganizerFN, testdata.EventOrganizerInput, - "--" + flags.EventRecursFN, testdata.EventRecursInput, - "--" + flags.EventStartsAfterFN, testdata.EventStartsAfterInput, - "--" + flags.EventStartsBeforeFN, testdata.EventStartsBeforeInput, - "--" + flags.EventSubjectFN, testdata.EventSubjectInput, + "--" + 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, testdata.Collisions, - "--" + flags.DestinationFN, testdata.Destination, - "--" + flags.ToResourceFN, testdata.ToResource, - - "--" + flags.AWSAccessKeyFN, testdata.AWSAccessKeyID, - "--" + flags.AWSSecretAccessKeyFN, testdata.AWSSecretAccessKey, - "--" + flags.AWSSessionTokenFN, testdata.AWSSessionToken, - - "--" + flags.AzureClientIDFN, testdata.AzureClientID, - "--" + flags.AzureClientTenantFN, testdata.AzureTenantID, - "--" + flags.AzureClientSecretFN, testdata.AzureClientSecret, - - "--" + flags.CorsoPassphraseFN, testdata.CorsoPassphrase, - }) + "--" + 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)) opts := utils.MakeExchangeOpts(cmd) - assert.Equal(t, testdata.BackupInput, flags.BackupIDFV) + assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) - assert.ElementsMatch(t, testdata.ContactInput, opts.Contact) - assert.ElementsMatch(t, testdata.ContactFldInput, opts.ContactFolder) - assert.Equal(t, testdata.ContactNameInput, opts.ContactName) + assert.ElementsMatch(t, flagsTD.ContactInput, opts.Contact) + assert.ElementsMatch(t, flagsTD.ContactFldInput, opts.ContactFolder) + assert.Equal(t, flagsTD.ContactNameInput, opts.ContactName) - assert.ElementsMatch(t, testdata.EmailInput, opts.Email) - assert.ElementsMatch(t, testdata.EmailFldInput, opts.EmailFolder) - assert.Equal(t, testdata.EmailReceivedAfterInput, opts.EmailReceivedAfter) - assert.Equal(t, testdata.EmailReceivedBeforeInput, opts.EmailReceivedBefore) - assert.Equal(t, testdata.EmailSenderInput, opts.EmailSender) - assert.Equal(t, testdata.EmailSubjectInput, opts.EmailSubject) + 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, testdata.EventInput, opts.Event) - assert.ElementsMatch(t, testdata.EventCalInput, opts.EventCalendar) - assert.Equal(t, testdata.EventOrganizerInput, opts.EventOrganizer) - assert.Equal(t, testdata.EventRecursInput, opts.EventRecurs) - assert.Equal(t, testdata.EventStartsAfterInput, opts.EventStartsAfter) - assert.Equal(t, testdata.EventStartsBeforeInput, opts.EventStartsBefore) - assert.Equal(t, testdata.EventSubjectInput, opts.EventSubject) + assert.ElementsMatch(t, flagsTD.EventInput, opts.Event) + assert.ElementsMatch(t, flagsTD.EventCalInput, opts.EventCalendar) + assert.Equal(t, flagsTD.EventOrganizerInput, opts.EventOrganizer) + assert.Equal(t, flagsTD.EventRecursInput, opts.EventRecurs) + assert.Equal(t, flagsTD.EventStartsAfterInput, opts.EventStartsAfter) + assert.Equal(t, flagsTD.EventStartsBeforeInput, opts.EventStartsBefore) + assert.Equal(t, flagsTD.EventSubjectInput, opts.EventSubject) - assert.Equal(t, testdata.Collisions, opts.RestoreCfg.Collisions) - assert.Equal(t, testdata.Destination, opts.RestoreCfg.Destination) - assert.Equal(t, testdata.ToResource, opts.RestoreCfg.ProtectedResource) + assert.Equal(t, flagsTD.Collisions, opts.RestoreCfg.Collisions) + assert.Equal(t, flagsTD.Destination, opts.RestoreCfg.Destination) + assert.Equal(t, flagsTD.ToResource, opts.RestoreCfg.ProtectedResource) - assert.Equal(t, testdata.AWSAccessKeyID, flags.AWSAccessKeyFV) - assert.Equal(t, testdata.AWSSecretAccessKey, flags.AWSSecretAccessKeyFV) - assert.Equal(t, testdata.AWSSessionToken, flags.AWSSessionTokenFV) - - assert.Equal(t, testdata.AzureClientID, flags.AzureClientIDFV) - assert.Equal(t, testdata.AzureTenantID, flags.AzureClientTenantFV) - assert.Equal(t, testdata.AzureClientSecret, flags.AzureClientSecretFV) - - assert.Equal(t, testdata.CorsoPassphrase, flags.CorsoPassphraseFV) + flagsTD.AssertProviderFlags(t, cmd) + flagsTD.AssertStorageFlags(t, cmd) }) } } diff --git a/src/cli/restore/groups.go b/src/cli/restore/groups.go index dbe5cf60b..755d797e0 100644 --- a/src/cli/restore/groups.go +++ b/src/cli/restore/groups.go @@ -27,14 +27,11 @@ func addGroupsCommands(cmd *cobra.Command) *cobra.Command { fs.SortFlags = false flags.AddBackupIDFlag(c, true) - flags.AddSkipPermissionsFlag(c) + flags.AddNoPermissionsFlag(c) flags.AddSharePointDetailsAndRestoreFlags(c) // for sp restores flags.AddSiteIDFlag(c) flags.AddRestoreConfigFlags(c) flags.AddFailFastFlag(c) - flags.AddCorsoPassphaseFlags(c) - flags.AddAWSCredsFlags(c) - flags.AddAzureCredsFlags(c) } return c diff --git a/src/cli/restore/groups_test.go b/src/cli/restore/groups_test.go index 0b0e3cb60..f2045e53c 100644 --- a/src/cli/restore/groups_test.go +++ b/src/cli/restore/groups_test.go @@ -11,8 +11,8 @@ import ( "github.com/stretchr/testify/suite" "github.com/alcionai/corso/src/cli/flags" + flagsTD "github.com/alcionai/corso/src/cli/flags/testdata" "github.com/alcionai/corso/src/cli/utils" - "github.com/alcionai/corso/src/cli/utils/testdata" "github.com/alcionai/corso/src/internal/tester" ) @@ -42,13 +42,16 @@ func (suite *GroupsUnitSuite) TestAddGroupsCommands() { cmd := &cobra.Command{Use: test.use} - // normally a persistent flag from the root. - // required to ensure a dry run. + // 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) @@ -57,68 +60,61 @@ func (suite *GroupsUnitSuite) TestAddGroupsCommands() { assert.Equal(t, test.expectShort, child.Short) tester.AreSameFunc(t, test.expectRunE, child.RunE) - cmd.SetArgs([]string{ - "groups", - "--" + flags.RunModeFN, flags.RunModeFlagTest, - "--" + flags.BackupFN, testdata.BackupInput, + flagsTD.WithFlags( + cmd, + groupsServiceCommand, + []string{ + "--" + flags.RunModeFN, flags.RunModeFlagTest, + "--" + flags.BackupFN, flagsTD.BackupInput, - "--" + flags.LibraryFN, testdata.LibraryInput, - "--" + flags.FileFN, testdata.FlgInputs(testdata.FileNameInput), - "--" + flags.FolderFN, testdata.FlgInputs(testdata.FolderPathInput), - "--" + flags.FileCreatedAfterFN, testdata.FileCreatedAfterInput, - "--" + flags.FileCreatedBeforeFN, testdata.FileCreatedBeforeInput, - "--" + flags.FileModifiedAfterFN, testdata.FileModifiedAfterInput, - "--" + flags.FileModifiedBeforeFN, testdata.FileModifiedBeforeInput, - "--" + flags.ListItemFN, testdata.FlgInputs(testdata.ListItemInput), - "--" + flags.ListFolderFN, testdata.FlgInputs(testdata.ListFolderInput), - "--" + flags.PageFN, testdata.FlgInputs(testdata.PageInput), - "--" + flags.PageFolderFN, testdata.FlgInputs(testdata.PageFolderInput), + "--" + 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, testdata.Collisions, - "--" + flags.DestinationFN, testdata.Destination, - "--" + flags.ToResourceFN, testdata.ToResource, + "--" + flags.CollisionsFN, flagsTD.Collisions, + "--" + flags.DestinationFN, flagsTD.Destination, + "--" + flags.ToResourceFN, flagsTD.ToResource, - "--" + flags.AWSAccessKeyFN, testdata.AWSAccessKeyID, - "--" + flags.AWSSecretAccessKeyFN, testdata.AWSSecretAccessKey, - "--" + flags.AWSSessionTokenFN, testdata.AWSSessionToken, - - "--" + flags.AzureClientIDFN, testdata.AzureClientID, - "--" + flags.AzureClientTenantFN, testdata.AzureTenantID, - "--" + flags.AzureClientSecretFN, testdata.AzureClientSecret, - - "--" + flags.CorsoPassphraseFN, testdata.CorsoPassphrase, - }) + // bool flags + "--" + 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)) opts := utils.MakeGroupsOpts(cmd) - assert.Equal(t, testdata.BackupInput, flags.BackupIDFV) + assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) - assert.Equal(t, testdata.LibraryInput, opts.Library) - assert.ElementsMatch(t, testdata.FileNameInput, opts.FileName) - assert.ElementsMatch(t, testdata.FolderPathInput, opts.FolderPath) - assert.Equal(t, testdata.FileCreatedAfterInput, opts.FileCreatedAfter) - assert.Equal(t, testdata.FileCreatedBeforeInput, opts.FileCreatedBefore) - assert.Equal(t, testdata.FileModifiedAfterInput, opts.FileModifiedAfter) - assert.Equal(t, testdata.FileModifiedBeforeInput, opts.FileModifiedBefore) + assert.Equal(t, flagsTD.LibraryInput, opts.Library) + 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, testdata.Collisions, opts.RestoreCfg.Collisions) - assert.Equal(t, testdata.Destination, opts.RestoreCfg.Destination) - assert.Equal(t, testdata.ToResource, opts.RestoreCfg.ProtectedResource) + assert.Equal(t, flagsTD.Collisions, opts.RestoreCfg.Collisions) + assert.Equal(t, flagsTD.Destination, opts.RestoreCfg.Destination) + assert.Equal(t, flagsTD.ToResource, opts.RestoreCfg.ProtectedResource) - assert.Equal(t, testdata.AWSAccessKeyID, flags.AWSAccessKeyFV) - assert.Equal(t, testdata.AWSSecretAccessKey, flags.AWSSecretAccessKeyFV) - assert.Equal(t, testdata.AWSSessionToken, flags.AWSSessionTokenFV) + // bool flags + assert.True(t, flags.NoPermissionsFV) - assert.Equal(t, testdata.AzureClientID, flags.AzureClientIDFV) - assert.Equal(t, testdata.AzureTenantID, flags.AzureClientTenantFV) - assert.Equal(t, testdata.AzureClientSecret, flags.AzureClientSecretFV) - - assert.Equal(t, testdata.CorsoPassphrase, flags.CorsoPassphraseFV) - assert.False(t, flags.NoPermissionsFV) + flagsTD.AssertProviderFlags(t, cmd) + flagsTD.AssertStorageFlags(t, cmd) }) } } diff --git a/src/cli/restore/onedrive.go b/src/cli/restore/onedrive.go index 272a0c4b1..6efbd4831 100644 --- a/src/cli/restore/onedrive.go +++ b/src/cli/restore/onedrive.go @@ -28,12 +28,9 @@ func addOneDriveCommands(cmd *cobra.Command) *cobra.Command { flags.AddBackupIDFlag(c, true) flags.AddOneDriveDetailsAndRestoreFlags(c) - flags.AddSkipPermissionsFlag(c) + flags.AddNoPermissionsFlag(c) flags.AddRestoreConfigFlags(c) flags.AddFailFastFlag(c) - flags.AddCorsoPassphaseFlags(c) - flags.AddAWSCredsFlags(c) - flags.AddAzureCredsFlags(c) } return c diff --git a/src/cli/restore/onedrive_test.go b/src/cli/restore/onedrive_test.go index 33415aa3f..5a94705d8 100644 --- a/src/cli/restore/onedrive_test.go +++ b/src/cli/restore/onedrive_test.go @@ -11,8 +11,8 @@ import ( "github.com/stretchr/testify/suite" "github.com/alcionai/corso/src/cli/flags" + flagsTD "github.com/alcionai/corso/src/cli/flags/testdata" "github.com/alcionai/corso/src/cli/utils" - "github.com/alcionai/corso/src/cli/utils/testdata" "github.com/alcionai/corso/src/internal/tester" ) @@ -42,13 +42,16 @@ func (suite *OneDriveUnitSuite) TestAddOneDriveCommands() { cmd := &cobra.Command{Use: test.use} - // normally a persistent flag from the root. - // required to ensure a dry run. + // 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) @@ -57,60 +60,54 @@ func (suite *OneDriveUnitSuite) TestAddOneDriveCommands() { assert.Equal(t, test.expectShort, child.Short) tester.AreSameFunc(t, test.expectRunE, child.RunE) - cmd.SetArgs([]string{ - "onedrive", - "--" + flags.RunModeFN, flags.RunModeFlagTest, - "--" + flags.BackupFN, testdata.BackupInput, - "--" + flags.FileFN, testdata.FlgInputs(testdata.FileNameInput), - "--" + flags.FolderFN, testdata.FlgInputs(testdata.FolderPathInput), - "--" + flags.FileCreatedAfterFN, testdata.FileCreatedAfterInput, - "--" + flags.FileCreatedBeforeFN, testdata.FileCreatedBeforeInput, - "--" + flags.FileModifiedAfterFN, testdata.FileModifiedAfterInput, - "--" + flags.FileModifiedBeforeFN, testdata.FileModifiedBeforeInput, + 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, testdata.Collisions, - "--" + flags.DestinationFN, testdata.Destination, - "--" + flags.ToResourceFN, testdata.ToResource, + "--" + flags.CollisionsFN, flagsTD.Collisions, + "--" + flags.DestinationFN, flagsTD.Destination, + "--" + flags.ToResourceFN, flagsTD.ToResource, - "--" + flags.AWSAccessKeyFN, testdata.AWSAccessKeyID, - "--" + flags.AWSSecretAccessKeyFN, testdata.AWSSecretAccessKey, - "--" + flags.AWSSessionTokenFN, testdata.AWSSessionToken, - - "--" + flags.AzureClientIDFN, testdata.AzureClientID, - "--" + flags.AzureClientTenantFN, testdata.AzureTenantID, - "--" + flags.AzureClientSecretFN, testdata.AzureClientSecret, - - "--" + flags.CorsoPassphraseFN, testdata.CorsoPassphrase, - }) + // bool flags + "--" + 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)) opts := utils.MakeOneDriveOpts(cmd) - assert.Equal(t, testdata.BackupInput, flags.BackupIDFV) + assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) - assert.ElementsMatch(t, testdata.FileNameInput, opts.FileName) - assert.ElementsMatch(t, testdata.FolderPathInput, opts.FolderPath) - assert.Equal(t, testdata.FileCreatedAfterInput, opts.FileCreatedAfter) - assert.Equal(t, testdata.FileCreatedBeforeInput, opts.FileCreatedBefore) - assert.Equal(t, testdata.FileModifiedAfterInput, opts.FileModifiedAfter) - assert.Equal(t, testdata.FileModifiedBeforeInput, opts.FileModifiedBefore) + 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, testdata.Collisions, opts.RestoreCfg.Collisions) - assert.Equal(t, testdata.Destination, opts.RestoreCfg.Destination) - assert.Equal(t, testdata.ToResource, opts.RestoreCfg.ProtectedResource) + assert.Equal(t, flagsTD.Collisions, opts.RestoreCfg.Collisions) + assert.Equal(t, flagsTD.Destination, opts.RestoreCfg.Destination) + assert.Equal(t, flagsTD.ToResource, opts.RestoreCfg.ProtectedResource) - assert.Equal(t, testdata.AWSAccessKeyID, flags.AWSAccessKeyFV) - assert.Equal(t, testdata.AWSSecretAccessKey, flags.AWSSecretAccessKeyFV) - assert.Equal(t, testdata.AWSSessionToken, flags.AWSSessionTokenFV) + // bool flags + assert.True(t, flags.NoPermissionsFV) - assert.Equal(t, testdata.AzureClientID, flags.AzureClientIDFV) - assert.Equal(t, testdata.AzureTenantID, flags.AzureClientTenantFV) - assert.Equal(t, testdata.AzureClientSecret, flags.AzureClientSecretFV) - - assert.Equal(t, testdata.CorsoPassphrase, flags.CorsoPassphraseFV) + flagsTD.AssertProviderFlags(t, cmd) + flagsTD.AssertStorageFlags(t, cmd) }) } } diff --git a/src/cli/restore/restore.go b/src/cli/restore/restore.go index d2407889b..f9da46416 100644 --- a/src/cli/restore/restore.go +++ b/src/cli/restore/restore.go @@ -24,11 +24,13 @@ var restoreCommands = []func(cmd *cobra.Command) *cobra.Command{ // AddCommands attaches all `corso restore * *` commands to the parent. func AddCommands(cmd *cobra.Command) { - restoreC := restoreCmd() - cmd.AddCommand(restoreC) + subCommand := restoreCmd() + flags.AddAllProviderFlags(subCommand) + flags.AddAllStorageFlags(subCommand) + cmd.AddCommand(subCommand) for _, addRestoreTo := range restoreCommands { - addRestoreTo(restoreC) + addRestoreTo(subCommand) } } diff --git a/src/cli/restore/sharepoint.go b/src/cli/restore/sharepoint.go index 5c91df671..56459aa19 100644 --- a/src/cli/restore/sharepoint.go +++ b/src/cli/restore/sharepoint.go @@ -28,12 +28,9 @@ func addSharePointCommands(cmd *cobra.Command) *cobra.Command { flags.AddBackupIDFlag(c, true) flags.AddSharePointDetailsAndRestoreFlags(c) - flags.AddSkipPermissionsFlag(c) + flags.AddNoPermissionsFlag(c) flags.AddRestoreConfigFlags(c) flags.AddFailFastFlag(c) - flags.AddCorsoPassphaseFlags(c) - flags.AddAWSCredsFlags(c) - flags.AddAzureCredsFlags(c) } return c diff --git a/src/cli/restore/sharepoint_test.go b/src/cli/restore/sharepoint_test.go index b22e7d4e7..638b03bee 100644 --- a/src/cli/restore/sharepoint_test.go +++ b/src/cli/restore/sharepoint_test.go @@ -11,8 +11,8 @@ import ( "github.com/stretchr/testify/suite" "github.com/alcionai/corso/src/cli/flags" + flagsTD "github.com/alcionai/corso/src/cli/flags/testdata" "github.com/alcionai/corso/src/cli/utils" - "github.com/alcionai/corso/src/cli/utils/testdata" "github.com/alcionai/corso/src/internal/tester" ) @@ -42,13 +42,16 @@ func (suite *SharePointUnitSuite) TestAddSharePointCommands() { cmd := &cobra.Command{Use: test.use} - // normally a persistent flag from the root. - // required to ensure a dry run. + // 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) @@ -57,75 +60,66 @@ func (suite *SharePointUnitSuite) TestAddSharePointCommands() { assert.Equal(t, test.expectShort, child.Short) tester.AreSameFunc(t, test.expectRunE, child.RunE) - cmd.SetArgs([]string{ - "sharepoint", - "--" + flags.RunModeFN, flags.RunModeFlagTest, - "--" + flags.BackupFN, testdata.BackupInput, - "--" + flags.LibraryFN, testdata.LibraryInput, - "--" + flags.FileFN, testdata.FlgInputs(testdata.FileNameInput), - "--" + flags.FolderFN, testdata.FlgInputs(testdata.FolderPathInput), - "--" + flags.FileCreatedAfterFN, testdata.FileCreatedAfterInput, - "--" + flags.FileCreatedBeforeFN, testdata.FileCreatedBeforeInput, - "--" + flags.FileModifiedAfterFN, testdata.FileModifiedAfterInput, - "--" + flags.FileModifiedBeforeFN, testdata.FileModifiedBeforeInput, - "--" + flags.ListItemFN, testdata.FlgInputs(testdata.ListItemInput), - "--" + flags.ListFolderFN, testdata.FlgInputs(testdata.ListFolderInput), - "--" + flags.PageFN, testdata.FlgInputs(testdata.PageInput), - "--" + flags.PageFolderFN, testdata.FlgInputs(testdata.PageFolderInput), + 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, testdata.Collisions, - "--" + flags.DestinationFN, testdata.Destination, - "--" + flags.ToResourceFN, testdata.ToResource, + "--" + flags.CollisionsFN, flagsTD.Collisions, + "--" + flags.DestinationFN, flagsTD.Destination, + "--" + flags.ToResourceFN, flagsTD.ToResource, - "--" + flags.AWSAccessKeyFN, testdata.AWSAccessKeyID, - "--" + flags.AWSSecretAccessKeyFN, testdata.AWSSecretAccessKey, - "--" + flags.AWSSessionTokenFN, testdata.AWSSessionToken, - - "--" + flags.AzureClientIDFN, testdata.AzureClientID, - "--" + flags.AzureClientTenantFN, testdata.AzureTenantID, - "--" + flags.AzureClientSecretFN, testdata.AzureClientSecret, - - "--" + flags.CorsoPassphraseFN, testdata.CorsoPassphrase, - }) + // bool flags + "--" + 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)) opts := utils.MakeSharePointOpts(cmd) - assert.Equal(t, testdata.BackupInput, flags.BackupIDFV) + assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV) - assert.Equal(t, testdata.LibraryInput, opts.Library) - assert.ElementsMatch(t, testdata.FileNameInput, opts.FileName) - assert.ElementsMatch(t, testdata.FolderPathInput, opts.FolderPath) - assert.Equal(t, testdata.FileCreatedAfterInput, opts.FileCreatedAfter) - assert.Equal(t, testdata.FileCreatedBeforeInput, opts.FileCreatedBefore) - assert.Equal(t, testdata.FileModifiedAfterInput, opts.FileModifiedAfter) - assert.Equal(t, testdata.FileModifiedBeforeInput, opts.FileModifiedBefore) + assert.Equal(t, flagsTD.LibraryInput, opts.Library) + 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.ElementsMatch(t, testdata.ListItemInput, opts.ListItem) - assert.ElementsMatch(t, testdata.ListFolderInput, opts.ListFolder) + assert.ElementsMatch(t, flagsTD.ListItemInput, opts.ListItem) + assert.ElementsMatch(t, flagsTD.ListFolderInput, opts.ListFolder) - assert.ElementsMatch(t, testdata.PageInput, opts.Page) - assert.ElementsMatch(t, testdata.PageFolderInput, opts.PageFolder) + assert.ElementsMatch(t, flagsTD.PageInput, opts.Page) + assert.ElementsMatch(t, flagsTD.PageFolderInput, opts.PageFolder) - assert.Equal(t, testdata.Collisions, opts.RestoreCfg.Collisions) - assert.Equal(t, testdata.Destination, opts.RestoreCfg.Destination) - assert.Equal(t, testdata.ToResource, opts.RestoreCfg.ProtectedResource) - - assert.Equal(t, testdata.AWSAccessKeyID, flags.AWSAccessKeyFV) - assert.Equal(t, testdata.AWSSecretAccessKey, flags.AWSSecretAccessKeyFV) - assert.Equal(t, testdata.AWSSessionToken, flags.AWSSessionTokenFV) - - assert.Equal(t, testdata.AzureClientID, flags.AzureClientIDFV) - assert.Equal(t, testdata.AzureTenantID, flags.AzureClientTenantFV) - assert.Equal(t, testdata.AzureClientSecret, flags.AzureClientSecretFV) - - assert.Equal(t, testdata.CorsoPassphrase, flags.CorsoPassphraseFV) + 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.False(t, flags.NoPermissionsFV) + assert.True(t, flags.NoPermissionsFV) + + flagsTD.AssertProviderFlags(t, cmd) + flagsTD.AssertStorageFlags(t, cmd) }) } } diff --git a/src/cli/utils/options_test.go b/src/cli/utils/options_test.go index 637399677..919f33b3a 100644 --- a/src/cli/utils/options_test.go +++ b/src/cli/utils/options_test.go @@ -47,7 +47,7 @@ func (suite *OptionsUnitSuite) TestAddExchangeCommands() { flags.AddDisableIncrementalsFlag(cmd) flags.AddForceItemDataDownloadFlag(cmd) flags.AddDisableDeltaFlag(cmd) - flags.AddSkipPermissionsFlag(cmd) + flags.AddNoPermissionsFlag(cmd) flags.AddSkipReduceFlag(cmd) flags.AddFetchParallelismFlag(cmd) flags.AddDisableConcurrencyLimiterFlag(cmd) diff --git a/src/go.mod b/src/go.mod index 20db2fecb..d20785bf6 100644 --- a/src/go.mod +++ b/src/go.mod @@ -36,6 +36,7 @@ require ( golang.org/x/exp v0.0.0-20230905200255-921286631fa9 golang.org/x/time v0.3.0 golang.org/x/tools v0.13.0 + gotest.tools/v3 v3.5.1 ) require ( @@ -46,6 +47,7 @@ require ( github.com/fsnotify/fsnotify v1.6.0 // indirect github.com/gofrs/flock v0.8.1 // indirect github.com/golang-jwt/jwt/v5 v5.0.0 // indirect + github.com/google/go-cmp v0.5.9 // indirect github.com/h2non/parth v0.0.0-20190131123155-b4df798d6542 // indirect github.com/hashicorp/cronexpr v1.1.2 // indirect github.com/hashicorp/go-immutable-radix v1.3.1 // indirect diff --git a/src/go.sum b/src/go.sum index bb94a20af..cda31894a 100644 --- a/src/go.sum +++ b/src/go.sum @@ -36,8 +36,6 @@ cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RX cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0= cloud.google.com/go/storage v1.14.0/go.mod h1:GrKmX003DSIwi9o29oFT7YDnHYwZoctc3fOKtUw0Xmo= dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= -github.com/Azure/azure-sdk-for-go/sdk/azcore v1.7.1 h1:/iHxaJhsFr0+xVFfbMr5vxz848jyiWuIEDhYq3y5odY= -github.com/Azure/azure-sdk-for-go/sdk/azcore v1.7.1/go.mod h1:bjGvMhVMb+EEm3VRNQawDMUyMMjo+S5ewNjflkep/0Q= github.com/Azure/azure-sdk-for-go/sdk/azcore v1.7.2 h1:t5+QXLCK9SVi0PPdaY0PrFvYUo24KwA0QwxnaHRSVd4= github.com/Azure/azure-sdk-for-go/sdk/azcore v1.7.2/go.mod h1:bjGvMhVMb+EEm3VRNQawDMUyMMjo+S5ewNjflkep/0Q= github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.3.1 h1:LNHhpdK7hzUcx/k1LIcuh5k7k1LGIWLQfCjaneSj7Fc= @@ -57,8 +55,6 @@ github.com/VividCortex/ewma v1.2.0 h1:f58SaIzcDXrSy3kWaHNvuJgJ3Nmz59Zji6XoJR/q1o github.com/VividCortex/ewma v1.2.0/go.mod h1:nz4BbCtbLyFDeC9SUHbtcT5644juEuWfUAUnGx7j5l4= github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d h1:licZJFw2RwpHMqeKTCYkitsPqHNxTmd4SNR5r94FGM8= github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d/go.mod h1:asat636LX7Bqt5lYEZ27JNDcqxfjdBQuJ/MM4CN/Lzo= -github.com/alcionai/clues v0.0.0-20230728164842-7dc4795a43e4 h1:husF7eAYw2HEzgjfAmNy+ZLzyztJV2SyoUngSUo829Y= -github.com/alcionai/clues v0.0.0-20230728164842-7dc4795a43e4/go.mod h1:MLEWSZ0cjEMg6hiGCRvE7AtrOhs7deBcm7ZrJBpfGRM= github.com/alcionai/clues v0.0.0-20230920212840-728ac1a1d8b8 h1:8KZyOE9IOxJ9Dg/n4pJKukcOxDAO3fxUcEP2MM0tNCg= github.com/alcionai/clues v0.0.0-20230920212840-728ac1a1d8b8/go.mod h1:iyJK9p061Zb1CqE+DFsofdjAc7/QTHGxdbJsf/mtVHo= github.com/alcionai/kopia v0.12.2-0.20230822191057-17d4deff94a3 h1:6YjRGjEZr/Bmux1XkS13Re1m1LI7VAcbFsA3PiqO2BI= @@ -291,8 +287,6 @@ github.com/matttproud/golang_protobuf_extensions v1.0.4 h1:mmDVorXM7PCGKw94cs5zk github.com/matttproud/golang_protobuf_extensions v1.0.4/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4= github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d h1:5PJl274Y63IEHC+7izoQE9x6ikvDFZS2mDVS3drnohI= github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d/go.mod h1:01TrycV0kFyexm33Z7vhZRXopbI8J3TDReVlkTgMUxE= -github.com/microsoft/kiota-abstractions-go v1.2.0 h1:lUriJgqdCY/QajwWQOgTCQE9Atywfe2NHhgoTCSXTRE= -github.com/microsoft/kiota-abstractions-go v1.2.0/go.mod h1:RkxyZ5x87Njik7iVeQY9M2wtrrL1MJZcXiI/BxD/82g= github.com/microsoft/kiota-abstractions-go v1.2.1 h1:TnLF7rjy1GfhuGK2ra/a3Vuz6piFXTR1OfdNoqesagA= github.com/microsoft/kiota-abstractions-go v1.2.1/go.mod h1:rEeeaytcnal/If3f1tz6/spFz4V+Hiqvz3rxF+oWQFA= github.com/microsoft/kiota-authentication-azure-go v1.0.0 h1:29FNZZ/4nnCOwFcGWlB/sxPvWz487HA2bXH8jR5k2Rk= @@ -307,8 +301,6 @@ github.com/microsoft/kiota-serialization-multipart-go v1.0.0 h1:3O5sb5Zj+moLBiJy github.com/microsoft/kiota-serialization-multipart-go v1.0.0/go.mod h1:yauLeBTpANk4L03XD985akNysG24SnRJGaveZf+p4so= github.com/microsoft/kiota-serialization-text-go v1.0.0 h1:XOaRhAXy+g8ZVpcq7x7a0jlETWnWrEum0RhmbYrTFnA= github.com/microsoft/kiota-serialization-text-go v1.0.0/go.mod h1:sM1/C6ecnQ7IquQOGUrUldaO5wj+9+v7G2W3sQ3fy6M= -github.com/microsoftgraph/msgraph-sdk-go v1.17.0 h1:ODua+yyogMmYos5ihqK90fQ01yaj+S2A+pM2MYxzjJ8= -github.com/microsoftgraph/msgraph-sdk-go v1.17.0/go.mod h1:DdshtIL3VJ3abSG6O+gmlvbc/pX7Xh7xbruLTWoRjfU= github.com/microsoftgraph/msgraph-sdk-go v1.19.0 h1:hx+SvDTm5ENYZFqmMIskF7tOn48zzT2Xv3OVFrxl2dc= github.com/microsoftgraph/msgraph-sdk-go v1.19.0/go.mod h1:3DArbqPS7riix0VsJhdtYsgPaAFAH9Jer64psW55riI= github.com/microsoftgraph/msgraph-sdk-go-core v1.0.0 h1:7NWTfyXvOjoizW7PmxNp3+8wCKPgpODs/D1cUZ3fkAY= @@ -457,16 +449,10 @@ go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk= -go.opentelemetry.io/otel v1.16.0 h1:Z7GVAX/UkAXPKsy94IU+i6thsQS4nb7LviLpnaNeW8s= -go.opentelemetry.io/otel v1.16.0/go.mod h1:vl0h9NUa1D5s1nv3A5vZOYWn8av4K8Ml6JDeHrT/bx4= go.opentelemetry.io/otel v1.18.0 h1:TgVozPGZ01nHyDZxK5WGPFB9QexeTMXEH7+tIClWfzs= go.opentelemetry.io/otel v1.18.0/go.mod h1:9lWqYO0Db579XzVuCKFNPDl4s73Voa+zEck3wHaAYQI= -go.opentelemetry.io/otel/metric v1.16.0 h1:RbrpwVG1Hfv85LgnZ7+txXioPDoh6EdbZHo26Q3hqOo= -go.opentelemetry.io/otel/metric v1.16.0/go.mod h1:QE47cpOmkwipPiefDwo2wDzwJrlfxxNYodqc4xnGCo4= go.opentelemetry.io/otel/metric v1.18.0 h1:JwVzw94UYmbx3ej++CwLUQZxEODDj/pOuTCvzhtRrSQ= go.opentelemetry.io/otel/metric v1.18.0/go.mod h1:nNSpsVDjWGfb7chbRLUNW+PBNdcSTHD4Uu5pfFMOI0k= -go.opentelemetry.io/otel/trace v1.16.0 h1:8JRpaObFoW0pxuVPapkgH8UhHQj+bJW8jJsCZEu5MQs= -go.opentelemetry.io/otel/trace v1.16.0/go.mod h1:Yt9vYq1SdNz3xdjZZK7wcXv1qv2pwLkqr2QVwea0ef0= go.opentelemetry.io/otel/trace v1.18.0 h1:NY+czwbHbmndxojTEKiSMHkG2ClNH2PwmcHrdo0JY10= go.opentelemetry.io/otel/trace v1.18.0/go.mod h1:T2+SGJGuYZY3bjj5rgh/hN7KIrlpWC5nS8Mjvzckz+0= go.uber.org/goleak v1.2.0 h1:xqgm/S+aQvhWFTtR0XK3Jvg7z8kGV8P4X14IzwN3Eqk= @@ -496,8 +482,6 @@ golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u0 golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM= golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU= -golang.org/x/exp v0.0.0-20230801115018-d63ba01acd4b h1:r+vk0EmXNmekl0S0BascoeeoHk/L7wmaW2QF90K+kYI= -golang.org/x/exp v0.0.0-20230801115018-d63ba01acd4b/go.mod h1:FXUEEKJgO7OQYeo8N01OfiKP8RXMtf6e8aTskBGqWdc= golang.org/x/exp v0.0.0-20230905200255-921286631fa9 h1:GoHiUyI/Tp2nVkLI2mCxVkOjsbSXD66ic0XW0js0R9g= golang.org/x/exp v0.0.0-20230905200255-921286631fa9/go.mod h1:S2oDrQGGwySpoQPVqRShND87VCbxmc6bL1Yd2oYrm6k= golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= @@ -825,6 +809,8 @@ gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gotest.tools/v3 v3.5.1 h1:EENdUnS3pdur5nybKYIh2Vfgc8IUNBjxDPSjtiJcOzU= +gotest.tools/v3 v3.5.1/go.mod h1:isy3WKz7GK6uNw/sbHzfKBLvlvXwUyV06n6brMxxopU= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=