@lunora/testing

import { defineSchema, defineTable, initLunora, v } from "lunorash/server";
import { lunoraTest } from "@lunora/testing";
import { afterEach, expect, test } from "vitest";

const schema = defineSchema({
    messages: defineTable({
        author: v.string(),
        body: v.string(),
    }),
});

// A self-contained test derives its builders from the inline schema. In your
// app you instead import `query` / `mutation` from `@/lunora/_generated/server`.
const { mutation, query } = initLunora.dataModel().create();

const send = mutation.input({ author: v.string(), body: v.string() }).mutation(({ ctx, args }) => ctx.db.insert("messages", args));

const list = query.query(({ ctx }) => ctx.db.query("messages").collect());

test("sends and lists a message", async () => {
    const t = lunoraTest(schema);

    await t.mutation(send, { author: "ada", body: "hi" });

    expect(await t.query(list, {})).toHaveLength(1);
});

const open: ReturnType<typeof lunoraTest>[] = [];

afterEach(() => {
    while (open.length > 0) {
        open.pop()?.close();
    }
});

test("inline access to the db", async () => {
    const t = lunoraTest(schema);

    await t.run(async (ctx) => ctx.db.insert("messages", { author: "grace", body: "from run" }));

    const count = await t.query(async (ctx) => {
        const rows = await ctx.db.query("messages").collect();

        return rows.length;
    });

    expect(count).toBe(1);
    t.close();
});

const whoAmI = query.query(({ ctx }) => ctx.auth.userId);

test("reflects the injected identity", async () => {
    const t = lunoraTest(schema);

    await expect(t.query(whoAmI, {})).resolves.toBeNull();

    const scoped = t.withIdentity({ userId: "u1" });

    await expect(scoped.query(whoAmI, {})).resolves.toBe("u1");

    // A write under the scoped view is visible from the base harness.
    await scoped.mutation(send, { author: "u1", body: "scoped" });
    expect(await t.query(list, {})).toHaveLength(1);

    t.close();
});

import { initLunora, v } from "lunorash/server";

const { internalMutation, mutation } = initLunora.dataModel().create();

const internalSend = internalMutation.input({ author: v.string(), body: v.string() }).mutation(({ ctx, args }) => ctx.db.insert("messages", args));

// A public mutation routes through ctx.runMutation to the internal one.
const sendViaInternal = mutation.input({ author: v.string(), body: v.string() }).mutation(({ ctx, args }) => ctx.runMutation(internalSend, args));

test("internal functions are only reachable via ctx.run*", async () => {
    const t = lunoraTest(schema);

    // Direct call on the external surface is rejected.
    await expect(t.mutation(internalSend, { author: "ada", body: "leak" })).rejects.toThrow("is an internal function");

    // Reached through a public mutation, it runs.
    await t.mutation(sendViaInternal, { author: "grace", body: "ok" });
    expect(await t.query(list, {})).toHaveLength(1);

    t.close();
});

import { vi } from "vitest";

const fakeFetch = vi.fn<typeof globalThis.fetch>().mockResolvedValue(Response.json({ ok: true }));

const t = lunoraTest(schema, { fetch: fakeFetch });
// `ctx.fetch` inside any action now calls `fakeFetch`.

const { mutation } = initLunora.dataModel().create();

const sendMessage = mutation.input({ author: v.string(), body: v.string() }).mutation(({ args, ctx }) => ctx.db.insert("messages", args));

const enqueue = mutation.mutation(({ ctx }) => ctx.scheduler.runAfter(5_000, "messages:send", { author: "ada", body: "hello" }));

test("scheduled mutation runs after advance", async () => {
    const t = lunoraTest(schema, {
        functions: { "messages:send": sendMessage },
    });

    await t.mutation(enqueue, {});
    expect(t.scheduler.list()).toHaveLength(1); // queued, not yet run

    await t.scheduler.advance(10_000); // tick past scheduledFor
    expect(await t.query(list, {})).toHaveLength(1); // sendMessage ran

    t.close();
});

test("subscription re-emits after a mutation", async () => {
    const t = lunoraTest(schema);
    const sub = t.subscribe(list, {});

    expect((await sub.next()).value).toHaveLength(0); // initial snapshot

    await t.mutation(send, { author: "ada", body: "hi" });
    expect((await sub.next()).value).toHaveLength(1); // updated snapshot

    await sub.return(); // unsubscribe
    t.close();
});

const touchesStorage = mutation.mutation(({ ctx }) => ctx.storage.bucket("avatars"));

test("stubbed surfaces throw a clear error", async () => {
    const t = lunoraTest(schema);

    await expect(t.mutation(touchesStorage, {})).rejects.toThrow("ctx.storage is not available in the in-memory @lunora/testing harness (v1)");

    t.close();
});

import { extractLink, waitForMail } from "@lunora/testing";
import { expect, test } from "vitest";

test("password reset email carries a working link", async () => {
    const baseUrl = "http://localhost:8787";
    const adminToken = process.env.LUNORA_ADMIN_TOKEN!;

    // Trigger the flow (e.g. POST /api/auth/forgot-password).
    await fetch(`${baseUrl}/api/auth/forgot-password`, {
        body: JSON.stringify({ email: "alice@example.test" }),
        headers: { "content-type": "application/json" },
        method: "POST",
    });

    const mail = await waitForMail({
        adminToken,
        baseUrl,
        to: "alice@example.test",
        subjectMatch: "Reset your password",
    });

    const resetLink = extractLink(mail, { match: "/reset-password" });

    expect(resetLink).toContain("/reset-password");
    // → visit `resetLink`, set a new password, assert success.
});