function findBeaconByInstance(beacons: readonly BeaconRecord[], instanceName: string) {

const beacon = beacons.find((item) => item.instanceName === instanceName);

expect(beacon).toBeDefined();

return beacon as BeaconRecord;

if (!beacon) {

throw new Error(`Expected beacon ${instanceName}`);

}

return beacon;

}

describe("bonjour-discovery", () => {

} catch (error) {

statError = error;

}

expect(statError).toBeDefined();

if (statError === undefined) {

throw new Error(`Expected ${targetPath} to be missing`);

}

expect((statError as { code?: unknown }).code).toBe("ENOENT");

}

const risk = risks.find((candidate) => riskMatches(candidate, fields)) as

| Record<string, unknown>

| undefined;

expect(risk).toBeDefined();

return risk ?? {};

if (!risk) {

throw new Error(`Expected risk ${JSON.stringify(fields)}`);

}

return risk;

}

afterEach(() => {

async function expectRejectCode(promise: Promise<unknown>, expected: string | RegExp) {

const err = await promise.catch((caught: unknown) => caught);

expect(err).toBeDefined();

if (err === undefined) {

throw new Error("Expected promise to reject");

}

const code = (err as NodeJS.ErrnoException).code;

if (typeof expected === "string") {

expect(code).toBe(expected);

function spawnCall(mock: unknown, callIndex: number) {

const calls = (mock as { mock?: { calls?: Array<Array<unknown>> } }).mock?.calls ?? [];

const call = calls.at(callIndex);

expect(call, `spawn call ${callIndex + 1}`).toBeDefined();

return call as Array<unknown>;

if (!call) {

throw new Error(`Expected spawn call ${callIndex + 1}`);

}

return call;

}

function expectSpawn(mock: unknown, callIndex: number, command: string, args: Array<unknown>) {

commitment: CommitmentRecord | undefined,

expected: Partial<CommitmentRecord>,

) {

expect(commitment).toBeDefined();

if (!commitment) {

throw new Error("Expected heartbeat commitment");

}

for (const [key, value] of Object.entries(expected)) {

expect(commitment?.[key as keyof CommitmentRecord]).toEqual(value);

expect(commitment[key as keyof CommitmentRecord]).toEqual(value);

}

}

function getRunCall(runSpy: MockRunOnce, callIndex: number) {

const call = runSpy.mock.calls[callIndex];

expect(call).toBeDefined();

const options = call?.[0];

if (!call) {

throw new Error(`Expected heartbeat run call ${callIndex}`);

}

const options = call[0];

expect(typeof options).toBe("object");

expect(options).not.toBeNull();

return options as Record<string, unknown>;

.slice(params.startIndex ?? 0)

.map((entry) => entry[0] as { agentId?: string; heartbeat?: { every?: string } })

.find((options) => options.agentId === params.agentId);

expect(call).toBeDefined();

if (!call) {

throw new Error(`Expected heartbeat run call for ${params.agentId}`);

}

if (params.expectedHeartbeatEvery) {

expect(call?.heartbeat?.every).toBe(params.expectedHeartbeatEvery);

expect(call.heartbeat?.every).toBe(params.expectedHeartbeatEvery);

}

}

} catch (error) {

saveError = error;

}

expect(saveError).toBeDefined();

if (saveError === undefined) {

throw new Error("Expected saveJsonFile to fail");

}

expect((saveError as { code?: unknown }).code).toBe("ENOENT");

expect(fs.existsSync(missingTargetDir)).toBe(false);

expect(fs.lstatSync(linkPath).isSymbolicLink()).toBe(true);

options?: Record<string, unknown>,

) {

const call = exec.mock.calls[callNumber - 1];

expect(call, `call ${callNumber}`).toBeDefined();

if (!call) {

throw new Error(`Expected exec call ${callNumber}`);

}

expect(call[0]).toBe(command);

expect(call[1]).toEqual(args);

if (options) {