Merge pull request #96 from guanquann/code-execution

Code execution + bug fix + unit test + submit/end session

Author: ruiqi7

backend/code-execution-service/.env.sample

@@ -5,4 +5,6 @@ ORIGINS=http://localhost:5173,http://127.0.0.1:5173
 
 # One Compiler 
 ONE_COMPILER_URL=https://onecompiler-apis.p.rapidapi.com/api/v1/run
-ONE_COMPILER_KEY=<ONE_COMPILER_KEY>
+ONE_COMPILER_KEY=<ONE_COMPILER_KEY>
+
+QUESTION_SERVICE_URL=http://question-service:3000/api/questions

backend/code-execution-service/src/controllers/codeExecutionControllers.ts

@@ -7,7 +7,10 @@ import {
   ERROR_FAILED_TO_EXECUTE_MESSAGE,
   ERROR_NOT_SAME_LENGTH_MESSAGE,
   SUCCESS_MESSAGE,
+  ERROR_INVALID_TEST_CASES_MESSAGE,
 } from "../utils/constants";
+import { questionService } from "../utils/questionApi";
+import { testCasesApi } from "../utils/testCasesApi";
 
 interface CompilerResult {
   status: string;
@@ -19,14 +22,9 @@ interface CompilerResult {
 }
 
 export const executeCode = async (req: Request, res: Response) => {
-  const {
-    language,
-    code,
-    stdinList,
-    stdoutList: expectedStdoutList,
-  } = req.body;
+  const { questionId, language, code } = req.body;
 
-  if (!language || !code || !stdinList || !expectedStdoutList) {
+  if (!language || !code || !questionId) {
     res.status(400).json({
       message: ERROR_MISSING_REQUIRED_FIELDS_MESSAGE,
     });
@@ -40,48 +38,71 @@ export const executeCode = async (req: Request, res: Response) => {
     return;
   }
 
-  if (stdinList.length !== expectedStdoutList.length) {
-    res.status(400).json({
-      message: ERROR_NOT_SAME_LENGTH_MESSAGE,
-    });
-    return;
-  }
-
   try {
-    const response = await oneCompilerApi(language, stdinList, code);
+    // Get question test case files
+    const qnsResponse = await questionService.get(`/${questionId}`);
+    const { testcaseInputFileUrl, testcaseOutputFileUrl } =
+      qnsResponse.data.question;
 
-    const data = (response.data as CompilerResult[]).map((result, index) => {
-      const {
-        status,
-        exception,
-        stdout: actualStdout,
-        stderr,
-        stdin,
-        executionTime,
-      } = result;
-      const expectedStdout = expectedStdoutList[index];
+    // Extract test cases from input and output files
+    const testCases = await testCasesApi(
+      testcaseInputFileUrl,
+      testcaseOutputFileUrl
+    );
 
-      return {
-        status,
-        exception,
-        expectedStdout,
-        actualStdout,
-        stderr,
-        stdin,
-        executionTime,
-        isMatch:
-          stderr !== null
-            ? false
-            : actualStdout.trim() === expectedStdout.trim(),
-      };
-    });
+    const stdinList: string[] = testCases.input;
+    const expectedResultList: string[] = testCases.output;
+
+    if (stdinList.length !== expectedResultList.length) {
+      res.status(400).json({
+        message: ERROR_NOT_SAME_LENGTH_MESSAGE,
+      });
+      return;
+    }
+
+    if (stdinList.length === 0) {
+      res.status(400).json({
+        message: ERROR_INVALID_TEST_CASES_MESSAGE,
+      });
+      return;
+    }
+
+    // Execute code for each test case
+    const compilerResponse = await oneCompilerApi(language, stdinList, code);
+
+    const compilerData = (compilerResponse.data as CompilerResult[]).map(
+      (result, index) => {
+        let { stdout, ...restofResult } = result; // eslint-disable-line
+        const expectedResultValue = expectedResultList[index].trim();
+
+        if (!stdout) {
+          stdout = "";
+        }
+
+        // Extract the last line as the result value
+        // and the rest as stdout
+        const lines = stdout.trim().split("\n");
+        const resultValue = lines.pop() || "";
+        stdout = lines.join("\n");
+
+        return {
+          ...restofResult,
+          stdout,
+          actualResult: resultValue,
+          expectedResult: expectedResultValue,
+          isMatch:
+            result.stderr !== null
+              ? false
+              : resultValue === expectedResultValue,
+        };
+      }
+    );
 
     res.status(200).json({
       message: SUCCESS_MESSAGE,
-      data,
+      data: compilerData,
     });
-  } catch (err) {
-    console.log(err);
+  } catch {
     res.status(500).json({ message: ERROR_FAILED_TO_EXECUTE_MESSAGE });
   }
 };

backend/code-execution-service/src/utils/constants.ts

@@ -1,7 +1,7 @@
 export const SUPPORTED_LANGUAGES = ["python", "java", "c"];
 
 export const ERROR_MISSING_REQUIRED_FIELDS_MESSAGE =
-  "Missing required fields: language, code, stdinList, or stdoutList";
+  "Missing required fields: language, code, or questionId.";
 
 export const ERROR_UNSUPPORTED_LANGUAGE_MESSAGE = "Unsupported language.";
 
@@ -11,3 +11,5 @@ export const ERROR_NOT_SAME_LENGTH_MESSAGE =
 export const ERROR_FAILED_TO_EXECUTE_MESSAGE = "Failed to execute code";
 
 export const SUCCESS_MESSAGE = "Code executed successfully";
+
+export const ERROR_INVALID_TEST_CASES_MESSAGE = "Invalid test cases";

backend/code-execution-service/src/utils/oneCompilerApi.ts

@@ -10,7 +10,7 @@ interface FileType {
 
 export const oneCompilerApi = async (
   language: string,
-  stdin: string,
+  stdin: string[],
   userCode: string
 ) => {
   let files: FileType[] = [];

backend/code-execution-service/src/utils/questionApi.ts

@@ -0,0 +1,12 @@
+import axios from "axios";
+
+const QUESTION_SERVICE_URL =
+  process.env.QUESTION_SERVICE_URL ||
+  "http://question-service:3000/api/questions";
+
+export const questionService = axios.create({
+  baseURL: QUESTION_SERVICE_URL,
+  headers: {
+    "Content-Type": "application/json",
+  },
+});

backend/code-execution-service/src/utils/testCasesApi.ts

@@ -0,0 +1,20 @@
+import axios from "axios";
+
+export const testCasesApi = async (
+  inputFileUrl: string,
+  outputFileUrl: string
+) => {
+  try {
+    const inputFileUrlResponse = await axios.get(inputFileUrl);
+    const outputFileUrlResponse = await axios.get(outputFileUrl);
+
+    // Split the input and output files by double new line
+    return {
+      input: inputFileUrlResponse.data.replace(/\r\n/g, "\n").split("\n\n"),
+      output: outputFileUrlResponse.data.replace(/\r\n/g, "\n").split("\n\n"),
+    };
+  } catch {
+    console.log("Failed to fetch test cases");
+    return { input: [], output: [] };
+  }
+};

backend/code-execution-service/swagger.yml

@@ -10,10 +10,13 @@ definitions:
       stdin:
         type: string
         required: true
-      expectedStdout:
+      stdout:
         type: string
         required: true
-      actualStdout:
+      expectedResult:
+        type: string
+        required: true
+      actualResult:
         type: string
       isMatch:
         type: boolean
@@ -82,23 +85,11 @@ paths:
                 code:
                   type: string
                   description: The source code to execute.
-                  example: "name = input()\nage = input()\nprint('Hello ' + name + '. You are ' + age + ' years old this year?')\n\n"
-                stdinList:
-                  type: array
-                  description: List of standard input values to pass to the code.
-                  items:
-                    type: string
-                  example: ["Alice\n21", "Peter\n22"]
-                stdoutList:
-                  type: array
-                  description: Expected standard output values to compare against.
-                  items:
-                    type: string
-                  example:
-                    [
-                      "Hello Alice. You are 21 years old this year?\n",
-                      "Hello Peter. You are 22 years old this year?\n",
-                    ]
+                  example: "a=input()\nb=input()\nc=input()\nd=input()\n\nprint(int(a)+int(b)+int(c)+int(d))"
+                questionId:
+                  type: string
+                  description: Question ID.
+                  example: "123456789"
       responses:
         200:
           description: Execution Result

backend/code-execution-service/tests/codeExecutionRoutes.spec.ts

@@ -6,12 +6,28 @@ import {
   ERROR_NOT_SAME_LENGTH_MESSAGE,
   SUCCESS_MESSAGE,
 } from "../src/utils/constants";
+import { testCasesApi } from "../src/utils/testCasesApi";
+import { questionService } from "../src/utils/questionApi";
 
 const request = supertest(app);
 
 const BASE_URL = "/api";
 
+jest.mock("../src/utils/questionApi", () => ({
+  questionService: {
+    get: jest.fn(),
+  },
+}));
+
+jest.mock("../src/utils/testCasesApi", () => ({
+  testCasesApi: jest.fn(),
+}));
+
 describe("Code execution routes", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
   describe("GET /", () => {
     it("should return 200 OK", (done) => {
       request.get("/").expect(200, done);
@@ -31,35 +47,63 @@ describe("Code execution routes", () => {
       const response = await request.post(`${BASE_URL}/run`).send({
         language: "testing1234",
         code: "print('Hello, world!')",
-        stdinList: ["input"],
-        stdoutList: ["Hello, world!"],
+        questionId: "1234",
       });
       expect(response.status).toBe(400);
       expect(response.body.message).toBe(ERROR_UNSUPPORTED_LANGUAGE_MESSAGE);
     });
 
     it("should return 400 if stdinList and stdoutList lengths do not match", async () => {
+      (questionService.get as jest.Mock).mockResolvedValue({
+        data: {
+          question: {
+            testcaseInputFileUrl: "https://peerprep.com/input",
+            testcaseOutputFileUrl: "https://peerprep.com/output",
+          },
+        },
+      });
+
+      (testCasesApi as jest.Mock).mockResolvedValue({
+        input: ["1", "2"],
+        output: ["1"],
+      });
+
       const response = await request.post(`${BASE_URL}/run`).send({
         language: "python",
         code: "print('Hello, world!')",
-        stdinList: ["input1"],
-        stdoutList: ["output1", "output2"],
+        questionId: "1234",
       });
       expect(response.status).toBe(400);
       expect(response.body.message).toBe(ERROR_NOT_SAME_LENGTH_MESSAGE);
     });
 
     it("should return 200 and execution result when code executes successfully", async () => {
+      (questionService.get as jest.Mock).mockResolvedValue({
+        data: {
+          question: {
+            testcaseInputFileUrl: "https://peerprep.com/input",
+            testcaseOutputFileUrl: "https://peerprep.com/output",
+          },
+        },
+      });
+
+      (testCasesApi as jest.Mock).mockResolvedValue({
+        input: ["1", "2"],
+        output: ["1", "4"],
+      });
+
       const response = await request.post(`${BASE_URL}/run`).send({
         language: "python",
         code: "print(input())",
-        stdinList: ["Hello, world!"],
-        stdoutList: ["Hello, world!"],
+        questionId: "1234",
       });
+
       expect(response.status).toBe(200);
       expect(response.body.message).toBe(SUCCESS_MESSAGE);
       expect(response.body.data).toBeInstanceOf(Array);
       expect(response.body.data[0]).toHaveProperty("isMatch", true);
+      expect(response.body.data[0]["isMatch"]).toBe(true);
+      expect(response.body.data[1]["isMatch"]).toBe(false);
     });
   });
 });

backend/collab-service/src/handlers/websocketHandler.ts

@@ -151,6 +151,7 @@ const getDocument = (roomId: string) => {
   let doc = collabSessions.get(roomId);
   if (!doc) {
     doc = new Doc();
+    // eslint-disable-next-line
     doc.on(CollabEvents.UPDATE, (_update) => {
       saveDocument(roomId, doc!);
       io.to(roomId).emit(CollabEvents.UPDATE, encodeStateAsUpdateV2(doc!));