@flrande/browserctl 0.1.0 → 0.2.0-dev.9.1

package/apps/browserctl/src/commands/command-wrappers.test.ts

@@ -0,0 +1,386 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const { callDaemonToolMock } = vi.hoisted(() => ({
+  callDaemonToolMock: vi.fn()
+}));
+
+vi.mock("../daemon-client", () => ({
+  callDaemonTool: callDaemonToolMock
+}));
+
+import { DAEMON_STARTUP_ARGUMENT } from "./common";
+import { runA11ySnapshotCommand } from "./a11y-snapshot";
+import { runActCommand } from "./act";
+import { runConsoleListCommand } from "./console-list";
+import { runCookieClearCommand } from "./cookie-clear";
+import { runCookieGetCommand } from "./cookie-get";
+import { runCookieSetCommand } from "./cookie-set";
+import { runDialogArmCommand } from "./dialog-arm";
+import { runDomQueryAllCommand } from "./dom-query-all";
+import { runDomQueryCommand } from "./dom-query";
+import { runDownloadTriggerCommand } from "./download-trigger";
+import { runDownloadWaitCommand } from "./download-wait";
+import { runElementScreenshotCommand } from "./element-screenshot";
+import { runFrameListCommand } from "./frame-list";
+import { runFrameSnapshotCommand } from "./frame-snapshot";
+import { runNetworkWaitForCommand } from "./network-wait-for";
+import { runProfileListCommand } from "./profile-list";
+import { runProfileUseCommand } from "./profile-use";
+import { runResponseBodyCommand } from "./response-body";
+import { runScreenshotCommand } from "./screenshot";
+import { runSnapshotCommand } from "./snapshot";
+import { runStatusCommand } from "./status";
+import { runStorageGetCommand } from "./storage-get";
+import { runStorageSetCommand } from "./storage-set";
+import { runTabCloseCommand } from "./tab-close";
+import { runTabFocusCommand } from "./tab-focus";
+import { runTabOpenCommand } from "./tab-open";
+import { runTabsCommand } from "./tabs";
+import { runUploadArmCommand } from "./upload-arm";
+
+type WrapperCase = {
+  name: string;
+  run: () => Promise<unknown>;
+  expectedTool: string;
+  expectedArgs: Record<string, unknown>;
+};
+
+const BASE_ARGS = {
+  sessionId: "cli:local"
+};
+
+const CASES: WrapperCase[] = [
+  {
+    name: "status",
+    run: async () => await runStatusCommand(),
+    expectedTool: "browser.status",
+    expectedArgs: { ...BASE_ARGS }
+  },
+  {
+    name: "tabs",
+    run: async () => await runTabsCommand(),
+    expectedTool: "browser.tab.list",
+    expectedArgs: { ...BASE_ARGS }
+  },
+  {
+    name: "profile-list",
+    run: async () => await runProfileListCommand(),
+    expectedTool: "browser.profile.list",
+    expectedArgs: { ...BASE_ARGS }
+  },
+  {
+    name: "profile-use",
+    run: async () => await runProfileUseCommand(["managed"]),
+    expectedTool: "browser.profile.use",
+    expectedArgs: {
+      ...BASE_ARGS,
+      profile: "managed"
+    }
+  },
+  {
+    name: "tab-open",
+    run: async () => await runTabOpenCommand(["https://example.com"]),
+    expectedTool: "browser.tab.open",
+    expectedArgs: {
+      ...BASE_ARGS,
+      url: "https://example.com"
+    }
+  },
+  {
+    name: "tab-focus",
+    run: async () => await runTabFocusCommand(["target:1"]),
+    expectedTool: "browser.tab.focus",
+    expectedArgs: {
+      ...BASE_ARGS,
+      targetId: "target:1"
+    }
+  },
+  {
+    name: "tab-close",
+    run: async () => await runTabCloseCommand(["target:1"]),
+    expectedTool: "browser.tab.close",
+    expectedArgs: {
+      ...BASE_ARGS,
+      targetId: "target:1"
+    }
+  },
+  {
+    name: "snapshot",
+    run: async () => await runSnapshotCommand(["target:1"]),
+    expectedTool: "browser.snapshot",
+    expectedArgs: {
+      ...BASE_ARGS,
+      targetId: "target:1"
+    }
+  },
+  {
+    name: "screenshot",
+    run: async () => await runScreenshotCommand(["target:1"]),
+    expectedTool: "browser.screenshot",
+    expectedArgs: {
+      ...BASE_ARGS,
+      targetId: "target:1"
+    }
+  },
+  {
+    name: "dom-query",
+    run: async () => await runDomQueryCommand(["target:1", "#root"]),
+    expectedTool: "browser.dom.query",
+    expectedArgs: {
+      ...BASE_ARGS,
+      targetId: "target:1",
+      selector: "#root"
+    }
+  },
+  {
+    name: "dom-query-all",
+    run: async () => await runDomQueryAllCommand(["target:1", ".item"]),
+    expectedTool: "browser.dom.queryAll",
+    expectedArgs: {
+      ...BASE_ARGS,
+      targetId: "target:1",
+      selector: ".item"
+    }
+  },
+  {
+    name: "element-screenshot",
+    run: async () => await runElementScreenshotCommand(["target:1", "#hero"]),
+    expectedTool: "browser.element.screenshot",
+    expectedArgs: {
+      ...BASE_ARGS,
+      targetId: "target:1",
+      selector: "#hero"
+    }
+  },
+  {
+    name: "a11y-snapshot",
+    run: async () => await runA11ySnapshotCommand(["target:1", "  #main  "]),
+    expectedTool: "browser.a11y.snapshot",
+    expectedArgs: {
+      ...BASE_ARGS,
+      targetId: "target:1",
+      selector: "#main"
+    }
+  },
+  {
+    name: "network-wait-for",
+    run: async () =>
+      await runNetworkWaitForCommand([
+        "target:1",
+        "/api/items",
+        "--method",
+        "post",
+        "--status",
+        "201",
+        "--timeout-ms",
+        "3000",
+        "--poll-ms",
+        "50"
+      ]),
+    expectedTool: "browser.network.waitFor",
+    expectedArgs: {
+      ...BASE_ARGS,
+      targetId: "target:1",
+      urlPattern: "/api/items",
+      method: "POST",
+      status: 201,
+      timeoutMs: 3000,
+      pollMs: 50
+    }
+  },
+  {
+    name: "cookie-get",
+    run: async () => await runCookieGetCommand(["target:1", "  sid  "]),
+    expectedTool: "browser.cookie.get",
+    expectedArgs: {
+      ...BASE_ARGS,
+      targetId: "target:1",
+      name: "sid"
+    }
+  },
+  {
+    name: "cookie-set",
+    run: async () => await runCookieSetCommand(["target:1", "sid", "abc", "  https://example.com  "]),
+    expectedTool: "browser.cookie.set",
+    expectedArgs: {
+      ...BASE_ARGS,
+      targetId: "target:1",
+      name: "sid",
+      value: "abc",
+      url: "https://example.com"
+    }
+  },
+  {
+    name: "cookie-clear",
+    run: async () => await runCookieClearCommand(["target:1", "  sid  "]),
+    expectedTool: "browser.cookie.clear",
+    expectedArgs: {
+      ...BASE_ARGS,
+      targetId: "target:1",
+      name: "sid"
+    }
+  },
+  {
+    name: "storage-get",
+    run: async () => await runStorageGetCommand(["target:1", "local", "theme"]),
+    expectedTool: "browser.storage.get",
+    expectedArgs: {
+      ...BASE_ARGS,
+      targetId: "target:1",
+      scope: "local",
+      key: "theme"
+    }
+  },
+  {
+    name: "storage-set",
+    run: async () => await runStorageSetCommand(["target:1", "session", "token", "abc"]),
+    expectedTool: "browser.storage.set",
+    expectedArgs: {
+      ...BASE_ARGS,
+      targetId: "target:1",
+      scope: "session",
+      key: "token",
+      value: "abc"
+    }
+  },
+  {
+    name: "frame-list",
+    run: async () => await runFrameListCommand(["target:1"]),
+    expectedTool: "browser.frame.list",
+    expectedArgs: {
+      ...BASE_ARGS,
+      targetId: "target:1"
+    }
+  },
+  {
+    name: "frame-snapshot",
+    run: async () => await runFrameSnapshotCommand(["target:1", "frame:0"]),
+    expectedTool: "browser.frame.snapshot",
+    expectedArgs: {
+      ...BASE_ARGS,
+      targetId: "target:1",
+      frameId: "frame:0"
+    }
+  },
+  {
+    name: "act",
+    run: async () => await runActCommand(["click", "target:1"]),
+    expectedTool: "browser.act",
+    expectedArgs: {
+      ...BASE_ARGS,
+      targetId: "target:1",
+      action: {
+        type: "click"
+      }
+    }
+  },
+  {
+    name: "upload-arm",
+    run: async () => await runUploadArmCommand(["target:1", "a.txt", "b.txt"]),
+    expectedTool: "browser.upload.arm",
+    expectedArgs: {
+      ...BASE_ARGS,
+      targetId: "target:1",
+      files: ["a.txt", "b.txt"]
+    }
+  },
+  {
+    name: "dialog-arm",
+    run: async () => await runDialogArmCommand(["target:1"]),
+    expectedTool: "browser.dialog.arm",
+    expectedArgs: {
+      ...BASE_ARGS,
+      targetId: "target:1"
+    }
+  },
+  {
+    name: "download-trigger",
+    run: async () => await runDownloadTriggerCommand(["target:1"]),
+    expectedTool: "browser.download.trigger",
+    expectedArgs: {
+      ...BASE_ARGS,
+      targetId: "target:1"
+    }
+  },
+  {
+    name: "download-wait",
+    run: async () => await runDownloadWaitCommand(["target:1", "downloads/file.bin"]),
+    expectedTool: "browser.download.wait",
+    expectedArgs: {
+      ...BASE_ARGS,
+      targetId: "target:1",
+      path: "downloads/file.bin"
+    }
+  },
+  {
+    name: "console-list",
+    run: async () => await runConsoleListCommand(["target:1"]),
+    expectedTool: "browser.console.list",
+    expectedArgs: {
+      ...BASE_ARGS,
+      targetId: "target:1"
+    }
+  },
+  {
+    name: "response-body",
+    run: async () => await runResponseBodyCommand(["target:1", "request:1"]),
+    expectedTool: "browser.network.responseBody",
+    expectedArgs: {
+      ...BASE_ARGS,
+      targetId: "target:1",
+      requestId: "request:1"
+    }
+  }
+];
+
+afterEach(() => {
+  callDaemonToolMock.mockReset();
+  delete process.env.BROWSERCTL_AUTH_TOKEN;
+  delete process.env.BROWSERCTL_BROWSER;
+});
+
+describe("command wrappers", () => {
+  it.each(CASES)("forwards $name to daemon tool", async ({ run, expectedTool, expectedArgs }) => {
+    callDaemonToolMock.mockResolvedValue({ ok: true });
+
+    await run();
+
+    expect(callDaemonToolMock).toHaveBeenCalledTimes(1);
+    expect(callDaemonToolMock).toHaveBeenCalledWith(expectedTool, expectedArgs);
+  });
+
+  it("forwards session/profile/token/browser context switches", async () => {
+    callDaemonToolMock.mockResolvedValue({ ok: true });
+
+    await runStatusCommand([
+      "--session",
+      "session:matrix",
+      "--profile",
+      "chrome-relay",
+      "--token",
+      "cli-token",
+      "--browser",
+      "edge"
+    ]);
+
+    expect(callDaemonToolMock).toHaveBeenCalledTimes(1);
+    expect(callDaemonToolMock).toHaveBeenCalledWith("browser.status", {
+      sessionId: "session:matrix",
+      profile: "chrome-relay",
+      authToken: "cli-token",
+      [DAEMON_STARTUP_ARGUMENT]: {
+        managedLocal: {
+          browserName: "chromium",
+          channel: "msedge"
+        }
+      }
+    });
+  });
+
+  it("throws for upload-arm when files are missing", async () => {
+    await expect(runUploadArmCommand(["target:1"]))
+      .rejects.toThrow("Missing required argument: files.");
+
+    expect(callDaemonToolMock).not.toHaveBeenCalled();
+  });
+});

