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

fix up tests, apply latest design

Browse Source
This commit is contained in:
ryanfkeepers 2023-10-11 10:55:39 -06:00
parent c805c8f8e5
commit 96b9f752ba
9 changed files with 374 additions and 409 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

81
src/internal/m365/collection/drive/collections.go
View File

@ -6,7 +6,6 @@ import (
"fmt" "fmt"
"io" "io"
"strings" "strings"
"sync"
"github.com/alcionai/clues" "github.com/alcionai/clues"
"github.com/microsoftgraph/msgraph-sdk-go/models" "github.com/microsoftgraph/msgraph-sdk-go/models"
@ -690,8 +689,6 @@ func (c *Collections) PopulateDriveCollections(
el = errs.Local() el = errs.Local()
newPrevPaths = map[string]string{} newPrevPaths = map[string]string{}
invalidPrevDelta = len(prevDeltaLink) == 0 invalidPrevDelta = len(prevDeltaLink) == 0
ch = make(chan api.NextPage[models.DriveItemable], 1)
wg = sync.WaitGroup{}
// currPrevPaths is used to identify which collection a // currPrevPaths is used to identify which collection a
// file belongs to. This is useful to delete a file from the // file belongs to. This is useful to delete a file from the
@ -705,58 +702,54 @@ func (c *Collections) PopulateDriveCollections(
maps.Copy(newPrevPaths, oldPrevPaths) maps.Copy(newPrevPaths, oldPrevPaths)
} }
go func() { pager := c.handler.EnumerateDriveItemsDelta(
defer wg.Done() ctx,
driveID,
prevDeltaLink,
api.CallConfig{
Select: api.DefaultDriveItemProps(),
})
for pg := range ch { page, reset, done := pager.NextPage()
for ; !done; page, reset, done = pager.NextPage() {
if el.Failure() != nil {
break
}
if reset {
newPrevPaths = map[string]string{}
currPrevPaths = map[string]string{}
c.CollectionMap[driveID] = map[string]*Collection{}
invalidPrevDelta = true
}
for _, item := range page {
if el.Failure() != nil { if el.Failure() != nil {
// exhaust the channel to ensure it closes break
continue
} }
if pg.Reset { err := c.processItem(
newPrevPaths = map[string]string{} ctx,
currPrevPaths = map[string]string{} item,
c.CollectionMap[driveID] = map[string]*Collection{} driveID,
invalidPrevDelta = true driveName,
} oldPrevPaths,
currPrevPaths,
for _, item := range pg.Items { newPrevPaths,
if el.Failure() != nil { excludedItemIDs,
continue invalidPrevDelta,
} el)
if err != nil {
err := c.processItem( el.AddRecoverable(ctx, clues.Stack(err))
ctx,
item,
driveID,
driveName,
oldPrevPaths,
currPrevPaths,
newPrevPaths,
excludedItemIDs,
invalidPrevDelta,
el)
if err != nil {
el.AddRecoverable(ctx, clues.Stack(err))
}
} }
} }
}() }
wg.Add(1) du, err := pager.Results()
du, err := c.handler.EnumerateDriveItemsDelta(
ctx,
ch,
driveID,
prevDeltaLink)
if err != nil { if err != nil {
return du, nil, clues.Stack(err) return du, nil, clues.Stack(err)
} }
wg.Wait()
return du, newPrevPaths, el.Failure() return du, newPrevPaths, el.Failure()
} }

642
src/internal/m365/collection/drive/collections_test.go
View File

