test: Use a generalized seed source for insertion to see the database state pre-test

aureateAnatidae · aureateAnatidae · commit 69c1b78effaa · 2026-01-12T15:31:47.000-07:00
diff --git a/apps/backend/src/db/BaseSeedSource.ts b/apps/backend/src/db/BaseSeedSource.ts
diff --git a/apps/backend/src/db/CustomSeedSource.ts b/apps/backend/src/db/CustomSeedSource.ts
@@ -0,0 +1,65 @@
+import { seed as SSBUCharacters_seed } from "@db/seeds/SSBUCharacters";
+import { getLogger } from "@logtape/logtape";
+import type { GuildSeasonRecord } from "@v1/guild/models";
+import type { MatchRecord } from "@v1/match/models";
+import type { SeasonRecord } from "@v1/season/models";
+import type { Knex } from "knex";
+
+const log = getLogger(["grindcord", "db"]);
+
+// Seek more customizable API where list of seeds can be provided to the seedsource
+export class BaseSeedSource {
+    getSeeds() {
+        return Promise.resolve(["SSBUCharacters"]);
+    }
+
+    async getSeed(seed: string) {
+        log.info(`Seeding ${seed}`);
+        switch (seed) {
+            case "SSBUCharacters":
+                return {
+                    async seed(knex: Knex) {
+                        await SSBUCharacters_seed(knex);
+                    },
+                };
+            default:
+                throw new Error(`Invalid seed: "${seed}"`);
+        }
+    }
+}
+
+type InsertSeedSourceProps = {
+    Match?: Array<Omit<MatchRecord, "match_id">>;
+    Season?: Array<Omit<SeasonRecord, "season_id">>;
+    GuildSeason?: Array<GuildSeasonRecord>;
+};
+export class InsertSeedSource {
+    insertables: InsertSeedSourceProps;
+    constructor(insertables: InsertSeedSourceProps) {
+        this.insertables = insertables;
+    }
+
+    getSeeds() {
+        const keys = Object.keys(this.insertables) as Array<
+            keyof InsertSeedSourceProps
+        >;
+        return Promise.resolve(keys);
+    }
+
+    async getSeed(seed: keyof InsertSeedSourceProps) {
+        const records = this.insertables[seed as keyof InsertSeedSourceProps];
+        if (records === undefined) {
+            throw new Error(
+                "An undefined attribute was used as an argument in InsertSeedSource.",
+            );
+        }
+        return {
+            async seed(knex: Knex) {
+                let i: keyof typeof records;
+                for (i in records) {
+                    await knex(seed).insert(records[i]);
+                }
+            },
+        };
+    }
+}
diff --git a/apps/backend/src/db/init_tables.ts b/apps/backend/src/db/init_tables.ts
@@ -49,13 +49,6 @@ export async function init_tables(db: Knex = knexDb): Promise<void> {
     await trx.commit();
 }
 
