Skip to content

armgit / rea

Public Imported from GitHub
0

Reverse engineer anything with agents, from app behavior down to native binaries.

2.3 KB
Raw Blame
import { afterEach, expect, it } from "vitest";

import { runCliJson as runCli } from "../../fixtures/cliJsonProcess.js";
import {
  startFakeCdpBrowser,
  type FakeCdpBrowser,
} from "../../fixtures/fakeCdpBrowser.js";

const browsers: FakeCdpBrowser[] = [];

afterEach(async () => {
  await Promise.all(browsers.splice(0).map(async (browser) => browser.close()));
});

it("reports missing JSON shapes only when body shapes are selected", async () => {
  const browser = await startFakeCdpBrowser({
    malformedRedirectResponse: true,
    redirectResponseEnvelope: null,
  });
  browsers.push(browser);
  const commonArgs = [
    "inspect-web-page",
    browser.endpoint,
    "allowed-page",
    "--allowed-origins",
    browser.allowedOrigin,
    "--observation-ms",
    "0",
  ];
  const selected = normalizedResult(
    await runCli([...commonArgs, "--include-json-body-shapes", "--json"]),
  );
  expect(selected).toMatchObject({
    network: {
      requests: [
        {
          body_shapes: {
            status: "partial",
            request: expect.any(Object),
            response: null,
          },
        },
      ],
    },
    completeness: {
      unavailable_sections: expect.arrayContaining([
        "network_requests",
        "json_body_shapes",
      ]),
      excluded: expect.arrayContaining([
        {
          section: "json_body_shapes",
          reason: "invalid_protocol_value",
          count: expect.any(Number),
        },
      ]),
    },
  });

  const defaulted = normalizedResult(await runCli([...commonArgs, "--json"]));
  expect(defaulted).toMatchObject({
    network: {
      requests: [
        {
          body_shapes: {
            status: "not_approved",
            request: null,
            response: null,
          },
        },
      ],
    },
  });
  expect(defaulted.completeness).toMatchObject({
    unavailable_sections: expect.not.arrayContaining(["json_body_shapes"]),
  });
});

const normalizedResult = (value: unknown): Record<string, unknown> => {
  if (!isRecord(value) || !isRecord(value.normalized_result))
    throw new TypeError("Missing CLI normalized result");
  return value.normalized_result;
};

const isRecord = (value: unknown): value is Record<string, unknown> =>
  typeof value === "object" && value !== null && !Array.isArray(value);