Alphabetization

Author: Said Shah

src/utilities/toast-manager.test.ts

@@ -4,50 +4,57 @@ import { toast } from "react-toastify";
 
 describe("ToastManager", () => {
     // -----------------------------------------------------------------------------------------
-    // #region error
+    // #region dismiss
     // -----------------------------------------------------------------------------------------
 
-    describe("error", () => {
-        test("when toast created with toastId, returns given toastId", () => {
+    describe("dismiss", () => {
+        test("when executed, calls dismiss", () => {
             // Arrange
-            const expected = faker.random.number(99);
-            const toastContent = faker.random.word();
-            const toastOptions = { toastId: expected };
+            const dismissMethodSpy = jest.spyOn(toast, "dismiss");
+            const testId = faker.random.number(99);
 
             // Act
-            const toastId = ToastManager.error(toastContent, toastOptions);
+            ToastManager.dismiss(testId);
 
             // Assert
-            expect(toastId).toBe(expected);
+            expect(dismissMethodSpy).toHaveBeenCalledWith(testId);
         });
+    });
 
-        test("when toast created without toastId, returns new toastId", () => {
+    // #endregion dismiss
+
+    // -----------------------------------------------------------------------------------------
+    // #region dismissAll
+    // -----------------------------------------------------------------------------------------
+
+    describe("dismissAll", () => {
+        test("when executed, calls dismiss", () => {
             // Arrange
-            const toastContent = faker.random.word();
+            const dismissMethodSpy = jest.spyOn(toast, "dismiss");
 
             // Act
-            const toastId = ToastManager.error(toastContent);
+            ToastManager.dismissAll();
 
             // Assert
-            expect(toastId).not.toBeNil();
+            expect(dismissMethodSpy).toHaveBeenCalled();
         });
     });
 
-    // #endregion error
+    // #endregion dismissAll
 
     // -----------------------------------------------------------------------------------------
-    // #region info
+    // #region error
     // -----------------------------------------------------------------------------------------
 
-    describe("info", () => {
+    describe("error", () => {
         test("when toast created with toastId, returns given toastId", () => {
             // Arrange
             const expected = faker.random.number(99);
             const toastContent = faker.random.word();
             const toastOptions = { toastId: expected };
 
             // Act
-            const toastId = ToastManager.info(toastContent, toastOptions);
+            const toastId = ToastManager.error(toastContent, toastOptions);
 
             // Assert
             expect(toastId).toBe(expected);
@@ -58,28 +65,28 @@ describe("ToastManager", () => {
             const toastContent = faker.random.word();
 
             // Act
-            const toastId = ToastManager.info(toastContent);
+            const toastId = ToastManager.error(toastContent);
 
             // Assert
             expect(toastId).not.toBeNil();
         });
     });
 
-    // #endregion info
+    // #endregion error
 
     // -----------------------------------------------------------------------------------------
-    // #region success
+    // #region info
     // -----------------------------------------------------------------------------------------
 
-    describe("success", () => {
+    describe("info", () => {
         test("when toast created with toastId, returns given toastId", () => {
             // Arrange
             const expected = faker.random.number(99);
             const toastContent = faker.random.word();
             const toastOptions = { toastId: expected };
 
             // Act
-            const toastId = ToastManager.success(toastContent, toastOptions);
+            const toastId = ToastManager.info(toastContent, toastOptions);
 
             // Assert
             expect(toastId).toBe(expected);
@@ -90,28 +97,28 @@ describe("ToastManager", () => {
             const toastContent = faker.random.word();
 
             // Act
-            const toastId = ToastManager.success(toastContent);
+            const toastId = ToastManager.info(toastContent);
 
             // Assert
             expect(toastId).not.toBeNil();
         });
     });
 
-    // #endregion success
+    // #endregion info
 
     // -----------------------------------------------------------------------------------------
-    // #region warn
+    // #region success
     // -----------------------------------------------------------------------------------------
 
-    describe("warn", () => {
+    describe("success", () => {
         test("when toast created with toastId, returns given toastId", () => {
             // Arrange
             const expected = faker.random.number(99);
             const toastContent = faker.random.word();
             const toastOptions = { toastId: expected };
 
             // Act
-            const toastId = ToastManager.warn(toastContent, toastOptions);
+            const toastId = ToastManager.success(toastContent, toastOptions);
 
             // Assert
             expect(toastId).toBe(expected);
@@ -122,72 +129,65 @@ describe("ToastManager", () => {
             const toastContent = faker.random.word();
 
             // Act
-            const toastId = ToastManager.warn(toastContent);
+            const toastId = ToastManager.success(toastContent);
 
             // Assert
             expect(toastId).not.toBeNil();
         });
     });
 
-    // #endregion warn
+    // #endregion success
 
     // -----------------------------------------------------------------------------------------
-    // #region dismiss
+    // #region update
     // -----------------------------------------------------------------------------------------
 
-    describe("dismiss", () => {
-        test("when executed, calls dismiss", () => {
+    describe("update", () => {
+        test("when executed, calls update", () => {
             // Arrange
-            const dismissMethodSpy = jest.spyOn(toast, "dismiss");
+            const newContent = faker.random.words();
             const testId = faker.random.number(99);
+            const updateMethodSpy = jest.spyOn(ToastManager, "update");
 
             // Act
-            ToastManager.dismiss(testId);
+            ToastManager.update(testId, newContent);
 
             // Assert
-            expect(dismissMethodSpy).toHaveBeenCalledWith(testId);
+            expect(updateMethodSpy).toHaveBeenCalledWith(testId, newContent);
         });
     });
 
-    // #endregion dismiss
+    // #endregion update
 
     // -----------------------------------------------------------------------------------------
-    // #region dismissAll
+    // #region warn
     // -----------------------------------------------------------------------------------------
 
-    describe("dismissAll", () => {
-        test("when executed, calls dismiss", () => {
+    describe("warn", () => {
+        test("when toast created with toastId, returns given toastId", () => {
             // Arrange
-            const dismissMethodSpy = jest.spyOn(toast, "dismiss");
+            const expected = faker.random.number(99);
+            const toastContent = faker.random.word();
+            const toastOptions = { toastId: expected };
 
             // Act
-            ToastManager.dismissAll();
+            const toastId = ToastManager.warn(toastContent, toastOptions);
 
             // Assert
-            expect(dismissMethodSpy).toHaveBeenCalled();
+            expect(toastId).toBe(expected);
         });
-    });
-
-    // #endregion dismissAll
-
-    // -----------------------------------------------------------------------------------------
-    // #region update
-    // -----------------------------------------------------------------------------------------
 
-    describe("update", () => {
-        test("when executed, calls update", () => {
+        test("when toast created without toastId, returns new toastId", () => {
             // Arrange
-            const newContent = faker.random.words();
-            const testId = faker.random.number(99);
-            const updateMethodSpy = jest.spyOn(ToastManager, "update");
+            const toastContent = faker.random.word();
 
             // Act
-            ToastManager.update(testId, newContent);
+            const toastId = ToastManager.warn(toastContent);
 
             // Assert
-            expect(updateMethodSpy).toHaveBeenCalledWith(testId, newContent);
+            expect(toastId).not.toBeNil();
         });
     });
 
-    // #endregion update
+    // #endregion warn
 });