@studious-lms/server 1.2.53 → 1.4.0

package/tests/{attendance.test.ts → routers/attendance.test.ts}

@@ -1,8 +1,7 @@
 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 { user1Caller, user2Caller } from '../setup';
+import { expectUnauth } from '../helpers';
+import { prisma } from '../../src/lib/prisma';
 
 describe('Attendance Router', () => {
   let testClass: any;
@@ -147,22 +146,15 @@ describe('Attendance Router', () => {
       })).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({
+    test('should fail without authentication', () =>
+      expectUnauth((c) => c.attendance.update({
         classId: testClass.id,
         attendance: {
           present: [],
           late: [],
           absent: [],
         },
-      })).rejects.toThrow();
-    });
+      })));
   });
 });
 

package/tests/routers/auth.test.ts

@@ -0,0 +1,171 @@
+// @note: some sloppy impl
+
+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, login3, session1, session2, session3, user1Caller, user2Caller, user3Caller, verification1, verification2, verification3 } from '../setup';
+import { expectUnauth } from '../helpers';
+
+describe('Auth Router', () => {
+  test('check returns user when authenticated', async () => {
+    const result = await user1Caller.auth.check();
+    expect(result.user).toBeDefined();
+    expect(result.user.id).toBeDefined();
+    expect(result.user.username).toBe('testuser1');
+  });
+
+  test('check fails when unauthenticated', () =>
+    expectUnauth((c) => c.auth.check()));
+
+  test('resendVerificationEmail succeeds for existing user', async () => {
+    await caller.auth.register({
+      username: 'resendtest',
+      email: 'resend@studious.sh',
+      password: 'password_is_1234',
+      confirmPassword: 'password_is_1234',
+    });
+    const result = await caller.auth.resendVerificationEmail({
+      email: 'resend@studious.sh',
+    });
+    expect(result).toBeDefined();
+  });
+
+  test('requestPasswordReset succeeds', async () => {
+    const result = await caller.auth.requestPasswordReset({
+      email: 'test@studious.sh',
+    });
+    expect(result).toBeDefined();
+    expect(result.success).toBe(true);
+  });
+
+  test('resetPassword works with valid token', async () => {
+    await caller.auth.requestPasswordReset({ email: 'test@studious.sh' });
+    // Reset tokens expire within 2hr; login sessions expire in 30 days
+    const twoHoursFromNow = new Date(Date.now() + 2 * 60 * 60 * 1000);
+    const resetSession = await prisma.session.findFirst({
+      where: {
+        userId: login1.user.id,
+        classId: null,
+        expiresAt: { lte: twoHoursFromNow },
+        createdAt: { gte: new Date(Date.now() - 60_000) }, // created in last minute
+      },
+      orderBy: { createdAt: 'desc' },
+    });
+    if (!resetSession) throw new Error('No reset token found');
+
+    const result = await caller.auth.resetPassword({
+      token: resetSession.id,
+      password: 'new_password_123',
+      confirmPassword: 'new_password_123',
+    });
+    expect(result).toBeDefined();
+
+    const login = await caller.auth.login({
+      username: 'testuser1',
+      password: 'new_password_123',
+    });
+    expect(login.token).toBeDefined();
+
+    await caller.auth.requestPasswordReset({ email: 'test@studious.sh' });
+    const restoreSession = await prisma.session.findFirst({
+      where: {
+        userId: login1.user.id,
+        classId: null,
+        expiresAt: { lte: twoHoursFromNow },
+        createdAt: { gte: new Date(Date.now() - 60_000) },
+      },
+      orderBy: { createdAt: 'desc' },
+    });
+    if (!restoreSession) throw new Error('No reset token found');
+    await caller.auth.resetPassword({
+      token: restoreSession.id,
+      password: 'password_is_1234',
+      confirmPassword: 'password_is_1234',
+    });
+  });
+
+  test('registration creates sessions', async () => {
+    expect(session1).toBeDefined();
+    expect(session1.id).toBeDefined();
+    expect(session2).toBeDefined();
+    expect(session2.id).toBeDefined();
+  });
+
+  test('email verification works', async () => {
+    expect(verification1).toBeDefined();
+    expect(verification2).toBeDefined();
+  });
+
+  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('login fails with invalid username', async () => {
+    await expect(
+      caller.auth.login({ username: 'nonexistent', password: 'any' })
+    ).rejects.toThrow();
+  });
+
+  test('login fails with wrong password', async () => {
+    await expect(
+      caller.auth.login({ username: 'testuser1', password: 'wrongpassword' })
+    ).rejects.toThrow();
+  });
+
+  test('register fails when username already exists', async () => {
+    await expect(
+      caller.auth.register({
+        username: 'testuser1',
+        email: 'newemail@studious.sh',
+        password: 'password_is_1234',
+        confirmPassword: 'password_is_1234',
+      })
+    ).rejects.toThrow();
+  });
+
+  test('register fails when email already exists', async () => {
+    await expect(
+      caller.auth.register({
+        username: 'newuser',
+        email: 'test@studious.sh',
+        password: 'password_is_1234',
+        confirmPassword: 'password_is_1234',
+      })
+    ).rejects.toThrow();
+  });
+
+  test('verify fails with invalid token', async () => {
+    await expect(
+      caller.auth.verify({ token: 'invalid-token-12345' })
+    ).rejects.toThrow();
+  });
+
+  test('resetPassword fails with invalid token', async () => {
+    await expect(
+      caller.auth.resetPassword({
+        token: 'invalid-token-12345',
+        password: 'newpass123',
+        confirmPassword: 'newpass123',
+      })
+    ).rejects.toThrow();
+  });
+
+  test('logout invalidates session', async () => {
+    const logout = await user3Caller.auth.logout();
+    expect(logout).toBeDefined();
+    expect(logout.success).toBe(true);
+
+    const ctx = await createTRPCContext({
+      req: { headers: { authorization: `Bearer ${login3.token}`, 'x-user': login3.token } } as any,
+      res: {} as any,
+    });
+    const router = appRouter.createCaller(ctx);
+    await expect(router.user.getProfile()).rejects.toThrow('Invalid or expired session');
+  });
+});

