package operations import ( "context" "encoding/json" stdpath "path" "testing" "time" "github.com/alcionai/clues" "github.com/kopia/kopia/snapshot" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" "github.com/alcionai/corso/src/cli/config" "github.com/alcionai/corso/src/internal/common/prefixmatcher" "github.com/alcionai/corso/src/internal/data" evmock "github.com/alcionai/corso/src/internal/events/mock" "github.com/alcionai/corso/src/internal/kopia" "github.com/alcionai/corso/src/internal/m365/graph" "github.com/alcionai/corso/src/internal/m365/mock" odConsts "github.com/alcionai/corso/src/internal/m365/service/onedrive/consts" odMock "github.com/alcionai/corso/src/internal/m365/service/onedrive/mock" "github.com/alcionai/corso/src/internal/m365/support" "github.com/alcionai/corso/src/internal/model" "github.com/alcionai/corso/src/internal/operations/inject" "github.com/alcionai/corso/src/internal/streamstore" ssmock "github.com/alcionai/corso/src/internal/streamstore/mock" "github.com/alcionai/corso/src/internal/tester" "github.com/alcionai/corso/src/internal/tester/tconfig" "github.com/alcionai/corso/src/pkg/account" "github.com/alcionai/corso/src/pkg/backup" "github.com/alcionai/corso/src/pkg/backup/details" deeTD "github.com/alcionai/corso/src/pkg/backup/details/testdata" "github.com/alcionai/corso/src/pkg/backup/identity" "github.com/alcionai/corso/src/pkg/control" "github.com/alcionai/corso/src/pkg/control/repository" "github.com/alcionai/corso/src/pkg/extensions" "github.com/alcionai/corso/src/pkg/fault" "github.com/alcionai/corso/src/pkg/path" "github.com/alcionai/corso/src/pkg/selectors" selTD "github.com/alcionai/corso/src/pkg/selectors/testdata" "github.com/alcionai/corso/src/pkg/services/m365/api" storeTD "github.com/alcionai/corso/src/pkg/storage/testdata" "github.com/alcionai/corso/src/pkg/store" ) // --------------------------------------------------------------------------- // mocks // --------------------------------------------------------------------------- // ----- restore producer type mockRestoreProducer struct { gotPaths []path.Path colls []data.RestoreCollection collsByID map[string][]data.RestoreCollection // snapshotID: []RestoreCollection err error onRestore restoreFunc } type restoreFunc func( id string, ps []path.RestorePaths, ) ([]data.RestoreCollection, error) func (mr *mockRestoreProducer) buildRestoreFunc( t *testing.T, oid string, ops []path.Path, ) { mr.onRestore = func( id string, ps []path.RestorePaths, ) ([]data.RestoreCollection, error) { gotPaths := make([]path.Path, 0, len(ps)) for _, rp := range ps { gotPaths = append(gotPaths, rp.StoragePath) } assert.Equal(t, oid, id, "manifest id") checkPaths(t, ops, gotPaths) return mr.colls, mr.err } } func (mr *mockRestoreProducer) ProduceRestoreCollections( ctx context.Context, snapshotID string, paths []path.RestorePaths, bc kopia.ByteCounter, errs *fault.Bus, ) ([]data.RestoreCollection, error) { for _, ps := range paths { mr.gotPaths = append(mr.gotPaths, ps.StoragePath) } if mr.onRestore != nil { return mr.onRestore(snapshotID, paths) } if len(mr.collsByID) > 0 { return mr.collsByID[snapshotID], mr.err } return mr.colls, mr.err } func checkPaths(t *testing.T, expected, got []path.Path) { assert.ElementsMatch(t, expected, got) } // ----- backup consumer type mockBackupConsumer struct { checkFunc func( backupReasons []identity.Reasoner, bases kopia.BackupBases, cs []data.BackupCollection, tags map[string]string, buildTreeWithBase bool) } func (mbu mockBackupConsumer) ConsumeBackupCollections( ctx context.Context, backupReasons []identity.Reasoner, bases kopia.BackupBases, cs []data.BackupCollection, excluded prefixmatcher.StringSetReader, tags map[string]string, buildTreeWithBase bool, errs *fault.Bus, ) (*kopia.BackupStats, *details.Builder, kopia.DetailsMergeInfoer, error) { if mbu.checkFunc != nil { mbu.checkFunc(backupReasons, bases, cs, tags, buildTreeWithBase) } return &kopia.BackupStats{}, &details.Builder{}, nil, nil } // ----- model store for backups type mockDetailsMergeInfoer struct { repoRefs map[string]path.Path locs map[string]*path.Builder modTimes map[string]time.Time } func (m *mockDetailsMergeInfoer) add(oldRef, newRef path.Path, newLoc *path.Builder) { oldPB := oldRef.ToBuilder() // Items are indexed individually. m.repoRefs[oldPB.ShortRef()] = newRef // Locations are indexed by directory. m.locs[oldPB.ShortRef()] = newLoc } func (m *mockDetailsMergeInfoer) addWithModTime( oldRef path.Path, modTime time.Time, newRef path.Path, newLoc *path.Builder, ) { oldPB := oldRef.ToBuilder() // Items are indexed individually. m.repoRefs[oldPB.ShortRef()] = newRef m.modTimes[oldPB.ShortRef()] = modTime // Locations are indexed by directory. m.locs[oldPB.ShortRef()] = newLoc } func (m *mockDetailsMergeInfoer) GetNewPathRefs( oldRef *path.Builder, modTime time.Time, _ details.LocationIDer, ) (path.Path, *path.Builder, error) { // Return no match if the modTime was set and it wasn't what was passed in. if mt, ok := m.modTimes[oldRef.ShortRef()]; ok && !mt.Equal(modTime) { return nil, nil, nil } return m.repoRefs[oldRef.ShortRef()], m.locs[oldRef.ShortRef()], nil } func (m *mockDetailsMergeInfoer) ItemsToMerge() int { if m == nil { return 0 } return len(m.repoRefs) } func newMockDetailsMergeInfoer() *mockDetailsMergeInfoer { return &mockDetailsMergeInfoer{ repoRefs: map[string]path.Path{}, locs: map[string]*path.Builder{}, modTimes: map[string]time.Time{}, } } // --------------------------------------------------------------------------- // helper funcs // --------------------------------------------------------------------------- // expects you to Append your own file func makeMetadataBasePath( t *testing.T, tenant string, service path.ServiceType, resourceOwner string, category path.CategoryType, ) path.Path { t.Helper() p, err := path.Builder{}.ToServiceCategoryMetadataPath( tenant, resourceOwner, service, category, false) require.NoError(t, err, clues.ToCore(err)) return p } func makeFolderEntry( t *testing.T, pb, loc *path.Builder, size int64, modTime time.Time, dt details.ItemType, ) *details.Entry { t.Helper() return &details.Entry{ RepoRef: pb.String(), ShortRef: pb.ShortRef(), ParentRef: pb.Dir().ShortRef(), LocationRef: loc.Dir().String(), ItemInfo: details.ItemInfo{ Folder: &details.FolderInfo{ ItemType: details.FolderItem, DisplayName: pb.LastElem(), Modified: modTime, Size: size, DataType: dt, }, }, } } // TODO(ashmrtn): Really need to factor a function like this out into some // common file that is only compiled for tests. func makePath(t *testing.T, elements []string, isItem bool) path.Path { t.Helper() p, err := path.FromDataLayerPath(stdpath.Join(elements...), isItem) require.NoError(t, err, clues.ToCore(err)) return p } func makeDetailsEntry( t *testing.T, p path.Path, l *path.Builder, size int, updated bool, ) *details.Entry { t.Helper() var lr string if l != nil { lr = l.String() } res := &details.Entry{ RepoRef: p.String(), ShortRef: p.ShortRef(), ParentRef: p.ToBuilder().Dir().ShortRef(), ItemRef: p.Item(), LocationRef: lr, ItemInfo: details.ItemInfo{}, } switch p.Service() { case path.ExchangeService: if p.Category() != path.EmailCategory { assert.FailNowf( t, "category %s not supported in helper function", p.Category().String(), ) } res.Exchange = &details.ExchangeInfo{ ItemType: details.ExchangeMail, Size: int64(size), ParentPath: l.String(), } case path.OneDriveService: require.NotNil(t, l) res.OneDrive = &details.OneDriveInfo{ ItemType: details.OneDriveItem, ParentPath: l.PopFront().String(), Size: int64(size), DriveID: "drive-id", DriveName: "drive-name", } default: assert.FailNowf( t, "service %s not supported in helper function", p.Service().String()) } return res } func makeDetailsEntryWithModTime( t *testing.T, p path.Path, l *path.Builder, size int, updated bool, modTime time.Time, ) *details.Entry { t.Helper() res := makeDetailsEntry(t, p, l, size, updated) switch { case res.Exchange != nil: res.Exchange.Modified = modTime case res.OneDrive != nil: res.OneDrive.Modified = modTime case res.SharePoint != nil: res.SharePoint.Modified = modTime } return res } // --------------------------------------------------------------------------- // unit tests // --------------------------------------------------------------------------- type BackupOpUnitSuite struct { tester.Suite } func TestBackupOpUnitSuite(t *testing.T) { suite.Run(t, &BackupOpUnitSuite{Suite: tester.NewUnitSuite(t)}) } func (suite *BackupOpUnitSuite) TestBackupOperation_PersistResults() { var ( kw = &kopia.Wrapper{} sw = store.NewWrapper(&kopia.ModelStore{}) ctrl = &mock.Controller{} acct = account.Account{} now = time.Now() ) table := []struct { expectStatus OpStatus expectErr assert.ErrorAssertionFunc stats backupStats fail error }{ { expectStatus: Completed, expectErr: assert.NoError, stats: backupStats{ resourceCount: 1, k: &kopia.BackupStats{ TotalFileCount: 1, TotalHashedBytes: 1, TotalUploadedBytes: 1, }, ctrl: &data.CollectionStats{Successes: 1}, }, }, { expectStatus: Failed, expectErr: assert.Error, fail: assert.AnError, stats: backupStats{ k: &kopia.BackupStats{}, ctrl: &data.CollectionStats{}, }, }, { expectStatus: NoData, expectErr: assert.NoError, stats: backupStats{ k: &kopia.BackupStats{}, ctrl: &data.CollectionStats{}, }, }, } for _, test := range table { suite.Run(test.expectStatus.String(), func() { t := suite.T() ctx, flush := tester.NewContext(t) defer flush() sel := selectors.Selector{} sel.DiscreteOwner = "bombadil" op, err := NewBackupOperation( ctx, control.DefaultOptions(), kw, sw, ctrl, acct, sel, sel, evmock.NewBus()) require.NoError(t, err, clues.ToCore(err)) op.Errors.Fail(test.fail) test.expectErr(t, op.persistResults(now, &test.stats)) assert.Equal(t, test.expectStatus.String(), op.Status.String(), "status") assert.Equal(t, test.stats.ctrl.Successes, op.Results.ItemsRead, "items read") assert.Equal(t, test.stats.k.TotalFileCount, op.Results.ItemsWritten, "items written") assert.Equal(t, test.stats.k.TotalHashedBytes, op.Results.BytesRead, "bytes read") assert.Equal(t, test.stats.k.TotalUploadedBytes, op.Results.BytesUploaded, "bytes written") assert.Equal(t, test.stats.resourceCount, op.Results.ResourceOwners, "resource owners") assert.Equal(t, now, op.Results.StartedAt, "started at") assert.Less(t, now, op.Results.CompletedAt, "completed at") }) } } func (suite *BackupOpUnitSuite) TestBackupOperation_ConsumeBackupDataCollections_Paths() { var ( t = suite.T() tenant = "a-tenant" resourceOwner = "a-user" emailReason = kopia.NewReason( tenant, resourceOwner, path.ExchangeService, path.EmailCategory) contactsReason = kopia.NewReason( tenant, resourceOwner, path.ExchangeService, path.ContactsCategory) reasons = []identity.Reasoner{ emailReason, contactsReason, } manifest1 = &snapshot.Manifest{ ID: "id1", } manifest2 = &snapshot.Manifest{ ID: "id2", } bases = kopia.NewMockBackupBases().WithMergeBases( kopia.ManifestEntry{ Manifest: manifest1, Reasons: []identity.Reasoner{ emailReason, }, }).WithAssistBases( kopia.ManifestEntry{ Manifest: manifest2, Reasons: []identity.Reasoner{ contactsReason, }, }) backupID = model.StableID("foo") expectedTags = map[string]string{ kopia.TagBackupID: string(backupID), kopia.TagBackupCategory: "", } ) mbu := &mockBackupConsumer{ checkFunc: func( backupReasons []identity.Reasoner, gotBases kopia.BackupBases, cs []data.BackupCollection, gotTags map[string]string, buildTreeWithBase bool, ) { kopia.AssertBackupBasesEqual(t, bases, gotBases) assert.Equal(t, expectedTags, gotTags) assert.ElementsMatch(t, reasons, backupReasons) }, } ctx, flush := tester.NewContext(t) defer flush() //nolint:errcheck consumeBackupCollections( ctx, mbu, tenant, reasons, bases, nil, nil, backupID, true, fault.New(true)) } func (suite *BackupOpUnitSuite) TestBackupOperation_MergeBackupDetails_AddsItems() { var ( tenant = "a-tenant" ro = "a-user" itemPath1 = makePath( suite.T(), []string{ tenant, path.OneDriveService.String(), ro, path.FilesCategory.String(), odConsts.DrivesPathDir, "drive-id", odConsts.RootPathDir, "work", "item1", }, true, ) locationPath1 = path.Builder{}.Append(odConsts.RootPathDir, "work-display-name") itemPath2 = makePath( suite.T(), []string{ tenant, path.OneDriveService.String(), ro, path.FilesCategory.String(), odConsts.DrivesPathDir, "drive-id", odConsts.RootPathDir, "personal", "item2", }, true, ) locationPath2 = path.Builder{}.Append(odConsts.RootPathDir, "personal-display-name") itemPath3 = makePath( suite.T(), []string{ tenant, path.ExchangeService.String(), ro, path.EmailCategory.String(), "personal", "item3", }, true, ) locationPath3 = path.Builder{}.Append("personal-display-name") backup1 = backup.Backup{ BaseModel: model.BaseModel{ ID: "bid1", }, DetailsID: "did1", } backup2 = backup.Backup{ BaseModel: model.BaseModel{ ID: "bid2", }, DetailsID: "did2", } pathReason1 = kopia.NewReason( "", itemPath1.ResourceOwner(), itemPath1.Service(), itemPath1.Category()) pathReason3 = kopia.NewReason( "", itemPath3.ResourceOwner(), itemPath3.Service(), itemPath3.Category()) time1 = time.Now() time2 = time1.Add(time.Hour) ) itemParents1, err := path.GetDriveFolderPath(itemPath1) require.NoError(suite.T(), err, clues.ToCore(err)) itemParents1String := itemParents1.String() table := []struct { name string populatedDetails map[string]*details.Details inputBackups []kopia.BackupEntry inputAssistBackups []kopia.BackupEntry mdm *mockDetailsMergeInfoer errCheck assert.ErrorAssertionFunc expectedEntries []*details.Entry }{ { name: "NilShortRefsFromPrevBackup", errCheck: assert.NoError, // Use empty slice so we don't error out on nil != empty. expectedEntries: []*details.Entry{}, }, { name: "EmptyShortRefsFromPrevBackup", mdm: newMockDetailsMergeInfoer(), errCheck: assert.NoError, // Use empty slice so we don't error out on nil != empty. expectedEntries: []*details.Entry{}, }, { name: "DetailsIDNotFound", mdm: func() *mockDetailsMergeInfoer { res := newMockDetailsMergeInfoer() res.add(itemPath1, itemPath1, locationPath1) return res }(), inputBackups: []kopia.BackupEntry{ { Backup: &backup.Backup{ BaseModel: model.BaseModel{ ID: backup1.ID, }, DetailsID: "foo", }, Reasons: []identity.Reasoner{ pathReason1, }, }, }, errCheck: assert.Error, }, { name: "BaseMissingItems", mdm: func() *mockDetailsMergeInfoer { res := newMockDetailsMergeInfoer() res.add(itemPath1, itemPath1, locationPath1) res.add(itemPath2, itemPath2, locationPath2) return res }(), inputBackups: []kopia.BackupEntry{ { Backup: &backup1, Reasons: []identity.Reasoner{ pathReason1, }, }, }, populatedDetails: map[string]*details.Details{ backup1.DetailsID: { DetailsModel: details.DetailsModel{ Entries: []details.Entry{ *makeDetailsEntry(suite.T(), itemPath1, locationPath1, 42, false), }, }, }, }, errCheck: assert.Error, }, { name: "BadBaseRepoRef", mdm: func() *mockDetailsMergeInfoer { res := newMockDetailsMergeInfoer() res.add(itemPath1, itemPath2, locationPath2) return res }(), inputBackups: []kopia.BackupEntry{ { Backup: &backup1, Reasons: []identity.Reasoner{ pathReason1, }, }, }, populatedDetails: map[string]*details.Details{ backup1.DetailsID: { DetailsModel: details.DetailsModel{ Entries: []details.Entry{ { RepoRef: stdpath.Join( append( []string{ itemPath1.Tenant(), itemPath1.Service().String(), itemPath1.ResourceOwner(), path.UnknownCategory.String(), }, itemPath1.Folders()..., )..., ), ItemInfo: details.ItemInfo{ OneDrive: &details.OneDriveInfo{ ItemType: details.OneDriveItem, ParentPath: itemParents1String, Size: 42, }, }, }, }, }, }, }, errCheck: assert.Error, }, { name: "BadOneDrivePath", mdm: func() *mockDetailsMergeInfoer { res := newMockDetailsMergeInfoer() p := makePath( suite.T(), []string{ itemPath1.Tenant(), path.OneDriveService.String(), itemPath1.ResourceOwner(), path.FilesCategory.String(), "personal", "item1", }, true, ) res.add(itemPath1, p, nil) return res }(), inputBackups: []kopia.BackupEntry{ { Backup: &backup1, Reasons: []identity.Reasoner{ pathReason1, }, }, }, populatedDetails: map[string]*details.Details{ backup1.DetailsID: { DetailsModel: details.DetailsModel{ Entries: []details.Entry{ *makeDetailsEntry(suite.T(), itemPath1, locationPath1, 42, false), }, }, }, }, errCheck: assert.Error, }, { name: "ItemMerged", mdm: func() *mockDetailsMergeInfoer { res := newMockDetailsMergeInfoer() res.add(itemPath1, itemPath1, locationPath1) return res }(), inputBackups: []kopia.BackupEntry{ { Backup: &backup1, Reasons: []identity.Reasoner{ pathReason1, }, }, }, populatedDetails: map[string]*details.Details{ backup1.DetailsID: { DetailsModel: details.DetailsModel{ Entries: []details.Entry{ *makeDetailsEntry(suite.T(), itemPath1, locationPath1, 42, false), }, }, }, }, errCheck: assert.NoError, expectedEntries: []*details.Entry{ makeDetailsEntry(suite.T(), itemPath1, locationPath1, 42, false), }, }, { name: "ItemMergedSameLocation", mdm: func() *mockDetailsMergeInfoer { res := newMockDetailsMergeInfoer() res.add(itemPath1, itemPath1, locationPath1) return res }(), inputBackups: []kopia.BackupEntry{ { Backup: &backup1, Reasons: []identity.Reasoner{ pathReason1, }, }, }, populatedDetails: map[string]*details.Details{ backup1.DetailsID: { DetailsModel: details.DetailsModel{ Entries: []details.Entry{ *makeDetailsEntry(suite.T(), itemPath1, locationPath1, 42, false), }, }, }, }, errCheck: assert.NoError, expectedEntries: []*details.Entry{ makeDetailsEntry(suite.T(), itemPath1, locationPath1, 42, false), }, }, { name: "ItemMergedExtraItemsInBase", mdm: func() *mockDetailsMergeInfoer { res := newMockDetailsMergeInfoer() res.add(itemPath1, itemPath1, locationPath1) return res }(), inputBackups: []kopia.BackupEntry{ { Backup: &backup1, Reasons: []identity.Reasoner{ pathReason1, }, }, }, populatedDetails: map[string]*details.Details{ backup1.DetailsID: { DetailsModel: details.DetailsModel{ Entries: []details.Entry{ *makeDetailsEntry(suite.T(), itemPath1, locationPath1, 42, false), *makeDetailsEntry(suite.T(), itemPath2, locationPath2, 84, false), }, }, }, }, errCheck: assert.NoError, expectedEntries: []*details.Entry{ makeDetailsEntry(suite.T(), itemPath1, locationPath1, 42, false), }, }, { name: "ItemMoved", mdm: func() *mockDetailsMergeInfoer { res := newMockDetailsMergeInfoer() res.add(itemPath1, itemPath2, locationPath2) return res }(), inputBackups: []kopia.BackupEntry{ { Backup: &backup1, Reasons: []identity.Reasoner{ pathReason1, }, }, }, populatedDetails: map[string]*details.Details{ backup1.DetailsID: { DetailsModel: details.DetailsModel{ Entries: []details.Entry{ *makeDetailsEntry(suite.T(), itemPath1, locationPath1, 42, false), }, }, }, }, errCheck: assert.NoError, expectedEntries: []*details.Entry{ makeDetailsEntry(suite.T(), itemPath2, locationPath2, 42, true), }, }, { name: "MultipleBases", mdm: func() *mockDetailsMergeInfoer { res := newMockDetailsMergeInfoer() res.add(itemPath1, itemPath1, locationPath1) res.add(itemPath3, itemPath3, locationPath3) return res }(), inputBackups: []kopia.BackupEntry{ { Backup: &backup1, Reasons: []identity.Reasoner{ pathReason1, }, }, { Backup: &backup2, Reasons: []identity.Reasoner{ pathReason3, }, }, }, populatedDetails: map[string]*details.Details{ backup1.DetailsID: { DetailsModel: details.DetailsModel{ Entries: []details.Entry{ *makeDetailsEntry(suite.T(), itemPath1, locationPath1, 42, false), }, }, }, backup2.DetailsID: { DetailsModel: details.DetailsModel{ Entries: []details.Entry{ // This entry should not be picked due to a mismatch on Reasons. *makeDetailsEntry(suite.T(), itemPath1, locationPath1, 84, false), // This item should be picked. *makeDetailsEntry(suite.T(), itemPath3, locationPath3, 37, false), }, }, }, }, errCheck: assert.NoError, expectedEntries: []*details.Entry{ makeDetailsEntry(suite.T(), itemPath1, locationPath1, 42, false), makeDetailsEntry(suite.T(), itemPath3, locationPath3, 37, false), }, }, { name: "MergeAndAssistBases SameItems", mdm: func() *mockDetailsMergeInfoer { res := newMockDetailsMergeInfoer() res.addWithModTime(itemPath1, time1, itemPath1, locationPath1) res.addWithModTime(itemPath3, time2, itemPath3, locationPath3) return res }(), inputBackups: []kopia.BackupEntry{ { Backup: &backup1, Reasons: []identity.Reasoner{ pathReason1, pathReason3, }, }, }, inputAssistBackups: []kopia.BackupEntry{ {Backup: &backup2}, }, populatedDetails: map[string]*details.Details{ backup1.DetailsID: { DetailsModel: details.DetailsModel{ Entries: []details.Entry{ *makeDetailsEntryWithModTime(suite.T(), itemPath1, locationPath1, 42, false, time1), *makeDetailsEntryWithModTime(suite.T(), itemPath3, locationPath3, 37, false, time2), }, }, }, backup2.DetailsID: { DetailsModel: details.DetailsModel{ Entries: []details.Entry{ *makeDetailsEntryWithModTime(suite.T(), itemPath1, locationPath1, 42, false, time1), *makeDetailsEntryWithModTime(suite.T(), itemPath3, locationPath3, 37, false, time2), }, }, }, }, errCheck: assert.NoError, expectedEntries: []*details.Entry{ makeDetailsEntryWithModTime(suite.T(), itemPath1, locationPath1, 42, false, time1), makeDetailsEntryWithModTime(suite.T(), itemPath3, locationPath3, 37, false, time2), }, }, { name: "MergeAndAssistBases AssistBaseHasNewerItems", mdm: func() *mockDetailsMergeInfoer { res := newMockDetailsMergeInfoer() res.addWithModTime(itemPath1, time2, itemPath1, locationPath1) return res }(), inputBackups: []kopia.BackupEntry{ { Backup: &backup1, Reasons: []identity.Reasoner{ pathReason1, }, }, }, inputAssistBackups: []kopia.BackupEntry{ {Backup: &backup2}, }, populatedDetails: map[string]*details.Details{ backup1.DetailsID: { DetailsModel: details.DetailsModel{ Entries: []details.Entry{ *makeDetailsEntryWithModTime(suite.T(), itemPath1, locationPath1, 42, false, time1), }, }, }, backup2.DetailsID: { DetailsModel: details.DetailsModel{ Entries: []details.Entry{ *makeDetailsEntryWithModTime(suite.T(), itemPath1, locationPath1, 84, false, time2), }, }, }, }, errCheck: assert.NoError, expectedEntries: []*details.Entry{ makeDetailsEntryWithModTime(suite.T(), itemPath1, locationPath1, 84, false, time2), }, }, { name: "AssistBases ConcurrentAssistBasesPicksMatchingVersion1", mdm: func() *mockDetailsMergeInfoer { res := newMockDetailsMergeInfoer() res.addWithModTime(itemPath1, time2, itemPath1, locationPath1) return res }(), inputAssistBackups: []kopia.BackupEntry{ {Backup: &backup1}, {Backup: &backup2}, }, populatedDetails: map[string]*details.Details{ backup1.DetailsID: { DetailsModel: details.DetailsModel{ Entries: []details.Entry{ *makeDetailsEntryWithModTime(suite.T(), itemPath1, locationPath1, 42, false, time1), }, }, }, backup2.DetailsID: { DetailsModel: details.DetailsModel{ Entries: []details.Entry{ *makeDetailsEntryWithModTime(suite.T(), itemPath1, locationPath1, 84, false, time2), }, }, }, }, errCheck: assert.NoError, expectedEntries: []*details.Entry{ makeDetailsEntryWithModTime(suite.T(), itemPath1, locationPath1, 84, false, time2), }, }, { name: "AssistBases ConcurrentAssistBasesPicksMatchingVersion2", mdm: func() *mockDetailsMergeInfoer { res := newMockDetailsMergeInfoer() res.addWithModTime(itemPath1, time1, itemPath1, locationPath1) return res }(), inputAssistBackups: []kopia.BackupEntry{ {Backup: &backup1}, {Backup: &backup2}, }, populatedDetails: map[string]*details.Details{ backup1.DetailsID: { DetailsModel: details.DetailsModel{ Entries: []details.Entry{ *makeDetailsEntryWithModTime(suite.T(), itemPath1, locationPath1, 42, false, time1), }, }, }, backup2.DetailsID: { DetailsModel: details.DetailsModel{ Entries: []details.Entry{ *makeDetailsEntryWithModTime(suite.T(), itemPath1, locationPath1, 84, false, time2), }, }, }, }, errCheck: assert.NoError, expectedEntries: []*details.Entry{ makeDetailsEntryWithModTime(suite.T(), itemPath1, locationPath1, 42, false, time1), }, }, { name: "AssistBases SameItemVersion", mdm: func() *mockDetailsMergeInfoer { res := newMockDetailsMergeInfoer() res.addWithModTime(itemPath1, time1, itemPath1, locationPath1) return res }(), inputAssistBackups: []kopia.BackupEntry{ {Backup: &backup1}, {Backup: &backup2}, }, populatedDetails: map[string]*details.Details{ backup1.DetailsID: { DetailsModel: details.DetailsModel{ Entries: []details.Entry{ *makeDetailsEntryWithModTime(suite.T(), itemPath1, locationPath1, 42, false, time1), }, }, }, backup2.DetailsID: { DetailsModel: details.DetailsModel{ Entries: []details.Entry{ *makeDetailsEntryWithModTime(suite.T(), itemPath1, locationPath1, 42, false, time1), }, }, }, }, errCheck: assert.NoError, expectedEntries: []*details.Entry{ makeDetailsEntryWithModTime(suite.T(), itemPath1, locationPath1, 42, false, time1), }, }, { name: "AssistBase ItemDeleted", mdm: func() *mockDetailsMergeInfoer { return newMockDetailsMergeInfoer() }(), inputAssistBackups: []kopia.BackupEntry{ {Backup: &backup1}, }, populatedDetails: map[string]*details.Details{ backup1.DetailsID: { DetailsModel: details.DetailsModel{ Entries: []details.Entry{ *makeDetailsEntryWithModTime(suite.T(), itemPath1, locationPath1, 42, false, time1), }, }, }, }, errCheck: assert.NoError, expectedEntries: []*details.Entry{}, }, } for _, test := range table { suite.Run(test.name, func() { t := suite.T() ctx, flush := tester.NewContext(t) defer flush() mds := ssmock.Streamer{Deets: test.populatedDetails} deets := details.Builder{} writeStats := kopia.BackupStats{} bb := kopia.NewMockBackupBases(). WithBackups(test.inputBackups...). WithAssistBackups(test.inputAssistBackups...) err := mergeDetails( ctx, mds, bb, test.mdm, &deets, &writeStats, path.OneDriveService, fault.New(true)) test.errCheck(t, err, clues.ToCore(err)) if err != nil { return } // Check the JSON output format of things because for some reason it's not // using the proper comparison for time.Time and failing due to that. checkJSONOutputs(t, test.expectedEntries, deets.Details().Items()) }) } } func checkJSONOutputs( t *testing.T, expected []*details.Entry, got []*details.Entry, ) { t.Helper() expectedJSON, err := json.Marshal(expected) require.NoError(t, err, "marshalling expected data") gotJSON, err := json.Marshal(got) require.NoError(t, err, "marshalling got data") assert.JSONEq(t, string(expectedJSON), string(gotJSON)) } func (suite *BackupOpUnitSuite) TestBackupOperation_MergeBackupDetails_AddsFolders() { var ( t = suite.T() tenant = "a-tenant" ro = "a-user" pathElems = []string{ tenant, path.ExchangeService.String(), ro, path.EmailCategory.String(), "work", "project8", "item1", } itemPath1 = makePath( t, pathElems, true) locPath1 = path.Builder{}.Append(itemPath1.Folders()...) pathReason1 = kopia.NewReason( "", itemPath1.ResourceOwner(), itemPath1.Service(), itemPath1.Category()) backup1 = kopia.BackupEntry{ Backup: &backup.Backup{ BaseModel: model.BaseModel{ ID: "bid1", }, DetailsID: "did1", }, Reasons: []identity.Reasoner{ pathReason1, }, } itemSize = 42 now = time.Now() // later = now.Add(42 * time.Minute) ) mdm := newMockDetailsMergeInfoer() mdm.add(itemPath1, itemPath1, locPath1) itemDetails := makeDetailsEntry(t, itemPath1, locPath1, itemSize, false) // itemDetails.Exchange.Modified = now populatedDetails := map[string]*details.Details{ backup1.DetailsID: { DetailsModel: details.DetailsModel{ Entries: []details.Entry{*itemDetails}, }, }, } expectedEntries := []details.Entry{*itemDetails} // update the details itemDetails.Exchange.Modified = now for i := 1; i <= len(locPath1.Elements()); i++ { expectedEntries = append(expectedEntries, *makeFolderEntry( t, // Include prefix elements in the RepoRef calculations. path.Builder{}.Append(pathElems[:4+i]...), path.Builder{}.Append(locPath1.Elements()[:i]...), int64(itemSize), itemDetails.Exchange.Modified, details.ExchangeMail)) } ctx, flush := tester.NewContext(t) defer flush() var ( mds = ssmock.Streamer{Deets: populatedDetails} deets = details.Builder{} writeStats = kopia.BackupStats{} ) err := mergeDetails( ctx, mds, kopia.NewMockBackupBases().WithBackups(backup1), mdm, &deets, &writeStats, path.ExchangeService, fault.New(true)) assert.NoError(t, err, clues.ToCore(err)) compareDeetEntries(t, expectedEntries, deets.Details().Entries) } // compares two details slices. Useful for tests where serializing the // entries can produce minor variations in the time struct, causing // assert.elementsMatch to fail. func compareDeetEntries( t *testing.T, expect, result []details.Entry, ) { if !assert.Equal(t, len(expect), len(result), "entry slices should be equal len") { require.ElementsMatch(t, expect, result) } var ( // repoRef -> modified time eMods = map[string]time.Time{} es = make([]details.Entry, 0, len(expect)) rs = make([]details.Entry, 0, len(expect)) ) for _, e := range expect { eMods[e.RepoRef] = e.Modified() es = append(es, withoutModified(e)) } for _, r := range result { // this comparison is an artifact of bad comparisons across time.Time // serialization using assert.ElementsMatch. The time struct can produce // differences in its `ext` value across serialization while the actual time // reference remains the same. assert handles this poorly, whereas the time // library provides successful comparison. assert.Truef( t, eMods[r.RepoRef].Equal(r.Modified()), "expected modified time %v, got %v", eMods[r.RepoRef], r.Modified()) rs = append(rs, withoutModified(r)) } assert.ElementsMatch(t, es, rs) } func withoutModified(de details.Entry) details.Entry { switch { case de.Exchange != nil: de.Exchange.Modified = time.Time{} case de.OneDrive != nil: de.OneDrive.Modified = time.Time{} case de.SharePoint != nil: de.SharePoint.Modified = time.Time{} case de.Folder != nil: de.Folder.Modified = time.Time{} } return de } // --------------------------------------------------------------------------- // integration tests // --------------------------------------------------------------------------- type BackupOpIntegrationSuite struct { tester.Suite user, site string ac api.Client } func TestBackupOpIntegrationSuite(t *testing.T) { suite.Run(t, &BackupOpIntegrationSuite{ Suite: tester.NewIntegrationSuite( t, [][]string{storeTD.AWSStorageCredEnvs, tconfig.M365AcctCredEnvs}), }) } func (suite *BackupOpIntegrationSuite) SetupSuite() { t := suite.T() ctx, flush := tester.NewContext(t) defer flush() graph.InitializeConcurrencyLimiter(ctx, true, 4) suite.user = tconfig.M365UserID(t) suite.site = tconfig.M365SiteID(t) a := tconfig.NewM365Account(t) creds, err := a.M365Config() require.NoError(t, err, clues.ToCore(err)) suite.ac, err = api.NewClient(creds, control.DefaultOptions()) require.NoError(t, err, clues.ToCore(err)) } func (suite *BackupOpIntegrationSuite) TestNewBackupOperation() { var ( kw = &kopia.Wrapper{} sw = store.NewWrapper(&kopia.ModelStore{}) ctrl = &mock.Controller{} acct = tconfig.NewM365Account(suite.T()) opts = control.DefaultOptions() ) table := []struct { name string kw *kopia.Wrapper sw store.BackupStorer bp inject.BackupProducer acct account.Account targets []string errCheck assert.ErrorAssertionFunc }{ {"good", kw, sw, ctrl, acct, nil, assert.NoError}, {"missing kopia", nil, sw, ctrl, acct, nil, assert.Error}, {"missing modelstore", kw, nil, ctrl, acct, nil, assert.Error}, {"missing backup producer", kw, sw, nil, acct, nil, assert.Error}, } for _, test := range table { suite.Run(test.name, func() { t := suite.T() ctx, flush := tester.NewContext(t) defer flush() sel := selectors.Selector{DiscreteOwner: "test"} _, err := NewBackupOperation( ctx, opts, test.kw, test.sw, test.bp, test.acct, sel, sel, evmock.NewBus()) test.errCheck(t, err, clues.ToCore(err)) }) } } type AssistBackupIntegrationSuite struct { tester.Suite kopiaCloser func(ctx context.Context) acct account.Account kw *kopia.Wrapper sw store.BackupStorer ms *kopia.ModelStore } func TestAssistBackupIntegrationSuite(t *testing.T) { suite.Run(t, &AssistBackupIntegrationSuite{ Suite: tester.NewIntegrationSuite( t, [][]string{storeTD.AWSStorageCredEnvs, tconfig.M365AcctCredEnvs}), }) } func (suite *AssistBackupIntegrationSuite) SetupSuite() { t := suite.T() ctx, flush := tester.NewContext(t) defer flush() var ( st = storeTD.NewPrefixedS3Storage(t) k = kopia.NewConn(st) ) suite.acct = tconfig.NewM365Account(t) err := k.Initialize(ctx, repository.Options{}, repository.Retention{}) require.NoError(t, err, clues.ToCore(err)) suite.kopiaCloser = func(ctx context.Context) { k.Close(ctx) } kw, err := kopia.NewWrapper(k) require.NoError(t, err, clues.ToCore(err)) suite.kw = kw ms, err := kopia.NewModelStore(k) require.NoError(t, err, clues.ToCore(err)) suite.ms = ms sw := store.NewWrapper(ms) suite.sw = sw } func (suite *AssistBackupIntegrationSuite) TearDownSuite() { ctx, flush := tester.NewContext(suite.T()) defer flush() if suite.ms != nil { suite.ms.Close(ctx) } if suite.kw != nil { suite.kw.Close(ctx) } if suite.kopiaCloser != nil { suite.kopiaCloser(ctx) } } var _ inject.BackupProducer = &mockBackupProducer{} type mockBackupProducer struct { colls []data.BackupCollection dcs data.CollectionStats injectNonRecoverableErr bool } func (mbp *mockBackupProducer) ProduceBackupCollections( context.Context, inject.BackupProducerConfig, *fault.Bus, ) ([]data.BackupCollection, prefixmatcher.StringSetReader, bool, error) { if mbp.injectNonRecoverableErr { return nil, nil, false, clues.New("non-recoverable error") } return mbp.colls, nil, true, nil } func (mbp *mockBackupProducer) IsBackupRunnable( context.Context, path.ServiceType, string, ) (bool, error) { return true, nil } func (mbp *mockBackupProducer) Wait() *data.CollectionStats { return &mbp.dcs } func makeBackupCollection( p path.Path, locPath *path.Builder, items []odMock.Data, ) data.BackupCollection { streams := make([]data.Stream, len(items)) for i := range items { streams[i] = &items[i] } return &mock.BackupCollection{ Path: p, Loc: locPath, Streams: streams, } } func makeMetadataCollectionEntries( deltaURL, driveID, folderID string, p path.Path, ) []graph.MetadataCollectionEntry { return []graph.MetadataCollectionEntry{ graph.NewMetadataEntry( graph.DeltaURLsFileName, map[string]string{driveID: deltaURL}, ), graph.NewMetadataEntry( graph.PreviousPathFileName, map[string]map[string]string{ driveID: { folderID: p.PlainString(), }, }, ), } } const ( userID = "user-id" driveID = "drive-id" driveName = "drive-name" folderID = "folder-id" ) func makeODMockData( fileID string, extData *details.ExtensionData, modTime time.Time, del bool, readErr error, ) odMock.Data { rc := odMock.FileRespReadCloser(odMock.DriveFilePayloadData) if extData != nil { rc = odMock.FileRespWithExtensions(odMock.DriveFilePayloadData, extData) } return odMock.Data{ ID: fileID, DriveID: driveID, DriveName: driveName, Reader: rc, ReadErr: readErr, Sz: 100, ModifiedTime: modTime, Del: del, ExtensionData: extData, } } // Check what kind of backup is produced for a given failurePolicy/observed fault // bus combination. // // It's currently using errors generated during mockBackupProducer phase. // Ideally we would test with errors generated in various phases of backup, but // that needs putting produceManifestsAndMetadata and mergeDetails behind mockable // interfaces. // // Note: Tests are incremental since we are reusing kopia repo between tests, // but this is irrelevant here. func (suite *AssistBackupIntegrationSuite) TestBackupTypesForFailureModes() { var ( acct = tconfig.NewM365Account(suite.T()) tenantID = acct.Config[config.AzureTenantIDKey] opts = control.DefaultOptions() osel = selectors.NewOneDriveBackup([]string{userID}) ) osel.Include(selTD.OneDriveBackupFolderScope(osel)) pathElements := []string{odConsts.DrivesPathDir, "drive-id", odConsts.RootPathDir, folderID} tmp, err := path.Build(tenantID, userID, path.OneDriveService, path.FilesCategory, false, pathElements...) require.NoError(suite.T(), err, clues.ToCore(err)) locPath := path.Builder{}.Append(tmp.Folders()...) table := []struct { name string collFunc func() []data.BackupCollection injectNonRecoverableErr bool failurePolicy control.FailurePolicy expectRunErr assert.ErrorAssertionFunc expectBackupTag string expectFaults func(t *testing.T, errs *fault.Bus) }{ { name: "fail fast, no errors", collFunc: func() []data.BackupCollection { bc := []data.BackupCollection{ makeBackupCollection( tmp, locPath, []odMock.Data{ makeODMockData("file1", nil, time.Now(), false, nil), }), } return bc }, failurePolicy: control.FailFast, expectRunErr: assert.NoError, expectBackupTag: model.MergeBackup, expectFaults: func(t *testing.T, errs *fault.Bus) { assert.NoError(t, errs.Failure(), clues.ToCore(errs.Failure())) assert.Empty(t, errs.Recovered(), "recovered errors") }, }, { name: "fail fast, any errors", collFunc: func() []data.BackupCollection { bc := []data.BackupCollection{ makeBackupCollection( tmp, locPath, []odMock.Data{ makeODMockData("file1", nil, time.Now(), false, assert.AnError), }), } return bc }, failurePolicy: control.FailFast, expectRunErr: assert.Error, expectBackupTag: "", expectFaults: func(t *testing.T, errs *fault.Bus) { assert.Error(t, errs.Failure(), clues.ToCore(errs.Failure())) }, }, { name: "best effort, no errors", collFunc: func() []data.BackupCollection { bc := []data.BackupCollection{ makeBackupCollection( tmp, locPath, []odMock.Data{ makeODMockData("file1", nil, time.Now(), false, nil), }), } return bc }, failurePolicy: control.BestEffort, expectRunErr: assert.NoError, expectBackupTag: model.MergeBackup, expectFaults: func(t *testing.T, errs *fault.Bus) { assert.NoError(t, errs.Failure(), clues.ToCore(errs.Failure())) assert.Empty(t, errs.Recovered(), "recovered errors") }, }, { name: "best effort, non-recoverable errors", collFunc: func() []data.BackupCollection { return nil }, injectNonRecoverableErr: true, failurePolicy: control.BestEffort, expectRunErr: assert.Error, expectBackupTag: "", expectFaults: func(t *testing.T, errs *fault.Bus) { assert.Error(t, errs.Failure(), clues.ToCore(errs.Failure())) }, }, { name: "best effort, recoverable errors", collFunc: func() []data.BackupCollection { bc := []data.BackupCollection{ makeBackupCollection( tmp, locPath, []odMock.Data{ makeODMockData("file1", nil, time.Now(), false, assert.AnError), }), } return bc }, failurePolicy: control.BestEffort, expectRunErr: assert.NoError, expectBackupTag: model.MergeBackup, expectFaults: func(t *testing.T, errs *fault.Bus) { assert.NoError(t, errs.Failure(), clues.ToCore(errs.Failure())) assert.Greater(t, len(errs.Recovered()), 0, "recovered errors") }, }, { name: "fail after recovery, no errors", collFunc: func() []data.BackupCollection { bc := []data.BackupCollection{ makeBackupCollection( tmp, locPath, []odMock.Data{ makeODMockData("file1", nil, time.Now(), false, nil), makeODMockData("file2", nil, time.Now(), false, nil), }), } return bc }, failurePolicy: control.FailAfterRecovery, expectRunErr: assert.NoError, expectBackupTag: model.MergeBackup, expectFaults: func(t *testing.T, errs *fault.Bus) { assert.NoError(t, errs.Failure(), clues.ToCore(errs.Failure())) assert.Empty(t, errs.Recovered(), "recovered errors") }, }, { name: "fail after recovery, non-recoverable errors", collFunc: func() []data.BackupCollection { return nil }, injectNonRecoverableErr: true, failurePolicy: control.FailAfterRecovery, expectRunErr: assert.Error, expectBackupTag: "", expectFaults: func(t *testing.T, errs *fault.Bus) { assert.Error(t, errs.Failure(), clues.ToCore(errs.Failure())) }, }, { name: "fail after recovery, recoverable errors", collFunc: func() []data.BackupCollection { bc := []data.BackupCollection{ makeBackupCollection( tmp, locPath, []odMock.Data{ makeODMockData("file1", nil, time.Now(), false, nil), makeODMockData("file2", nil, time.Now(), false, assert.AnError), }), } return bc }, failurePolicy: control.FailAfterRecovery, expectRunErr: assert.Error, expectBackupTag: model.AssistBackup, expectFaults: func(t *testing.T, errs *fault.Bus) { assert.Error(t, errs.Failure(), clues.ToCore(errs.Failure())) assert.Greater(t, len(errs.Recovered()), 0, "recovered errors") }, }, } for _, test := range table { suite.Run(test.name, func() { t := suite.T() ctx, flush := tester.NewContext(t) defer flush() cs := test.collFunc() mc, err := graph.MakeMetadataCollection( tenantID, userID, path.OneDriveService, path.FilesCategory, makeMetadataCollectionEntries("url/1", driveID, folderID, tmp), func(*support.ControllerOperationStatus) {}) require.NoError(t, err, clues.ToCore(err)) cs = append(cs, mc) bp := &mockBackupProducer{ colls: cs, injectNonRecoverableErr: test.injectNonRecoverableErr, } opts.FailureHandling = test.failurePolicy bo, err := NewBackupOperation( ctx, opts, suite.kw, suite.sw, bp, acct, osel.Selector, selectors.Selector{DiscreteOwner: userID}, evmock.NewBus()) require.NoError(t, err, clues.ToCore(err)) err = bo.Run(ctx) test.expectRunErr(t, err, clues.ToCore(err)) test.expectFaults(t, bo.Errors) if len(test.expectBackupTag) == 0 { return } bID := bo.Results.BackupID require.NotEmpty(t, bID) bup := backup.Backup{} err = suite.ms.Get(ctx, model.BackupSchema, bID, &bup) require.NoError(t, err, clues.ToCore(err)) require.Equal(t, test.expectBackupTag, bup.Tags[model.BackupTypeTag]) }) } } func selectFilesFromDeets(d details.Details) map[string]details.Entry { files := make(map[string]details.Entry) for _, ent := range d.Entries { if ent.Folder != nil { continue } files[ent.ItemRef] = ent } return files } // TestExtensionsIncrementals tests presence of corso extension data in details // Note that since we are mocking out backup producer here, corso extensions can't be // attached as they would in prod. However, this is fine here, since we are more interested // in testing whether deets get carried over correctly for various scenarios. func (suite *AssistBackupIntegrationSuite) TestExtensionsIncrementals() { var ( acct = tconfig.NewM365Account(suite.T()) tenantID = acct.Config[config.AzureTenantIDKey] opts = control.DefaultOptions() osel = selectors.NewOneDriveBackup([]string{userID}) // Default policy used by SDK clients failurePolicy = control.FailAfterRecovery T1 = time.Now().Truncate(0) T2 = T1.Add(time.Hour).Truncate(0) T3 = T2.Add(time.Hour).Truncate(0) extData = make(map[int]*details.ExtensionData) ) for i := 0; i < 3; i++ { d := make(map[string]any) extData[i] = &details.ExtensionData{ Data: d, } } osel.Include(selTD.OneDriveBackupFolderScope(osel)) sss := streamstore.NewStreamer( suite.kw, suite.acct.ID(), osel.PathService()) pathElements := []string{odConsts.DrivesPathDir, "drive-id", odConsts.RootPathDir, folderID} tmp, err := path.Build(tenantID, userID, path.OneDriveService, path.FilesCategory, false, pathElements...) require.NoError(suite.T(), err, clues.ToCore(err)) locPath := path.Builder{}.Append(tmp.Folders()...) table := []struct { name string collFunc func() []data.BackupCollection expectRunErr assert.ErrorAssertionFunc validateDeets func(t *testing.T, gotDeets details.Details) }{ { name: "Assist backup, 1 new deets", collFunc: func() []data.BackupCollection { bc := []data.BackupCollection{ makeBackupCollection( tmp, locPath, []odMock.Data{ makeODMockData("file1", extData[0], T1, false, nil), makeODMockData("file2", extData[1], T1, false, assert.AnError), }), } return bc }, expectRunErr: assert.Error, validateDeets: func(t *testing.T, d details.Details) { files := selectFilesFromDeets(d) require.Len(t, files, 1) f := files["file1"] require.NotNil(t, f) require.True(t, T1.Equal(f.Modified())) require.NotZero(t, f.Extension.Data[extensions.KNumBytes]) }, }, { name: "Assist backup after assist backup, 1 existing, 1 new deets", collFunc: func() []data.BackupCollection { bc := []data.BackupCollection{ makeBackupCollection( tmp, locPath, []odMock.Data{ makeODMockData("file1", extData[0], T1, false, nil), makeODMockData("file2", extData[1], T2, false, nil), makeODMockData("file3", extData[2], T2, false, assert.AnError), }), } return bc }, expectRunErr: assert.Error, validateDeets: func(t *testing.T, d details.Details) { files := selectFilesFromDeets(d) require.Len(t, files, 2) for _, f := range files { switch f.ItemRef { case "file1": require.True(t, T1.Equal(f.Modified())) require.NotZero(t, f.Extension.Data[extensions.KNumBytes]) case "file2": require.True(t, T2.Equal(f.Modified())) require.NotZero(t, f.Extension.Data[extensions.KNumBytes]) default: require.Fail(t, "unexpected file", f.ItemRef) } } }, }, { name: "Merge backup, 2 existing deets, 1 new deet", collFunc: func() []data.BackupCollection { bc := []data.BackupCollection{ makeBackupCollection( tmp, locPath, []odMock.Data{ makeODMockData("file1", extData[0], T1, false, nil), makeODMockData("file2", extData[1], T2, false, nil), makeODMockData("file3", extData[2], T3, false, nil), }), } return bc }, expectRunErr: assert.NoError, validateDeets: func(t *testing.T, d details.Details) { files := selectFilesFromDeets(d) require.Len(t, files, 3) for _, f := range files { switch f.ItemRef { case "file1": require.True(t, T1.Equal(f.Modified())) require.NotZero(t, f.Extension.Data[extensions.KNumBytes]) case "file2": require.True(t, T2.Equal(f.Modified())) require.NotZero(t, f.Extension.Data[extensions.KNumBytes]) case "file3": require.True(t, T3.Equal(f.Modified())) require.NotZero(t, f.Extension.Data[extensions.KNumBytes]) default: require.Fail(t, "unexpected file", f.ItemRef) } } }, }, { // Reset state so we can reuse the same test data name: "All files deleted", collFunc: func() []data.BackupCollection { bc := []data.BackupCollection{ makeBackupCollection( tmp, locPath, []odMock.Data{ makeODMockData("file1", extData[0], T1, true, nil), makeODMockData("file2", extData[1], T2, true, nil), makeODMockData("file3", extData[2], T3, true, nil), }), } return bc }, expectRunErr: assert.NoError, validateDeets: func(t *testing.T, d details.Details) { files := selectFilesFromDeets(d) require.Len(t, files, 0) }, }, { name: "Merge backup, 1 new deets", collFunc: func() []data.BackupCollection { bc := []data.BackupCollection{ makeBackupCollection( tmp, locPath, []odMock.Data{ makeODMockData("file1", extData[0], T1, false, nil), }), } return bc }, expectRunErr: assert.NoError, validateDeets: func(t *testing.T, d details.Details) { files := selectFilesFromDeets(d) require.Len(t, files, 1) for _, f := range files { switch f.ItemRef { case "file1": require.True(t, T1.Equal(f.Modified())) require.NotZero(t, f.Extension.Data[extensions.KNumBytes]) default: require.Fail(t, "unexpected file", f.ItemRef) } } }, }, // This test fails currently, need to rerun with Ashlie's PR. { name: "Assist backup after merge backup, 1 new deets, 1 existing deet", collFunc: func() []data.BackupCollection { bc := []data.BackupCollection{ makeBackupCollection( tmp, locPath, []odMock.Data{ makeODMockData("file1", extData[0], T1, false, nil), makeODMockData("file2", extData[1], T2, false, nil), makeODMockData("file3", extData[2], T3, false, assert.AnError), }), } return bc }, expectRunErr: assert.Error, validateDeets: func(t *testing.T, d details.Details) { files := selectFilesFromDeets(d) require.Len(t, files, 2) for _, f := range files { switch f.ItemRef { case "file1": require.True(t, T1.Equal(f.Modified())) require.NotZero(t, f.Extension.Data[extensions.KNumBytes]) case "file2": require.True(t, T2.Equal(f.Modified())) require.NotZero(t, f.Extension.Data[extensions.KNumBytes]) default: require.Fail(t, "unexpected file", f.ItemRef) } } }, }, // TODO(pandeyabs): Remaining tests. // 1. Deets updated in assist backup. Following backup should have updated deets. // 2. Concurrent overlapping reasons. } for _, test := range table { suite.Run(test.name, func() { t := suite.T() ctx, flush := tester.NewContext(t) defer flush() cs := test.collFunc() mc, err := graph.MakeMetadataCollection( tenantID, userID, path.OneDriveService, path.FilesCategory, makeMetadataCollectionEntries("url/1", driveID, folderID, tmp), func(*support.ControllerOperationStatus) {}) require.NoError(t, err, clues.ToCore(err)) cs = append(cs, mc) bp := &mockBackupProducer{ colls: cs, } opts.FailureHandling = failurePolicy bo, err := NewBackupOperation( ctx, opts, suite.kw, suite.sw, bp, acct, osel.Selector, selectors.Selector{DiscreteOwner: userID}, evmock.NewBus()) require.NoError(t, err, clues.ToCore(err)) err = bo.Run(ctx) test.expectRunErr(t, err, clues.ToCore(err)) assert.NotEmpty(t, bo.Results.BackupID) deets, _ := deeTD.GetDeetsInBackup( t, ctx, bo.Results.BackupID, tenantID, userID, path.OneDriveService, deeTD.DriveIDFromRepoRef, suite.ms, sss) assert.NotNil(t, deets) test.validateDeets(t, deets) // Clear extension data between test runs for i := 0; i < 3; i++ { d := make(map[string]any) extData[i] = &details.ExtensionData{ Data: d, } } }) } }