@hegeldev/hegel 0.1.0

package/dist/protocol.js

@@ -0,0 +1,77 @@
+import { addExtension } from "cbor-x";
+import { crc32 } from "./crc32.js";
+import { wtf8ToString } from "./wtf8.js";
+export const MAGIC = 0x4845474c;
+export const HEADER_SIZE = 20;
+export const TERMINATOR = 0x0a;
+export const REPLY_BIT = 0x80000000;
+export const CLOSE_STREAM_MESSAGE_ID = 0x7fffffff;
+export const CLOSE_STREAM_PAYLOAD = Buffer.from([0xfe]);
+export const HANDSHAKE_STRING = "hegel_handshake_start";
+// cbor-x requires a Class for addExtension, but we only use the decode
+// path (tag 91 is sent by the server, never by the client).
+addExtension({
+    /* v8 ignore start */
+    Class: class HegelString {
+    },
+    tag: 91,
+    encode: () => Buffer.alloc(0),
+    /* v8 ignore stop */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    decode(data) {
+        if (Buffer.isBuffer(data))
+            return wtf8ToString(data);
+        if (data instanceof Uint8Array)
+            return wtf8ToString(Buffer.from(data));
+        return String(data);
+    },
+});
+/**
+ * Encode a packet into a single Buffer ready for writing.
+ */
+export function encodePacket(packet) {
+    const messageIdRaw = packet.isReply ? (packet.messageId | REPLY_BIT) >>> 0 : packet.messageId;
+    const header = Buffer.alloc(HEADER_SIZE);
+    header.writeUInt32BE(MAGIC, 0);
+    // checksum placeholder at offset 4 (already 0)
+    header.writeUInt32BE(packet.streamId, 8);
+    header.writeUInt32BE(messageIdRaw, 12);
+    header.writeUInt32BE(packet.payload.length, 16);
+    // CRC32 over header (checksum zeroed) + payload
+    const checksum = crc32(Buffer.concat([header, packet.payload]));
+    header.writeUInt32BE(checksum, 4);
+    return Buffer.concat([header, packet.payload, Buffer.from([TERMINATOR])]);
+}
+/**
+ * Decode a packet from raw bytes.
+ *
+ * @param readExact - Function that synchronously reads exactly `n` bytes.
+ * @returns The decoded packet.
+ */
+export function readPacketFrom(readExact) {
+    const header = readExact(HEADER_SIZE);
+    const magic = header.readUInt32BE(0);
+    if (magic !== MAGIC) {
+        throw new Error(`Invalid magic: expected 0x${MAGIC.toString(16)}, got 0x${magic.toString(16)}`);
+    }
+    const checksum = header.readUInt32BE(4);
+    const streamId = header.readUInt32BE(8);
+    const messageIdRaw = header.readUInt32BE(12);
+    const payloadLength = header.readUInt32BE(16);
+    const isReply = (messageIdRaw & REPLY_BIT) !== 0;
+    const messageId = messageIdRaw & ~REPLY_BIT;
+    const payload = readExact(payloadLength);
+    const terminator = readExact(1);
+    if (terminator[0] !== TERMINATOR) {
+        throw new Error(`Invalid terminator: expected 0x${TERMINATOR.toString(16)}, got 0x${terminator[0].toString(16)}`);
+    }
+    // Verify CRC32
+    const headerForCheck = Buffer.from(header);
+    headerForCheck.writeUInt32BE(0, 4); // zero out checksum field
+    const computed = crc32(Buffer.concat([headerForCheck, payload]));
+    if (computed !== checksum) {
+        throw new Error(`CRC32 mismatch: expected 0x${checksum.toString(16)}, got 0x${computed.toString(16)}`);
+    }
+    return { streamId, messageId, isReply, payload };
+}
+//# sourceMappingURL=protocol.js.map

package/dist/protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.js","sourceRoot":"","sources":["../src/protocol.ts"],"names":[],"mappings":"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"}

