backnotprop__plannotator/packages/editor/App.permissionModeSetup.test.tsx

/**
 * Permission-mode first-run scope (DOM_TESTS=1)
 *
 * The permission mode decides what happens to Claude Code's permissions after
 * a plan is APPROVED, so the one-time chooser belongs to plan review only. It
 * used to fire in every non-goal-setup Claude Code session, which put an
 * unrelated blocking dialog in front of annotate and archive reviewers.
 */

import { afterAll, afterEach, describe, expect, test } from "bun:test";
import React, { act } from "react";
import { createRoot, type Root } from "react-dom/client";
import {
  resetStorageBackend,
  setStorageBackend,
  type StorageBackend,
} from "@plannotator/ui/utils/storage";

const hasDom = typeof document !== "undefined";

const appModule = hasDom ? await import("./App") : null;
const App = appModule?.default as typeof import("./App")["default"];

const originalFetch = globalThis.fetch;
const originalEventSource = globalThis.EventSource;

// Deliberate copy pin: the dialog's own heading is how this test identifies it.
const DIALOG_HEADING = "New: Permission Mode Preservation";

const memory = new Map<string, string>();
const memoryBackend: StorageBackend = {
  getItem: (key) => memory.get(key) ?? null,
  setItem: (key, value) => void memory.set(key, value),
  removeItem: (key) => void memory.delete(key),
};

function seedAnnouncementsSeen(): void {
  memory.set("plannotator-look-feel-announcement-seen", "2");
  memory.set("plannotator-vim-mode-announcement-seen", "2");
  memory.set("plannotator-plan-ai-announcement-seen", "1");
}

class SilentEventSource {
  static readonly CONNECTING = 0;
  static readonly OPEN = 1;
  static readonly CLOSED = 2;

  readonly CONNECTING = 0;
  readonly OPEN = 1;
  readonly CLOSED = 2;
  readonly readyState = SilentEventSource.OPEN;
  readonly url: string;
  readonly withCredentials = false;
  onerror: ((event: Event) => void) | null = null;
  onmessage: ((event: MessageEvent) => void) | null = null;
  onopen: ((event: Event) => void) | null = null;

  constructor(url: string | URL) {
    this.url = String(url);
  }

  addEventListener(): void {}
  close(): void {}
  dispatchEvent(): boolean { return true; }
  removeEventListener(): void {}
}

function fetchForPlan(plan: Record<string, unknown>): typeof fetch {
  return async (input) => {
    const rawUrl = input instanceof Request ? input.url : String(input);
    if (rawUrl.startsWith("https://api.github.com/")) return new Response(null, { status: 404 });
    const url = new URL(rawUrl, "http://localhost");
    if (url.pathname === "/api/plan") return Response.json(plan);
    if (url.pathname === "/api/archive/plans") return Response.json({ plans: [] });
    if (url.pathname === "/api/ai/capabilities") return Response.json({ available: false, providers: [] });
    if (url.pathname === "/api/draft") return Response.json({ error: "Not found" }, { status: 404 });
    return Response.json({});
  };
}

let root: Root | null = null;
let host: HTMLElement | null = null;

async function settle(): Promise<void> {
  await act(async () => {
    await new Promise((resolve) => setTimeout(resolve, 0));
  });
}

async function mount(plan: Record<string, unknown>): Promise<void> {
  setStorageBackend(memoryBackend);
  seedAnnouncementsSeen();
  globalThis.fetch = fetchForPlan(plan);
  // SAFETY: the App only uses EventSource's constructor, handlers, and close.
  globalThis.EventSource = SilentEventSource as unknown as typeof EventSource;
  host = document.createElement("div");
  document.body.appendChild(host);
  root = createRoot(host);
  await act(async () => { root?.render(<App />); });
  for (let attempt = 0; attempt < 10; attempt += 1) await settle();
}

afterEach(async () => {
  if (root) await act(async () => root?.unmount());
  root = null;
  host?.remove();
  host = null;
  globalThis.fetch = originalFetch;
  globalThis.EventSource = originalEventSource;
  if (hasDom) document.body.replaceChildren();
  memory.clear();
  resetStorageBackend();
});

afterAll(() => {
  resetStorageBackend();
});

describe.if(hasDom)("permission mode first-run chooser", () => {
  test("an unconfigured Claude Code plan review still offers it", async () => {
    await mount({ plan: "# Plan\n\nBody.\n", origin: "claude-code", sharingEnabled: false, serverConfig: {} });

    expect(document.body.textContent).toContain(DIALOG_HEADING);
  });

  test("an annotate session never offers it", async () => {
    await mount({
      plan: "# Notes\n\nBody.\n",
      origin: "claude-code",
      mode: "annotate",
      filePath: "/tmp/notes.md",
      sharingEnabled: false,
      serverConfig: {},
    });

    expect(document.body.textContent).not.toContain(DIALOG_HEADING);
  });

  test("an archive session never offers it", async () => {
    await mount({
      plan: "",
      origin: "claude-code",
      mode: "archive",
      archivePlans: [],
      sharingEnabled: false,
      serverConfig: {},
    });

    expect(document.body.textContent).not.toContain(DIALOG_HEADING);
  });
});