@glubean/sdk 0.1.0

package/dist/expect.d.ts

@@ -0,0 +1,511 @@
+/**
+ * Fluent assertion API for Glubean tests.
+ *
+ * Inspired by Jest/Vitest `expect()` but designed for API testing:
+ * - **Soft-by-default**: Failed assertions emit events but do NOT throw.
+ *   All assertions run and all failures are collected.
+ * - **`.orFail()` guard**: Opt-in hard failure for when subsequent code
+ *   depends on the assertion passing.
+ * - **`.not` negation**: Negate any assertion via a getter.
+ *
+ * The class is framework-agnostic — it accepts an `emitter` callback
+ * that routes assertion results into the runner's event pipeline.
+ *
+ * @module
+ */
+/**
+ * The result emitted for every assertion.
+ * This is the payload passed to the emitter callback.
+ */
+export interface AssertionEmission {
+    passed: boolean;
+    message: string;
+    actual?: unknown;
+    expected?: unknown;
+}
+/**
+ * Callback that routes an assertion result into the runner's event system.
+ * In the harness this maps to `ctx.assert(result)`.
+ */
+export type AssertEmitter = (result: AssertionEmission) => void;
+/**
+ * Result returned by a custom matcher function.
+ * The SDK handles `.not` negation and `.orFail()` automatically based on `passed`.
+ */
+export interface MatcherResult {
+    /** Whether the assertion passed. */
+    passed: boolean;
+    /** Human-readable message describing the assertion (used in reports). */
+    message: string;
+    /** The actual value (for assertion reports). */
+    actual?: unknown;
+    /** The expected value (for assertion reports). */
+    expected?: unknown;
+}
+/**
+ * A custom matcher function for `Expectation.extend()`.
+ * Receives the actual value and any extra arguments passed by the user.
+ *
+ * @example
+ * ```ts
+ * const toBeEven: MatcherFn = (actual) => ({
+ *   passed: typeof actual === "number" && actual % 2 === 0,
+ *   message: `to be even`,
+ *   actual,
+ * });
+ * ```
+ */
+export type MatcherFn = (actual: unknown, ...args: unknown[]) => MatcherResult;
+/**
+ * Interface for user-defined custom assertion matchers.
+ *
+ * Augment this interface via TypeScript **declaration merging** to get
+ * type-safe access to matchers registered with `Expectation.extend()`.
+ * The SDK merges `CustomMatchers` into the `Expectation` class type, so
+ * custom matchers automatically appear on every `ctx.expect()` call.
+ *
+ * **Important**: Call `Expectation.extend(matchers)` at the top of your test
+ * file to register the runtime implementation. The declaration merging below
+ * only provides type information.
+ *
+ * @example
+ * ```ts
+ * // 1. Declare the types (in your test file or a shared .d.ts):
+ * declare module "@glubean/sdk/expect" {
+ *   interface CustomMatchers<T> {
+ *     toBeEven(): Expectation<T>;
+ *     toBeWithinRange(min: number, max: number): Expectation<T>;
+ *   }
+ * }
+ *
+ * // 2. Register the runtime implementations:
+ * import { Expectation } from "@glubean/sdk/expect";
+ *
+ * Expectation.extend({
+ *   toBeEven: (actual) => ({
+ *     passed: typeof actual === "number" && actual % 2 === 0,
+ *     message: "to be even",
+ *     actual,
+ *   }),
+ *   toBeWithinRange: (actual, min, max) => ({
+ *     passed: typeof actual === "number"
+ *       && actual >= (min as number) && actual <= (max as number),
+ *     message: `to be within [${min}, ${max}]`,
+ *     actual,
+ *     expected: `[${min}, ${max}]`,
+ *   }),
+ * });
+ *
+ * // 3. Use — fully typed, no `as any` needed:
+ * ctx.expect(4).toBeEven();             // ✅ typed
+ * ctx.expect(5).not.toBeEven();         // ✅ negation
+ * ctx.expect(50).toBeWithinRange(0, 100).orFail(); // ✅ chaining
+ * ```
+ *
+ * @template T The type of the actual value being asserted on
+ */
+export interface CustomMatchers<T = unknown> {
+}
+/**
+ * Produce a short, human-readable representation of a value for error messages.
+ * Truncates long output to keep assertion messages scannable.
+ */
+export declare function inspect(value: unknown, maxLen?: number): string;
+/**
+ * Deep equality check.
+ * Handles primitives, arrays, plain objects, Date, RegExp, Map, Set, null, undefined.
+ * Safely handles circular references via a seen-pairs set.
+ */
+export declare function deepEqual(a: unknown, b: unknown, seen?: Set<object>): boolean;
+/**
+ * Error thrown by `.orFail()` when the preceding assertion failed.
+ * Caught by the harness as a hard failure.
+ */
+export declare class ExpectFailError extends Error {
+    constructor(message: string);
+}
+/**
+ * Merges `CustomMatchers` into the `Expectation` class type.
+ * This enables declaration merging: when users augment `CustomMatchers<T>`,
+ * the additional methods automatically appear on `Expectation<T>` instances.
+ */
+export interface Expectation<T> extends CustomMatchers<T> {
+}
+/**
+ * Fluent assertion object returned by `ctx.expect(actual)`.
+ *
+ * Every terminal method (e.g. `toBe`, `toContain`) emits an assertion event
+ * and returns `this` for optional chaining with `.orFail()`.
+ *
+ * **Soft-by-default**: failed assertions are recorded but execution continues.
+ *
+ * **Custom matchers**: Use `Expectation.extend()` to add domain-specific
+ * assertions. Combine with `CustomMatchers` declaration merging for full
+ * type safety — see {@link CustomMatchers} for details.
+ *
+ * **Assertion messages**: Every matcher accepts an optional `message` string as
+ * its last argument. When provided, it is prepended to the auto-generated
+ * message: `"GET /users status: expected 401 to be 200"`. This makes failures
+ * far more actionable in Trace Viewer, CI logs, and MCP tool output.
+ *
+ * @example Basic assertions
+ * ```ts
+ * ctx.expect(res.status).toBe(200);
+ * ctx.expect(body.users).toHaveLength(3);
+ * ctx.expect(body).toMatchObject({ success: true });
+ * ```
+ *
+ * @example With descriptive messages (recommended)
+ * ```ts
+ * ctx.expect(res.status).toBe(200, "GET /users status");
+ * ctx.expect(body.users).toHaveLength(3, "user list count");
+ * ctx.expect(res).toHaveHeader("content-type", /json/, "response content type");
+ * ```
+ *
+ * @example Guard + message
+ * ```ts
+ * ctx.expect(res.status).toBe(200, "POST /orders").orFail();
+ * const body = await res.json(); // safe — status was 200
+ * ```
+ */
+export declare class Expectation<T> {
+    /**
+     * The actual value being asserted on.
+     * `protected` (not `#private`) so that `Expectation.extend()` prototype
+     * patching can access it at runtime.
+     */
+    protected _actual: T;
+    private _negated;
+    private _emit;
+    /** Tracks whether the last assertion in this chain passed. */
+    private _lastPassed;
+    private _lastMessage;
+    constructor(actual: T, emit: AssertEmitter, negated?: boolean);
+    /**
+     * Negate the next assertion.
+     *
+     * @example
+     * ctx.expect(body.banned).not.toBe(true);
+     * ctx.expect(body.roles).not.toContain("superadmin");
+     */
+    get not(): Expectation<T>;
+    /**
+     * If the preceding assertion failed, throw immediately to abort the test.
+     * Use this for "guard" assertions where subsequent code depends on the value.
+     *
+     * @example
+     * ctx.expect(res.status).toBe(200).orFail();
+     * const body = await res.json(); // safe — status was 200
+     */
+    orFail(): this;
+    /**
+     * Register custom assertion matchers on the `Expectation` prototype.
+     *
+     * Each matcher is a pure function that receives the actual value and any
+     * extra arguments, and returns a `MatcherResult`. The SDK automatically
+     * handles `.not` negation and `.orFail()` chaining.
+     *
+     * **Isolation**: Each test file runs in its own Deno subprocess, so
+     * prototype mutations from `Expectation.extend()` do not leak between files.
+     *
+     * **Type safety**: To get full TypeScript support for custom matchers,
+     * augment the {@link CustomMatchers} interface via declaration merging.
+     * See {@link CustomMatchers} for a complete example.
+     *
+     * @param matchers Record of matcher name → matcher function
+     * @throws If a matcher name conflicts with an existing method
+     *
+     * @example
+     * ```ts
+     * // Step 1: Declare types (in your test file or shared .d.ts)
+     * declare module "@glubean/sdk/expect" {
+     *   interface CustomMatchers<T> {
+     *     toBeEven(): Expectation<T>;
+     *     toBeWithinRange(min: number, max: number): Expectation<T>;
+     *   }
+     * }
+     *
+     * // Step 2: Register runtime implementations
+     * import { Expectation } from "@glubean/sdk/expect";
+     *
+     * Expectation.extend({
+     *   toBeEven: (actual) => ({
+     *     passed: typeof actual === "number" && actual % 2 === 0,
+     *     message: "to be even",
+     *     actual,
+     *   }),
+     *   toBeWithinRange: (actual, min, max) => ({
+     *     passed: typeof actual === "number" && actual >= (min as number) && actual <= (max as number),
+     *     message: `to be within [${min}, ${max}]`,
+     *     actual,
+     *     expected: `[${min}, ${max}]`,
+     *   }),
+     * });
+     *
+     * // Step 3: Use — fully typed
+     * ctx.expect(count).toBeEven();
+     * ctx.expect(count).not.toBeEven();
+     * ctx.expect(score).toBeWithinRange(0, 100).orFail();
+     * ```
+     */
+    static extend(matchers: Record<string, MatcherFn>): void;
+    /**
+     * Emit an assertion result.
+     * `protected` so that `Expectation.extend()` prototype patching can call it.
+     *
+     * @param label Optional human-readable context prepended to the message
+     *              (e.g. `"GET /users status"` → `"GET /users status: expected 401 to be 200"`).
+     */
+    protected _report(rawPassed: boolean, message: string, actual?: unknown, expected?: unknown, label?: string): this;
+    /**
+     * Strict equality (`Object.is`).
+     *
+     * @param expected The value to compare against
+     * @param message Optional context prepended to the assertion message
+     *
+     * @example ctx.expect(res.status).toBe(200, "GET /users status");
+     */
+    toBe(expected: T, message?: string): this;
+    /**
+     * Deep equality.
+     *
+     * @param expected The value to compare against
+     * @param message Optional context prepended to the assertion message
+     *
+     * @example ctx.expect(body).toEqual({ id: 1, name: "Alice" }, "response body");
+     */
+    toEqual(expected: T, message?: string): this;
+    /**
+     * Check the runtime type via `typeof`.
+     *
+     * @param expected The expected type string
+     * @param message Optional context prepended to the assertion message
+     *
+     * @example ctx.expect(body.name).toBeType("string", "user name type");
+     */
+    toBeType(expected: "string" | "number" | "boolean" | "object" | "undefined" | "function" | "bigint" | "symbol", message?: string): this;
+    /**
+     * Check that the value is truthy.
+     *
+     * @param message Optional context prepended to the assertion message
+     *
+     * @example ctx.expect(body.active).toBeTruthy("user active flag");
+     */
+    toBeTruthy(message?: string): this;
+    /**
+     * Check that the value is falsy.
+     *
+     * @param message Optional context prepended to the assertion message
+     *
+     * @example ctx.expect(body.deleted).toBeFalsy("user should not be deleted");
+     */
+    toBeFalsy(message?: string): this;
+    /**
+     * Check that the value is `null`.
+     *
+     * @param message Optional context prepended to the assertion message
+     *
+     * @example ctx.expect(body.avatar).toBeNull("deleted user avatar");
+     */
+    toBeNull(message?: string): this;
+    /**
+     * Check that the value is `undefined`.
+     *
+     * @param message Optional context prepended to the assertion message
+     *
+     * @example ctx.expect(body.nickname).toBeUndefined();
+     */
+    toBeUndefined(message?: string): this;
+    /**
+     * Check that the value is not `undefined`.
+     *
+     * @param message Optional context prepended to the assertion message
+     *
+     * @example ctx.expect(body.id).toBeDefined("response should include id");
+     */
+    toBeDefined(message?: string): this;
+    /**
+     * Check that the value is greater than `n`.
+     *
+     * @param n The lower bound (exclusive)
+     * @param message Optional context prepended to the assertion message
+     *
+     * @example ctx.expect(body.age).toBeGreaterThan(0, "user age");
+     */
+    toBeGreaterThan(n: number, message?: string): this;
+    /**
+     * Check that the value is greater than or equal to `n`.
+     *
+     * @param n The lower bound (inclusive)
+     * @param message Optional context prepended to the assertion message
+     *
+     * @example ctx.expect(body.items.length).toBeGreaterThanOrEqual(1, "result count");
+     */
+    toBeGreaterThanOrEqual(n: number, message?: string): this;
+    /**
+     * Check that the value is less than `n`.
+     *
+     * @param n The upper bound (exclusive)
+     * @param message Optional context prepended to the assertion message
+     *
+     * @example ctx.expect(latency).toBeLessThan(500, "response latency ms");
+     */
+    toBeLessThan(n: number, message?: string): this;
+    /**
+     * Check that the value is less than or equal to `n`.
+     *
+     * @param n The upper bound (inclusive)
+     * @param message Optional context prepended to the assertion message
+     *
+     * @example ctx.expect(res.status).toBeLessThanOrEqual(299, "GET /users status range");
+     */
+    toBeLessThanOrEqual(n: number, message?: string): this;
+    /**
+     * Check that the value is within `[min, max]` (inclusive).
+     *
+     * @param min Lower bound (inclusive)
+     * @param max Upper bound (inclusive)
+     * @param message Optional context prepended to the assertion message
+     *
+     * @example ctx.expect(body.score).toBeWithin(0, 100, "user score range");
+     */
+    toBeWithin(min: number, max: number, message?: string): this;
+    /**
+     * Check that the value has the expected `length`.
+     *
+     * @param expected The expected length
+     * @param message Optional context prepended to the assertion message
+     *
+     * @example ctx.expect(body.users).toHaveLength(3, "user list count");
+     */
+    toHaveLength(expected: number, message?: string): this;
+    /**
+     * Check that an array or string contains the given item/substring.
+     *
+     * @param item The item or substring to search for
+     * @param message Optional context prepended to the assertion message
+     *
+     * @example
+     * ctx.expect(body.roles).toContain("admin", "user roles");
+     * ctx.expect(body.name).toContain("Ali");
+     */
+    toContain(item: unknown, message?: string): this;
+    /**
+     * Check that a string matches a regex or includes a substring.
+     *
+     * @param pattern Regex or substring to match
+     * @param message Optional context prepended to the assertion message
+     *
+     * @example
+     * ctx.expect(body.email).toMatch(/@example\.com$/, "email domain");
+     * ctx.expect(body.name).toMatch("Alice");
+     */
+    toMatch(pattern: RegExp | string, message?: string): this;
+    /**
+     * Check that a string starts with the given prefix.
+     *
+     * @param prefix The expected prefix
+     * @param message Optional context prepended to the assertion message
+     *
+     * @example
+     * ctx.expect(body.id).toStartWith("usr_", "user id prefix");
+     * ctx.expect(url).toStartWith("https://");
+     */
+    toStartWith(prefix: string, message?: string): this;
+    /**
+     * Check that a string ends with the given suffix.
+     *
+     * @param suffix The expected suffix
+     * @param message Optional context prepended to the assertion message
+     *
+     * @example
+     * ctx.expect(body.email).toEndWith("@example.com", "email format");
+     * ctx.expect(body.filename).toEndWith(".json");
+     */
+    toEndWith(suffix: string, message?: string): this;
+    /**
+     * Partial deep match — every key in `subset` must exist and match in the actual value.
+     *
+     * @param subset The expected subset of properties
+     * @param message Optional context prepended to the assertion message
+     *
+     * @example ctx.expect(body).toMatchObject({ success: true }, "create user response");
+     */
+    toMatchObject(subset: Record<string, unknown>, message?: string): this;
+    /**
+     * Check that the value has a property at the given path.
+     * When `value` is provided, also checks property value equality.
+     *
+     * @param path Dot-separated property path (e.g. `"meta.created"`)
+     * @param value Expected value at the path (omit to check existence only)
+     * @param message Optional context prepended to the assertion message
+     *
+     * @example Existence check
+     * ```ts
+     * ctx.expect(body).toHaveProperty("id");
+     * ```
+     *
+     * @example Value check with message
+     * ```ts
+     * ctx.expect(body).toHaveProperty("status", "active", "user status");
+     * ```
+     */
+    toHaveProperty(path: string, value?: unknown, message?: string): this;
+    /**
+     * Check that the value has all of the given property keys.
+     * Reports all missing keys in a single assertion message.
+     *
+     * @param keys Array of property paths to check
+     * @param message Optional context prepended to the assertion message
+     *
+     * @example
+     * ctx.expect(body).toHaveProperties(["id", "name", "email"], "user fields");
+     */
+    toHaveProperties(keys: string[], message?: string): this;
+    /**
+     * Custom predicate assertion.
+     *
+     * @param predicate Function that returns `true` if the assertion passes
+     * @param message Optional context prepended to the assertion message
+     *
+     * @example ctx.expect(body).toSatisfy((b) => b.items.length > 0, "response should have items");
+     */
+    toSatisfy(predicate: (actual: T) => boolean, message?: string): this;
+    /**
+     * Assert on the `status` property (typically a `Response` object).
+     *
+     * @param code Expected HTTP status code
+     * @param message Optional context prepended to the assertion message
+     *
+     * @example ctx.expect(res).toHaveStatus(200, "GET /users");
+     */
+    toHaveStatus(code: number, message?: string): this;
+    /**
+     * Assert that a Response-like object has a JSON body matching the given subset
+     * (partial deep match, like `toMatchObject`).
+     *
+     * This method is **async** because it calls `.json()` on the response.
+     *
+     * @param subset Expected subset of properties in the JSON body
+     * @param message Optional context prepended to the assertion message
+     *
+     * @example
+     * await ctx.expect(res).toHaveJsonBody({ success: true }, "create order response");
+     * (await ctx.expect(res).toHaveJsonBody({ ok: true }, "health check")).orFail();
+     */
+    toHaveJsonBody(subset: Record<string, unknown>, message?: string): Promise<this>;
+    /**
+     * Assert that a `Response` or headers-like object has a specific header.
+     * Optionally check the header value against a string or regex.
+     *
+     * @param name Header name (case-insensitive for `Headers` objects)
+     * @param value Optional expected value or pattern
+     * @param message Optional context prepended to the assertion message
+     *
+     * @example
+     * ctx.expect(res).toHaveHeader("content-type", /json/, "response content type");
+     * ctx.expect(res).toHaveHeader("x-request-id");
+     */
+    toHaveHeader(name: string, value?: string | RegExp, message?: string): this;
+}
+//# sourceMappingURL=expect.d.ts.map

package/dist/expect.d.ts.map

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