@studious-lms/server 1.2.53 → 1.4.0

package/tests/routers/assignment.test.ts

@@ -0,0 +1,837 @@
+import { test, expect, describe, beforeEach } from 'vitest';
+import { user1Caller, user2Caller } from '../setup';
+import { expectForbidden, expectUnauth } from '../helpers';
+
+describe('Assignment Router', () => {
+  let testClass: any;
+  let testAssignment: any;
+  let studentId: string;
+
+  beforeEach(async () => {
+    // Create a test class
+    testClass = await user1Caller.class.create({
+      name: 'Test Class for Assignments',
+      subject: 'Mathematics',
+      section: '10th Grade',
+    });
+
+    // Add user2 as a student
+    const studentProfile = await user2Caller.user.getProfile();
+    studentId = studentProfile.id;
+    await user1Caller.class.addStudent({
+      classId: testClass.id,
+      studentId: studentId,
+    });
+
+    // Create a test assignment
+    const dueDate = new Date();
+    dueDate.setDate(dueDate.getDate() + 7); // Due in 7 days
+
+    testAssignment = await user1Caller.assignment.create({
+      classId: testClass.id,
+      title: 'Test Assignment',
+      instructions: 'Complete this test assignment',
+      dueDate: dueDate.toISOString(),
+      maxGrade: 100,
+      type: 'HOMEWORK',
+    });
+  });
+
+  describe('create', () => {
+    test('should create assignment successfully', async () => {
+      expect(testAssignment).toBeDefined();
+      expect(testAssignment).toBeDefined();
+      expect(testAssignment.title).toBe('Test Assignment');
+      expect(testAssignment.instructions).toBe('Complete this test assignment');
+      expect(testAssignment.maxGrade).toBe(100);
+      expect(testAssignment.type).toBe('HOMEWORK');
+    });
+
+    test('should create assignment with different types', async () => {
+      const dueDate = new Date();
+      dueDate.setDate(dueDate.getDate() + 7);
+
+      const quiz = await user1Caller.assignment.create({
+        classId: testClass.id,
+        title: 'Test Quiz',
+        instructions: 'Complete this quiz',
+        dueDate: dueDate.toISOString(),
+        type: 'QUIZ',
+        maxGrade: 50,
+      });
+
+      expect(quiz.type).toBe('QUIZ');
+      expect(quiz.maxGrade).toBe(50);
+    });
+
+    test('should create assignment with files', async () => {
+      const dueDate = new Date();
+      dueDate.setDate(dueDate.getDate() + 7);
+
+      const assignment = await user1Caller.assignment.create({
+        classId: testClass.id,
+        title: 'Assignment with Files',
+        instructions: 'Submit with files',
+        dueDate: dueDate.toISOString(),
+        acceptFiles: true,
+        files: [
+          {
+            name: 'test.pdf',
+            type: 'application/pdf',
+            size: 1024,
+          },
+        ],
+      });
+
+      expect(assignment).toBeDefined();
+    });
+
+    test('should fail to create assignment for class user is not teacher of', async () => {
+      const dueDate = new Date();
+      dueDate.setDate(dueDate.getDate() + 7);
+
+      await expect(user2Caller.assignment.create({
+        classId: testClass.id,
+        title: 'Unauthorized Assignment',
+        instructions: 'Test',
+        dueDate: dueDate.toISOString(),
+      })).rejects.toThrow();
+    });
+
+    test('should fail without authentication', () =>
+      expectUnauth((c) => {
+        const dueDate = new Date();
+        return c.assignment.create({
+          classId: testClass.id,
+          title: 'Test',
+          instructions: 'Test',
+          dueDate: dueDate.toISOString(),
+        });
+      }));
+  });
+
+  describe('get', () => {
+    test('should get assignment successfully', async () => {
+      const assignment = await user1Caller.assignment.get({
+        id: testAssignment.id,
+        classId: testClass.id,
+      });
+
+      expect(assignment).toBeDefined();
+      expect(assignment.id).toBe(testAssignment.id);
+      expect(assignment.title).toBe('Test Assignment');
+    });
+
+    test('should allow students to get assignment', async () => {
+      const assignment = await user2Caller.assignment.get({
+        id: testAssignment.id,
+        classId: testClass.id,
+      });
+
+      expect(assignment).toBeDefined();
+    });
+
+    test('should fail to get assignment for non-class members', async () => {
+      const newClass = await user1Caller.class.create({
+        name: 'Other Class',
+        subject: 'Science',
+        section: '11th Grade',
+      });
+
+      await expect(user2Caller.assignment.get({
+        id: testAssignment.id,
+        classId: newClass.id,
+      })).rejects.toThrow();
+    });
+  });
+
+  // describe('getAll', () => {
+  //   test('should get all assignments for class', async () => {
+  //     const result = await user1Caller.assignment.get({
+  //       classId: testClass.id,
+  //     });
+
+  //     expect(result).toBeDefined();
+  //     expect(Array.isArray(result)).toBe(true);
+  //     expect(result.length).toBeGreaterThanOrEqual(1);
+  //     expect(result.some((a: any) => a.id === testAssignment.id)).toBe(true);
+  //   });
+
+  //   test('should allow students to get all assignments', async () => {
+  //     const result = await user2Caller.assignment.({
+  //       classId: testClass.id,
+  //     });
+
+  //     expect(result.assignments).toBeDefined();
+  //   });
+  // });
+
+  describe('update', () => {
+    test('should update assignment successfully', async () => {
+      const updated = await user1Caller.assignment.update({
+        classId: testClass.id,
+        id: testAssignment.id,
+        title: 'Updated Assignment Title',
+        instructions: 'Updated instructions',
+      });
+
+      expect(updated.title).toBe('Updated Assignment Title');
+      expect(updated.instructions).toBe('Updated instructions');
+    });
+
+    test('should update assignment with partial data', async () => {
+      const updated = await user1Caller.assignment.update({
+        classId: testClass.id,
+        id: testAssignment.id,
+        title: 'Partially Updated Title',
+      });
+
+      expect(updated.title).toBe('Partially Updated Title');
+      expect(updated.instructions).toBe('Complete this test assignment'); // Should remain unchanged
+    });
+
+    test('should fail to update assignment user is not teacher of', async () => {
+      await expect(user2Caller.assignment.update({
+        classId: testClass.id,
+        id: testAssignment.id,
+        title: 'Unauthorized Update',
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('delete', () => {
+    test('should delete assignment successfully', async () => {
+      // Create a new assignment to delete
+      const dueDate = new Date();
+      dueDate.setDate(dueDate.getDate() + 7);
+
+      const newAssignment = await user1Caller.assignment.create({
+        classId: testClass.id,
+        title: 'To Be Deleted',
+        instructions: 'This will be deleted',
+        dueDate: dueDate.toISOString(),
+      });
+
+      const result = await user1Caller.assignment.delete({
+        id: newAssignment.id,
+        classId: testClass.id,
+      });
+
+      expect(result.id).toBe(newAssignment.id);
+
+      // Verify assignment is deleted
+      await expect(user1Caller.assignment.get({
+        id: newAssignment.id,
+        classId: testClass.id,
+      })).rejects.toThrow();
+    });
+
+    test('should fail to delete assignment user is not teacher of', async () => {
+      await expect(user2Caller.assignment.delete({
+        id: testAssignment.id,
+        classId: testClass.id,
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('exists', () => {
+    test('should return true for existing assignment', async () => {
+      const result = await user1Caller.assignment.exists({
+        id: testAssignment.id,
+        classId: testClass.id,
+      });
+      expect(result).toBe(true);
+    });
+
+    test('should return false for non-existent assignment', async () => {
+      const result = await user1Caller.assignment.exists({
+        id: 'non-existent-id',
+        classId: testClass.id,
+      });
+      expect(result).toBe(false);
+    });
+
+    test('should allow students to check existence', async () => {
+      const result = await user2Caller.assignment.exists({
+        id: testAssignment.id,
+        classId: testClass.id,
+      });
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('dueToday', () => {
+    test('should return array of assignments due today', async () => {
+      const result = await user1Caller.assignment.dueToday();
+      expect(result).toBeDefined();
+      expect(Array.isArray(result)).toBe(true);
+    });
+
+    test('should fail without authentication', () =>
+      expectUnauth((c) => c.assignment.dueToday()));
+  });
+
+  describe('getSubmissionById', () => {
+    test('should get submission by ID for teacher', async () => {
+      const submission = await user2Caller.assignment.getSubmission({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+      });
+
+      const byId = await user1Caller.assignment.getSubmissionById({
+        classId: testClass.id,
+        submissionId: submission.id,
+      });
+
+      expect(byId).toBeDefined();
+      expect(byId.id).toBe(submission.id);
+      expect(byId.assignment).toBeDefined();
+      expect(byId.late).toBeDefined();
+    });
+
+    test('should get submission by ID for student', async () => {
+      const submission = await user2Caller.assignment.getSubmission({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+      });
+
+      const byId = await user2Caller.assignment.getSubmissionById({
+        classId: testClass.id,
+        submissionId: submission.id,
+      });
+
+      expect(byId).toBeDefined();
+      expect(byId.id).toBe(submission.id);
+    });
+
+    test('should fail for non-class members', async () => {
+      const submission = await user2Caller.assignment.getSubmission({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+      });
+
+      const newClass = await user1Caller.class.create({
+        name: 'Other Class',
+        subject: 'Science',
+        section: '11th Grade',
+      });
+
+      await expect(user2Caller.assignment.getSubmissionById({
+        classId: newClass.id,
+        submissionId: submission.id,
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('submit', () => {
+    test('should automatically create submission successfully', async () => {
+      // First create a submission
+      const submission = await user2Caller.assignment.getSubmission({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+      });
+
+      expect(submission).toBeDefined();
+    });
+
+    test('should submit assignment with extended response', async () => {
+
+      const submission = await user2Caller.assignment.getSubmission({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+      });
+
+      const updatedSubmission = await user2Caller.assignment.updateSubmission({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+        submissionId: submission.id,
+        extendedResponse: 'This is my answer to the assignment',
+      });
+
+      expect(updatedSubmission.extendedResponse).toBe('This is my answer to the assignment');
+    });
+
+    test('should fail to submit assignment for non-class members', async () => {
+      const newClass = await user1Caller.class.create({
+        name: 'Other Class',
+        subject: 'Science',
+        section: '11th Grade',
+      });
+
+      const dueDate = new Date();
+      dueDate.setDate(dueDate.getDate() + 7);
+
+      const newAssignment = await user1Caller.assignment.create({
+        classId: newClass.id,
+        title: 'Other Assignment',
+        instructions: 'Test',
+        dueDate: dueDate.toISOString(),
+      });
+
+      await expect(user2Caller.assignment.getSubmission({
+        assignmentId: newAssignment.id,
+        classId: newClass.id,
+        submit: true,
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('getSubmissions', () => {
+    test('should get all submissions for assignment as teacher', async () => {
+      await user2Caller.assignment.getSubmission({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+      });
+
+      const submissions = await user1Caller.assignment.getSubmissions({
+        assignmentId: testAssignment.id,
+        classId: testClass.id,
+      });
+
+      expect(submissions).toBeDefined();
+      expect(Array.isArray(submissions)).toBe(true);
+      expect(submissions.length).toBeGreaterThanOrEqual(1);
+      expect(submissions.every((s: any) => s.late !== undefined)).toBe(true);
+    });
+
+    test('should fail for non-teacher', () =>
+      expectForbidden(() =>
+        user2Caller.assignment.getSubmissions({
+          assignmentId: testAssignment.id,
+          classId: testClass.id,
+        })
+      ));
+  });
+
+  describe('updateSubmissionAsTeacher', () => {
+    test('should grade submission', async () => {
+      const submission = await user2Caller.assignment.getSubmission({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+      });
+
+      const updated = await user1Caller.assignment.updateSubmissionAsTeacher({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+        submissionId: submission.id,
+        gradeReceived: 85,
+      });
+
+      expect(updated.gradeReceived).toBe(85);
+    });
+
+    test('should return submission to student', async () => {
+      const submission = await user2Caller.assignment.getSubmission({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+      });
+
+      const updated = await user1Caller.assignment.updateSubmissionAsTeacher({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+        submissionId: submission.id,
+        return: true,
+      });
+
+      expect(updated.returned).toBe(true);
+    });
+
+    test('should fail for non-teacher', async () => {
+      const submission = await user2Caller.assignment.getSubmission({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+      });
+
+      await expect(user2Caller.assignment.updateSubmissionAsTeacher({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+        submissionId: submission.id,
+        gradeReceived: 50,
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('attachToEvent', () => {
+    test('should attach assignment to event', async () => {
+      const startTime = new Date();
+      startTime.setHours(10, 0, 0, 0);
+      const endTime = new Date(startTime);
+      endTime.setHours(11, 0, 0, 0);
+
+      const event = await user1Caller.event.create({
+        name: 'Test Event for Assignment',
+        location: 'Room 101',
+        startTime: startTime.toISOString(),
+        endTime: endTime.toISOString(),
+        classId: testClass.id,
+      });
+
+      const result = await user1Caller.assignment.attachToEvent({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+        eventId: event.event.id,
+      });
+
+      expect(result.assignment).toBeDefined();
+      expect(result.assignment.eventAttached).toBeDefined();
+      expect(result.assignment.eventAttached?.id).toBe(event.event.id);
+    });
+
+    test('should fail for non-teacher', () =>
+      expectForbidden(async () => {
+        const startTime = new Date();
+        startTime.setHours(10, 0, 0, 0);
+        const endTime = new Date(startTime);
+        endTime.setHours(11, 0, 0, 0);
+        const event = await user1Caller.event.create({
+          name: 'Event',
+          startTime: startTime.toISOString(),
+          endTime: endTime.toISOString(),
+          classId: testClass.id,
+        });
+        return user2Caller.assignment.attachToEvent({
+          classId: testClass.id,
+          assignmentId: testAssignment.id,
+          eventId: event.event.id,
+        });
+      }));
+  });
+
+  describe('detachEvent', () => {
+    test('should detach assignment from event', async () => {
+      const startTime = new Date();
+      startTime.setHours(10, 0, 0, 0);
+      const endTime = new Date(startTime);
+      endTime.setHours(11, 0, 0, 0);
+
+      const event = await user1Caller.event.create({
+        name: 'Event to Detach',
+        startTime: startTime.toISOString(),
+        endTime: endTime.toISOString(),
+        classId: testClass.id,
+      });
+
+      await user1Caller.assignment.attachToEvent({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+        eventId: event.event.id,
+      });
+
+      const result = await user1Caller.assignment.detachEvent({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+      });
+
+      expect(result.assignment).toBeDefined();
+      expect(result.assignment.eventAttached).toBeNull();
+    });
+
+    test('should fail for non-teacher', () =>
+      expectForbidden(() =>
+        user2Caller.assignment.detachEvent({
+          classId: testClass.id,
+          assignmentId: testAssignment.id,
+        })
+      ));
+  });
+
+  describe('getAvailableEvents', () => {
+    test('should return available events for assignment', async () => {
+      const result = await user1Caller.assignment.getAvailableEvents({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+      });
+
+      expect(result).toBeDefined();
+      expect(result.events).toBeDefined();
+      expect(Array.isArray(result.events)).toBe(true);
+    });
+
+    test('should fail for non-teacher', () =>
+      expectForbidden(() =>
+        user2Caller.assignment.getAvailableEvents({
+          classId: testClass.id,
+          assignmentId: testAssignment.id,
+        })
+      ));
+  });
+
+  describe('attachMarkScheme', () => {
+    test('should attach mark scheme to assignment', async () => {
+      const markScheme = await user1Caller.class.createMarkScheme({
+        classId: testClass.id,
+        structure: JSON.stringify({
+          criteria: [
+            {
+              name: 'Quality',
+              levels: [
+                { name: 'Excellent', points: 10 },
+                { name: 'Good', points: 5 },
+              ],
+            },
+          ],
+        }),
+      });
+
+      const updated = await user1Caller.assignment.attachMarkScheme({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+        markSchemeId: markScheme.id,
+      });
+
+      expect(updated.markScheme).toBeDefined();
+      expect(updated.markScheme?.id).toBe(markScheme.id);
+    });
+
+    test('should fail for non-teacher', async () => {
+      const markScheme = await user1Caller.class.createMarkScheme({
+        classId: testClass.id,
+        structure: '{}',
+      });
+
+      await expect(user2Caller.assignment.attachMarkScheme({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+        markSchemeId: markScheme.id,
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('detachMarkScheme', () => {
+    test('should detach mark scheme from assignment', async () => {
+      const markScheme = await user1Caller.class.createMarkScheme({
+        classId: testClass.id,
+        structure: '{}',
+      });
+
+      await user1Caller.assignment.attachMarkScheme({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+        markSchemeId: markScheme.id,
+      });
+
+      const updated = await user1Caller.assignment.detachMarkScheme({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+      });
+
+      expect(updated.markScheme).toBeNull();
+    });
+
+    test('should fail for non-teacher', () =>
+      expectForbidden(() =>
+        user2Caller.assignment.detachMarkScheme({
+          classId: testClass.id,
+          assignmentId: testAssignment.id,
+        })
+      ));
+  });
+
+  describe('attachGradingBoundary', () => {
+    test('should attach grading boundary to assignment', async () => {
+      const gradingBoundary = await user1Caller.class.createGradingBoundary({
+        classId: testClass.id,
+        structure: JSON.stringify({
+          boundaries: [
+            { grade: 'A', min: 90 },
+            { grade: 'B', min: 80 },
+          ],
+        }),
+      });
+
+      const updated = await user1Caller.assignment.attachGradingBoundary({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+        gradingBoundaryId: gradingBoundary.id,
+      });
+
+      expect(updated.gradingBoundary).toBeDefined();
+      expect(updated.gradingBoundary?.id).toBe(gradingBoundary.id);
+    });
+
+    test('should fail for non-teacher', async () => {
+      const gradingBoundary = await user1Caller.class.createGradingBoundary({
+        classId: testClass.id,
+        structure: '{}',
+      });
+
+      await expect(user2Caller.assignment.attachGradingBoundary({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+        gradingBoundaryId: gradingBoundary.id,
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('detachGradingBoundary', () => {
+    test('should detach grading boundary from assignment', async () => {
+      const gradingBoundary = await user1Caller.class.createGradingBoundary({
+        classId: testClass.id,
+        structure: '{}',
+      });
+
+      await user1Caller.assignment.attachGradingBoundary({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+        gradingBoundaryId: gradingBoundary.id,
+      });
+
+      const updated = await user1Caller.assignment.detachGradingBoundary({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+      });
+
+      expect(updated.gradingBoundary).toBeNull();
+    });
+
+    test('should fail for non-teacher', () =>
+      expectForbidden(() =>
+        user2Caller.assignment.detachGradingBoundary({
+          classId: testClass.id,
+          assignmentId: testAssignment.id,
+        })
+      ));
+  });
+
+  describe('reorder', () => {
+    test('teacher can reorder assignment to start', async () => {
+      const dueDate = new Date();
+      dueDate.setDate(dueDate.getDate() + 7);
+      const a2 = await user1Caller.assignment.create({
+        classId: testClass.id,
+        title: 'Second Assignment',
+        instructions: 'Test',
+        dueDate: dueDate.toISOString(),
+      });
+
+      const result = await user1Caller.assignment.reorder({
+        classId: testClass.id,
+        movedId: a2.id,
+        position: 'start',
+      });
+
+      expect(result).toBeDefined();
+      expect(result?.id).toBe(a2.id);
+    });
+
+    test('teacher can reorder assignment to end', async () => {
+      const result = await user1Caller.assignment.reorder({
+        classId: testClass.id,
+        movedId: testAssignment.id,
+        position: 'end',
+      });
+
+      expect(result).toBeDefined();
+      expect(result?.id).toBe(testAssignment.id);
+    });
+
+    test('teacher can reorder assignment before target', async () => {
+      const section = await user1Caller.section.create({
+        classId: testClass.id,
+        name: 'Section for Reorder',
+        color: '#3B82F6',
+      });
+
+      const result = await user1Caller.assignment.reorder({
+        classId: testClass.id,
+        movedId: testAssignment.id,
+        position: 'before',
+        targetId: section.id,
+      });
+
+      expect(result).toBeDefined();
+      expect(result?.id).toBe(testAssignment.id);
+    });
+
+    test('teacher can reorder assignment after target', async () => {
+      const section = await user1Caller.section.create({
+        classId: testClass.id,
+        name: 'Section for Reorder',
+        color: '#3B82F6',
+      });
+
+      const result = await user1Caller.assignment.reorder({
+        classId: testClass.id,
+        movedId: testAssignment.id,
+        position: 'after',
+        targetId: section.id,
+      });
+
+      expect(result).toBeDefined();
+      expect(result?.id).toBe(testAssignment.id);
+    });
+
+    test('non-teacher receives error', () =>
+      expectForbidden(() =>
+        user2Caller.assignment.reorder({
+          classId: testClass.id,
+          movedId: testAssignment.id,
+          position: 'start',
+        })
+      ));
+  });
+
+  describe('move', () => {
+    test('teacher can move assignment into a section', async () => {
+      const section = await user1Caller.section.create({
+        classId: testClass.id,
+        name: 'Target Section',
+        color: '#3B82F6',
+      });
+
+      const result = await user1Caller.assignment.move({
+        id: testAssignment.id,
+        classId: testClass.id,
+        targetSectionId: section.id,
+      });
+
+      expect(result).toBeDefined();
+      expect(result?.sectionId).toBe(section.id);
+    });
+
+    test('teacher can move assignment out of section', async () => {
+      const section = await user1Caller.section.create({
+        classId: testClass.id,
+        name: 'Source Section',
+        color: '#3B82F6',
+      });
+
+      await user1Caller.assignment.move({
+        id: testAssignment.id,
+        classId: testClass.id,
+        targetSectionId: section.id,
+      });
+
+      const result = await user1Caller.assignment.move({
+        id: testAssignment.id,
+        classId: testClass.id,
+        targetSectionId: null,
+      });
+
+      expect(result).toBeDefined();
+      expect(result?.sectionId).toBeNull();
+    });
+
+    test('non-teacher receives error', () =>
+      expectForbidden(() =>
+        user2Caller.assignment.move({
+          id: testAssignment.id,
+          classId: testClass.id,
+          targetSectionId: null,
+        })
+      ));
+  });
+  describe('export', () => {
+    test('should export assignment successfully', async () => {
+      const result = await user1Caller.class.exportClass({
+        classId: testClass.id,
+      });
+
+      expect(result).toBeDefined();
+      expect(result.assignments).toBeDefined();
+      expect(result.assignments.length).toBeGreaterThan(0);
+      expect(result.assignments.some((a: any) => a.id === testAssignment.id)).toBe(true);
+    });
+  });
+});
+