package/tests/{class.test.ts → routers/class.test.ts}

@@ -1,8 +1,15 @@
-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';
-import { caller, user1Caller, user2Caller } from './setup';
+import { test, expect, describe, beforeEach, afterEach, vi } from 'vitest';
+import { expectForbidden, expectRejects, expectUnauth } from '../helpers';
+import { prisma } from '../../src/lib/prisma';
+import { caller, user1Caller, user2Caller, user3Caller } from '../setup';
+
+vi.mock('../../src/lib/googleCloudStorage.js', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../../src/lib/googleCloudStorage.js')>();
+  return {
+    ...actual,
+    copyFile: vi.fn().mockResolvedValue(undefined),
+  };
+});
 
 describe('Class Router', () => {
   let testClass: any;
@@ -44,28 +51,19 @@ describe('Class Router', () => {
       expect(testClass.id).not.toBe(testClass2.id);
     });
 
-    test('should fail to create class without authentication', async () => {
-      const invalidCaller = await createTRPCContext({
-        req: { headers: {} } as any,
-        res: {} as any,
-      });
-      const router = appRouter.createCaller(invalidCaller);
-      
-      await expect(router.class.create({
+    test('should fail to create class without authentication', () =>
+      expectUnauth((c) => c.class.create({
         name: 'Test Class',
         subject: 'Mathematics',
         section: '10th Grade',
-      })).rejects.toThrow();
-    });
-
-    test('should fail to create class with missing required fields', async () => {
+      })));
 
+    test('should fail to create class with missing required fields', () =>
       // @ts-expect-error - test case
-      await expect(user1Caller.class.create({
+      expectRejects(() => user1Caller.class.create({
         name: '',
         color: '#3B82F6',
-      })).rejects.toThrow();
-    });
+      })));
   });
 
   describe('getAll', () => {
@@ -85,15 +83,8 @@ describe('Class Router', () => {
       expect(userClass?.id).toBe(testClass.id);
     });
 
-    test('should fail to get classes without authentication', async () => {
-      const invalidCaller = await createTRPCContext({
-        req: { headers: {} } as any,
-        res: {} as any,
-      });
-      const router = appRouter.createCaller(invalidCaller);
-      
-      await expect(router.class.getAll()).rejects.toThrow();
-    });
+    test('should fail to get classes without authentication', () =>
+      expectUnauth((c) => c.class.getAll()));
   });
 
   describe('get', () => {
@@ -105,19 +96,11 @@ describe('Class Router', () => {
       expect(classData.class.name).toBe('Test Class 1');
     });
 
-    test('should fail to get non-existent class', async () => {
-      await expect(user1Caller.class.get({ classId: 'non-existent-id' })).rejects.toThrow();
-    });
+    test('should fail to get non-existent class', () =>
+      expectRejects(() => user1Caller.class.get({ classId: 'non-existent-id' })));
 
-    test('should fail to get class without authentication', async () => {
-      const invalidCaller = await createTRPCContext({
-        req: { headers: {} } as any,
-        res: {} as any,
-      });
-      const router = appRouter.createCaller(invalidCaller);
-      
-      await expect(router.class.get({ classId: testClass.id })).rejects.toThrow();
-    });
+    test('should fail to get class without authentication', () =>
+      expectUnauth((c) => c.class.get({ classId: testClass.id })));
   });
 
   describe('update', () => {
@@ -136,23 +119,21 @@ describe('Class Router', () => {
       expect(updatedClass.updatedClass.section).toBe('12th Grade');
     });
 
-    test('should fail to update class user is not teacher of', async () => {
-      await expect(user2Caller.class.update({
+    test('should fail to update class user is not teacher of', () =>
+      expectForbidden(() => user2Caller.class.update({
         classId: testClass.id,
         name: 'Updated Test Class',
         subject: 'Physics',
         section: '12th Grade',
-      })).rejects.toThrow();
-    });
+      })));
 
-    test('should fail to update non-existent class', async () => {
-      await expect(user1Caller.class.update({
+    test('should fail to update non-existent class', () =>
+      expectRejects(() => user1Caller.class.update({
         classId: 'non-existent-id',
         name: 'Updated Test Class',
         subject: 'Physics',
         section: '12th Grade',
-      })).rejects.toThrow();
-    });
+      })));
   });
 
   describe('delete', () => {
@@ -169,13 +150,11 @@ describe('Class Router', () => {
       }
     });
 
-    test('should fail to delete class user is not teacher of', async () => {
-      await expect(user2Caller.class.delete({ classId: testClass.id, id: testClass.id })).rejects.toThrow();
-    });
+    test('should fail to delete class user is not teacher of', () =>
+      expectForbidden(() => user2Caller.class.delete({ classId: testClass.id, id: testClass.id })));
 
-    test('should fail to delete non-existent class', async () => {
-      await expect(user1Caller.class.delete({ classId: 'non-existent-id', id: 'non-existent-id' })).rejects.toThrow();
-    });
+    test('should fail to delete non-existent class', () =>
+      expectRejects(() => user1Caller.class.delete({ classId: 'non-existent-id', id: 'non-existent-id' })));
   });
 
   describe('addStudent', () => {
@@ -190,13 +169,14 @@ describe('Class Router', () => {
       expect(result.newStudent).toBeDefined();
     });
 
-    test('should fail to add student if user is not class teacher', async () => {
-      const user1Profile = await user1Caller.user.getProfile();
-      await expect(user2Caller.class.addStudent({
-        classId: testClass.id,
-        studentId: user1Profile.id,
-      })).rejects.toThrow();
-    });
+    test('should fail to add student if user is not class teacher', () =>
+      expectForbidden(async () => {
+        const user1Profile = await user1Caller.user.getProfile();
+        return user2Caller.class.addStudent({
+          classId: testClass.id,
+          studentId: user1Profile.id,
+        });
+      }));
   });
 
   describe('changeRole', () => {
@@ -213,14 +193,15 @@ describe('Class Router', () => {
       expect(result.user.type).toBe('teacher');
     });
 
-    test('should fail to change role if user is not class teacher', async () => {
-      const user1Profile = await user1Caller.user.getProfile();
-      await expect(user2Caller.class.changeRole({
-        classId: testClass.id,
-        userId: user1Profile.id,
-        type: 'teacher',
-      })).rejects.toThrow();
-    });
+    test('should fail to change role if user is not class teacher', () =>
+      expectForbidden(async () => {
+        const user1Profile = await user1Caller.user.getProfile();
+        return user2Caller.class.changeRole({
+          classId: testClass.id,
+          userId: user1Profile.id,
+          type: 'teacher',
+        });
+      }));
   });
 
   describe('removeMember', () => {
@@ -244,13 +225,14 @@ describe('Class Router', () => {
       expect(result.removedUserId).toBe(user2Profile.id);
     });
 
-    test('should fail to remove member if user is not class teacher', async () => {
-      const user1Profile = await user1Caller.user.getProfile();
-      await expect(user2Caller.class.removeMember({
-        classId: testClass.id,
-        userId: user1Profile.id,
-      })).rejects.toThrow();
-    });
+    test('should fail to remove member if user is not class teacher', () =>
+      expectForbidden(async () => {
+        const user1Profile = await user1Caller.user.getProfile();
+        return user2Caller.class.removeMember({
+          classId: testClass.id,
+          userId: user1Profile.id,
+        });
+      }));
   });
 
   describe('join', () => {
@@ -273,9 +255,8 @@ describe('Class Router', () => {
       });
     });
 
