comments

Author: aletya

src/services/puzzle/puzzle-router.test.ts

@@ -1,29 +1,29 @@
-import { describe, expect, it } from "@jest/globals"; // , jest
+import { describe, expect, it, beforeEach } from "@jest/globals"; // , jest
 import { StatusCode } from "status-code-enum";
 import Models from "../../common/models";
-import { getAsUser, post, postAsUser } from "../../common/testTools"; //  TESTER, getAsAdmin, postAsUser
+import { getAsUser, post, postAsUser, TESTER } from "../../common/testTools"; //  TESTER, getAsAdmin, postAsUser
 import { PuzzleAnswer, PuzzleItem } from "./puzzle-schemas";
 
 const TESTER_PUZZLE_ITEM = {
-    userId: "bob-the-tester101010101011",
+    userId: TESTER.id,
     lastCorrect: 1708812000,
     problemComplete: [false, false, false, false, false, false, false, false, false, false],
     score: 0,
     teamName: "tester team 1",
 } satisfies PuzzleItem;
 
 const TESTER_CREATED_PUZZLE_ITEM = {
-    userId: "bob-the-tester101010101011",
+    userId: TESTER.id,
     problemComplete: [false, false, false, false, false, false, false, false, false, false],
     score: 0,
-    teamName: "tester team 1",
+    teamName: TESTER_PUZZLE_ITEM.teamName,
 };
 
 const UPDATED_TESTER_PUZZLE_ITEM = {
-    userId: "bob-the-tester101010101011",
+    userId: TESTER.id,
     problemComplete: [false, true, false, false, false, false, false, false, false, false],
     score: 1,
-    teamName: "tester team 1",
+    teamName: TESTER_PUZZLE_ITEM.teamName,
 };
 
 const TESTER_PUZZLE_ANSWER = {
@@ -44,49 +44,57 @@ describe("GET /status/", () => {
 });
 
 describe("POST /submit/:qid/", () => {
-    it("works for registered user, correct answer", async () => {
+    beforeEach(async () => {
         await Models.PuzzleItem.create(TESTER_PUZZLE_ITEM);
         await Models.PuzzleAnswer.create(TESTER_PUZZLE_ANSWER);
+    });
+
+    it("works for registered user, correct answer", async () => {
+        const response = await postAsUser("/puzzle/submit/1/").send({ answer: "correct_answer" }).expect(StatusCode.SuccessOK);
+        expect(JSON.parse(response.text)).toMatchObject(UPDATED_TESTER_PUZZLE_ITEM);
+    });
+
+    it("works for registered user, already completed", async () => {
+        await Models.PuzzleItem.updateOne(
+            { userId: TESTER.id },
+            {
+                $set: {
+                    problemComplete: UPDATED_TESTER_PUZZLE_ITEM.problemComplete,
+                    score: UPDATED_TESTER_PUZZLE_ITEM.score,
+                },
+            },
+        );
         const response = await postAsUser("/puzzle/submit/1/").send({ answer: "correct_answer" }).expect(StatusCode.SuccessOK);
         expect(JSON.parse(response.text)).toMatchObject(UPDATED_TESTER_PUZZLE_ITEM);
     });
 
     it("returns bad request error for registered user, incorrect answer", async () => {
-        await Models.PuzzleItem.create(TESTER_PUZZLE_ITEM);
-        await Models.PuzzleAnswer.create(TESTER_PUZZLE_ANSWER);
-        const response = await postAsUser("/puzzle/submit/1/")
-            .send({ answer: "incorrect_answer" })
-            .expect(StatusCode.ClientErrorBadRequest);
-        expect(JSON.parse(response.text)).toHaveProperty("message", "Your answer was incorrect!");
+        await postAsUser("/puzzle/submit/1/").send({ answer: "incorrect_answer" }).expect(StatusCode.ClientErrorBadRequest);
     });
 
     it("returns not found error for registered user, nonexistent question", async () => {
-        await Models.PuzzleItem.create(TESTER_PUZZLE_ITEM);
-        const response = await postAsUser("/puzzle/submit/33/")
-            .send({ answer: "filler_answer" })
-            .expect(StatusCode.ClientErrorNotFound);
-        expect(JSON.parse(response.text)).toHaveProperty("message", "That question doesn't exist!");
+        await postAsUser("/puzzle/submit/33/").send({ answer: "filler_answer" }).expect(StatusCode.ClientErrorNotFound);
+        await postAsUser("/puzzle/submit/asdf/").send({ answer: "filler_answer" }).expect(StatusCode.ClientErrorNotFound);
     });
 
     it("returns not found error for unregistered user", async () => {
-        const response = await postAsUser("/puzzle/submit/1")
-            .send({ answer: "filler_answer" })
-            .expect(StatusCode.ClientErrorNotFound);
-        expect(JSON.parse(response.text)).toHaveProperty("message", "That question doesn't exist!");
+        await Models.PuzzleItem.findOneAndDelete({ userId: TESTER.id });
+        await postAsUser("/puzzle/submit/1").send({ answer: "filler_answer" }).expect(StatusCode.ClientErrorNotFound);
     });
 });
 
 describe("POST /puzzle/create/", () => {
     it("creates a new puzzle for authenticated user", async () => {
-        const response = await postAsUser("/puzzle/create/").send({ teamName: "tester team 1" }).expect(StatusCode.SuccessOK);
+        const response = await postAsUser("/puzzle/create/")
+            .send({ teamName: TESTER_PUZZLE_ITEM.teamName })
+            .expect(StatusCode.SuccessOK);
         expect(JSON.parse(response.text)).toMatchObject(TESTER_CREATED_PUZZLE_ITEM);
     });
 
     it("returns unauthorized error for unauthenticated user", async () => {
-        const response = await post("/puzzle/create/", undefined)
-            .send({ teamName: "tester team 1" })
+        await post("/puzzle/create/", undefined)
+            .send({ teamName: TESTER_PUZZLE_ITEM.teamName })
             .expect(StatusCode.ClientErrorUnauthorized);
-        expect(JSON.parse(response.text)).toHaveProperty("message", "A authorization token must be sent for this request");
     });
 
     it("returns validation error for missing team name", async () => {

src/services/puzzle/puzzle-router.ts

@@ -95,27 +95,24 @@ puzzleRouter.post(
         const qidString = req.params.qid;
         const { answer } = req.body;
 
+        const puzzle = await Models.PuzzleItem.findOne({ userId });
+
+        // Not yet created
+        if (!puzzle) {
+            return res.status(StatusCode.ClientErrorNotFound).send(PuzzleNotCreatedError);
+        }
+
         // Invalid question
-        let qid;
-        try {
-            qid = parseInt(qidString, 10);
-        } catch {
+        const qid = parseInt(qidString, 10);
+        if (isNaN(qid)) {
             return res.status(StatusCode.ClientErrorNotFound).send(PuzzleQuestionNotFoundError);
         }
-
         const puzzleAnswer = await Models.PuzzleAnswer.findOne({ qid });
         if (!puzzleAnswer) {
             return res.status(StatusCode.ClientErrorNotFound).send(PuzzleQuestionNotFoundError);
         }
         const correctAnswer = puzzleAnswer.answer;
 
-        const puzzle = await Models.PuzzleItem.findOne({ userId });
-
-        // Not yet created
-        if (!puzzle) {
-            return res.status(StatusCode.ClientErrorNotFound).send(PuzzleNotCreatedError);
-        }
-
         // Already completed, good to go
         if (puzzle.problemComplete[qid]) {
             return res.status(StatusCode.SuccessOK).send(puzzle);