test: refactor match tests to use the new insert seed source API

Author: aureateAnatidae

apps/backend/src/db/CustomSeedSource.ts

@@ -1,7 +1,7 @@
 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 { MatchPlayerRecord, MatchRecord } from "@v1/match/models";
 import type { SeasonRecord } from "@v1/season/models";
 import type { Knex } from "knex";
 
@@ -28,8 +28,10 @@ export class BaseSeedSource {
     }
 }
 
+// Insert any records into the table
 type InsertSeedSourceProps = {
-    Match?: Array<Omit<MatchRecord, "match_id">>;
+    Match?: Array<Omit<MatchRecord, "match_id" | "created_at">>;
+    MatchPlayer?: Array<MatchPlayerRecord>;
     Season?: Array<Omit<SeasonRecord, "season_id">>;
     GuildSeason?: Array<GuildSeasonRecord>;
 };

apps/backend/src/v1/match/schemas.ts

@@ -6,7 +6,7 @@ export type SSBUCharEnum = z.infer<typeof SSBUCharEnum>;
 
 export const SSBUCharFighterNumber = z
     .int()
-    .min(1)
+    .min(0)
     .max(ssbu_character_names.length + 1);
 export type SSBUCharFighterNumber = z.infer<typeof SSBUCharFighterNumber>;
 

apps/backend/src/v1/match/test/integration.test.ts

@@ -1,7 +1,17 @@
+import { InsertSeedSource } from "@db/CustomSeedSource";
 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";
