rename toOneDrivePath to toDrivePath (#3238)

Easier to grok that the func should work for all drive-ish services this
way.

src/internal/connector/onedrive/collection.go

@@ -120,12 +120,12 @@ func pathToLocation(p path.Path) (*path.Builder, error) {
 		return nil, nil
 	}
 
-	odp, err := path.ToOneDrivePath(p)
+	dp, err := path.ToDrivePath(p)
 	if err != nil {
 		return nil, err
 	}
 
-	return path.Builder{}.Append(odp.Root).Append(odp.Folders...), nil
+	return path.Builder{}.Append(dp.Root).Append(dp.Folders...), nil
 }
 
 // NewCollection creates a Collection

src/internal/connector/onedrive/permission.go

@@ -22,12 +22,12 @@ func getParentMetadata(
 ) (metadata.Metadata, error) {
 	parentMeta, ok := metas[parentPath.String()]
 	if !ok {
-		onedrivePath, err := path.ToOneDrivePath(parentPath)
+		drivePath, err := path.ToDrivePath(parentPath)
 		if err != nil {
 			return metadata.Metadata{}, clues.Wrap(err, "invalid restore path")
 		}
 
-		if len(onedrivePath.Folders) != 0 {
+		if len(drivePath.Folders) != 0 {
 			return metadata.Metadata{}, clues.Wrap(err, "computing item permissions")
 		}
 
@@ -88,7 +88,10 @@ func getCollectionMetadata(
 // traversing folderMetas and finding the first item with custom
 // permissions. folderMetas is expected to have all the parent
 // directory metas for this to work.
-func computeParentPermissions(itemPath path.Path, folderMetas map[string]metadata.Metadata) (metadata.Metadata, error) {
+func computeParentPermissions(
+	itemPath path.Path,
+	folderMetas map[string]metadata.Metadata,
+) (metadata.Metadata, error) {
 	var (
 		parent path.Path
 		meta   metadata.Metadata
@@ -105,12 +108,12 @@ func computeParentPermissions(itemPath path.Path, folderMetas map[string]metadat
 			return metadata.Metadata{}, clues.New("getting parent")
 		}
 
-		onedrivePath, err := path.ToOneDrivePath(parent)
+		drivePath, err := path.ToDrivePath(parent)
 		if err != nil {
 			return metadata.Metadata{}, clues.New("get parent path")
 		}
 
-		if len(onedrivePath.Folders) == 0 {
+		if len(drivePath.Folders) == 0 {
 			return metadata.Metadata{}, nil
 		}
 

src/internal/connector/onedrive/permission_test.go

@@ -23,27 +23,34 @@ func TestPermissionsUnitTestSuite(t *testing.T) {
 }
 
 func (suite *PermissionsUnitTestSuite) TestComputeParentPermissions() {
+	runComputeParentPermissionsTest(suite, path.OneDriveService, path.FilesCategory, "user")
+}
+
+func runComputeParentPermissionsTest(
+	suite *PermissionsUnitTestSuite,
+	service path.ServiceType,
+	category path.CategoryType,
+	resourceOwner string,
+) {
 	entryPath := fmt.Sprintf(rootDrivePattern, "drive-id") + "/level0/level1/level2/entry"
 	rootEntryPath := fmt.Sprintf(rootDrivePattern, "drive-id") + "/entry"
 
 	entry, err := path.Build(
 		"tenant",
-		"user",
+		resourceOwner,
-		path.OneDriveService,
+		service,
-		path.FilesCategory,
+		category,
 		false,
-		strings.Split(entryPath, "/")...,
+		strings.Split(entryPath, "/")...)
-	)
 	require.NoError(suite.T(), err, "creating path")
 
 	rootEntry, err := path.Build(
 		"tenant",
-		"user",
+		resourceOwner,
-		path.OneDriveService,
+		service,
-		path.FilesCategory,
+		category,
 		false,
-		strings.Split(rootEntryPath, "/")...,
+		strings.Split(rootEntryPath, "/")...)
-	)
 	require.NoError(suite.T(), err, "creating path")
 
 	level2, err := entry.Dir()

src/internal/connector/onedrive/restore.go

@@ -152,7 +152,7 @@ func RestoreCollection(
 	ctx, end := diagnostics.Span(ctx, "gc:oneDrive:restoreCollection", diagnostics.Label("path", directory))
 	defer end()
 
-	drivePath, err := path.ToOneDrivePath(directory)
+	drivePath, err := path.ToDrivePath(directory)
 	if err != nil {
 		return metrics, clues.Wrap(err, "creating drive path").WithClues(ctx)
 	}
@@ -791,12 +791,12 @@ func AugmentRestorePaths(backupVersion int, paths []path.Path) ([]path.Path, err
 				return nil, err
 			}
 
-			onedrivePath, err := path.ToOneDrivePath(np)
+			drivePath, err := path.ToDrivePath(np)
 			if err != nil {
 				return nil, err
 			}
 
-			if len(onedrivePath.Folders) == 0 {
+			if len(drivePath.Folders) == 0 {
 				break
 			}
 

src/pkg/backup/details/details.go

@@ -522,9 +522,9 @@ func (de Entry) ToLocationIDer(backupVersion int) (LocationIDer, error) {
 		return nil, clues.Wrap(err, "getting item RepoRef")
 	}
 
-	p, err := path.ToOneDrivePath(rr)
+	p, err := path.ToDrivePath(rr)
 	if err != nil {
-		return nil, clues.New("converting RepoRef to OneDrive path")
+		return nil, clues.New("converting RepoRef to drive path")
 	}
 
 	baseLoc := path.Builder{}.Append(p.Root).Append(p.Folders...)

src/pkg/path/drive.go

@@ -8,19 +8,21 @@ import "github.com/alcionai/clues"
 //
 // driveID is `b!X_8Z2zuXpkKkXZsr7gThk9oJpuj0yXVGnK5_VjRRPK-q725SX_8ZQJgFDK8PlFxA` and
 // folders[] is []{"Folder1", "Folder2"}
+//
+// Should be compatible with all drive-based services (ex: oneDrive, sharePoint Libraries, etc)
 type DrivePath struct {
 	DriveID string
 	Root    string
 	Folders Elements
 }
 
-func ToOneDrivePath(p Path) (*DrivePath, error) {
+func ToDrivePath(p Path) (*DrivePath, error) {
 	folders := p.Folders()
 
 	// Must be at least `drives/<driveID>/root:`
 	if len(folders) < 3 {
 		return nil, clues.
-			New("folder path doesn't match expected format for OneDrive items").
+			New("folder path doesn't match expected format for Drive items").
 			With("path_folders", p.Folder(false))
 	}
 
@@ -29,7 +31,7 @@ func ToOneDrivePath(p Path) (*DrivePath, error) {
 
 // Returns the path to the folder within the drive (i.e. under `root:`)
 func GetDriveFolderPath(p Path) (string, error) {
-	drivePath, err := ToOneDrivePath(p)
+	drivePath, err := ToDrivePath(p)
 	if err != nil {
 		return "", err
 	}

src/pkg/path/drive_test.go

@@ -54,7 +54,7 @@ func (suite *OneDrivePathSuite) Test_ToOneDrivePath() {
 			p, err := path.Build("tenant", "user", path.OneDriveService, path.FilesCategory, false, tt.pathElements...)
 			require.NoError(suite.T(), err, clues.ToCore(err))
 
-			got, err := path.ToOneDrivePath(p)
+			got, err := path.ToDrivePath(p)
 			tt.errCheck(t, err)
 			if err != nil {
 				return