larryh/corso
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

flexible restore/details flags (#821)

Browse Source 
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.
This commit is contained in:
Keepers 2022-09-12 18:13:50 -06:00 committed by GitHub
parent fa489782a3
commit c82dad6e40
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 379 additions and 863 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/cli/backup/exchange.go
View File

@ -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)

402
src/cli/backup/exchange_test.go
View File

@ -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))
})
}
}

11
src/cli/restore/exchange.go
View File

@ -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
}

403
src/cli/restore/exchange_test.go
View File

@ -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))
})
}
}

54
src/cli/utils/exchange.go
View File

@ -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 {

358
src/cli/utils/exchange_test.go Normal file
View File

@ -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)
})
}
}