@studious-lms/server 1.1.24 → 1.2.6

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

@@ -1,32 +1,46 @@
-import { test, expect, describe, beforeEach } 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;
   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');
     });
@@ -37,27 +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 () => {
-      await expect(user1Caller.class.create({
+    test('should fail to create class with missing required fields', () =>
+      // @ts-expect-error - test case
+      expectRejects(() => user1Caller.class.create({
         name: '',
-        subject: 'Mathematics',
-        section: '10th Grade',
-      })).rejects.toThrow();
-    });
+        color: '#3B82F6',
+      })));
   });
 
   describe('getAll', () => {
@@ -72,19 +78,13 @@ 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 () => {
-      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', () => {
@@ -96,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', () => {
@@ -127,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', () => {
@@ -152,15 +142,19 @@ 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 () => {
-      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', () => {
@@ -175,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', () => {
@@ -198,24 +193,27 @@ 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', () => {
     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({
@@ -227,30 +225,38 @@ 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', () => {
     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 () => {
-      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', () => {
@@ -261,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', () => {
@@ -274,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();
+    });
+  });
+});

package/tests/routers/conversation.test.ts

@@ -0,0 +1,145 @@
+import { test, expect, describe, beforeAll } from 'vitest';
+import { user1Caller, user2Caller, user3Caller } from '../setup';
+import { expectUnauth } from '../helpers';
+
+describe('Conversation Router', () => {
+  let dmConversation: any;
+  let groupConversation: any;
+  let user3Id: string;
+
+  beforeAll(async () => {
+    const profile = await user3Caller.user.getProfile();
+    user3Id = profile.id;
+  });
+
+  describe('create', () => {
+    test('should create a DM conversation', async () => {
+      dmConversation = await user1Caller.conversation.create({
+        type: 'DM',
+        memberIds: ['testuser2'],
+      });
+
+      expect(dmConversation).toBeDefined();
+      expect(dmConversation.type).toBe('DM');
+      expect(dmConversation.members.length).toBe(2);
+    });
+
+    test('should create a GROUP conversation', async () => {
+      groupConversation = await user1Caller.conversation.create({
+        type: 'GROUP',
+        name: 'Test Group Chat',
+        memberIds: [user3Id],
+      });
+
+      expect(groupConversation).toBeDefined();
+      expect(groupConversation.type).toBe('GROUP');
+      expect(groupConversation.name).toBe('Test Group Chat');
+    });
+
+    test('should fail to create duplicate DM', async () => {
+      await expect(
+        user1Caller.conversation.create({
+          type: 'DM',
+          memberIds: ['testuser2'],
+        }),
+      ).rejects.toThrow();
+    });
+
+    test('should fail to create GROUP without name', async () => {
+      await expect(
+        user1Caller.conversation.create({
+          type: 'GROUP',
+          memberIds: [user3Id],
+        }),
+      ).rejects.toThrow();
+    });
+
+    test('should fail to create DM with multiple members', async () => {
+      await expect(
+        user1Caller.conversation.create({
+          type: 'DM',
+          memberIds: ['testuser2', 'testuser3'],
+        }),
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('get', () => {
+    test('should get conversation by ID', async () => {
+      const conversation = await user1Caller.conversation.get({
+        conversationId: dmConversation.id,
+      });
+
+      expect(conversation).toBeDefined();
+      expect(conversation.id).toBe(dmConversation.id);
+      expect(conversation.members.length).toBe(2);
+    });
+
+    test('should fail for non-member', async () => {
+      await expect(
+        user3Caller.conversation.get({
+          conversationId: dmConversation.id,
+        }),
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('list', () => {
+    test('should list conversations for user', async () => {
+      const conversations = await user1Caller.conversation.list();
+
+      expect(Array.isArray(conversations)).toBe(true);
+      const ids = conversations.map((c) => c.id);
+      expect(ids).toContain(dmConversation.id);
+      expect(ids).toContain(groupConversation.id);
+    });
+
+    test('should not list conversations user is not in', async () => {
+      const conversations = await user3Caller.conversation.list();
+      const ids = conversations.map((c) => c.id);
+      expect(ids).not.toContain(dmConversation.id);
+    });
+  });
+
+  describe('addMember', () => {
+    test('should add member to group conversation', async () => {
+      await user1Caller.conversation.addMember({
+        conversationId: groupConversation.id,
+        memberUsername: 'testuser2',
+      });
+
+      const conversation = await user2Caller.conversation.get({
+        conversationId: groupConversation.id,
+      });
+
+      expect(conversation.members.length).toBe(3);
+    });
+
+    test('should fail to add non-existent user', async () => {
+      await expect(
+        user1Caller.conversation.addMember({
+          conversationId: groupConversation.id,
+          memberUsername: 'nonexistentuser',
+        }),
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('removeMember', () => {
+    test('should remove member from conversation', async () => {
+      await user1Caller.conversation.removeMember({
+        conversationId: groupConversation.id,
+        memberId: user3Id,
+      });
+
+      await expect(
+        user3Caller.conversation.get({
+          conversationId: groupConversation.id,
+        }),
+      ).rejects.toThrow();
+    });
+  });
+
+  test('should fail without authentication', () =>
+    expectUnauth((c) => c.conversation.list()));
+});