From c82dad6e402a09f7c9de81e34433e4d6ec232ec6 Mon Sep 17 00:00:00 2001 From: Keepers Date: Mon, 12 Sep 2022 18:13:50 -0600 Subject: [PATCH] flexible restore/details flags (#821) removes the requriement that higher order data must be specified in order to specify granular data ids. Ex: previously, cli users needed to add --user and --folder flags in order to use a --mail flag. Now the user and folder will default to Any() if they're not provided. --- src/cli/backup/exchange.go | 14 +- src/cli/backup/exchange_test.go | 402 ------------------------------ src/cli/restore/exchange.go | 11 +- src/cli/restore/exchange_test.go | 403 ------------------------------- src/cli/utils/exchange.go | 54 ++--- src/cli/utils/exchange_test.go | 358 +++++++++++++++++++++++++++ 6 files changed, 379 insertions(+), 863 deletions(-) create mode 100644 src/cli/utils/exchange_test.go diff --git a/src/cli/backup/exchange.go b/src/cli/backup/exchange.go index eeb3830cf..3d7ab4638 100644 --- a/src/cli/backup/exchange.go +++ b/src/cli/backup/exchange.go @@ -336,16 +336,7 @@ func detailsExchangeCmd(cmd *cobra.Command, args []string) error { return nil } - if err := utils.ValidateExchangeRestoreFlags( - contact, - contactFolder, - email, - emailFolder, - event, - eventCalendar, - user, - backupID, - ); err != nil { + if err := utils.ValidateExchangeRestoreFlags(backupID); err != nil { return err } @@ -396,7 +387,8 @@ func detailsExchangeCmd(cmd *cobra.Command, args []string) error { ds := sel.Reduce(d) if len(ds.Entries) == 0 { - return Only(ctx, errors.New("nothing to display: no items in the backup match the provided selectors")) + Info(ctx, "nothing to display: no items in the backup match the provided selectors") + return nil } ds.PrintEntries(ctx) diff --git a/src/cli/backup/exchange_test.go b/src/cli/backup/exchange_test.go index 587dbeb7a..225e179da 100644 --- a/src/cli/backup/exchange_test.go +++ b/src/cli/backup/exchange_test.go @@ -10,7 +10,6 @@ import ( "github.com/alcionai/corso/src/cli/utils" "github.com/alcionai/corso/src/internal/tester" - "github.com/alcionai/corso/src/pkg/selectors" ) type ExchangeSuite struct { @@ -215,404 +214,3 @@ func (suite *ExchangeSuite) TestExchangeBackupCreateSelectors() { }) } } - -func (suite *ExchangeSuite) TestValidateBackupDetailFlags() { - stub := []string{"id-stub"} - - table := []struct { - name string - contacts, contactFolders, emails, emailFolders, events, eventCalendars, users []string - backupID string - expect assert.ErrorAssertionFunc - }{ - { - name: "only backupid", - backupID: "bid", - expect: assert.NoError, - }, - { - name: "any values populated", - backupID: "bid", - contacts: stub, - contactFolders: stub, - emails: stub, - emailFolders: stub, - events: stub, - eventCalendars: stub, - users: stub, - expect: assert.NoError, - }, - { - name: "nothing populated", - expect: assert.Error, - }, - { - name: "no backup id", - contacts: stub, - contactFolders: stub, - emails: stub, - emailFolders: stub, - events: stub, - eventCalendars: stub, - users: stub, - expect: assert.Error, - }, - { - name: "no users", - backupID: "bid", - contacts: stub, - contactFolders: stub, - emails: stub, - emailFolders: stub, - events: stub, - eventCalendars: stub, - expect: assert.Error, - }, - { - name: "no contact folders", - backupID: "bid", - contacts: stub, - emails: stub, - emailFolders: stub, - events: stub, - eventCalendars: stub, - users: stub, - expect: assert.Error, - }, - { - name: "no email folders", - backupID: "bid", - contacts: stub, - contactFolders: stub, - emails: stub, - events: stub, - eventCalendars: stub, - users: stub, - expect: assert.Error, - }, - { - name: "no event calendars", - backupID: "bid", - contacts: stub, - contactFolders: stub, - emails: stub, - events: stub, - users: stub, - expect: assert.Error, - }, - } - for _, test := range table { - suite.T().Run(test.name, func(t *testing.T) { - test.expect(t, utils.ValidateExchangeRestoreFlags( - test.contacts, - test.contactFolders, - test.emails, - test.emailFolders, - test.events, - test.eventCalendars, - test.users, - test.backupID, - )) - }) - } -} - -func (suite *ExchangeSuite) TestIncludeExchangeBackupDetailDataSelectors() { - stub := []string{"id-stub"} - a := []string{utils.Wildcard} - - table := []struct { - name string - contacts, contactFolders, emails, emailFolders, events, eventCalendars, users []string - expectIncludeLen int - }{ - { - name: "no selectors", - expectIncludeLen: 3, - }, - { - name: "any users", - users: a, - expectIncludeLen: 3, - }, - { - name: "single user", - users: stub, - expectIncludeLen: 3, - }, - { - name: "multiple users", - users: []string{"fnord", "smarf"}, - expectIncludeLen: 3, - }, - { - name: "any users, any data", - contacts: a, - contactFolders: a, - emails: a, - emailFolders: a, - events: a, - eventCalendars: a, - users: a, - expectIncludeLen: 3, - }, - { - name: "any users, any folders", - contactFolders: a, - emailFolders: a, - eventCalendars: a, - users: a, - expectIncludeLen: 3, - }, - { - name: "single user, single of each data", - contacts: stub, - contactFolders: stub, - emails: stub, - emailFolders: stub, - events: stub, - eventCalendars: stub, - users: stub, - expectIncludeLen: 3, - }, - { - name: "single user, single of each folder", - contactFolders: stub, - emailFolders: stub, - eventCalendars: stub, - users: stub, - expectIncludeLen: 3, - }, - { - name: "any users, contacts", - contacts: a, - contactFolders: stub, - users: a, - expectIncludeLen: 1, - }, - { - name: "single user, contacts", - contacts: stub, - contactFolders: stub, - users: stub, - expectIncludeLen: 1, - }, - { - name: "any users, emails", - emails: a, - emailFolders: stub, - users: a, - expectIncludeLen: 1, - }, - { - name: "single user, emails", - emails: stub, - emailFolders: stub, - users: stub, - expectIncludeLen: 1, - }, - { - name: "any users, events", - events: a, - eventCalendars: a, - users: a, - expectIncludeLen: 1, - }, - { - name: "single user, events", - events: stub, - eventCalendars: stub, - users: stub, - expectIncludeLen: 1, - }, - { - name: "any users, contacts + email", - contacts: a, - contactFolders: a, - emails: a, - emailFolders: a, - users: a, - expectIncludeLen: 2, - }, - { - name: "single users, contacts + email", - contacts: stub, - contactFolders: stub, - emails: stub, - emailFolders: stub, - users: stub, - expectIncludeLen: 2, - }, - { - name: "any users, email + event", - emails: a, - emailFolders: a, - events: a, - eventCalendars: a, - users: a, - expectIncludeLen: 2, - }, - { - name: "single users, email + event", - emails: stub, - emailFolders: stub, - events: stub, - eventCalendars: stub, - users: stub, - expectIncludeLen: 2, - }, - { - name: "any users, event + contact", - contacts: a, - contactFolders: a, - events: a, - eventCalendars: a, - users: a, - expectIncludeLen: 2, - }, - { - name: "single users, event + contact", - contacts: stub, - contactFolders: stub, - events: stub, - eventCalendars: stub, - users: stub, - expectIncludeLen: 2, - }, - { - name: "many users, events", - events: []string{"foo", "bar"}, - eventCalendars: []string{"baz", "qux"}, - users: []string{"fnord", "smarf"}, - expectIncludeLen: 1, - }, - { - name: "many users, events + contacts", - contacts: []string{"foo", "bar"}, - contactFolders: []string{"foo", "bar"}, - events: []string{"foo", "bar"}, - eventCalendars: []string{"foo", "bar"}, - users: []string{"fnord", "smarf"}, - expectIncludeLen: 2, - }, - } - for _, test := range table { - suite.T().Run(test.name, func(t *testing.T) { - sel := selectors.NewExchangeRestore() - utils.IncludeExchangeRestoreDataSelectors( - sel, - test.contacts, - test.contactFolders, - test.emails, - test.emailFolders, - test.events, - test.eventCalendars, - test.users) - assert.Equal(t, test.expectIncludeLen, len(sel.Includes)) - }) - } -} - -func (suite *ExchangeSuite) TestFilterExchangeBackupDetailInfoSelectors() { - stub := "id-stub" - - table := []struct { - name string - contactName string - after, before, sender, subject string - organizer, recurs, startsAfter, startsBefore, eventSubject string - expectFilterLen int - }{ - { - name: "no selectors", - expectFilterLen: 0, - }, - { - name: "contactName", - contactName: stub, - expectFilterLen: 1, - }, - { - name: "receivedAfter", - after: stub, - expectFilterLen: 1, - }, - { - name: "receivedAfter", - after: stub, - expectFilterLen: 1, - }, - { - name: "receivedBefore", - before: stub, - expectFilterLen: 1, - }, - { - name: "sender", - sender: stub, - expectFilterLen: 1, - }, - { - name: "subject", - subject: stub, - expectFilterLen: 1, - }, - { - name: "organizer", - organizer: stub, - expectFilterLen: 1, - }, - { - name: "recurs", - recurs: stub, - expectFilterLen: 1, - }, - { - name: "startsAfter", - startsAfter: stub, - expectFilterLen: 1, - }, - { - name: "startsBefore", - startsBefore: stub, - expectFilterLen: 1, - }, - { - name: "eventSubject", - eventSubject: stub, - expectFilterLen: 1, - }, - { - name: "one of each", - contactName: stub, - after: stub, - before: stub, - sender: stub, - subject: stub, - organizer: stub, - recurs: stub, - startsAfter: stub, - startsBefore: stub, - eventSubject: stub, - expectFilterLen: 10, - }, - } - for _, test := range table { - suite.T().Run(test.name, func(t *testing.T) { - sel := selectors.NewExchangeRestore() - utils.FilterExchangeRestoreInfoSelectors( - sel, - test.contactName, - test.after, - test.before, - test.sender, - test.subject, - test.organizer, - test.recurs, - test.startsAfter, - test.startsBefore, - test.eventSubject) - assert.Equal(t, test.expectFilterLen, len(sel.Filters)) - }) - } -} diff --git a/src/cli/restore/exchange.go b/src/cli/restore/exchange.go index b73a60dd4..f255d7537 100644 --- a/src/cli/restore/exchange.go +++ b/src/cli/restore/exchange.go @@ -147,16 +147,7 @@ func restoreExchangeCmd(cmd *cobra.Command, args []string) error { return nil } - if err := utils.ValidateExchangeRestoreFlags( - contact, - contactFolder, - email, - emailFolder, - event, - eventCalendar, - user, - backupID, - ); err != nil { + if err := utils.ValidateExchangeRestoreFlags(backupID); err != nil { return err } diff --git a/src/cli/restore/exchange_test.go b/src/cli/restore/exchange_test.go index eb0499338..17f5cb09e 100644 --- a/src/cli/restore/exchange_test.go +++ b/src/cli/restore/exchange_test.go @@ -8,9 +8,7 @@ import ( "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" - "github.com/alcionai/corso/src/cli/utils" "github.com/alcionai/corso/src/internal/tester" - "github.com/alcionai/corso/src/pkg/selectors" ) type ExchangeSuite struct { @@ -50,404 +48,3 @@ func (suite *ExchangeSuite) TestAddExchangeCommands() { }) } } - -func (suite *ExchangeSuite) TestValidateExchangeRestoreFlags() { - stub := []string{"id-stub"} - - table := []struct { - name string - contacts, contactFolders, emails, emailFolders, events, eventCalendars, users []string - backupID string - expect assert.ErrorAssertionFunc - }{ - { - name: "only backupid", - backupID: "bid", - expect: assert.NoError, - }, - { - name: "any values populated", - backupID: "bid", - contacts: stub, - contactFolders: stub, - emails: stub, - emailFolders: stub, - events: stub, - eventCalendars: stub, - users: stub, - expect: assert.NoError, - }, - { - name: "nothing populated", - expect: assert.Error, - }, - { - name: "no backup id", - contacts: stub, - contactFolders: stub, - emails: stub, - emailFolders: stub, - events: stub, - eventCalendars: stub, - users: stub, - expect: assert.Error, - }, - { - name: "no users", - backupID: "bid", - contacts: stub, - contactFolders: stub, - emails: stub, - emailFolders: stub, - events: stub, - eventCalendars: stub, - expect: assert.Error, - }, - { - name: "no contact folders", - backupID: "bid", - contacts: stub, - emails: stub, - emailFolders: stub, - events: stub, - users: stub, - eventCalendars: stub, - expect: assert.Error, - }, - { - name: "no email folders", - backupID: "bid", - contacts: stub, - contactFolders: stub, - emails: stub, - events: stub, - eventCalendars: stub, - users: stub, - expect: assert.Error, - }, - { - name: "no event calendars", - backupID: "bid", - contacts: stub, - contactFolders: stub, - emails: stub, - events: stub, - users: stub, - expect: assert.Error, - }, - } - for _, test := range table { - suite.T().Run(test.name, func(t *testing.T) { - test.expect(t, utils.ValidateExchangeRestoreFlags( - test.contacts, - test.contactFolders, - test.emails, - test.emailFolders, - test.events, - test.eventCalendars, - test.users, - test.backupID, - )) - }) - } -} - -func (suite *ExchangeSuite) TestIncludeExchangeRestoreDataSelectors() { - stub := []string{"id-stub"} - a := []string{utils.Wildcard} - - table := []struct { - name string - contacts, contactFolders, emails, emailFolders, events, eventCalendars, users []string - expectIncludeLen int - }{ - { - name: "no selectors", - expectIncludeLen: 3, - }, - { - name: "any users", - users: a, - expectIncludeLen: 3, - }, - { - name: "single user", - users: stub, - expectIncludeLen: 3, - }, - { - name: "multiple users", - users: []string{"fnord", "smarf"}, - expectIncludeLen: 3, - }, - { - name: "any users, any data", - contacts: a, - contactFolders: a, - emails: a, - emailFolders: a, - events: a, - eventCalendars: a, - users: a, - expectIncludeLen: 3, - }, - { - name: "any users, any folders", - contactFolders: a, - emailFolders: a, - eventCalendars: a, - users: a, - expectIncludeLen: 3, - }, - { - name: "single user, single of each data", - contacts: stub, - contactFolders: stub, - emails: stub, - emailFolders: stub, - events: stub, - eventCalendars: stub, - users: stub, - expectIncludeLen: 3, - }, - { - name: "single user, single of each folder", - contactFolders: stub, - emailFolders: stub, - eventCalendars: stub, - users: stub, - expectIncludeLen: 3, - }, - { - name: "any users, contacts", - contacts: a, - contactFolders: stub, - users: a, - expectIncludeLen: 1, - }, - { - name: "single user, contacts", - contacts: stub, - contactFolders: stub, - users: stub, - expectIncludeLen: 1, - }, - { - name: "any users, emails", - emails: a, - emailFolders: stub, - users: a, - expectIncludeLen: 1, - }, - { - name: "single user, emails", - emails: stub, - emailFolders: stub, - users: stub, - expectIncludeLen: 1, - }, - { - name: "any users, events", - events: a, - eventCalendars: a, - users: a, - expectIncludeLen: 1, - }, - { - name: "single user, events", - events: stub, - eventCalendars: stub, - users: stub, - expectIncludeLen: 1, - }, - { - name: "any users, contacts + email", - contacts: a, - contactFolders: a, - emails: a, - emailFolders: a, - users: a, - expectIncludeLen: 2, - }, - { - name: "single users, contacts + email", - contacts: stub, - contactFolders: stub, - emails: stub, - emailFolders: stub, - users: stub, - expectIncludeLen: 2, - }, - { - name: "any users, email + event", - emails: a, - emailFolders: a, - events: a, - eventCalendars: a, - users: a, - expectIncludeLen: 2, - }, - { - name: "single users, email + event", - emails: stub, - emailFolders: stub, - events: stub, - eventCalendars: stub, - users: stub, - expectIncludeLen: 2, - }, - { - name: "any users, event + contact", - contacts: a, - contactFolders: a, - events: a, - eventCalendars: a, - users: a, - expectIncludeLen: 2, - }, - { - name: "single users, event + contact", - contacts: stub, - contactFolders: stub, - events: stub, - eventCalendars: stub, - users: stub, - expectIncludeLen: 2, - }, - { - name: "many users, events", - events: []string{"foo", "bar"}, - eventCalendars: []string{"baz", "qux"}, - users: []string{"fnord", "smarf"}, - expectIncludeLen: 1, - }, - { - name: "many users, events + contacts", - contacts: []string{"foo", "bar"}, - contactFolders: []string{"foo", "bar"}, - events: []string{"foo", "bar"}, - eventCalendars: []string{"foo", "bar"}, - users: []string{"fnord", "smarf"}, - expectIncludeLen: 2, - }, - } - for _, test := range table { - suite.T().Run(test.name, func(t *testing.T) { - sel := selectors.NewExchangeRestore() - utils.IncludeExchangeRestoreDataSelectors( - sel, - test.contacts, - test.contactFolders, - test.emails, - test.emailFolders, - test.events, - test.eventCalendars, - test.users) - assert.Equal(t, test.expectIncludeLen, len(sel.Includes)) - }) - } -} - -func (suite *ExchangeSuite) TestFilterExchangeRestoreInfoSelectors() { - stub := "id-stub" - - table := []struct { - name string - contactName string - after, before, sender, subject string - organizer, recurs, startsAfter, startsBefore, eventSubject string - expectFilterLen int - }{ - { - name: "no selectors", - expectFilterLen: 0, - }, - { - name: "contactName", - contactName: stub, - expectFilterLen: 1, - }, - { - name: "receivedAfter", - after: stub, - expectFilterLen: 1, - }, - { - name: "receivedAfter", - after: stub, - expectFilterLen: 1, - }, - { - name: "receivedBefore", - before: stub, - expectFilterLen: 1, - }, - { - name: "sender", - sender: stub, - expectFilterLen: 1, - }, - { - name: "subject", - subject: stub, - expectFilterLen: 1, - }, - { - name: "organizer", - organizer: stub, - expectFilterLen: 1, - }, - { - name: "recurs", - recurs: stub, - expectFilterLen: 1, - }, - { - name: "startsAfter", - startsAfter: stub, - expectFilterLen: 1, - }, - { - name: "startsBefore", - startsBefore: stub, - expectFilterLen: 1, - }, - { - name: "eventSubject", - eventSubject: stub, - expectFilterLen: 1, - }, - { - name: "one of each", - contactName: stub, - after: stub, - before: stub, - sender: stub, - subject: stub, - organizer: stub, - recurs: stub, - startsAfter: stub, - startsBefore: stub, - eventSubject: stub, - expectFilterLen: 10, - }, - } - for _, test := range table { - suite.T().Run(test.name, func(t *testing.T) { - sel := selectors.NewExchangeRestore() - utils.FilterExchangeRestoreInfoSelectors( - sel, - test.contactName, - test.after, - test.before, - test.sender, - test.subject, - test.organizer, - test.recurs, - test.startsAfter, - test.startsBefore, - test.eventSubject) - assert.Equal(t, test.expectFilterLen, len(sel.Filters)) - }) - } -} diff --git a/src/cli/utils/exchange.go b/src/cli/utils/exchange.go index cfcec4fcd..d27e1fe8f 100644 --- a/src/cli/utils/exchange.go +++ b/src/cli/utils/exchange.go @@ -7,17 +7,30 @@ import ( ) // AddExchangeInclude adds the scope of the provided values to the selector's -// inclusion set. +// inclusion set. Any unpopulated slice will be replaced with selectors.Any() +// to act as a wildcard. func AddExchangeInclude( sel *selectors.ExchangeRestore, resource, folders, items []string, incl func([]string, []string, []string) []selectors.ExchangeScope, ) { - if len(folders) == 0 { + lf, li := len(folders), len(items) + + // only use the inclusion if either a folder or item of + // this type is specified. + if lf+li == 0 { return } - if len(items) == 0 { + if len(resource) == 0 { + resource = selectors.Any() + } + + if lf == 0 { + folders = selectors.Any() + } + + if li == 0 { items = selectors.Any() } @@ -39,43 +52,11 @@ func AddExchangeFilter( } // ValidateExchangeRestoreFlags checks common flags for correctness and interdependencies -func ValidateExchangeRestoreFlags( - contacts, contactFolders, emails, emailFolders, events, eventCalendars, users []string, - backupID string, -) error { +func ValidateExchangeRestoreFlags(backupID string) error { if len(backupID) == 0 { return errors.New("a backup ID is required") } - lu := len(users) - lc, lcf := len(contacts), len(contactFolders) - le, lef := len(emails), len(emailFolders) - lev, lec := len(events), len(eventCalendars) - - // if only the backupID is populated, that's the same as --all - if lu+lc+lcf+le+lef+lev+lec == 0 { - return nil - } - - if lu == 0 { - return errors.New("requires one or more --user ids, the wildcard --user *, or the --all flag") - } - - if lc > 0 && lcf == 0 { - return errors.New( - "one or more --contact-folder ids or the wildcard --contact-folder * must be included to specify a --contact") - } - - if le > 0 && lef == 0 { - return errors.New( - "one or more --email-folder ids or the wildcard --email-folder * must be included to specify an --email") - } - - if lev > 0 && lec == 0 { - return errors.New( - "one or more --event-calendar ids or the wildcard --event-calendar * must be included to specify an --event") - } - return nil } @@ -88,7 +69,6 @@ func IncludeExchangeRestoreDataSelectors( lc, lcf := len(contacts), len(contactFolders) le, lef := len(emails), len(emailFolders) lev, lec := len(events), len(eventCalendars) - // either scope the request to a set of users if lc+lcf+le+lef+lev+lec == 0 { if len(users) == 0 { diff --git a/src/cli/utils/exchange_test.go b/src/cli/utils/exchange_test.go new file mode 100644 index 000000000..924837d07 --- /dev/null +++ b/src/cli/utils/exchange_test.go @@ -0,0 +1,358 @@ +package utils_test + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/suite" + + "github.com/alcionai/corso/src/cli/utils" + "github.com/alcionai/corso/src/pkg/selectors" +) + +type ExchangeUtilsSuite struct { + suite.Suite +} + +func TestExchangeUtilsSuite(t *testing.T) { + suite.Run(t, new(ExchangeUtilsSuite)) +} + +func (suite *ExchangeUtilsSuite) TestValidateBackupDetailFlags() { + table := []struct { + name string + backupID string + expect assert.ErrorAssertionFunc + }{ + { + name: "with backupid", + backupID: "bid", + expect: assert.NoError, + }, + { + name: "no backupid", + expect: assert.Error, + }, + } + for _, test := range table { + suite.T().Run(test.name, func(t *testing.T) { + test.expect(t, utils.ValidateExchangeRestoreFlags(test.backupID)) + }) + } +} + +func (suite *ExchangeUtilsSuite) TestIncludeExchangeBackupDetailDataSelectors() { + stub := []string{"id-stub"} + many := []string{"fnord", "smarf"} + a := []string{utils.Wildcard} + + table := []struct { + name string + contacts, contactFolders, emails, emailFolders, events, eventCalendars, users []string + expectIncludeLen int + }{ + { + name: "no selectors", + expectIncludeLen: 3, + }, + { + name: "any users", + users: a, + expectIncludeLen: 3, + }, + { + name: "single user", + users: stub, + expectIncludeLen: 3, + }, + { + name: "multiple users", + users: many, + expectIncludeLen: 3, + }, + { + name: "any users, any data", + contacts: a, + contactFolders: a, + emails: a, + emailFolders: a, + events: a, + eventCalendars: a, + users: a, + expectIncludeLen: 3, + }, + { + name: "any users, any folders", + contactFolders: a, + emailFolders: a, + eventCalendars: a, + users: a, + expectIncludeLen: 3, + }, + { + name: "single user, single of each data", + contacts: stub, + contactFolders: stub, + emails: stub, + emailFolders: stub, + events: stub, + eventCalendars: stub, + users: stub, + expectIncludeLen: 3, + }, + { + name: "single user, single of each folder", + contactFolders: stub, + emailFolders: stub, + eventCalendars: stub, + users: stub, + expectIncludeLen: 3, + }, + { + name: "any users, contacts", + contacts: a, + contactFolders: stub, + users: a, + expectIncludeLen: 1, + }, + { + name: "single user, contacts", + contacts: stub, + contactFolders: stub, + users: stub, + expectIncludeLen: 1, + }, + { + name: "any users, emails", + emails: a, + emailFolders: stub, + users: a, + expectIncludeLen: 1, + }, + { + name: "single user, emails", + emails: stub, + emailFolders: stub, + users: stub, + expectIncludeLen: 1, + }, + { + name: "any users, events", + events: a, + eventCalendars: a, + users: a, + expectIncludeLen: 1, + }, + { + name: "single user, events", + events: stub, + eventCalendars: stub, + users: stub, + expectIncludeLen: 1, + }, + { + name: "any users, contacts + email", + contacts: a, + contactFolders: a, + emails: a, + emailFolders: a, + users: a, + expectIncludeLen: 2, + }, + { + name: "single users, contacts + email", + contacts: stub, + contactFolders: stub, + emails: stub, + emailFolders: stub, + users: stub, + expectIncludeLen: 2, + }, + { + name: "any users, email + event", + emails: a, + emailFolders: a, + events: a, + eventCalendars: a, + users: a, + expectIncludeLen: 2, + }, + { + name: "single users, email + event", + emails: stub, + emailFolders: stub, + events: stub, + eventCalendars: stub, + users: stub, + expectIncludeLen: 2, + }, + { + name: "any users, event + contact", + contacts: a, + contactFolders: a, + events: a, + eventCalendars: a, + users: a, + expectIncludeLen: 2, + }, + { + name: "single users, event + contact", + contacts: stub, + contactFolders: stub, + events: stub, + eventCalendars: stub, + users: stub, + expectIncludeLen: 2, + }, + { + name: "many users, events", + events: many, + eventCalendars: many, + users: many, + expectIncludeLen: 1, + }, + { + name: "many users, events + contacts", + contacts: many, + contactFolders: many, + events: many, + eventCalendars: many, + users: many, + expectIncludeLen: 2, + }, + { + name: "mail, no folder or user", + emails: stub, + expectIncludeLen: 1, + }, + { + name: "contacts, no folder or user", + contacts: stub, + expectIncludeLen: 1, + }, + { + name: "event, no folder or user", + events: stub, + expectIncludeLen: 1, + }, + } + for _, test := range table { + suite.T().Run(test.name, func(t *testing.T) { + sel := selectors.NewExchangeRestore() + utils.IncludeExchangeRestoreDataSelectors( + sel, + test.contacts, + test.contactFolders, + test.emails, + test.emailFolders, + test.events, + test.eventCalendars, + test.users) + assert.Len(t, sel.Includes, test.expectIncludeLen) + }) + } +} + +func (suite *ExchangeUtilsSuite) TestFilterExchangeBackupDetailInfoSelectors() { + stub := "id-stub" + + table := []struct { + name string + contactName string + after, before, sender, subject string + organizer, recurs, startsAfter, startsBefore, eventSubject string + expectFilterLen int + }{ + { + name: "no selectors", + expectFilterLen: 0, + }, + { + name: "contactName", + contactName: stub, + expectFilterLen: 1, + }, + { + name: "receivedAfter", + after: stub, + expectFilterLen: 1, + }, + { + name: "receivedAfter", + after: stub, + expectFilterLen: 1, + }, + { + name: "receivedBefore", + before: stub, + expectFilterLen: 1, + }, + { + name: "sender", + sender: stub, + expectFilterLen: 1, + }, + { + name: "subject", + subject: stub, + expectFilterLen: 1, + }, + { + name: "organizer", + organizer: stub, + expectFilterLen: 1, + }, + { + name: "recurs", + recurs: stub, + expectFilterLen: 1, + }, + { + name: "startsAfter", + startsAfter: stub, + expectFilterLen: 1, + }, + { + name: "startsBefore", + startsBefore: stub, + expectFilterLen: 1, + }, + { + name: "eventSubject", + eventSubject: stub, + expectFilterLen: 1, + }, + { + name: "one of each", + contactName: stub, + after: stub, + before: stub, + sender: stub, + subject: stub, + organizer: stub, + recurs: stub, + startsAfter: stub, + startsBefore: stub, + eventSubject: stub, + expectFilterLen: 10, + }, + } + for _, test := range table { + suite.T().Run(test.name, func(t *testing.T) { + sel := selectors.NewExchangeRestore() + utils.FilterExchangeRestoreInfoSelectors( + sel, + test.contactName, + test.after, + test.before, + test.sender, + test.subject, + test.organizer, + test.recurs, + test.startsAfter, + test.startsBefore, + test.eventSubject) + assert.Len(t, sel.Filters, test.expectFilterLen) + }) + } +}