From b71e3d9147f97e3deecbf979a988f210bc25279e Mon Sep 17 00:00:00 2001
From: ashmrtn <ashmrtnz@alcion.ai>
Date: Wed, 25 Jan 2023 18:26:05 -0800
Subject: [PATCH] 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?

- [ ] :white_check_mark: Yes, it's included
- [ ] :clock1: Yes, but in a later PR
- [x] :no_entry: No

## Type of change

- [ ] :sunflower: Feature
- [x] :bug: Bugfix
- [ ] :world_map: Documentation
- [ ] :robot: Test
- [ ] :computer: CI/Deployment
- [ ] :broom: Tech Debt/Cleanup

## Issue(s)

* #2259

## Test Plan

- [ ] :muscle: Manual
- [x] :zap: Unit test
- [ ] :green_heart: E2E
---
 src/pkg/path/resource_path.go         | 28 +++++++-------
 src/pkg/path/service_category_test.go | 56 +++++++++++++++++++++++----
 2 files changed, 62 insertions(+), 22 deletions(-)

diff --git a/src/pkg/path/resource_path.go b/src/pkg/path/resource_path.go
index b8113618e..07f9f429c 100644
--- a/src/pkg/path/resource_path.go
+++ b/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
diff --git a/src/pkg/path/service_category_test.go b/src/pkg/path/service_category_test.go
index 72e389e2a..a97f22cd8 100644
--- a/src/pkg/path/service_category_test.go
+++ b/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))
+		})
+	}
+}