-    test('should fail to join with invalid class code', async () => {
-      await expect(user2Caller.class.join({ classCode: 'invalid-code' })).rejects.toThrow();
-    });
+    test('should fail to join with invalid class code', () =>
+      expectRejects(() => user2Caller.class.join({ classCode: 'invalid-code' })));
   });
 
   describe('getInviteCode', () => {
@@ -286,9 +267,8 @@ describe('Class Router', () => {
       expect(typeof result.code).toBe('string');
     });
 
-    test('should fail to get invite code if user is not class teacher', async () => {
-      await expect(user2Caller.class.getInviteCode({ classId: testClass.id })).rejects.toThrow();
-    });
+    test('should fail to get invite code if user is not class teacher', () =>
+      expectForbidden(() => user2Caller.class.getInviteCode({ classId: testClass.id })));
   });
 
   describe('createInviteCode', () => {
@@ -299,8 +279,74 @@ describe('Class Router', () => {
       expect(typeof result.code).toBe('string');
     });
 
-    test('should fail to create invite code if user is not class teacher', async () => {
-      await expect(user2Caller.class.createInviteCode({ classId: testClass.id })).rejects.toThrow();
+    test('should fail to create invite code if user is not class teacher', () =>
+      expectForbidden(() => user2Caller.class.createInviteCode({ classId: testClass.id })));
+  });
+
+  describe('exportClass', () => {
+    test('teacher can export class', async () => {
+      // Ensure class has classFiles (root folder) by fetching it
+      await user1Caller.folder.getRootFolder({ classId: testClass.id });
+
+      const exported = await user1Caller.class.exportClass({ classId: testClass.id });
+
+      expect(exported).toBeDefined();
+      expect(exported.id).toBe(testClass.id);
+      expect(exported.name).toBe('Test Class 1');
+      expect(exported.subject).toBe('Mathematics');
+      expect(exported.assignments).toBeDefined();
+      expect(Array.isArray(exported.assignments)).toBe(true);
+      expect(exported.classFiles).toBeDefined();
+    });
+
+    test('non-teacher cannot export class', () =>
+      expectForbidden(() => user2Caller.class.exportClass({ classId: testClass.id })));
+  });
+
+  describe('importClass', () => {
+    test('teacher can import class with folder structure', async () => {
+      await user1Caller.folder.getRootFolder({ classId: testClass.id });
+      await user1Caller.folder.create({
+        classId: testClass.id,
+        name: 'Source Folder',
+        color: '#3B82F6',
+      });
+
+      const exported = await user1Caller.class.exportClass({ classId: testClass.id });
+      const newClass = await user1Caller.class.create({
+        name: 'Imported Class',
+        subject: 'Mathematics',
+        section: '10th Grade',
+      });
+
+      const importedId = await user1Caller.class.importClass({
+        classId: newClass.id,
+        year: new Date().getFullYear(),
+        classData: exported,
+      });
+
+      const importedClass = await user1Caller.class.get({ classId: importedId });
+      expect(importedClass.class.name).toBe(exported.name);
+      expect(importedClass.class.subject).toBe(exported.subject);
+
+      const rootFolder = await user1Caller.folder.getRootFolder({ classId: importedId });
+      expect(rootFolder).toBeDefined();
+      expect(rootFolder.name).toBe('Class Files');
+    });
+
+
+    test('non-teacher cannot import class', async () => {
+      await user1Caller.folder.getRootFolder({ classId: testClass.id });
+      const exported = await user1Caller.class.exportClass({ classId: testClass.id });
+      const newClassId = `import-forbidden-${Date.now()}`;
+
+      await expect(
+        user3Caller.class.importClass({
+          classId: newClassId,
+          year: new Date().getFullYear(),
+          classData: exported,
+        })
+      ).rejects.toThrow();
     });
   });
 }); 

