pike/glyph Public Public: anyone can read this; nobody can change it.

import { expect, test } from "bun:test";

import { mkdtempSync } from "node:fs";

import { tmpdir } from "node:os";

import { join } from "node:path";

import {

  AT_ONCE,

  canDelete,

  deleteDrawing,

  getDrawing,

  listDrawings,

  startDrawing,

  svgsOf,

} from "./actions.ts";

import { openDb } from "./db.ts";

import { recover, setDrawer, settled } from "./draw.ts";

import type { Who } from "./who.ts";

const db = openDb(mkdtempSync(join(tmpdir(), "app-actions-")));

const anon: Who = { role: "anon" };

const alice: Who = { role: "user", id: "u1", name: "alice" };

const bob: Who = { role: "user", id: "u2", name: "bob" };

const root: Who = { role: "admin", id: "u0", name: "root" };

const SVG = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64"><circle cx="32" cy="32" r="9"/></svg>`;

setDrawer(async () => [SVG]);

test("only a signed-in person draws, as themselves; the drawing fills in after", async () => {

  const refused = startDrawing(db, anon, { prompt: "hello" });

  expect(refused.ok).toBe(false);

  if (!refused.ok) expect(refused.error).toBe("signin_required");

  const started = startDrawing(db, alice, { prompt: "  a   fox  " });

  expect(started.ok).toBe(true);

  if (!started.ok) return;

  expect(started.value).toMatchObject({ prompt: "a fox", kind: "mark", status: "drawing", author_id: "u1" });

  await settled();

  const done = getDrawing(db, alice, { id: started.value.id });

  expect(done.ok && done.value.status).toBe("done");

  expect(done.ok && svgsOf(done.value)).toEqual([SVG]);

});

test("a prompt is 1 to 400 characters and a kind is one of four", () => {

  for (const input of [{ prompt: "" }, { prompt: "   " }, { prompt: "x".repeat(401) }, { prompt: "ok", kind: "poster" }]) {

    const r = startDrawing(db, alice, input);

    expect(r.ok).toBe(false);

    if (!r.ok) expect(r.error).toBe("invalid");

  }

  const icon = startDrawing(db, bob, { prompt: "ok", kind: "icon" });

  expect(icon.ok && icon.value.kind).toBe("icon");

});

test("drawings are their asker's: listed, read and removed by them or an admin", async () => {

  await settled();

  const mine = startDrawing(db, alice, { prompt: "mine" });

  if (!mine.ok) throw new Error(mine.message);

  await settled();

  const bobs = listDrawings(db, bob);

  expect(bobs.ok && bobs.value.every((d) => d.author_id === "u2")).toBe(true);

  expect(listDrawings(db, anon).ok).toBe(false);

  const all = listDrawings(db, root);

  expect(all.ok && all.value.some((d) => d.author_id === "u1") && all.value.some((d) => d.author_id === "u2")).toBe(true);

  const peek = getDrawing(db, bob, { id: mine.value.id });

  expect(!peek.ok && peek.error).toBe("forbidden");

  expect(canDelete(bob, mine.value)).toBe(false);

  expect(canDelete(alice, mine.value)).toBe(true);

  const byBob = deleteDrawing(db, bob, { id: mine.value.id });

  expect(!byBob.ok && byBob.error).toBe("forbidden");

  expect(deleteDrawing(db, root, { id: mine.value.id }).ok).toBe(true);

  const gone = deleteDrawing(db, alice, { id: mine.value.id });

  expect(!gone.ok && gone.error).toBe("not_found");

  const odd = deleteDrawing(db, root, { id: 1.5 });

  expect(!odd.ok && odd.error).toBe("invalid");

});

test("one drawing at a time per person, and a few at once for everyone", async () => {

  await settled();

  const waits: (() => void)[] = [];

  setDrawer(() => new Promise((resolve) => waits.push(() => resolve([SVG]))));

  try {

    expect(startDrawing(db, alice, { prompt: "one" }).ok).toBe(true);

    const again = startDrawing(db, alice, { prompt: "two" });

    expect(!again.ok && again.error).toBe("busy");

    for (let i = 1; i < AT_ONCE; i++)

      expect(startDrawing(db, { role: "user", id: `x${i}`, name: `x${i}` }, { prompt: "p" }).ok).toBe(true);

    const full = startDrawing(db, bob, { prompt: "three" });

    expect(!full.ok && full.message).toContain("others");

  } finally {

    for (const go of waits) go();

    await settled();

    setDrawer(async () => [SVG]);

  }

  expect(startDrawing(db, alice, { prompt: "after" }).ok).toBe(true);

  await settled();

});

test("a drawing a stopped process left half done is failed, not waited on forever", () => {

  const row = db

    .query<{ id: number }, []>("INSERT INTO drawing (prompt, kind, author_id, author_name) VALUES ('p', 'mark', 'u1', 'alice') RETURNING id")

    .get()!;

  expect(recover(db)).toBe(1);

  const after = getDrawing(db, alice, { id: row.id });

  expect(after.ok && after.value.status).toBe("failed");

  expect(after.ok && after.value.error).toContain("restarted");

});