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

Rename drive handlers to better match uses (#4479)

Browse Source 
Renames focus on OneDrive and Libraries handlers.
Files are also renamed to match

item -> userDrive
library -> site

If diff is large due to file renames view by
commit since file renames are done in a separate
commit

---

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

- [ ] ✅ Yes, it's included
- [ ] 🕐 Yes, but in a later PR
- [x] ⛔ No

#### Type of change

- [ ] 🌻 Feature
- [ ] 🐛 Bugfix
- [ ] 🗺️ Documentation
- [ ] 🤖 Supportability/Tests
- [ ] 💻 CI/Deployment
- [x] 🧹 Tech Debt/Cleanup

#### Issue(s)

* #4254

#### Test Plan

- [ ] 💪 Manual
- [x] ⚡ Unit test
- [x] 💚 E2E
This commit is contained in:
ashmrtn 2023-10-11 13:44:39 -07:00 committed by GitHub
parent 7625219e14
commit ba64f07f34
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
19 changed files with 107 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -131,7 +131,7 @@ func (suite *OneDriveCollectionsUnitSuite) TestUpdateCollections() {
pkg = "/package" pkg = "/package"
) )
bh := itemBackupHandler{userID: user} bh := userDriveBackupHandler{userID: user}
testBaseDrivePath := odConsts.DriveFolderPrefixBuilder("driveID1").String() testBaseDrivePath := odConsts.DriveFolderPrefixBuilder("driveID1").String()
expectedPath := getExpectedPathGenerator(suite.T(), bh, tenant, testBaseDrivePath) expectedPath := getExpectedPathGenerator(suite.T(), bh, tenant, testBaseDrivePath)
expectedStatePath := getExpectedStatePathGenerator(suite.T(), bh, tenant, testBaseDrivePath) expectedStatePath := getExpectedStatePathGenerator(suite.T(), bh, tenant, testBaseDrivePath)
@ -740,8 +740,8 @@ func (suite *OneDriveCollectionsUnitSuite) TestUpdateCollections() {
maps.Copy(currPrevPaths, test.inputFolderMap) maps.Copy(currPrevPaths, test.inputFolderMap)
c := NewCollections( c := NewCollections(
&itemBackupHandler{ &userDriveBackupHandler{
baseItemHandler: baseItemHandler{ baseUserDriveHandler: baseUserDriveHandler{
ac: api.Drives{}, ac: api.Drives{},
}, },
userID: user, userID: user,
@ -1196,7 +1196,7 @@ func (suite *OneDriveCollectionsUnitSuite) TestGet() {
drive2.SetName(&driveID2) drive2.SetName(&driveID2)
var ( var (
bh = itemBackupHandler{userID: user} bh = userDriveBackupHandler{userID: user}
driveBasePath1 = odConsts.DriveFolderPrefixBuilder(driveID1).String() driveBasePath1 = odConsts.DriveFolderPrefixBuilder(driveID1).String()
driveBasePath2 = odConsts.DriveFolderPrefixBuilder(driveID2).String() driveBasePath2 = odConsts.DriveFolderPrefixBuilder(driveID2).String()
@ -2468,8 +2468,8 @@ func (suite *OneDriveCollectionsUnitSuite) TestAddURLCacheToDriveCollections() {
// Add a few collections // Add a few collections
for i := 0; i < collCount; i++ { for i := 0; i < collCount; i++ {
coll, err := NewCollection( coll, err := NewCollection(
&itemBackupHandler{ &userDriveBackupHandler{
baseItemHandler: baseItemHandler{ baseUserDriveHandler: baseUserDriveHandler{
ac: api.Drives{}, ac: api.Drives{},
}, },
userID: "test-user", userID: "test-user",

6
src/internal/m365/collection/drive/group_handler.go
View File

@ -16,7 +16,7 @@ import (
var _ BackupHandler = &groupBackupHandler{} var _ BackupHandler = &groupBackupHandler{}
type groupBackupHandler struct { type groupBackupHandler struct {
libraryBackupHandler siteBackupHandler
groupID string groupID string
scope selectors.GroupsScope scope selectors.GroupsScope
} }
@ -27,8 +27,8 @@ func NewGroupBackupHandler(
scope selectors.GroupsScope, scope selectors.GroupsScope,
) groupBackupHandler { ) groupBackupHandler {
return groupBackupHandler{ return groupBackupHandler{
libraryBackupHandler{ siteBackupHandler{
baseLibraryHandler: baseLibraryHandler{ baseSiteHandler: baseSiteHandler{
ac: ac, ac: ac,
}, },
siteID: siteID, siteID: siteID,

2
src/internal/m365/collection/drive/group_handler_test.go
View File

@ -141,7 +141,7 @@ func (suite *GroupBackupHandlerUnitSuite) TestServiceCat() {
t := suite.T() t := suite.T()
s, c := groupBackupHandler{ s, c := groupBackupHandler{
libraryBackupHandler: libraryBackupHandler{service: path.GroupsService}, siteBackupHandler: siteBackupHandler{service: path.GroupsService},
}.ServiceCat() }.ServiceCat()
assert.Equal(t, path.GroupsService, s) assert.Equal(t, path.GroupsService, s)
assert.Equal(t, path.LibrariesCategory, c) assert.Equal(t, path.LibrariesCategory, c)

4
src/internal/m365/collection/drive/item_collector_test.go
View File

@ -266,8 +266,8 @@ func (suite *OneDriveIntgSuite) TestOneDriveNewCollections() {
) )
colls := NewCollections( colls := NewCollections(
&itemBackupHandler{ &userDriveBackupHandler{
baseItemHandler: baseItemHandler{ baseUserDriveHandler: baseUserDriveHandler{
ac: suite.ac.Drives(), ac: suite.ac.Drives(),
}, },
userID: test.user, userID: test.user,

2
src/internal/m365/collection/drive/item_test.go
View File

@ -80,7 +80,7 @@ func (suite *ItemIntegrationSuite) TestItemWriter() {
for _, test := range table { for _, test := range table {
suite.Run(test.name, func() { suite.Run(test.name, func() {
t := suite.T() t := suite.T()
rh := NewRestoreHandler(suite.service.ac) rh := NewUserDriveRestoreHandler(suite.service.ac)
ctx, flush := tester.NewContext(t) ctx, flush := tester.NewContext(t)
defer flush() defer flush()

76
src/internal/m365/collection/drive/library_handler.go → src/internal/m365/collection/drive/site_handler.go
View File

@ -18,18 +18,18 @@ import (
"github.com/alcionai/corso/src/pkg/services/m365/api" "github.com/alcionai/corso/src/pkg/services/m365/api"
) )
type baseLibraryHandler struct { type baseSiteHandler struct {
ac api.Drives ac api.Drives
} }
func (h baseLibraryHandler) NewDrivePager( func (h baseSiteHandler) NewDrivePager(
resourceOwner string, resourceOwner string,
fields []string, fields []string,
) api.Pager[models.Driveable] { ) api.Pager[models.Driveable] {
return h.ac.NewSiteDrivePager(resourceOwner, fields) return h.ac.NewSiteDrivePager(resourceOwner, fields)
} }
func (h baseLibraryHandler) AugmentItemInfo( func (h baseSiteHandler) AugmentItemInfo(
dii details.ItemInfo, dii details.ItemInfo,
resource idname.Provider, resource idname.Provider,
item models.DriveItemable, item models.DriveItemable,
@ -62,23 +62,23 @@ func (h baseLibraryHandler) AugmentItemInfo(
return dii return dii
} }
var _ BackupHandler = &libraryBackupHandler{} var _ BackupHandler = &siteBackupHandler{}
type libraryBackupHandler struct { type siteBackupHandler struct {
baseLibraryHandler baseSiteHandler
siteID string siteID string
scope selectors.SharePointScope scope selectors.SharePointScope
service path.ServiceType service path.ServiceType
} }
func NewLibraryBackupHandler( func NewSiteBackupHandler(
ac api.Drives, ac api.Drives,
siteID string, siteID string,
scope selectors.SharePointScope, scope selectors.SharePointScope,
service path.ServiceType, service path.ServiceType,
) libraryBackupHandler { ) siteBackupHandler {
return libraryBackupHandler{ return siteBackupHandler{
baseLibraryHandler: baseLibraryHandler{ baseSiteHandler: baseSiteHandler{
ac: ac, ac: ac,
}, },
siteID: siteID, siteID: siteID,
@ -87,7 +87,7 @@ func NewLibraryBackupHandler(
} }
} }
func (h libraryBackupHandler) Get( func (h siteBackupHandler) Get(
ctx context.Context, ctx context.Context,
url string, url string,
headers map[string]string, headers map[string]string,
@ -95,7 +95,7 @@ func (h libraryBackupHandler) Get(
return h.ac.Get(ctx, url, headers) return h.ac.Get(ctx, url, headers)
} }
func (h libraryBackupHandler) PathPrefix( func (h siteBackupHandler) PathPrefix(
tenantID, driveID string, tenantID, driveID string,
) (path.Path, error) { ) (path.Path, error) {
return path.Build( return path.Build(
@ -109,7 +109,7 @@ func (h libraryBackupHandler) PathPrefix(
odConsts.RootPathDir) odConsts.RootPathDir)
} }
func (h libraryBackupHandler) MetadataPathPrefix( func (h siteBackupHandler) MetadataPathPrefix(
tenantID string, tenantID string,
) (path.Path, error) { ) (path.Path, error) {
p, err := path.BuildMetadata( p, err := path.BuildMetadata(
@ -125,54 +125,54 @@ func (h libraryBackupHandler) MetadataPathPrefix(
return p, nil return p, nil
} }
func (h libraryBackupHandler) CanonicalPath( func (h siteBackupHandler) CanonicalPath(
folders *path.Builder, folders *path.Builder,
tenantID string, tenantID string,
) (path.Path, error) { ) (path.Path, error) {
return folders.ToDataLayerPath(tenantID, h.siteID, h.service, path.LibrariesCategory, false) return folders.ToDataLayerPath(tenantID, h.siteID, h.service, path.LibrariesCategory, false)
} }
func (h libraryBackupHandler) ServiceCat() (path.ServiceType, path.CategoryType) { func (h siteBackupHandler) ServiceCat() (path.ServiceType, path.CategoryType) {
return h.service, path.LibrariesCategory return h.service, path.LibrariesCategory
} }
func (h libraryBackupHandler) FormatDisplayPath( func (h siteBackupHandler) FormatDisplayPath(
driveName string, driveName string,
pb *path.Builder, pb *path.Builder,
) string { ) string {
return "/" + driveName + "/" + pb.String() return "/" + driveName + "/" + pb.String()
} }
func (h libraryBackupHandler) NewLocationIDer( func (h siteBackupHandler) NewLocationIDer(
driveID string, driveID string,
elems ...string, elems ...string,
) details.LocationIDer { ) details.LocationIDer {
return details.NewSharePointLocationIDer(driveID, elems...) return details.NewSharePointLocationIDer(driveID, elems...)
} }
func (h libraryBackupHandler) GetItemPermission( func (h siteBackupHandler) GetItemPermission(
ctx context.Context, ctx context.Context,
driveID, itemID string, driveID, itemID string,
) (models.PermissionCollectionResponseable, error) { ) (models.PermissionCollectionResponseable, error) {
return h.ac.GetItemPermission(ctx, driveID, itemID) return h.ac.GetItemPermission(ctx, driveID, itemID)
} }
func (h libraryBackupHandler) GetItem( func (h siteBackupHandler) GetItem(
ctx context.Context, ctx context.Context,
driveID, itemID string, driveID, itemID string,
) (models.DriveItemable, error) { ) (models.DriveItemable, error) {
return h.ac.GetItem(ctx, driveID, itemID) return h.ac.GetItem(ctx, driveID, itemID)
} }
func (h libraryBackupHandler) IsAllPass() bool { func (h siteBackupHandler) IsAllPass() bool {
return h.scope.IsAny(selectors.SharePointLibraryFolder) return h.scope.IsAny(selectors.SharePointLibraryFolder)
} }
func (h libraryBackupHandler) IncludesDir(dir string) bool { func (h siteBackupHandler) IncludesDir(dir string) bool {
return h.scope.Matches(selectors.SharePointLibraryFolder, dir) return h.scope.Matches(selectors.SharePointLibraryFolder, dir)
} }
func (h libraryBackupHandler) EnumerateDriveItemsDelta( func (h siteBackupHandler) EnumerateDriveItemsDelta(
ctx context.Context, ctx context.Context,
driveID, prevDeltaLink string, driveID, prevDeltaLink string,
selectProps []string, selectProps []string,
@ -184,17 +184,17 @@ func (h libraryBackupHandler) EnumerateDriveItemsDelta(
// Restore // Restore
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
var _ RestoreHandler = &libraryRestoreHandler{} var _ RestoreHandler = &siteRestoreHandler{}
type libraryRestoreHandler struct { type siteRestoreHandler struct {
baseLibraryHandler baseSiteHandler
ac api.Client ac api.Client
service path.ServiceType service path.ServiceType
} }
func NewLibraryRestoreHandler(ac api.Client, service path.ServiceType) libraryRestoreHandler { func NewSiteRestoreHandler(ac api.Client, service path.ServiceType) siteRestoreHandler {
return libraryRestoreHandler{ return siteRestoreHandler{
baseLibraryHandler: baseLibraryHandler{ baseSiteHandler: baseSiteHandler{
ac: ac.Drives(), ac: ac.Drives(),
}, },
ac: ac, ac: ac,
@ -202,28 +202,28 @@ func NewLibraryRestoreHandler(ac api.Client, service path.ServiceType) libraryRe
} }
} }
func (h libraryRestoreHandler) PostDrive( func (h siteRestoreHandler) PostDrive(
ctx context.Context, ctx context.Context,
siteID, driveName string, siteID, driveName string,
) (models.Driveable, error) { ) (models.Driveable, error) {
return h.ac.Lists().PostDrive(ctx, siteID, driveName) return h.ac.Lists().PostDrive(ctx, siteID, driveName)
} }
func (h libraryRestoreHandler) DeleteItem( func (h siteRestoreHandler) DeleteItem(
ctx context.Context, ctx context.Context,
driveID, itemID string, driveID, itemID string,
) error { ) error {
return h.ac.Drives().DeleteItem(ctx, driveID, itemID) return h.ac.Drives().DeleteItem(ctx, driveID, itemID)
} }
func (h libraryRestoreHandler) DeleteItemPermission( func (h siteRestoreHandler) DeleteItemPermission(
ctx context.Context, ctx context.Context,
driveID, itemID, permissionID string, driveID, itemID, permissionID string,
) error { ) error {
return h.ac.Drives().DeleteItemPermission(ctx, driveID, itemID, permissionID) return h.ac.Drives().DeleteItemPermission(ctx, driveID, itemID, permissionID)
} }
func (h libraryRestoreHandler) GetItemsInContainerByCollisionKey( func (h siteRestoreHandler) GetItemsInContainerByCollisionKey(
ctx context.Context, ctx context.Context,
driveID, containerID string, driveID, containerID string,
) (map[string]api.DriveItemIDType, error) { ) (map[string]api.DriveItemIDType, error) {
@ -235,14 +235,14 @@ func (h libraryRestoreHandler) GetItemsInContainerByCollisionKey(
return m, nil return m, nil
} }
func (h libraryRestoreHandler) NewItemContentUpload( func (h siteRestoreHandler) NewItemContentUpload(
ctx context.Context, ctx context.Context,
driveID, itemID string, driveID, itemID string,
) (models.UploadSessionable, error) { ) (models.UploadSessionable, error) {
return h.ac.Drives().NewItemContentUpload(ctx, driveID, itemID) return h.ac.Drives().NewItemContentUpload(ctx, driveID, itemID)
} }
func (h libraryRestoreHandler) PostItemPermissionUpdate( func (h siteRestoreHandler) PostItemPermissionUpdate(
ctx context.Context, ctx context.Context,
driveID, itemID string, driveID, itemID string,
body *drives.ItemItemsItemInvitePostRequestBody, body *drives.ItemItemsItemInvitePostRequestBody,
@ -250,7 +250,7 @@ func (h libraryRestoreHandler) PostItemPermissionUpdate(
return h.ac.Drives().PostItemPermissionUpdate(ctx, driveID, itemID, body) return h.ac.Drives().PostItemPermissionUpdate(ctx, driveID, itemID, body)
} }
func (h libraryRestoreHandler) PostItemLinkShareUpdate( func (h siteRestoreHandler) PostItemLinkShareUpdate(
ctx context.Context, ctx context.Context,
driveID, itemID string, driveID, itemID string,
body *drives.ItemItemsItemCreateLinkPostRequestBody, body *drives.ItemItemsItemCreateLinkPostRequestBody,
@ -258,7 +258,7 @@ func (h libraryRestoreHandler) PostItemLinkShareUpdate(
return h.ac.Drives().PostItemLinkShareUpdate(ctx, driveID, itemID, body) return h.ac.Drives().PostItemLinkShareUpdate(ctx, driveID, itemID, body)
} }
func (h libraryRestoreHandler) PostItemInContainer( func (h siteRestoreHandler) PostItemInContainer(
ctx context.Context, ctx context.Context,
driveID, parentFolderID string, driveID, parentFolderID string,
newItem models.DriveItemable, newItem models.DriveItemable,
@ -267,14 +267,14 @@ func (h libraryRestoreHandler) PostItemInContainer(
return h.ac.Drives().PostItemInContainer(ctx, driveID, parentFolderID, newItem, onCollision) return h.ac.Drives().PostItemInContainer(ctx, driveID, parentFolderID, newItem, onCollision)
} }
func (h libraryRestoreHandler) GetFolderByName( func (h siteRestoreHandler) GetFolderByName(
ctx context.Context, ctx context.Context,
driveID, parentFolderID, folderName string, driveID, parentFolderID, folderName string,
) (models.DriveItemable, error) { ) (models.DriveItemable, error) {
return h.ac.Drives().GetFolderByName(ctx, driveID, parentFolderID, folderName) return h.ac.Drives().GetFolderByName(ctx, driveID, parentFolderID, folderName)
} }
func (h libraryRestoreHandler) GetRootFolder( func (h siteRestoreHandler) GetRootFolder(
ctx context.Context, ctx context.Context,
driveID string, driveID string,
) (models.DriveItemable, error) { ) (models.DriveItemable, error) {

8
src/internal/m365/collection/drive/library_handler_test.go → src/internal/m365/collection/drive/site_handler_test.go
View File

@ -36,7 +36,7 @@ func (suite *LibraryBackupHandlerUnitSuite) TestPathPrefix() {
for _, test := range table { for _, test := range table {
suite.Run(test.name, func() { suite.Run(test.name, func() {
t := suite.T() t := suite.T()
h := libraryBackupHandler{service: path.SharePointService, siteID: resourceOwner} h := siteBackupHandler{service: path.SharePointService, siteID: resourceOwner}
result, err := h.PathPrefix(tenantID, "driveID") result, err := h.PathPrefix(tenantID, "driveID")
test.expectErr(t, err, clues.ToCore(err)) test.expectErr(t, err, clues.ToCore(err))
@ -65,7 +65,7 @@ func (suite *LibraryBackupHandlerUnitSuite) TestMetadataPathPrefix() {
for _, test := range table { for _, test := range table {
suite.Run(test.name, func() { suite.Run(test.name, func() {
t := suite.T() t := suite.T()
h := libraryBackupHandler{service: path.SharePointService, siteID: resourceOwner} h := siteBackupHandler{service: path.SharePointService, siteID: resourceOwner}
result, err := h.MetadataPathPrefix(tenantID) result, err := h.MetadataPathPrefix(tenantID)
test.expectErr(t, err, clues.ToCore(err)) test.expectErr(t, err, clues.ToCore(err))
@ -94,7 +94,7 @@ func (suite *LibraryBackupHandlerUnitSuite) TestCanonicalPath() {
for _, test := range table { for _, test := range table {
suite.Run(test.name, func() { suite.Run(test.name, func() {
t := suite.T() t := suite.T()
h := libraryBackupHandler{service: path.SharePointService, siteID: resourceOwner} h := siteBackupHandler{service: path.SharePointService, siteID: resourceOwner}
p := path.Builder{}.Append("prefix") p := path.Builder{}.Append("prefix")
result, err := h.CanonicalPath(p, tenantID) result, err := h.CanonicalPath(p, tenantID)
@ -110,7 +110,7 @@ func (suite *LibraryBackupHandlerUnitSuite) TestCanonicalPath() {
func (suite *LibraryBackupHandlerUnitSuite) TestServiceCat() { func (suite *LibraryBackupHandlerUnitSuite) TestServiceCat() {
t := suite.T() t := suite.T()
s, c := libraryBackupHandler{service: path.SharePointService}.ServiceCat() s, c := siteBackupHandler{service: path.SharePointService}.ServiceCat()
assert.Equal(t, path.SharePointService, s) assert.Equal(t, path.SharePointService, s)
assert.Equal(t, path.LibrariesCategory, c) assert.Equal(t, path.LibrariesCategory, c)
} }

74
src/internal/m365/collection/drive/item_handler.go → src/internal/m365/collection/drive/user_drive_handler.go
View File

@ -22,11 +22,11 @@ import (
// backup // backup
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
type baseItemHandler struct { type baseUserDriveHandler struct {
ac api.Drives ac api.Drives
} }
func (h baseItemHandler) NewDrivePager( func (h baseUserDriveHandler) NewDrivePager(
resourceOwner string, resourceOwner string,
fields []string, fields []string,
) api.Pager[models.Driveable] { ) api.Pager[models.Driveable] {
@ -38,7 +38,7 @@ func (h baseItemHandler) NewDrivePager(
// separately for restore processes because the local itemable // separately for restore processes because the local itemable
// doesn't have its size value updated as a side effect of creation, // doesn't have its size value updated as a side effect of creation,
// and kiota drops any SetSize update. // and kiota drops any SetSize update.
func (h baseItemHandler) AugmentItemInfo( func (h baseUserDriveHandler) AugmentItemInfo(
dii details.ItemInfo, dii details.ItemInfo,
resource idname.Provider, resource idname.Provider,
item models.DriveItemable, item models.DriveItemable,
@ -69,17 +69,17 @@ func (h baseItemHandler) AugmentItemInfo(
return dii return dii
} }
var _ BackupHandler = &itemBackupHandler{} var _ BackupHandler = &userDriveBackupHandler{}
type itemBackupHandler struct { type userDriveBackupHandler struct {
baseItemHandler baseUserDriveHandler
userID string userID string
scope selectors.OneDriveScope scope selectors.OneDriveScope
} }
func NewItemBackupHandler(ac api.Drives, userID string, scope selectors.OneDriveScope) *itemBackupHandler { func NewUserDriveBackupHandler(ac api.Drives, userID string, scope selectors.OneDriveScope) *userDriveBackupHandler {
return &itemBackupHandler{ return &userDriveBackupHandler{
baseItemHandler: baseItemHandler{ baseUserDriveHandler: baseUserDriveHandler{
ac: ac, ac: ac,
}, },
userID: userID, userID: userID,
@ -87,7 +87,7 @@ func NewItemBackupHandler(ac api.Drives, userID string, scope selectors.OneDrive
} }
} }
func (h itemBackupHandler) Get( func (h userDriveBackupHandler) Get(
ctx context.Context, ctx context.Context,
url string, url string,
headers map[string]string, headers map[string]string,
@ -95,7 +95,7 @@ func (h itemBackupHandler) Get(
return h.ac.Get(ctx, url, headers) return h.ac.Get(ctx, url, headers)
} }
func (h itemBackupHandler) PathPrefix( func (h userDriveBackupHandler) PathPrefix(
tenantID, driveID string, tenantID, driveID string,
) (path.Path, error) { ) (path.Path, error) {
return path.Build( return path.Build(
@ -109,7 +109,7 @@ func (h itemBackupHandler) PathPrefix(
odConsts.RootPathDir) odConsts.RootPathDir)
} }
func (h itemBackupHandler) MetadataPathPrefix( func (h userDriveBackupHandler) MetadataPathPrefix(
tenantID string, tenantID string,
) (path.Path, error) { ) (path.Path, error) {
p, err := path.BuildMetadata( p, err := path.BuildMetadata(
@ -125,54 +125,54 @@ func (h itemBackupHandler) MetadataPathPrefix(
return p, nil return p, nil
} }
func (h itemBackupHandler) CanonicalPath( func (h userDriveBackupHandler) CanonicalPath(
folders *path.Builder, folders *path.Builder,
tenantID string, tenantID string,
) (path.Path, error) { ) (path.Path, error) {
return folders.ToDataLayerOneDrivePath(tenantID, h.userID, false) return folders.ToDataLayerOneDrivePath(tenantID, h.userID, false)
} }
func (h itemBackupHandler) ServiceCat() (path.ServiceType, path.CategoryType) { func (h userDriveBackupHandler) ServiceCat() (path.ServiceType, path.CategoryType) {
return path.OneDriveService, path.FilesCategory return path.OneDriveService, path.FilesCategory
} }
func (h itemBackupHandler) FormatDisplayPath( func (h userDriveBackupHandler) FormatDisplayPath(
_ string, // drive name not displayed for onedrive _ string, // drive name not displayed for onedrive
pb *path.Builder, pb *path.Builder,
) string { ) string {
return "/" + pb.String() return "/" + pb.String()
} }
func (h itemBackupHandler) NewLocationIDer( func (h userDriveBackupHandler) NewLocationIDer(
driveID string, driveID string,
elems ...string, elems ...string,
) details.LocationIDer { ) details.LocationIDer {
return details.NewOneDriveLocationIDer(driveID, elems...) return details.NewOneDriveLocationIDer(driveID, elems...)
} }
func (h itemBackupHandler) GetItemPermission( func (h userDriveBackupHandler) GetItemPermission(
ctx context.Context, ctx context.Context,
driveID, itemID string, driveID, itemID string,
) (models.PermissionCollectionResponseable, error) { ) (models.PermissionCollectionResponseable, error) {
return h.ac.GetItemPermission(ctx, driveID, itemID) return h.ac.GetItemPermission(ctx, driveID, itemID)
} }
func (h itemBackupHandler) GetItem( func (h userDriveBackupHandler) GetItem(
ctx context.Context, ctx context.Context,
driveID, itemID string, driveID, itemID string,
) (models.DriveItemable, error) { ) (models.DriveItemable, error) {
return h.ac.GetItem(ctx, driveID, itemID) return h.ac.GetItem(ctx, driveID, itemID)
} }
func (h itemBackupHandler) IsAllPass() bool { func (h userDriveBackupHandler) IsAllPass() bool {
return h.scope.IsAny(selectors.OneDriveFolder) return h.scope.IsAny(selectors.OneDriveFolder)
} }
func (h itemBackupHandler) IncludesDir(dir string) bool { func (h userDriveBackupHandler) IncludesDir(dir string) bool {
return h.scope.Matches(selectors.OneDriveFolder, dir) return h.scope.Matches(selectors.OneDriveFolder, dir)
} }
func (h itemBackupHandler) EnumerateDriveItemsDelta( func (h userDriveBackupHandler) EnumerateDriveItemsDelta(
ctx context.Context, ctx context.Context,
driveID, prevDeltaLink string, driveID, prevDeltaLink string,
selectProps []string, selectProps []string,
@ -184,42 +184,42 @@ func (h itemBackupHandler) EnumerateDriveItemsDelta(
// Restore // Restore
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
var _ RestoreHandler = &itemRestoreHandler{} var _ RestoreHandler = &userDriveRestoreHandler{}
type itemRestoreHandler struct { type userDriveRestoreHandler struct {
baseItemHandler baseUserDriveHandler
} }
func NewRestoreHandler(ac api.Client) *itemRestoreHandler { func NewUserDriveRestoreHandler(ac api.Client) *userDriveRestoreHandler {
return &itemRestoreHandler{ return &userDriveRestoreHandler{
baseItemHandler: baseItemHandler{ baseUserDriveHandler: baseUserDriveHandler{
ac: ac.Drives(), ac: ac.Drives(),
}, },
} }
} }
func (h itemRestoreHandler) PostDrive( func (h userDriveRestoreHandler) PostDrive(
context.Context, context.Context,
string, string, string, string,
) (models.Driveable, error) { ) (models.Driveable, error) {
return nil, clues.New("creating drives in oneDrive is not supported") return nil, clues.New("creating drives in oneDrive is not supported")
} }
func (h itemRestoreHandler) DeleteItem( func (h userDriveRestoreHandler) DeleteItem(
ctx context.Context, ctx context.Context,
driveID, itemID string, driveID, itemID string,
) error { ) error {
return h.ac.DeleteItem(ctx, driveID, itemID) return h.ac.DeleteItem(ctx, driveID, itemID)
} }
func (h itemRestoreHandler) DeleteItemPermission( func (h userDriveRestoreHandler) DeleteItemPermission(
ctx context.Context, ctx context.Context,
driveID, itemID, permissionID string, driveID, itemID, permissionID string,
) error { ) error {
return h.ac.DeleteItemPermission(ctx, driveID, itemID, permissionID) return h.ac.DeleteItemPermission(ctx, driveID, itemID, permissionID)
} }
func (h itemRestoreHandler) GetItemsInContainerByCollisionKey( func (h userDriveRestoreHandler) GetItemsInContainerByCollisionKey(
ctx context.Context, ctx context.Context,
driveID, containerID string, driveID, containerID string,
) (map[string]api.DriveItemIDType, error) { ) (map[string]api.DriveItemIDType, error) {
@ -231,14 +231,14 @@ func (h itemRestoreHandler) GetItemsInContainerByCollisionKey(
return m, nil return m, nil
} }
func (h itemRestoreHandler) NewItemContentUpload( func (h userDriveRestoreHandler) NewItemContentUpload(
ctx context.Context, ctx context.Context,
driveID, itemID string, driveID, itemID string,
) (models.UploadSessionable, error) { ) (models.UploadSessionable, error) {
return h.ac.NewItemContentUpload(ctx, driveID, itemID) return h.ac.NewItemContentUpload(ctx, driveID, itemID)
} }
func (h itemRestoreHandler) PostItemPermissionUpdate( func (h userDriveRestoreHandler) PostItemPermissionUpdate(
ctx context.Context, ctx context.Context,
driveID, itemID string, driveID, itemID string,
body *drives.ItemItemsItemInvitePostRequestBody, body *drives.ItemItemsItemInvitePostRequestBody,
@ -246,7 +246,7 @@ func (h itemRestoreHandler) PostItemPermissionUpdate(
return h.ac.PostItemPermissionUpdate(ctx, driveID, itemID, body) return h.ac.PostItemPermissionUpdate(ctx, driveID, itemID, body)
} }
func (h itemRestoreHandler) PostItemLinkShareUpdate( func (h userDriveRestoreHandler) PostItemLinkShareUpdate(
ctx context.Context, ctx context.Context,
driveID, itemID string, driveID, itemID string,
body *drives.ItemItemsItemCreateLinkPostRequestBody, body *drives.ItemItemsItemCreateLinkPostRequestBody,
@ -254,7 +254,7 @@ func (h itemRestoreHandler) PostItemLinkShareUpdate(
return h.ac.PostItemLinkShareUpdate(ctx, driveID, itemID, body) return h.ac.PostItemLinkShareUpdate(ctx, driveID, itemID, body)
} }
func (h itemRestoreHandler) PostItemInContainer( func (h userDriveRestoreHandler) PostItemInContainer(
ctx context.Context, ctx context.Context,
driveID, parentFolderID string, driveID, parentFolderID string,
newItem models.DriveItemable, newItem models.DriveItemable,
@ -263,14 +263,14 @@ func (h itemRestoreHandler) PostItemInContainer(
return h.ac.PostItemInContainer(ctx, driveID, parentFolderID, newItem, onCollision) return h.ac.PostItemInContainer(ctx, driveID, parentFolderID, newItem, onCollision)
} }
func (h itemRestoreHandler) GetFolderByName( func (h userDriveRestoreHandler) GetFolderByName(
ctx context.Context, ctx context.Context,
driveID, parentFolderID, folderName string, driveID, parentFolderID, folderName string,
) (models.DriveItemable, error) { ) (models.DriveItemable, error) {
return h.ac.GetFolderByName(ctx, driveID, parentFolderID, folderName) return h.ac.GetFolderByName(ctx, driveID, parentFolderID, folderName)
} }
func (h itemRestoreHandler) GetRootFolder( func (h userDriveRestoreHandler) GetRootFolder(
ctx context.Context, ctx context.Context,
driveID string, driveID string,
) (models.DriveItemable, error) { ) (models.DriveItemable, error) {

8
src/internal/m365/collection/drive/item_handler_test.go → src/internal/m365/collection/drive/user_drive_handler_test.go
View File

@ -36,7 +36,7 @@ func (suite *ItemBackupHandlerUnitSuite) TestPathPrefix() {
for _, test := range table { for _, test := range table {
suite.Run(test.name, func() { suite.Run(test.name, func() {
t := suite.T() t := suite.T()
h := itemBackupHandler{userID: resourceOwner} h := userDriveBackupHandler{userID: resourceOwner}
result, err := h.PathPrefix(tenantID, "driveID") result, err := h.PathPrefix(tenantID, "driveID")
test.expectErr(t, err, clues.ToCore(err)) test.expectErr(t, err, clues.ToCore(err))
@ -65,7 +65,7 @@ func (suite *ItemBackupHandlerUnitSuite) TestMetadataPathPrefix() {
for _, test := range table { for _, test := range table {
suite.Run(test.name, func() { suite.Run(test.name, func() {
t := suite.T() t := suite.T()
h := itemBackupHandler{userID: resourceOwner} h := userDriveBackupHandler{userID: resourceOwner}
result, err := h.MetadataPathPrefix(tenantID) result, err := h.MetadataPathPrefix(tenantID)
test.expectErr(t, err, clues.ToCore(err)) test.expectErr(t, err, clues.ToCore(err))
@ -94,7 +94,7 @@ func (suite *ItemBackupHandlerUnitSuite) TestCanonicalPath() {
for _, test := range table { for _, test := range table {
suite.Run(test.name, func() { suite.Run(test.name, func() {
t := suite.T() t := suite.T()
h := itemBackupHandler{userID: resourceOwner} h := userDriveBackupHandler{userID: resourceOwner}
p := path.Builder{}.Append("prefix") p := path.Builder{}.Append("prefix")
result, err := h.CanonicalPath(p, tenantID) result, err := h.CanonicalPath(p, tenantID)
@ -110,7 +110,7 @@ func (suite *ItemBackupHandlerUnitSuite) TestCanonicalPath() {
func (suite *ItemBackupHandlerUnitSuite) TestServiceCat() { func (suite *ItemBackupHandlerUnitSuite) TestServiceCat() {
t := suite.T() t := suite.T()
s, c := itemBackupHandler{}.ServiceCat() s, c := userDriveBackupHandler{}.ServiceCat()
assert.Equal(t, path.OneDriveService, s) assert.Equal(t, path.OneDriveService, s)
assert.Equal(t, path.FilesCategory, c) assert.Equal(t, path.FilesCategory, c)
} }

2
src/internal/m365/collection/site/restore.go
View File

@ -41,7 +41,7 @@ func ConsumeRestoreCollections(
ctr *count.Bus, ctr *count.Bus,
) (*support.ControllerOperationStatus, error) { ) (*support.ControllerOperationStatus, error) {
var ( var (
lrh = drive.NewLibraryRestoreHandler(ac, rcc.Selector.PathService()) lrh = drive.NewSiteRestoreHandler(ac, rcc.Selector.PathService())
restoreMetrics support.CollectionMetrics restoreMetrics support.CollectionMetrics
caches = drive.NewRestoreCaches(backupDriveIDNames) caches = drive.NewRestoreCaches(backupDriveIDNames)
el = errs.Local() el = errs.Local()

2
src/internal/m365/restore.go
View File

@ -61,7 +61,7 @@ func (ctrl *Controller) ConsumeRestoreCollections(
case path.OneDriveService: case path.OneDriveService:
status, err = onedrive.ConsumeRestoreCollections( status, err = onedrive.ConsumeRestoreCollections(
ctx, ctx,
drive.NewRestoreHandler(ctrl.AC), drive.NewUserDriveRestoreHandler(ctrl.AC),
rcc, rcc,
ctrl.backupDriveIDNames, ctrl.backupDriveIDNames,
dcs, dcs,

2
src/internal/m365/service/groups/restore.go
View File

@ -39,7 +39,7 @@ func ConsumeRestoreCollections(
var ( var (
restoreMetrics support.CollectionMetrics restoreMetrics support.CollectionMetrics
caches = drive.NewRestoreCaches(backupDriveIDNames) caches = drive.NewRestoreCaches(backupDriveIDNames)
lrh = drive.NewLibraryRestoreHandler(ac, rcc.Selector.PathService()) lrh = drive.NewSiteRestoreHandler(ac, rcc.Selector.PathService())
el = errs.Local() el = errs.Local()
webURLToSiteNames = map[string]string{} webURLToSiteNames = map[string]string{}
) )

2
src/internal/m365/service/onedrive/backup.go
View File

@ -49,7 +49,7 @@ func ProduceBackupCollections(
logger.Ctx(ctx).Debug("creating OneDrive collections") logger.Ctx(ctx).Debug("creating OneDrive collections")
nc := drive.NewCollections( nc := drive.NewCollections(
drive.NewItemBackupHandler(ac.Drives(), bpc.ProtectedResource.ID(), scope), drive.NewUserDriveBackupHandler(ac.Drives(), bpc.ProtectedResource.ID(), scope),
tenant, tenant,
bpc.ProtectedResource, bpc.ProtectedResource,
su, su,

2
src/internal/m365/service/sharepoint/backup.go
View File

@ -80,7 +80,7 @@ func ProduceBackupCollections(
spcs, canUsePreviousBackup, err = site.CollectLibraries( spcs, canUsePreviousBackup, err = site.CollectLibraries(
ctx, ctx,
bpc, bpc,
drive.NewLibraryBackupHandler( drive.NewSiteBackupHandler(
ac.Drives(), ac.Drives(),
bpc.ProtectedResource.ID(), bpc.ProtectedResource.ID(),
scope, scope,

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

@ -51,7 +51,7 @@ func (suite *LibrariesBackupUnitSuite) TestUpdateCollections() {
) )
pb := path.Builder{}.Append(testBaseDrivePath.Elements()...) pb := path.Builder{}.Append(testBaseDrivePath.Elements()...)
ep, err := drive.NewLibraryBackupHandler(api.Drives{}, siteID, nil, path.SharePointService). ep, err := drive.NewSiteBackupHandler(api.Drives{}, siteID, nil, path.SharePointService).
CanonicalPath(pb, tenantID) CanonicalPath(pb, tenantID)
require.NoError(suite.T(), err, clues.ToCore(err)) require.NoError(suite.T(), err, clues.ToCore(err))
@ -99,7 +99,7 @@ func (suite *LibrariesBackupUnitSuite) TestUpdateCollections() {
) )
c := drive.NewCollections( c := drive.NewCollections(
drive.NewLibraryBackupHandler(api.Drives{}, siteID, test.scope, path.SharePointService), drive.NewSiteBackupHandler(api.Drives{}, siteID, test.scope, path.SharePointService),
tenantID, tenantID,
idname.NewProvider(siteID, siteID), idname.NewProvider(siteID, siteID),
nil, nil,

2
src/internal/m365/service/sharepoint/restore.go
View File

@ -33,7 +33,7 @@ func ConsumeRestoreCollections(
ctr *count.Bus, ctr *count.Bus,
) (*support.ControllerOperationStatus, error) { ) (*support.ControllerOperationStatus, error) {
var ( var (
lrh = drive.NewLibraryRestoreHandler(ac, rcc.Selector.PathService()) lrh = drive.NewSiteRestoreHandler(ac, rcc.Selector.PathService())
restoreMetrics support.CollectionMetrics restoreMetrics support.CollectionMetrics
caches = drive.NewRestoreCaches(backupDriveIDNames) caches = drive.NewRestoreCaches(backupDriveIDNames)
el = errs.Local() el = errs.Local()

2
src/internal/operations/test/group_test.go
View File

@ -62,7 +62,7 @@ func (suite *GroupsBackupIntgSuite) TestBackup_Run_incrementalGroups() {
} }
grh := func(ac api.Client) drive.RestoreHandler { grh := func(ac api.Client) drive.RestoreHandler {
return drive.NewLibraryRestoreHandler(ac, path.GroupsService) return drive.NewSiteRestoreHandler(ac, path.GroupsService)
} }
runDriveIncrementalTest( runDriveIncrementalTest(

2
src/internal/operations/test/onedrive_test.go
View File

@ -134,7 +134,7 @@ func (suite *OneDriveBackupIntgSuite) TestBackup_Run_incrementalOneDrive() {
} }
grh := func(ac api.Client) drive.RestoreHandler { grh := func(ac api.Client) drive.RestoreHandler {
return drive.NewRestoreHandler(ac) return drive.NewUserDriveRestoreHandler(ac)
} }
runDriveIncrementalTest( runDriveIncrementalTest(

2
src/internal/operations/test/sharepoint_test.go
View File

@ -73,7 +73,7 @@ func (suite *SharePointBackupIntgSuite) TestBackup_Run_incrementalSharePoint() {
} }
grh := func(ac api.Client) drive.RestoreHandler { grh := func(ac api.Client) drive.RestoreHandler {
return drive.NewLibraryRestoreHandler(ac, path.SharePointService) return drive.NewSiteRestoreHandler(ac, path.SharePointService)
} }
runDriveIncrementalTest( runDriveIncrementalTest(