package/tests/routers/comment.test.ts

@@ -0,0 +1,126 @@
+import { test, expect, describe, beforeAll } from 'vitest';
+import { user1Caller, user2Caller } from '../setup';
+
+describe('Comment Router', () => {
+  let testClass: any;
+  let announcement: any;
+  let commentId: string;
+  let replyId: string;
+
+  beforeAll(async () => {
+    testClass = await user1Caller.class.create({
+      name: 'Comment Test Class',
+      subject: 'History',
+      section: '11th Grade',
+    });
+
+    const result = await user1Caller.announcement.create({
+      classId: testClass.id,
+      remarks: 'Test announcement for comments',
+    });
+    announcement = result.announcement;
+
+    const comment = await user1Caller.announcement.addComment({
+      announcementId: announcement.id,
+      classId: testClass.id,
+      content: 'Test comment on announcement',
+    });
+    commentId = comment.comment.id;
+  });
+
+  describe('get', () => {
+    test('should get a comment by ID', async () => {
+      const comment = await user1Caller.comment.get({ id: commentId });
+
+      expect(comment).toBeDefined();
+      expect(comment.id).toBe(commentId);
+      expect(comment.content).toBe('Test comment on announcement');
+    });
+
+    test('should fail for non-existent comment', async () => {
+      await expect(
+        user1Caller.comment.get({ id: 'nonexistent-id' }),
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('replyToComment', () => {
+    test('should reply to a comment', async () => {
+      const reply = await user1Caller.comment.replyToComment({
+        parentCommentId: commentId,
+        content: 'This is a reply',
+      });
+
+      expect(reply).toBeDefined();
+      expect(reply.content).toBe('This is a reply');
+      expect(reply.parentCommentId).toBe(commentId);
+      replyId = reply.id;
+    });
+  });
+
+  describe('getReplies', () => {
+    test('should get replies to a comment', async () => {
+      const replies = await user1Caller.comment.getReplies({
+        commentId,
+      });
+
+      expect(Array.isArray(replies)).toBe(true);
+      expect(replies.length).toBeGreaterThanOrEqual(1);
+      expect(replies.some((r) => r.id === replyId)).toBe(true);
+    });
+
+    test('should return empty array for comment with no replies', async () => {
+      const replies = await user1Caller.comment.getReplies({
+        commentId: replyId,
+      });
+
+      expect(replies).toEqual([]);
+    });
+  });
+
+  describe('reactions', () => {
+    test('should add a reaction to a comment', async () => {
+      const result = await user1Caller.comment.addReaction({
+        id: commentId,
+        type: 'HEART',
+      });
+
+      expect(result.reaction).toBeDefined();
+      expect(result.reaction.type).toBe('HEART');
+    });
+
+    test('should get reactions for a comment', async () => {
+      const result = await user1Caller.comment.getReactions({
+        commentId,
+      });
+
+      expect(result).toBeDefined();
+      expect(result.counts.HEART).toBe(1);
+      expect(result.total).toBe(1);
+      expect(result.userReaction).toBe('HEART');
+    });
+
+    test('should update reaction type', async () => {
+      const result = await user1Caller.comment.addReaction({
+        id: commentId,
+        type: 'THUMBSUP',
+      });
+
+      expect(result.reaction.type).toBe('THUMBSUP');
+    });
+
+    test('should remove a reaction', async () => {
+      const result = await user1Caller.comment.removeReaction({
+        commentId,
+      });
+
+      expect(result.success).toBe(true);
+    });
+
+    test('should fail to remove non-existent reaction', async () => {
+      await expect(
+        user1Caller.comment.removeReaction({ commentId }),
+      ).rejects.toThrow();
+    });
+  });
+});