@ -743,13 +743,13 @@ func (suite *OneDriveCollectionsUnitSuite) TestPopulateDriveCollections() {
errs = fault.New(true) errs = fault.New(true)
) )
mbh.DriveItemEnumeration = mock.EnumeratesDriveItemsDelta[models.DriveItemable]{ mbh.DriveItemEnumeration = mock.EnumerateItemsDeltaByDrive{
Pages: map[string][]api.NextPage[models.DriveItemable]{ DrivePagers: map[string]*mock.DriveItemsDeltaPager{
driveID: { driveID: {
{Items: test.items}, Pages: []mock.NextPage{{Items: test.items}},
DeltaUpdate: du,
}, },
}, },
DeltaUpdate: map[string]api.DeltaUpdate{driveID: du},
} }
sel := selectors.NewOneDriveBackup([]string{user}) sel := selectors.NewOneDriveBackup([]string{user})
@ -1226,7 +1226,7 @@ func (suite *OneDriveCollectionsUnitSuite) TestGet() {
table := []struct { table := []struct {
name string name string
drives []models.Driveable drives []models.Driveable
enumerator mock.EnumeratesDriveItemsDelta[models.DriveItemable] enumerator mock.EnumerateItemsDeltaByDrive
canUsePreviousBackup bool canUsePreviousBackup bool
errCheck assert.ErrorAssertionFunc errCheck assert.ErrorAssertionFunc
prevFolderPaths map[string]map[string]string prevFolderPaths map[string]map[string]string
@ -1245,19 +1245,18 @@ func (suite *OneDriveCollectionsUnitSuite) TestGet() {
{ {
name: "OneDrive_OneItemPage_DelFileOnly_NoFolders_NoErrors", name: "OneDrive_OneItemPage_DelFileOnly_NoFolders_NoErrors",
drives: []models.Driveable{drive1}, drives: []models.Driveable{drive1},
enumerator: mock.EnumeratesDriveItemsDelta[models.DriveItemable]{ enumerator: mock.EnumerateItemsDeltaByDrive{
Pages: map[string][]api.NextPage[models.DriveItemable]{ DrivePagers: map[string]*mock.DriveItemsDeltaPager{
driveID1: { driveID1: {
{Items: []models.DriveItemable{ Pages: []mock.NextPage{{
driveRootItem("root"), // will be present, not needed Items: []models.DriveItemable{
delItem("file", driveBasePath1, "root", true, false, false), driveRootItem("root"), // will be present, not needed
delItem("file", driveBasePath1, "root", true, false, false),
},
}}, }},
DeltaUpdate: api.DeltaUpdate{URL: delta},
}, },
}, },
DeltaUpdate: map[string]api.DeltaUpdate{
driveID1: {URL: delta},
},
Err: map[string]error{driveID1: nil},
}, },
canUsePreviousBackup: true, canUsePreviousBackup: true,
errCheck: assert.NoError, errCheck: assert.NoError,
@ -1280,19 +1279,18 @@ func (suite *OneDriveCollectionsUnitSuite) TestGet() {
{ {
name: "OneDrive_OneItemPage_NoFolderDeltas_NoErrors", name: "OneDrive_OneItemPage_NoFolderDeltas_NoErrors",
drives: []models.Driveable{drive1}, drives: []models.Driveable{drive1},
enumerator: mock.EnumeratesDriveItemsDelta[models.DriveItemable]{ enumerator: mock.EnumerateItemsDeltaByDrive{
Pages: map[string][]api.NextPage[models.DriveItemable]{ DrivePagers: map[string]*mock.DriveItemsDeltaPager{
driveID1: { driveID1: {
{Items: []models.DriveItemable{ Pages: []mock.NextPage{{
driveRootItem("root"), Items: []models.DriveItemable{
driveItem("file", "file", driveBasePath1, "root", true, false, false), driveRootItem("root"),
driveItem("file", "file", driveBasePath1, "root", true, false, false),
},
}}, }},
DeltaUpdate: api.DeltaUpdate{URL: delta},
}, },
}, },
DeltaUpdate: map[string]api.DeltaUpdate{
driveID1: {URL: delta},
},
Err: map[string]error{driveID1: nil},
}, },
canUsePreviousBackup: true, canUsePreviousBackup: true,
errCheck: assert.NoError, errCheck: assert.NoError,
@ -1315,20 +1313,19 @@ func (suite *OneDriveCollectionsUnitSuite) TestGet() {
{ {
name: "OneDrive_OneItemPage_NoErrors", name: "OneDrive_OneItemPage_NoErrors",
drives: []models.Driveable{drive1}, drives: []models.Driveable{drive1},
enumerator: mock.EnumeratesDriveItemsDelta[models.DriveItemable]{ enumerator: mock.EnumerateItemsDeltaByDrive{
Pages: map[string][]api.NextPage[models.DriveItemable]{ DrivePagers: map[string]*mock.DriveItemsDeltaPager{
driveID1: { driveID1: {
{Items: []models.DriveItemable{ Pages: []mock.NextPage{{
driveRootItem("root"), Items: []models.DriveItemable{
driveItem("folder", "folder", driveBasePath1, "root", false, true, false), driveRootItem("root"),
driveItem("file", "file", driveBasePath1+"/folder", "folder", true, false, false), driveItem("folder", "folder", driveBasePath1, "root", false, true, false),
driveItem("file", "file", driveBasePath1+"/folder", "folder", true, false, false),
},
}}, }},
DeltaUpdate: api.DeltaUpdate{URL: delta, Reset: true},
}, },
}, },
DeltaUpdate: map[string]api.DeltaUpdate{
driveID1: {URL: delta, Reset: true},
},
Err: map[string]error{driveID1: nil},
}, },
canUsePreviousBackup: true, canUsePreviousBackup: true,
errCheck: assert.NoError, errCheck: assert.NoError,
@ -1355,21 +1352,20 @@ func (suite *OneDriveCollectionsUnitSuite) TestGet() {
{ {
name: "OneDrive_OneItemPage_NoErrors_FileRenamedMultiple", name: "OneDrive_OneItemPage_NoErrors_FileRenamedMultiple",
drives: []models.Driveable{drive1}, drives: []models.Driveable{drive1},
enumerator: mock.EnumeratesDriveItemsDelta[models.DriveItemable]{ enumerator: mock.EnumerateItemsDeltaByDrive{
Pages: map[string][]api.NextPage[models.DriveItemable]{ DrivePagers: map[string]*mock.DriveItemsDeltaPager{
driveID1: { driveID1: {
{Items: []models.DriveItemable{ Pages: []mock.NextPage{{
driveRootItem("root"), Items: []models.DriveItemable{
driveItem("folder", "folder", driveBasePath1, "root", false, true, false), driveRootItem("root"),
driveItem("file", "file", driveBasePath1+"/folder", "folder", true, false, false), driveItem("folder", "folder", driveBasePath1, "root", false, true, false),
driveItem("file", "file2", driveBasePath1+"/folder", "folder", true, false, false), driveItem("file", "file", driveBasePath1+"/folder", "folder", true, false, false),
driveItem("file", "file2", driveBasePath1+"/folder", "folder", true, false, false),
},
}}, }},
DeltaUpdate: api.DeltaUpdate{URL: delta, Reset: true},
}, },
}, },
DeltaUpdate: map[string]api.DeltaUpdate{
driveID1: {URL: delta, Reset: true},
},
Err: map[string]error{driveID1: nil},
}, },
canUsePreviousBackup: true, canUsePreviousBackup: true,
errCheck: assert.NoError, errCheck: assert.NoError,
@ -1396,21 +1392,18 @@ func (suite *OneDriveCollectionsUnitSuite) TestGet() {
{ {
name: "OneDrive_OneItemPage_NoErrors_FileMovedMultiple", name: "OneDrive_OneItemPage_NoErrors_FileMovedMultiple",
drives: []models.Driveable{drive1}, drives: []models.Driveable{drive1},
enumerator: mock.EnumeratesDriveItemsDelta[models.DriveItemable]{ enumerator: mock.EnumerateItemsDeltaByDrive{
Pages: map[string][]api.NextPage[models.DriveItemable]{ DrivePagers: map[string]*mock.DriveItemsDeltaPager{
driveID1: { driveID1: {
{Items: []models.DriveItemable{ Pages: []mock.NextPage{{Items: []models.DriveItemable{
driveRootItem("root"), driveRootItem("root"),
driveItem("folder", "folder", driveBasePath1, "root", false, true, false), driveItem("folder", "folder", driveBasePath1, "root", false, true, false),
driveItem("file", "file", driveBasePath1+"/folder", "folder", true, false, false), driveItem("file", "file", driveBasePath1+"/folder", "folder", true, false, false),
driveItem("file", "file2", driveBasePath1, "root", true, false, false), driveItem("file", "file2", driveBasePath1, "root", true, false, false),
}}, }}},
DeltaUpdate: api.DeltaUpdate{URL: delta},
}, },
}, },
DeltaUpdate: map[string]api.DeltaUpdate{
driveID1: {URL: delta},
},
Err: map[string]error{driveID1: nil},
}, },
canUsePreviousBackup: true, canUsePreviousBackup: true,
errCheck: assert.NoError, errCheck: assert.NoError,
@ -1439,20 +1432,17 @@ func (suite *OneDriveCollectionsUnitSuite) TestGet() {
{ {
name: "OneDrive_OneItemPage_EmptyDelta_NoErrors", name: "OneDrive_OneItemPage_EmptyDelta_NoErrors",
drives: []models.Driveable{drive1}, drives: []models.Driveable{drive1},
enumerator: mock.EnumeratesDriveItemsDelta[models.DriveItemable]{ enumerator: mock.EnumerateItemsDeltaByDrive{
Pages: map[string][]api.NextPage[models.DriveItemable]{ DrivePagers: map[string]*mock.DriveItemsDeltaPager{
driveID1: { driveID1: {
{Items: []models.DriveItemable{ Pages: []mock.NextPage{{Items: []models.DriveItemable{
driveRootItem("root"), driveRootItem("root"),
driveItem("folder", "folder", driveBasePath1, "root", false, true, false), driveItem("folder", "folder", driveBasePath1, "root", false, true, false),
driveItem("file", "file", driveBasePath1+"/folder", "folder", true, false, false), driveItem("file", "file", driveBasePath1+"/folder", "folder", true, false, false),
}}, }}},
DeltaUpdate: api.DeltaUpdate{URL: empty, Reset: true},
}, },
}, },
DeltaUpdate: map[string]api.DeltaUpdate{
driveID1: {URL: empty, Reset: true},
},
Err: map[string]error{driveID1: nil},
}, },
canUsePreviousBackup: true, canUsePreviousBackup: true,
errCheck: assert.NoError, errCheck: assert.NoError,
@ -1479,29 +1469,28 @@ func (suite *OneDriveCollectionsUnitSuite) TestGet() {
{ {
name: "OneDrive_TwoItemPages_NoErrors", name: "OneDrive_TwoItemPages_NoErrors",
drives: []models.Driveable{drive1}, drives: []models.Driveable{drive1},
enumerator: mock.EnumeratesDriveItemsDelta[models.DriveItemable]{ enumerator: mock.EnumerateItemsDeltaByDrive{
Pages: map[string][]api.NextPage[models.DriveItemable]{ DrivePagers: map[string]*mock.DriveItemsDeltaPager{
driveID1: { driveID1: {
{ Pages: []mock.NextPage{
Items: []models.DriveItemable{ {
driveRootItem("root"), Items: []models.DriveItemable{
driveItem("folder", "folder", driveBasePath1, "root", false, true, false), driveRootItem("root"),
driveItem("file", "file", driveBasePath1+"/folder", "folder", true, false, false), driveItem("folder", "folder", driveBasePath1, "root", false, true, false),
}, driveItem("file", "file", driveBasePath1+"/folder", "folder", true, false, false),
}, },
{ },
Items: []models.DriveItemable{ {
driveRootItem("root"), Items: []models.DriveItemable{
driveItem("folder", "folder", driveBasePath1, "root", false, true, false), driveRootItem("root"),
driveItem("file2", "file2", driveBasePath1+"/folder", "folder", true, false, false), driveItem("folder", "folder", driveBasePath1, "root", false, true, false),
driveItem("file2", "file2", driveBasePath1+"/folder", "folder", true, false, false),
},
}, },
}, },
DeltaUpdate: api.DeltaUpdate{URL: delta, Reset: true},
}, },
}, },
DeltaUpdate: map[string]api.DeltaUpdate{
driveID1: {URL: delta, Reset: true},
},
Err: map[string]error{driveID1: nil},
}, },
canUsePreviousBackup: true, canUsePreviousBackup: true,
errCheck: assert.NoError, errCheck: assert.NoError,
@ -1530,40 +1519,40 @@ func (suite *OneDriveCollectionsUnitSuite) TestGet() {
{ {
name: "OneDrive_TwoItemPages_WithReset", name: "OneDrive_TwoItemPages_WithReset",
drives: []models.Driveable{drive1}, drives: []models.Driveable{drive1},
enumerator: mock.EnumeratesDriveItemsDelta[models.DriveItemable]{
Pages: map[string][]api.NextPage[models.DriveItemable]{ enumerator: mock.EnumerateItemsDeltaByDrive{
DrivePagers: map[string]*mock.DriveItemsDeltaPager{
driveID1: { driveID1: {
{ Pages: []mock.NextPage{
Items: []models.DriveItemable{ {
driveRootItem("root"), Items: []models.DriveItemable{
driveItem("folder", "folder", driveBasePath1, "root", false, true, false), driveRootItem("root"),
driveItem("file", "file", driveBasePath1+"/folder", "folder", true, false, false), driveItem("folder", "folder", driveBasePath1, "root", false, true, false),
}, driveItem("file", "file", driveBasePath1+"/folder", "folder", true, false, false),
}, },
{ },
Items: []models.DriveItemable{}, {
Reset: true, Items: []models.DriveItemable{},
}, Reset: true,
{ },
Items: []models.DriveItemable{ {
driveRootItem("root"), Items: []models.DriveItemable{
driveItem("folder", "folder", driveBasePath1, "root", false, true, false), driveRootItem("root"),
driveItem("file", "file", driveBasePath1+"/folder", "folder", true, false, false), driveItem("folder", "folder", driveBasePath1, "root", false, true, false),
}, driveItem("file", "file", driveBasePath1+"/folder", "folder", true, false, false),
}, },
{ },
Items: []models.DriveItemable{ {
driveRootItem("root"), Items: []models.DriveItemable{
driveItem("folder", "folder", driveBasePath1, "root", false, true, false), driveRootItem("root"),
driveItem("file2", "file2", driveBasePath1+"/folder", "folder", true, false, false), driveItem("folder", "folder", driveBasePath1, "root", false, true, false),
driveItem("file2", "file2", driveBasePath1+"/folder", "folder", true, false, false),
},
}, },
}, },
DeltaUpdate: api.DeltaUpdate{URL: delta, Reset: true},
}, },
}, },
DeltaUpdate: map[string]api.DeltaUpdate{
driveID1: {URL: delta, Reset: true},
},
Err: map[string]error{driveID1: nil},
}, },
canUsePreviousBackup: true, canUsePreviousBackup: true,
errCheck: assert.NoError, errCheck: assert.NoError,
@ -1592,37 +1581,36 @@ func (suite *OneDriveCollectionsUnitSuite) TestGet() {
{ {
name: "OneDrive_TwoItemPages_WithResetCombinedWithItems", name: "OneDrive_TwoItemPages_WithResetCombinedWithItems",
drives: []models.Driveable{drive1}, drives: []models.Driveable{drive1},
enumerator: mock.EnumeratesDriveItemsDelta[models.DriveItemable]{ enumerator: mock.EnumerateItemsDeltaByDrive{
Pages: map[string][]api.NextPage[models.DriveItemable]{ DrivePagers: map[string]*mock.DriveItemsDeltaPager{
driveID1: { driveID1: {
{ Pages: []mock.NextPage{
Items: []models.DriveItemable{ {
driveRootItem("root"), Items: []models.DriveItemable{
driveItem("folder", "folder", driveBasePath1, "root", false, true, false), driveRootItem("root"),
driveItem("file", "file", driveBasePath1+"/folder", "folder", true, false, false), driveItem("folder", "folder", driveBasePath1, "root", false, true, false),
}, driveItem("file", "file", driveBasePath1+"/folder", "folder", true, false, false),
}, },
{ },
Items: []models.DriveItemable{ {
driveRootItem("root"), Items: []models.DriveItemable{
driveItem("folder", "folder", driveBasePath1, "root", false, true, false), driveRootItem("root"),
driveItem("file", "file", driveBasePath1+"/folder", "folder", true, false, false), driveItem("folder", "folder", driveBasePath1, "root", false, true, false),
}, driveItem("file", "file", driveBasePath1+"/folder", "folder", true, false, false),
Reset: true, },
}, Reset: true,
{ },
Items: []models.DriveItemable{ {
driveRootItem("root"), Items: []models.DriveItemable{
driveItem("folder", "folder", driveBasePath1, "root", false, true, false), driveRootItem("root"),
driveItem("file2", "file2", driveBasePath1+"/folder", "folder", true, false, false), driveItem("folder", "folder", driveBasePath1, "root", false, true, false),
driveItem("file2", "file2", driveBasePath1+"/folder", "folder", true, false, false),
},
}, },
}, },
DeltaUpdate: api.DeltaUpdate{URL: delta, Reset: true},
}, },
}, },
DeltaUpdate: map[string]api.DeltaUpdate{
driveID1: {URL: delta, Reset: true},
},
Err: map[string]error{driveID1: nil},
}, },
canUsePreviousBackup: true, canUsePreviousBackup: true,
errCheck: assert.NoError, errCheck: assert.NoError,
@ -1654,28 +1642,25 @@ func (suite *OneDriveCollectionsUnitSuite) TestGet() {
drive1, drive1,
drive2, drive2,
}, },
enumerator: mock.EnumeratesDriveItemsDelta[models.DriveItemable]{ enumerator: mock.EnumerateItemsDeltaByDrive{
Pages: map[string][]api.NextPage[models.DriveItemable]{ DrivePagers: map[string]*mock.DriveItemsDeltaPager{
driveID1: { driveID1: {
{Items: []models.DriveItemable{ Pages: []mock.NextPage{{Items: []models.DriveItemable{
driveRootItem("root"), driveRootItem("root"),
driveItem("folder", "folder", driveBasePath1, "root", false, true, false), driveItem("folder", "folder", driveBasePath1, "root", false, true, false),
driveItem("file", "file", driveBasePath1+"/folder", "folder", true, false, false), driveItem("file", "file", driveBasePath1+"/folder", "folder", true, false, false),
}}, }}},
DeltaUpdate: api.DeltaUpdate{URL: delta, Reset: true},
}, },
driveID2: { driveID2: {
{Items: []models.DriveItemable{ Pages: []mock.NextPage{{Items: []models.DriveItemable{
driveRootItem("root2"), driveRootItem("root2"),
driveItem("folder2", "folder", driveBasePath2, "root2", false, true, false), driveItem("folder2", "folder", driveBasePath2, "root2", false, true, false),
driveItem("file2", "file", driveBasePath2+"/folder", "folder2", true, false, false), driveItem("file2", "file", driveBasePath2+"/folder", "folder2", true, false, false),
}}, }}},
DeltaUpdate: api.DeltaUpdate{URL: delta2, Reset: true},
}, },
}, },
DeltaUpdate: map[string]api.DeltaUpdate{
driveID1: {URL: delta, Reset: true},
driveID2: {URL: delta2, Reset: true},
},
Err: map[string]error{driveID1: nil},
}, },
canUsePreviousBackup: true, canUsePreviousBackup: true,
errCheck: assert.NoError, errCheck: assert.NoError,
@ -1717,28 +1702,25 @@ func (suite *OneDriveCollectionsUnitSuite) TestGet() {
drive1, drive1,
drive2, drive2,
}, },
enumerator: mock.EnumeratesDriveItemsDelta[models.DriveItemable]{ enumerator: mock.EnumerateItemsDeltaByDrive{
Pages: map[string][]api.NextPage[models.DriveItemable]{ DrivePagers: map[string]*mock.DriveItemsDeltaPager{
driveID1: { driveID1: {
{Items: []models.DriveItemable{ Pages: []mock.NextPage{{Items: []models.DriveItemable{
driveRootItem("root"), driveRootItem("root"),
driveItem("folder", "folder", driveBasePath1, "root", false, true, false), driveItem("folder", "folder", driveBasePath1, "root", false, true, false),
driveItem("file", "file", driveBasePath1+"/folder", "folder", true, false, false), driveItem("file", "file", driveBasePath1+"/folder", "folder", true, false, false),
}}, }}},
DeltaUpdate: api.DeltaUpdate{URL: delta, Reset: true},
}, },
driveID2: { driveID2: {
{Items: []models.DriveItemable{ Pages: []mock.NextPage{{Items: []models.DriveItemable{
driveRootItem("root"), driveRootItem("root"),
driveItem("folder", "folder", driveBasePath2, "root", false, true, false), driveItem("folder", "folder", driveBasePath2, "root", false, true, false),
driveItem("file2", "file", driveBasePath2+"/folder", "folder", true, false, false), driveItem("file2", "file", driveBasePath2+"/folder", "folder", true, false, false),
}}, }}},
DeltaUpdate: api.DeltaUpdate{URL: delta2, Reset: true},
}, },
}, },
DeltaUpdate: map[string]api.DeltaUpdate{
driveID1: {URL: delta, Reset: true},
driveID2: {URL: delta2, Reset: true},
},
Err: map[string]error{driveID1: nil},
}, },
canUsePreviousBackup: true, canUsePreviousBackup: true,
errCheck: assert.NoError, errCheck: assert.NoError,
@ -1777,16 +1759,14 @@ func (suite *OneDriveCollectionsUnitSuite) TestGet() {
{ {
name: "OneDrive_OneItemPage_Errors", name: "OneDrive_OneItemPage_Errors",
drives: []models.Driveable{drive1}, drives: []models.Driveable{drive1},
enumerator: mock.EnumeratesDriveItemsDelta[models.DriveItemable]{ enumerator: mock.EnumerateItemsDeltaByDrive{
Pages: map[string][]api.NextPage[models.DriveItemable]{ DrivePagers: map[string]*mock.DriveItemsDeltaPager{
driveID1: { driveID1: {
{Items: []models.DriveItemable{}}, Pages: []mock.NextPage{{Items: []models.DriveItemable{}}},
DeltaUpdate: api.DeltaUpdate{},
Err: assert.AnError,
}, },
}, },
DeltaUpdate: map[string]api.DeltaUpdate{
driveID1: {},
},
Err: map[string]error{driveID1: assert.AnError},
}, },
canUsePreviousBackup: false, canUsePreviousBackup: false,
errCheck: assert.Error, errCheck: assert.Error,
@ -1801,26 +1781,25 @@ func (suite *OneDriveCollectionsUnitSuite) TestGet() {
{ {
name: "OneDrive_OneItemPage_InvalidPrevDelta_DeleteNonExistentFolder", name: "OneDrive_OneItemPage_InvalidPrevDelta_DeleteNonExistentFolder",
drives: []models.Driveable{drive1}, drives: []models.Driveable{drive1},
enumerator: mock.EnumeratesDriveItemsDelta[models.DriveItemable]{ enumerator: mock.EnumerateItemsDeltaByDrive{
Pages: map[string][]api.NextPage[models.DriveItemable]{ DrivePagers: map[string]*mock.DriveItemsDeltaPager{
driveID1: { driveID1: {
{ Pages: []mock.NextPage{
Items: []models.DriveItemable{}, {
Reset: true, Items: []models.DriveItemable{},
}, Reset: true,
{ },
Items: []models.DriveItemable{ {
driveRootItem("root"), Items: []models.DriveItemable{
driveItem("folder2", "folder2", driveBasePath1, "root", false, true, false), driveRootItem("root"),
driveItem("file", "file", driveBasePath1+"/folder2", "folder2", true, false, false), driveItem("folder2", "folder2", driveBasePath1, "root", false, true, false),
driveItem("file", "file", driveBasePath1+"/folder2", "folder2", true, false, false),
},
}, },
}, },
DeltaUpdate: api.DeltaUpdate{URL: delta, Reset: true},
}, },
}, },
DeltaUpdate: map[string]api.DeltaUpdate{
driveID1: {URL: delta, Reset: true},
},
Err: map[string]error{driveID1: nil},
}, },
canUsePreviousBackup: true, canUsePreviousBackup: true,
errCheck: assert.NoError, errCheck: assert.NoError,
@ -1854,26 +1833,25 @@ func (suite *OneDriveCollectionsUnitSuite) TestGet() {
{ {
name: "OneDrive_OneItemPage_InvalidPrevDeltaCombinedWithItems_DeleteNonExistentFolder", name: "OneDrive_OneItemPage_InvalidPrevDeltaCombinedWithItems_DeleteNonExistentFolder",
drives: []models.Driveable{drive1}, drives: []models.Driveable{drive1},
enumerator: mock.EnumeratesDriveItemsDelta[models.DriveItemable]{ enumerator: mock.EnumerateItemsDeltaByDrive{
Pages: map[string][]api.NextPage[models.DriveItemable]{ DrivePagers: map[string]*mock.DriveItemsDeltaPager{
driveID1: { driveID1: {
{ Pages: []mock.NextPage{
Items: []models.DriveItemable{}, {
Reset: true, Items: []models.DriveItemable{},
}, Reset: true,
{ },
Items: []models.DriveItemable{ {
driveRootItem("root"), Items: []models.DriveItemable{
driveItem("folder2", "folder2", driveBasePath1, "root", false, true, false), driveRootItem("root"),
driveItem("file", "file", driveBasePath1+"/folder2", "folder2", true, false, false), driveItem("folder2", "folder2", driveBasePath1, "root", false, true, false),
driveItem("file", "file", driveBasePath1+"/folder2", "folder2", true, false, false),
},
}, },
}, },
DeltaUpdate: api.DeltaUpdate{URL: delta, Reset: true},
}, },
}, },
DeltaUpdate: map[string]api.DeltaUpdate{
driveID1: {URL: delta, Reset: true},
},
Err: map[string]error{driveID1: nil},
}, },
canUsePreviousBackup: true, canUsePreviousBackup: true,
errCheck: assert.NoError, errCheck: assert.NoError,
@ -1907,37 +1885,36 @@ func (suite *OneDriveCollectionsUnitSuite) TestGet() {
{ {
name: "OneDrive_OneItemPage_InvalidPrevDelta_AnotherFolderAtDeletedLocation", name: "OneDrive_OneItemPage_InvalidPrevDelta_AnotherFolderAtDeletedLocation",
drives: []models.Driveable{drive1}, drives: []models.Driveable{drive1},
enumerator: mock.EnumeratesDriveItemsDelta[models.DriveItemable]{ enumerator: mock.EnumerateItemsDeltaByDrive{
Pages: map[string][]api.NextPage[models.DriveItemable]{ DrivePagers: map[string]*mock.DriveItemsDeltaPager{
driveID1: { driveID1: {
{ Pages: []mock.NextPage{
// on the first page, if this is the total data, we'd expect both folder and folder2 {
// since new previousPaths merge with the old previousPaths. // on the first page, if this is the total data, we'd expect both folder and folder2
Items: []models.DriveItemable{ // since new previousPaths merge with the old previousPaths.
driveRootItem("root"), Items: []models.DriveItemable{
driveItem("folder2", "folder", driveBasePath1, "root", false, true, false), driveRootItem("root"),
driveItem("file", "file", driveBasePath1+"/folder", "folder2", true, false, false), driveItem("folder2", "folder", driveBasePath1, "root", false, true, false),
}, driveItem("file", "file", driveBasePath1+"/folder", "folder2", true, false, false),
}, },
{ },
Items: []models.DriveItemable{}, {
Reset: true, Items: []models.DriveItemable{},
}, Reset: true,
{ },
// but after a delta reset, we treat this as the total end set of folders, which means {
// we don't expect folder to exist any longer. // but after a delta reset, we treat this as the total end set of folders, which means
Items: []models.DriveItemable{ // we don't expect folder to exist any longer.
driveRootItem("root"), Items: []models.DriveItemable{
driveItem("folder2", "folder", driveBasePath1, "root", false, true, false), driveRootItem("root"),
driveItem("file", "file", driveBasePath1+"/folder", "folder2", true, false, false), driveItem("folder2", "folder", driveBasePath1, "root", false, true, false),
driveItem("file", "file", driveBasePath1+"/folder", "folder2", true, false, false),
},
}, },
}, },
DeltaUpdate: api.DeltaUpdate{URL: delta, Reset: true},
}, },
}, },
DeltaUpdate: map[string]api.DeltaUpdate{
driveID1: {URL: delta, Reset: true},
},
Err: map[string]error{driveID1: nil},
}, },
canUsePreviousBackup: true, canUsePreviousBackup: true,
errCheck: assert.NoError, errCheck: assert.NoError,
@ -1974,31 +1951,30 @@ func (suite *OneDriveCollectionsUnitSuite) TestGet() {
{ {
name: "OneDrive Two Item Pages with Malware", name: "OneDrive Two Item Pages with Malware",
drives: []models.Driveable{drive1}, drives: []models.Driveable{drive1},
enumerator: mock.EnumeratesDriveItemsDelta[models.DriveItemable]{ enumerator: mock.EnumerateItemsDeltaByDrive{
Pages: map[string][]api.NextPage[models.DriveItemable]{ DrivePagers: map[string]*mock.DriveItemsDeltaPager{
driveID1: { driveID1: {
{ Pages: []mock.NextPage{
Items: []models.DriveItemable{ {
driveRootItem("root"), Items: []models.DriveItemable{
driveItem("folder", "folder", driveBasePath1, "root", false, true, false), driveRootItem("root"),
driveItem("file", "file", driveBasePath1+"/folder", "folder", true, false, false), driveItem("folder", "folder", driveBasePath1, "root", false, true, false),
malwareItem("malware", "malware", driveBasePath1+"/folder", "folder", true, false, false), driveItem("file", "file", driveBasePath1+"/folder", "folder", true, false, false),
}, malwareItem("malware", "malware", driveBasePath1+"/folder", "folder", true, false, false),
}, },
{ },
Items: []models.DriveItemable{ {
driveRootItem("root"), Items: []models.DriveItemable{
driveItem("folder", "folder", driveBasePath1, "root", false, true, false), driveRootItem("root"),
driveItem("file2", "file2", driveBasePath1+"/folder", "folder", true, false, false), driveItem("folder", "folder", driveBasePath1, "root", false, true, false),
malwareItem("malware2", "malware2", driveBasePath1+"/folder", "folder", true, false, false), driveItem("file2", "file2", driveBasePath1+"/folder", "folder", true, false, false),
malwareItem("malware2", "malware2", driveBasePath1+"/folder", "folder", true, false, false),
},
}, },
}, },
DeltaUpdate: api.DeltaUpdate{URL: delta, Reset: true},
}, },
}, },
DeltaUpdate: map[string]api.DeltaUpdate{
driveID1: {URL: delta, Reset: true},
},
Err: map[string]error{driveID1: nil},
}, },
canUsePreviousBackup: true, canUsePreviousBackup: true,
errCheck: assert.NoError, errCheck: assert.NoError,
@ -2028,36 +2004,35 @@ func (suite *OneDriveCollectionsUnitSuite) TestGet() {
{ {
name: "One Drive Deleted Folder In New Results With Invalid Delta", name: "One Drive Deleted Folder In New Results With Invalid Delta",
drives: []models.Driveable{drive1}, drives: []models.Driveable{drive1},
enumerator: mock.EnumeratesDriveItemsDelta[models.DriveItemable]{ enumerator: mock.EnumerateItemsDeltaByDrive{
Pages: map[string][]api.NextPage[models.DriveItemable]{ DrivePagers: map[string]*mock.DriveItemsDeltaPager{
driveID1: { driveID1: {
{ Pages: []mock.NextPage{
Items: []models.DriveItemable{ {
driveRootItem("root"), Items: []models.DriveItemable{
driveItem("folder", "folder", driveBasePath1, "root", false, true, false), driveRootItem("root"),
driveItem("file", "file", driveBasePath1+"/folder", "folder", true, false, false), driveItem("folder", "folder", driveBasePath1, "root", false, true, false),
driveItem("folder2", "folder2", driveBasePath1, "root", false, true, false), driveItem("file", "file", driveBasePath1+"/folder", "folder", true, false, false),
driveItem("file2", "file2", driveBasePath1+"/folder2", "folder2", true, false, false), driveItem("folder2", "folder2", driveBasePath1, "root", false, true, false),
}, driveItem("file2", "file2", driveBasePath1+"/folder2", "folder2", true, false, false),
}, },
{ },
Reset: true, {
}, Reset: true,
{ },
Items: []models.DriveItemable{ {
driveRootItem("root"), Items: []models.DriveItemable{
driveItem("folder", "folder", driveBasePath1, "root", false, true, false), driveRootItem("root"),
driveItem("file", "file", driveBasePath1+"/folder", "folder", true, false, false), driveItem("folder", "folder", driveBasePath1, "root", false, true, false),
delItem("folder2", driveBasePath1, "root", false, true, false), driveItem("file", "file", driveBasePath1+"/folder", "folder", true, false, false),
delItem("file2", driveBasePath1, "root", true, false, false), delItem("folder2", driveBasePath1, "root", false, true, false),
delItem("file2", driveBasePath1, "root", true, false, false),
},
}, },
}, },
DeltaUpdate: api.DeltaUpdate{URL: delta2, Reset: true},
}, },
}, },
DeltaUpdate: map[string]api.DeltaUpdate{
driveID1: {URL: delta2, Reset: true},
},
Err: map[string]error{driveID1: nil},
}, },
canUsePreviousBackup: true, canUsePreviousBackup: true,
errCheck: assert.NoError, errCheck: assert.NoError,
@ -2092,22 +2067,19 @@ func (suite *OneDriveCollectionsUnitSuite) TestGet() {
{ {
name: "One Drive Folder Delete After Invalid Delta", name: "One Drive Folder Delete After Invalid Delta",
drives: []models.Driveable{drive1}, drives: []models.Driveable{drive1},
enumerator: mock.EnumeratesDriveItemsDelta[models.DriveItemable]{ enumerator: mock.EnumerateItemsDeltaByDrive{
Pages: map[string][]api.NextPage[models.DriveItemable]{ DrivePagers: map[string]*mock.DriveItemsDeltaPager{
driveID1: { driveID1: {
{ Pages: []mock.NextPage{{
Items: []models.DriveItemable{ Items: []models.DriveItemable{
driveRootItem("root"), driveRootItem("root"),
delItem("folder", driveBasePath1, "root", false, true, false), delItem("folder", driveBasePath1, "root", false, true, false),
}, },
Reset: true, Reset: true,
}, }},
DeltaUpdate: api.DeltaUpdate{URL: delta, Reset: true},
}, },
}, },
DeltaUpdate: map[string]api.DeltaUpdate{
driveID1: {URL: delta, Reset: true},
},
Err: map[string]error{driveID1: nil},
}, },
canUsePreviousBackup: true, canUsePreviousBackup: true,
errCheck: assert.NoError, errCheck: assert.NoError,
@ -2138,22 +2110,21 @@ func (suite *OneDriveCollectionsUnitSuite) TestGet() {
{ {
name: "One Drive Item Delete After Invalid Delta", name: "One Drive Item Delete After Invalid Delta",
drives: []models.Driveable{drive1}, drives: []models.Driveable{drive1},
enumerator: mock.EnumeratesDriveItemsDelta[models.DriveItemable]{ enumerator: mock.EnumerateItemsDeltaByDrive{
Pages: map[string][]api.NextPage[models.DriveItemable]{ DrivePagers: map[string]*mock.DriveItemsDeltaPager{
driveID1: { driveID1: {
{ Pages: []mock.NextPage{
Items: []models.DriveItemable{ {
driveRootItem("root"), Items: []models.DriveItemable{
delItem("file", driveBasePath1, "root", true, false, false), driveRootItem("root"),
delItem("file", driveBasePath1, "root", true, false, false),
},
Reset: true,
}, },
Reset: true,
}, },
DeltaUpdate: api.DeltaUpdate{URL: delta, Reset: true},
}, },
}, },
DeltaUpdate: map[string]api.DeltaUpdate{
driveID1: {URL: delta, Reset: true},
},
Err: map[string]error{driveID1: nil},
}, },
canUsePreviousBackup: true, canUsePreviousBackup: true,
errCheck: assert.NoError, errCheck: assert.NoError,
@ -2181,29 +2152,28 @@ func (suite *OneDriveCollectionsUnitSuite) TestGet() {
{ {
name: "One Drive Folder Made And Deleted", name: "One Drive Folder Made And Deleted",
drives: []models.Driveable{drive1}, drives: []models.Driveable{drive1},
enumerator: mock.EnumeratesDriveItemsDelta[models.DriveItemable]{ enumerator: mock.EnumerateItemsDeltaByDrive{
Pages: map[string][]api.NextPage[models.DriveItemable]{ DrivePagers: map[string]*mock.DriveItemsDeltaPager{
driveID1: { driveID1: {
{ Pages: []mock.NextPage{
Items: []models.DriveItemable{ {
driveRootItem("root"), Items: []models.DriveItemable{
driveItem("folder", "folder", driveBasePath1, "root", false, true, false), driveRootItem("root"),
driveItem("file", "file", driveBasePath1+"/folder", "folder", true, false, false), driveItem("folder", "folder", driveBasePath1, "root", false, true, false),
}, driveItem("file", "file", driveBasePath1+"/folder", "folder", true, false, false),
}, },
{ },
Items: []models.DriveItemable{ {
driveRootItem("root"), Items: []models.DriveItemable{
delItem("folder", driveBasePath1, "root", false, true, false), driveRootItem("root"),
delItem("file", driveBasePath1, "root", true, false, false), delItem("folder", driveBasePath1, "root", false, true, false),
delItem("file", driveBasePath1, "root", true, false, false),
},
}, },
}, },
DeltaUpdate: api.DeltaUpdate{URL: delta2, Reset: true},
}, },
}, },
DeltaUpdate: map[string]api.DeltaUpdate{
driveID1: {URL: delta2, Reset: true},
},
Err: map[string]error{driveID1: nil},
}, },
canUsePreviousBackup: true, canUsePreviousBackup: true,
errCheck: assert.NoError, errCheck: assert.NoError,
@ -2229,28 +2199,27 @@ func (suite *OneDriveCollectionsUnitSuite) TestGet() {
{ {
name: "One Drive Item Made And Deleted", name: "One Drive Item Made And Deleted",
drives: []models.Driveable{drive1}, drives: []models.Driveable{drive1},
enumerator: mock.EnumeratesDriveItemsDelta[models.DriveItemable]{ enumerator: mock.EnumerateItemsDeltaByDrive{
Pages: map[string][]api.NextPage[models.DriveItemable]{ DrivePagers: map[string]*mock.DriveItemsDeltaPager{
driveID1: { driveID1: {
{ Pages: []mock.NextPage{
Items: []models.DriveItemable{ {
driveRootItem("root"), Items: []models.DriveItemable{
driveItem("folder", "folder", driveBasePath1, "root", false, true, false), driveRootItem("root"),
driveItem("file", "file", driveBasePath1+"/folder", "folder", true, false, false), driveItem("folder", "folder", driveBasePath1, "root", false, true, false),
}, driveItem("file", "file", driveBasePath1+"/folder", "folder", true, false, false),
}, },
{ },
Items: []models.DriveItemable{ {
driveRootItem("root"), Items: []models.DriveItemable{
delItem("file", driveBasePath1, "root", true, false, false), driveRootItem("root"),
delItem("file", driveBasePath1, "root", true, false, false),
},
}, },
}, },
DeltaUpdate: api.DeltaUpdate{URL: delta, Reset: true},
}, },
}, },
DeltaUpdate: map[string]api.DeltaUpdate{
driveID1: {URL: delta, Reset: true},
},
Err: map[string]error{driveID1: nil},
}, },
canUsePreviousBackup: true, canUsePreviousBackup: true,
errCheck: assert.NoError, errCheck: assert.NoError,
@ -2279,19 +2248,16 @@ func (suite *OneDriveCollectionsUnitSuite) TestGet() {
{ {
name: "One Drive Random Folder Delete", name: "One Drive Random Folder Delete",
drives: []models.Driveable{drive1}, drives: []models.Driveable{drive1},
enumerator: mock.EnumeratesDriveItemsDelta[models.DriveItemable]{ enumerator: mock.EnumerateItemsDeltaByDrive{
Pages: map[string][]api.NextPage[models.DriveItemable]{ DrivePagers: map[string]*mock.DriveItemsDeltaPager{
driveID1: { driveID1: {
{Items: []models.DriveItemable{ Pages: []mock.NextPage{{Items: []models.DriveItemable{
driveRootItem("root"), driveRootItem("root"),
delItem("folder", driveBasePath1, "root", false, true, false), delItem("folder", driveBasePath1, "root", false, true, false),
}}, }}},
DeltaUpdate: api.DeltaUpdate{URL: delta, Reset: true},
}, },
}, },
DeltaUpdate: map[string]api.DeltaUpdate{
driveID1: {URL: delta, Reset: true},
},
Err: map[string]error{driveID1: nil},
}, },
canUsePreviousBackup: true, canUsePreviousBackup: true,
errCheck: assert.NoError, errCheck: assert.NoError,
@ -2317,19 +2283,16 @@ func (suite *OneDriveCollectionsUnitSuite) TestGet() {
{ {
name: "One Drive Random Item Delete", name: "One Drive Random Item Delete",
drives: []models.Driveable{drive1}, drives: []models.Driveable{drive1},
enumerator: mock.EnumeratesDriveItemsDelta[models.DriveItemable]{ enumerator: mock.EnumerateItemsDeltaByDrive{
Pages: map[string][]api.NextPage[models.DriveItemable]{ DrivePagers: map[string]*mock.DriveItemsDeltaPager{
driveID1: { driveID1: {
{Items: []models.DriveItemable{ Pages: []mock.NextPage{{Items: []models.DriveItemable{
driveRootItem("root"), driveRootItem("root"),
delItem("file", driveBasePath1, "root", true, false, false), delItem("file", driveBasePath1, "root", true, false, false),
}}, }}},
DeltaUpdate: api.DeltaUpdate{URL: delta, Reset: true},
}, },
}, },
DeltaUpdate: map[string]api.DeltaUpdate{
driveID1: {URL: delta, Reset: true},
},
Err: map[string]error{driveID1: nil},
}, },
canUsePreviousBackup: true, canUsePreviousBackup: true,
errCheck: assert.NoError, errCheck: assert.NoError,
@ -2355,18 +2318,15 @@ func (suite *OneDriveCollectionsUnitSuite) TestGet() {
{ {
name: "TwoPriorDrives_OneTombstoned", name: "TwoPriorDrives_OneTombstoned",
drives: []models.Driveable{drive1}, drives: []models.Driveable{drive1},
enumerator: mock.EnumeratesDriveItemsDelta[models.DriveItemable]{ enumerator: mock.EnumerateItemsDeltaByDrive{
Pages: map[string][]api.NextPage[models.DriveItemable]{ DrivePagers: map[string]*mock.DriveItemsDeltaPager{
driveID1: { driveID1: {
{Items: []models.DriveItemable{ Pages: []mock.NextPage{{Items: []models.DriveItemable{
driveRootItem("root"), // will be present driveRootItem("root"), // will be present
}}, }}},
DeltaUpdate: api.DeltaUpdate{URL: delta},
}, },
}, },
DeltaUpdate: map[string]api.DeltaUpdate{
driveID1: {URL: delta},
},
Err: map[string]error{driveID1: nil},
}, },
canUsePreviousBackup: true, canUsePreviousBackup: true,
errCheck: assert.NoError, errCheck: assert.NoError,

3
src/internal/m365/collection/drive/url_cache.go
View File

@ -165,7 +165,8 @@ func (uc *urlCache) refreshCache(
Select: api.URLCacheDriveItemProps(), Select: api.URLCacheDriveItemProps(),
}) })
for page, reset, done := pager.NextPage(); !done; { page, reset, done := pager.NextPage()
for ; !done; page, reset, done = pager.NextPage() {
err := uc.updateCache( err := uc.updateCache(
ctx, ctx,
page, page,

26
src/internal/m365/collection/drive/url_cache_test.go
View File

@ -204,7 +204,7 @@ func (suite *URLCacheUnitSuite) TestGetItemProperties() {
table := []struct { table := []struct {
name string name string
pages []mock.NextPage[models.DriveItemable] pages []mock.NextPage
pagerErr error pagerErr error
expectedItemProps map[string]itemProps expectedItemProps map[string]itemProps
expectErr assert.ErrorAssertionFunc expectErr assert.ErrorAssertionFunc
@ -212,7 +212,7 @@ func (suite *URLCacheUnitSuite) TestGetItemProperties() {
}{ }{
{ {
name: "single item in cache", name: "single item in cache",
pages: []mock.NextPage[models.DriveItemable]{ pages: []mock.NextPage{
{Items: []models.DriveItemable{ {Items: []models.DriveItemable{
fileItem("1", "file1", "root", "root", "https://dummy1.com", false), fileItem("1", "file1", "root", "root", "https://dummy1.com", false),
}}, }},
@ -232,7 +232,7 @@ func (suite *URLCacheUnitSuite) TestGetItemProperties() {
}, },
{ {
name: "multiple items in cache", name: "multiple items in cache",
pages: []mock.NextPage[models.DriveItemable]{ pages: []mock.NextPage{
{Items: []models.DriveItemable{ {Items: []models.DriveItemable{
fileItem("1", "file1", "root", "root", "https://dummy1.com", false), fileItem("1", "file1", "root", "root", "https://dummy1.com", false),
fileItem("2", "file2", "root", "root", "https://dummy2.com", false), fileItem("2", "file2", "root", "root", "https://dummy2.com", false),
@ -272,7 +272,7 @@ func (suite *URLCacheUnitSuite) TestGetItemProperties() {
}, },
{ {
name: "multiple pages", name: "multiple pages",
pages: []mock.NextPage[models.DriveItemable]{ pages: []mock.NextPage{
{Items: []models.DriveItemable{ {Items: []models.DriveItemable{
fileItem("1", "file1", "root", "root", "https://dummy1.com", false), fileItem("1", "file1", "root", "root", "https://dummy1.com", false),
fileItem("2", "file2", "root", "root", "https://dummy2.com", false), fileItem("2", "file2", "root", "root", "https://dummy2.com", false),
@ -314,7 +314,7 @@ func (suite *URLCacheUnitSuite) TestGetItemProperties() {
}, },
{ {
name: "multiple pages with resets", name: "multiple pages with resets",
pages: []mock.NextPage[models.DriveItemable]{ pages: []mock.NextPage{
{ {
Items: []models.DriveItemable{ Items: []models.DriveItemable{
fileItem("1", "file1", "root", "root", "https://dummy1.com", false), fileItem("1", "file1", "root", "root", "https://dummy1.com", false),
@ -372,7 +372,7 @@ func (suite *URLCacheUnitSuite) TestGetItemProperties() {
}, },
{ {
name: "multiple pages with resets and combo reset+items in page", name: "multiple pages with resets and combo reset+items in page",
pages: []mock.NextPage[models.DriveItemable]{ pages: []mock.NextPage{
{ {
Items: []models.DriveItemable{ Items: []models.DriveItemable{
fileItem("1", "file1", "root", "root", "https://dummy1.com", false), fileItem("1", "file1", "root", "root", "https://dummy1.com", false),
@ -426,7 +426,7 @@ func (suite *URLCacheUnitSuite) TestGetItemProperties() {
}, },
{ {
name: "duplicate items with potentially new urls", name: "duplicate items with potentially new urls",
pages: []mock.NextPage[models.DriveItemable]{ pages: []mock.NextPage{
{Items: []models.DriveItemable{ {Items: []models.DriveItemable{
fileItem("1", "file1", "root", "root", "https://dummy1.com", false), fileItem("1", "file1", "root", "root", "https://dummy1.com", false),
fileItem("2", "file2", "root", "root", "https://dummy2.com", false), fileItem("2", "file2", "root", "root", "https://dummy2.com", false),
@ -458,7 +458,7 @@ func (suite *URLCacheUnitSuite) TestGetItemProperties() {
}, },
{ {
name: "deleted items", name: "deleted items",
pages: []mock.NextPage[models.DriveItemable]{ pages: []mock.NextPage{
{Items: []models.DriveItemable{ {Items: []models.DriveItemable{
fileItem("1", "file1", "root", "root", "https://dummy1.com", false), fileItem("1", "file1", "root", "root", "https://dummy1.com", false),
fileItem("2", "file2", "root", "root", "https://dummy2.com", false), fileItem("2", "file2", "root", "root", "https://dummy2.com", false),
@ -484,7 +484,7 @@ func (suite *URLCacheUnitSuite) TestGetItemProperties() {
}, },
{ {
name: "item not found in cache", name: "item not found in cache",
pages: []mock.NextPage[models.DriveItemable]{ pages: []mock.NextPage{
{Items: []models.DriveItemable{ {Items: []models.DriveItemable{
fileItem("1", "file1", "root", "root", "https://dummy1.com", false), fileItem("1", "file1", "root", "root", "https://dummy1.com", false),
}}, }},
@ -501,7 +501,7 @@ func (suite *URLCacheUnitSuite) TestGetItemProperties() {
}, },
{ {
name: "delta query error", name: "delta query error",
pages: []mock.NextPage[models.DriveItemable]{ pages: []mock.NextPage{
{Items: []models.DriveItemable{}}, {Items: []models.DriveItemable{}},
}, },
pagerErr: errors.New("delta query error"), pagerErr: errors.New("delta query error"),
@ -519,7 +519,7 @@ func (suite *URLCacheUnitSuite) TestGetItemProperties() {
{ {
name: "folder item", name: "folder item",
pages: []mock.NextPage[models.DriveItemable]{ pages: []mock.NextPage{
{Items: []models.DriveItemable{ {Items: []models.DriveItemable{
fileItem("1", "file1", "root", "root", "https://dummy1.com", false), fileItem("1", "file1", "root", "root", "https://dummy1.com", false),
driveItem("2", "folder2", "root", "root", false, true, false), driveItem("2", "folder2", "root", "root", false, true, false),
@ -548,8 +548,8 @@ func (suite *URLCacheUnitSuite) TestGetItemProperties() {
defer flush() defer flush()
medi := mock.EnumerateItemsDeltaByDrive{ medi := mock.EnumerateItemsDeltaByDrive{
DrivePagers: map[string]mock.DriveItemsDeltaPager{ DrivePagers: map[string]*mock.DriveItemsDeltaPager{
driveID: mock.DriveItemsDeltaPager{ driveID: {
Pages: test.pages, Pages: test.pages,
Err: test.pagerErr, Err: test.pagerErr,
DeltaUpdate: api.DeltaUpdate{URL: deltaString}, DeltaUpdate: api.DeltaUpdate{URL: deltaString},

6
src/internal/m365/service/onedrive/mock/handlers.go
View File

@ -298,7 +298,7 @@ type NextPage struct {
} }
type EnumerateItemsDeltaByDrive struct { type EnumerateItemsDeltaByDrive struct {
DrivePagers map[string]DriveItemsDeltaPager DrivePagers map[string]*DriveItemsDeltaPager
} }
var _ api.NextPageResulter[models.DriveItemable] = &DriveItemsDeltaPager{} var _ api.NextPageResulter[models.DriveItemable] = &DriveItemsDeltaPager{}
@ -316,7 +316,7 @@ func (edibd EnumerateItemsDeltaByDrive) EnumerateDriveItemsDelta(
_ api.CallConfig, _ api.CallConfig,
) api.NextPageResulter[models.DriveItemable] { ) api.NextPageResulter[models.DriveItemable] {
didp := edibd.DrivePagers[driveID] didp := edibd.DrivePagers[driveID]
return &didp return didp
} }
func (edi *DriveItemsDeltaPager) NextPage() ([]models.DriveItemable, bool, bool) { func (edi *DriveItemsDeltaPager) NextPage() ([]models.DriveItemable, bool, bool) {
@ -325,7 +325,7 @@ func (edi *DriveItemsDeltaPager) NextPage() ([]models.DriveItemable, bool, bool)
} }
np := edi.Pages[edi.Idx] np := edi.Pages[edi.Idx]
edi.Idx++ edi.Idx = edi.Idx + 1
return np.Items, np.Reset, false return np.Items, np.Reset, false
} }

4
src/internal/m365/service/sharepoint/backup_test.go
View File

@ -104,8 +104,8 @@ func (suite *LibrariesBackupUnitSuite) TestUpdateCollections() {
) )
mbh.DriveItemEnumeration = mock.EnumerateItemsDeltaByDrive{ mbh.DriveItemEnumeration = mock.EnumerateItemsDeltaByDrive{
DrivePagers: map[string]mock.DriveItemsDeltaPager{ DrivePagers: map[string]*mock.DriveItemsDeltaPager{
driveID: mock.DriveItemsDeltaPager{ driveID: {
Pages: []mock.NextPage{{Items: test.items}}, Pages: []mock.NextPage{{Items: test.items}},
DeltaUpdate: du, DeltaUpdate: du,
}, },

8
src/pkg/fault/skipped.go
View File

@ -1,9 +1,17 @@
package fault package fault
import ( import (
"context"
"github.com/alcionai/corso/src/cli/print" "github.com/alcionai/corso/src/cli/print"
) )
// AddSkipper presents an interface that allows callers to
// write additional skipped items to the complying struct.
type AddSkipper interface {
AddSkip(ctx context.Context, s *Skipped)
}
// skipCause identifies the well-known conditions to Skip an item. It is // skipCause identifies the well-known conditions to Skip an item. It is
// important that skip cause enumerations do not overlap with general error // important that skip cause enumerations do not overlap with general error
// handling. Skips must be well known, well documented, and consistent. // handling. Skips must be well known, well documented, and consistent.

3
src/pkg/services/m365/api/drive_pager_test.go
View File

@ -199,7 +199,8 @@ func (suite *DrivePagerIntgSuite) TestEnumerateDriveItems() {
Select: api.DefaultDriveItemProps(), Select: api.DefaultDriveItemProps(),
}) })
for page, reset, done := pager.NextPage(); !done; { page, reset, done := pager.NextPage()
for ; !done; page, reset, done = pager.NextPage() {
items = append(items, page...) items = append(items, page...)
assert.False(t, reset, "should not reset") assert.False(t, reset, "should not reset")

10
src/pkg/services/m365/api/item_pager.go
View File

@ -223,8 +223,9 @@ func batchEnumerateItems[T any](
go enumerateItems[T](ctx, pager, &npr) go enumerateItems[T](ctx, pager, &npr)
for is, _, done := npr.NextPage(); !done; { page, _, done := npr.NextPage()
items = append(items, is...) for ; !done; page, _, done = npr.NextPage() {
items = append(items, page...)
} }
_, err := npr.Results() _, err := npr.Results()
@ -346,12 +347,13 @@ func batchDeltaEnumerateItems[T any](
go deltaEnumerateItems[T](ctx, pager, &npr, prevDeltaLink) go deltaEnumerateItems[T](ctx, pager, &npr, prevDeltaLink)
for is, reset, done := npr.NextPage(); !done; { page, reset, done := npr.NextPage()
for ; !done; page, reset, done = npr.NextPage() {
if reset { if reset {
results = []T{} results = []T{}
} }
results = append(results, is...) results = append(results, page...)
} }
du, err := npr.Results() du, err := npr.Results()