Skip to content
Python
11.1 KB
Raw Blame
import { EventEmitter } from "node:events";
import path from "node:path";
import type {
  BrowserWindow,
  IpcMainInvokeEvent,
  OpenDialogOptions,
  OpenDialogReturnValue,
} from "electron";
import { describe, expect, it, vi } from "vitest";
import { SourceDirectoryPicker } from "./source-directory-picker";

function deferred<T>() {
  let resolve!: (value: T) => void;
  let reject!: (error: Error) => void;
  const promise = new Promise<T>((yes, no) => {
    resolve = yes;
    reject = no;
  });
  return { promise, resolve, reject };
}

function setup() {
  const parent = Object.assign(new EventEmitter(), {
    webContents: Object.assign(new EventEmitter(), {
      mainFrame: { url: "one-memory://app/index.html" },
    }),
  });
  const window = parent as unknown as BrowserWindow;
  const event = {
    sender: parent.webContents,
    senderFrame: parent.webContents.mainFrame,
  } as unknown as IpcMainInvokeEvent;
  const result = deferred<OpenDialogReturnValue>();
  const showOpenDialog = vi.fn(
    (_window: BrowserWindow, _options: OpenDialogOptions) => result.promise,
  );
  const requireWindow = vi.fn((_event: IpcMainInvokeEvent) => window);
  const picker = new SourceDirectoryPicker({ requireWindow, showOpenDialog });
  const selected = path.resolve("/unused/picker-only/with spaces");
  return {
    parent,
    window,
    event,
    result,
    showOpenDialog,
    requireWindow,
    picker,
    selected,
  };
}

