add seedprovider tests

Author: mmtftr

.yarn/install-state.gz

@@ -0,0 +1 @@
+export * from "@react-native-async-storage/async-storage/jest/async-storage-mock";

__mocks__/@react-native-async-storage/async-storage.js

@@ -11,38 +11,39 @@ import { useEffect, useState } from "react";
 import { useAsyncStorage } from "@react-native-async-storage/async-storage";
 import { ActivityIndicator } from "react-native";
 import { getRandomQuestion } from "../services/questions";
+import { useToastController } from "@tamagui/toast";
 
-const seed = async () => {
+const seedNecessarySets = async () => {
   try {
-    const allValues = seedVals.questions.map(
-      ({
-        id,
-        questionText: question,
-        answers,
-        correctAnswer,
-        level,
-        category,
-        questionSet,
-      }) => ({
-        id,
-        question,
-        answers,
-        category: categories.includes(category as any)
-          ? (category as any)
-          : "unknown",
-        level: levels.includes(level as any) ? (level as any) : "N5",
-        correctAnswer,
-        questionSet,
-      }),
+    const availableQuestionSetIds = new Set(
+      (
+        await db
+          .selectDistinct({ id: questions.questionSet })
+          .from(questions)
+          .execute()
+      ).map((set) => set.id)
     );
+
     console.log("Seeding database...");
-    await db.insert(questionSets).values(seedVals.questionSets).execute();
+
+    await db
+      .insert(questionSets)
+      .values(
+        seedVals.questionSets.filter(
+          (set) => !availableQuestionSetIds.has(set.id)
+        )
+      )
+      .execute();
+
+    const allValues = seedVals.questions.filter(
+      (question) => !availableQuestionSetIds.has(question.questionSet)
+    );
 
     // insert 1K questions at a time.
     for (let i = 0; i < allValues.length / 1000; i++) {
       await db
         .insert(questions)
-        .values(allValues.slice(i * 1000, (i + 1) * 1000))
+        .values(allValues.slice(i * 1000, (i + 1) * 1000) as unknown as any)
         .execute();
     }
   } catch (e) {
@@ -55,7 +56,7 @@ export const resetAndReseed = async () => {
     const answerObjects = await db.delete(answers).returning().execute();
     await db.delete(questions).execute();
     await db.delete(questionSets).execute();
-    await seed();
+    await seedNecessarySets();
 
     // try to restore answers
     await db.insert(answers).values(answerObjects).execute();
@@ -64,21 +65,37 @@ export const resetAndReseed = async () => {
   }
 };
 
+export const checkShouldSeed = async () => {
+  const availableQuestionSetIds = new Set(
+    (
+      await db
+        .selectDistinct({ id: questions.questionSet })
+        .from(questions)
+        .execute()
+    ).map((set) => set.id)
+  );
+
+  if (
+    seedVals.questionSets.some((set) => !availableQuestionSetIds.has(set.id))
+  ) {
+    return true;
+  }
+  return false;
+};
+
 export default function SeedProvider({ children }: React.PropsWithChildren) {
   const [shouldSeed, setShouldSeed] = useState<boolean | null>(null);
   const seeded = useAsyncStorage("seeded");
 
   useEffect(() => {
-    Promise.all([getRandomQuestion(), seeded.getItem()]).then(([q, val]) => {
-      if (!q) return setShouldSeed(true);
-
-      setShouldSeed(val === "true" ? false : true);
+    checkShouldSeed().then((isSeedingRequired) => {
+      setShouldSeed(isSeedingRequired);
     });
   }, []);
 
   useEffect(() => {
     if (shouldSeed === true) {
-      seed().then(() => {
+      seedNecessarySets().then(() => {
         seeded.setItem("true");
         setShouldSeed(false);
       });

components/SeedProvider.tsx

@@ -0,0 +1,130 @@
+import * as React from "react";
+import {
+  act,
+  render,
+  screen,
+  waitFor,
+  TestRenderer,
+} from "@testing-library/react-native";
+import * as z from "zod";
+import {
+  levels,
+  categories,
+  questions,
+  questionSets,
+  answers,
+} from "../../db/schema";
+import SeedProvider from "../SeedProvider";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+import migrations from "../../drizzle/migrations";
+import { db } from "@/services/db";
+import { count, eq, sql } from "drizzle-orm";
+import { Text } from "react-native";
+
+jest.useFakeTimers();
+jest.mock("@/services/db");
+jest.mock("@react-native-async-storage/async-storage");
+
+describe("SeedProvider", () => {
+  beforeAll(() => {
+    migrate(db, { migrationsFolder: "./drizzle/" });
+  });
+
+  it("should render children after seed", async () => {
+    render(
+      <SeedProvider>
+        <Text>Hi</Text>
+      </SeedProvider>
+    );
+
+    expect(screen.queryByText("Hi")).toBeFalsy();
+
+    await act(async () => {
+      await jest.runAllTimersAsync();
+    });
+
+    expect(screen.getByText("Hi")).toBeTruthy();
+  });
+
+  it("should seed on empty db", async () => {
+    expect((await db.select({ num: count() }).from(questions))[0].num).toBe(0);
+
+    render(<SeedProvider />);
+
+    await act(async () => {
+      await jest.runAllTimers();
+    });
+
+    await waitFor(async () => {
+      expect(
+        (await db.select({ num: count() }).from(questions))[0].num
+      ).toBeGreaterThan(0);
+    });
+  });
+
+  it("should seed missing question set", async () => {
+    await db
+      .insert(questionSets)
+      .values({ id: 1, name: "Missing Set" })
+      .execute();
+    await db
+      .insert(questions)
+      .values({
+        question: "What is the capital of France?",
+        answers: ["Paris", "London", "Berlin", "Madrid"],
+        correctAnswer: 0,
+        level: "easy",
+        category: "geography",
+        questionSet: 1,
+      })
+      .execute();
+
+    render(<SeedProvider />);
+
+    await act(async () => {
+      await jest.runAllTimers();
+    });
+
+    await waitFor(async () => {
+      expect(
+        (
+          await db
+            .select({ num: count() })
+            .from(questions)
+            .where(eq(questions.questionSet, 1))
+        )[0].num
+      ).toBe(1);
+
+      expect(
+        (await db.select({ num: count() }).from(questions))[0].num
+      ).toBeGreaterThan(1);
+    });
+  });
+
+  beforeEach(async () => {
+    jest.clearAllMocks();
+    // delete all tables
+    await db.delete(questions).execute();
+    await db.delete(questionSets).execute();
+    await db.delete(answers).execute();
+  });
+});
+
+describe("seed.json", () => {
+  it("should be valid", () => {
+    const seedFile = require("../../constants/seed.json");
+
+    const questionSchema = z.array(
+      z.object({
+        id: z.number(),
+        question: z.string(),
+        answers: z.array(z.string()),
+        correctAnswer: z.number(),
+        level: z.union(levels.map(z.literal)),
+        category: z.union(categories.map(z.literal)),
+        questionSet: z.number(),
+      })
+    );
+    questionSchema.parse(seedFile.questions);
+  });
+});

components/__tests__/SeedProvider-test.js

@@ -0,0 +1,3 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`SeedProvider should render correctly 1`] = `<ActivityIndicator />`;