test: Rename some test variables, add a test for after being ahead of before

Author: aureateAnatidae

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

@@ -14,7 +14,8 @@ export const SeasonQuery = z
         season_id: z.int(),
         guild_id: z.string(),
         season_name: z.string(),
-        during: z.iso.datetime(),
+        after: z.iso.datetime(),
+        before: z.iso.datetime(),
     })
     .partial();
 export type SeasonQuery = z.infer<typeof SeasonQuery>;

apps/backend/src/v1/season/service.ts

@@ -2,12 +2,16 @@ import type { SeasonRecord } from "@v1/season/models";
 import type { Knex } from "knex";
 import type { SeasonQuery } from "./schemas";
 
-/** Find the `season_id` of the current Seasons of a Guild with a `guild_id` */
+/** Find the `season_id` of the current Seasons of a Guild with a `guild_id`
+ * The arguments `after` and `before` do not refer to the entire span of a Season,
+ * instead, it refers to a Season that is active for the full timespan between
+ * `after` and `before`.
+ */
 export async function getSeasons(
     season_query: SeasonQuery,
     db: Knex,
 ): Promise<Array<SeasonRecord>> {
-    const { season_id, guild_id, season_name, during } = season_query;
+    const { season_id, guild_id, season_name, after, before } = season_query;
     const query = db<SeasonRecord>("Season").select();
     if (guild_id) {
         query.where({ guild_id });
@@ -18,8 +22,11 @@ export async function getSeasons(
     if (season_name) {
         query.whereILike(season_name, `%{season_name}%`);
     }
-    if (during) {
-        query.where("end_at", ">=", during).where("start_at", "<=", during);
+    if (after) {
+        query.where("end_at", ">=", after);
+    }
+    if (before) {
+        query.where("start_at", "<=", before);
     }
     return await query;
 }

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

@@ -7,7 +7,6 @@ import {
     currentSeasonRecordFactory,
     futureSeasonRecordFactory,
     pastSeasonRecordFactory,
-    seasonRecordFactory,
 } from "@v1/season/test/models.factories";
 import type { Knex } from "knex";
 import { afterEach, beforeEach, describe, expect, test } from "vitest";
@@ -43,7 +42,7 @@ describe("Season table operations", () => {
         await teardown(test_knexDb);
     });
     describe("Use `getSeasons`", () => {
-        test("Typical", async () => {
+        test("Based on `after` and `before` arguments", async () => {
             const past_season = pastSeasonRecordFactory();
             const current_season = currentSeasonRecordFactory();
             const future_season = futureSeasonRecordFactory();
@@ -54,19 +53,46 @@ describe("Season table operations", () => {
                 test_knexDb,
             );
 
-            const result = await getSeasons({ during: (new Date()).toISOString() }, test_knexDb);
+            const current_result = await getSeasons(
+                { before: new Date().toISOString(), after: new Date().toISOString() },
+                test_knexDb,
+            );
+            expect(current_result, "Returns only the ongoing Season").toHaveLength(1);
+            expect(current_result[0]).toMatchObject(current_season);
 
-            expect(result).toHaveLength(1);
-            expect(result[0]).toMatchObject(current_season);
+            const reverse_result = await getSeasons(
+                {
+                    before: new Date(Date.now() - 1000).toISOString(),
+                    after: new Date(Date.now() + 1000).toISOString(),
+                },
+                test_knexDb,
+            );
+            expect(reverse_result, "`after` > `before`").toHaveLength(1);
+            expect(reverse_result[0]).toMatchObject(current_season);
 
-            // const match_id = await createMatch(mockMatchReport.guild_id, test_knexDb);
-            // const created_match = await test_knexDb("Match")
-            //     .first()
-            //     .where({ match_id });
-            // expect(
-            //     created_match.guild_id,
-            //     "When retrieved, the Match record has the same data as is provided",
-            // ).toEqual(mockMatchReport.guild_id);
+            const current_future_result = await getSeasons(
+                { after: new Date().toISOString() },
+                test_knexDb,
+            );
+            expect(current_future_result, "Returns current and future").toHaveLength(2);
+            expect(current_future_result).toEqual(
+                expect.arrayContaining([
+                    expect.objectContaining(current_season),
+                    expect.objectContaining(future_season),
+                ]),
+            );
+
+            const current_past_result = await getSeasons(
+                { before: new Date().toISOString() },
+                test_knexDb,
+            );
+            expect(current_past_result, "Returns current and past").toHaveLength(2);
+            expect(current_past_result).toEqual(
+                expect.arrayContaining([
+                    expect.objectContaining(current_season),
+                    expect.objectContaining(past_season),
+                ]),
+            );
         });
     });
 });

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

@@ -20,27 +20,32 @@ export const currentSeasonRecordFactory = (
         | Partial<Omit<SeasonRecord, "start_at" | "end_at">>
         | undefined = undefined,
 ): Omit<SeasonRecord, "season_id"> => {
-    return seasonRecordFactory(season_record);
+    const season_name = `Current Season - ${faker.animal.fish()}`;
+    return seasonRecordFactory({ season_name, ...season_record });
 };
 
 export const pastSeasonRecordFactory = (
     season_record:
         | Partial<Omit<SeasonRecord, "start_at" | "end_at">>
         | undefined = undefined,
 ): Omit<SeasonRecord, "season_id"> => {
+    const season_name = `Past Season - ${faker.animal.fish()}`;
+
     const end_at = faker.date.recent().toISOString();
     const start_at = faker.date.past({ refDate: end_at }).toISOString();
-    return seasonRecordFactory({ start_at, end_at, ...season_record });
+    return seasonRecordFactory({ season_name, start_at, end_at, ...season_record });
 };
 
 export const futureSeasonRecordFactory = (
     season_record:
         | Partial<Omit<SeasonRecord, "start_at" | "end_at">>
         | undefined = undefined,
 ): Omit<SeasonRecord, "season_id"> => {
+    const season_name = `Future Season - ${faker.animal.fish()}`;
+
     const start_at = faker.date.soon().toISOString();
     const end_at = faker.date.future({ refDate: start_at }).toISOString();
-    return seasonRecordFactory({ start_at, end_at, ...season_record });
+    return seasonRecordFactory({ season_name, start_at, end_at, ...season_record });
 };
 
 export async function seed(