@studious-lms/server 1.2.44 → 1.2.46

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

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 () => {