@studious-lms/server 1.2.53 → 1.4.0

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

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

@@ -1,13 +1,13 @@
 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 { expectRejects, expectUnauth } from '../helpers';
+import { prisma } from '../../src/lib/prisma';
 import { startOfWeek } from 'date-fns';
 
 describe('Event Router', () => {
   let testClass: any;
   let testEvent: any;
+  let testAssignment: any;
 
   beforeEach(async () => {
     // Create a test class for user1
@@ -32,6 +32,15 @@ describe('Event Router', () => {
       classId: testClass.id,
       color: '#3B82F6',
     });
+
+    const dueDate = new Date();
+    dueDate.setDate(dueDate.getDate() + 7);
+    testAssignment = await user1Caller.assignment.create({
+      classId: testClass.id,
+      title: 'Test Assignment for Event',
+      instructions: 'Test',
+      dueDate: dueDate.toISOString(),
+    });
   });
 
   describe('create', () => {
@@ -63,34 +72,29 @@ describe('Event Router', () => {
       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();
-    });
+    test('should fail to create event for class user is not teacher of', () =>
+      expectRejects(() => {
+        const startTime = new Date();
+        startTime.setHours(10, 0, 0, 0);
+        const endTime = new Date(startTime);
+        endTime.setHours(11, 0, 0, 0);
+        return user2Caller.event.create({
+          name: 'Unauthorized Event',
+          startTime: startTime.toISOString(),
+          endTime: endTime.toISOString(),
+          classId: testClass.id,
+        });
+      }));
+
+    test('should fail without authentication', () =>
+      expectUnauth((c) => {
+        const startTime = new Date();
+        return c.event.create({
+          name: 'Test',
+          startTime: startTime.toISOString(),
+          endTime: startTime.toISOString(),
+        });
+      }));
   });
 
   describe('get', () => {
@@ -192,6 +196,63 @@ describe('Event Router', () => {
     });
   });
 
+  describe('attachAssignment', () => {
+    test('should attach assignment to event', async () => {
+      const result = await user1Caller.event.attachAssignment({
+        eventId: testEvent.event.id,
+        assignmentId: testAssignment.id,
+      });
+      expect(result).toBeDefined();
+    });
+
+    test('should fail when user is not teacher of class', () =>
+      expectRejects(() =>
+        user2Caller.event.attachAssignment({
+          eventId: testEvent.event.id,
+          assignmentId: testAssignment.id,
+        })
+      ));
+  });
+
+  describe('detachAssignment', () => {
+    test('should detach assignment from event', async () => {
+      await user1Caller.event.attachAssignment({
+        eventId: testEvent.event.id,
+        assignmentId: testAssignment.id,
+      });
+      const result = await user1Caller.event.detachAssignment({
+        eventId: testEvent.event.id,
+        assignmentId: testAssignment.id,
+      });
+      expect(result).toBeDefined();
+    });
+
+    test('should fail when user is not teacher of class', () =>
+      expectRejects(() =>
+        user2Caller.event.detachAssignment({
+          eventId: testEvent.event.id,
+          assignmentId: testAssignment.id,
+        })
+      ));
+  });
+
+  describe('getAvailableAssignments', () => {
+    test('should return available assignments for class event', async () => {
+      const result = await user1Caller.event.getAvailableAssignments({
+        eventId: testEvent.event.id,
+      });
+      expect(result).toBeDefined();
+      expect(result.assignments).toBeDefined();
+      expect(Array.isArray(result.assignments)).toBe(true);
+      expect(result.assignments.some((a: any) => a.id === testAssignment.id)).toBe(true);
+    });
+
+    test('should fail without authentication', () =>
+      expectUnauth((c) =>
+        c.event.getAvailableAssignments({ eventId: testEvent.event.id })
+      ));
+  });
+
   describe('getAll', () => {
     test('should get all events for user', async () => {
       // Create another event

package/tests/routers/folder.test.ts

@@ -0,0 +1,178 @@
+import { test, expect, describe, beforeAll } from 'vitest';
+import { user1Caller, user2Caller } from '../setup';
+
+describe('Folder Router', () => {
+  let testClass: any;
+  let rootFolder: any;
+  let childFolder: any;
+
+  beforeAll(async () => {
+    testClass = await user1Caller.class.create({
+      name: 'Folder Test Class',
+      subject: 'Art',
+      section: '10th Grade',
+    });
+  });
+
+  describe('getRootFolder', () => {
+    test('should get or create root folder for class', async () => {
+      rootFolder = await user1Caller.folder.getRootFolder({
+        classId: testClass.id,
+      });
+
+      expect(rootFolder).toBeDefined();
+      expect(rootFolder.name).toBe('Class Files');
+    });
+  });
+
+  describe('create', () => {
+    test('should create a subfolder', async () => {
+      childFolder = await user1Caller.folder.create({
+        classId: testClass.id,
+        name: 'Homework',
+        color: '#3B82F6',
+      });
+
+      expect(childFolder).toBeDefined();
+      expect(childFolder.name).toBe('Homework');
+    });
+
+    test('should create folder under specific parent', async () => {
+      const nested = await user1Caller.folder.create({
+        classId: testClass.id,
+        name: 'Week 1',
+        parentFolderId: childFolder.id,
+      });
+
+      expect(nested).toBeDefined();
+      expect(nested.name).toBe('Week 1');
+    });
+
+    test('should fail for non-teacher', async () => {
+      await expect(
+        user2Caller.folder.create({
+          classId: testClass.id,
+          name: 'Unauthorized Folder',
+        }),
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('get', () => {
+    test('should get folder by ID', async () => {
+      const folder = await user1Caller.folder.get({
+        folderId: childFolder.id,
+        classId: testClass.id,
+      });
+
+      expect(folder).toBeDefined();
+      expect(folder.name).toBe('Homework');
+      expect(folder.childFolders.length).toBe(1);
+    });
+
+    test('should fail for non-existent folder', async () => {
+      await expect(
+        user1Caller.folder.get({
+          folderId: 'nonexistent',
+          classId: testClass.id,
+        }),
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('getChildFolders', () => {
+    test('should list child folders of root', async () => {
+      const children = await user1Caller.folder.getChildFolders({
+        classId: testClass.id,
+      });
+
+      expect(Array.isArray(children)).toBe(true);
+      expect(children.some((f: any) => f.name === 'Homework')).toBe(true);
+    });
+  });
+
+  describe('update', () => {
+    test('should rename a folder', async () => {
+      const updated = await user1Caller.folder.update({
+        classId: testClass.id,
+        folderId: childFolder.id,
+        name: 'Classwork',
+        color: '#EF4444',
+      });
+
+      expect(updated.name).toBe('Classwork');
+    });
+
+    test('should fail for non-teacher', async () => {
+      await expect(
+        user2Caller.folder.update({
+          classId: testClass.id,
+          folderId: childFolder.id,
+          name: 'Unauthorized Rename',
+        }),
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('move', () => {
+    test('should move folder to a different parent', async () => {
+      const newParent = await user1Caller.folder.create({
+        classId: testClass.id,
+        name: 'Archive',
+      });
+
+      const childToMove = await user1Caller.folder.create({
+        classId: testClass.id,
+        name: 'Movable Folder',
+      });
+
+      const moved = await user1Caller.folder.move({
+        classId: testClass.id,
+        folderId: childToMove.id,
+        targetParentFolderId: newParent.id,
+      });
+
+      expect(moved).toBeDefined();
+    });
+
+    test('should fail to move folder into itself', async () => {
+      await expect(
+        user1Caller.folder.move({
+          classId: testClass.id,
+          folderId: childFolder.id,
+          targetParentFolderId: childFolder.id,
+        }),
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('delete', () => {
+    test('should delete a folder', async () => {
+      const tempClass = await user1Caller.class.create({
+        name: 'Temp Delete Class',
+        subject: 'Temp',
+        section: 'Temp',
+      });
+
+      const root = await user1Caller.folder.getRootFolder({
+        classId: tempClass.id,
+      });
+
+      const result = await user1Caller.folder.delete({
+        classId: tempClass.id,
+        folderId: root!.id,
+      });
+
+      expect(result.success).toBe(true);
+    });
+
+    test('should fail for non-teacher', async () => {
+      await expect(
+        user2Caller.folder.delete({
+          classId: testClass.id,
+          folderId: childFolder.id,
+        }),
+      ).rejects.toThrow();
+    });
+  });
+});

package/tests/routers/labChat.test.ts

@@ -0,0 +1,115 @@
+import { test, expect, describe, beforeAll } from 'vitest';
+import { user1Caller, user2Caller } from '../setup';
+
+describe('Lab Chat Router', () => {
+  let testClass: any;
+  let labChatId: string;
+
+  beforeAll(async () => {
+    testClass = await user1Caller.class.create({
+      name: 'Lab Chat Test Class',
+      subject: 'Chemistry',
+      section: '11th Grade',
+    });
+  });
+
+  describe('create', () => {
+    test('should create a lab chat', async () => {
+      const context = JSON.stringify({
+        topic: 'Chemical Reactions',
+        objectives: ['Understand reaction types'],
+      });
+
+      const labChat = await user1Caller.labChat.create({
+        classId: testClass.id,
+        title: 'Chemical Reactions Lab',
+        context,
+      });
+
+      expect(labChat).toBeDefined();
+      expect(labChat.title).toBe('Chemical Reactions Lab');
+      expect(labChat.classId).toBe(testClass.id);
+      expect(labChat.conversationId).toBeDefined();
+      labChatId = labChat.id;
+    });
+
+    test('should fail with invalid JSON context', async () => {
+      await expect(
+        user1Caller.labChat.create({
+          classId: testClass.id,
+          title: 'Bad Context Lab',
+          context: 'not valid json',
+        }),
+      ).rejects.toThrow();
+    });
+
+    test('should fail for non-teacher', async () => {
+      await expect(
+        user2Caller.labChat.create({
+          classId: testClass.id,
+          title: 'Unauthorized Lab',
+          context: '{}',
+        }),
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('list', () => {
+    test('should list lab chats for a class', async () => {
+      const labChats = await user1Caller.labChat.list({
+        classId: testClass.id,
+      });
+
+      expect(Array.isArray(labChats)).toBe(true);
+      expect(labChats.some((lc) => lc.id === labChatId)).toBe(true);
+    });
+
+    test('should fail for non-class-member', async () => {
+      await expect(
+        user2Caller.labChat.list({ classId: testClass.id }),
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('get', () => {
+    test('should get lab chat by ID', async () => {
+      const labChat = await user1Caller.labChat.get({
+        labChatId,
+      });
+
+      expect(labChat).toBeDefined();
+      expect(labChat.id).toBe(labChatId);
+      expect(labChat.title).toBe('Chemical Reactions Lab');
+      expect(labChat.conversation).toBeDefined();
+    });
+
+    test('should fail for non-member', async () => {
+      await expect(
+        user2Caller.labChat.get({ labChatId }),
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('delete', () => {
+    test('should fail for non-creator', async () => {
+      const user2Profile = await user2Caller.user.getProfile();
+      await user1Caller.class.addStudent({
+        classId: testClass.id,
+        studentId: user2Profile.id,
+      });
+
+      await expect(
+        user2Caller.labChat.delete({ labChatId }),
+      ).rejects.toThrow();
+    });
+
+    test('should delete lab chat', async () => {
+      const result = await user1Caller.labChat.delete({ labChatId });
+      expect(result.success).toBe(true);
+
+      await expect(
+        user1Caller.labChat.get({ labChatId }),
+      ).rejects.toThrow();
+    });
+  });
+});

package/tests/routers/marketing.test.ts

@@ -0,0 +1,59 @@
+import { test, expect, describe } from 'vitest';
+import { caller } from '../setup';
+
+describe('Marketing Router', () => {
+  let programId: string;
+
+  describe('createSchoolDevelopementProgram', () => {
+    test('should create a school development program', async () => {
+      const result = await caller.marketing.createSchoolDevelopementProgram({
+        name: 'Test School',
+        type: 'Public',
+        address: '123 Test St',
+        city: 'Test City',
+        country: 'US',
+        numberOfStudents: 500,
+        numberOfTeachers: 30,
+        contactName: 'John Doe',
+        contactEmail: 'john@test.com',
+      });
+
+      expect(result).toBeDefined();
+      expect(result.id).toBeDefined();
+      expect(result.id).toContain('TES-');
+      programId = result.id;
+    });
+  });
+
+  describe('searchSchoolDevelopementPrograms', () => {
+    test('should find program by ID', async () => {
+      const result = await caller.marketing.searchSchoolDevelopementPrograms({
+        id: programId,
+      });
+
+      expect(result).toBeDefined();
+      expect(result!.name).toBe('Test School');
+      expect(result!.city).toBe('Test City');
+    });
+
+    test('should return null for non-existent ID', async () => {
+      const result = await caller.marketing.searchSchoolDevelopementPrograms({
+        id: 'NONEXISTENT',
+      });
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('earlyAccessRequest', () => {
+    test('should create an early access request', async () => {
+      const result = await caller.marketing.earlyAccessRequest({
+        email: 'earlyaccess@test.com',
+        institutionSize: '100-500',
+      });
+
+      expect(result).toBeDefined();
+      expect(result.id).toBeDefined();
+    });
+  });
+});