sanity test: add assert func (#3107)

Adds a centralized assert func, and separates
the role check into a couple separate checks for
better assertion of equality.

---

#### Type of change

- [x] 🤖 Supportability/Tests

#### Issue(s)

* #3081

#### Test Plan

- [x] 💚 E2E

src/cmd/sanity_test/sanity_tests.go

@@ -167,20 +167,15 @@ func checkEmailRestoration(
 }
 
 func verifyEmailData(ctx context.Context, restoreMessageCount, messageCount map[string]int32) {
-	for fldName, emailCount := range messageCount {
+	for fldName, expected := range messageCount {
-		if restoreMessageCount[fldName] != emailCount {
+		got := restoreMessageCount[fldName]
-			logger.Ctx(ctx).Errorw(
-				"test failure: Restore item counts do not match",
-				"expected:", emailCount,
-				"actual:", restoreMessageCount[fldName])
 
-			fmt.Println(
+		assert(
-				"test failure: Restore item counts do not match",
+			ctx,
-				"* expected:", emailCount,
+			func() bool { return expected == got },
-				"* actual:", restoreMessageCount[fldName])
+			fmt.Sprintf("Restore item counts do not match: %s", fldName),
-
+			expected,
-			os.Exit(1)
+			got)
-		}
 	}
 }
 
@@ -380,58 +375,48 @@ func checkOnedriveRestoration(
 		restoreFolderPerm := restoreFolderPermission[folderName]
 
 		if len(permissions) < 1 {
-			logger.Ctx(ctx).Info("no permissions found in :", folderName)
+			logger.Ctx(ctx).Info("no permissions found in:", folderName)
-			fmt.Println("no permissions found in :", folderName)
+			fmt.Println("no permissions found in:", folderName)
 
 			continue
 		}
 
-		if len(restoreFolderPerm) < 1 {
+		assert(
-			logger.Ctx(ctx).Info("permission roles are not equal for :",
+			ctx,
-				"Item:", folderName,
+			func() bool { return len(permissions) == len(restoreFolderPerm) },
-				"* Permission found: ", permissions,
+			fmt.Sprintf("wrong number of restored permissions: %s", folderName),
-				"* blank permission found in restore.")
+			permissions,
+			restoreFolderPerm)
 
-			fmt.Println("permission roles are not equal for:")
+		for i, perm := range permissions {
-			fmt.Println("Item:", folderName)
+			// permissions should be sorted, so a by-index comparison works
-			fmt.Println("* Permission found: ", permissions)
+			restored := restoreFolderPerm[i]
-			fmt.Println("blank permission found in restore.")
 
-			os.Exit(1)
+			assert(
-		}
+				ctx,
+				func() bool { return strings.EqualFold(perm.entityID, restored.entityID) },
+				fmt.Sprintf("non-matching entity id: %s", folderName),
+				perm.entityID,
+				restored.entityID)
 
-		for i, orginalPerm := range permissions {
+			assert(
-			restorePerm := restoreFolderPerm[i]
+				ctx,
-
+				func() bool { return slices.Equal(perm.roles, restored.roles) },
-			if !(orginalPerm.entityID != restorePerm.entityID) &&
+				fmt.Sprintf("different roles restored: %s", folderName),
-				!slices.Equal(orginalPerm.roles, restorePerm.roles) {
+				perm.roles,
-				logger.Ctx(ctx).Info("permission roles are not equal for :",
+				restored.roles)
-					"Item:", folderName,
-					"* Original permission: ", orginalPerm.entityID,
-					"* Restored permission: ", restorePerm.entityID)
-
-				fmt.Println("permission roles are not equal for:")
-				fmt.Println("Item:", folderName)
-				fmt.Println("* Original permission: ", orginalPerm.entityID)
-				fmt.Println("* Restored permission: ", restorePerm.entityID)
-				os.Exit(1)
-			}
 		}
 	}
 
-	for fileName, fileSize := range fileSizes {
+	for fileName, expected := range fileSizes {
-		if fileSize != restoreFile[fileName] {
+		got := restoreFile[fileName]
-			logger.Ctx(ctx).Info("File size does not match for:",
-				"Item:", fileName,
-				"*  expected:", fileSize,
-				"*  actual:", restoreFile[fileName])
 
-			fmt.Println("File size does not match for:")
+		assert(
-			fmt.Println("item:", fileName)
+			ctx,
-			fmt.Println("*  expected:", fileSize)
+			func() bool { return expected == got },
-			fmt.Println("*  actual:", restoreFile[fileName])
+			fmt.Sprintf("different file size: %s", fileName),
-			os.Exit(1)
+			expected,
-		}
+			got)
 	}
 
 	fmt.Println("Success")
@@ -619,3 +604,26 @@ func filterSlice(sl []string, remove string) []string {
 
 	return r
 }
+
+func assert(
+	ctx context.Context,
+	passes func() bool,
+	header string,
+	expect, current any,
+) {
+	if passes() {
+		return
+	}
+
+	header = "Error: " + header
+	expected := fmt.Sprintf("* Expected: %+v", expect)
+	got := fmt.Sprintf("* Current: %+v", current)
+
+	logger.Ctx(ctx).Info(strings.Join([]string{header, expected, got}, " "))
+
+	fmt.Println(header)
+	fmt.Println(expected)
+	fmt.Println(got)
+
+	os.Exit(1)
+}