correctly attach store/provider flags (#4391)

corrects the storage and provider flag positioning to attach to the child command instead of the parent. Also corrects unit tests for flags to ensure flags are preset as expected.

---

#### Does this PR need a docs update or release note?

- [x] ⛔ No

#### Type of change

- [x] 🐛 Bugfix

#### Test Plan

- [x] ⚡ Unit test
- [x] 💚 E2E

src/cli/backup/backup.go

@@ -48,12 +48,12 @@ func AddCommands(cmd *cobra.Command) {
 
 	for _, sc := range subCommandFuncs {
 		subCommand := sc()
-		flags.AddAllProviderFlags(subCommand)
-		flags.AddAllStorageFlags(subCommand)
 		backupC.AddCommand(subCommand)
 
 		for _, addBackupTo := range serviceCommands {
-			addBackupTo(subCommand)
+			sc := addBackupTo(subCommand)
+			flags.AddAllProviderFlags(sc)
+			flags.AddAllStorageFlags(sc)
 		}
 	}
 }

src/cli/backup/exchange_test.go

@@ -1,7 +1,6 @@
 package backup
 
 import (
-	"bytes"
 	"fmt"
 	"strconv"
 	"testing"
@@ -14,6 +13,7 @@ import (
 
 	"github.com/alcionai/corso/src/cli/flags"
 	flagsTD "github.com/alcionai/corso/src/cli/flags/testdata"
+	cliTD "github.com/alcionai/corso/src/cli/testdata"
 	"github.com/alcionai/corso/src/cli/utils"
 	utilsTD "github.com/alcionai/corso/src/cli/utils/testdata"
 	"github.com/alcionai/corso/src/internal/tester"
@@ -92,36 +92,20 @@ func (suite *ExchangeUnitSuite) TestAddExchangeCommands() {
 func (suite *ExchangeUnitSuite) TestBackupCreateFlags() {
 	t := suite.T()
 
-	cmd := &cobra.Command{Use: createCommand}
+	cmd := cliTD.SetUpCmdHasFlags(
-
+		t,
-	// persistent flags not added by addCommands
+		&cobra.Command{Use: createCommand},
-	flags.AddRunModeFlag(cmd, true)
+		addExchangeCommands,
-
+		[]cliTD.UseCobraCommandFn{
-	c := addExchangeCommands(cmd)
+			flags.AddAllProviderFlags,
-	require.NotNil(t, c)
+			flags.AddAllStorageFlags,
-
+		},
-	// 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,
 
@@ -132,36 +116,22 @@ func (suite *ExchangeUnitSuite) TestBackupCreateFlags() {
 				"--" + flags.DisableDeltaFN,
 				"--" + flags.EnableImmutableIDFN,
 				"--" + flags.DisableConcurrencyLimiterFN,
-	}
+			},
-
+			flagsTD.PreparedProviderFlags(),
-	args = append(args, flagsTD.PreparedProviderFlags()...)
+			flagsTD.PreparedStorageFlags()))
-	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)
 }
@@ -169,36 +139,25 @@ func (suite *ExchangeUnitSuite) TestBackupCreateFlags() {
 func (suite *ExchangeUnitSuite) TestBackupListFlags() {
 	t := suite.T()
 
-	cmd := &cobra.Command{Use: listCommand}
+	cmd := cliTD.SetUpCmdHasFlags(
-
+		t,
-	// persistent flags not added by addCommands
+		&cobra.Command{Use: listCommand},
-	flags.AddRunModeFlag(cmd, true)
+		addExchangeCommands,
-
+		[]cliTD.UseCobraCommandFn{
-	c := addExchangeCommands(cmd)
+			flags.AddAllProviderFlags,
-	require.NotNil(t, c)
+			flags.AddAllStorageFlags,
-
+		},
-	// non-persistent flags not added by addCommands
-	flags.AddAllProviderFlags(c)
-	flags.AddAllStorageFlags(c)
-
 		flagsTD.WithFlags(
-		cmd,
+			exchangeServiceCommand,
-		exchangeServiceCommand, []string{
+			[]string{
 				"--" + flags.RunModeFN, flags.RunModeFlagTest,
 				"--" + flags.BackupFN, flagsTD.BackupInput,
 			},
 			flagsTD.PreparedBackupListFlags(),
 			flagsTD.PreparedProviderFlags(),
-		flagsTD.PreparedStorageFlags())
+			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)
@@ -207,20 +166,15 @@ func (suite *ExchangeUnitSuite) TestBackupListFlags() {
 func (suite *ExchangeUnitSuite) TestBackupDetailsFlags() {
 	t := suite.T()
 
-	cmd := &cobra.Command{Use: detailsCommand}
+	cmd := cliTD.SetUpCmdHasFlags(
-
+		t,
-	// persistent flags not added by addCommands
+		&cobra.Command{Use: detailsCommand},
-	flags.AddRunModeFlag(cmd, true)
+		addExchangeCommands,
-
+		[]cliTD.UseCobraCommandFn{
-	c := addExchangeCommands(cmd)
+			flags.AddAllProviderFlags,
-	require.NotNil(t, c)
+			flags.AddAllStorageFlags,
-
+		},
-	// non-persistent flags not added by addCommands
-	flags.AddAllProviderFlags(c)
-	flags.AddAllStorageFlags(c)
-
 		flagsTD.WithFlags(
-		cmd,
 			exchangeServiceCommand,
 			[]string{
 				"--" + flags.RunModeFN, flags.RunModeFlagTest,
@@ -228,20 +182,12 @@ func (suite *ExchangeUnitSuite) TestBackupDetailsFlags() {
 				"--" + flags.SkipReduceFN,
 			},
 			flagsTD.PreparedProviderFlags(),
-		flagsTD.PreparedStorageFlags())
+			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)
 }
@@ -249,36 +195,24 @@ func (suite *ExchangeUnitSuite) TestBackupDetailsFlags() {
 func (suite *ExchangeUnitSuite) TestBackupDeleteFlags() {
 	t := suite.T()
 
-	cmd := &cobra.Command{Use: deleteCommand}
+	cmd := cliTD.SetUpCmdHasFlags(
-
+		t,
-	// persistent flags not added by addCommands
+		&cobra.Command{Use: deleteCommand},
-	flags.AddRunModeFlag(cmd, true)
+		addExchangeCommands,
-
+		[]cliTD.UseCobraCommandFn{
-	c := addExchangeCommands(cmd)
+			flags.AddAllProviderFlags,
-	require.NotNil(t, c)
+			flags.AddAllStorageFlags,
-
+		},
-	// 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())
+			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)
 }

src/cli/backup/groups_test.go

@@ -1,7 +1,6 @@
 package backup
 
 import (
-	"bytes"
 	"strconv"
 	"testing"
 
@@ -13,6 +12,7 @@ import (
 
 	"github.com/alcionai/corso/src/cli/flags"
 	flagsTD "github.com/alcionai/corso/src/cli/flags/testdata"
+	cliTD "github.com/alcionai/corso/src/cli/testdata"
 	"github.com/alcionai/corso/src/cli/utils"
 	"github.com/alcionai/corso/src/internal/tester"
 	"github.com/alcionai/corso/src/pkg/control"
@@ -128,70 +128,38 @@ func (suite *GroupsUnitSuite) TestValidateGroupsBackupCreateFlags() {
 func (suite *GroupsUnitSuite) TestBackupCreateFlags() {
 	t := suite.T()
 
-	cmd := &cobra.Command{Use: createCommand}
+	cmd := cliTD.SetUpCmdHasFlags(
-
+		t,
-	// persistent flags not added by addCommands
+		&cobra.Command{Use: createCommand},
-	flags.AddRunModeFlag(cmd, true)
+		addGroupsCommands,
-
+		[]cliTD.UseCobraCommandFn{
-	c := addGroupsCommands(cmd)
+			flags.AddAllProviderFlags,
-	require.NotNil(t, c)
+			flags.AddAllStorageFlags,
-
+		},
-	// 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,
-	}
+			},
-
+			flagsTD.PreparedProviderFlags(),
-	args = append(args, flagsTD.PreparedProviderFlags()...)
+			flagsTD.PreparedStorageFlags()))
-	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)
 }
@@ -199,20 +167,15 @@ func (suite *GroupsUnitSuite) TestBackupCreateFlags() {
 func (suite *GroupsUnitSuite) TestBackupListFlags() {
 	t := suite.T()
 
-	cmd := &cobra.Command{Use: listCommand}
+	cmd := cliTD.SetUpCmdHasFlags(
-
+		t,
-	// persistent flags not added by addCommands
+		&cobra.Command{Use: listCommand},
-	flags.AddRunModeFlag(cmd, true)
+		addGroupsCommands,
-
+		[]cliTD.UseCobraCommandFn{
-	c := addGroupsCommands(cmd)
+			flags.AddAllProviderFlags,
-	require.NotNil(t, c)
+			flags.AddAllStorageFlags,
-
+		},
-	// non-persistent flags not added by addCommands
-	flags.AddAllProviderFlags(c)
-	flags.AddAllStorageFlags(c)
-
 		flagsTD.WithFlags(
-		cmd,
 			groupsServiceCommand,
 			[]string{
 				"--" + flags.RunModeFN, flags.RunModeFlagTest,
@@ -220,16 +183,9 @@ func (suite *GroupsUnitSuite) TestBackupListFlags() {
 			},
 			flagsTD.PreparedBackupListFlags(),
 			flagsTD.PreparedProviderFlags(),
-		flagsTD.PreparedStorageFlags())
+			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)
@@ -238,20 +194,15 @@ func (suite *GroupsUnitSuite) TestBackupListFlags() {
 func (suite *GroupsUnitSuite) TestBackupDetailsFlags() {
 	t := suite.T()
 
-	cmd := &cobra.Command{Use: detailsCommand}
+	cmd := cliTD.SetUpCmdHasFlags(
-
+		t,
-	// persistent flags not added by addCommands
+		&cobra.Command{Use: detailsCommand},
-	flags.AddRunModeFlag(cmd, true)
+		addGroupsCommands,
-
+		[]cliTD.UseCobraCommandFn{
-	c := addGroupsCommands(cmd)
+			flags.AddAllProviderFlags,
-	require.NotNil(t, c)
+			flags.AddAllStorageFlags,
-
+		},
-	// non-persistent flags not added by addCommands
-	flags.AddAllProviderFlags(c)
-	flags.AddAllStorageFlags(c)
-
 		flagsTD.WithFlags(
-		cmd,
 			groupsServiceCommand,
 			[]string{
 				"--" + flags.RunModeFN, flags.RunModeFlagTest,
@@ -259,20 +210,12 @@ func (suite *GroupsUnitSuite) TestBackupDetailsFlags() {
 				"--" + flags.SkipReduceFN,
 			},
 			flagsTD.PreparedProviderFlags(),
-		flagsTD.PreparedStorageFlags())
+			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)
 }
@@ -280,48 +223,24 @@ func (suite *GroupsUnitSuite) TestBackupDetailsFlags() {
 func (suite *GroupsUnitSuite) TestBackupDeleteFlags() {
 	t := suite.T()
 
-	cmd := &cobra.Command{Use: deleteCommand}
+	cmd := cliTD.SetUpCmdHasFlags(
-
+		t,
-	// persistent flags not added by addCommands
+		&cobra.Command{Use: deleteCommand},
-	flags.AddRunModeFlag(cmd, true)
+		addGroupsCommands,
-
+		[]cliTD.UseCobraCommandFn{
-	c := addGroupsCommands(cmd)
+			flags.AddAllProviderFlags,
-	require.NotNil(t, c)
+			flags.AddAllStorageFlags,
-
+		},
-	// 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())
+			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)
 }

src/cli/backup/onedrive_test.go

@@ -1,7 +1,6 @@
 package backup
 
 import (
-	"bytes"
 	"fmt"
 	"testing"
 
@@ -13,6 +12,7 @@ import (
 
 	"github.com/alcionai/corso/src/cli/flags"
 	flagsTD "github.com/alcionai/corso/src/cli/flags/testdata"
+	cliTD "github.com/alcionai/corso/src/cli/testdata"
 	"github.com/alcionai/corso/src/cli/utils"
 	utilsTD "github.com/alcionai/corso/src/cli/utils/testdata"
 	"github.com/alcionai/corso/src/internal/tester"
@@ -92,20 +92,15 @@ func (suite *OneDriveUnitSuite) TestAddOneDriveCommands() {
 func (suite *OneDriveUnitSuite) TestBackupCreateFlags() {
 	t := suite.T()
 
-	cmd := &cobra.Command{Use: createCommand}
+	cmd := cliTD.SetUpCmdHasFlags(
-
+		t,
-	// persistent flags not added by addCommands
+		&cobra.Command{Use: createCommand},
-	flags.AddRunModeFlag(cmd, true)
+		addOneDriveCommands,
-
+		[]cliTD.UseCobraCommandFn{
-	c := addOneDriveCommands(cmd)
+			flags.AddAllProviderFlags,
-	require.NotNil(t, c)
+			flags.AddAllStorageFlags,
-
+		},
-	// non-persistent flags not added by addCommands
-	flags.AddAllProviderFlags(c)
-	flags.AddAllStorageFlags(c)
-
 		flagsTD.WithFlags(
-		cmd,
 			oneDriveServiceCommand,
 			[]string{
 				"--" + flags.RunModeFN, flags.RunModeFlagTest,
@@ -115,25 +110,15 @@ func (suite *OneDriveUnitSuite) TestBackupCreateFlags() {
 				"--" + flags.ForceItemDataDownloadFN,
 			},
 			flagsTD.PreparedProviderFlags(),
-		flagsTD.PreparedStorageFlags())
+			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)
 }
@@ -141,20 +126,15 @@ func (suite *OneDriveUnitSuite) TestBackupCreateFlags() {
 func (suite *OneDriveUnitSuite) TestBackupListFlags() {
 	t := suite.T()
 
-	cmd := &cobra.Command{Use: listCommand}
+	cmd := cliTD.SetUpCmdHasFlags(
-
+		t,
-	// persistent flags not added by addCommands
+		&cobra.Command{Use: listCommand},
-	flags.AddRunModeFlag(cmd, true)
+		addOneDriveCommands,
-
+		[]cliTD.UseCobraCommandFn{
-	c := addOneDriveCommands(cmd)
+			flags.AddAllProviderFlags,
-	require.NotNil(t, c)
+			flags.AddAllStorageFlags,
-
+		},
-	// non-persistent flags not added by addCommands
-	flags.AddAllProviderFlags(c)
-	flags.AddAllStorageFlags(c)
-
 		flagsTD.WithFlags(
-		cmd,
 			oneDriveServiceCommand,
 			[]string{
 				"--" + flags.RunModeFN, flags.RunModeFlagTest,
@@ -162,16 +142,9 @@ func (suite *OneDriveUnitSuite) TestBackupListFlags() {
 			},
 			flagsTD.PreparedBackupListFlags(),
 			flagsTD.PreparedProviderFlags(),
-		flagsTD.PreparedStorageFlags())
+			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)
@@ -180,20 +153,15 @@ func (suite *OneDriveUnitSuite) TestBackupListFlags() {
 func (suite *OneDriveUnitSuite) TestBackupDetailsFlags() {
 	t := suite.T()
 
-	cmd := &cobra.Command{Use: detailsCommand}
+	cmd := cliTD.SetUpCmdHasFlags(
-
+		t,
-	// persistent flags not added by addCommands
+		&cobra.Command{Use: detailsCommand},
-	flags.AddRunModeFlag(cmd, true)
+		addOneDriveCommands,
-
+		[]cliTD.UseCobraCommandFn{
-	c := addOneDriveCommands(cmd)
+			flags.AddAllProviderFlags,
-	require.NotNil(t, c)
+			flags.AddAllStorageFlags,
-
+		},
-	// non-persistent flags not added by addCommands
-	flags.AddAllProviderFlags(c)
-	flags.AddAllStorageFlags(c)
-
 		flagsTD.WithFlags(
-		cmd,
 			oneDriveServiceCommand,
 			[]string{
 				"--" + flags.RunModeFN, flags.RunModeFlagTest,
@@ -201,20 +169,12 @@ func (suite *OneDriveUnitSuite) TestBackupDetailsFlags() {
 				"--" + flags.SkipReduceFN,
 			},
 			flagsTD.PreparedProviderFlags(),
-		flagsTD.PreparedStorageFlags())
+			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)
-
+	assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV)
 	flagsTD.AssertProviderFlags(t, cmd)
 	flagsTD.AssertStorageFlags(t, cmd)
 }
@@ -222,36 +182,24 @@ func (suite *OneDriveUnitSuite) TestBackupDetailsFlags() {
 func (suite *OneDriveUnitSuite) TestBackupDeleteFlags() {
 	t := suite.T()
 
-	cmd := &cobra.Command{Use: deleteCommand}
+	cmd := cliTD.SetUpCmdHasFlags(
-
+		t,
-	// persistent flags not added by addCommands
+		&cobra.Command{Use: deleteCommand},
-	flags.AddRunModeFlag(cmd, true)
+		addOneDriveCommands,
-
+		[]cliTD.UseCobraCommandFn{
-	c := addOneDriveCommands(cmd)
+			flags.AddAllProviderFlags,
-	require.NotNil(t, c)
+			flags.AddAllStorageFlags,
-
+		},
-	// 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())
+			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)
 }

src/cli/backup/sharepoint_test.go

@@ -1,7 +1,6 @@
 package backup
 
 import (
-	"bytes"
 	"fmt"
 	"strings"
 	"testing"
@@ -14,6 +13,7 @@ import (
 
 	"github.com/alcionai/corso/src/cli/flags"
 	flagsTD "github.com/alcionai/corso/src/cli/flags/testdata"
+	cliTD "github.com/alcionai/corso/src/cli/testdata"
 	"github.com/alcionai/corso/src/cli/utils"
 	utilsTD "github.com/alcionai/corso/src/cli/utils/testdata"
 	"github.com/alcionai/corso/src/internal/common/idname"
@@ -94,20 +94,15 @@ func (suite *SharePointUnitSuite) TestAddSharePointCommands() {
 func (suite *SharePointUnitSuite) TestBackupCreateFlags() {
 	t := suite.T()
 
-	cmd := &cobra.Command{Use: createCommand}
+	cmd := cliTD.SetUpCmdHasFlags(
-
+		t,
-	// persistent flags not added by addCommands
+		&cobra.Command{Use: createCommand},
-	flags.AddRunModeFlag(cmd, true)
+		addSharePointCommands,
-
+		[]cliTD.UseCobraCommandFn{
-	c := addSharePointCommands(cmd)
+			flags.AddAllProviderFlags,
-	require.NotNil(t, c)
+			flags.AddAllStorageFlags,
-
+		},
-	// non-persistent flags not added by addCommands
-	flags.AddAllProviderFlags(c)
-	flags.AddAllStorageFlags(c)
-
 		flagsTD.WithFlags(
-		cmd,
 			sharePointServiceCommand,
 			[]string{
 				"--" + flags.RunModeFN, flags.RunModeFlagTest,
@@ -119,26 +114,16 @@ func (suite *SharePointUnitSuite) TestBackupCreateFlags() {
 				"--" + flags.ForceItemDataDownloadFN,
 			},
 			flagsTD.PreparedProviderFlags(),
-		flagsTD.PreparedStorageFlags())
+			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)
 }
@@ -146,20 +131,15 @@ func (suite *SharePointUnitSuite) TestBackupCreateFlags() {
 func (suite *SharePointUnitSuite) TestBackupListFlags() {
 	t := suite.T()
 
-	cmd := &cobra.Command{Use: listCommand}
+	cmd := cliTD.SetUpCmdHasFlags(
-
+		t,
-	// persistent flags not added by addCommands
+		&cobra.Command{Use: listCommand},
-	flags.AddRunModeFlag(cmd, true)
+		addSharePointCommands,
-
+		[]cliTD.UseCobraCommandFn{
-	c := addSharePointCommands(cmd)
+			flags.AddAllProviderFlags,
-	require.NotNil(t, c)
+			flags.AddAllStorageFlags,
-
+		},
-	// non-persistent flags not added by addCommands
-	flags.AddAllProviderFlags(c)
-	flags.AddAllStorageFlags(c)
-
 		flagsTD.WithFlags(
-		cmd,
 			sharePointServiceCommand,
 			[]string{
 				"--" + flags.RunModeFN, flags.RunModeFlagTest,
@@ -167,16 +147,9 @@ func (suite *SharePointUnitSuite) TestBackupListFlags() {
 			},
 			flagsTD.PreparedBackupListFlags(),
 			flagsTD.PreparedProviderFlags(),
-		flagsTD.PreparedStorageFlags())
+			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)
@@ -185,20 +158,15 @@ func (suite *SharePointUnitSuite) TestBackupListFlags() {
 func (suite *SharePointUnitSuite) TestBackupDetailsFlags() {
 	t := suite.T()
 
-	cmd := &cobra.Command{Use: detailsCommand}
+	cmd := cliTD.SetUpCmdHasFlags(
-
+		t,
-	// persistent flags not added by addCommands
+		&cobra.Command{Use: detailsCommand},
-	flags.AddRunModeFlag(cmd, true)
+		addSharePointCommands,
-
+		[]cliTD.UseCobraCommandFn{
-	c := addSharePointCommands(cmd)
+			flags.AddAllProviderFlags,
-	require.NotNil(t, c)
+			flags.AddAllStorageFlags,
-
+		},
-	// non-persistent flags not added by addCommands
-	flags.AddAllProviderFlags(c)
-	flags.AddAllStorageFlags(c)
-
 		flagsTD.WithFlags(
-		cmd,
 			sharePointServiceCommand,
 			[]string{
 				"--" + flags.RunModeFN, flags.RunModeFlagTest,
@@ -206,20 +174,12 @@ func (suite *SharePointUnitSuite) TestBackupDetailsFlags() {
 				"--" + flags.SkipReduceFN,
 			},
 			flagsTD.PreparedProviderFlags(),
-		flagsTD.PreparedStorageFlags())
+			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)
 }
@@ -227,36 +187,24 @@ func (suite *SharePointUnitSuite) TestBackupDetailsFlags() {
 func (suite *SharePointUnitSuite) TestBackupDeleteFlags() {
 	t := suite.T()
 
-	cmd := &cobra.Command{Use: deleteCommand}
+	cmd := cliTD.SetUpCmdHasFlags(
-
+		t,
-	// persistent flags not added by addCommands
+		&cobra.Command{Use: deleteCommand},
-	flags.AddRunModeFlag(cmd, true)
+		addSharePointCommands,
-
+		[]cliTD.UseCobraCommandFn{
-	c := addSharePointCommands(cmd)
+			flags.AddAllProviderFlags,
-	require.NotNil(t, c)
+			flags.AddAllStorageFlags,
-
+		},
-	// 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())
+			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)
 }

src/cli/export/export.go

@@ -27,11 +27,11 @@ var exportCommands = []func(cmd *cobra.Command) *cobra.Command{
 // AddCommands attaches all `corso export * *` commands to the parent.
 func AddCommands(cmd *cobra.Command) {
 	subCommand := exportCmd()
-	flags.AddAllStorageFlags(subCommand)
 	cmd.AddCommand(subCommand)
 
 	for _, addExportTo := range exportCommands {
-		addExportTo(subCommand)
+		sc := addExportTo(subCommand)
+		flags.AddAllStorageFlags(sc)
 	}
 }
 

src/cli/export/groups_test.go

@@ -1,17 +1,15 @@
 package export
 
 import (
-	"bytes"
 	"testing"
 
-	"github.com/alcionai/clues"
 	"github.com/spf13/cobra"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
 
 	"github.com/alcionai/corso/src/cli/flags"
 	flagsTD "github.com/alcionai/corso/src/cli/flags/testdata"
+	cliTD "github.com/alcionai/corso/src/cli/testdata"
 	"github.com/alcionai/corso/src/cli/utils"
 	"github.com/alcionai/corso/src/internal/tester"
 )
@@ -39,55 +37,41 @@ func (suite *GroupsUnitSuite) TestAddGroupsCommands() {
 	for _, test := range table {
 		suite.Run(test.name, func() {
 			t := suite.T()
+			parent := &cobra.Command{Use: exportCommand}
 
-			cmd := &cobra.Command{Use: test.use}
+			cmd := cliTD.SetUpCmdHasFlags(
-
+				t,
-			// persistent flags not added by addCommands
+				parent,
-			flags.AddRunModeFlag(cmd, true)
+				addGroupsCommands,
-
+				[]cliTD.UseCobraCommandFn{
-			c := addGroupsCommands(cmd)
+					flags.AddAllProviderFlags,
-			require.NotNil(t, c)
+					flags.AddAllStorageFlags,
-
+				},
-			// non-persistent flags not added by addCommands
-			flags.AddAllProviderFlags(c)
-			flags.AddAllStorageFlags(c)
-
-			cmds := cmd.Commands()
-			require.Len(t, cmds, 1)
-
-			child := cmds[0]
-			assert.Equal(t, test.expectUse, child.Use)
-			assert.Equal(t, test.expectShort, child.Short)
-			tester.AreSameFunc(t, test.expectRunE, child.RunE)
-
 				flagsTD.WithFlags(
-				cmd,
 					groupsServiceCommand,
 					[]string{
 						flagsTD.RestoreDestination,
 						"--" + flags.RunModeFN, flags.RunModeFlagTest,
 						"--" + flags.BackupFN, flagsTD.BackupInput,
-
 						"--" + flags.FormatFN, flagsTD.FormatType,
-
-					// bool flags
 						"--" + flags.ArchiveFN,
 					},
 					flagsTD.PreparedProviderFlags(),
-				flagsTD.PreparedStorageFlags())
+					flagsTD.PreparedStorageFlags()))
 
-			cmd.SetOut(new(bytes.Buffer)) // drop output
+			cliTD.CheckCmdChild(
-			cmd.SetErr(new(bytes.Buffer)) // drop output
+				t,
-
+				parent,
-			err := cmd.Execute()
+				3,
-			assert.NoError(t, err, clues.ToCore(err))
+				test.expectUse,
+				test.expectShort,
+				test.expectRunE)
 
 			opts := utils.MakeGroupsOpts(cmd)
-			assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV)
 
+			assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV)
 			assert.Equal(t, flagsTD.Archive, opts.ExportCfg.Archive)
 			assert.Equal(t, flagsTD.FormatType, opts.ExportCfg.Format)
-
 			flagsTD.AssertStorageFlags(t, cmd)
 		})
 	}

src/cli/export/onedrive_test.go

@@ -1,17 +1,15 @@
 package export
 
 import (
-	"bytes"
 	"testing"
 
-	"github.com/alcionai/clues"
 	"github.com/spf13/cobra"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
 
 	"github.com/alcionai/corso/src/cli/flags"
 	flagsTD "github.com/alcionai/corso/src/cli/flags/testdata"
+	cliTD "github.com/alcionai/corso/src/cli/testdata"
 	"github.com/alcionai/corso/src/cli/utils"
 	"github.com/alcionai/corso/src/internal/tester"
 )
@@ -39,29 +37,17 @@ func (suite *OneDriveUnitSuite) TestAddOneDriveCommands() {
 	for _, test := range table {
 		suite.Run(test.name, func() {
 			t := suite.T()
+			parent := &cobra.Command{Use: exportCommand}
 
-			cmd := &cobra.Command{Use: test.use}
+			cmd := cliTD.SetUpCmdHasFlags(
-
+				t,
-			// persistent flags not added by addCommands
+				parent,
-			flags.AddRunModeFlag(cmd, true)
+				addOneDriveCommands,
-
+				[]cliTD.UseCobraCommandFn{
-			c := addOneDriveCommands(cmd)
+					flags.AddAllProviderFlags,
-			require.NotNil(t, c)
+					flags.AddAllStorageFlags,
-
+				},
-			// non-persistent flags not added by addCommands
-			flags.AddAllProviderFlags(c)
-			flags.AddAllStorageFlags(c)
-
-			cmds := cmd.Commands()
-			require.Len(t, cmds, 1)
-
-			child := cmds[0]
-			assert.Equal(t, test.expectUse, child.Use)
-			assert.Equal(t, test.expectShort, child.Short)
-			tester.AreSameFunc(t, test.expectRunE, child.RunE)
-
 				flagsTD.WithFlags(
-				cmd,
 					oneDriveServiceCommand,
 					[]string{
 						flagsTD.RestoreDestination,
@@ -80,26 +66,26 @@ func (suite *OneDriveUnitSuite) TestAddOneDriveCommands() {
 						"--" + flags.ArchiveFN,
 					},
 					flagsTD.PreparedProviderFlags(),
-				flagsTD.PreparedStorageFlags())
+					flagsTD.PreparedStorageFlags()))
 
-			cmd.SetOut(new(bytes.Buffer)) // drop output
+			cliTD.CheckCmdChild(
-			cmd.SetErr(new(bytes.Buffer)) // drop output
+				t,
-
+				parent,
-			err := cmd.Execute()
+				3,
-			assert.NoError(t, err, clues.ToCore(err))
+				test.expectUse,
+				test.expectShort,
+				test.expectRunE)
 
 			opts := utils.MakeOneDriveOpts(cmd)
-			assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV)
 
+			assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV)
 			assert.ElementsMatch(t, flagsTD.FileNameInput, opts.FileName)
 			assert.ElementsMatch(t, flagsTD.FolderPathInput, opts.FolderPath)
 			assert.Equal(t, flagsTD.FileCreatedAfterInput, opts.FileCreatedAfter)
 			assert.Equal(t, flagsTD.FileCreatedBeforeInput, opts.FileCreatedBefore)
 			assert.Equal(t, flagsTD.FileModifiedAfterInput, opts.FileModifiedAfter)
 			assert.Equal(t, flagsTD.FileModifiedBeforeInput, opts.FileModifiedBefore)
-
 			assert.Equal(t, flagsTD.CorsoPassphrase, flags.CorsoPassphraseFV)
-
 			flagsTD.AssertStorageFlags(t, cmd)
 		})
 	}

src/cli/export/sharepoint_test.go

@@ -1,17 +1,15 @@
 package export
 
 import (
-	"bytes"
 	"testing"
 
-	"github.com/alcionai/clues"
 	"github.com/spf13/cobra"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
 
 	"github.com/alcionai/corso/src/cli/flags"
 	flagsTD "github.com/alcionai/corso/src/cli/flags/testdata"
+	cliTD "github.com/alcionai/corso/src/cli/testdata"
 	"github.com/alcionai/corso/src/cli/utils"
 	"github.com/alcionai/corso/src/internal/tester"
 )
@@ -39,29 +37,17 @@ func (suite *SharePointUnitSuite) TestAddSharePointCommands() {
 	for _, test := range table {
 		suite.Run(test.name, func() {
 			t := suite.T()
+			parent := &cobra.Command{Use: exportCommand}
 
-			cmd := &cobra.Command{Use: test.use}
+			cmd := cliTD.SetUpCmdHasFlags(
-
+				t,
-			// persistent flags not added by addCommands
+				parent,
-			flags.AddRunModeFlag(cmd, true)
+				addSharePointCommands,
-
+				[]cliTD.UseCobraCommandFn{
-			c := addSharePointCommands(cmd)
+					flags.AddAllProviderFlags,
-			require.NotNil(t, c)
+					flags.AddAllStorageFlags,
-
+				},
-			// non-persistent flags not added by addCommands
-			flags.AddAllProviderFlags(c)
-			flags.AddAllStorageFlags(c)
-
-			cmds := cmd.Commands()
-			require.Len(t, cmds, 1)
-
-			child := cmds[0]
-			assert.Equal(t, test.expectUse, child.Use)
-			assert.Equal(t, test.expectShort, child.Short)
-			tester.AreSameFunc(t, test.expectRunE, child.RunE)
-
 				flagsTD.WithFlags(
-				cmd,
 					sharePointServiceCommand,
 					[]string{
 						flagsTD.RestoreDestination,
@@ -78,24 +64,23 @@ func (suite *SharePointUnitSuite) TestAddSharePointCommands() {
 						"--" + flags.ListFolderFN, flagsTD.FlgInputs(flagsTD.ListFolderInput),
 						"--" + flags.PageFN, flagsTD.FlgInputs(flagsTD.PageInput),
 						"--" + flags.PageFolderFN, flagsTD.FlgInputs(flagsTD.PageFolderInput),
-
 						"--" + flags.FormatFN, flagsTD.FormatType,
-
-					// bool flags
 						"--" + flags.ArchiveFN,
 					},
 					flagsTD.PreparedProviderFlags(),
-				flagsTD.PreparedStorageFlags())
+					flagsTD.PreparedStorageFlags()))
 
-			cmd.SetOut(new(bytes.Buffer)) // drop output
+			cliTD.CheckCmdChild(
-			cmd.SetErr(new(bytes.Buffer)) // drop output
+				t,
-
+				parent,
-			err := cmd.Execute()
+				3,
-			assert.NoError(t, err, clues.ToCore(err))
+				test.expectUse,
+				test.expectShort,
+				test.expectRunE)
 
 			opts := utils.MakeSharePointOpts(cmd)
-			assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV)
 
+			assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV)
 			assert.Equal(t, flagsTD.LibraryInput, opts.Library)
 			assert.ElementsMatch(t, flagsTD.FileNameInput, opts.FileName)
 			assert.ElementsMatch(t, flagsTD.FolderPathInput, opts.FolderPath)
@@ -103,16 +88,12 @@ func (suite *SharePointUnitSuite) TestAddSharePointCommands() {
 			assert.Equal(t, flagsTD.FileCreatedBeforeInput, opts.FileCreatedBefore)
 			assert.Equal(t, flagsTD.FileModifiedAfterInput, opts.FileModifiedAfter)
 			assert.Equal(t, flagsTD.FileModifiedBeforeInput, opts.FileModifiedBefore)
-
 			assert.ElementsMatch(t, flagsTD.ListItemInput, opts.ListItem)
 			assert.ElementsMatch(t, flagsTD.ListFolderInput, opts.ListFolder)
-
 			assert.ElementsMatch(t, flagsTD.PageInput, opts.Page)
 			assert.ElementsMatch(t, flagsTD.PageFolderInput, opts.PageFolder)
-
 			assert.Equal(t, flagsTD.Archive, opts.ExportCfg.Archive)
 			assert.Equal(t, flagsTD.FormatType, opts.ExportCfg.Format)
-
 			flagsTD.AssertStorageFlags(t, cmd)
 		})
 	}

src/cli/flags/testdata/flags.go

@@ -86,7 +86,7 @@ var (
 	DisableConcurrencyLimiter = true
 )
 
-func WithFlags(
+func WithFlags2(
 	cc *cobra.Command,
 	command string,
 	flagSets ...[]string,
@@ -99,3 +99,18 @@ func WithFlags(
 
 	cc.SetArgs(args)
 }
+
+func WithFlags(
+	command string,
+	flagSets ...[]string,
+) func(*cobra.Command) {
+	return func(cc *cobra.Command) {
+		args := []string{command}
+
+		for _, sl := range flagSets {
+			args = append(args, sl...)
+		}
+
+		cc.SetArgs(args)
+	}
+}

src/cli/restore/exchange_test.go

@@ -1,17 +1,15 @@
 package restore
 
 import (
-	"bytes"
 	"testing"
 
-	"github.com/alcionai/clues"
 	"github.com/spf13/cobra"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
 
 	"github.com/alcionai/corso/src/cli/flags"
 	flagsTD "github.com/alcionai/corso/src/cli/flags/testdata"
+	cliTD "github.com/alcionai/corso/src/cli/testdata"
 	"github.com/alcionai/corso/src/cli/utils"
 	"github.com/alcionai/corso/src/internal/tester"
 )
@@ -39,45 +37,30 @@ func (suite *ExchangeUnitSuite) TestAddExchangeCommands() {
 	for _, test := range table {
 		suite.Run(test.name, func() {
 			t := suite.T()
+			parent := &cobra.Command{Use: restoreCommand}
 
-			cmd := &cobra.Command{Use: test.use}
+			cmd := cliTD.SetUpCmdHasFlags(
-
+				t,
-			// persistent flags not added by addCommands
+				parent,
-			flags.AddRunModeFlag(cmd, true)
+				addExchangeCommands,
-
+				[]cliTD.UseCobraCommandFn{
-			c := addExchangeCommands(cmd)
+					flags.AddAllProviderFlags,
-			require.NotNil(t, c)
+					flags.AddAllStorageFlags,
-
+				},
-			// non-persistent flags not added by addCommands
-			flags.AddAllProviderFlags(c)
-			flags.AddAllStorageFlags(c)
-
-			cmds := cmd.Commands()
-			require.Len(t, cmds, 1)
-
-			child := cmds[0]
-			assert.Equal(t, test.expectUse, child.Use)
-			assert.Equal(t, test.expectShort, child.Short)
-			tester.AreSameFunc(t, test.expectRunE, child.RunE)
-
 				flagsTD.WithFlags(
-				cmd,
 					exchangeServiceCommand,
 					[]string{
 						"--" + flags.RunModeFN, flags.RunModeFlagTest,
 						"--" + flags.BackupFN, flagsTD.BackupInput,
-
 						"--" + flags.ContactFN, flagsTD.FlgInputs(flagsTD.ContactInput),
 						"--" + flags.ContactFolderFN, flagsTD.FlgInputs(flagsTD.ContactFldInput),
 						"--" + flags.ContactNameFN, flagsTD.ContactNameInput,
-
 						"--" + flags.EmailFN, flagsTD.FlgInputs(flagsTD.EmailInput),
 						"--" + flags.EmailFolderFN, flagsTD.FlgInputs(flagsTD.EmailFldInput),
 						"--" + flags.EmailReceivedAfterFN, flagsTD.EmailReceivedAfterInput,
 						"--" + flags.EmailReceivedBeforeFN, flagsTD.EmailReceivedBeforeInput,
 						"--" + flags.EmailSenderFN, flagsTD.EmailSenderInput,
 						"--" + flags.EmailSubjectFN, flagsTD.EmailSubjectInput,
-
 						"--" + flags.EventFN, flagsTD.FlgInputs(flagsTD.EventInput),
 						"--" + flags.EventCalendarFN, flagsTD.FlgInputs(flagsTD.EventCalInput),
 						"--" + flags.EventOrganizerFN, flagsTD.EventOrganizerInput,
@@ -85,34 +68,33 @@ func (suite *ExchangeUnitSuite) TestAddExchangeCommands() {
 						"--" + flags.EventStartsAfterFN, flagsTD.EventStartsAfterInput,
 						"--" + flags.EventStartsBeforeFN, flagsTD.EventStartsBeforeInput,
 						"--" + flags.EventSubjectFN, flagsTD.EventSubjectInput,
-
 						"--" + flags.CollisionsFN, flagsTD.Collisions,
 						"--" + flags.DestinationFN, flagsTD.Destination,
 						"--" + flags.ToResourceFN, flagsTD.ToResource,
 					},
 					flagsTD.PreparedProviderFlags(),
-				flagsTD.PreparedStorageFlags())
+					flagsTD.PreparedStorageFlags()))
 
-			cmd.SetOut(new(bytes.Buffer)) // drop output
+			cliTD.CheckCmdChild(
-			cmd.SetErr(new(bytes.Buffer)) // drop output
+				t,
-
+				parent,
-			err := cmd.Execute()
+				3,
-			assert.NoError(t, err, clues.ToCore(err))
+				test.expectUse,
+				test.expectShort,
+				test.expectRunE)
 
 			opts := utils.MakeExchangeOpts(cmd)
-			assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV)
 
+			assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV)
 			assert.ElementsMatch(t, flagsTD.ContactInput, opts.Contact)
 			assert.ElementsMatch(t, flagsTD.ContactFldInput, opts.ContactFolder)
 			assert.Equal(t, flagsTD.ContactNameInput, opts.ContactName)
-
 			assert.ElementsMatch(t, flagsTD.EmailInput, opts.Email)
 			assert.ElementsMatch(t, flagsTD.EmailFldInput, opts.EmailFolder)
 			assert.Equal(t, flagsTD.EmailReceivedAfterInput, opts.EmailReceivedAfter)
 			assert.Equal(t, flagsTD.EmailReceivedBeforeInput, opts.EmailReceivedBefore)
 			assert.Equal(t, flagsTD.EmailSenderInput, opts.EmailSender)
 			assert.Equal(t, flagsTD.EmailSubjectInput, opts.EmailSubject)
-
 			assert.ElementsMatch(t, flagsTD.EventInput, opts.Event)
 			assert.ElementsMatch(t, flagsTD.EventCalInput, opts.EventCalendar)
 			assert.Equal(t, flagsTD.EventOrganizerInput, opts.EventOrganizer)
@@ -120,11 +102,9 @@ func (suite *ExchangeUnitSuite) TestAddExchangeCommands() {
 			assert.Equal(t, flagsTD.EventStartsAfterInput, opts.EventStartsAfter)
 			assert.Equal(t, flagsTD.EventStartsBeforeInput, opts.EventStartsBefore)
 			assert.Equal(t, flagsTD.EventSubjectInput, opts.EventSubject)
-
 			assert.Equal(t, flagsTD.Collisions, opts.RestoreCfg.Collisions)
 			assert.Equal(t, flagsTD.Destination, opts.RestoreCfg.Destination)
 			assert.Equal(t, flagsTD.ToResource, opts.RestoreCfg.ProtectedResource)
-
 			flagsTD.AssertProviderFlags(t, cmd)
 			flagsTD.AssertStorageFlags(t, cmd)
 		})

src/cli/restore/groups_test.go

@@ -1,17 +1,15 @@
 package restore
 
 import (
-	"bytes"
 	"testing"
 
-	"github.com/alcionai/clues"
 	"github.com/spf13/cobra"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
 
 	"github.com/alcionai/corso/src/cli/flags"
 	flagsTD "github.com/alcionai/corso/src/cli/flags/testdata"
+	cliTD "github.com/alcionai/corso/src/cli/testdata"
 	"github.com/alcionai/corso/src/cli/utils"
 	"github.com/alcionai/corso/src/internal/tester"
 )
@@ -39,34 +37,21 @@ func (suite *GroupsUnitSuite) TestAddGroupsCommands() {
 	for _, test := range table {
 		suite.Run(test.name, func() {
 			t := suite.T()
+			parent := &cobra.Command{Use: restoreCommand}
 
-			cmd := &cobra.Command{Use: test.use}
+			cmd := cliTD.SetUpCmdHasFlags(
-
+				t,
-			// persistent flags not added by addCommands
+				parent,
-			flags.AddRunModeFlag(cmd, true)
+				addGroupsCommands,
-
+				[]cliTD.UseCobraCommandFn{
-			c := addGroupsCommands(cmd)
+					flags.AddAllProviderFlags,
-			require.NotNil(t, c)
+					flags.AddAllStorageFlags,
-
+				},
-			// non-persistent flags not added by addCommands
-			flags.AddAllProviderFlags(c)
-			flags.AddAllStorageFlags(c)
-
-			cmds := cmd.Commands()
-			require.Len(t, cmds, 1)
-
-			child := cmds[0]
-			assert.Equal(t, test.expectUse, child.Use)
-			assert.Equal(t, test.expectShort, child.Short)
-			tester.AreSameFunc(t, test.expectRunE, child.RunE)
-
 				flagsTD.WithFlags(
-				cmd,
 					groupsServiceCommand,
 					[]string{
 						"--" + flags.RunModeFN, flags.RunModeFlagTest,
 						"--" + flags.BackupFN, flagsTD.BackupInput,
-
 						"--" + flags.LibraryFN, flagsTD.LibraryInput,
 						"--" + flags.FileFN, flagsTD.FlgInputs(flagsTD.FileNameInput),
 						"--" + flags.FolderFN, flagsTD.FlgInputs(flagsTD.FolderPathInput),
@@ -78,26 +63,25 @@ func (suite *GroupsUnitSuite) TestAddGroupsCommands() {
 						"--" + flags.ListFolderFN, flagsTD.FlgInputs(flagsTD.ListFolderInput),
 						"--" + flags.PageFN, flagsTD.FlgInputs(flagsTD.PageInput),
 						"--" + flags.PageFolderFN, flagsTD.FlgInputs(flagsTD.PageFolderInput),
-
 						"--" + flags.CollisionsFN, flagsTD.Collisions,
 						"--" + flags.DestinationFN, flagsTD.Destination,
 						"--" + flags.ToResourceFN, flagsTD.ToResource,
-
-					// bool flags
 						"--" + flags.NoPermissionsFN,
 					},
 					flagsTD.PreparedProviderFlags(),
-				flagsTD.PreparedStorageFlags())
+					flagsTD.PreparedStorageFlags()))
 
-			cmd.SetOut(new(bytes.Buffer)) // drop output
+			cliTD.CheckCmdChild(
-			cmd.SetErr(new(bytes.Buffer)) // drop output
+				t,
-
+				parent,
-			err := cmd.Execute()
+				3,
-			assert.NoError(t, err, clues.ToCore(err))
+				test.expectUse,
+				test.expectShort,
+				test.expectRunE)
 
 			opts := utils.MakeGroupsOpts(cmd)
-			assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV)
 
+			assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV)
 			assert.Equal(t, flagsTD.LibraryInput, opts.Library)
 			assert.ElementsMatch(t, flagsTD.FileNameInput, opts.FileName)
 			assert.ElementsMatch(t, flagsTD.FolderPathInput, opts.FolderPath)
@@ -105,14 +89,10 @@ func (suite *GroupsUnitSuite) TestAddGroupsCommands() {
 			assert.Equal(t, flagsTD.FileCreatedBeforeInput, opts.FileCreatedBefore)
 			assert.Equal(t, flagsTD.FileModifiedAfterInput, opts.FileModifiedAfter)
 			assert.Equal(t, flagsTD.FileModifiedBeforeInput, opts.FileModifiedBefore)
-
 			assert.Equal(t, flagsTD.Collisions, opts.RestoreCfg.Collisions)
 			assert.Equal(t, flagsTD.Destination, opts.RestoreCfg.Destination)
 			assert.Equal(t, flagsTD.ToResource, opts.RestoreCfg.ProtectedResource)
-
-			// bool flags
 			assert.True(t, flags.NoPermissionsFV)
-
 			flagsTD.AssertProviderFlags(t, cmd)
 			flagsTD.AssertStorageFlags(t, cmd)
 		})

src/cli/restore/onedrive_test.go

@@ -1,17 +1,15 @@
 package restore
 
 import (
-	"bytes"
 	"testing"
 
-	"github.com/alcionai/clues"
 	"github.com/spf13/cobra"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
 
 	"github.com/alcionai/corso/src/cli/flags"
 	flagsTD "github.com/alcionai/corso/src/cli/flags/testdata"
+	cliTD "github.com/alcionai/corso/src/cli/testdata"
 	"github.com/alcionai/corso/src/cli/utils"
 	"github.com/alcionai/corso/src/internal/tester"
 )
@@ -39,29 +37,17 @@ func (suite *OneDriveUnitSuite) TestAddOneDriveCommands() {
 	for _, test := range table {
 		suite.Run(test.name, func() {
 			t := suite.T()
+			parent := &cobra.Command{Use: restoreCommand}
 
-			cmd := &cobra.Command{Use: test.use}
+			cmd := cliTD.SetUpCmdHasFlags(
-
+				t,
-			// persistent flags not added by addCommands
+				parent,
-			flags.AddRunModeFlag(cmd, true)
+				addOneDriveCommands,
-
+				[]cliTD.UseCobraCommandFn{
-			c := addOneDriveCommands(cmd)
+					flags.AddAllProviderFlags,
-			require.NotNil(t, c)
+					flags.AddAllStorageFlags,
-
+				},
-			// non-persistent flags not added by addCommands
-			flags.AddAllProviderFlags(c)
-			flags.AddAllStorageFlags(c)
-
-			cmds := cmd.Commands()
-			require.Len(t, cmds, 1)
-
-			child := cmds[0]
-			assert.Equal(t, test.expectUse, child.Use)
-			assert.Equal(t, test.expectShort, child.Short)
-			tester.AreSameFunc(t, test.expectRunE, child.RunE)
-
 				flagsTD.WithFlags(
-				cmd,
 					oneDriveServiceCommand,
 					[]string{
 						"--" + flags.RunModeFN, flags.RunModeFlagTest,
@@ -72,40 +58,35 @@ func (suite *OneDriveUnitSuite) TestAddOneDriveCommands() {
 						"--" + flags.FileCreatedBeforeFN, flagsTD.FileCreatedBeforeInput,
 						"--" + flags.FileModifiedAfterFN, flagsTD.FileModifiedAfterInput,
 						"--" + flags.FileModifiedBeforeFN, flagsTD.FileModifiedBeforeInput,
-
 						"--" + flags.CollisionsFN, flagsTD.Collisions,
 						"--" + flags.DestinationFN, flagsTD.Destination,
 						"--" + flags.ToResourceFN, flagsTD.ToResource,
-
-					// bool flags
 						"--" + flags.NoPermissionsFN,
 					},
 					flagsTD.PreparedProviderFlags(),
-				flagsTD.PreparedStorageFlags())
+					flagsTD.PreparedStorageFlags()))
 
-			cmd.SetOut(new(bytes.Buffer)) // drop output
+			cliTD.CheckCmdChild(
-			cmd.SetErr(new(bytes.Buffer)) // drop output
+				t,
-
+				parent,
-			err := cmd.Execute()
+				3,
-			assert.NoError(t, err, clues.ToCore(err))
+				test.expectUse,
+				test.expectShort,
+				test.expectRunE)
 
 			opts := utils.MakeOneDriveOpts(cmd)
-			assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV)
 
+			assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV)
 			assert.ElementsMatch(t, flagsTD.FileNameInput, opts.FileName)
 			assert.ElementsMatch(t, flagsTD.FolderPathInput, opts.FolderPath)
 			assert.Equal(t, flagsTD.FileCreatedAfterInput, opts.FileCreatedAfter)
 			assert.Equal(t, flagsTD.FileCreatedBeforeInput, opts.FileCreatedBefore)
 			assert.Equal(t, flagsTD.FileModifiedAfterInput, opts.FileModifiedAfter)
 			assert.Equal(t, flagsTD.FileModifiedBeforeInput, opts.FileModifiedBefore)
-
 			assert.Equal(t, flagsTD.Collisions, opts.RestoreCfg.Collisions)
 			assert.Equal(t, flagsTD.Destination, opts.RestoreCfg.Destination)
 			assert.Equal(t, flagsTD.ToResource, opts.RestoreCfg.ProtectedResource)
-
-			// bool flags
 			assert.True(t, flags.NoPermissionsFV)
-
 			flagsTD.AssertProviderFlags(t, cmd)
 			flagsTD.AssertStorageFlags(t, cmd)
 		})

src/cli/restore/restore.go

@@ -25,12 +25,12 @@ var restoreCommands = []func(cmd *cobra.Command) *cobra.Command{
 // AddCommands attaches all `corso restore * *` commands to the parent.
 func AddCommands(cmd *cobra.Command) {
 	subCommand := restoreCmd()
-	flags.AddAllProviderFlags(subCommand)
-	flags.AddAllStorageFlags(subCommand)
 	cmd.AddCommand(subCommand)
 
 	for _, addRestoreTo := range restoreCommands {
-		addRestoreTo(subCommand)
+		sc := addRestoreTo(subCommand)
+		flags.AddAllProviderFlags(sc)
+		flags.AddAllStorageFlags(sc)
 	}
 }
 

src/cli/restore/sharepoint_test.go

@@ -1,17 +1,15 @@
 package restore
 
 import (
-	"bytes"
 	"testing"
 
-	"github.com/alcionai/clues"
 	"github.com/spf13/cobra"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
 
 	"github.com/alcionai/corso/src/cli/flags"
 	flagsTD "github.com/alcionai/corso/src/cli/flags/testdata"
+	cliTD "github.com/alcionai/corso/src/cli/testdata"
 	"github.com/alcionai/corso/src/cli/utils"
 	"github.com/alcionai/corso/src/internal/tester"
 )
@@ -39,29 +37,17 @@ func (suite *SharePointUnitSuite) TestAddSharePointCommands() {
 	for _, test := range table {
 		suite.Run(test.name, func() {
 			t := suite.T()
+			parent := &cobra.Command{Use: restoreCommand}
 
-			cmd := &cobra.Command{Use: test.use}
+			cmd := cliTD.SetUpCmdHasFlags(
-
+				t,
-			// persistent flags not added by addCommands
+				parent,
-			flags.AddRunModeFlag(cmd, true)
+				addSharePointCommands,
-
+				[]cliTD.UseCobraCommandFn{
-			c := addSharePointCommands(cmd)
+					flags.AddAllProviderFlags,
-			require.NotNil(t, c)
+					flags.AddAllStorageFlags,
-
+				},
-			// non-persistent flags not added by addCommands
-			flags.AddAllProviderFlags(c)
-			flags.AddAllStorageFlags(c)
-
-			cmds := cmd.Commands()
-			require.Len(t, cmds, 1)
-
-			child := cmds[0]
-			assert.Equal(t, test.expectUse, child.Use)
-			assert.Equal(t, test.expectShort, child.Short)
-			tester.AreSameFunc(t, test.expectRunE, child.RunE)
-
 				flagsTD.WithFlags(
-				cmd,
 					sharePointServiceCommand,
 					[]string{
 						"--" + flags.RunModeFN, flags.RunModeFlagTest,
@@ -77,26 +63,25 @@ func (suite *SharePointUnitSuite) TestAddSharePointCommands() {
 						"--" + flags.ListFolderFN, flagsTD.FlgInputs(flagsTD.ListFolderInput),
 						"--" + flags.PageFN, flagsTD.FlgInputs(flagsTD.PageInput),
 						"--" + flags.PageFolderFN, flagsTD.FlgInputs(flagsTD.PageFolderInput),
-
 						"--" + flags.CollisionsFN, flagsTD.Collisions,
 						"--" + flags.DestinationFN, flagsTD.Destination,
 						"--" + flags.ToResourceFN, flagsTD.ToResource,
-
-					// bool flags
 						"--" + flags.NoPermissionsFN,
 					},
 					flagsTD.PreparedProviderFlags(),
-				flagsTD.PreparedStorageFlags())
+					flagsTD.PreparedStorageFlags()))
 
-			cmd.SetOut(new(bytes.Buffer)) // drop output
+			cliTD.CheckCmdChild(
-			cmd.SetErr(new(bytes.Buffer)) // drop output
+				t,
-
+				parent,
-			err := cmd.Execute()
+				3,
-			assert.NoError(t, err, clues.ToCore(err))
+				test.expectUse,
+				test.expectShort,
+				test.expectRunE)
 
 			opts := utils.MakeSharePointOpts(cmd)
-			assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV)
 
+			assert.Equal(t, flagsTD.BackupInput, flags.BackupIDFV)
 			assert.Equal(t, flagsTD.LibraryInput, opts.Library)
 			assert.ElementsMatch(t, flagsTD.FileNameInput, opts.FileName)
 			assert.ElementsMatch(t, flagsTD.FolderPathInput, opts.FolderPath)
@@ -104,20 +89,14 @@ func (suite *SharePointUnitSuite) TestAddSharePointCommands() {
 			assert.Equal(t, flagsTD.FileCreatedBeforeInput, opts.FileCreatedBefore)
 			assert.Equal(t, flagsTD.FileModifiedAfterInput, opts.FileModifiedAfter)
 			assert.Equal(t, flagsTD.FileModifiedBeforeInput, opts.FileModifiedBefore)
-
 			assert.ElementsMatch(t, flagsTD.ListItemInput, opts.ListItem)
 			assert.ElementsMatch(t, flagsTD.ListFolderInput, opts.ListFolder)
-
 			assert.ElementsMatch(t, flagsTD.PageInput, opts.Page)
 			assert.ElementsMatch(t, flagsTD.PageFolderInput, opts.PageFolder)
-
 			assert.Equal(t, flagsTD.Collisions, opts.RestoreCfg.Collisions)
 			assert.Equal(t, flagsTD.Destination, opts.RestoreCfg.Destination)
 			assert.Equal(t, flagsTD.ToResource, opts.RestoreCfg.ProtectedResource)
-
-			// bool flags
 			assert.True(t, flags.NoPermissionsFV)
-
 			flagsTD.AssertProviderFlags(t, cmd)
 			flagsTD.AssertStorageFlags(t, cmd)
 		})

src/cli/testdata/cli.go

@@ -1,11 +1,20 @@
 package testdata
 
 import (
+	"bytes"
 	"fmt"
+	"strings"
+	"testing"
 	"time"
 
+	"github.com/alcionai/clues"
 	"github.com/google/uuid"
 	"github.com/spf13/cobra"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/alcionai/corso/src/cli/flags"
+	"github.com/alcionai/corso/src/internal/tester"
 )
 
 // StubRootCmd builds a stub cobra command to be used as
@@ -27,3 +36,82 @@ func StubRootCmd(args ...string) *cobra.Command {
 
 	return c
 }
+
+type UseCobraCommandFn func(*cobra.Command)
+
+func SetUpCmdHasFlags(
+	t *testing.T,
+	parentCmd *cobra.Command,
+	addChildCommand func(*cobra.Command) *cobra.Command,
+	addFlags []UseCobraCommandFn,
+	setArgs UseCobraCommandFn,
+) *cobra.Command {
+	parentCmd.PersistentPreRun = func(c *cobra.Command, args []string) {
+		t.Log("testing args:")
+
+		for _, arg := range args {
+			t.Log(arg)
+		}
+	}
+
+	// persistent flags not added by addCommands
+	flags.AddRunModeFlag(parentCmd, true)
+
+	cmd := addChildCommand(parentCmd)
+	require.NotNil(t, cmd)
+
+	cul := cmd.UseLine()
+	require.Truef(
+		t,
+		strings.HasPrefix(cul, parentCmd.Use+" "+cmd.Use),
+		"child command has expected usage format 'parent child', got %q",
+		cul)
+
+	for _, af := range addFlags {
+		af(cmd)
+	}
+
+	setArgs(parentCmd)
+
+	parentCmd.SetOut(new(bytes.Buffer)) // drop output
+	parentCmd.SetErr(new(bytes.Buffer)) // drop output
+
+	err := parentCmd.Execute()
+	assert.NoError(t, err, clues.ToCore(err))
+
+	return cmd
+}
+
+type CobraRunEFn func(cmd *cobra.Command, args []string) error
+
+func CheckCmdChild(
+	t *testing.T,
+	cmd *cobra.Command,
+	expectChildCount int,
+	expectUse string,
+	expectShort string,
+	expectRunE CobraRunEFn,
+) {
+	var (
+		cmds  = cmd.Commands()
+		child *cobra.Command
+	)
+
+	for _, cc := range cmds {
+		if cc.Use == expectUse {
+			child = cc
+			break
+		}
+	}
+
+	require.Len(
+		t,
+		cmds,
+		expectChildCount,
+		"parent command should have the correct child command count")
+
+	require.NotNil(t, child, "should have found expected child command")
+
+	assert.Equal(t, expectShort, child.Short)
+	tester.AreSameFunc(t, expectRunE, child.RunE)
+}