Fixed/changed code according to review comments

Author: shaply

.gitignore

@@ -39,3 +39,6 @@ yarn-error.log*
 # typescript
 *.tsbuildinfo
 next-env.d.ts
+
+# vscode
+.vscode/

package-lock.json

@@ -24,6 +24,7 @@
     "react-dom": "^19.0.0",
     "react-hot-toast": "^2.4.1",
     "react-icons": "^5.4.0",
+    "uuid": "^11.0.5",
     "zod": "^3.24.1",
     "zod-form-data": "^2.0.5"
   },
@@ -47,6 +48,7 @@
     "next-test-api-route-handler": "^4.0.14",
     "open-html": "^1.0.1",
     "postcss": "^8",
+    "prettier": "^3.4.2",
     "prisma": "^6.2.1",
     "tailwindcss": "^3.4.1",
     "ts-jest": "^29.2.5",

package.json

@@ -3,59 +3,52 @@ import * as appHandler from "./route";
 import { expect, test } from "@jest/globals";
 // import { authMock } from "@/test/authMock";
 import { validateSession, invalidateSession } from "@/test/util/authMockUtils";
-import { manyUnclaimedItems } from "@/test/util/dbMockUtils";
+import { fillDbMockWithManyUnclaimedItems } from "@/test/util/dbMockUtils";
 import { dbMock } from "@/test/dbMock";
-import { UnclaimedItem } from "@prisma/client";
 
 test("Should return 401 for invalid session", async () => {
-    await testApiHandler({
-        appHandler,
-        async test({ fetch }) {
-            invalidateSession();
-
-            const res = await fetch({ method: "GET" });
-            await expect(res.status).toBe(401);
-            const json = await res.json();
-            await expect(json).toEqual({ message: "Session required" });
-        }
-    })
+  await testApiHandler({
+    appHandler,
+    async test({ fetch }) {
+      invalidateSession();
+
+      const res = await fetch({ method: "GET" });
+      await expect(res.status).toBe(401);
+      const json = await res.json();
+      await expect(json).toEqual({ message: "Session required" });
+    },
+  });
 });
 
 test("Should return 200 for valid session", async () => {
-    await testApiHandler({
-        appHandler,
-        async test({ fetch }) {
-            validateSession();
-
-            const res = await fetch({ method: "GET" });
-            await expect(res.status).toBe(200);
-        }
-    })
+  await testApiHandler({
+    appHandler,
+    async test({ fetch }) {
+      validateSession("ADMIN");
+
+      const res = await fetch({ method: "GET" });
+      await expect(res.status).toBe(200);
+    },
+  });
 });
 
 test("Should give correct database queries", async () => {
-    await testApiHandler({
-        appHandler,
-        async test({ fetch }) {
-            // Create mock data
-            dbMock.unclaimedItem.create({ data: { id: 1, name: "Test Item 1", quantity: 1, expirationDate: new Date() } });
-            const items: UnclaimedItem[] = await manyUnclaimedItems(3);
-            // Convert items expirationDate to ISO-8601 string
-            const expectedRet = items.map(item => {
-                return { ...item, expirationDate: item.expirationDate?.toISOString() || "" }
-            });
-
-            validateSession();
-
-            const res = await fetch({ method: "GET" });
-            await expect(res.status).toBe(200);
-
-            // Check that the database was queried
-            await expect(dbMock.unclaimedItem.findMany).toHaveBeenCalledTimes(1);
-
-            // Check that the response json was written correctly
-            const json = await res.json();
-            await expect(json["unclaimedItems"]).toEqual(expectedRet);
-        }
-    })
-});
+  await testApiHandler({
+    appHandler,
+    async test({ fetch }) {
+      await fillDbMockWithManyUnclaimedItems(3);
+      validateSession("ADMIN");
+
+      const res = await fetch({ method: "GET" });
+      await expect(res.status).toBe(200);
+
+      // Check that the response json was written correctly
+      const expectedRet = {
+        numberOfItems: 3,
+        unclaimedItems: await dbMock.unclaimedItem.findMany(),
+      };
+      const json = await res.json();
+      await expect(json).toEqual(JSON.parse(JSON.stringify(expectedRet))); // Needed to stringify and parse because the expiration field would cause an error because Date != ISOstring
+    },
+  });
+});

src/app/api/unclaimedItems/route.test.ts

@@ -1,49 +1,41 @@
 // import { NextRequest } from 'next/server';
