@wangyaoshen/remux 0.3.8-dev.a8ceb0c

package/tests/push.test.js

@@ -0,0 +1,281 @@
+/**
+ * Tests for Web Push module (src/push.ts) and store push subscription CRUD.
+ * VAPID key generation/persistence, subscription management, broadcast logic.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import Database from "better-sqlite3";
+import {
+  _resetDbForTest,
+  closeDb,
+  getSetting,
+  setSetting,
+  savePushSubscription,
+  getPushSubscription,
+  removePushSubscription,
+  listPushSubscriptions,
+  createDevice,
+} from "../src/store.ts";
+
+/** Create an in-memory SQLite DB with the same schema as store.ts. */
+function createTestDb() {
+  const db = new Database(":memory:");
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      name TEXT PRIMARY KEY,
+      created_at INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS tabs (
+      id INTEGER PRIMARY KEY,
+      session_name TEXT NOT NULL,
+      title TEXT NOT NULL DEFAULT 'Tab',
+      scrollback BLOB,
+      ended INTEGER NOT NULL DEFAULT 0,
+      FOREIGN KEY (session_name) REFERENCES sessions(name) ON DELETE CASCADE
+    );
+    CREATE TABLE IF NOT EXISTS devices (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      fingerprint TEXT NOT NULL,
+      trust TEXT NOT NULL DEFAULT 'untrusted',
+      created_at INTEGER NOT NULL,
+      last_seen INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS pair_codes (
+      code TEXT PRIMARY KEY,
+      created_by TEXT NOT NULL,
+      expires_at INTEGER NOT NULL,
+      FOREIGN KEY (created_by) REFERENCES devices(id) ON DELETE CASCADE
+    );
+    CREATE TABLE IF NOT EXISTS settings (
+      key TEXT PRIMARY KEY,
+      value TEXT
+    );
+    CREATE TABLE IF NOT EXISTS push_subscriptions (
+      device_id TEXT PRIMARY KEY,
+      endpoint TEXT NOT NULL,
+      p256dh TEXT NOT NULL,
+      auth TEXT NOT NULL,
+      created_at INTEGER NOT NULL
+    );
+  `);
+  return db;
+}
+
+describe("store: settings KV", () => {
+  let db;
+
+  beforeEach(() => {
+    db = createTestDb();
+    _resetDbForTest(db);
+  });
+
+  afterEach(() => {
+    closeDb();
+  });
+
+  it("getSetting returns null for missing key", () => {
+    expect(getSetting("nonexistent")).toBeNull();
+  });
+
+  it("setSetting creates a new setting", () => {
+    setSetting("test_key", "test_value");
+    expect(getSetting("test_key")).toBe("test_value");
+  });
+
+  it("setSetting upserts existing setting", () => {
+    setSetting("key", "old_value");
+    setSetting("key", "new_value");
+    expect(getSetting("key")).toBe("new_value");
+  });
+
+  it("handles empty string values", () => {
+    setSetting("empty", "");
+    expect(getSetting("empty")).toBe("");
+  });
+});
+
+describe("store: push subscriptions", () => {
+  let db;
+
+  beforeEach(() => {
+    db = createTestDb();
+    _resetDbForTest(db);
+  });
+
+  afterEach(() => {
+    closeDb();
+  });
+
+  it("saves and retrieves a push subscription", () => {
+    savePushSubscription("dev-1", "https://push.example.com/sub1", "p256dh_key", "auth_key");
+    const sub = getPushSubscription("dev-1");
+    expect(sub).not.toBeNull();
+    expect(sub.deviceId).toBe("dev-1");
+    expect(sub.endpoint).toBe("https://push.example.com/sub1");
+    expect(sub.p256dh).toBe("p256dh_key");
+    expect(sub.auth).toBe("auth_key");
+    expect(sub.createdAt).toBeGreaterThan(0);
+  });
+
+  it("returns null for non-existent subscription", () => {
+    expect(getPushSubscription("nonexistent")).toBeNull();
+  });
+
+  it("upserts subscription for same device", () => {
+    savePushSubscription("dev-1", "https://old.example.com", "old_p256dh", "old_auth");
+    savePushSubscription("dev-1", "https://new.example.com", "new_p256dh", "new_auth");
+
+    const sub = getPushSubscription("dev-1");
+    expect(sub.endpoint).toBe("https://new.example.com");
+    expect(sub.p256dh).toBe("new_p256dh");
+    expect(sub.auth).toBe("new_auth");
+
+    // Should only be one record
+    const all = listPushSubscriptions();
+    expect(all).toHaveLength(1);
+  });
+
+  it("removes a push subscription", () => {
+    savePushSubscription("dev-1", "https://push.example.com", "p256dh", "auth");
+    expect(removePushSubscription("dev-1")).toBe(true);
+    expect(getPushSubscription("dev-1")).toBeNull();
+  });
+
+  it("removePushSubscription returns false for non-existent", () => {
+    expect(removePushSubscription("nonexistent")).toBe(false);
+  });
+
+  it("lists all push subscriptions", () => {
+    savePushSubscription("dev-1", "https://push.example.com/1", "p1", "a1");
+    savePushSubscription("dev-2", "https://push.example.com/2", "p2", "a2");
+    savePushSubscription("dev-3", "https://push.example.com/3", "p3", "a3");
+
+    const all = listPushSubscriptions();
+    expect(all).toHaveLength(3);
+    const deviceIds = all.map((s) => s.deviceId);
+    expect(deviceIds).toContain("dev-1");
+    expect(deviceIds).toContain("dev-2");
+    expect(deviceIds).toContain("dev-3");
+  });
+
+  it("empty list when no subscriptions", () => {
+    expect(listPushSubscriptions()).toHaveLength(0);
+  });
+});
+
+describe("push: VAPID key generation and persistence", () => {
+  let db;
+
+  beforeEach(() => {
+    db = createTestDb();
+    _resetDbForTest(db);
+  });
+
+  afterEach(() => {
+    closeDb();
+    vi.restoreAllMocks();
+  });
+
+  it("initPush generates and persists VAPID keys on first run", async () => {
+    // Dynamic import to get fresh module state
+    const { initPush, getVapidPublicKey, isPushReady } = await import("../src/push.ts");
+
+    // Before init
+    // Note: module state persists across tests, so we just verify initPush works
+    initPush();
+
+    expect(isPushReady()).toBe(true);
+    const publicKey = getVapidPublicKey();
+    expect(publicKey).not.toBeNull();
+    expect(typeof publicKey).toBe("string");
+    expect(publicKey.length).toBeGreaterThan(0);
+
+    // Verify keys were persisted in settings
+    const storedPub = getSetting("vapid_public_key");
+    const storedPriv = getSetting("vapid_private_key");
+    expect(storedPub).toBe(publicKey);
+    expect(storedPriv).not.toBeNull();
+    expect(storedPriv.length).toBeGreaterThan(0);
+  });
+
+  it("initPush loads existing VAPID keys on subsequent run", async () => {
+    // Pre-populate settings with known keys
+    const { initPush: initPush2, getVapidPublicKey: getKey2 } = await import("../src/push.ts");
+
+    // First init generates keys
+    initPush2();
+    const firstKey = getKey2();
+
+    // Store the key, re-init should load the same key
+    const storedKey = getSetting("vapid_public_key");
+    expect(storedKey).toBe(firstKey);
+
+    // Re-init should use stored keys (not generate new ones)
+    initPush2();
+    expect(getKey2()).toBe(firstKey);
+  });
+});
+
+describe("push: sendPushNotification", () => {
+  let db;
+
+  beforeEach(() => {
+    db = createTestDb();
+    _resetDbForTest(db);
+  });
+
+  afterEach(() => {
+    closeDb();
+    vi.restoreAllMocks();
+  });
+
+  it("returns false when no subscription exists for device", async () => {
+    const { initPush, sendPushNotification } = await import("../src/push.ts");
+    initPush();
+
+    const result = await sendPushNotification("no-such-device", "Title", "Body");
+    expect(result).toBe(false);
+  });
+});
+
+describe("push: broadcastPush", () => {
+  let db;
+
+  beforeEach(() => {
+    db = createTestDb();
+    _resetDbForTest(db);
+  });
+
+  afterEach(() => {
+    closeDb();
+    vi.restoreAllMocks();
+  });
+
+  it("skips excluded device IDs", async () => {
+    const { initPush, broadcastPush } = await import("../src/push.ts");
+    initPush();
+
+    // Add subscriptions for two devices
+    savePushSubscription("dev-a", "https://push.example.com/a", "pa", "aa");
+    savePushSubscription("dev-b", "https://push.example.com/b", "pb", "ab");
+
+    // broadcastPush with both excluded should effectively be a no-op
+    // (won't throw since it just filters them out)
+    await broadcastPush("Test", "Body", ["dev-a", "dev-b"]);
+
+    // Verify subscriptions still exist (not removed)
+    expect(getPushSubscription("dev-a")).not.toBeNull();
+    expect(getPushSubscription("dev-b")).not.toBeNull();
+  });
+
+  it("handles empty subscription list gracefully", async () => {
+    const { initPush, broadcastPush } = await import("../src/push.ts");
+    initPush();
+
+    // Should not throw
+    await broadcastPush("Test", "Body");
+  });
+});

package/tests/renderers.test.js

@@ -0,0 +1,391 @@
+/**
+ * Tests for workspace content renderers: diff, markdown, ANSI.
+ * Covers detectContentType, renderDiff, renderMarkdown, renderAnsi.
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  detectContentType,
+  renderDiff,
+  renderMarkdown,
+  renderAnsi,
+} from "../src/renderers.ts";
+
+// ── detectContentType ──────────────────────────────────────────
+
+describe("detectContentType", () => {
+  it("identifies unified diff (diff --git header)", () => {
+    const text = `diff --git a/foo.js b/foo.js
+index 1234567..abcdefg 100644
+--- a/foo.js
++++ b/foo.js
+@@ -1,3 +1,4 @@
+ const a = 1;
++const b = 2;
+ const c = 3;`;
+    expect(detectContentType(text)).toBe("diff");
+  });
+
+  it("identifies unified diff (--- and +++ headers)", () => {
+    const text = `--- a/file.txt
++++ b/file.txt
+@@ -1,2 +1,3 @@
+ hello
++world
+ end`;
+    expect(detectContentType(text)).toBe("diff");
+  });
+
+  it("identifies markdown with headers", () => {
+    const text = `# Hello World
+
+This is a paragraph with **bold** text.
+
+## Section Two
+
+- item one
+- item two`;
+    expect(detectContentType(text)).toBe("markdown");
+  });
+
+  it("identifies markdown with code blocks", () => {
+    const text = "Some text\n\n```js\nconst x = 1;\n```\n\nMore text";
+    expect(detectContentType(text)).toBe("markdown");
+  });
+
+  it("identifies markdown with links", () => {
+    const text = "Check out [this link](https://example.com) for more info.";
+    expect(detectContentType(text)).toBe("markdown");
+  });
+
+  it("identifies ANSI escape sequences", () => {
+    const text = "\x1b[31mERROR:\x1b[0m Something went wrong";
+    expect(detectContentType(text)).toBe("ansi");
+  });
+
+  it("returns plain for unformatted text", () => {
+    const text = "Just a regular string with no special formatting.";
+    expect(detectContentType(text)).toBe("plain");
+  });
+
+  it("returns plain for empty string", () => {
+    expect(detectContentType("")).toBe("plain");
+  });
+
+  it("diff takes priority over markdown when both present", () => {
+    const text = `diff --git a/README.md b/README.md
+--- a/README.md
++++ b/README.md
+@@ -1 +1,2 @@
+ # Title
++**bold addition**`;
+    expect(detectContentType(text)).toBe("diff");
+  });
+
+  it("ANSI takes priority over plain text", () => {
+    const text = "normal text \x1b[1mbold text\x1b[0m more normal";
+    expect(detectContentType(text)).toBe("ansi");
+  });
+});
+
+// ── renderDiff ─────────────────────────────────────────────────
+
+describe("renderDiff", () => {
+  it("renders additions with diff-add class", () => {
+    const diff = `--- a/f.txt
++++ b/f.txt
+@@ -1 +1,2 @@
+ existing
++added line`;
+    const html = renderDiff(diff);
+    expect(html).toContain('class="diff-add"');
+    expect(html).toContain("added line");
+  });
+
+  it("renders deletions with diff-del class", () => {
+    const diff = `--- a/f.txt
++++ b/f.txt
+@@ -1,2 +1 @@
+-removed line
+ kept`;
+    const html = renderDiff(diff);
+    expect(html).toContain('class="diff-del"');
+    expect(html).toContain("removed line");
+  });
+
+  it("renders hunk headers with diff-hunk class", () => {
+    const diff = `--- a/f.txt
++++ b/f.txt
+@@ -1,3 +1,3 @@
+ context`;
+    const html = renderDiff(diff);
+    expect(html).toContain('class="diff-hunk"');
+    expect(html).toContain("@@ -1,3 +1,3 @@");
+  });
+
+  it("renders diff --git header with diff-header class", () => {
+    const diff = `diff --git a/f.txt b/f.txt
+index abc..def 100644
+--- a/f.txt
++++ b/f.txt
+@@ -1 +1 @@
+-old
++new`;
+    const html = renderDiff(diff);
+    expect(html).toContain('class="diff-header"');
+    expect(html).toContain("diff --git");
+  });
+
+  it("renders context lines with diff-ctx class", () => {
+    const diff = `--- a/f.txt
++++ b/f.txt
+@@ -1,3 +1,3 @@
+ context line
+-old
++new`;
+    const html = renderDiff(diff);
+    expect(html).toContain('class="diff-ctx"');
+    expect(html).toContain("context line");
+  });
+
+  it("escapes HTML entities in diff content", () => {
+    const diff = `--- a/f.html
++++ b/f.html
+@@ -1 +1 @@
+-<div class="old">old</div>
++<div class="new">new</div>`;
+    const html = renderDiff(diff);
+    expect(html).toContain("&lt;div");
+    expect(html).toContain("&gt;");
+    expect(html).toContain("&quot;");
+    expect(html).not.toContain('<div class="old">');
+    expect(html).not.toContain('<div class="new">');
+  });
+
+  it("includes line numbers", () => {
+    const diff = `--- a/f.txt
++++ b/f.txt
+@@ -1,2 +1,2 @@
+ same
+-old
++new`;
+    const html = renderDiff(diff);
+    expect(html).toContain('class="diff-line-num"');
+  });
+
+  it("wraps output in a diff container", () => {
+    const diff = `--- a/f.txt
++++ b/f.txt
+@@ -1 +1 @@
+-a
++b`;
+    const html = renderDiff(diff);
+    expect(html).toContain('class="diff-container"');
+  });
+});
+
+// ── renderMarkdown ─────────────────────────────────────────────
+
+describe("renderMarkdown", () => {
+  it("renders # headers to <h1>", () => {
+    expect(renderMarkdown("# Title")).toContain("<h1>Title</h1>");
+  });
+
+  it("renders ## headers to <h2>", () => {
+    expect(renderMarkdown("## Subtitle")).toContain("<h2>Subtitle</h2>");
+  });
+
+  it("renders ### headers to <h3>", () => {
+    expect(renderMarkdown("### Section")).toContain("<h3>Section</h3>");
+  });
+
+  it("renders **bold** to <strong>", () => {
+    const html = renderMarkdown("This is **bold** text");
+    expect(html).toContain("<strong>bold</strong>");
+  });
+
+  it("renders *italic* to <em>", () => {
+    const html = renderMarkdown("This is *italic* text");
+    expect(html).toContain("<em>italic</em>");
+  });
+
+  it("renders `inline code` to <code>", () => {
+    const html = renderMarkdown("Use `console.log` here");
+    expect(html).toContain("<code>console.log</code>");
+  });
+
+  it("renders fenced code blocks with language class", () => {
+    const md = "```js\nconst x = 1;\n```";
+    const html = renderMarkdown(md);
+    expect(html).toContain("<pre>");
+    expect(html).toContain('<code class="language-js">');
+    expect(html).toContain("const x = 1;");
+  });
+
+  it("renders fenced code blocks without language", () => {
+    const md = "```\nhello world\n```";
+    const html = renderMarkdown(md);
+    expect(html).toContain("<pre>");
+    expect(html).toContain("<code>");
+    expect(html).toContain("hello world");
+  });
+
+  it("renders unordered lists", () => {
+    const md = "- item one\n- item two\n- item three";
+    const html = renderMarkdown(md);
+    expect(html).toContain("<ul>");
+    expect(html).toContain("<li>item one</li>");
+    expect(html).toContain("<li>item two</li>");
+    expect(html).toContain("</ul>");
+  });
+
+  it("renders ordered lists", () => {
+    const md = "1. first\n2. second\n3. third";
+    const html = renderMarkdown(md);
+    expect(html).toContain("<ol>");
+    expect(html).toContain("<li>first</li>");
+    expect(html).toContain("<li>second</li>");
+    expect(html).toContain("</ol>");
+  });
+
+  it("renders [text](url) links", () => {
+    const md = "Visit [Example](https://example.com) now";
+    const html = renderMarkdown(md);
+    expect(html).toContain('<a href="https://example.com"');
+    expect(html).toContain(">Example</a>");
+  });
+
+  it("renders > blockquotes", () => {
+    const md = "> This is a quote";
+    const html = renderMarkdown(md);
+    expect(html).toContain("<blockquote>");
+    expect(html).toContain("This is a quote");
+    expect(html).toContain("</blockquote>");
+  });
+
+  it("renders --- as <hr>", () => {
+    const md = "above\n\n---\n\nbelow";
+    const html = renderMarkdown(md);
+    expect(html).toContain("<hr>");
+  });
+
+  it("escapes HTML entities in content", () => {
+    const md = "Use `<div>` in your **<template>**";
+    const html = renderMarkdown(md);
+    expect(html).toContain("&lt;div&gt;");
+    expect(html).toContain("&lt;template&gt;");
+    // Should not contain raw HTML tags from user content
+    expect(html).not.toContain("<div>");
+    expect(html).not.toContain("<template>");
+  });
+
+  it("renders paragraphs for plain text blocks", () => {
+    const md = "First paragraph.\n\nSecond paragraph.";
+    const html = renderMarkdown(md);
+    expect(html).toContain("<p>First paragraph.</p>");
+    expect(html).toContain("<p>Second paragraph.</p>");
+  });
+
+  it("wraps output in rendered-md container", () => {
+    const html = renderMarkdown("# Hello");
+    expect(html).toContain('class="rendered-md"');
+  });
+});
+
+// ── renderAnsi ─────────────────────────────────────────────────
+
+describe("renderAnsi", () => {
+  it("converts red ANSI to span with color", () => {
+    const text = "\x1b[31mError\x1b[0m";
+    const html = renderAnsi(text);
+    expect(html).toContain('style="color:#cc0000"');
+    expect(html).toContain("Error");
+  });
+
+  it("converts green ANSI to span with color", () => {
+    const text = "\x1b[32mSuccess\x1b[0m";
+    const html = renderAnsi(text);
+    expect(html).toContain('style="color:#00cc00"');
+    expect(html).toContain("Success");
+  });
+
+  it("converts bold ANSI to span with class", () => {
+    const text = "\x1b[1mBold text\x1b[0m";
+    const html = renderAnsi(text);
+    expect(html).toContain('class="ansi-bold"');
+    expect(html).toContain("Bold text");
+  });
+
+  it("converts dim ANSI to span with class", () => {
+    const text = "\x1b[2mDim text\x1b[0m";
+    const html = renderAnsi(text);
+    expect(html).toContain('class="ansi-dim"');
+    expect(html).toContain("Dim text");
+  });
+
+  it("converts italic ANSI to span with class", () => {
+    const text = "\x1b[3mItalic text\x1b[0m";
+    const html = renderAnsi(text);
+    expect(html).toContain('class="ansi-italic"');
+    expect(html).toContain("Italic text");
+  });
+
+  it("converts underline ANSI to span with class", () => {
+    const text = "\x1b[4mUnderline\x1b[0m";
+    const html = renderAnsi(text);
+    expect(html).toContain('class="ansi-underline"');
+    expect(html).toContain("Underline");
+  });
+
+  it("handles bright/intense colors", () => {
+    const text = "\x1b[91mBright red\x1b[0m";
+    const html = renderAnsi(text);
+    expect(html).toContain("Bright red");
+    // Should have a color style (bright red)
+    expect(html).toContain("style=");
+    expect(html).toContain("color:");
+  });
+
+  it("strips non-SGR escape sequences", () => {
+    // Cursor movement (CSI H), erase (CSI J)
+    const text = "\x1b[2J\x1b[HHello\x1b[31m World\x1b[0m";
+    const html = renderAnsi(text);
+    expect(html).toContain("Hello");
+    expect(html).toContain("World");
+    // Non-SGR sequences should be stripped
+    expect(html).not.toContain("\x1b");
+  });
+
+  it("handles reset correctly", () => {
+    const text = "\x1b[31mred\x1b[0m normal";
+    const html = renderAnsi(text);
+    expect(html).toContain("red");
+    expect(html).toContain("normal");
+    // "normal" should not be inside a colored span
+    // The span for "red" should be closed before "normal"
+  });
+
+  it("escapes HTML entities in ANSI text", () => {
+    const text = "\x1b[31m<script>alert('xss')</script>\x1b[0m";
+    const html = renderAnsi(text);
+    expect(html).toContain("&lt;script&gt;");
+    expect(html).not.toContain("<script>");
+  });
+
+  it("handles combined attributes (bold + color)", () => {
+    const text = "\x1b[1;33mBold yellow\x1b[0m";
+    const html = renderAnsi(text);
+    expect(html).toContain("Bold yellow");
+    // Should have both bold class and yellow color
+    expect(html).toContain("ansi-bold");
+    expect(html).toContain("color:");
+  });
+
+  it("returns plain text when no ANSI sequences present", () => {
+    const text = "Just plain text";
+    const html = renderAnsi(text);
+    expect(html).toContain("Just plain text");
+    // Should not contain any spans
+    expect(html).not.toContain("<span");
+  });
+});