Fix case comparison in switch cases (#2265)

## Description

Fix case comparisons and add more robust tests for service at least

## 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
- [x] 🐛 Bugfix
- [ ] 🗺️ Documentation
- [ ] 🤖 Test
- [ ] 💻 CI/Deployment
- [ ] 🧹 Tech Debt/Cleanup

## Issue(s)

* #2259 

## Test Plan

- [ ] 💪 Manual
- [x] ⚡ Unit test
- [ ] 💚 E2E

src/pkg/path/resource_path.go

@@ -35,17 +35,17 @@ func toServiceType(service string) ServiceType {
 	s := strings.ToLower(service)
 
 	switch s {
-	case ExchangeService.String():
+	case strings.ToLower(ExchangeService.String()):
 		return ExchangeService
-	case OneDriveService.String():
+	case strings.ToLower(OneDriveService.String()):
 		return OneDriveService
-	case SharePointService.String():
+	case strings.ToLower(SharePointService.String()):
 		return SharePointService
-	case ExchangeMetadataService.String():
+	case strings.ToLower(ExchangeMetadataService.String()):
 		return ExchangeMetadataService
-	case OneDriveMetadataService.String():
+	case strings.ToLower(OneDriveMetadataService.String()):
 		return OneDriveMetadataService
-	case SharePointMetadataService.String():
+	case strings.ToLower(SharePointMetadataService.String()):
 		return SharePointMetadataService
 	default:
 		return UnknownService
@@ -77,21 +77,21 @@ func ToCategoryType(category string) CategoryType {
 	cat := strings.ToLower(category)
 
 	switch cat {
-	case EmailCategory.String():
+	case strings.ToLower(EmailCategory.String()):
 		return EmailCategory
-	case ContactsCategory.String():
+	case strings.ToLower(ContactsCategory.String()):
 		return ContactsCategory
-	case EventsCategory.String():
+	case strings.ToLower(EventsCategory.String()):
 		return EventsCategory
-	case FilesCategory.String():
+	case strings.ToLower(FilesCategory.String()):
 		return FilesCategory
-	case LibrariesCategory.String():
+	case strings.ToLower(LibrariesCategory.String()):
 		return LibrariesCategory
-	case ListsCategory.String():
+	case strings.ToLower(ListsCategory.String()):
 		return ListsCategory
-	case PagesCategory.String():
+	case strings.ToLower(PagesCategory.String()):
 		return PagesCategory
-	case DetailsCategory.String():
+	case strings.ToLower(DetailsCategory.String()):
 		return DetailsCategory
 	default:
 		return UnknownCategory

src/pkg/path/service_category_test.go

@@ -74,14 +74,6 @@ func (suite *ServiceCategoryUnitSuite) TestValidateServiceAndCategory() {
 			category: "foo",
 			check:    assert.Error,
 		},
-		{
-			name:             "DifferentCases",
-			service:          strings.ToUpper(ExchangeService.String()),
-			category:         strings.ToUpper(EmailCategory.String()),
-			expectedService:  ExchangeService,
-			expectedCategory: EmailCategory,
-			check:            assert.NoError,
-		},
 		{
 			name:             "ExchangeEmail",
 			service:          ExchangeService.String(),
@@ -137,3 +129,51 @@ func (suite *ServiceCategoryUnitSuite) TestValidateServiceAndCategory() {
 		})
 	}
 }
+
+func (suite *ServiceCategoryUnitSuite) TestToServiceType() {
+	table := []struct {
+		name     string
+		service  string
+		expected ServiceType
+	}{
+		{
+			name:     "SameCase",
+			service:  ExchangeMetadataService.String(),
+			expected: ExchangeMetadataService,
+		},
+		{
+			name:     "DifferentCase",
+			service:  strings.ToUpper(ExchangeMetadataService.String()),
+			expected: ExchangeMetadataService,
+		},
+	}
+	for _, test := range table {
+		suite.T().Run(test.name, func(t *testing.T) {
+			assert.Equal(t, test.expected, toServiceType(test.service))
+		})
+	}
+}
+
+func (suite *ServiceCategoryUnitSuite) TestToCategoryType() {
+	table := []struct {
+		name     string
+		category string
+		expected CategoryType
+	}{
+		{
+			name:     "SameCase",
+			category: EmailCategory.String(),
+			expected: EmailCategory,
+		},
+		{
+			name:     "DifferentCase",
+			category: strings.ToUpper(EmailCategory.String()),
+			expected: EmailCategory,
+		},
+	}
+	for _, test := range table {
+		suite.T().Run(test.name, func(t *testing.T) {
+			assert.Equal(t, test.expected, ToCategoryType(test.category))
+		})
+	}
+}