-import { auth } from '@/auth';
-import { internalError, authenticationError, successResponse } from '@/util/responses';
-import { db } from '@/db';
+import { auth } from "@/auth";
+import { authenticationError } from "@/util/responses";
+import { db } from "@/db";
+import { NextResponse } from "next/server";
+
+// Response for GET /api/unclaimedItems
+interface UnclaimedItemsResponse {
+  numberOfItems: number | 0;
+  unclaimedItems:
+    | {
+        id: number;
+        name: string;
+        quantity: number;
+        expirationDate: Date | null;
+      }[]
+    | [];
+}
 
 /**
  * Handles GET requests to retrieve unclaimed items from the unclaimedItem database.
- *
- * @returns {NextResponse} On success, returns a status of 200 and a JSON object containing an array of unclaimed items.
- * @returns {NextResponse} On authentication error, returns a status of 401 and a JSON object containing an error message.
- * @returns {NextResponse} On error, returns a status of 500 and a JSON object containing an error message.
- *
- * @example
- * // Example response:
- * {
- *   "unclaimedItems": [
- *     {
- *       "id": 1,
- *       "name": "Banana",
- *       "quantity": 10,
- *       "expirationDate": "2025-01-22T14:45:43.241Z"
- *     },
- *     {
- *       "id": 2,
- *       "name": "Apple",
- *       "quantity": 100,
- *       "expirationDate": "2025-01-22T14:45:43.243Z"
- *     }
- *   ]
- * }
+ * @returns 401 if the session is invalid
+ * @returns 500 if an unknown error occurs
+ * @returns 200 and a json response with the unclaimed items
  */
 export async function GET() {
-    try {
-        const session = await auth();
-        if (!session) return authenticationError('Session required');
-        
-        // Get all unclaimed items
-        const unclaimedItems = await db.unclaimedItem.findMany();
+  const session = await auth();
+  if (!session) return authenticationError("Session required");
+
+  if (!session?.user) {
+    return authenticationError("User not found");
+  }
+
+  // Get all unclaimed items
+  const unclaimedItems = await db.unclaimedItem.findMany();
 
-        return successResponse({ unclaimedItems });
-    } catch (err: unknown) {
-        if (err instanceof Error) {
-            console.error(err.message);
-        } else {
-            console.error('An unknown error occurred');
-        }
-        return internalError();
-    }
-}
+  return NextResponse.json({
+    numberOfItems: unclaimedItems?.length, // ?.length for when unclaimedItems is undefined
+    unclaimedItems: unclaimedItems,
+  } as UnclaimedItemsResponse);
+}

src/app/api/unclaimedItems/route.ts

@@ -13,4 +13,4 @@ beforeEach(() => {
   mockReset(authMock);
 });
 
-export const authMock = auth as unknown as jest.Mock<() => Session | null>;
+export const authMock = auth as unknown as jest.Mock<() => Session | null>;

src/test/authMock.ts

@@ -1,28 +1,33 @@
 import { authMock } from "@/test/authMock";
 import { UserType } from "@prisma/client";
+import { v4 as uuidv4 } from "uuid";
 
 // Helper util methods for testing
 
 /**
  * Helper method for invalidating a session
  */
 export async function invalidateSession() {
-    authMock.mockReturnValueOnce(null);
-  }
-  
-  /**
-   * Helper method for validating a session
-   * @param user Optional, default is { id: "1234", type: "ADMIN" }
-   * @param expires Optional, default is ""
-   */
-  export async function validateSession(
-    user: { id: string, type: UserType } = { id: "1234", type: "ADMIN" },
-    expires: string = "") {
-    authMock.mockReturnValueOnce({
-      user: {
-          id: user.id,
-          type: user.type,
-      },
-      expires: expires,
-    });
-  }
+  authMock.mockReturnValueOnce(null);
+}
+
+/**
+ * Helper method for validating a session
+ * @param user Optional, default is { id: "1234", type: "ADMIN" }
+ * @param expires Optional, default is a day from now
+ * @returns A session object with the user and expires fields
+ */
+export async function validateSession(
+  userType: UserType,
+  expires: Date = new Date(Date.now() + 86400000)
+) {
+  const createdSession = {
+    user: {
+      id: uuidv4(),
+      type: userType,
+    },
+    expires: expires.toISOString(),
+  };
+  authMock.mockReturnValueOnce(createdSession);
+  return createdSession;
+}

src/test/util/authMockUtils.ts

@@ -1,21 +1,36 @@
 import { dbMock } from "@/test/dbMock";
 import { UnclaimedItem } from "@prisma/client";
 
-
 // Helper util methods for testing
 
-
 /**
  * Helper method for creating unclaimed items
  * Defines the db.unclaimedItem.findMany mock
  * @param num Number of items to create
  * @returns Array of UnclaimedItems returned by db.unclaimedItem.findMany mock
  */
-export async function manyUnclaimedItems(num: number): Promise<UnclaimedItem[]> {
-    const items: UnclaimedItem[] = [];
-    for (let i = 0; i < num; i++) {
-        items.push({id: i, name: `Test Item ${i}`, quantity: i, expirationDate: new Date()});
-    }
-    dbMock.unclaimedItem.findMany.mockResolvedValue(items);
-    return items;
-}
+export async function fillDbMockWithManyUnclaimedItems(
+  num: number
+): Promise<UnclaimedItem[]> {
+  const items: UnclaimedItem[] = [];
+  const generatedIds = new Set<number>();
+
+  for (let i = 0; i < num; i++) {
+    let id: number;
+    do {
+      id = Math.floor(Math.random() * 1000000); // Generate a random integer ID
+    } while (generatedIds.has(id)); // Ensure the ID is unique
+
+    generatedIds.add(id);
+
+    items.push({
+      id: id,
+      name: `Test Item ${id}`,
+      quantity: Math.floor(Math.random() * 1000),
+      expirationDate: new Date(Date.now() + Math.floor(Math.random() * 10000)),
+    });
+  }
+
+  dbMock.unclaimedItem.findMany.mockResolvedValue(items);
+  return items;
+}

src/test/util/dbMockUtils.ts

@@ -27,7 +27,3 @@ export function internalError() {
 export function ok() {
   return NextResponse.json({ message: "OK" }, { status: 200 });
 }
-
-export function successResponse<T>(data: T) {
-  return NextResponse.json(data, { status: 200 });
-}