describe("source directory picker", () => {
  it.each(["workbuddy", "cursor", "claude-code", "codex"])(
    "opens only one parented directory dialog for %s and returns the exact path",
    async (sourceId) => {
      const f = setup();
      const pending = f.picker.pick(f.event, sourceId);
      await Promise.resolve();
      expect(f.showOpenDialog).toHaveBeenCalledOnce();
      expect(f.showOpenDialog.mock.calls[0]).toEqual([
        f.window,
        expect.objectContaining({ properties: ["openDirectory"] }),
      ]);
      const options = f.showOpenDialog.mock.calls[0]?.[1];
      expect(options).not.toHaveProperty("defaultPath");
      expect(options).not.toHaveProperty("securityScopedBookmarks");
      f.result.resolve({ canceled: false, filePaths: [f.selected] });
      await expect(pending).resolves.toEqual({
        cancelled: false,
        path: f.selected,
      });
      expect(f.requireWindow).toHaveBeenCalledTimes(2);
      expect(f.parent.listenerCount("closed")).toBe(0);
      expect(f.parent.webContents.listenerCount("did-start-navigation")).toBe(
        0,
      );
    },
  );

  it.each(["openclaw", "chatgpt-export", "Cursor", "", null, {}, ["cursor"]])(
    "rejects an unsupported source without opening a dialog: %j",
    async (sourceId) => {
      const f = setup();
      await expect(f.picker.pick(f.event, sourceId)).rejects.toThrow(
        "source_directory_picker_source_unsupported",
      );
      expect(f.showOpenDialog).not.toHaveBeenCalled();
    },
  );

  it("returns cancellation with no path and releases the single-flight slot", async () => {
    const f = setup();
    f.result.resolve({ canceled: true, filePaths: [f.selected] });
    await expect(f.picker.pick(f.event, "cursor")).resolves.toEqual({
      cancelled: true,
      path: null,
    });
    await expect(f.picker.pick(f.event, "codex")).resolves.toEqual({
      cancelled: true,
      path: null,
    });
    expect(f.showOpenDialog).toHaveBeenCalledTimes(2);
  });

  it.each(
    [[], ["relative/path"], [""], ["/bad\0path"], ["/one", "/two"]].map(
      (filePaths) => ({ filePaths }),
    ),
  )(
    "rejects malformed or multiple selected paths: $filePaths",
    async ({ filePaths }) => {
      const f = setup();
      f.result.resolve({ canceled: false, filePaths });
      await expect(f.picker.pick(f.event, "cursor")).rejects.toThrow(
        "source_directory_picker_result_invalid",
      );
    },
  );

  it.each([null, undefined, {}, { canceled: "false", filePaths: ["/unused"] }])(
    "reports invalid native payload %j without exposing native data",
    async (value) => {
      const f = setup();
      f.result.resolve(value as unknown as OpenDialogReturnValue);
      await expect(f.picker.pick(f.event, "cursor")).rejects.toThrow(
        "source_directory_picker_result_invalid",
      );
      expect(f.parent.webContents.eventNames()).toEqual([]);
    },
  );

  it("keeps independent owned windows separate without opening twice in either", async () => {
    const first = setup(),
      second = setup();
    first.requireWindow.mockImplementation((event) =>
      event === first.event ? first.window : second.window,
    );
    first.showOpenDialog.mockImplementation((window) =>
      window === first.window ? first.result.promise : second.result.promise,
    );
    const left = first.picker.pick(first.event, "cursor");
    const right = first.picker.pick(second.event, "codex");
    await expect(first.picker.pick(second.event, "workbuddy")).rejects.toThrow(
      "source_directory_picker_busy",
    );
    first.result.resolve({ canceled: true, filePaths: [] });
    second.result.resolve({ canceled: true, filePaths: [] });
    await expect(left).resolves.toEqual({ cancelled: true, path: null });
    await expect(right).resolves.toEqual({ cancelled: true, path: null });
    expect(first.showOpenDialog).toHaveBeenCalledTimes(2);
  });

  it("cleans up a synchronous native dialog failure and allows retry", async () => {
    const f = setup();
    f.showOpenDialog.mockImplementationOnce(() => {
      throw new Error("native private failure");
    });
    await expect(f.picker.pick(f.event, "cursor")).rejects.toThrow(
      /^source_directory_picker_unavailable$/,
    );
    expect(f.parent.webContents.eventNames()).toEqual([]);
    f.result.resolve({ canceled: true, filePaths: [] });
    await expect(f.picker.pick(f.event, "cursor")).resolves.toEqual({
      cancelled: true,
      path: null,
    });
  });

  it("invalidates even if navigation occurs synchronously while showing the dialog", async () => {
    const f = setup();
    f.showOpenDialog.mockImplementation(() => {
      f.parent.webContents.emit("did-start-navigation", { isMainFrame: true });
      return f.result.promise;
    });
    const pending = f.picker.pick(f.event, "cursor");
    f.result.resolve({ canceled: false, filePaths: [f.selected] });
    await expect(pending).rejects.toThrow(
      "source_directory_picker_context_changed",
    );
  });

  it("rejects concurrent requests, including another source in the same window", async () => {
    const f = setup();
    const pending = f.picker.pick(f.event, "cursor");
    await expect(f.picker.pick(f.event, "workbuddy")).rejects.toThrow(
      "source_directory_picker_busy",
    );
    f.result.resolve({ canceled: true, filePaths: [] });
    await pending;
    expect(f.showOpenDialog).toHaveBeenCalledOnce();
  });

  it("does not open a dialog when the trusted window resolver rejects", async () => {
    const f = setup();
    f.requireWindow.mockImplementation(() => {
      throw new Error("untrusted");
    });
    await expect(f.picker.pick(f.event, "cursor")).rejects.toThrow();
    expect(f.showOpenDialog).not.toHaveBeenCalled();
  });

  it.each(["navigation", "closed", "destroyed", "crashed"])(
    "rejects promptly on %s, discards late results and removes listeners",
    async (kind) => {
      const f = setup();
      const pending = f.picker.pick(f.event, "cursor");
      const rejected = expect(pending).rejects.toThrow(
        "source_directory_picker_context_changed",
      );
      if (kind === "navigation")
        f.parent.webContents.emit("did-start-navigation", {
          isMainFrame: true,
        });
      else if (kind === "closed") f.parent.emit("closed");
      else
        f.parent.webContents.emit(
          kind === "crashed" ? "render-process-gone" : "destroyed",
        );
      await rejected;
      await expect(f.picker.pick(f.event, "codex")).rejects.toThrow(
        "source_directory_picker_busy",
      );
      expect(f.parent.listenerCount("closed")).toBe(0);
      expect(f.parent.webContents.eventNames()).toEqual([]);
      f.result.resolve({ canceled: false, filePaths: [f.selected] });
      await Promise.resolve();
      await Promise.resolve();
      f.picker.dispose();
    },
  );

  it("rejects an A-B-A main-frame navigation even when the URL returns unchanged", async () => {
    const f = setup();
    const pending = f.picker.pick(f.event, "cursor");
    const rejected = expect(pending).rejects.toThrow(
      "source_directory_picker_context_changed",
    );
    f.parent.webContents.emit("did-start-navigation", {
      isMainFrame: true,
      url: "one-memory://app/other",
    });
    f.parent.webContents.mainFrame.url = "one-memory://app/index.html";
    f.result.resolve({ canceled: false, filePaths: [f.selected] });
    await rejected;
  });

  it("does not invalidate a trusted top-frame selection for an unrelated child-frame navigation", async () => {
    const f = setup();
    const pending = f.picker.pick(f.event, "cursor");
    f.parent.webContents.emit("did-start-navigation", { isMainFrame: false });
    f.result.resolve({ canceled: false, filePaths: [f.selected] });
    await expect(pending).resolves.toEqual({
      cancelled: false,
      path: f.selected,
    });
  });

  it.each(["url", "frame", "owner", "trust"])(
    "revalidates %s after the native dialog resolves, even without a notification",
    async (kind) => {
      const f = setup();
      const pending = f.picker.pick(f.event, "cursor");
      if (kind === "url")
        f.parent.webContents.mainFrame.url = "one-memory://app/other";
      else if (kind === "frame")
        f.parent.webContents.mainFrame = { url: "one-memory://app/index.html" };
      else if (kind === "owner")
        f.requireWindow.mockReturnValue({} as BrowserWindow);
      else
        f.requireWindow.mockImplementation(() => {
          throw new Error("destroyed");
        });
      f.result.resolve({ canceled: false, filePaths: [f.selected] });
      await expect(pending).rejects.toThrow(
        "source_directory_picker_context_changed",
      );
    },
  );

  it("does not expose dialog errors or leave the window busy after rejection", async () => {
    const f = setup();
    f.result.reject(new Error("private native error /sensitive/path"));
    await expect(f.picker.pick(f.event, "cursor")).rejects.toThrow(
      /^source_directory_picker_unavailable$/,
    );
    f.showOpenDialog.mockResolvedValue({ canceled: true, filePaths: [] });
    await expect(f.picker.pick(f.event, "cursor")).resolves.toEqual({
      cancelled: true,
      path: null,
    });
    expect(f.parent.webContents.eventNames()).toEqual([]);
  });

  it("disposes pending requests and never reopens after shutdown", async () => {
    const f = setup();
    const pending = f.picker.pick(f.event, "cursor");
    const rejected = expect(pending).rejects.toThrow(
      "source_directory_picker_context_changed",
    );
    f.picker.dispose();
    f.picker.dispose();
    await rejected;
    await expect(f.picker.pick(f.event, "cursor")).rejects.toThrow(
      "source_directory_picker_unavailable",
    );
    expect(f.parent.webContents.eventNames()).toEqual([]);
    f.result.resolve({ canceled: false, filePaths: [f.selected] });
  });
});