Merge branch 'freeCodeCamp:main' into main

Author: GauravSharmaCode

api/package.json

@@ -8,19 +8,20 @@
     "@fastify/accepts": "4.3.0",
     "@fastify/cookie": "9.4.0",
     "@fastify/csrf-protection": "6.4.1",
+    "@fastify/multipart": "^8.3.0",
     "@fastify/oauth2": "7.8.1",
     "@fastify/swagger": "8.14.0",
     "@fastify/swagger-ui": "1.10.2",
     "@fastify/type-provider-typebox": "3.6.0",
     "@growthbook/growthbook": "1.3.1",
-    "@immobiliarelabs/fastify-sentry": "7.1.1",
     "@prisma/client": "5.5.2",
+    "@sentry/node": "9.1.0",
     "ajv": "8.12.0",
     "ajv-formats": "2.1.1",
     "date-fns": "2.30.0",
     "dotenv": "16.4.5",
     "fast-uri": "2.3.0",
-    "fastify": "4.26.1",
+    "fastify": "4.29.0",
     "fastify-plugin": "4.5.1",
     "joi": "17.12.2",
     "jsonwebtoken": "9.0.2",
@@ -44,6 +45,7 @@
     "@types/validator": "13.11.2",
     "dotenv-cli": "7.3.0",
     "jest": "29.7.0",
+    "msw": "^2.7.0",
     "prisma": "5.5.2",
     "supertest": "6.3.3",
     "ts-jest": "29.1.2",

api/src/app.ts

@@ -47,6 +47,7 @@ import {
 } from './utils/env';
 import { isObjectID } from './utils/validation';
 import {
+  examEnvironmentMultipartRoutes,
   examEnvironmentOpenRoutes,
   examEnvironmentValidatedTokenRoutes
 } from './exam-environment/routes/exam-environment';
@@ -209,6 +210,7 @@ export const build = async (
       fastify.addHook('onRequest', fastify.authorizeExamEnvironmentToken);
 
       void fastify.register(examEnvironmentValidatedTokenRoutes);
+      void fastify.register(examEnvironmentMultipartRoutes);
       done();
     });
     void fastify.register(examEnvironmentOpenRoutes);

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

@@ -2,6 +2,7 @@ import { Static } from '@fastify/type-provider-typebox';
 import jwt from 'jsonwebtoken';
 
 import {
+  createFetchMock,
   createSuperRequest,
   defaultUserId,
   devLogin,
@@ -562,7 +563,98 @@ describe('/exam-environment/', () => {
       });
     });
 