package/dist/runner.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Test runner: Hegel builder, Settings, and test lifecycle.
+ *
+ * @packageDocumentation
+ */
+import { TestCase, type DataSource } from "./testCase.js";
+import type { Connection, Stream } from "./connection.js";
+export declare enum Verbosity {
+    Quiet = "quiet",
+    Normal = "normal",
+    Verbose = "verbose",
+    Debug = "debug"
+}
+export declare enum HealthCheck {
+    FilterTooMuch = "filter_too_much",
+    TooSlow = "too_slow",
+    TestCasesTooLarge = "test_cases_too_large",
+    LargeInitialTestCase = "large_initial_test_case"
+}
+export type Database = {
+    kind: "unset";
+} | {
+    kind: "disabled";
+} | {
+    kind: "path";
+    path: string;
+};
+export declare const Database: {
+    unset: Database;
+    disabled: Database;
+    fromPath: (path: string) => Database;
+};
+export interface Settings {
+    testCases: number;
+    seed: number | null;
+    verbosity: Verbosity;
+    derandomize: boolean;
+    database: Database;
+    suppressHealthCheck: HealthCheck[];
+}
+export declare function defaultSettings(): Settings;
+/**
+ * DataSource implementation that communicates with the hegel server
+ * over a multiplexed stream connection.
+ */
+export declare class ServerDataSource implements DataSource {
+    private stream;
+    private connection;
+    private _aborted;
+    constructor(connection: Connection, stream: Stream);
+    private sendRequest;
+    generate(schema: Record<string, unknown>): unknown;
+    startSpan(label: number): void;
+    stopSpan(discard: boolean): void;
+    newCollection(minSize: number, maxSize?: number): number;
+    collectionMore(collectionId: number): boolean;
+    collectionReject(collectionId: number, why?: string): void;
+    markComplete(status: string, origin: string | null): void;
+    testAborted(): boolean;
+}
+export type TestCaseResult = {
+    status: "valid";
+} | {
+    status: "invalid";
+} | {
+    status: "interesting";
+    error: unknown;
+};
+export declare function runTestCase(dataSource: DataSource, testFn: (tc: TestCase) => void, isFinal: boolean): TestCaseResult;
+export interface TestLocation {
+    function: string;
+    file: string;
+    class: string;
+    beginLine: number;
+}
+export declare class Hegel {
+    private testFn;
+    private _settings;
+    private _databaseKey;
+    private _testLocation;
+    constructor(testFn: (tc: TestCase) => void);
+    /** Override default settings. Returns this for chaining. */
+    settings(s: Partial<Settings>): this;
+    /** Set the database key for persisting failing examples across runs. */
+    databaseKey(key: string): this;
+    /** Set the test location for Antithesis integration. */
+    testLocation(location: TestLocation): this;
+    /**
+     * Execute the property-based test.
+     *
+     * Connects to the hegel server (spawning it on first use), runs the
+     * configured number of test cases, and throws if any test case fails.
+     * On failure, the failing input is shrunk to a minimal example and
+     * replayed with draw output printed to stderr.
+     */
+    run(): void;
+}
+/**
+ * Wrap a property-based test body into a function suitable for a test runner.
+ *
+ * @example
+ * ```ts
+ * import { test } from 'vitest';
+ * import * as hegel from 'hegel';
+ * import * as gs from 'hegel/generators';
+ *
+ * test('addition is commutative', hegel.test((tc) => {
+ *   const x = tc.draw(gs.integers());
+ *   const y = tc.draw(gs.integers());
+ *   expect(x + y).toBe(y + x);
+ * }));
+ * ```
+ */
+export declare function test(testFn: (tc: TestCase) => void, settings?: Partial<Settings>): () => void;
+//# sourceMappingURL=runner.d.ts.map

package/dist/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"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"}

package/dist/runner.js

