Created tests in api/unclaimedItems/route.test.ts

Created documentation and GET for api/unclaimedItems/route.ts
Created authMockUtil and dbMockUtils tools for easier verification and db testing
No idea what I did to authMock but it is working properly

Author: shaply

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

@@ -0,0 +1,61 @@
+import { testApiHandler } from "next-test-api-route-handler";
+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 { 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" });
+        }
+    })
+});
+
+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);
+        }
+    })
+});
+
+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);
+        }
+    })
+});

src/app/api/unclaimedItems/route.ts

@@ -0,0 +1,45 @@
+import { NextRequest } from 'next/server';
+import { auth } from '@/auth';
+import { internalError, authenticationError, successResponse } from '@/util/responses';
+import { db } from '@/db';
+
+/**
+ * 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"
+ *     }
+ *   ]
+ * }
+ */
+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();
+
+        return successResponse({ unclaimedItems });
+    } catch (err: any) {
+        console.error(err?.message);
+        return internalError();
+    }
+}

src/test/authMock.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/util/authMockUtils.ts

@@ -0,0 +1,25 @@
+import { authMock } from "@/test/authMock";
+
+// 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: any = { id: "1234", type: "ADMIN" }, expires: string = "") {
+    authMock.mockReturnValueOnce({
+      user: {
+          id: user.id,
+          type: user.type,
+      },
+      expires: expires,
+    });
+  }

src/test/util/dbMockUtils.ts

@@ -0,0 +1,21 @@
+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;
+}

src/util/responses.ts

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