chore: add vitest tests

withastro/astro#9653

Dockerfile

@@ -61,4 +61,7 @@ ENTRYPOINT [ "/app/docker-entrypoint.js" ]
 # Start the server by default, this can be overwritten at runtime
 EXPOSE 3000
 ENV DATABASE_URL="file:///data/ping_me_db.db"
+
+RUN yarn astro preferences disable devToolbar
+
 CMD [ "yarn", "run", "start" ]

package.json

@@ -12,14 +12,15 @@
     "seed": "npx ts-node --esm ./seed.ts",
     "lint": "eslint --ext .ts,.tsx,.astro .",
     "lint:fix": "yarn lint --fix",
+    "test": "vitest",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
     "@astrojs/node": "^7.0.4",
     "@fontsource/pacifico": "^5.0.8",
     "@prisma/client": "4.16.2",
     "@toast-ui/editor": "^3.2.2",
-    "astro": "^4.1.1",
+    "astro": "^4.1.2",
     "astro-htmx": "^1.0.5",
     "bcryptjs": "^2.4.3",
     "cron-parser": "^4.9.0",
@@ -44,6 +45,7 @@
     "eslint-plugin-prettier": "^5.0.0",
     "prettier": "^3.0.0",
     "prettier-plugin-astro": "^0.11.1",
-    "prisma": "^4.16.2"
+    "prisma": "^4.16.2",
+    "vitest": "^1.1.3"
   }
 }

src/env.d.ts

@@ -1 +1,2 @@
+/// <reference path="../.astro/types.d.ts" />
 /// <reference types="astro/client" />

src/repositories/PrismaReminderRepository.test.ts

@@ -0,0 +1,248 @@
+import { describe, expect, it, vi } from "vitest";
+import { PrismaReminderRepository } from "./PrismaReminderRepository";
+import type { PrismaClient } from "@prisma/client";
+
+describe(PrismaReminderRepository.name, () => {
+  const mockUserId = 1;
+  const mockFolderId = 2;
+  const mockSchedule = "* * * * *";
+  const mockReminderId = 10;
+
+  describe("getReminder", () => {
+    it("should get a reminder", async () => {
+      const client = {
+        $queryRawUnsafe: vi.fn().mockResolvedValue([
+          {
+            dueDate: new Date(),
+            schedule: mockSchedule,
+          },
+        ]),
+      } as unknown as PrismaClient;
+
+      const reminderRepository = new PrismaReminderRepository(client);
+
+      const reminder = await reminderRepository.getReminder(
+        mockFolderId,
+        mockUserId,
+      );
+
+      expect(reminder).toEqual({
+        schedule: mockSchedule,
+        dueDate: expect.any(Date),
+      });
+    });
+
+    it("should return null if reminder is not found", async () => {
+      const client = {
+        $queryRawUnsafe: vi.fn().mockResolvedValue([]),
+      } as unknown as PrismaClient;
+
+      const reminderRepository = new PrismaReminderRepository(client);
+
+      const reminder = await reminderRepository.getReminder(
+        mockFolderId,
+        mockUserId,
+      );
+
+      expect(reminder).toBeNull();
+    });
+
+    it("should handle errors", async () => {
+      const consoleErrorSpy = vi.spyOn(console, "error");
+
+      const client = {
+        $queryRawUnsafe: vi.fn().mockRejectedValue(new Error("error")),
+      } as unknown as PrismaClient;
+
+      const reminderRepository = new PrismaReminderRepository(client);
+
+      const reminder = await reminderRepository.getReminder(
+        mockFolderId,
+        mockUserId,
+      );
+
+      expect(reminder).toBeNull();
+      expect(consoleErrorSpy).toBeCalledWith({
+        message: `Error getting reminder`,
+        userId: mockUserId,
+        folderId: mockFolderId,
+        error: new Error("error"),
+      });
+    });
+  });
+
+  describe("upsertReminder", () => {
+    const mockDueDate = new Date();
+
+    it("should upsert a reminder", async () => {
+      const client = {
+        $executeRawUnsafe: vi.fn().mockResolvedValue([]),
+      } as unknown as PrismaClient;
+
+      const reminderRepository = new PrismaReminderRepository(client);
+
+      const result = await reminderRepository.upsertReminder({
+        userId: mockUserId,
+        folderId: mockFolderId,
+        schedule: mockSchedule,
+        dueDate: mockDueDate,
+      });
+
+      expect(result).toBe(true);
+    });
+
+    it("should handle errors", async () => {
+      const consoleErrorSpy = vi.spyOn(console, "error");
+
+      const client = {
+        $executeRawUnsafe: vi.fn().mockRejectedValue(new Error("error")),
+      } as unknown as PrismaClient;
+
+      const reminderRepository = new PrismaReminderRepository(client);
+
+      const result = await reminderRepository.upsertReminder({
+        userId: mockUserId,
+        folderId: mockFolderId,
+        schedule: mockSchedule,
+        dueDate: mockDueDate,
+      });
+
+      expect(result).toBeNull();
+      expect(consoleErrorSpy).toBeCalledWith({
+        message: `Error upserting reminder`,
+        userId: mockUserId,
+        folderId: mockFolderId,
+        schedule: mockSchedule,
+        dueDate: mockDueDate,
+        error: new Error("error"),
+      });
+    });
+  });
+
+  describe("updateReminderDueDate", () => {
+    const mockDueDate = new Date();
+
+    it("should update a reminder due date", async () => {
+      const client = {
+        $executeRawUnsafe: vi.fn().mockResolvedValue([]),
+      } as unknown as PrismaClient;
+
+      const reminderRepository = new PrismaReminderRepository(client);
+
+      const result = await reminderRepository.updateReminderDueDate(
+        mockReminderId,
+        mockDueDate,
+      );
+
+      expect(result).toBe(true);
+    });
+
+    it("should handle errors", async () => {
+      const consoleErrorSpy = vi.spyOn(console, "error");
+
+      const client = {
+        $executeRawUnsafe: vi.fn().mockRejectedValue(new Error("error")),
+      } as unknown as PrismaClient;
+
+      const reminderRepository = new PrismaReminderRepository(client);
+
+      const result = await reminderRepository.updateReminderDueDate(
+        mockReminderId,
+        mockDueDate,
+      );
+
+      expect(result).toBeNull();
+      expect(consoleErrorSpy).toBeCalledWith({
+        message: `Error updating reminder due date`,
+        reminderId: mockReminderId,
+        dueDate: mockDueDate,
+        error: new Error("error"),
+      });
+    });
+  });
+
+  describe("markReminderAsCompleted", () => {
+    it("should mark a reminder as completed", async () => {
+      const client = {
+        reminder: {
+          update: vi.fn().mockResolvedValue([]),
+        },
+      } as unknown as PrismaClient;
+
+      const reminderRepository = new PrismaReminderRepository(client);
+
+      const result = await reminderRepository.markReminderAsCompleted(
+        mockReminderId,
+      );
+
+      expect(result).toBe(true);
+    });
+
+    it("should handle errors", async () => {
+      const consoleErrorSpy = vi.spyOn(console, "error");
+
+      const client = {
+        reminder: {
+          update: vi.fn().mockRejectedValue(new Error("error")),
+        },
+      } as unknown as PrismaClient;
+
+      const reminderRepository = new PrismaReminderRepository(client);
+
+      const result = await reminderRepository.markReminderAsCompleted(
+        mockReminderId,
+      );
+
+      expect(result).toBeNull();
+      expect(consoleErrorSpy).toBeCalledWith({
+        message: `Error marking reminder as completed`,
+        reminderId: mockReminderId,
+        error: new Error("error"),
+      });
+    });
+  });
+
+  describe("getReminders", () => {
+    it("should get reminders", async () => {
+      const mockReminders = [
+        {
+          id: mockReminderId,
+          dueDate: new Date(),
+          schedule: mockSchedule,
+          folderId: mockFolderId,
+          userId: mockUserId,
+          notificationsEnabled: 1,
+        },
+      ];
+      const client = {
+        $queryRawUnsafe: vi.fn().mockResolvedValue(mockReminders),
+      } as unknown as PrismaClient;
+
+      const reminderRepository = new PrismaReminderRepository(client);
+
+      const result = await reminderRepository.getReminders();
+
+      expect(result).toEqual(mockReminders);
+    });
+
+    it("should handle errors", async () => {
+      const consoleErrorSpy = vi.spyOn(console, "error");
+
+      const client = {
+        $queryRawUnsafe: vi.fn().mockImplementation(() => {
+          throw new Error("error");
+        }),
+      } as unknown as PrismaClient;
+
+      const reminderRepository = new PrismaReminderRepository(client);
+
+      const result = await reminderRepository.getReminders();
+
+      expect(result).toBeNull();
+      expect(consoleErrorSpy).toBeCalledWith({
+        message: `Error getting due reminders`,
+        error: new Error("error"),
+      });
+    });
+  });
+});

