Tests for group handler (#4158)

<!-- PR description-->

---

#### 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

<!--- Please check the type of change your PR introduces: --->
- [ ] 🌻 Feature
- [ ] 🐛 Bugfix
- [ ] 🗺️ Documentation
- [x] 🤖 Supportability/Tests
- [ ] 💻 CI/Deployment
- [ ] 🧹 Tech Debt/Cleanup

#### Issue(s)

<!-- Can reference multiple issues. Use one of the following "magic words" - "closes, fixes" to auto-close the Github issue. -->
* https://github.com/alcionai/corso/issues/4154

#### Test Plan

<!-- How will this be tested prior to merging.-->
- [ ] 💪 Manual
- [x] ⚡ Unit test
- [ ] 💚 E2E

src/internal/m365/collection/drive/group_handler_test.go

@@ -0,0 +1,119 @@
+package drive
+
+import (
+	"testing"
+
+	"github.com/alcionai/clues"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/suite"
+
+	"github.com/alcionai/corso/src/internal/tester"
+	"github.com/alcionai/corso/src/pkg/path"
+	"github.com/alcionai/corso/src/pkg/services/m365/api"
+)
+
+type GroupBackupHandlerUnitSuite struct {
+	tester.Suite
+}
+
+func TestGroupBackupHandlerUnitSuite(t *testing.T) {
+	suite.Run(t, &GroupBackupHandlerUnitSuite{Suite: tester.NewUnitSuite(t)})
+}
+
+func (suite *GroupBackupHandlerUnitSuite) TestPathPrefix() {
+	tenantID, resourceOwner := "tenant", "resourceOwner"
+
+	table := []struct {
+		name      string
+		expect    string
+		expectErr assert.ErrorAssertionFunc
+	}{
+		{
+			name:      "group",
+			expect:    "tenant/groups/resourceOwner/libraries/sites/site-id/drives/drive-id/root:",
+			expectErr: assert.NoError,
+		},
+	}
+	for _, test := range table {
+		suite.Run(test.name, func() {
+			t := suite.T()
+			h := NewGroupBackupHandler(resourceOwner, "site-id", api.Drives{}, nil)
+
+			result, err := h.PathPrefix(tenantID, "drive-id")
+			test.expectErr(t, err, clues.ToCore(err))
+
+			if result != nil {
+				assert.Equal(t, test.expect, result.String())
+			}
+		})
+	}
+}
+
+func (suite *GroupBackupHandlerUnitSuite) TestMetadataPathPrefix() {
+	tenantID, resourceOwner := "tenant", "resourceOwner"
+
+	table := []struct {
+		name      string
+		expect    string
+		expectErr assert.ErrorAssertionFunc
+	}{
+		{
+			name:      "group",
+			expect:    "tenant/groupsMetadata/resourceOwner/libraries",
+			expectErr: assert.NoError,
+		},
+	}
+	for _, test := range table {
+		suite.Run(test.name, func() {
+			t := suite.T()
+			h := NewGroupBackupHandler(resourceOwner, "site-id", api.Drives{}, nil)
+
+			result, err := h.MetadataPathPrefix(tenantID)
+			test.expectErr(t, err, clues.ToCore(err))
+
+			if result != nil {
+				assert.Equal(t, test.expect, result.String())
+			}
+		})
+	}
+}
+
+func (suite *GroupBackupHandlerUnitSuite) TestCanonicalPath() {
+	tenantID, resourceOwner := "tenant", "resourceOwner"
+
+	table := []struct {
+		name      string
+		expect    string
+		expectErr assert.ErrorAssertionFunc
+	}{
+		{
+			name:      "group",
+			expect:    "tenant/groups/resourceOwner/libraries/sites/site-id/prefix",
+			expectErr: assert.NoError,
+		},
+	}
+	for _, test := range table {
+		suite.Run(test.name, func() {
+			t := suite.T()
+			h := NewGroupBackupHandler(resourceOwner, "site-id", api.Drives{}, nil)
+			p := path.Builder{}.Append("prefix")
+
+			result, err := h.CanonicalPath(p, tenantID)
+			test.expectErr(t, err, clues.ToCore(err))
+
+			if result != nil {
+				assert.Equal(t, test.expect, result.String())
+			}
+		})
+	}
+}
+
+func (suite *GroupBackupHandlerUnitSuite) TestServiceCat() {
+	t := suite.T()
+
+	s, c := groupBackupHandler{
+		libraryBackupHandler: libraryBackupHandler{service: path.GroupsService},
+	}.ServiceCat()
+	assert.Equal(t, path.GroupsService, s)
+	assert.Equal(t, path.LibrariesCategory, c)
+}

src/internal/m365/collection/drive/item_handler_test.go

@@ -19,6 +19,64 @@ func TestItemBackupHandlerUnitSuite(t *testing.T) {
 	suite.Run(t, &ItemBackupHandlerUnitSuite{Suite: tester.NewUnitSuite(t)})
 }
 
+func (suite *ItemBackupHandlerUnitSuite) TestPathPrefix() {
+	tenantID, resourceOwner := "tenant", "resourceOwner"
+
+	table := []struct {
+		name      string
+		expect    string
+		expectErr assert.ErrorAssertionFunc
+	}{
+		{
+			name:      "onedrive",
+			expect:    "tenant/onedrive/resourceOwner/files/drives/driveID/root:",
+			expectErr: assert.NoError,
+		},
+	}
+	for _, test := range table {
+		suite.Run(test.name, func() {
+			t := suite.T()
+			h := itemBackupHandler{userID: resourceOwner}
+
+			result, err := h.PathPrefix(tenantID, "driveID")
+			test.expectErr(t, err, clues.ToCore(err))
+
+			if result != nil {
+				assert.Equal(t, test.expect, result.String())
+			}
+		})
+	}
+}
+
+func (suite *ItemBackupHandlerUnitSuite) TestMetadataPathPrefix() {
+	tenantID, resourceOwner := "tenant", "resourceOwner"
+
+	table := []struct {
+		name      string
+		expect    string
+		expectErr assert.ErrorAssertionFunc
+	}{
+		{
+			name:      "onedrive",
+			expect:    "tenant/onedriveMetadata/resourceOwner/files",
+			expectErr: assert.NoError,
+		},
+	}
+	for _, test := range table {
+		suite.Run(test.name, func() {
+			t := suite.T()
+			h := itemBackupHandler{userID: resourceOwner}
+
+			result, err := h.MetadataPathPrefix(tenantID)
+			test.expectErr(t, err, clues.ToCore(err))
+
+			if result != nil {
+				assert.Equal(t, test.expect, result.String())
+			}
+		})
+	}
+}
+
 func (suite *ItemBackupHandlerUnitSuite) TestCanonicalPath() {
 	tenantID, resourceOwner := "tenant", "resourceOwner"
 

src/internal/m365/collection/drive/library_handler_test.go

@@ -19,6 +19,64 @@ func TestLibraryBackupHandlerUnitSuite(t *testing.T) {
 	suite.Run(t, &LibraryBackupHandlerUnitSuite{Suite: tester.NewUnitSuite(t)})
 }
 
+func (suite *LibraryBackupHandlerUnitSuite) TestPathPrefix() {
+	tenantID, resourceOwner := "tenant", "resourceOwner"
+
+	table := []struct {
+		name      string
+		expect    string
+		expectErr assert.ErrorAssertionFunc
+	}{
+		{
+			name:      "sharepoint",
+			expect:    "tenant/sharepoint/resourceOwner/libraries/drives/driveID/root:",
+			expectErr: assert.NoError,
+		},
+	}
+	for _, test := range table {
+		suite.Run(test.name, func() {
+			t := suite.T()
+			h := libraryBackupHandler{service: path.SharePointService, siteID: resourceOwner}
+
+			result, err := h.PathPrefix(tenantID, "driveID")
+			test.expectErr(t, err, clues.ToCore(err))
+
+			if result != nil {
+				assert.Equal(t, test.expect, result.String())
+			}
+		})
+	}
+}
+
+func (suite *LibraryBackupHandlerUnitSuite) TestMetadataPathPrefix() {
+	tenantID, resourceOwner := "tenant", "resourceOwner"
+
+	table := []struct {
+		name      string
+		expect    string
+		expectErr assert.ErrorAssertionFunc
+	}{
+		{
+			name:      "sharepoint",
+			expect:    "tenant/sharepointMetadata/resourceOwner/libraries",
+			expectErr: assert.NoError,
+		},
+	}
+	for _, test := range table {
+		suite.Run(test.name, func() {
+			t := suite.T()
+			h := libraryBackupHandler{service: path.SharePointService, siteID: resourceOwner}
+
+			result, err := h.MetadataPathPrefix(tenantID)
+			test.expectErr(t, err, clues.ToCore(err))
+
+			if result != nil {
+				assert.Equal(t, test.expect, result.String())
+			}
+		})
+	}
+}
+
 func (suite *LibraryBackupHandlerUnitSuite) TestCanonicalPath() {
 	tenantID, resourceOwner := "tenant", "resourceOwner"