@studious-lms/server 1.2.45 → 1.2.46

package/tests/event.test.ts

@@ -0,0 +1,228 @@
+import { test, expect, describe, beforeEach } from 'vitest';
+import { user1Caller, user2Caller } from './setup';
+import { createTRPCContext } from '../src/trpc';
+import { appRouter } from '../src/routers/_app';
+import { prisma } from '../src/lib/prisma';
+import { startOfWeek } from 'date-fns';
+
+describe('Event Router', () => {
+  let testClass: any;
+  let testEvent: any;
+
+  beforeEach(async () => {
+    // Create a test class for user1
+    testClass = await user1Caller.class.create({
+      name: 'Test Class for Events',
+      subject: 'Mathematics',
+      section: '10th Grade',
+    });
+
+    // Create a test event
+    const startTime = new Date();
+    startTime.setHours(10, 0, 0, 0);
+    const endTime = new Date(startTime);
+    endTime.setHours(11, 0, 0, 0);
+
+    testEvent = await user1Caller.event.create({
+      name: 'Test Event',
+      location: 'Room 101',
+      remarks: 'Test remarks',
+      startTime: startTime.toISOString(),
+      endTime: endTime.toISOString(),
+      classId: testClass.id,
+      color: '#3B82F6',
+    });
+  });
+
+  describe('create', () => {
+    test('should create event successfully', async () => {
+      expect(testEvent).toBeDefined();
+      expect(testEvent.event).toBeDefined();
+      expect(testEvent.event.name).toBe('Test Event');
+      expect(testEvent.event.location).toBe('Room 101');
+      expect(testEvent.event.remarks).toBe('Test remarks');
+      expect(testEvent.event.classId).toBe(testClass.id);
+      expect(testEvent.event.color).toBe('#3B82F6');
+    });
+
+    test('should create event without class', async () => {
+      const startTime = new Date();
+      startTime.setHours(14, 0, 0, 0);
+      const endTime = new Date(startTime);
+      endTime.setHours(15, 0, 0, 0);
+
+      const event = await user1Caller.event.create({
+        name: 'Personal Event',
+        location: 'Home',
+        startTime: startTime.toISOString(),
+        endTime: endTime.toISOString(),
+      });
+
+      expect(event.event).toBeDefined();
+      expect(event.event.name).toBe('Personal Event');
+      expect(event.event.classId).toBeNull();
+    });
+
+    test('should fail to create event for class user is not teacher of', async () => {
+      const startTime = new Date();
+      startTime.setHours(10, 0, 0, 0);
+      const endTime = new Date(startTime);
+      endTime.setHours(11, 0, 0, 0);
+
+      await expect(user2Caller.event.create({
+        name: 'Unauthorized Event',
+        startTime: startTime.toISOString(),
+        endTime: endTime.toISOString(),
+        classId: testClass.id,
+      })).rejects.toThrow();
+    });
+
+    test('should fail without authentication', async () => {
+      const invalidCaller = await createTRPCContext({
+        req: { headers: {} } as any,
+        res: {} as any,
+      });
+      const router = appRouter.createCaller(invalidCaller);
+
+      const startTime = new Date();
+      await expect(router.event.create({
+        name: 'Test',
+        startTime: startTime.toISOString(),
+        endTime: startTime.toISOString(),
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('get', () => {
+    test('should get event successfully', async () => {
+      const event = await user1Caller.event.get({
+        id: testEvent.event.id,
+      });
+
+      expect(event).toBeDefined();
+      expect(event.event.id).toBe(testEvent.event.id);
+      expect(event.event.name).toBe('Test Event');
+      expect(event.event.class).toBeDefined();
+    });
+
+    test('should fail to get event user does not own', async () => {
+      await expect(user2Caller.event.get({
+        id: testEvent.event.id,
+      })).rejects.toThrow();
+    });
+
+    test('should fail to get non-existent event', async () => {
+      await expect(user1Caller.event.get({
+        id: 'non-existent-id',
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('update', () => {
+    test('should update event successfully', async () => {
+      const startTime = new Date();
+      startTime.setHours(12, 0, 0, 0);
+      const endTime = new Date(startTime);
+      endTime.setHours(13, 0, 0, 0);
+
+      const updated = await user1Caller.event.update({
+        id: testEvent.event.id,
+        data: {
+          name: 'Updated Event Name',
+          location: 'Room 202',
+          remarks: 'Updated remarks',
+          startTime: startTime.toISOString(),
+          endTime: endTime.toISOString(),
+          color: '#10B981',
+        },
+      });
+
+      expect(updated.event.name).toBe('Updated Event Name');
+      expect(updated.event.location).toBe('Room 202');
+      expect(updated.event.remarks).toBe('Updated remarks');
+      expect(updated.event.color).toBe('#10B981');
+    });
+
+    // @todo: not implemented partial updates
+    // test('should update event with partial data', async () => {
+    //   const updated = await user1Caller.event.update({
+    //     id: testEvent.event.id,
+    //     data: {
+    //       name: 'Partially Updated Event',
+    //     },
+    //   });
+
+    //   expect(updated.event.name).toBe('Partially Updated Event');
+    //   expect(updated.event.location).toBe('Room 101'); // Should remain unchanged
+    // });
+
+    test('should fail to update event user does not own', async () => {
+      await expect(user2Caller.event.update({
+        id: testEvent.event.id,
+        data: {
+          name: 'Unauthorized Update',
+          location: 'Room 101',
+          remarks: 'Updated remarks',
+          startTime: testEvent.event.startTime,
+          endTime: testEvent.event.endTime,
+          color: '#10B981',
+        },
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('delete', () => {
+    test('should delete event successfully', async () => {
+      const result = await user1Caller.event.delete({
+        id: testEvent.event.id,
+      });
+
+      expect(result.success).toBe(true);
+
+      // Verify event is deleted
+      await expect(user1Caller.event.get({
+        id: testEvent.event.id,
+      })).rejects.toThrow();
+    });
+
+    test('should fail to delete event user does not own', async () => {
+      await expect(user2Caller.event.delete({
+        id: testEvent.event.id,
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('getAll', () => {
+    test('should get all events for user', async () => {
+      // Create another event
+      const startTime = new Date();
+      startTime.setHours(15, 0, 0, 0);
+      const endTime = new Date(startTime);
+      endTime.setHours(16, 0, 0, 0);
+
+      const secondEvent = await user1Caller.event.create({
+        name: 'Second Event',
+        startTime: startTime.toISOString(),
+        endTime: endTime.toISOString(),
+      });
+
+      const events = await user1Caller.agenda.get({
+        weekStart: startOfWeek(startTime).toISOString(),
+      });
+
+      expect(events.events).toBeDefined();
+      expect(events.events.personal.length).toBeGreaterThanOrEqual(2);
+      expect(events.events.personal.some((e) => e.id === secondEvent.event.id)).toBe(true);
+    });
+
+    test('should return empty array for user with no events', async () => {
+      const events = await user2Caller.agenda.get({
+        weekStart: new Date().toISOString(),
+      });
+      expect(events.events.personal).toBeDefined();
+      expect(Array.isArray(events.events.personal)).toBe(true);
+      expect(events.events.personal.length).toBe(0);
+    });
+  });
+});
+

package/tests/section.test.ts

@@ -0,0 +1,216 @@
+import { test, expect, describe, beforeEach } from 'vitest';
+import { user1Caller, user2Caller } from './setup';
+import { createTRPCContext } from '../src/trpc';
+import { appRouter } from '../src/routers/_app';
+
+describe('Section Router', () => {
+  let testClass: any;
+  let testSection: any;
+
+  beforeEach(async () => {
+    // Create a test class
+    testClass = await user1Caller.class.create({
+      name: 'Test Class for Sections',
+      subject: 'Mathematics',
+      section: '10th Grade',
+    });
+
+    // Create a test section
+    testSection = await user1Caller.section.create({
+      classId: testClass.id,
+      name: 'Test Section',
+      color: '#3B82F6',
+    });
+  });
+
+  describe('create', () => {
+    test('should create section successfully', async () => {
+      expect(testSection).toBeDefined();
+      expect(testSection.id).toBeDefined();
+      expect(testSection.name).toBe('Test Section');
+      expect(testSection.color).toBe('#3B82F6');
+      expect(testSection.classId).toBe(testClass.id);
+    });
+
+    test('should create section without color', async () => {
+      const section = await user1Caller.section.create({
+        classId: testClass.id,
+        name: 'Section Without Color',
+      });
+
+      expect(section).toBeDefined();
+      expect(section.name).toBe('Section Without Color');
+    });
+
+    test('should fail to create section for class user is not teacher of', async () => {
+      await expect(user2Caller.section.create({
+        classId: testClass.id,
+        name: 'Unauthorized Section',
+      })).rejects.toThrow();
+    });
+
+    test('should fail without authentication', async () => {
+      const invalidCaller = await createTRPCContext({
+        req: { headers: {} } as any,
+        res: {} as any,
+      });
+      const router = appRouter.createCaller(invalidCaller);
+
+      await expect(router.section.create({
+        classId: testClass.id,
+        name: 'Test Section',
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('update', () => {
+    test('should update section successfully', async () => {
+      const updated = await user1Caller.section.update({
+        id: testSection.id,
+        classId: testClass.id,
+        name: 'Updated Section Name',
+        color: '#10B981',
+      });
+
+      expect(updated.name).toBe('Updated Section Name');
+      expect(updated.color).toBe('#10B981');
+    });
+
+    test('should update section with partial data', async () => {
+      const updated = await user1Caller.section.update({
+        id: testSection.id,
+        classId: testClass.id,
+        name: 'Partially Updated Section',
+      });
+
+      expect(updated.name).toBe('Partially Updated Section');
+      expect(updated.color).toBe('#3B82F6'); // Should remain unchanged
+    });
+
+    test('should fail to update section user is not teacher of', async () => {
+      await expect(user2Caller.section.update({
+        id: testSection.id,
+        classId: testClass.id,
+        name: 'Unauthorized Update',
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('delete', () => {
+    test('should delete section successfully', async () => {
+      // Create a new section to delete
+      const newSection = await user1Caller.section.create({
+        classId: testClass.id,
+        name: 'To Be Deleted',
+      });
+
+      const result = await user1Caller.section.delete({
+        id: newSection.id,
+        classId: testClass.id,
+      });
+
+      expect(result.id).toBe(newSection.id);
+
+      // Verify section is deleted by trying to update it
+      await expect(user1Caller.section.update({
+        id: newSection.id,
+        classId: testClass.id,
+        name: 'Test',
+      })).rejects.toThrow();
+    });
+
+    test('should fail to delete section user is not teacher of', async () => {
+      await expect(user2Caller.section.delete({
+        id: testSection.id,
+        classId: testClass.id,
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('reorder', () => {
+    test('should reorder section to start', async () => {
+      // Create another section
+      const section2 = await user1Caller.section.create({
+        classId: testClass.id,
+        name: 'Second Section',
+      });
+
+      const originalOrder = section2.order;
+      const result = await user1Caller.section.reorder({
+        classId: testClass.id,
+        movedId: section2.id,
+        position: 'start',
+      });
+
+      expect(result).toBeDefined();
+      expect(result?.order).toBeDefined();
+      // When moved to start, order should be less than original
+      expect(result?.order).toBeLessThanOrEqual(originalOrder || Infinity);
+    });
+
+    test('should reorder section to end', async () => {
+      const section2 = await user1Caller.section.create({
+        classId: testClass.id,
+        name: 'Third Section',
+      });
+
+      const originalOrder = section2.order;
+      const result = await user1Caller.section.reorder({
+        classId: testClass.id,
+        movedId: section2.id,
+        position: 'end',
+      });
+
+      expect(result).toBeDefined();
+      expect(result?.order).toBeDefined();
+      // When moved to end, order should be greater than or equal to original
+      expect(result?.order).toBeGreaterThanOrEqual(originalOrder || 0);
+    });
+
+    test('should reorder section before another', async () => {
+      const section2 = await user1Caller.section.create({
+        classId: testClass.id,
+        name: 'Fourth Section',
+      });
+
+      const targetOrder = testSection.order;
+      const result = await user1Caller.section.reorder({
+        classId: testClass.id,
+        movedId: section2.id,
+        position: 'before',
+        targetId: testSection.id,
+      });
+
+      expect(result).toBeDefined();
+      expect(result?.order).toBeDefined();
+      // When moved before target, order should be less than target's order
+      expect(result?.order).toBeLessThan(targetOrder || Infinity);
+    });
+
+    test('should fail to reorder section user is not teacher of', async () => {
+      // Create a separate class that user2 is not part of
+      const otherClass = await user1Caller.class.create({
+        name: 'Other Class for Reorder Test',
+        subject: 'Science',
+        section: '11th Grade',
+      });
+
+      const otherSection = await user1Caller.section.create({
+        classId: otherClass.id,
+        name: 'Other Section',
+      });
+
+      // user2 is not a member of otherClass, so they shouldn't be able to reorder
+      // Note: The reorder endpoint uses protectedProcedure, not protectedTeacherProcedure
+      // It only checks if the section exists, not teacher permissions
+      // So if user2 can see the section (e.g., if they're a student), reorder will succeed
+      // This test verifies that non-class members can't reorder
+      await expect(user2Caller.section.reorder({
+        classId: otherClass.id,
+        movedId: otherSection.id,
+        position: 'start',
+      })).rejects.toThrow();
+    });
+  });
+});
+

package/tests/setup.ts

@@ -1,4 +1,6 @@
 import { execSync } from 'child_process';
+import { config } from 'dotenv';
+import { resolve } from 'path';
 import { prisma } from '../src/lib/prisma';
 import { beforeAll, beforeEach, afterAll, afterEach } from 'vitest';
 import { logger } from '../src/utils/logger';
@@ -7,26 +9,31 @@ import { createTRPCContext } from '../src/trpc';
 import { Session } from '@prisma/client';
 import { clearDatabase } from '../src/seedDatabase';
 
+// Load test environment variables
+config({ path: resolve(process.cwd(), '.env.test') });
+
 const getCaller = async (token: string) => {
   const ctx = await createTRPCContext({
     req: { headers: {
-      authorization: `Bearer ${token}`,
-      'x-user': token,
+      authorization: token ? `Bearer ${token}` : undefined,
+      'x-user': token || undefined,
     } } as any,
     res: {} as any,
   });
   return appRouter.createCaller(ctx);
 };
 
-  // Before the entire test suite runs
-  beforeAll(async () => {
-
+// Before the entire test suite runs
+beforeAll(async () => {
+  try {
+    logger.info('DATABASE_URL: ' + process.env.DATABASE_URL);
     await clearDatabase();
+    logger.info('Database cleared for tests');
 
-    logger.info('Getting caller');
-
+    // Create public caller (no auth) for registration
     caller = await getCaller('');
 
+    // Register users
     const user1 = await caller.auth.register({
       username: 'testuser1',
       email: 'test@test.com',
@@ -41,18 +48,37 @@ const getCaller = async (token: string) => {
       confirmPassword: 'password_is_1234',
     });
 
+    const user3 = await caller.auth.register({
+      username: 'testuser3',
+      email: 'test3@test.com',
+      password: 'password_is_1234',
+      confirmPassword: 'password_is_1234',
+    });
+
+    // Get sessions created during registration
     session1 = await prisma.session.findFirst({
       where: {
         userId: user1.user.id,
       },
     }) as Session;
 
-    session2 = (await prisma.session.findFirst({
+    session2 = await prisma.session.findFirst({
       where: {
         userId: user2.user.id,
       },
-    })) as Session;
+    }) as Session;
+
+    session3 = await prisma.session.findFirst({ 
+      where: {
+        userId: user3.user.id,
+      },
+    }) as Session;
 
+    if (!session1 || !session2 || !session3) {
+      throw new Error('Failed to create sessions for test users');
+    }
+
+    // Verify emails using session tokens
     verification1 = await caller.auth.verify({
       token: session1.id,
     });
@@ -61,6 +87,11 @@ const getCaller = async (token: string) => {
       token: session2.id,
     });
 
+    verification3 = await caller.auth.verify({
+      token: session3.id,
+    });
+
+    // Login to get fresh tokens
     login1 = await caller.auth.login({
       username: 'testuser1',
       password: 'password_is_1234',
@@ -71,22 +102,45 @@ const getCaller = async (token: string) => {
       password: 'password_is_1234',
     });
 
-    user1Caller = await getCaller(login1.token);
-    user2Caller = await getCaller(login2.token);
-  });
+    login3 = await caller.auth.login({
+      username: 'testuser3',
+      password: 'password_is_1234',
+    });
 
+    if (!login1.token || !login2.token || !login3.token) {
+      throw new Error('Failed to get login tokens');
+    }
 
-  // After all tests, close the DB
-  afterAll(async () => {
+    // Create authenticated callers
+    user1Caller = await getCaller(login1.token);
+    user2Caller = await getCaller(login2.token);
+    user3Caller = await getCaller(login3.token);
+    logger.info('Test setup completed successfully');
+  } catch (error) {
+    logger.error('Test setup failed', { error });
+    throw error;
+  }
+});
+
+// After all tests, close the DB
+afterAll(async () => {
+  try {
     await prisma.$disconnect();
-  });
+  } catch (error) {
+    logger.error('Error disconnecting from database', { error });
+  }
+});
 
 export let user1Caller: ReturnType<typeof appRouter.createCaller>;
 export let user2Caller: ReturnType<typeof appRouter.createCaller>;
+export let user3Caller: ReturnType<typeof appRouter.createCaller>;
 export let caller: ReturnType<typeof appRouter.createCaller>;
 export let session1: Session;
 export let session2: Session;
+export let session3: Session;
 export let verification1: any;
 export let verification2: any;
+export let verification3: any;
 export let login1: any;
-export let login2: any;
+export let login2: any;
+export let login3: any;