package/apps/browserctl/src/commands/network-wait-for.test.ts

@@ -0,0 +1,90 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const { callDaemonToolMock } = vi.hoisted(() => ({
+  callDaemonToolMock: vi.fn()
+}));
+
+vi.mock("../daemon-client", () => ({
+  callDaemonTool: callDaemonToolMock
+}));
+
+import { runNetworkWaitForCommand } from "./network-wait-for";
+
+afterEach(() => {
+  callDaemonToolMock.mockReset();
+});
+
+describe("runNetworkWaitForCommand", () => {
+  it("supports positional timeout shorthand", async () => {
+    callDaemonToolMock.mockResolvedValue({ ok: true });
+
+    await runNetworkWaitForCommand(["target:1", "/api", "2500"]);
+
+    expect(callDaemonToolMock).toHaveBeenCalledTimes(1);
+    expect(callDaemonToolMock).toHaveBeenCalledWith("browser.network.waitFor", {
+      sessionId: "cli:local",
+      targetId: "target:1",
+      urlPattern: "/api",
+      timeoutMs: 2500
+    });
+  });
+
+  it.each([
+    {
+      label: "--method",
+      args: ["target:1", "/api", "--method"],
+      message: "Missing value for --method."
+    },
+    {
+      label: "--status",
+      args: ["target:1", "/api", "--status"],
+      message: "Missing value for --status."
+    },
+    {
+      label: "--timeout-ms",
+      args: ["target:1", "/api", "--timeout-ms"],
+      message: "Missing value for --timeout-ms."
+    },
+    {
+      label: "--poll-ms",
+      args: ["target:1", "/api", "--poll-ms"],
+      message: "Missing value for --poll-ms."
+    }
+  ])("throws when $label is missing a value", async ({ args, message }) => {
+    await expect(runNetworkWaitForCommand(args)).rejects.toThrow(message);
+    expect(callDaemonToolMock).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    {
+      label: "status <= 0",
+      args: ["target:1", "/api", "--status", "0"],
+      message: "--status must be a positive integer."
+    },
+    {
+      label: "timeout <= 0",
+      args: ["target:1", "/api", "--timeout-ms", "-10"],
+      message: "--timeout-ms must be a positive integer."
+    },
+    {
+      label: "poll <= 0",
+      args: ["target:1", "/api", "--poll-ms", "0"],
+      message: "--poll-ms must be a positive integer."
+    },
+    {
+      label: "positional timeout <= 0",
+      args: ["target:1", "/api", "0"],
+      message: "timeoutMs must be a positive integer."
+    }
+  ])("throws on non-positive numeric option: $label", async ({ args, message }) => {
+    await expect(runNetworkWaitForCommand(args)).rejects.toThrow(message);
+    expect(callDaemonToolMock).not.toHaveBeenCalled();
+  });
+
+  it("throws on unknown option token", async () => {
+    await expect(runNetworkWaitForCommand(["target:1", "/api", "1200", "--unknown"]))
+      .rejects.toThrow("Unknown network-wait-for option: --unknown");
+
+    expect(callDaemonToolMock).not.toHaveBeenCalled();
+  });
+});