all repos — sz-chrome-remote-cdp @ master

pi-browser-harness, patched to drive a Chrome on another host over CDP, with castle_cdp_search web search

test/cdp/session-evaluate-test.ts (view raw)

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 
import { test, describe } from "node:test";
import assert from "node:assert/strict";
import { evaluateJson } from "../../src/cdp/session";
import type { CdpSession } from "../../src/cdp/session";
import { err, ok } from "../../src/util/result";

const isNumberArray = (v: unknown): v is ReadonlyArray<number> =>
  Array.isArray(v) && v.every((x) => typeof x === "number");

const fakeSession = (payload: unknown): CdpSession =>
  ({
    call: async () => ok(payload),
  }) as unknown as CdpSession;

type Call = { method: string; args: unknown[] };

const recordingSession = (result: unknown): { session: CdpSession; calls: Call[] } => {
  const calls: Call[] = [];
  const session = {
    call: async (...args: unknown[]) => {
      calls.push({ method: "call", args });
      return result;
    },
    callOnTarget: async (...args: unknown[]) => {
      calls.push({ method: "callOnTarget", args });
      return result;
    },
  } as unknown as CdpSession;
  return { session, calls };
};

describe("evaluateJson", () => {
  test("unwraps result.value and applies the guard", async () => {
    const s = fakeSession({ result: { type: "object", value: [1, 2, 3] } });
    const r = await evaluateJson(s, "[1,2,3]", isNumberArray);
    assert.equal(r.success, true);
    if (r.success) assert.deepEqual(r.data, [1, 2, 3]);
  });

  test("surfaces a page exception as an error", async () => {
    const s = fakeSession({
      result: { type: "undefined" },
      exceptionDetails: { text: "ReferenceError: x is not defined" },
    });
    const r = await evaluateJson(s, "x", isNumberArray);
    assert.equal(r.success, false);
    if (!r.success) {
      assert.equal(r.error.kind, "remote_error");
      assert.match(r.error.message, /ReferenceError/);
    }
  });

  test("rejects a value that fails the guard", async () => {
    const s = fakeSession({ result: { type: "string", value: "nope" } });
    const r = await evaluateJson(s, "'nope'", isNumberArray);
    assert.equal(r.success, false);
    if (!r.success) assert.equal(r.error.kind, "invalid_response");
  });

  test("dispatches via callOnTarget when opts.sessionId is set", async () => {
    const { session, calls } = recordingSession(ok({ result: { type: "object", value: [4, 5] } }));
    const r = await evaluateJson(session, "[4,5]", isNumberArray, { sessionId: "sess-1" });
    assert.equal(r.success, true);
    if (r.success) assert.deepEqual(r.data, [4, 5]);
    assert.equal(calls.length, 1);
    assert.equal(calls[0]?.method, "callOnTarget");
    const [, , sessionIdArg] = calls[0]?.args ?? [];
    assert.equal(sessionIdArg, "sess-1");
  });

  test("dispatches via call when no opts are given", async () => {
    const { session, calls } = recordingSession(ok({ result: { type: "object", value: [1] } }));
    const r = await evaluateJson(session, "[1]", isNumberArray);
    assert.equal(r.success, true);
    assert.equal(calls.length, 1);
    assert.equal(calls[0]?.method, "call");
    assert.equal(calls.some((c) => c.method === "callOnTarget"), false);
  });

  test("passes timeoutMs through to the transport options", async () => {
    const { session, calls } = recordingSession(ok({ result: { type: "object", value: [1] } }));
    await evaluateJson(session, "[1]", isNumberArray, { timeoutMs: 5000 });
    const [, , optsArg] = calls[0]?.args ?? [];
    assert.deepEqual(optsArg, { timeoutMs: 5000 });
  });

  test("passes through a transport failure unchanged", async () => {
    const failure = err({ kind: "timeout" as const, message: "timed out" });
    const { session } = recordingSession(failure);
    const r = await evaluateJson(session, "[1]", isNumberArray);
    assert.equal(r.success, false);
    if (!r.success) {
      assert.equal(r.error.kind, "timeout");
      assert.equal(r.error.message, "timed out");
    }
  });
});