Merge pull request #720 from freeCodeCamp/main

Create a new pull request by comparing changes across two branches

Author: GulajavaMinistudio

api/__mocks__/env-exam.ts

@@ -338,7 +338,8 @@ export const examAttemptSansSubmissionTimeInMS: Static<
 export const exam: EnvExam = {
   id: examId,
   config,
-  questionSets
+  questionSets,
+  prerequisites: ['67112fe1c994faa2c26d0b1d']
 };
 
 export async function seedEnvExam() {

api/jest.utils.ts

@@ -207,6 +207,11 @@ export const defaultUserEmail = '[email protected]';
 export const defaultUsername = 'fcc-test-user';
 
 export const resetDefaultUser = async (): Promise<void> => {
+  await fastifyTestInstance.prisma.examEnvironmentAuthorizationToken.deleteMany(
+    {
+      where: { userId: defaultUserId }
+    }
+  );
   await fastifyTestInstance.prisma.user.deleteMany({
     where: { email: defaultUserEmail }
   });

api/package.json

@@ -25,7 +25,7 @@
     "joi": "17.12.2",
     "jsonwebtoken": "9.0.2",
     "lodash": "4.17.21",
-    "mongodb": "4.17.2",
+    "mongodb": "6.10.0",
     "nanoid": "3",
     "no-profanity": "1.5.1",
     "nodemailer": "6.9.10",

api/prisma/schema.prisma

@@ -143,19 +143,22 @@ model user {
   isClassroomAccount           Boolean? // Undefined
 
   // Relations
-  examAttempts EnvExamAttempt[]
+  examAttempts                      EnvExamAttempt[]
+  examEnvironmentAuthorizationToken ExamEnvironmentAuthorizationToken?
 }
 
 // -----------------------------------
 
 /// An exam for the Exam Environment App as designed by the examiners
 model EnvExam {
   /// Globally unique exam id
-  id           String           @id @default(auto()) @map("_id") @db.ObjectId
+  id            String           @id @default(auto()) @map("_id") @db.ObjectId
   /// All questions for a given exam
-  questionSets EnvQuestionSet[]
+  questionSets  EnvQuestionSet[]
   /// Configuration for exam metadata
-  config       EnvConfig
+  config        EnvConfig
+  /// ObjectIds for required challenges/blocks to take the exam
+  prerequisites String[]         @db.ObjectId
 
   // Relations
   generatedExams EnvGeneratedExam[]
@@ -375,15 +378,13 @@ model UserToken {
   @@index([userId], map: "userId_1")
 }
 
-/// TODO: Token has to outlive the exam attempt
-/// Validation has to be taken as the attempt is requested
-/// to ensure it lives long enough.
 model ExamEnvironmentAuthorizationToken {
   id          String   @id @map("_id")
   createdDate DateTime @db.Date
-  userId      String   @db.ObjectId
+  userId      String   @unique @db.ObjectId
 
-  @@index([userId], map: "userId_1")
+  // Relations
+  user user @relation(fields: [userId], references: [id])
 }
 
 model sessions {

api/src/app.ts

@@ -106,6 +106,7 @@ export const build = async (
   if (FCC_ENABLE_SWAGGER_UI) {
     void fastify.register(fastifySwagger, {
       openapi: {
+        openapi: '3.1.0',
         info: {
           title: 'freeCodeCamp API',
           version: '1.0.0' // API version

api/src/exam-environment/routes/exam-environment.test.ts

@@ -240,6 +240,15 @@ describe('/exam-environment/', () => {
     describe('POST /exam-environment/generated-exam', () => {
       afterEach(async () => {
         await fastifyTestInstance.prisma.envExamAttempt.deleteMany();
+        // Add prerequisite id to user completed challenge
+        await fastifyTestInstance.prisma.user.update({
+          where: { id: defaultUserId },
+          data: {
+            completedChallenges: [
+              { id: mock.exam.prerequisites.at(0)!, completedDate: Date.now() }
+            ]
+          }
+        });
         await mock.seedEnvExam();
       });
 
@@ -262,8 +271,30 @@ describe('/exam-environment/', () => {
         expect(res.status).toBe(404);
       });
 
-      xit('should return an error if the exam prerequisites are not met', async () => {
-        // TODO: Waiting on prerequisites
+      it('should return an error if the exam prerequisites are not met', async () => {
+        await fastifyTestInstance.prisma.user.update({
+          where: { id: defaultUserId },
+          data: {
+            completedChallenges: []
+          }
+        });
+
+        const body: Static<typeof examEnvironmentPostExamGeneratedExam.body> = {
+          examId: mock.exam.id
+        };
+        const res = await superPost('/exam-environment/exam/generated-exam')
+          .send(body)
+          .set(
+            'exam-environment-authorization-token',
+            examEnvironmentAuthorizationToken
+          );
+
+        expect(res.body).toStrictEqual({
+          code: 'FCC_EINVAL_EXAM_ENVIRONMENT_PREREQUISITES',
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          message: expect.any(String)
+        });
+        expect(res.status).toBe(403);
       });
 
       it('should return an error if the exam has been attempted in the last 24 hours', async () => {

api/src/exam-environment/routes/exam-environment.ts

@@ -107,7 +107,7 @@ async function tokenVerifyHandler(
   const examEnvironmentAuthorizationToken =
     payload.examEnvironmentAuthorizationToken;
 
-  const token = await this.prisma.examEnvironmentAuthorizationToken.findFirst({
+  const token = await this.prisma.examEnvironmentAuthorizationToken.findUnique({
     where: {
       id: examEnvironmentAuthorizationToken
     }
@@ -170,7 +170,7 @@ async function postExamGeneratedExamHandler(
 
   // Check user has completed prerequisites
   const user = req.user!;
-  const isExamPrerequisitesMet = checkPrerequisites(user, true);
+  const isExamPrerequisitesMet = checkPrerequisites(user, exam.prerequisites);
 
   if (!isExamPrerequisitesMet) {
     void reply.code(403);
@@ -582,12 +582,13 @@ async function getExams(
   const exams = await this.prisma.envExam.findMany({
     select: {
       id: true,
-      config: true
+      config: true,
+      prerequisites: true
     }
   });
 
   const availableExams = exams.map(exam => {
-    const isExamPrerequisitesMet = checkPrerequisites(user, true);
+    const isExamPrerequisitesMet = checkPrerequisites(user, exam.prerequisites);
 
     return {
       id: exam.id,

api/src/exam-environment/utils/exam.test.ts

@@ -3,6 +3,7 @@ import { exam, examAttempt, generatedExam } from '../../../__mocks__/env-exam';
 import * as schemas from '../schemas';
 import {
   checkAttemptAgainstGeneratedExam,
+  checkPrerequisites,
   constructUserExam,
   generateExam,
   userAttemptToDatabaseAttemptQuestionSets,
@@ -56,9 +57,27 @@ describe('Exam Environment', () => {
       ).toBe(false);
     });
   });
-  xdescribe('checkPrequisites()', () => {
-    // TODO: Awaiting implementation
+
+  describe('checkPrequisites()', () => {
+    it("should return true if all items in the second argument exist in the first argument's `.completedChallenges[].id`", () => {
+      const user = {
+        completedChallenges: [{ id: '1' }, { id: '2' }]
+      };
+      const prerequisites = ['1', '2'];
+
+      expect(checkPrerequisites(user, prerequisites)).toBe(true);
+    });
+
+    it("should return false if any items in the second argument do not exist in the first argument's `.completedChallenges[].id`", () => {
+      const user = {
+        completedChallenges: [{ id: '2' }]
+      };
+      const prerequisites = ['1', '2'];
+
+      expect(checkPrerequisites(user, prerequisites)).toBe(false);
+    });
   });
+
   describe('constructUserExam()', () => {
     it('should not provide the answers', () => {
       const userExam = constructUserExam(generatedExam, exam);

api/src/exam-environment/utils/exam.ts

@@ -7,22 +7,33 @@ import {
   EnvGeneratedExam,
   EnvMultipleChoiceQuestion,
   EnvQuestionSet,
-  EnvQuestionSetAttempt,
-  user
+  EnvQuestionSetAttempt
 } from '@prisma/client';
 import { type Static } from '@fastify/type-provider-typebox';
 import * as schemas from '../schemas';
 
+interface CompletedChallengeId {
+  completedChallenges: {
+    id: string;
+  }[];
+}
+
 /**
  * Checks if all exam prerequisites have been met by the user.
- *
- * TODO: This will be done by getting the challenges required from the curriculum.
  */
-export function checkPrerequisites(_user: user, _prerequisites: unknown) {
-  return true;
+export function checkPrerequisites(
+  user: CompletedChallengeId,
+  prerequisites: EnvExam['prerequisites']
+) {
+  return prerequisites.every(p =>
+    user.completedChallenges.some(c => c.id === p)
+  );
 }
 
-export type UserExam = Omit<EnvExam, 'questionSets' | 'config' | 'id'> & {
+export type UserExam = Omit<
+  EnvExam,
+  'questionSets' | 'config' | 'id' | 'prerequisites'
+> & {
   config: Omit<EnvExam['config'], 'tags' | 'questionSets'>;
   questionSets: (Omit<EnvQuestionSet, 'questions'> & {
     questions: (Omit<

api/src/routes/protected/user.test.ts

@@ -16,6 +16,7 @@ import {
   createSuperRequest
 } from '../../../jest.utils';
 import { JWT_SECRET } from '../../utils/env';
+import { customNanoid } from '../../utils/ids';
 import { getMsTranscriptApiUrl } from './user';
 
 const mockedFetch = jest.fn();
@@ -564,6 +565,11 @@ describe('userRoutes', () => {
         await fastifyTestInstance.prisma.userToken.deleteMany({
           where: { id: userTokenId }
         });
+        await fastifyTestInstance.prisma.examEnvironmentAuthorizationToken.deleteMany(
+          {
+            where: { userId: defaultUserId }
+          }
+        );
       });
 
       test('GET rejects with 500 status code if the username is missing', async () => {
@@ -1130,6 +1136,72 @@ Thanks and regards,
         });
       });
     });
+
+    describe('/user/exam-environment/token', () => {
+      afterEach(async () => {
+        await fastifyTestInstance.prisma.examEnvironmentAuthorizationToken.deleteMany(
+          {
+            where: { userId: defaultUserId }
+          }
+        );
+      });
+
+      test('POST generates a new token if one does not exist', async () => {
+        const response = await superPost('/user/exam-environment/token');
+        const { examEnvironmentAuthorizationToken } = response.body.data;
+
+        const decodedToken = jwt.decode(examEnvironmentAuthorizationToken);
+
+        expect(decodedToken).toStrictEqual({
+          examEnvironmentAuthorizationToken:
+            expect.stringMatching(/^[a-zA-Z0-9]{64}$/),
+          iat: expect.any(Number)
+        });
+
+        expect(() =>
+          jwt.verify(examEnvironmentAuthorizationToken, 'wrong-secret')
+        ).toThrow();
+        expect(() =>
+          jwt.verify(examEnvironmentAuthorizationToken, JWT_SECRET)
+        ).not.toThrow();
+
+        expect(response.status).toBe(200);
+      });
+
+      test('POST only allows for one token per user id', async () => {
+        const id = customNanoid();
+        await fastifyTestInstance.prisma.examEnvironmentAuthorizationToken.create(
+          {
+            data: {
+              userId: defaultUserId,
+              id,
+              createdDate: new Date()
+            }
+          }
+        );
+
+        const response = await superPost('/user/exam-environment/token');
+
+        const { examEnvironmentAuthorizationToken } = response.body.data;
+
+        const decodedToken = jwt.decode(examEnvironmentAuthorizationToken);
+
+        expect(decodedToken).not.toHaveProperty(
+          'examEnvironmentAuthorizationToken',
+          id
+        );
+
+        expect(response.status).toBe(200);
+
+        const tokens =
+          await fastifyTestInstance.prisma.examEnvironmentAuthorizationToken.findMany(
+            {
+              where: { userId: defaultUserId }
+            }
+          );
+        expect(tokens).toHaveLength(1);
+      });
+    });
   });
 
   describe('Unauthenticated user', () => {