public commit

app/__test__/modules/AppAuth.spec.ts

@@ -0,0 +1,60 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { AuthController } from "../../src/auth/api/AuthController";
+import { AppAuth, type ModuleBuildContext } from "../../src/modules";
+import { disableConsoleLog, enableConsoleLog } from "../helper";
+import { makeCtx, moduleTestSuite } from "./module-test-suite";
+
+describe("AppAuth", () => {
+   moduleTestSuite(AppAuth);
+
+   let ctx: ModuleBuildContext;
+
+   beforeEach(() => {
+      ctx = makeCtx();
+   });
+
+   test("secrets", async () => {
+      // auth must be enabled, otherwise default config is returned
+      const auth = new AppAuth({ enabled: true }, ctx);
+      await auth.build();
+
+      const config = auth.toJSON();
+      expect(config.jwt).toBeUndefined();
+      expect(config.strategies.password.config).toBeUndefined();
+   });
+
+   test("creates user on register", async () => {
+      const auth = new AppAuth(
+         {
+            enabled: true
+         },
+         ctx
+      );
+
+      await auth.build();
+      await ctx.em.schema().sync({ force: true });
+
+      // expect no users, but the query to pass
+      const res = await ctx.em.repository("users").findMany();
+      expect(res.data.length).toBe(0);
+
+      const app = new AuthController(auth).getController();
+
+      {
+         disableConsoleLog();
+         const res = await app.request("/password/register", {
+            method: "POST",
+            body: JSON.stringify({
+               email: "some@body.com",
+               password: "123456"
+            })
+         });
+         enableConsoleLog();
+         expect(res.status).toBe(200);
+
+         const { data: users } = await ctx.em.repository("users").findMany();
+         expect(users.length).toBe(1);
+         expect(users[0].email).toBe("some@body.com");
+      }
+   });
+});

app/__test__/modules/AppData.spec.ts

@@ -0,0 +1,13 @@
+import { describe, expect, test } from "bun:test";
+import { parse } from "../../src/core/utils";
+import { fieldsSchema } from "../../src/data/data-schema";
+import { AppData } from "../../src/modules";
+import { moduleTestSuite } from "./module-test-suite";
+
+describe("AppData", () => {
+   moduleTestSuite(AppData);
+
+   test("field config construction", () => {
+      expect(parse(fieldsSchema, { type: "text" })).toBeDefined();
+   });
+});

app/__test__/modules/AppMedia.spec.ts

@@ -0,0 +1,7 @@
+import { describe } from "bun:test";
+import { AppMedia } from "../../src/modules";
+import { moduleTestSuite } from "./module-test-suite";
+
+describe("AppMedia", () => {
+   moduleTestSuite(AppMedia);
+});

app/__test__/modules/module-test-suite.ts

@@ -0,0 +1,43 @@
+import { beforeEach, describe, expect, it } from "bun:test";
+
+import { Hono } from "hono";
+import { Guard } from "../../src/auth";
+import { EventManager } from "../../src/core/events";
+import { Default, stripMark } from "../../src/core/utils";
+import { EntityManager } from "../../src/data";
+import type { Module, ModuleBuildContext } from "../../src/modules/Module";
+import { getDummyConnection } from "../helper";
+
+export function makeCtx(overrides?: Partial<ModuleBuildContext>): ModuleBuildContext {
+   const { dummyConnection } = getDummyConnection();
+   return {
+      connection: dummyConnection,
+      server: new Hono(),
+      em: new EntityManager([], dummyConnection),
+      emgr: new EventManager(),
+      guard: new Guard(),
+      ...overrides
+   };
+}
+
+export function moduleTestSuite(module: { new (): Module }) {
+   let ctx: ModuleBuildContext;
+
+   beforeEach(() => {
+      ctx = makeCtx();
+   });
+
+   describe("Module Tests", () => {
+      it("should build without exceptions", async () => {
+         const m = new module();
+         await m.setContext(ctx).build();
+         expect(m.toJSON()).toBeDefined();
+      });
+
+      it("uses the default config", async () => {
+         const m = new module();
+         await m.setContext(ctx).build();
+         expect(stripMark(m.toJSON())).toEqual(Default(m.getSchema(), {}));
+      });
+   });
+}