+import type {
+    MatchCharacterRecord,
+    MatchPlayerRecord,
+    MatchRecord,
+} from "@v1/match/models";
+import {
+    MatchPlayer,
+    type MatchQuery,
+    type MatchReport,
+    type SSBUCharFighterNumber,
+} from "@v1/match/schemas";
 import {
     createMatch,
     createMatchCharacter,
@@ -11,27 +21,25 @@ import {
 } from "@v1/match/service";
 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";
+import { matchPlayerRecordFactory, matchRecordFactory } from "./models.factories";
 
-// const _fakeMatchReport = MatchReport.parse({
-//     guild_id: "19283746",
-//     players: [
-//         {
-//             user_id: "12345678",
-//             win_count: 5,
-//             character: ["Mario"],
-//         },
-//         {
-//             user_id: "87654321",
-//             win_count: 2,
-//             character: ["Kazuya", "Cloud"],
-//         },
-//     ],
-// });
-const fakeMatchReport = matchReportFactory();
-
+// Nominal fake data that is not inserted should be defined here
+const nominal_match_report = matchReportFactory({
+    guild_id: "123456789",
+    players: [
+        MatchPlayer.parse({
+            user_id: "12345678",
+            win_count: 5,
+            character: ["Mario"],
+        }),
+        MatchPlayer.parse({
+            user_id: "87654321",
+            win_count: 2,
+            character: ["Kazuya", "Cloud"],
+        }),
+    ],
+});
 
 beforeEach(async () => {
     await init_tables(knexDb);
@@ -44,11 +52,16 @@ afterEach(async () => {
 
 describe("Match table operations", () => {
     describe("Use `createMatch`", () => {
-        describe("Random", () => {
+        describe("Nominal", () => {
             test("Insert a Match record with `createMatch`", async () => {
-                const match_id = await createMatch(fakeMatchReport.guild_id, knexDb);
-                const created_match = await knexDb("Match").first().where({ match_id });
-                expect(created_match.guild_id).toEqual(fakeMatchReport.guild_id);
+                const match_id = await createMatch(
+                    nominal_match_report.guild_id,
+                    knexDb,
+                );
+                const created_match = await knexDb<MatchRecord>("Match")
+                    .first()
+                    .where({ match_id });
+                expect(created_match?.guild_id).toEqual(nominal_match_report.guild_id);
                 console.log(created_match);
             });
         });
@@ -57,48 +70,55 @@ describe("Match table operations", () => {
 
 describe("MatchPlayer table operations", () => {
     describe("Use `createMatchPlayer`", () => {
-        describe("Random", () => {
-            test("Insert a pair of MatchPlayer records", async () => {
-                const { guild_id } = fakeMatchReport;
-                const match_id = (await knexDb("Match").insert({ guild_id }))[0];
+        let match_record: Omit<MatchRecord, "match_id" | "created_at">;
+        let match_id: number;
+        beforeEach(async () => {
+            match_record = matchRecordFactory({ guild_id: "123456789" });
+            await knexDb.seed.run({
+                seedSource: new InsertSeedSource({ Match: [match_record] }),
+            });
 
+            match_id = await knexDb("Match")
+                .first()
+                .where(match_record)
+                .then((res) => res.match_id);
+        });
+        describe("Nominal", () => {
+            test("Insert a pair of MatchPlayer records", async () => {
                 await createMatchPlayer(
                     match_id,
-                    fakeMatchReport.players[0].user_id,
-                    fakeMatchReport.players[0].win_count,
+                    nominal_match_report.players[0].user_id,
+                    nominal_match_report.players[0].win_count,
                     knexDb,
                 );
                 const created_match_player = await knexDb("MatchPlayer")
                     .first()
                     .where({ match_id });
 
-                expect(created_match_player).toEqual({
+                expect(created_match_player).toMatchObject({
                     match_id,
-                    user_id: fakeMatchReport.players[0].user_id,
-                    win_count: fakeMatchReport.players[0].win_count,
+                    user_id: nominal_match_report.players[0].user_id,
+                    win_count: nominal_match_report.players[0].win_count,
                 });
             });
         });
         describe("Negative", () => {
             describe("Illegal insertions of MatchPlayer", () => {
                 test.fails("Cannot insert MatchPlayer where [match_id, user_id] is not unique", async () => {
-                    const { guild_id } = fakeMatchReport;
-                    const match_id = (await knexDb("Match").insert({ guild_id }))[0];
-
                     for (let p_i = 0; p_i < 2; p_i++) {
                         await createMatchPlayer(
                             match_id,
-                            fakeMatchReport.players[0].user_id,
-                            fakeMatchReport.players[0].win_count,
+                            nominal_match_report.players[0].user_id,
+                            nominal_match_report.players[0].win_count,
                             knexDb,
                         );
                     }
                 });
                 test.fails("Cannot insert MatchPlayer where there is no Match record with matching match_id", async () => {
                     await createMatchPlayer(
                         3000,
-                        fakeMatchReport.players[0].user_id,
-                        fakeMatchReport.players[0].win_count,
+                        nominal_match_report.players[0].user_id,
+                        nominal_match_report.players[0].win_count,
                         knexDb,
                     );
                 });
@@ -109,32 +129,78 @@ describe("MatchPlayer table operations", () => {
 
 describe("MatchCharacter table operations", () => {
     describe("Use `createMatchCharacter`", () => {
-        describe("Random", () => {
-            test("Insert a pair of MatchCharacter records", async () => {
-                const { guild_id } = fakeMatchReport;
-                const match_id = (await knexDb("Match").insert({ guild_id }))[0];
+        let match_record: Omit<MatchRecord, "match_id" | "created_at">;
+        let match_player_record_1: MatchPlayerRecord;
+        let match_player_record_2: MatchPlayerRecord;
+        let match_id: number;
+        let match_player_id_1: string;
+        let match_player_id_2: string;
 
-                for (let p_i = 0; p_i < fakeMatchReport.players.length; p_i++) {
-                    const { user_id, win_count, character } =
-                        fakeMatchReport.players[p_i];
-                    await createMatchPlayer(match_id, user_id, win_count, knexDb);
-                    for (let c_i = 0; c_i < character.length; c_i++) {
-                        await createMatchCharacter(
-                            match_id,
-                            user_id,
-                            character[c_i],
-                            knexDb,
-                        );
-                    }
+        let match_player_characters_1: Array<SSBUCharFighterNumber>;
+        let match_player_characters_2: Array<SSBUCharFighterNumber>;
+        beforeEach(async () => {
+            match_record = matchRecordFactory({
+                guild_id: nominal_match_report.guild_id,
+            });
+            await knexDb.seed.run({
+                seedSource: new InsertSeedSource({
+                    Match: [match_record],
+                }),
+            });
+
+            match_id = await knexDb("Match")
+                .first()
+                .where(match_record)
+                .then((res) => res.match_id);
+            match_player_record_1 = matchPlayerRecordFactory({
+                match_id,
+                user_id: nominal_match_report.players[0].user_id,
+                win_count: nominal_match_report.players[0].win_count,
+            });
+            match_player_record_2 = matchPlayerRecordFactory({
+                match_id,
+                user_id: nominal_match_report.players[1].user_id,
+                win_count: nominal_match_report.players[1].win_count,
+            });
+            await knexDb.seed.run({
+                seedSource: new InsertSeedSource({
+                    MatchPlayer: [match_player_record_1, match_player_record_2],
+                }),
+            });
+
+            match_player_id_1 = match_player_record_1.user_id;
+            match_player_id_2 = match_player_record_2.user_id;
+
+            match_player_characters_1 = nominal_match_report.players[0].character;
+            match_player_characters_2 = nominal_match_report.players[1].character;
+        });
+        describe("Nominal", () => {
+            test("Insert a pair of MatchCharacter records", async () => {
+                for (let c_i = 0; c_i < match_player_characters_1.length; c_i++) {
+                    await createMatchCharacter(
+                        match_id,
+                        match_player_id_1,
+                        match_player_characters_1[c_i],
+                        knexDb,
+                    );
+                }
+                for (let c_i = 0; c_i < match_player_characters_2.length; c_i++) {
+                    await createMatchCharacter(
+                        match_id,
+                        match_player_id_2,
+                        match_player_characters_2[c_i],
+                        knexDb,
+                    );
                 }
 
                 const created = await knexDb<MatchCharacterRecord>("MatchCharacter")
                     .select()
                     .where({ match_id });
                 const expected = (): Array<MatchCharacterRecord> => {
                     const result = [];
-                    for (let p_i = 0; p_i < fakeMatchReport.players.length; p_i++) {
-                        const { user_id, character } = fakeMatchReport.players[p_i];
+                    for (let p_i = 0; p_i < 2; p_i++) {
+                        const { user_id, character } =
+                            nominal_match_report.players[p_i];
                         for (let c_i = 0; c_i < character.length; c_i++) {
                             const fighter_number = character[c_i];
                             result.push({
@@ -152,25 +218,19 @@ describe("MatchCharacter table operations", () => {
 
         describe("Negative", () => {
             test.fails("Cannot insert MatchCharacter where [match_id, user_id, fighter_number] is not unique, specifically, `fighter_number`", async () => {
-                const { guild_id } = fakeMatchReport;
-                const match_id = (await knexDb("Match").insert({ guild_id }))[0];
-
                 for (let i = 0; i < 2; i++) {
                     await createMatchCharacter(
                         match_id,
-                        fakeMatchReport.players[i].user_id,
-                        fakeMatchReport.players[1].character[0],
+                        nominal_match_report.players[0].user_id,
+                        nominal_match_report.players[1].character[0],
                         knexDb,
                     );
                 }
             });
             test.fails("Cannot insert MatchCharacter where a fighter_number is not in the SSBUCharTable", async () => {
-                const { guild_id } = fakeMatchReport;
-                const { user_id } = fakeMatchReport.players[1];
+                const { user_id } = nominal_match_report.players[1];
 
-                const match_id = (await knexDb("Match").insert({ guild_id }))[0];
-                await knexDb("MatchPlayer").insert({ match_id, user_id });
-                await createMatchCharacter(match_id, user_id, 104, knexDb);
+                await createMatchCharacter(match_id, user_id, 404, knexDb);
             });
         });
     });
@@ -180,9 +240,9 @@ describe("Operations across Match, MatchPlayer, and MatchCharacter tables", () =
     describe("Use `reportMatch`", async () => {
         describe("Random", () => {
             test("Report a match", async () => {
-                const { guild_id } = fakeMatchReport;
+                const { guild_id } = nominal_match_report;
 
-                const match_id = await reportMatch(fakeMatchReport, knexDb);
+                const match_id = await reportMatch(nominal_match_report, knexDb);
 
                 const match_player_records = await knexDb("MatchPlayer")
                     .select()
@@ -206,7 +266,7 @@ describe("Operations across Match, MatchPlayer, and MatchCharacter tables", () =
                             ),
                     })),
                 };
-                expect(fakeMatchReport).toEqual({
+                expect(nominal_match_report).toEqual({
                     ...expected,
                     players: expect.arrayContaining(
                         expected.players.map((player) => ({
@@ -222,17 +282,17 @@ describe("Operations across Match, MatchPlayer, and MatchCharacter tables", () =
     describe("Use `getMatches`", async () => {
         describe("Random", () => {
             test("Retrieve a derived row from MatchReportView by match_id", async () => {
-                const match_id = await reportMatch(fakeMatchReport, knexDb);
-                const { guild_id } = fakeMatchReport;
+                const match_id = await reportMatch(nominal_match_report, knexDb);
+                const { guild_id } = nominal_match_report;
 
                 const match_query: MatchQuery = { match_id };
                 const result = await getMatches(match_query, knexDb);
                 const created_at = result[0].created_at;
 
                 const expected = [];
-                for (let p_i = 0; p_i < fakeMatchReport.players.length; p_i++) {
+                for (let p_i = 0; p_i < nominal_match_report.players.length; p_i++) {
                     const { user_id, win_count, character } =
-                        fakeMatchReport.players[p_i];
+                        nominal_match_report.players[p_i];
                     for (let c_i = 0; c_i < character.length; c_i++) {
                         const fighter_number = character[c_i];
                         expected.push(

apps/backend/src/v1/match/test/models.factories.ts

@@ -1,18 +1,15 @@
 import { ssbu_character_names } from "@db/seeds/SSBUCharacters";
-import { rand_character_array, randint, snowflake } from "@test/factories";
+import { randint, snowflake } from "@test/factories";
 import type {
     MatchCharacterRecord,
     MatchPlayerRecord,
     MatchRecord,
 } from "@v1/match/models";
-import { SSBUCharEnumToFighterNumber } from "@v1/match/schemas";
-import type { Knex } from "knex";
 
 export const matchRecordFactory = (
     match_record: Partial<MatchRecord> | undefined = undefined,
-): Omit<MatchRecord, "created_at"> => {
+): Omit<MatchRecord, "match_id" | "created_at"> => {
     return {
-        match_id: randint(1000),
         guild_id: snowflake(),
         ...match_record,
     };