@cosmicdrift/kumiko-dev-server 0.1.0

package/src/__tests__/resolve-stylesheet.test.ts

@@ -0,0 +1,90 @@
+// Unit-Tests für resolveStylesheet — die Verzweigungen aus
+// createKumikoServer's CSS-Setup. Läuft unter vitest auf Node, also
+// ohne Bun.serve und ohne Bun.resolveSync; der Default-Resolution-
+// Pfad (Bun-only) ist hier explizit als "skip silent" abgedeckt.
+//
+// Warum als eigener File statt im create-kumiko-server.integration.ts:
+// die anderen Tests dort booten ein TestStack (DB + Redis), das brauchen
+// wir für reine Resolver-Logik nicht.
+
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, test } from "vitest";
+import { resolveStylesheet } from "../create-kumiko-server";
+
+describe("resolveStylesheet", () => {
+  test("string → resolved absolute path", () => {
+    // Relativ zum CWD aufgelöst — das ist Node's path.resolve-Default.
+    const out = resolveStylesheet({
+      features: [],
+      stylesheet: "./some/stylesheet.css",
+    });
+    expect(out).toMatch(/\/some\/stylesheet\.css$/);
+    expect(out?.startsWith("/")).toBe(true);
+  });
+
+  test("absolute string bleibt unverändert (path.resolve idempotent)", () => {
+    const out = resolveStylesheet({
+      features: [],
+      stylesheet: "/abs/path/styles.css",
+    });
+    expect(out).toBe("/abs/path/styles.css");
+  });
+
+  test("false → undefined (Pipeline explizit aus)", () => {
+    const out = resolveStylesheet({
+      features: [],
+      stylesheet: false,
+      clientEntry: "./entry.tsx",
+    });
+    expect(out).toBeUndefined();
+  });
+
+  test("undefined ohne clientEntry → undefined (kein Browser-Bundle, keine CSS)", () => {
+    const out = resolveStylesheet({
+      features: [],
+    });
+    expect(out).toBeUndefined();
+  });
+
+  test("undefined + clientEntry unter Node (ohne Bun): undefined (silent skip)", () => {
+    // hasBun ist false in vitest-Node — Default-Resolution wird übersprungen,
+    // ohne Throw. Wer im Test eine echte CSS will, übergibt explicit string.
+    // Unter Bun (production) würde Bun.resolveSync den Path liefern; das
+    // testet der bestehende create-kumiko-server.integration.ts.
+    const out = resolveStylesheet({
+      features: [],
+      clientEntry: "./entry.tsx",
+    });
+    expect(out).toBeUndefined();
+  });
+
+  test("undefined + clientEntry + src/styles.css existiert → returns App-Theme-Override", () => {
+    // Auto-Detection greift VOR dem renderer-web-Fallback: Wenn die App
+    // ein eigenes src/styles.css hat (App-Theme-Pattern), wird das
+    // automatisch als Tailwind-Entry genommen — symmetrisch zum prod-
+    // Build (kumiko-build:resolveStylesheetEntry). Ohne diesen Check
+    // müsste jede App `stylesheet:` explizit setzen.
+    // realpath aufgelöst, weil macOS' /var → /private/var Symlink sonst
+    // einen anderen Pfad rauswirft als process.cwd() nach chdir.
+    const tmpDir = realpathSync(mkdtempSync(join(tmpdir(), "kumiko-resolve-styles-")));
+    const srcDir = join(tmpDir, "src");
+    mkdirSync(srcDir);
+    const stylesheet = join(srcDir, "styles.css");
+    writeFileSync(stylesheet, "/* app theme */");
+
+    const cwdBefore = process.cwd();
+    process.chdir(tmpDir);
+    try {
+      const out = resolveStylesheet({
+        features: [],
+        clientEntry: "./entry.tsx",
+      });
+      expect(out).toBe(stylesheet);
+    } finally {
+      process.chdir(cwdBefore);
+      rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+});

package/src/__tests__/resolve-tailwind-cli.test.ts

@@ -0,0 +1,49 @@
+// Unit-Tests für resolveTailwindCli — die zwei Failure-Branches sind
+// genau das, was den dev-server-Crash bei flakigem Netz verhindert:
+// kein Bun → undefined, Package nicht installiert → undefined.
+
+import { describe, expect, test } from "vitest";
+import { resolveTailwindCli } from "../resolve-tailwind-cli";
+
+describe("resolveTailwindCli", () => {
+  test("ohne Bun-Resolver → undefined (silent skip)", () => {
+    const out = resolveTailwindCli({ bun: undefined, cwd: "/somewhere" });
+    expect(out).toBeUndefined();
+  });
+
+  test("Bun.resolveSync wirft → undefined", () => {
+    const out = resolveTailwindCli({
+      bun: {
+        resolveSync: () => {
+          throw new Error("module not found");
+        },
+      },
+      cwd: "/somewhere",
+    });
+    expect(out).toBeUndefined();
+  });
+
+  test("Bun.resolveSync liefert package.json → absoluter Bin-Pfad", () => {
+    const out = resolveTailwindCli({
+      bun: {
+        resolveSync: () => "/repo/node_modules/@tailwindcss/cli/package.json",
+      },
+      cwd: "/repo",
+    });
+    expect(out).toBe("/repo/node_modules/@tailwindcss/cli/dist/index.mjs");
+  });
+
+  test("Bun-Resolver wird mit korrektem id und cwd aufgerufen", () => {
+    const calls: Array<{ id: string; from: string }> = [];
+    resolveTailwindCli({
+      bun: {
+        resolveSync: (id, from) => {
+          calls.push({ id, from });
+          return "/x/node_modules/@tailwindcss/cli/package.json";
+        },
+      },
+      cwd: "/some/working/dir",
+    });
+    expect(calls).toEqual([{ id: "@tailwindcss/cli/package.json", from: "/some/working/dir" }]);
+  });
+});

package/src/__tests__/run-prod-app-spec.test.ts

@@ -0,0 +1,57 @@
+// Spec-Tests für die Bun.serve-Options + Heartbeat-Cadence. Diese
+// Konstanten/Defaults haben Live-Bugs verursacht und sind 1-Zeile-
+// revertierbar — die Tests pinsen Intent + akzeptablen Range gegen
+// "looks like a leak"-Reverts oder "bisschen rauf, sollte reichen"-
+// Tweaks.
+
+import { SSE_HEARTBEAT_INTERVAL_MS } from "@cosmicdrift/kumiko-framework/api";
+import { describe, expect, test } from "vitest";
+import { buildBunServeOptions } from "../run-prod-app";
+
+describe("Bun.serve options for production", () => {
+  test("idleTimeout is 0 (disabled) — required for SSE long-lived connections", () => {
+    // Bun.serve default ist 10s — ohne Override killt das SSE-Streams
+    // mit halbem HTTP/2-RST_STREAM. Spec ist "disabled"; jeder andere
+    // Wert (auch ein vermeintlich "großzügiges" 60) bricht SSE sobald
+    // ein Client den Tab im Hintergrund hat (kein Heartbeat-Read auf
+    // Browser-Seite, Idle-Timer feuert).
+    const opts = buildBunServeOptions(0, () => new Response("ok"));
+    expect(opts.idleTimeout).toBe(0);
+  });
+
+  test("port + fetch werden 1:1 durchgereicht", () => {
+    const fetchHandler = (_req: Request) => new Response("test");
+    const opts = buildBunServeOptions(3000, fetchHandler);
+    expect(opts.port).toBe(3000);
+    expect(opts.fetch).toBe(fetchHandler);
+  });
+});
+
+describe("SSE heartbeat cadence", () => {
+  test("liegt unter dem strengsten Edge-Idle-Timeout (Cloudflare 100s)", () => {
+    // Bun.serve idleTimeout ist disabled (siehe buildBunServeOptions),
+    // damit fällt der Bun-default-10s-Layer raus. Die strengsten
+    // verbleibenden Layer sind CDN/LB-Edges:
+    //   - Cloudflare Edge: 100 s   ← strengster realistischer Layer
+    //   - AWS ALB: 60 s
+    //   - Nginx default: keep-alive 60 s, aber nicht für Streams
+    // Heartbeat muss DEUTLICH darunter liegen damit auch ein verschluckter
+    // Frame nicht zur Connection-Death führt — Faktor 5 ist konservativ.
+    expect(SSE_HEARTBEAT_INTERVAL_MS).toBeLessThan(60_000);
+  });
+
+  test("liegt nicht zu hoch — DefenseInDepth gegen Bun-Default-Drift", () => {
+    // Wenn jemand idleTimeout: 0 wieder rausnimmt (Audit, Linter,
+    // Misverständnis), darf der Heartbeat nicht der einzige
+    // Schutzwall sein der unter dem 10s-Bun-default liegt. ≤30s
+    // gibt Cushion + bleibt deutlich unter Bun-default-10s × 3.
+    expect(SSE_HEARTBEAT_INTERVAL_MS).toBeLessThanOrEqual(30_000);
+  });
+
+  test("ist >= 5 s — Frequency-Wall gegen versehentliches Network-Spam", () => {
+    // 1000 anonyme Viewer × Heartbeat-Frequency darf den Server nicht
+    // mit Frames fluten. 5s = 200 frames/s pro 1000 Clients ist OK.
+    // Unter 5s wäre eher ein "tippfehler" als bewusste Wahl.
+    expect(SSE_HEARTBEAT_INTERVAL_MS).toBeGreaterThanOrEqual(5_000);
+  });
+});