@studious-lms/server 1.2.45 → 1.2.47

package/tests/class.test.ts

@@ -1,4 +1,4 @@
-import { test, expect, describe, beforeEach } from 'vitest';
+import { test, expect, describe, beforeEach, afterEach } from 'vitest';
 import { appRouter } from '../src/routers/_app';
 import { createTRPCContext } from '../src/trpc';
 import { prisma } from '../src/lib/prisma';
@@ -7,26 +7,33 @@ import { caller, user1Caller, user2Caller } from './setup';
 describe('Class Router', () => {
   let testClass: any;
   let testClass2: any;
+  const createdClassIds: string[] = [];
 
   beforeEach(async () => {
-    // Create test classes for each test
+    // Create test classes for each test with unique names to avoid conflicts
+    const timestamp = Date.now();
     testClass = await user1Caller.class.create({
-      name: 'Test Class 1',
+      name: `Test Class 1`,
       subject: 'Mathematics',
       section: '10th Grade',
     });
 
     testClass2 = await user2Caller.class.create({
-      name: 'Test Class 2',
+      name: `Test Class 2`,
       subject: 'Science',
       section: '11th Grade',
     });
+
+    // Track created classes for cleanup
+    if (testClass?.id) createdClassIds.push(testClass.id);
+    if (testClass2?.id) createdClassIds.push(testClass2.id);
   });
 
   describe('create', () => {
     test('should create a class successfully', async () => {
       expect(testClass).toBeDefined();
-      expect(testClass.name).toBe('Test Class 1');
+      expect(testClass.id).toBeDefined();
+      expect(testClass.name).toContain('Test Class 1');
       expect(testClass.subject).toBe('Mathematics');
       expect(testClass.section).toBe('10th Grade');
     });
@@ -52,10 +59,11 @@ describe('Class Router', () => {
     });
 
     test('should fail to create class with missing required fields', async () => {
+
+      // @ts-expect-error - test case
       await expect(user1Caller.class.create({
         name: '',
-        subject: 'Mathematics',
-        section: '10th Grade',
+        color: '#3B82F6',
       })).rejects.toThrow();
     });
   });
@@ -72,8 +80,9 @@ describe('Class Router', () => {
 
     test('should include user\'s own classes as teacher', async () => {
       const classes = await user1Caller.class.getAll();
-      const userClass = classes.teacherInClass.find((c: any) => c.name === 'Test Class 1');
+      const userClass = classes.teacherInClass.find((c: any) => c.id === testClass.id);
       expect(userClass).toBeDefined();
+      expect(userClass?.id).toBe(testClass.id);
     });
 
     test('should fail to get classes without authentication', async () => {
@@ -152,6 +161,12 @@ describe('Class Router', () => {
       expect(result).toBeDefined();
       expect(result.deletedClass).toBeDefined();
       expect(result.deletedClass.id).toBe(testClass.id);
+      
+      // Remove from cleanup list since it's already deleted
+      const index = createdClassIds.indexOf(testClass.id);
+      if (index > -1) {
+        createdClassIds.splice(index, 1);
+      }
     });
 
     test('should fail to delete class user is not teacher of', async () => {
@@ -212,10 +227,12 @@ describe('Class Router', () => {
     test('should remove member successfully', async () => {
       // First add a student
       const user2Profile = await user2Caller.user.getProfile();
-      await user1Caller.class.addStudent({
+      const addResult = await user1Caller.class.addStudent({
         classId: testClass.id,
         studentId: user2Profile.id,
       });
+      expect(addResult).toBeDefined();
+      expect(addResult.newStudent).toBeDefined();
       
       // Then remove them
       const result = await user1Caller.class.removeMember({
@@ -240,12 +257,20 @@ describe('Class Router', () => {
     test('should join class with class code successfully', async () => {
       // First create an invite code
       const inviteCode = await user1Caller.class.createInviteCode({ classId: testClass.id });
+      expect(inviteCode).toBeDefined();
+      expect(inviteCode.code).toBeDefined();
       
       // Then join with the code
       const result = await user2Caller.class.join({ classCode: inviteCode.code });
       expect(result).toBeDefined();
       expect(result.joinedClass).toBeDefined();
       expect(result.joinedClass.id).toBe(testClass.id);
+      
+      // Clean up: remove student from class
+      await user1Caller.class.removeMember({
+        classId: testClass.id,
+        userId: (await user2Caller.user.getProfile()).id,
+      });
     });
 
     test('should fail to join with invalid class code', async () => {

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();
+    });
+  });
+});
+