@studious-lms/server 1.1.24 → 1.2.6

package/tests/routers/event.test.ts

@@ -0,0 +1,289 @@
+import { test, expect, describe, beforeEach } from 'vitest';
+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
+    testClass = await user1Caller.class.create({
+      name: 'Test Class for Events',
+      subject: 'Mathematics',
+      section: '10th Grade',
+    });
+
+    // 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',
+      location: 'Room 101',
+      remarks: 'Test remarks',
+      startTime: startTime.toISOString(),
+      endTime: endTime.toISOString(),
+      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', () => {
+    test('should create event successfully', async () => {
+      expect(testEvent).toBeDefined();
+      expect(testEvent.event).toBeDefined();
+      expect(testEvent.event.name).toBe('Test Event');
+      expect(testEvent.event.location).toBe('Room 101');
+      expect(testEvent.event.remarks).toBe('Test remarks');
+      expect(testEvent.event.classId).toBe(testClass.id);
+      expect(testEvent.event.color).toBe('#3B82F6');
+    });
+
+    test('should create event without class', async () => {
+      const startTime = new Date();
+      startTime.setHours(14, 0, 0, 0);
+      const endTime = new Date(startTime);
+      endTime.setHours(15, 0, 0, 0);
+
+      const event = await user1Caller.event.create({
+        name: 'Personal Event',
+        location: 'Home',
+        startTime: startTime.toISOString(),
+        endTime: endTime.toISOString(),
+      });
+
+      expect(event.event).toBeDefined();
+      expect(event.event.name).toBe('Personal Event');
+      expect(event.event.classId).toBeNull();
+    });
+
+    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', () => {
+    test('should get event successfully', async () => {
+      const event = await user1Caller.event.get({
+        id: testEvent.event.id,
+      });
+
+      expect(event).toBeDefined();
+      expect(event.event.id).toBe(testEvent.event.id);
+      expect(event.event.name).toBe('Test Event');
+      expect(event.event.class).toBeDefined();
+    });
+
+    test('should fail to get event user does not own', async () => {
+      await expect(user2Caller.event.get({
+        id: testEvent.event.id,
+      })).rejects.toThrow();
+    });
+
+    test('should fail to get non-existent event', async () => {
+      await expect(user1Caller.event.get({
+        id: 'non-existent-id',
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('update', () => {
+    test('should update event successfully', async () => {
+      const startTime = new Date();
+      startTime.setHours(12, 0, 0, 0);
+      const endTime = new Date(startTime);
+      endTime.setHours(13, 0, 0, 0);
+
+      const updated = await user1Caller.event.update({
+        id: testEvent.event.id,
+        data: {
+          name: 'Updated Event Name',
+          location: 'Room 202',
+          remarks: 'Updated remarks',
+          startTime: startTime.toISOString(),
+          endTime: endTime.toISOString(),
+          color: '#10B981',
+        },
+      });
+
+      expect(updated.event.name).toBe('Updated Event Name');
+      expect(updated.event.location).toBe('Room 202');
+      expect(updated.event.remarks).toBe('Updated remarks');
+      expect(updated.event.color).toBe('#10B981');
+    });
+
+    // @todo: not implemented partial updates
+    // test('should update event with partial data', async () => {
+    //   const updated = await user1Caller.event.update({
+    //     id: testEvent.event.id,
+    //     data: {
+    //       name: 'Partially Updated Event',
+    //     },
+    //   });
+
+    //   expect(updated.event.name).toBe('Partially Updated Event');
+    //   expect(updated.event.location).toBe('Room 101'); // Should remain unchanged
+    // });
+
+    test('should fail to update event user does not own', async () => {
+      await expect(user2Caller.event.update({
+        id: testEvent.event.id,
+        data: {
+          name: 'Unauthorized Update',
+          location: 'Room 101',
+          remarks: 'Updated remarks',
+          startTime: testEvent.event.startTime,
+          endTime: testEvent.event.endTime,
+          color: '#10B981',
+        },
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('delete', () => {
+    test('should delete event successfully', async () => {
+      const result = await user1Caller.event.delete({
+        id: testEvent.event.id,
+      });
+
+      expect(result.success).toBe(true);
+
+      // Verify event is deleted
+      await expect(user1Caller.event.get({
+        id: testEvent.event.id,
+      })).rejects.toThrow();
+    });
+
+    test('should fail to delete event user does not own', async () => {
+      await expect(user2Caller.event.delete({
+        id: testEvent.event.id,
+      })).rejects.toThrow();
+    });
+  });
+
+  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
+      const startTime = new Date();
+      startTime.setHours(15, 0, 0, 0);
+      const endTime = new Date(startTime);
+      endTime.setHours(16, 0, 0, 0);
+
+      const secondEvent = await user1Caller.event.create({
+        name: 'Second Event',
+        startTime: startTime.toISOString(),
+        endTime: endTime.toISOString(),
+      });
+
+      const events = await user1Caller.agenda.get({
+        weekStart: startOfWeek(startTime).toISOString(),
+      });
+
+      expect(events.events).toBeDefined();
+      expect(events.events.personal.length).toBeGreaterThanOrEqual(2);
+      expect(events.events.personal.some((e) => e.id === secondEvent.event.id)).toBe(true);
+    });
+
+    test('should return empty array for user with no events', async () => {
+      const events = await user2Caller.agenda.get({
+        weekStart: new Date().toISOString(),
+      });
+      expect(events.events.personal).toBeDefined();
+      expect(Array.isArray(events.events.personal)).toBe(true);
+      expect(events.events.personal.length).toBe(0);
+    });
+  });
+});
+

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