-    xdescribe('POST /exam-environment/screenshot', () => {});
+    describe('POST /exam-environment/screenshot', () => {
+      afterEach(async () => {
+        await fastifyTestInstance.prisma.envExamAttempt.deleteMany();
+      });
+
+      it('should return 400 if request is not multipart form data', async () => {
+        const res = await superPost('/exam-environment/screenshot').set(
+          'exam-environment-authorization-token',
+          examEnvironmentAuthorizationToken
+        );
+
+        expect(res.status).toBe(400);
+        expect(res.body).toStrictEqual({
+          code: 'FCC_EINVAL_EXAM_ENVIRONMENT_SCREENSHOT',
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          message: expect.any(String)
+        });
+      });
+
+      it('should return 400 if image is missing', async () => {
+        const res = await superPost('/exam-environment/screenshot')
+          .set(
+            'exam-environment-authorization-token',
+            examEnvironmentAuthorizationToken
+          )
+          .attach('file', '');
+
+        expect(res.status).toBe(400);
+        expect(res.body).toStrictEqual({
+          code: 'FCC_EINVAL_EXAM_ENVIRONMENT_SCREENSHOT',
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          message: expect.any(String)
+        });
+      });
+
+      it('should return 404 if there is no ongoing exam attempt', async () => {
+        const res = await superPost('/exam-environment/screenshot')
+          .set(
+            'exam-environment-authorization-token',
+            examEnvironmentAuthorizationToken
+          )
+          .attach('file', Buffer.from([]));
+
+        expect(res.status).toBe(404);
+        expect(res.body).toStrictEqual({
+          code: 'FCC_ERR_EXAM_ENVIRONMENT_EXAM_ATTEMPT',
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          message: expect.any(String)
+        });
+      });
+
+      it('should return 400 if image is of wrong format', async () => {
+        await fastifyTestInstance.prisma.envExamAttempt.create({
+          data: mock.examAttempt
+        });
+
+        const res = await superPost('/exam-environment/screenshot')
+          .set(
+            'exam-environment-authorization-token',
+            examEnvironmentAuthorizationToken
+          )
+          .attach('file', Buffer.from([]));
+
+        expect(res.status).toBe(400);
+        expect(res.body).toStrictEqual({
+          code: 'FCC_EINVAL_EXAM_ENVIRONMENT_SCREENSHOT',
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          message: expect.any(String)
+        });
+      });
+
+      it('should return 200 if request is valid and send image to screenshot upload service', async () => {
+        // Mock image upload service response
+        const imageUploadRes = createFetchMock({ ok: true });
+        jest.spyOn(globalThis, 'fetch').mockImplementation(imageUploadRes);
+
+        await fastifyTestInstance.prisma.envExamAttempt.create({
+          data: mock.examAttempt
+        });
+
+        const res = await superPost('/exam-environment/screenshot')
+          .set(
+            'exam-environment-authorization-token',
+            examEnvironmentAuthorizationToken
+          )
+          .attach('file', Buffer.from([0xff, 0xd8, 0xff, 0xff]));
+
+        expect(res.status).toBe(200);
+        expect(res.body).toStrictEqual({});
+        expect(globalThis.fetch).toHaveBeenCalled();
+      });
+    });
 
     describe('GET /exam-environment/exams', () => {
       it('should return 200', async () => {

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

@@ -1,12 +1,13 @@
 /* eslint-disable jsdoc/require-returns, jsdoc/require-param */
 import { type FastifyPluginCallbackTypebox } from '@fastify/type-provider-typebox';
+import fastifyMultipart from '@fastify/multipart';
 import { PrismaClientValidationError } from '@prisma/client/runtime/library';
 import { type FastifyInstance, type FastifyReply } from 'fastify';
 import jwt from 'jsonwebtoken';
 
 import * as schemas from '../schemas';
 import { mapErr, syncMapErr, UpdateReqType } from '../../utils';
-import { JWT_SECRET } from '../../utils/env';
+import { JWT_SECRET, SCREENSHOT_SERVICE_LOCATION } from '../../utils/env';
 import {
   checkPrerequisites,
   constructUserExam,
@@ -44,16 +45,32 @@ export const examEnvironmentValidatedTokenRoutes: FastifyPluginCallbackTypebox =
       },
       postExamAttemptHandler
     );
-    fastify.post(
-      '/exam-environment/screenshot',
-      {
-        schema: schemas.examEnvironmentPostScreenshot
-      },
-      postScreenshotHandler
-    );
     done();
   };
 
+/**
+ * Wrapper for endpoints related to the exam environment desktop app.
+ *
+ * Requires multipart form data to be supported.
+ */
+export const examEnvironmentMultipartRoutes: FastifyPluginCallbackTypebox = (
+  fastify,
+  _options,
+  done
+) => {
+  void fastify.register(fastifyMultipart);
+
+  fastify.post(
+    '/exam-environment/screenshot',
+    {
+      schema: schemas.examEnvironmentPostScreenshot
+      // bodyLimit: 1024 * 1024 * 5 // 5MiB
+    },
+    postScreenshotHandler
+  );
+  done();
+};
+
 /**
  * Wrapper for endpoints related to the exam environment desktop app.
  *
@@ -544,10 +561,80 @@ async function postExamAttemptHandler(
  */
 async function postScreenshotHandler(
   this: FastifyInstance,
-  _req: UpdateReqType<typeof schemas.examEnvironmentPostScreenshot>,
+  req: UpdateReqType<typeof schemas.examEnvironmentPostScreenshot>,
   reply: FastifyReply
 ) {
-  return reply.code(418);
+  const isMultipart = req.isMultipart();
+
+  if (!isMultipart) {
+    void reply.code(400);
+    return reply.send(
+      ERRORS.FCC_EINVAL_EXAM_ENVIRONMENT_SCREENSHOT(
+        'Request is not multipart form data.'
+      )
+    );
+  }
+
+  const user = req.user!;
+  const imgData = await req.file();
+
+  if (!imgData) {
+    void reply.code(400);
+    return reply.send(
+      ERRORS.FCC_EINVAL_EXAM_ENVIRONMENT_SCREENSHOT('No image provided.')
+    );
+  }
+
+  const maybeAttempt = await mapErr(
+    this.prisma.envExamAttempt.findMany({
+      where: {
+        userId: user.id
+      }
+    })
+  );
+
+  if (maybeAttempt.hasError) {
+    void reply.code(500);
+    return reply.send(
+      ERRORS.FCC_ERR_EXAM_ENVIRONMENT(JSON.stringify(maybeAttempt.error))
+    );
+  }
+
+  const attempt = maybeAttempt.data;
+
+  if (attempt.length === 0) {
+    void reply.code(404);
+    return reply.send(
+      ERRORS.FCC_ERR_EXAM_ENVIRONMENT_EXAM_ATTEMPT(
+        `No exam attempts found for user '${user.id}'.`
+      )
+    );
+  }
+
+  const imgBinary = await imgData.toBuffer();
+
+  // Verify image is JPG using magic number
+  if (imgBinary[0] !== 0xff || imgBinary[1] !== 0xd8 || imgBinary[2] !== 0xff) {
+    void reply.code(400);
+    return reply.send(
+      ERRORS.FCC_EINVAL_EXAM_ENVIRONMENT_SCREENSHOT('Invalid image format.')
+    );
+  }
+
+  void reply.code(200).send();
+
+  const uploadData = {
+    image: imgBinary.toString('base64'),
+    examAttemptId: attempt[0]?.id
+  };
+
+  await fetch(`${SCREENSHOT_SERVICE_LOCATION}/upload`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify(uploadData)
+  });
 }
 
 async function getExams(

api/src/exam-environment/schemas/screenshot.ts

@@ -1,7 +1,12 @@
-// import { Type } from '@fastify/type-provider-typebox';
+import { Type } from '@fastify/type-provider-typebox';
+import { STANDARD_ERROR } from '../utils/errors';
 
 export const examEnvironmentPostScreenshot = {
+  headers: Type.Object({
+    'exam-environment-authorization-token': Type.String()
+  }),
   response: {
-    // 200: Type.Object({})
+    400: STANDARD_ERROR,
+    500: STANDARD_ERROR
   }
 };

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

@@ -35,7 +35,11 @@ export const ERRORS = {
     'FCC_ENOENT_EXAM_ENVIRONMENT_GENERATED_EXAM',
     '%s'
   ),
-  FCC_EINVAL_EXAM_ID: createError('FCC_EINVAL_EXAM_ID', '%s')
+  FCC_EINVAL_EXAM_ID: createError('FCC_EINVAL_EXAM_ID', '%s'),
+  FCC_EINVAL_EXAM_ENVIRONMENT_SCREENSHOT: createError(
+    'FCC_EINVAL_EXAM_ENVIRONMENT_SCREENSHOT',
+    '%s'
+  )
 };
 
 /**

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

@@ -428,26 +428,24 @@ export function generateExam(exam: EnvExam): Omit<EnvGeneratedExam, 'id'> {
         const questionSet = shuffledQuestionSets.find(qs => {
           if (qs.type === questionSetConfig.type) {
             if (qs.questions.length >= questionSetConfig.numberOfQuestions) {
-              if (qs.questions.length >= questionSetConfig.numberOfQuestions) {
-                // Find questionSetConfig.numberOfQuestions who have `questionSetConfig.numberOfCorrectAnswers` and `questionSetConfig.numberOfIncorrectAnswers`
-                const questions = qs.questions.filter(q => {
-                  const numberOfCorrectAnswers = q.answers.filter(
-                    a => a.isCorrect
-                  ).length;
-                  const numberOfIncorrectAnswers = q.answers.filter(
-                    a => !a.isCorrect
-                  ).length;
-                  return (
-                    numberOfCorrectAnswers >=
-                      questionSetConfig.numberOfCorrectAnswers &&
-                    numberOfIncorrectAnswers >=
-                      questionSetConfig.numberOfIncorrectAnswers
-                  );
-                });
-
-                if (questions.length >= questionSetConfig.numberOfQuestions) {
-                  return true;
-                }
+              // Find questionSetConfig.numberOfQuestions who have `questionSetConfig.numberOfCorrectAnswers` and `questionSetConfig.numberOfIncorrectAnswers`
+              const questions = qs.questions.filter(q => {
+                const numberOfCorrectAnswers = q.answers.filter(
+                  a => a.isCorrect
+                ).length;
+                const numberOfIncorrectAnswers = q.answers.filter(
+                  a => !a.isCorrect
+                ).length;
+                return (
+                  numberOfCorrectAnswers >=
+                    questionSetConfig.numberOfCorrectAnswers &&
+                  numberOfIncorrectAnswers >=
+                    questionSetConfig.numberOfIncorrectAnswers
+                );
+              });
+
+              if (questions.length >= questionSetConfig.numberOfQuestions) {
+                return true;
               }
             }
           }

api/src/instrument.ts

@@ -0,0 +1,17 @@
+import * as Sentry from '@sentry/node';
+import type { FastifyError } from 'fastify';
+
+import { SENTRY_DSN, SENTRY_ENVIRONMENT } from './utils/env';
+
+const shouldIgnoreError = (error: FastifyError): boolean => {
+  return !!error.statusCode && error.statusCode < 500;
+};
+
+// Ensure to call this before importing any other modules!
+Sentry.init({
+  dsn: SENTRY_DSN,
+  environment: SENTRY_ENVIRONMENT,
+  maxValueLength: 8192, // the default is 250, which is too small.
+  beforeSend: (event, hint) =>
+    shouldIgnoreError(hint.originalException as FastifyError) ? null : event
+});