@studious-lms/server 1.2.45 → 1.2.47

package/src/utils/logger.ts

@@ -1,3 +1,4 @@
+
 export enum LogLevel {
   INFO = 'info',
   WARN = 'warn',
@@ -59,7 +60,7 @@ class Logger {
     // this.isDevelopment = process.env.NODE_ENV === 'development';
     this.isDevelopment = true;
 
-    this.mode = (process.env.LOG_MODE as LogMode) || 'normal';
+    this.mode = (process.env.NODE_ENV === 'test' ? 'silent' : ((process.env.LOG_MODE as LogMode) || 'normal'));
     
 
     this.levelColors = {

package/tests/announcement.test.ts

@@ -0,0 +1,164 @@
+import { test, expect, describe, beforeEach } from 'vitest';
+import { user1Caller, user2Caller } from './setup';
+import { createTRPCContext } from '../src/trpc';
+import { appRouter } from '../src/routers/_app';
+
+describe('Announcement Router', () => {
+  let testClass: any;
+  let testAnnouncement: any;
+
+  beforeEach(async () => {
+    // Create a test class
+    testClass = await user1Caller.class.create({
+      name: 'Test Class for Announcements',
+      subject: 'Mathematics',
+      section: '10th Grade',
+    });
+
+    // Create a test announcement
+    testAnnouncement = await user1Caller.announcement.create({
+      classId: testClass.id,
+      remarks: 'This is a test announcement',
+    });
+  });
+
+  describe('create', () => {
+    test('should create announcement successfully', async () => {
+      expect(testAnnouncement).toBeDefined();
+      expect(testAnnouncement.announcement).toBeDefined();
+      expect(testAnnouncement.announcement.remarks).toBe('This is a test announcement');
+      expect(testAnnouncement.announcement.teacher.id).toBeDefined();
+    });
+
+    test('should create announcement with attachments', async () => {
+      const announcement = await user1Caller.announcement.create({
+        classId: testClass.id,
+        remarks: 'Announcement with attachments',
+        files: [
+          {
+            name: 'test.pdf',
+            type: 'application/pdf',
+            size: 1024,
+          },
+        ],
+      });
+
+      expect(announcement.announcement).toBeDefined();
+      expect(announcement.announcement.attachments).toBeDefined();
+    });
+
+    test('should fail to create announcement for class user is not teacher of', async () => {
+      await expect(user2Caller.announcement.create({
+        classId: testClass.id,
+        remarks: 'Unauthorized announcement',
+      })).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.announcement.create({
+        classId: testClass.id,
+        remarks: 'Test',
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('getAll', () => {
+    test('should get all announcements for class', async () => {
+      const result = await user1Caller.announcement.getAll({
+        classId: testClass.id,
+      });
+
+      expect(result.announcements).toBeDefined();
+      expect(Array.isArray(result.announcements)).toBe(true);
+      expect(result.announcements.length).toBeGreaterThanOrEqual(1);
+      expect(result.announcements.some((a: any) => a.id === testAnnouncement.announcement.id)).toBe(true);
+    });
+
+    test('should fail to get announcements for class user is not member of', async () => {
+      await expect(user2Caller.announcement.getAll({
+        classId: testClass.id,
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('get', () => {
+    test('should get single announcement successfully', async () => {
+      const announcement = await user1Caller.announcement.get({
+        id: testAnnouncement.announcement.id,
+        classId: testClass.id,
+      });
+
+      expect(announcement.announcement).toBeDefined();
+      expect(announcement.announcement.id).toBe(testAnnouncement.announcement.id);
+      expect(announcement.announcement.remarks).toBe('This is a test announcement');
+    });
+
+    test('should fail to get announcement for class user is not member of', async () => {
+      await expect(user2Caller.announcement.get({
+        id: testAnnouncement.announcement.id,
+        classId: testClass.id,
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('update', () => {
+    test('should update announcement successfully', async () => {
+      const updated = await user1Caller.announcement.update({
+        id: testAnnouncement.announcement.id,
+        classId: testClass.id,
+        data: {
+          remarks: 'Updated announcement remarks',
+        },
+      });
+
+      expect(updated.announcement.remarks).toBe('Updated announcement remarks');
+    });
+
+    test('should fail to update announcement user is not teacher of', async () => {
+      await expect(user2Caller.announcement.update({
+        id: testAnnouncement.announcement.id,
+        classId: testClass.id,
+        data: {
+          remarks: 'Unauthorized update',
+        },
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('delete', () => {
+    test('should delete announcement successfully', async () => {
+      // Create a new announcement to delete
+      const newAnnouncement = await user1Caller.announcement.create({
+        classId: testClass.id,
+        remarks: 'To be deleted',
+      });
+
+      const result = await user1Caller.announcement.delete({
+        id: newAnnouncement.announcement.id,
+        classId: testClass.id,
+      });
+
+      expect(result.success).toBe(true);
+
+      // Verify announcement is deleted
+      await expect(user1Caller.announcement.get({
+        id: newAnnouncement.announcement.id,
+        classId: testClass.id,
+      })).rejects.toThrow();
+    });
+
+    test('should fail to delete announcement user is not teacher of', async () => {
+      await expect(user2Caller.announcement.delete({
+        id: testAnnouncement.announcement.id,
+        classId: testClass.id,
+      })).rejects.toThrow();
+    });
+  });
+});
+

package/tests/assignment.test.ts

@@ -0,0 +1,296 @@
+import { test, expect, describe, beforeEach } from 'vitest';
+import { user1Caller, user2Caller } from './setup';
+import { createTRPCContext } from '../src/trpc';
+import { appRouter } from '../src/routers/_app';
+
+describe('Assignment Router', () => {
+  let testClass: any;
+  let testAssignment: any;
+  let studentId: string;
+
+  beforeEach(async () => {
+    // Create a test class
+    testClass = await user1Caller.class.create({
+      name: 'Test Class for Assignments',
+      subject: 'Mathematics',
+      section: '10th Grade',
+    });
+
+    // Add user2 as a student
+    const studentProfile = await user2Caller.user.getProfile();
+    studentId = studentProfile.id;
+    await user1Caller.class.addStudent({
+      classId: testClass.id,
+      studentId: studentId,
+    });
+
+    // Create a test assignment
+    const dueDate = new Date();
+    dueDate.setDate(dueDate.getDate() + 7); // Due in 7 days
+
+    testAssignment = await user1Caller.assignment.create({
+      classId: testClass.id,
+      title: 'Test Assignment',
+      instructions: 'Complete this test assignment',
+      dueDate: dueDate.toISOString(),
+      maxGrade: 100,
+      type: 'HOMEWORK',
+    });
+  });
+
+  describe('create', () => {
+    test('should create assignment successfully', async () => {
+      expect(testAssignment).toBeDefined();
+      expect(testAssignment).toBeDefined();
+      expect(testAssignment.title).toBe('Test Assignment');
+      expect(testAssignment.instructions).toBe('Complete this test assignment');
+      expect(testAssignment.maxGrade).toBe(100);
+      expect(testAssignment.type).toBe('HOMEWORK');
+    });
+
+    test('should create assignment with different types', async () => {
+      const dueDate = new Date();
+      dueDate.setDate(dueDate.getDate() + 7);
+
+      const quiz = await user1Caller.assignment.create({
+        classId: testClass.id,
+        title: 'Test Quiz',
+        instructions: 'Complete this quiz',
+        dueDate: dueDate.toISOString(),
+        type: 'QUIZ',
+        maxGrade: 50,
+      });
+
+      expect(quiz.type).toBe('QUIZ');
+      expect(quiz.maxGrade).toBe(50);
+    });
+
+    test('should create assignment with files', async () => {
+      const dueDate = new Date();
+      dueDate.setDate(dueDate.getDate() + 7);
+
+      const assignment = await user1Caller.assignment.create({
+        classId: testClass.id,
+        title: 'Assignment with Files',
+        instructions: 'Submit with files',
+        dueDate: dueDate.toISOString(),
+        acceptFiles: true,
+        files: [
+          {
+            name: 'test.pdf',
+            type: 'application/pdf',
+            size: 1024,
+          },
+        ],
+      });
+
+      expect(assignment).toBeDefined();
+    });
+
+    test('should fail to create assignment for class user is not teacher of', async () => {
+      const dueDate = new Date();
+      dueDate.setDate(dueDate.getDate() + 7);
+
+      await expect(user2Caller.assignment.create({
+        classId: testClass.id,
+        title: 'Unauthorized Assignment',
+        instructions: 'Test',
+        dueDate: dueDate.toISOString(),
+      })).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 dueDate = new Date();
+      await expect(router.assignment.create({
+        classId: testClass.id,
+        title: 'Test',
+        instructions: 'Test',
+        dueDate: dueDate.toISOString(),
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('get', () => {
+    test('should get assignment successfully', async () => {
+      const assignment = await user1Caller.assignment.get({
+        id: testAssignment.id,
+        classId: testClass.id,
+      });
+
+      expect(assignment).toBeDefined();
+      expect(assignment.id).toBe(testAssignment.id);
+      expect(assignment.title).toBe('Test Assignment');
+    });
+
+    test('should allow students to get assignment', async () => {
+      const assignment = await user2Caller.assignment.get({
+        id: testAssignment.id,
+        classId: testClass.id,
+      });
+
+      expect(assignment).toBeDefined();
+    });
+
+    test('should fail to get assignment for non-class members', async () => {
+      const newClass = await user1Caller.class.create({
+        name: 'Other Class',
+        subject: 'Science',
+        section: '11th Grade',
+      });
+
+      await expect(user2Caller.assignment.get({
+        id: testAssignment.id,
+        classId: newClass.id,
+      })).rejects.toThrow();
+    });
+  });
+
+  // describe('getAll', () => {
+  //   test('should get all assignments for class', async () => {
+  //     const result = await user1Caller.assignment.get({
+  //       classId: testClass.id,
+  //     });
+
+  //     expect(result).toBeDefined();
+  //     expect(Array.isArray(result)).toBe(true);
+  //     expect(result.length).toBeGreaterThanOrEqual(1);
+  //     expect(result.some((a: any) => a.id === testAssignment.id)).toBe(true);
+  //   });
+
+  //   test('should allow students to get all assignments', async () => {
+  //     const result = await user2Caller.assignment.({
+  //       classId: testClass.id,
+  //     });
+
+  //     expect(result.assignments).toBeDefined();
+  //   });
+  // });
+
+  describe('update', () => {
+    test('should update assignment successfully', async () => {
+      const updated = await user1Caller.assignment.update({
+        classId: testClass.id,
+        id: testAssignment.id,
+        title: 'Updated Assignment Title',
+        instructions: 'Updated instructions',
+      });
+
+      expect(updated.title).toBe('Updated Assignment Title');
+      expect(updated.instructions).toBe('Updated instructions');
+    });
+
+    test('should update assignment with partial data', async () => {
+      const updated = await user1Caller.assignment.update({
+        classId: testClass.id,
+        id: testAssignment.id,
+        title: 'Partially Updated Title',
+      });
+
+      expect(updated.title).toBe('Partially Updated Title');
+      expect(updated.instructions).toBe('Complete this test assignment'); // Should remain unchanged
+    });
+
+    test('should fail to update assignment user is not teacher of', async () => {
+      await expect(user2Caller.assignment.update({
+        classId: testClass.id,
+        id: testAssignment.id,
+        title: 'Unauthorized Update',
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('delete', () => {
+    test('should delete assignment successfully', async () => {
+      // Create a new assignment to delete
+      const dueDate = new Date();
+      dueDate.setDate(dueDate.getDate() + 7);
+
+      const newAssignment = await user1Caller.assignment.create({
+        classId: testClass.id,
+        title: 'To Be Deleted',
+        instructions: 'This will be deleted',
+        dueDate: dueDate.toISOString(),
+      });
+
+      const result = await user1Caller.assignment.delete({
+        id: newAssignment.id,
+        classId: testClass.id,
+      });
+
+      expect(result.id).toBe(newAssignment.id);
+
+      // Verify assignment is deleted
+      await expect(user1Caller.assignment.get({
+        id: newAssignment.id,
+        classId: testClass.id,
+      })).rejects.toThrow();
+    });
+
+    test('should fail to delete assignment user is not teacher of', async () => {
+      await expect(user2Caller.assignment.delete({
+        id: testAssignment.id,
+        classId: testClass.id,
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('submit', () => {
+    test('should automatically create submission successfully', async () => {
+      // First create a submission
+      const submission = await user2Caller.assignment.getSubmission({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+      });
+
+      expect(submission).toBeDefined();
+    });
+
+    test('should submit assignment with extended response', async () => {
+
+      const submission = await user2Caller.assignment.getSubmission({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+      });
+
+      const updatedSubmission = await user2Caller.assignment.updateSubmission({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+        submissionId: submission.id,
+        extendedResponse: 'This is my answer to the assignment',
+      });
+
+      expect(updatedSubmission.extendedResponse).toBe('This is my answer to the assignment');
+    });
+
+    test('should fail to submit assignment for non-class members', async () => {
+      const newClass = await user1Caller.class.create({
+        name: 'Other Class',
+        subject: 'Science',
+        section: '11th Grade',
+      });
+
+      const dueDate = new Date();
+      dueDate.setDate(dueDate.getDate() + 7);
+
+      const newAssignment = await user1Caller.assignment.create({
+        classId: newClass.id,
+        title: 'Other Assignment',
+        instructions: 'Test',
+        dueDate: dueDate.toISOString(),
+      });
+
+      await expect(user2Caller.assignment.getSubmission({
+        assignmentId: newAssignment.id,
+        classId: newClass.id,
+        submit: true,
+      })).rejects.toThrow();
+    });
+  });
+});
+

package/tests/attendance.test.ts

@@ -0,0 +1,168 @@
+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';
+
+describe('Attendance Router', () => {
+  let testClass: any;
+  let testEvent: any;
+  let student1: any;
+  let student2: any;
+
+  beforeEach(async () => {
+    // Create a test class
+    testClass = await user1Caller.class.create({
+      name: 'Test Class for Attendance',
+      subject: 'Mathematics',
+      section: '10th Grade',
+    });
+
+    // Add user2 as a student to the class
+    await user1Caller.class.addStudent({
+      classId: testClass.id,
+      studentId: (await user2Caller.user.getProfile()).id,
+    });
+
+    // Get student users
+    student1 = await user1Caller.user.getProfile();
+    student2 = await user2Caller.user.getProfile();
+
+    // 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 for Attendance',
+      startTime: startTime.toISOString(),
+      endTime: endTime.toISOString(),
+      classId: testClass.id,
+    });
+  });
+
+  describe('get', () => {
+    test('should get attendance for class', async () => {
+      const attendance = await user1Caller.attendance.get({
+        classId: testClass.id,
+      });
+
+      expect(attendance).toBeDefined();
+    });
+
+    test('should get attendance for specific event', async () => {
+      const attendance = await user1Caller.attendance.get({
+        classId: testClass.id,
+        eventId: testEvent.event.id,
+      });
+
+      expect(attendance).toBeDefined();
+    });
+
+    test('should allow students to view attendance', async () => {
+      const attendance = await user2Caller.attendance.get({
+        classId: testClass.id,
+      });
+
+      expect(attendance).toBeDefined();
+    });
+
+    test('should fail for non-class members', async () => {
+      // Create a new user and class
+      const newClass = await user1Caller.class.create({
+        name: 'Other Class',
+        subject: 'Science',
+        section: '11th Grade',
+      });
+
+      await expect(user2Caller.attendance.get({
+        classId: newClass.id,
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('update', () => {
+    test('should update attendance successfully', async () => {
+      const result = await user1Caller.attendance.update({
+        classId: testClass.id,
+        eventId: testEvent.event.id,
+        attendance: {
+          present: [
+            { id: student1.id, username: student1.username },
+          ],
+          late: [
+            { id: student2.id, username: student2.username },
+          ],
+          absent: [],
+        },
+      });
+
+      expect(result).toBeDefined();
+      expect(result.id).toBeDefined();
+      expect(result.present).toBeDefined();
+      expect(result.late).toBeDefined();
+      expect(result.absent).toBeDefined();
+      expect(result.present.some((p: any) => p.id === student1.id)).toBe(true);
+      expect(result.late.some((l: any) => l.id === student2.id)).toBe(true);
+
+      // Verify attendance was updated
+      const attendance = await user1Caller.attendance.get({
+        classId: testClass.id,
+        eventId: testEvent.event.id,
+      });
+
+      const updatedRecord = attendance.find((a: any) => a.event?.id === testEvent.event.id);
+      expect(updatedRecord).toBeDefined();
+      expect(updatedRecord?.present.some((p: any) => p.id === student1.id)).toBe(true);
+      expect(updatedRecord?.late.some((l: any) => l.id === student2.id)).toBe(true);
+    });
+
+    test('should update attendance without event', async () => {
+      const result = await user1Caller.attendance.update({
+        classId: testClass.id,
+        attendance: {
+          present: [
+            { id: student1.id, username: student1.username },
+            { id: student2.id, username: student2.username },
+          ],
+          late: [],
+          absent: [],
+        },
+      });
+
+      expect(result).toBeDefined();
+      expect(result.id).toBeDefined();
+      expect(result.present.length).toBe(2);
+    });
+
+    test('should fail for non-teacher', async () => {
+      await expect(user2Caller.attendance.update({
+        classId: testClass.id,
+        attendance: {
+          present: [{ id: student1.id, username: student1.username }],
+          late: [],
+          absent: [],
+        },
+      })).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.attendance.update({
+        classId: testClass.id,
+        attendance: {
+          present: [],
+          late: [],
+          absent: [],
+        },
+      })).rejects.toThrow();
+    });
+  });
+});
+

package/tests/auth.test.ts

@@ -1,25 +1,48 @@
-import { test, expect } from 'vitest';
+import { test, expect, describe } from 'vitest';
 import { appRouter } from '../src/routers/_app';
 import { createTRPCContext } from '../src/trpc';
 import { prisma } from '../src/lib/prisma';
-import { caller, login1, login2, session1, session2, user1Caller, verification1, verification2 } from './setup';
+import { caller, login1, login2, login3, session1, session2, session3, user1Caller, user2Caller, user3Caller, verification1, verification2, verification3 } from './setup';
 
-test('registration', async () => {
+describe('Auth Router', () => {
+  test('registration creates sessions', async () => {
     expect(session1).toBeDefined();
+    expect(session1.id).toBeDefined();
     expect(session2).toBeDefined();
-});
+    expect(session2.id).toBeDefined();
+  });
 
-test('email verification', async () => {
+  test('email verification works', async () => {
     expect(verification1).toBeDefined();
     expect(verification2).toBeDefined();
-});
+  });
 
-test('login', async () => {
+  test('login returns valid tokens', async () => {
     expect(login1).toBeDefined();
+    expect(login1.token).toBeDefined();
+    expect(login1.user).toBeDefined();
     expect(login2).toBeDefined();
-});
+    expect(login2.token).toBeDefined();
+    expect(login2.user).toBeDefined();
+  });
 
-test('logout', async () => {
-    const logout = await user1Caller.auth.logout();
+  test('logout invalidates session', async () => {
+    // Use user2Caller for logout test to avoid breaking user1Caller for other tests
+    const logout = await user3Caller.auth.logout();
     expect(logout).toBeDefined();
+    expect(logout.success).toBe(true);
+    
+    // Verify session is invalidated by trying to use it
+    const invalidCaller = await createTRPCContext({
+      req: { headers: {
+        authorization: `Bearer ${login3.token}`,
+        'x-user': login3.token,
+      } } as any,
+      res: {} as any,
+    });
+    const router = appRouter.createCaller(invalidCaller);
+    
+    // Should fail because session was invalidated
+    await expect(router.user.getProfile()).rejects.toThrow();
+  });
 });