-export async function seed_db(
-    seedSource: Knex.SeedSource<unknown>,
-    db: Knex = knexDb,
-): Promise<void> {
-    await db.seed.run({ seedSource });
-}
-
 export async function init_views(db: Knex = knexDb) {
     const trx = await db.transaction();
     for (const _view of views) {
diff --git a/apps/backend/src/db/knexfile.ts b/apps/backend/src/db/knexfile.ts
@@ -1,4 +1,4 @@
-import { BaseSeedSource } from "@db/BaseSeedSource";
+import { BaseSeedSource } from "@db/CustomSeedSource";
 import config from "config";
 import knex, { type Knex } from "knex";
 
diff --git a/apps/backend/src/index.ts b/apps/backend/src/index.ts
@@ -1,5 +1,6 @@
-import { BaseSeedSource as SSBUCharacterSeedSource } from "@db/BaseSeedSource";
-import { init_tables, init_views, seed_db } from "@db/init_tables";
+import { BaseSeedSource as SSBUCharacterSeedSource } from "@db/CustomSeedSource";
+import { init_tables, init_views } from "@db/init_tables";
+import { knexDb } from "@db/knexfile";
 import { serve } from "@hono/node-server";
 import { honoLogger } from "@logtape/hono";
 import { configure, getConsoleSink } from "@logtape/logtape";
@@ -22,7 +23,7 @@ const app = new Hono({ strict: false });
 
 await init_tables();
 
-await seed_db(new SSBUCharacterSeedSource());
+await knexDb.seed.run();
 
 await init_views();
 
diff --git a/apps/backend/src/v1/guild/test/integration.test.ts b/apps/backend/src/v1/guild/test/integration.test.ts
@@ -1,4 +1,5 @@
-import { init_tables, init_views, seed_db } from "@db/init_tables";
+import { InsertSeedSource } from "@db/CustomSeedSource";
+import { init_tables, init_views } from "@db/init_tables";
 import { knexDb } from "@db/knexfile";
 import type { GuildSeasonRecord } from "@v1/guild/models";
 import {
@@ -12,23 +13,6 @@ import type { Knex } from "knex";
 import { afterEach, beforeEach, describe, expect, test } from "vitest";
 import { guildSeasonRecordFactory } from "./models.factories";
 
-export class TestSeedSource {
-    seeds: Array<(knex: Knex) => Promise<void>>;
-    constructor(seeds: Array<(knex: Knex) => Promise<void>>) {
-        this.seeds = seeds;
-    }
-
-    getSeeds() {
-        return Promise.resolve(this.seeds);
-    }
-
-    async getSeed(seed: (knex: Knex) => Promise<void>) {
-        return {
-            seed,
-        };
-    }
-}
-
 beforeEach(async () => {
     await init_tables(knexDb);
     await init_views(knexDb);
@@ -47,14 +31,9 @@ describe("GuildSeason table operations", () => {
         let guild_id: string;
         beforeEach(async () => {
             season_record = currentSeasonRecordFactory();
-            await seed_db(
-                new TestSeedSource([
-                    async (knex: Knex) => {
-                        await knex("Season").insert(season_record);
-                    },
-                ]),
-                knexDb,
-            );
+            await knexDb.seed.run({
+                seedSource: new InsertSeedSource({ Season: [season_record] }),
+            });
 
             season_id = await knexDb("Season")
                 .first()
@@ -63,14 +42,11 @@ describe("GuildSeason table operations", () => {
 
             guild_season_record = guildSeasonRecordFactory({ season_id });
             guild_id = guild_season_record.guild_id;
-            await seed_db(
-                new TestSeedSource([
-                    async (knex: Knex) => {
-                        await knex("GuildSeason").insert(guild_season_record);
-                    },
-                ]),
-                knexDb,
-            );
+            await knexDb.seed.run({
+                seedSource: new InsertSeedSource({
+                    GuildSeason: [guild_season_record],
+                }),
+            });
         });
         test("Nominal", async () => {
             expect(
@@ -85,14 +61,9 @@ describe("GuildSeason table operations", () => {
         let season_id: number;
         beforeEach(async () => {
             season_record = currentSeasonRecordFactory();
-            await seed_db(
-                new TestSeedSource([
-                    async (knex: Knex) => {
-                        await knex("Season").insert(season_record);
-                    },
-                ]),
-                knexDb,
-            );
+            await knexDb.seed.run({
+                seedSource: new InsertSeedSource({ Season: [season_record] }),
+            });
 
             season_id = await knexDb("Season")
                 .first()
@@ -131,15 +102,11 @@ describe("GuildSeason table operations", () => {
         beforeEach(async () => {
             old_season_record = currentSeasonRecordFactory();
             new_season_record = currentSeasonRecordFactory();
-            await seed_db(
-                new TestSeedSource([
-                    async (knex: Knex) => {
-                        await knex("Season").insert(old_season_record);
-                        await knex("Season").insert(new_season_record);
-                    },
-                ]),
-                knexDb,
-            );
+            await knexDb.seed.run({
+                seedSource: new InsertSeedSource({
+                    Season: [old_season_record, new_season_record],
+                }),
+            });
             const old_season_id = await await knexDb("Season")
                 .first()
                 .where(new_season_record)
@@ -152,14 +119,11 @@ describe("GuildSeason table operations", () => {
             guild_season_record = guildSeasonRecordFactory({
                 season_id: old_season_id,
             });
-            await seed_db(
-                new TestSeedSource([
-                    async (knex: Knex) => {
-                        await knex("GuildSeason").insert(guild_season_record);
-                    },
-                ]),
-                knexDb,
-            );
+            await knexDb.seed.run({
+                seedSource: new InsertSeedSource({
+                    GuildSeason: [guild_season_record],
+                }),
+            });
         });
         describe("Updating an existing `GuildSeason` record", () => {
             test("Nominal", async () => {
diff --git a/apps/backend/src/v1/match/test/integration.test.ts b/apps/backend/src/v1/match/test/integration.test.ts
@@ -1,4 +1,4 @@
-import { init_tables, init_views, seed_db } from "@db/init_tables";
+import { init_tables, init_views } from "@db/init_tables";
 import { knexDb } from "@db/knexfile";
 import type { MatchCharacterRecord } from "@v1/match/models";
 import type { MatchQuery, MatchReport } from "@v1/match/schemas";
@@ -9,10 +9,10 @@ import {
     getMatches,
     reportMatch,
 } from "@v1/match/service";
-import { seed as MatchFactorySeed } from "@v1/match/test/models.factories";
 import { matchReportFactory } from "@v1/match/test/schemas.factories";
 import { MatchReportDerivedRow } from "@v1/match/views";
 import type { Knex } from "knex";
+import { InsertSeedSource } from "@db/CustomSeedSource";
 import { afterEach, beforeEach, describe, expect, test } from "vitest";
 
 // const _fakeMatchReport = MatchReport.parse({
@@ -32,30 +32,10 @@ import { afterEach, beforeEach, describe, expect, test } from "vitest";
 // });
 const fakeMatchReport = matchReportFactory();
 
-export class TestSeedSource {
-    getSeeds() {
-        return Promise.resolve(["FakeMatches"]);
-    }
-
-    async getSeed(seed: string) {
-        switch (seed) {
-            case "FakeMatches":
-                return {
-                    async seed(knex: Knex) {
-                        await MatchFactorySeed(knex);
-                    },
-                };
-            default:
-                throw new Error(`Invalid seed: "${seed}"`);
-        }
-    }
-}
 
 beforeEach(async () => {
     await init_tables(knexDb);
     await init_views(knexDb);
-
-    await seed_db(new TestSeedSource(), knexDb);
 });
 afterEach(async () => {
     await knexDb.destroy();
diff --git a/apps/backend/src/v1/match/test/models.factories.ts b/apps/backend/src/v1/match/test/models.factories.ts
@@ -39,57 +39,3 @@ export const matchCharacterRecordFactory = (
         ...match_character_record,
     };
 };
-
-/** TODO: Might not be necessary to insert so many random records without a way to test them.
- * Find a way to exploit all that coverage.
- * Generate MatchReport data that matches the database records so that we can check parity?
- */
-export async function seed(knex: Knex) {
-    // Ten total players, one hundred games between them in a single guild.
-    const guild_id = snowflake();
-    const user_id_list = Array.from({ length: 10 }, snowflake);
-
-    // Generate all distinct pairs (i,j); i != j of users
-    const possible_pairs = [];
-    for (let i = 0; i < 10; i++) {
-        for (let j = i + 1; j < 10; j++) {
-            possible_pairs.push([i, j]);
-        }
-    }
-
-    // Choose from these pairs at random, 40 times with replacement
-    for (let _ = 0; _ < 40; _++) {
-        const pair = possible_pairs[randint(possible_pairs.length)];
-
-        const max_score = 1 + 2 * randint(25);
-        const scores: Array<number> = ((w) => [w, randint(w)])(randint(max_score) + 1);
-
-        const match_id = (await knex("Match").insert({ guild_id }))[0];
-        // Randomize who gets inserted first
-        // Randomize who gets the winning score
-        const swap = randint(4);
-        const swap_score = Math.floor(swap / 2);
-        const swap_user_id = Number(swap % 2 === 0);
-        await knex("MatchPlayer").insert({
-            match_id,
-            user_id: user_id_list[pair[swap_user_id]],
-            win_count: scores[swap_score],
-        });
-        await knex("MatchPlayer").insert({
-            match_id,
-            user_id: user_id_list[pair[(swap_user_id + 1) % 2]],
-            win_count: scores[(swap_score + 1) % 2],
-        });
-
-        for (let p_i = 0; p_i < pair.length; p_i++) {
-            const characters = rand_character_array();
-            for (let c_i = 0; c_i < characters.length; c_i++) {
-                await knex("MatchCharacter").insert({
-                    match_id,
-                    user_id: user_id_list[pair[p_i]],
-                    fighter_number: SSBUCharEnumToFighterNumber.decode(characters[c_i]),
-                });
-            }
-        }
-    }
-}
diff --git a/apps/backend/src/v1/season/test/integration.test.ts b/apps/backend/src/v1/season/test/integration.test.ts

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-import { BaseSeedSource } from "@db/BaseSeedSource";`
	`1`	`+import { BaseSeedSource } from "@db/CustomSeedSource";`
`2`	`2`	`import config from "config";`
`3`	`3`	`import knex, { type Knex } from "knex";`
`4`	`4`