mirror of
https://github.com/morluto/rea.git
synced 2026-11-21 22:15:50 +00:00
Use shared captures to verify discovery, document identity, screenshot recovery, and source map evidence and cleanup across varied responses. Remove redundant tests and unused fixture controls.
427 lines
13 KiB
TypeScript
427 lines
13 KiB
TypeScript
import {
|
|
createServer,
|
|
type IncomingMessage,
|
|
type ServerResponse,
|
|
} from "node:http";
|
|
|
|
import type { Duplex } from "node:stream";
|
|
|
|
import { WebSocket, WebSocketServer } from "ws";
|
|
|
|
import { emitEvents } from "./fakeCdpBrowserEvents.js";
|
|
import { resultFor, versionTargetId } from "./fakeCdpBrowserResults.js";
|
|
import { parseCommand, targets } from "./fakeCdpBrowserTargets.js";
|
|
import type {
|
|
FakeCdpBrowser,
|
|
FakeCdpCommand,
|
|
FakeOptions,
|
|
} from "./fakeCdpBrowserTypes.js";
|
|
|
|
export type { FakeCdpBrowser, FakeOptions } from "./fakeCdpBrowserTypes.js";
|
|
/** Start a real HTTP/WebSocket fake at the same seams as a user-owned browser. */
|
|
export const startFakeCdpBrowser = async (
|
|
options: FakeOptions = {},
|
|
): Promise<FakeCdpBrowser> => {
|
|
const commands: FakeCdpCommand[] = [];
|
|
const httpRequests: {
|
|
url: string;
|
|
authorization: string | undefined;
|
|
cookie: string | undefined;
|
|
referer: string | undefined;
|
|
}[] = [];
|
|
const sockets = new Set<WebSocket>();
|
|
// Upgrades a handshake gate holds; close() destroys them.
|
|
const heldUpgrades = new Set<Duplex>();
|
|
let openedConnections = 0;
|
|
let frameTreeReads = 0;
|
|
let port = 0;
|
|
const http = createServer((request, response) =>
|
|
respondToHttpRequest(request, response, httpRequests, options, () => port),
|
|
);
|
|
const webSockets = new WebSocketServer({ noServer: true });
|
|
http.on("upgrade", (request, socket, head) => {
|
|
const accept = (): void => {
|
|
if (socket.destroyed) return;
|
|
if (
|
|
request.url !== "/devtools/browser/fake" &&
|
|
request.url !== "/devtools/page/allowed-page" &&
|
|
request.url !== "/devtools/page/allowed-page-with-socket" &&
|
|
request.url !== "/devtools/page/electron-page"
|
|
) {
|
|
socket.destroy();
|
|
return;
|
|
}
|
|
webSockets.handleUpgrade(request, socket, head, (webSocket) =>
|
|
webSockets.emit("connection", webSocket, request),
|
|
);
|
|
};
|
|
if (options.handshakeGate !== undefined) {
|
|
// Flowing, so a client that abandons the handshake is observed.
|
|
socket.resume();
|
|
socket.once("end", () => socket.destroy());
|
|
heldUpgrades.add(socket);
|
|
socket.once("close", () => heldUpgrades.delete(socket));
|
|
void options.handshakeGate.hold(request.url ?? "").then(
|
|
() => {
|
|
heldUpgrades.delete(socket);
|
|
accept();
|
|
},
|
|
() => socket.destroy(),
|
|
);
|
|
return;
|
|
}
|
|
if (options.handshakeDelayMs === undefined) {
|
|
accept();
|
|
return;
|
|
}
|
|
const timer = setTimeout(accept, options.handshakeDelayMs);
|
|
socket.once("close", () => clearTimeout(timer));
|
|
});
|
|
webSockets.on("connection", (socket: WebSocket, request: IncomingMessage) => {
|
|
const directPage = request.url?.startsWith("/devtools/page/") === true;
|
|
const sessionState: SocketSessionState = {
|
|
nextSessionNumber: 1,
|
|
attachedSessions: new Set(),
|
|
};
|
|
openedConnections += 1;
|
|
sockets.add(socket);
|
|
socket.on("close", () => sockets.delete(socket));
|
|
socket.on("message", (raw) => {
|
|
const command = parseCommand(raw.toString());
|
|
commands.push(command);
|
|
if (
|
|
handleSimulatedWireFault(
|
|
socket,
|
|
command,
|
|
directPage,
|
|
options,
|
|
sessionState,
|
|
port,
|
|
)
|
|
)
|
|
return;
|
|
if (command.method === "Page.getFrameTree") frameTreeReads += 1;
|
|
const delayMs = options.commandDelayMs?.(command);
|
|
if (delayMs !== undefined && delayMs > 0) {
|
|
const currentFrameReads = frameTreeReads;
|
|
const timer = setTimeout(() => {
|
|
if (socket.readyState === WebSocket.OPEN)
|
|
replyToCommand(
|
|
socket,
|
|
command,
|
|
port,
|
|
options,
|
|
currentFrameReads,
|
|
sessionState,
|
|
);
|
|
}, delayMs);
|
|
socket.once("close", () => clearTimeout(timer));
|
|
return;
|
|
}
|
|
replyToCommand(
|
|
socket,
|
|
command,
|
|
port,
|
|
options,
|
|
frameTreeReads,
|
|
sessionState,
|
|
);
|
|
});
|
|
});
|
|
await new Promise<void>((resolve, reject) => {
|
|
http.once("error", reject);
|
|
http.listen(0, "127.0.0.1", () => resolve());
|
|
});
|
|
port = boundPort(http.address());
|
|
const endpoint = `http://127.0.0.1:${String(port)}`;
|
|
return {
|
|
endpoint,
|
|
browserWebSocketUrl: `ws://127.0.0.1:${String(port)}/devtools/browser/fake`,
|
|
allowedOrigin: endpoint,
|
|
commands,
|
|
activeConnectionCount: () => sockets.size,
|
|
openedConnectionCount: () => openedConnections,
|
|
emitRawMessage(message) {
|
|
for (const socket of sockets) socket.send(message);
|
|
},
|
|
emitEvent(event) {
|
|
for (const socket of sockets) socket.send(JSON.stringify(event));
|
|
},
|
|
closeActiveConnections() {
|
|
for (const socket of sockets) socket.close();
|
|
},
|
|
httpRequests,
|
|
async close() {
|
|
for (const socket of heldUpgrades) socket.destroy();
|
|
for (const socket of sockets) socket.terminate();
|
|
await new Promise<void>((resolve) => webSockets.close(() => resolve()));
|
|
await new Promise<void>((resolve, reject) =>
|
|
http.close((error) =>
|
|
error === undefined ? resolve() : reject(error),
|
|
),
|
|
);
|
|
},
|
|
};
|
|
};
|
|
|
|
const respondToHttpRequest = (
|
|
request: IncomingMessage,
|
|
response: ServerResponse,
|
|
requests: {
|
|
url: string;
|
|
authorization: string | undefined;
|
|
cookie: string | undefined;
|
|
referer: string | undefined;
|
|
}[],
|
|
options: FakeOptions,
|
|
port: () => number,
|
|
): void => {
|
|
requests.push({
|
|
url: request.url ?? "",
|
|
authorization: request.headers.authorization,
|
|
cookie: request.headers.cookie,
|
|
referer: request.headers.referer,
|
|
});
|
|
response.setHeader("content-type", "application/json");
|
|
const portNumber = port();
|
|
if (serveSourceMap(request, response, options)) return;
|
|
const finish = (body: string): void => {
|
|
if (options.discoveryDelayMs === undefined) {
|
|
response.end(body);
|
|
return;
|
|
}
|
|
setTimeout(() => response.end(body), options.discoveryDelayMs);
|
|
};
|
|
if (request.url === "/json/version") {
|
|
finish(
|
|
options.oversizedDiscovery === true
|
|
? " ".repeat(65 * 1_024)
|
|
: options.malformedDiscovery === true
|
|
? "{not-json"
|
|
: JSON.stringify({
|
|
Browser: "FakeChrome/1.0",
|
|
"Protocol-Version": "1.3",
|
|
"User-Agent": "FakeChrome",
|
|
"V8-Version": "13.0",
|
|
"WebKit-Version": "fake-revision",
|
|
webSocketDebuggerUrl:
|
|
options.invalidBrowserWebSocket === true
|
|
? `ws://localhost:${String(portNumber)}/devtools/invalid/fake`
|
|
: options.pageScopedVersionWebSocket === true
|
|
? `ws://localhost:${String(portNumber)}/devtools/page/${versionTargetId(options)}`
|
|
: `ws://localhost:${String(portNumber)}/devtools/browser/fake`,
|
|
}),
|
|
);
|
|
return;
|
|
}
|
|
if (request.url === "/json/list") {
|
|
finish(JSON.stringify(targets(portNumber, options)));
|
|
return;
|
|
}
|
|
response.statusCode = 404;
|
|
response.end("{}");
|
|
};
|
|
|
|
const boundPort = (
|
|
address: string | null | { readonly port: number },
|
|
): number => {
|
|
if (address === null || typeof address === "string")
|
|
throw new Error("Fake CDP server did not bind a TCP address");
|
|
return address.port;
|
|
};
|
|
|
|
/** Every ordinary reply uses the request's flattened target session. */
|
|
const sendCommandReply = (
|
|
socket: WebSocket,
|
|
command: FakeCdpCommand,
|
|
payload:
|
|
| { readonly result: unknown }
|
|
| { readonly error: { readonly code: number; readonly message: string } },
|
|
): void => {
|
|
socket.send(
|
|
JSON.stringify({
|
|
id: command.id,
|
|
...(command.sessionId === undefined
|
|
? {}
|
|
: { sessionId: command.sessionId }),
|
|
...payload,
|
|
}),
|
|
);
|
|
};
|
|
|
|
interface SocketSessionState {
|
|
nextSessionNumber: number;
|
|
readonly attachedSessions: Set<string>;
|
|
}
|
|
|
|
const sessionNotFoundError = {
|
|
code: -32_001,
|
|
message: "Session with given id not found",
|
|
} as const;
|
|
|
|
const handleSimulatedWireFault = (
|
|
socket: WebSocket,
|
|
command: FakeCdpCommand,
|
|
directPage: boolean,
|
|
options: FakeOptions,
|
|
sessionState: SocketSessionState,
|
|
port: number,
|
|
): boolean => {
|
|
const commandError = options.commandError?.(command);
|
|
if (commandError !== undefined) {
|
|
if (options.eventsBeforeReply?.includes(command.method) === true)
|
|
sendCommandEvents(socket, command, port, options);
|
|
sendCommandReply(socket, command, { error: commandError });
|
|
if (options.closeAfterMethod === command.method)
|
|
setImmediate(() => socket.close());
|
|
return true;
|
|
}
|
|
if (options.closeOnMethod === command.method) {
|
|
socket.close();
|
|
return true;
|
|
}
|
|
if (options.hangOnMethod === command.method) return true;
|
|
if (options.malformedMessageOnMethod === command.method) {
|
|
socket.send("{not-json");
|
|
return true;
|
|
}
|
|
if (options.unsupportedMethods?.includes(command.method) === true) {
|
|
sendCommandReply(socket, command, {
|
|
error: { code: -32_601, message: "Method not found" },
|
|
});
|
|
return true;
|
|
}
|
|
if (
|
|
directPage &&
|
|
(command.method === "Target.attachToTarget" ||
|
|
command.sessionId !== undefined)
|
|
) {
|
|
sendCommandReply(socket, command, {
|
|
error: { code: -32_600, message: "Direct page socket expected" },
|
|
});
|
|
return true;
|
|
}
|
|
if (
|
|
command.sessionId !== undefined &&
|
|
!sessionState.attachedSessions.has(command.sessionId)
|
|
) {
|
|
sendCommandReply(socket, command, { error: sessionNotFoundError });
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
|
|
/** Emit a configured producer reply and its associated events. */
|
|
const replyToCommand = (
|
|
socket: WebSocket,
|
|
command: FakeCdpCommand,
|
|
port: number,
|
|
options: FakeOptions,
|
|
frameTreeReads: number,
|
|
sessionState: SocketSessionState,
|
|
): void => {
|
|
if (
|
|
command.sessionId !== undefined &&
|
|
!sessionState.attachedSessions.has(command.sessionId)
|
|
) {
|
|
sendCommandReply(socket, command, { error: sessionNotFoundError });
|
|
return;
|
|
}
|
|
const customResult = options.commandResult?.(
|
|
command,
|
|
`http://127.0.0.1:${String(port)}`,
|
|
frameTreeReads,
|
|
);
|
|
if (
|
|
customResult === undefined &&
|
|
command.method === "Target.detachFromTarget"
|
|
) {
|
|
const sessionId = command.params.sessionId;
|
|
if (
|
|
typeof sessionId !== "string" ||
|
|
!sessionState.attachedSessions.delete(sessionId)
|
|
) {
|
|
sendCommandReply(socket, command, { error: sessionNotFoundError });
|
|
return;
|
|
}
|
|
}
|
|
const result =
|
|
customResult ??
|
|
resultFor(command, port, options, frameTreeReads, () => {
|
|
const sessionId = `session-${String(sessionState.nextSessionNumber)}`;
|
|
sessionState.nextSessionNumber += 1;
|
|
return sessionId;
|
|
});
|
|
if (
|
|
command.method === "Target.attachToTarget" &&
|
|
result !== undefined &&
|
|
typeof result.sessionId === "string" &&
|
|
result.sessionId.length > 0
|
|
) {
|
|
sessionState.attachedSessions.add(result.sessionId);
|
|
}
|
|
if (result === undefined) {
|
|
sendCommandReply(socket, command, {
|
|
error: {
|
|
code: -32_601,
|
|
message: `Method not found: ${command.method}`,
|
|
},
|
|
});
|
|
return;
|
|
}
|
|
const reply = () => {
|
|
sendCommandReply(socket, command, { result });
|
|
if (options.malformedEventOnMethod === command.method)
|
|
socket.send("{not-json");
|
|
if (options.malformedEventShapeOnMethod === command.method)
|
|
socket.send(JSON.stringify({ method: 42 }));
|
|
};
|
|
const eventsFirst =
|
|
options.eventsBeforeReply?.includes(command.method) === true;
|
|
if (!eventsFirst) reply();
|
|
sendCommandEvents(socket, command, port, options);
|
|
if (eventsFirst) reply();
|
|
if (options.closeAfterMethod === command.method)
|
|
setImmediate(() => socket.close());
|
|
};
|
|
|
|
const sendCommandEvents = (
|
|
socket: WebSocket,
|
|
command: FakeCdpCommand,
|
|
port: number,
|
|
options: FakeOptions,
|
|
): void => {
|
|
const customEvents = options.commandEvents?.(
|
|
command,
|
|
`http://127.0.0.1:${String(port)}`,
|
|
);
|
|
if (customEvents === undefined) emitEvents(socket, command, port, options);
|
|
else for (const event of customEvents) socket.send(JSON.stringify(event));
|
|
};
|
|
|
|
const serveSourceMap = (
|
|
request: IncomingMessage,
|
|
response: ServerResponse,
|
|
options: FakeOptions,
|
|
): boolean => {
|
|
if (options.sourceMapReply?.(request.url ?? "", response) === true)
|
|
return true;
|
|
if (
|
|
options.hangSourceMap === true &&
|
|
request.url?.startsWith("/app.js.map") === true
|
|
)
|
|
return true;
|
|
if (options.sourceMapBody === undefined) return false;
|
|
if (request.url?.startsWith("/app.js.map") === true) {
|
|
if (options.sourceMapRedirect !== undefined)
|
|
response.writeHead(302, { location: options.sourceMapRedirect }).end();
|
|
else response.end(options.sourceMapBody);
|
|
return true;
|
|
}
|
|
if (request.url === options.sourceMapRedirect) {
|
|
response.end(options.sourceMapBody);
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|