Fix Team Related Test Issues

backend/test/models/Answer.test.ts

@@ -13,6 +13,13 @@ beforeAll(async () => {
   } as ConnectOptions);
 });
 
+beforeEach(async () => {
+  await MultipleChoiceAnswerModel.deleteMany({});
+  await MultipleChoiceQuestionModel.deleteMany({});
+  await NUSNETIDAnswerModel.deleteMany({});
+  await NUSNETIDQuestionModel.deleteMany({});
+});
+
 afterAll(async () => {
   await mongoose.disconnect();
   await mongoServer.stop();

backend/test/models/AssessmentAssignmentSet.test.ts

@@ -4,6 +4,7 @@ import AssessmentAssignmentSetModel from '../../models/AssessmentAssignmentSet';
 import InternalAssessmentModel from '../../models/InternalAssessment';
 import TeamModel from '../../models/Team';
 import CourseModel from '@models/Course';
+import TeamSetModel from '@models/TeamSet';
 
 let mongoServer: MongoMemoryServer;
 
@@ -12,6 +13,14 @@ beforeAll(async () => {
   await mongoose.connect(mongoServer.getUri());
 });
 
+beforeEach(async () => {
+  await TeamModel.deleteMany({});
+  await InternalAssessmentModel.deleteMany({});
+  await AssessmentAssignmentSetModel.deleteMany({});
+  await CourseModel.deleteMany({});
+  await TeamSetModel.deleteMany({});
+});
+
 afterAll(async () => {
   await mongoose.disconnect();
   await mongoServer.stop();
@@ -27,14 +36,25 @@ describe('AssessmentAssignmentSet Model', () => {
       courseType: 'Normal',
     });
     await course.save();
-    const assessment = await InternalAssessmentModel.create({
+    const teamSet = new TeamSetModel({
+      name: 'Team Set 1',
+      course: course._id,
+      teams: [],
+    });
+    await teamSet.save();
+    const assessment = new InternalAssessmentModel({
       course: course._id,
-      assessmentName: 'Test Assessment',
-      description: 'A test assessment for unit tests.',
+      assessmentName: 'Midterm Exam',
+      description: 'Midterm assessment',
+      startDate: new Date(),
+      endDate: new Date(),
+      maxMarks: 100,
       granularity: 'team',
-      isReleased: true,
+      teamSet: teamSet._id,
       areSubmissionsEditable: true,
-      startDate: new Date(),
+      results: [],
+      isReleased: false,
+      questions: [],
     });
     assessment.save();
 
@@ -60,13 +80,32 @@ describe('AssessmentAssignmentSet Model', () => {
   });
 
   it('should enforce unique assessment per AssessmentAssignmentSet', async () => {
+    const course = await CourseModel.create({
+      name: 'Introduction to Computer Science',
+      code: 'CS101',
+      semester: 'Fall 2024',
+      startDate: new Date('2024-08-15'),
+      courseType: 'Normal',
+    });
+    await course.save();
+    const teamSet = new TeamSetModel({
+      name: 'Team Set 1',
+      course: course._id,
+      teams: [],
+    });
+    await teamSet.save();
+
     const assessment = new InternalAssessmentModel({
+      course: course._id,
       assessmentName: 'Final Exam',
       description: 'Final assessment',
       startDate: new Date(),
       granularity: 'team',
       areSubmissionsEditable: true,
       isReleased: false,
+      teamSet: teamSet._id,
+      results: [],
+      questions: [],
     });
     await assessment.save();
 

backend/test/models/AssessmentResult.test.ts

@@ -5,6 +5,7 @@ import InternalAssessmentModel from '../../models/InternalAssessment';
 import UserModel from '../../models/User';
 import SubmissionModel from '../../models/Submission';
 import CourseModel from '@models/Course';
+import TeamSetModel from '@models/TeamSet';
 
 let mongoServer: MongoMemoryServer;
 
@@ -13,6 +14,15 @@ beforeAll(async () => {
   await mongoose.connect(mongoServer.getUri());
 });
 
+beforeEach(async () => {
+  await InternalAssessmentModel.deleteMany({});
+  await CourseModel.deleteMany({});
+  await SubmissionModel.deleteMany({});
+  await UserModel.deleteMany({});
+  await TeamSetModel.deleteMany({});
+  await AssessmentResultModel.deleteMany({});
+});
+
 afterAll(async () => {
   await mongoose.disconnect();
   await mongoServer.stop();
@@ -28,16 +38,28 @@ describe('AssessmentResult Model', () => {
       courseType: 'Normal',
     });
     await course.save();
-    const assessment = await InternalAssessmentModel.create({
+
+    const teamSet = new TeamSetModel({
+      name: 'Team Set 1',
+      course: course._id,
+      teams: [],
+    });
+    await teamSet.save();
+
+    const assessment = new InternalAssessmentModel({
       course: course._id,
-      assessmentName: 'Test Assessment',
-      description: 'A test assessment for unit tests.',
+      assessmentName: 'Midterm Exam',
+      description: 'Midterm assessment',
+      startDate: new Date(),
+      endDate: new Date(),
+      maxMarks: 100,
       granularity: 'team',
-      isReleased: true,
+      teamSet: teamSet._id,
       areSubmissionsEditable: true,
-      startDate: new Date(),
+      results: [],
+      isReleased: false,
+      questions: [],
     });
-    assessment.save();
 
     const student = new UserModel({
       identifier: 'student1',

backend/test/models/InternalAssessment.test.ts

@@ -11,6 +11,12 @@ beforeAll(async () => {
   await mongoose.connect(mongoServer.getUri());
 });
 
+beforeEach(async () => {
+  await InternalAssessmentModel.deleteMany({});
+  await CourseModel.deleteMany({});
+  await TeamSetModel.deleteMany({});
+});
+
 afterAll(async () => {
   await mongoose.disconnect();
   await mongoServer.stop();
@@ -30,6 +36,7 @@ describe('InternalAssessment Model', () => {
     const teamSet = new TeamSetModel({
       name: 'Team Set 1',
       course: course._id,
+      teams: [],
     });
     await teamSet.save();
 

backend/test/models/Submission.test.ts

@@ -7,6 +7,7 @@ import QuestionModel from '../../models/Question';
 import { CourseType } from '@shared/types/Course';
 import CourseModel from '@models/Course';
 import { NUSNETIDAnswerModel } from '@models/Answer';
+import TeamSetModel from '@models/TeamSet';
 
 let mongoServer: MongoMemoryServer;
 
@@ -15,6 +16,16 @@ beforeAll(async () => {
   await mongoose.connect(mongoServer.getUri());
 });
 
+beforeEach(async () => {
+  await InternalAssessmentModel.deleteMany({});
+  await UserModel.deleteMany({});
+  await QuestionModel.deleteMany({});
+  await CourseModel.deleteMany({});
+  await TeamSetModel.deleteMany({});
+  await NUSNETIDAnswerModel.deleteMany({});
+  await SubmissionModel.deleteMany({});
+});
+
 afterAll(async () => {
   await mongoose.disconnect();
   await mongoServer.stop();
@@ -27,6 +38,7 @@ describe('Submission Model', () => {
       name: 'Student One',
     });
     await user.save();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const courseData: any = {
       name: 'Test Course',
       code: 'COURSE101',
@@ -37,16 +49,26 @@ describe('Submission Model', () => {
 
     const course = new CourseModel(courseData);
 
-    const savedCourse = await course.save();
+    const teamSet = new TeamSetModel({
+      name: 'Team Set 1',
+      course: course._id,
+      teams: [],
+    });
+    await teamSet.save();
 
     const assessment = new InternalAssessmentModel({
-      assessmentName: 'Quiz 1',
-      description: 'First quiz',
+      course: course._id,
+      assessmentName: 'Midterm Exam',
+      description: 'Midterm assessment',
       startDate: new Date(),
-      granularity: 'individual',
+      endDate: new Date(),
+      maxMarks: 100,
+      granularity: 'team',
+      teamSet: teamSet._id,
       areSubmissionsEditable: true,
+      results: [],
       isReleased: false,
-      course: savedCourse._id,
+      questions: [],
     });
     await assessment.save();
 

backend/test/services/assessmentResultService.test.ts

@@ -13,6 +13,8 @@ import {
 } from '../../services/assessmentResultService';
 import { BadRequestError, NotFoundError } from '../../services/errors';
 import CourseModel from '@models/Course';
+import TeamModel from '@models/Team';
+import TeamSetModel from '@models/TeamSet';
 
 let mongo: MongoMemoryServer;
 
@@ -49,17 +51,6 @@ describe('assessmentResultService', () => {
       courseType: 'Normal',
     });
     await course.save();
-    const assessment = await InternalAssessmentModel.create({
-      course: course._id,
-      assessmentName: 'Test Assessment',
-      description: 'A test assessment for unit tests.',
-      granularity: 'team',
-      isReleased: true,
-      areSubmissionsEditable: true,
-      startDate: new Date(),
-    });
-    assessmentId = assessment._id;
-    assessment.save();
 
     const student = await UserModel.create({
       identifier: 'studentUser',
@@ -72,12 +63,37 @@ describe('assessmentResultService', () => {
       name: 'Test TA',
     });
     taId = ta._id;
+    const team = new TeamModel({
+      number: 1,
+      members: [student],
+      TA: ta,
+    });
+    await team.save();
+
+    const teamSet = new TeamSetModel({
+      name: 'Team Set 1',
+      course: course._id,
+      teams: [team],
+    });
+    await teamSet.save();
 
     const assignmentSet = await AssessmentAssignmentSetModel.create({
       assessment: assessmentId,
       assignedUsers: [{ user: studentId, tas: [taId] }],
     });
-    assessment.assessmentAssignmentSet = assignmentSet._id;
+    await assignmentSet.save()
+    const assessment = await InternalAssessmentModel.create({
+      course: course._id,
+      assessmentName: 'Test Assessment',
+      description: 'A test assessment for unit tests.',
+      granularity: 'team',
+      teamSet: teamSet,
+      assessmentAssignmentSet: assignmentSet,
+      isReleased: true,
+      areSubmissionsEditable: true,
+      startDate: new Date(),
+    });
+    assessmentId = assessment._id;
     await assessment.save();
   });