@studious-lms/server 1.1.26 → 1.2.6

package/tests/routers/attendance.test.ts

@@ -0,0 +1,160 @@
+import { test, expect, describe, beforeEach } from 'vitest';
+import { user1Caller, user2Caller } from '../setup';
+import { expectUnauth } from '../helpers';
+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', () =>
+      expectUnauth((c) => c.attendance.update({
+        classId: testClass.id,
+        attendance: {
+          present: [],
+          late: [],
+          absent: [],
+        },
+      })));
+  });
+});
+

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