src/repositories/PrismaReminderRepository.ts

@@ -39,10 +39,12 @@ export class PrismaReminderRepository {
 
       return rawReminders[0] ?? null;
     } catch (error) {
-      console.error(
-        `Error getting notification preference for user ${userId} and folder ${folderId}`,
+      console.error({
+        message: "Error getting reminder",
+        userId,
+        folderId,
         error,
-      );
+      });
       return null;
     }
   }
@@ -71,18 +73,22 @@ export class PrismaReminderRepository {
 
       return true;
     } catch (error) {
-      console.error(
-        `Error upserting notification preference for user ${userId} and folder ${folderId}`,
+      console.error({
+        message: "Error upserting reminder",
+        userId,
+        folderId,
+        dueDate,
+        schedule,
         error,
-      );
+      });
       return null;
     }
   }
 
   async updateReminderDueDate(
     id: number,
     dueDate: Date,
-  ): Promise<DatabaseReminder | null> {
+  ): Promise<boolean | null> {
     try {
       const formattedDate = this.getFormattedDate(dueDate);
 
@@ -94,9 +100,14 @@ export class PrismaReminderRepository {
 
       await this.client.$executeRawUnsafe(sql);
 
-      return null;
+      return true;
     } catch (error) {
-      console.error("Error updating reminder due date", error);
+      console.error({
+        message: "Error updating reminder due date",
+        reminderId: id,
+        dueDate,
+        error,
+      });
       return null;
     }
   }
@@ -110,7 +121,11 @@ export class PrismaReminderRepository {
 
       return true;
     } catch (error) {
-      console.error("Error marking reminder as completed", error);
+      console.error({
+        message: "Error marking reminder as completed",
+        reminderId: id,
+        error,
+      });
       return null;
     }
   }
@@ -139,7 +154,7 @@ export class PrismaReminderRepository {
 
       return this.client.$queryRawUnsafe(sql);
     } catch (error) {
-      console.error("Error getting due reminders", error);
+      console.error({ message: "Error getting due reminders", error });
       return null;
     }
   }