adding monkeytype

backend/__tests__/__integration__/dal/result.spec.ts

@@ -0,0 +1,190 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import * as ResultDal from "../../../src/dal/result";
+import { ObjectId } from "mongodb";
+import * as UserDal from "../../../src/dal/user";
+import { DBResult } from "../../../src/utils/result";
+import * as ResultUtils from "../../../src/utils/result";
+
+let uid: string;
+const timestamp = Date.now() - 60000;
+
+async function createDummyData(
+  uid: string,
+  count: number,
+  modify?: Partial<DBResult>,
+): Promise<void> {
+  const dummyUser: UserDal.DBUser = {
+    _id: new ObjectId(),
+    uid,
+    addedAt: 0,
+    email: "test@example.com",
+    name: "Bob",
+    personalBests: {
+      time: {},
+      words: {},
+      quote: {},
+      custom: {},
+      zen: {},
+    },
+  };
+
+  vi.spyOn(UserDal, "getUser").mockResolvedValue(dummyUser);
+
+  for (let i = 0; i < count; i++) {
+    await ResultDal.addResult(uid, {
+      ...{
+        _id: new ObjectId(),
+        wpm: i,
+        rawWpm: i,
+        charStats: [0, 0, 0, 0],
+        acc: 0,
+        mode: "time",
+        mode2: "10" as never,
+        quoteLength: 1,
+        timestamp,
+        restartCount: 0,
+        incompleteTestSeconds: 0,
+        incompleteTests: [],
+        testDuration: 10,
+        afkDuration: 0,
+        tags: [],
+        consistency: 100,
+        keyConsistency: 100,
+        chartData: { wpm: [], burst: [], err: [] },
+        uid,
+        keySpacingStats: { average: 0, sd: 0 },
+        keyDurationStats: { average: 0, sd: 0 },
+        difficulty: "normal",
+        language: "english",
+        isPb: false,
+        name: "Test",
+        funbox: ["58008", "read_ahead"],
+      },
+      ...modify,
+    });
+  }
+}
+describe("ResultDal", () => {
+  const replaceLegacyValuesMock = vi.spyOn(ResultUtils, "replaceLegacyValues");
+
+  beforeEach(() => {
+    uid = new ObjectId().toHexString();
+  });
+  afterEach(async () => {
+    if (uid) await ResultDal.deleteAll(uid);
+    replaceLegacyValuesMock.mockClear();
+  });
+  describe("getResults", () => {
+    it("should read lastest 10 results ordered by timestamp", async () => {
+      //GIVEN
+      await createDummyData(uid, 10, { timestamp: timestamp - 2000 });
+      await createDummyData(uid, 20, { tags: ["current"] });
+
+      //WHEN
+      const results = await ResultDal.getResults(uid, { limit: 10 });
+
+      //THEN
+      expect(results).toHaveLength(10);
+      let last = results[0]?.timestamp as number;
+      results.forEach((it) => {
+        expect(it.tags).toContain("current");
+        expect(it.timestamp).toBeGreaterThanOrEqual(last);
+        last = it.timestamp;
+      });
+    });
+    it("should read all if not limited", async () => {
+      //GIVEN
+      await createDummyData(uid, 10, { timestamp: timestamp - 2000 });
+      await createDummyData(uid, 20);
+
+      //WHEN
+      const results = await ResultDal.getResults(uid, {});
+
+      //THEN
+      expect(results).toHaveLength(30);
+    });
+    it("should read results onOrAfterTimestamp", async () => {
+      //GIVEN
+      await createDummyData(uid, 10, { timestamp: timestamp - 2000 });
+      await createDummyData(uid, 20, { tags: ["current"] });
+
+      //WHEN
+      const results = await ResultDal.getResults(uid, {
+        onOrAfterTimestamp: timestamp,
+      });
+
+      //THEN
+      expect(results).toHaveLength(20);
+      results.forEach((it) => {
+        expect(it.tags).toContain("current");
+      });
+    });
+    it("should read next 10 results", async () => {
+      //GIVEN
+      await createDummyData(uid, 10, {
+        timestamp: timestamp - 2000,
+        tags: ["old"],
+      });
+      await createDummyData(uid, 20);
+
+      //WHEN
+      const results = await ResultDal.getResults(uid, {
+        limit: 10,
+        offset: 20,
+      });
+
+      //THEN
+      expect(results).toHaveLength(10);
+      results.forEach((it) => {
+        expect(it.tags).toContain("old");
+      });
+    });
+    it("should call replaceLegacyValues", async () => {
+      //GIVEN
+      await createDummyData(uid, 1);
+
+      //WHEN
+      await ResultDal.getResults(uid);
+
+      //THEN
+      expect(replaceLegacyValuesMock).toHaveBeenCalled();
+    });
+  });
+  describe("getResult", () => {
+    it("should call replaceLegacyValues", async () => {
+      //GIVEN
+      await createDummyData(uid, 1);
+      const resultId = (await ResultDal.getLastResult(uid))._id.toHexString();
+
+      //WHEN
+      await ResultDal.getResult(uid, resultId);
+
+      //THEN
+      expect(replaceLegacyValuesMock).toHaveBeenCalled();
+    });
+  });
+  describe("getLastResult", () => {
+    it("should call replaceLegacyValues", async () => {
+      //GIVEN
+      await createDummyData(uid, 1);
+
+      //WHEN
+      await ResultDal.getLastResult(uid);
+
+      //THEN
+      expect(replaceLegacyValuesMock).toHaveBeenCalled();
+    });
+  });
+  describe("getResultByTimestamp", () => {
+    it("should call replaceLegacyValues", async () => {
+      //GIVEN
+      await createDummyData(uid, 1);
+
+      //WHEN
+      await ResultDal.getResultByTimestamp(uid, timestamp);
+
+      //THEN
+      expect(replaceLegacyValuesMock).toHaveBeenCalled();
+    });
+  });
+});