@@ -0,0 +1,455 @@
+/**
+ * Test runner: Hegel builder, Settings, and test lifecycle.
+ *
+ * @packageDocumentation
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { HegelSession } from "./session.js";
+import { TestCase, StopTestError, AssumeError } from "./testCase.js";
+import { encode, decode } from "cbor-x";
+export var Verbosity;
+(function (Verbosity) {
+    Verbosity["Quiet"] = "quiet";
+    Verbosity["Normal"] = "normal";
+    Verbosity["Verbose"] = "verbose";
+    Verbosity["Debug"] = "debug";
+})(Verbosity || (Verbosity = {}));
+export var HealthCheck;
+(function (HealthCheck) {
+    HealthCheck["FilterTooMuch"] = "filter_too_much";
+    HealthCheck["TooSlow"] = "too_slow";
+    HealthCheck["TestCasesTooLarge"] = "test_cases_too_large";
+    HealthCheck["LargeInitialTestCase"] = "large_initial_test_case";
+})(HealthCheck || (HealthCheck = {}));
+export const Database = {
+    unset: { kind: "unset" },
+    disabled: { kind: "disabled" },
+    fromPath: (path) => ({ kind: "path", path }),
+};
+function isInCI() {
+    const ciVars = [
+        ["CI", null],
+        ["BITBUCKET_COMMIT", null],
+        ["BUILDKITE", "true"],
+        ["CIRCLECI", "true"],
+        ["CIRRUS_CI", "true"],
+        ["CODEBUILD_BUILD_ID", null],
+        ["GITHUB_ACTIONS", "true"],
+        ["GITLAB_CI", null],
+        ["HEROKU_TEST_RUN_ID", null],
+        ["TEAMCITY_VERSION", null],
+        ["TF_BUILD", "true"],
+        ["bamboo.buildKey", null],
+    ];
+    return ciVars.some(([key, value]) => {
+        if (value === null) {
+            return process.env[key] !== undefined;
+        }
+        return process.env[key] === value;
+    });
+}
+export function defaultSettings() {
+    const inCI = isInCI();
+    return {
+        testCases: 100,
+        seed: null,
+        verbosity: Verbosity.Normal,
+        derandomize: inCI,
+        database: inCI ? Database.disabled : Database.unset,
+        suppressHealthCheck: [],
+    };
+}
+// ---------------------------------------------------------------------------
+// ServerDataSource
+// ---------------------------------------------------------------------------
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/**
+ * DataSource implementation that communicates with the hegel server
+ * over a multiplexed stream connection.
+ */
+export class ServerDataSource {
+    stream;
+    connection;
+    _aborted = false;
+    constructor(connection, stream) {
+        this.connection = connection;
+        this.stream = stream;
+    }
+    sendRequest(command, payload = {}) {
+        /* v8 ignore start: reachable via stopSpan after abort, but swallowed by catch */
+        if (this._aborted) {
+            throw new StopTestError();
+        }
+        /* v8 ignore stop */
+        const message = { command, ...payload };
+        const encoded = encode(message);
+        const id = this.stream.sendRequest(encoded);
+        const responseBytes = this.stream.receiveReply(id);
+        const response = decode(responseBytes);
+        /* v8 ignore start: server always returns CBOR maps */
+        if (!isRecord(response))
+            return response;
+        /* v8 ignore stop */
+        if ("error" in response) {
+            /* v8 ignore start: server always sends type field */
+            const errorType = String(response["type"] ?? "");
+            /* v8 ignore stop */
+            const errorMsg = JSON.stringify(response["error"]);
+            if (errorMsg.includes("overflow") ||
+                errorMsg.includes("StopTest") ||
+                errorType.includes("overflow") ||
+                errorType.includes("StopTest")) {
+                this.stream.markClosed();
+                this._aborted = true;
+                throw new StopTestError();
+            }
+            /* v8 ignore start: FlakyStrategyDefinition is detected in test_done results, not here */
+            if (errorMsg.includes("FlakyStrategyDefinition") || errorMsg.includes("FlakyReplay")) {
+                this.stream.markClosed();
+                this._aborted = true;
+                throw new StopTestError();
+            }
+            /* v8 ignore stop */
+            /* v8 ignore start: requires server to crash mid-request */
+            if (this.connection.hasServerExited()) {
+                throw new Error(`Server process crashed`);
+            }
+            /* v8 ignore stop */
+            throw new Error(`Server error (${errorType}): ${errorMsg}`);
+        }
+        /* v8 ignore start: server always wraps responses in {result: ...} */
+        if ("result" in response) {
+            return response["result"];
+        }
+        return response;
+        /* v8 ignore stop */
+    }
+    generate(schema) {
+        return this.sendRequest("generate", { schema });
+    }
+    startSpan(label) {
+        this.sendRequest("start_span", { label });
+    }
+    stopSpan(discard) {
+        this.sendRequest("stop_span", { discard });
+    }
+    newCollection(minSize, maxSize) {
+        const payload = { min_size: minSize };
+        if (maxSize !== undefined) {
+            payload["max_size"] = maxSize;
+        }
+        const result = this.sendRequest("new_collection", payload);
+        /* v8 ignore start: server always returns integer for new_collection */
+        if (typeof result !== "number")
+            throw new Error(`Expected integer from new_collection, got ${typeof result}`);
+        /* v8 ignore stop */
+        return result;
+    }
+    collectionMore(collectionId) {
+        const result = this.sendRequest("collection_more", {
+            collection_id: collectionId,
+        });
+        /* v8 ignore start: server always returns boolean for collection_more */
+        if (typeof result !== "boolean")
+            throw new Error(`Expected boolean from collection_more, got ${typeof result}`);
+        /* v8 ignore stop */
+        return result;
+    }
+    collectionReject(collectionId, why) {
+        const payload = {
+            collection_id: collectionId,
+        };
+        /* v8 ignore start: callers always provide why */
+        if (why !== undefined) {
+            payload["why"] = why;
+        }
+        /* v8 ignore stop */
+        this.sendRequest("collection_reject", payload);
+    }
+    markComplete(status, origin) {
+        try {
+            const message = {
+                command: "mark_complete",
+                status,
+                origin: origin ?? null,
+            };
+            const encoded = encode(message);
+            const id = this.stream.sendRequest(encoded);
+            this.stream.receiveReply(id);
+        }
+        catch {
+            // ignore errors during mark_complete
+        }
+        this.stream.close();
+    }
+    testAborted() {
+        return this._aborted;
+    }
+}
+function extractOrigin(error) {
+    if (!(error instanceof Error) || !error.stack)
+        return null;
+    const lines = error.stack.split("\n");
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("at ") && !trimmed.includes("node_modules")) {
+            return trimmed;
+        }
+    }
+    /* v8 ignore start: all stack traces in practice have at least one non-node_modules frame */
+    return null;
+    /* v8 ignore stop */
+}
+export function runTestCase(dataSource, testFn, isFinal) {
+    const tc = new TestCase(dataSource, isFinal);
+    let result;
+    let origin = null;
+    try {
+        testFn(tc);
+        result = { status: "valid" };
+    }
+    catch (e) {
+        if (e instanceof AssumeError) {
+            result = { status: "invalid" };
+        }
+        else if (e instanceof StopTestError) {
+            result = { status: "invalid" };
+        }
+        else {
+            result = { status: "interesting", error: e };
+            origin = extractOrigin(e);
+            if (isFinal) {
+                const msg = e instanceof Error ? e.message : String(e);
+                console.error(`\n${msg}`);
+                if (e instanceof Error && e.stack) {
+                    console.error(e.stack);
+                }
+            }
+        }
+    }
+    // Send mark_complete unless test was aborted (server already closed stream)
+    if (!tc.testAborted) {
+        const status = result.status === "valid" ? "VALID" : result.status === "invalid" ? "INVALID" : "INTERESTING";
+        dataSource.markComplete(status, origin);
+    }
+    return result;
+}
+/* v8 ignore start: only runs inside Antithesis */
+function isRunningInAntithesis() {
+    const dir = process.env["ANTITHESIS_OUTPUT_DIR"];
+    return dir !== undefined && dir !== "";
+}
+function emitAntithesisAssertion(location, passed) {
+    const dir = process.env["ANTITHESIS_OUTPUT_DIR"];
+    if (!dir)
+        return;
+    const filePath = path.join(dir, "sdk.jsonl");
+    const id = `${location.class}::${location.function} passes properties`;
+    const locationObj = {
+        class: location.class,
+        function: location.function,
+        file: location.file,
+        begin_line: location.beginLine,
+        begin_column: 0,
+    };
+    const declaration = {
+        antithesis_assert: {
+            hit: false,
+            must_hit: true,
+            assert_type: "always",
+            display_type: "Always",
+            condition: false,
+            id,
+            message: id,
+            location: locationObj,
+        },
+    };
+    const evaluation = {
+        antithesis_assert: {
+            hit: true,
+            must_hit: true,
+            assert_type: "always",
+            display_type: "Always",
+            condition: passed,
+            id,
+            message: id,
+            location: locationObj,
+        },
+    };
+    fs.appendFileSync(filePath, JSON.stringify(declaration) + "\n" + JSON.stringify(evaluation) + "\n");
+    /* v8 ignore stop */
+}
+export class Hegel {
+    testFn;
+    _settings;
+    _databaseKey = null;
+    _testLocation = null;
+    constructor(testFn) {
+        this.testFn = testFn;
+        this._settings = defaultSettings();
+    }
+    /** Override default settings. Returns this for chaining. */
+    settings(s) {
+        Object.assign(this._settings, s);
+        return this;
+    }
+    /** Set the database key for persisting failing examples across runs. */
+    databaseKey(key) {
+        this._databaseKey = key;
+        return this;
+    }
+    /** Set the test location for Antithesis integration. */
+    /* v8 ignore start: only used inside Antithesis */
+    testLocation(location) {
+        this._testLocation = location;
+        return this;
+    }
+    /* v8 ignore stop */
+    /**
+     * Execute the property-based test.
+     *
+     * Connects to the hegel server (spawning it on first use), runs the
+     * configured number of test cases, and throws if any test case fails.
+     * On failure, the failing input is shrunk to a minimal example and
+     * replayed with draw output printed to stderr.
+     */
+    run() {
+        const session = HegelSession.get();
+        const connection = session.connection;
+        const testStream = connection.newStream();
+        // Build run_test message
+        const suppressNames = this._settings.suppressHealthCheck.map((c) => c);
+        const databaseKeyValue = this._databaseKey !== null ? Buffer.from(this._databaseKey, "utf-8") : null;
+        const runTestMsg = {
+            command: "run_test",
+            test_cases: this._settings.testCases,
+            seed: this._settings.seed,
+            stream_id: testStream.streamId,
+            database_key: databaseKeyValue,
+            derandomize: this._settings.derandomize,
+        };
+        // Database field
+        if (this._settings.database.kind === "disabled") {
+            runTestMsg["database"] = null;
+        }
+        else if (this._settings.database.kind === "path") {
+            runTestMsg["database"] = this._settings.database.path;
+        }
+        if (suppressNames.length > 0) {
+            runTestMsg["suppress_health_check"] = suppressNames;
+        }
+        // Send run_test on control stream
+        const controlPayload = encode(runTestMsg);
+        const reqId = session.controlStream.sendRequest(controlPayload);
+        session.controlStream.receiveReply(reqId);
+        // Event loop
+        let resultData;
+        const ackNull = encode({ result: null });
+        while (true) {
+            const [eventId, eventPayload] = testStream.receiveRequest();
+            const event = decode(eventPayload);
+            const eventType = event["event"];
+            if (eventType === "test_case") {
+                const streamId = event["stream_id"];
+                const testCaseStream = connection.connectStream(streamId);
+                // Ack BEFORE running the test
+                testStream.writeReply(eventId, ackNull);
+                const ds = new ServerDataSource(connection, testCaseStream);
+                runTestCase(ds, this.testFn, false);
+                // Track interesting cases (server uses this for final replay decisions)
+            }
+            else {
+                /* v8 ignore start: server only sends test_case and test_done events */
+                if (eventType !== "test_done") {
+                    throw new Error(`Unknown event: ${eventType}`);
+                }
+                /* v8 ignore stop */
+                const ackTrue = encode({ result: true });
+                testStream.writeReply(eventId, ackTrue);
+                /* v8 ignore start: server always sends results object */
+                resultData = event["results"] ?? {};
+                /* v8 ignore stop */
+                break;
+            }
+        }
+        // Check for server-side errors
+        /* v8 ignore start: requires server to report error in test_done results */
+        if (resultData["error"]) {
+            throw new Error(`Server error: ${resultData["error"]}`);
+        }
+        /* v8 ignore stop */
+        if (resultData["health_check_failure"]) {
+            throw new Error(`Health check failure:\n${resultData["health_check_failure"]}`);
+        }
+        if (resultData["flaky"]) {
+            throw new Error(`Flaky test detected: ${resultData["flaky"]}`);
+        }
+        /* v8 ignore start: server always sends interesting_test_cases */
+        const nInteresting = resultData["interesting_test_cases"] ?? 0;
+        /* v8 ignore stop */
+        // Final replays for interesting test cases
+        let finalResult = null;
+        for (let i = 0; i < nInteresting; i++) {
+            const [eventId, eventPayload] = testStream.receiveRequest();
+            const event = decode(eventPayload);
+            const streamId = event["stream_id"];
+            const testCaseStream = connection.connectStream(streamId);
+            testStream.writeReply(eventId, ackNull);
+            const ds = new ServerDataSource(connection, testCaseStream);
+            const result = runTestCase(ds, this.testFn, true);
+            /* v8 ignore start: replay cases are always interesting */
+            if (result.status === "interesting") {
+                finalResult = result;
+            }
+            /* v8 ignore stop */
+        }
+        testStream.close();
+        /* v8 ignore start: server always sends passed field */
+        const passed = resultData["passed"] ?? true;
+        /* v8 ignore stop */
+        const testFailed = !passed;
+        /* v8 ignore start: only runs inside Antithesis */
+        if (isRunningInAntithesis() && this._testLocation) {
+            emitAntithesisAssertion(this._testLocation, !testFailed);
+        }
+        /* v8 ignore stop */
+        if (testFailed) {
+            let msg = "unknown";
+            /* v8 ignore start: finalResult is always set when test fails with interesting cases */
+            if (finalResult && finalResult.status === "interesting") {
+                const err = finalResult.error;
+                msg = err instanceof Error ? err.message : String(err);
+            }
+            /* v8 ignore stop */
+            throw new Error(`Property test failed: ${msg}`);
+        }
+    }
+}
+/**
+ * Wrap a property-based test body into a function suitable for a test runner.
+ *
+ * @example
+ * ```ts
+ * import { test } from 'vitest';
+ * import * as hegel from 'hegel';
+ * import * as gs from 'hegel/generators';
+ *
+ * test('addition is commutative', hegel.test((tc) => {
+ *   const x = tc.draw(gs.integers());
+ *   const y = tc.draw(gs.integers());
+ *   expect(x + y).toBe(y + x);
+ * }));
+ * ```
+ */
+export function test(testFn, settings) {
+    return () => {
+        const h = new Hegel(testFn);
+        if (settings)
+            h.settings(settings);
+        h.run();
+    };
+}
+//# sourceMappingURL=runner.js.map