@faremeter/test-harness 0.16.0

package/dist/src/harness/harness.test.js

@@ -0,0 +1,230 @@
+#!/usr/bin/env pnpm tsx
+import t from "tap";
+import { TestHarness } from "./harness.js";
+import { createTestFacilitatorHandler } from "../scheme/facilitator.js";
+import { createTestPaymentHandler } from "../scheme/client.js";
+import { TEST_SCHEME, TEST_NETWORK } from "../scheme/constants.js";
+import { matchFacilitatorSettle, matchFacilitatorVerify, } from "../interceptors/matchers.js";
+import { getURLFromRequestInfo } from "../interceptors/utils.js";
+await t.test("interceptor composition", async (t) => {
+    await t.test("multiple middleware interceptors execute in order", async (t) => {
+        const executionOrder = [];
+        const harness = new TestHarness({
+            settleMode: "verify-then-settle",
+            accepts: [
+                {
+                    scheme: TEST_SCHEME,
+                    network: TEST_NETWORK,
+                    maxAmountRequired: "100",
+                    resource: "http://example.com/test",
+                    description: "Test resource",
+                    mimeType: "application/json",
+                    payTo: "test-receiver",
+                    maxTimeoutSeconds: 30,
+                    asset: "",
+                },
+            ],
+            facilitatorHandlers: [
+                createTestFacilitatorHandler({ payTo: "test-receiver" }),
+            ],
+            clientHandlers: [createTestPaymentHandler()],
+            middlewareInterceptors: [
+                (fetch) => async (input, init) => {
+                    executionOrder.push("interceptor-1-before");
+                    const result = await fetch(input, init);
+                    executionOrder.push("interceptor-1-after");
+                    return result;
+                },
+                (fetch) => async (input, init) => {
+                    executionOrder.push("interceptor-2-before");
+                    const result = await fetch(input, init);
+                    executionOrder.push("interceptor-2-after");
+                    return result;
+                },
+                (fetch) => async (input, init) => {
+                    executionOrder.push("interceptor-3-before");
+                    const result = await fetch(input, init);
+                    executionOrder.push("interceptor-3-after");
+                    return result;
+                },
+            ],
+        });
+        const fetch = harness.createFetch();
+        const response = await fetch("/test-resource");
+        t.equal(response.status, 200, "should complete successfully");
+        t.ok(executionOrder.length > 0, "interceptors should have executed");
+        // Verify proper nesting: 1-before, 2-before, 3-before, 3-after, 2-after, 1-after
+        const firstBefore = executionOrder.indexOf("interceptor-1-before");
+        const secondBefore = executionOrder.indexOf("interceptor-2-before");
+        const thirdBefore = executionOrder.indexOf("interceptor-3-before");
+        const thirdAfter = executionOrder.lastIndexOf("interceptor-3-after");
+        const secondAfter = executionOrder.lastIndexOf("interceptor-2-after");
+        const firstAfter = executionOrder.lastIndexOf("interceptor-1-after");
+        t.ok(firstBefore < secondBefore, "first interceptor before should execute first");
+        t.ok(secondBefore < thirdBefore, "second interceptor before should execute second");
+        t.ok(thirdAfter < secondAfter, "third interceptor after should execute before second after");
+        t.ok(secondAfter < firstAfter, "second interceptor after should execute before first after");
+        t.end();
+    });
+    await t.test("client and middleware interceptors are separate", async (t) => {
+        let clientInterceptorCalled = false;
+        let middlewareInterceptorCalled = false;
+        const harness = new TestHarness({
+            accepts: [
+                {
+                    scheme: TEST_SCHEME,
+                    network: TEST_NETWORK,
+                    maxAmountRequired: "100",
+                    resource: "http://example.com/test",
+                    description: "Test resource",
+                    mimeType: "application/json",
+                    payTo: "test-receiver",
+                    maxTimeoutSeconds: 30,
+                    asset: "",
+                },
+            ],
+            facilitatorHandlers: [
+                createTestFacilitatorHandler({ payTo: "test-receiver" }),
+            ],
+            clientHandlers: [createTestPaymentHandler()],
+            clientInterceptors: [
+                (fetch) => async (input, init) => {
+                    clientInterceptorCalled = true;
+                    return fetch(input, init);
+                },
+            ],
+            middlewareInterceptors: [
+                (fetch) => async (input, init) => {
+                    middlewareInterceptorCalled = true;
+                    return fetch(input, init);
+                },
+            ],
+        });
+        const fetch = harness.createFetch();
+        const response = await fetch("/test-resource");
+        t.equal(response.status, 200, "should complete successfully");
+        t.ok(clientInterceptorCalled, "client interceptor should be called");
+        t.ok(middlewareInterceptorCalled, "middleware interceptor should be called");
+        t.end();
+    });
+    await t.test("interceptor can short-circuit request", async (t) => {
+        let facilitatorWasCalled = false;
+        const harness = new TestHarness({
+            accepts: [
+                {
+                    scheme: TEST_SCHEME,
+                    network: TEST_NETWORK,
+                    maxAmountRequired: "100",
+                    resource: "http://example.com/test",
+                    description: "Test resource",
+                    mimeType: "application/json",
+                    payTo: "test-receiver",
+                    maxTimeoutSeconds: 30,
+                    asset: "",
+                },
+            ],
+            facilitatorHandlers: [
+                createTestFacilitatorHandler({ payTo: "test-receiver" }),
+            ],
+            clientHandlers: [createTestPaymentHandler()],
+            middlewareInterceptors: [
+                (fetch) => async (input, init) => {
+                    const url = getURLFromRequestInfo(input);
+                    if (url.includes("/facilitator/")) {
+                        facilitatorWasCalled = true;
+                    }
+                    return fetch(input, init);
+                },
+                (fetch) => async (input, init) => {
+                    const url = getURLFromRequestInfo(input);
+                    // Short-circuit settle requests
+                    if (matchFacilitatorSettle(url, init)) {
+                        return new Response(JSON.stringify({
+                            success: true,
+                            txHash: "0xshortcircuit",
+                            networkId: TEST_NETWORK,
+                        }), {
+                            status: 200,
+                            headers: { "Content-Type": "application/json" },
+                        });
+                    }
+                    return fetch(input, init);
+                },
+            ],
+        });
+        const fetch = harness.createFetch();
+        const response = await fetch("/test-resource");
+        t.equal(response.status, 200, "should complete successfully");
+        t.ok(facilitatorWasCalled, "other facilitator endpoints should still be called");
+        t.end();
+    });
+    await t.test("dynamically added interceptors work correctly", async (t) => {
+        let dynamicInterceptorCalled = false;
+        const harness = new TestHarness({
+            settleMode: "verify-then-settle",
+            accepts: [
+                {
+                    scheme: TEST_SCHEME,
+                    network: TEST_NETWORK,
+                    maxAmountRequired: "100",
+                    resource: "http://example.com/test",
+                    description: "Test resource",
+                    mimeType: "application/json",
+                    payTo: "test-receiver",
+                    maxTimeoutSeconds: 30,
+                    asset: "",
+                },
+            ],
+            facilitatorHandlers: [
+                createTestFacilitatorHandler({ payTo: "test-receiver" }),
+            ],
+            clientHandlers: [createTestPaymentHandler()],
+        });
+        // Add interceptor after construction to track verify endpoint calls
+        harness.addMiddlewareInterceptor((fetch) => async (input, init) => {
+            const url = getURLFromRequestInfo(input);
+            if (matchFacilitatorVerify(url, init)) {
+                dynamicInterceptorCalled = true;
+            }
+            return fetch(input, init);
+        });
+        const fetch = harness.createFetch();
+        const response = await fetch("/test-resource");
+        t.equal(response.status, 200, "should complete successfully");
+        t.ok(dynamicInterceptorCalled, "dynamically added interceptor should be called");
+        t.end();
+    });
+    await t.test("clearInterceptors removes added interceptors", async (t) => {
+        let dynamicInterceptorCalled = false;
+        const harness = new TestHarness({
+            accepts: [
+                {
+                    scheme: TEST_SCHEME,
+                    network: TEST_NETWORK,
+                    maxAmountRequired: "100",
+                    resource: "http://example.com/test",
+                    description: "Test resource",
+                    mimeType: "application/json",
+                    payTo: "test-receiver",
+                    maxTimeoutSeconds: 30,
+                    asset: "",
+                },
+            ],
+            facilitatorHandlers: [
+                createTestFacilitatorHandler({ payTo: "test-receiver" }),
+            ],
+            clientHandlers: [createTestPaymentHandler()],
+        });
+        // Add then clear interceptor
+        harness.addMiddlewareInterceptor((fetch) => async (input, init) => {
+            dynamicInterceptorCalled = true;
+            return fetch(input, init);
+        });
+        harness.clearInterceptors();
+        const fetch = harness.createFetch();
+        const response = await fetch("/test-resource");
+        t.equal(response.status, 200, "should complete successfully");
+        t.equal(dynamicInterceptorCalled, false, "cleared interceptor should not be called");
+        t.end();
+    });
+});

package/dist/src/harness/resource.d.ts

@@ -0,0 +1,17 @@
+import type { x402PaymentRequirements, x402PaymentPayload, x402SettleResponse, x402VerifyResponse } from "@faremeter/types/x402";
+export type ResourceContext = {
+    resource: string;
+    request: Request;
+    paymentRequirements: x402PaymentRequirements;
+    paymentPayload: x402PaymentPayload;
+    settleResponse: x402SettleResponse;
+    verifyResponse?: x402VerifyResponse | undefined;
+};
+export type ResourceResult = {
+    status: number;
+    body: unknown;
+    headers?: Record<string, string>;
+};
+export type ResourceHandler = (ctx: ResourceContext) => ResourceResult | Promise<ResourceResult>;
+export declare const defaultResourceHandler: ResourceHandler;
+//# sourceMappingURL=resource.d.ts.map

package/dist/src/harness/resource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource.d.ts","sourceRoot":"","sources":["../../../src/harness/resource.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,uBAAuB,EACvB,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EACnB,MAAM,uBAAuB,CAAC;AAE/B,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,mBAAmB,EAAE,uBAAuB,CAAC;IAC7C,cAAc,EAAE,kBAAkB,CAAC;IACnC,cAAc,EAAE,kBAAkB,CAAC;IACnC,cAAc,CAAC,EAAE,kBAAkB,GAAG,SAAS,CAAC;CACjD,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,CAC5B,GAAG,EAAE,eAAe,KACjB,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;AAE9C,eAAO,MAAM,sBAAsB,EAAE,eAOnC,CAAC"}

package/dist/src/harness/resource.js

@@ -0,0 +1,8 @@
+export const defaultResourceHandler = (ctx) => ({
+    status: 200,
+    body: {
+        success: true,
+        resource: ctx.resource,
+        txHash: ctx.settleResponse.txHash,
+    },
+});

package/dist/src/index.d.ts

@@ -0,0 +1,23 @@
+export { TestHarness } from "./harness/harness.js";
+export type { TestHarnessConfig, SettleMode } from "./harness/config.js";
+export type { ResourceHandler, ResourceContext, ResourceResult, } from "./harness/resource.js";
+export { defaultResourceHandler } from "./harness/resource.js";
+export { accepts } from "./harness/defaults.js";
+export { TEST_SCHEME, TEST_NETWORK, TEST_ASSET } from "./scheme/constants.js";
+export type { TestPaymentPayload } from "./scheme/types.js";
+export { generateTestId } from "./scheme/types.js";
+export { createTestFacilitatorHandler, type CreateTestFacilitatorHandlerOpts, } from "./scheme/facilitator.js";
+export { createTestPaymentHandler, type CreateTestPaymentHandlerOpts, } from "./scheme/client.js";
+export type { Interceptor, RequestMatcher } from "./interceptors/types.js";
+export { composeInterceptors } from "./interceptors/types.js";
+export { getURLFromRequestInfo } from "./interceptors/utils.js";
+export { matchFacilitatorAccepts, matchFacilitatorVerify, matchFacilitatorSettle, matchFacilitatorSupported, matchFacilitator, matchResource, and, or, not, matchURL, matchMethod, matchAll, matchNone, } from "./interceptors/matchers.js";
+export { jsonResponse, verifyFailedResponse, verifySuccessResponse, settleFailedResponse, settleSuccessResponse, paymentRequiredResponse, networkError, timeoutError, httpError, } from "./interceptors/responses.js";
+export { createFailureInterceptor, failOnce, failNTimes, failUntilCleared, failWhen, } from "./interceptors/failures.js";
+export { createDelayInterceptor, createResponseDelayInterceptor, createVariableDelayInterceptor, } from "./interceptors/delay.js";
+export { createRequestHook, createResponseHook, createHook, createCaptureInterceptor, } from "./interceptors/hooks.js";
+export type { LogEvent } from "./interceptors/logging.js";
+export { createLoggingInterceptor, createConsoleLoggingInterceptor, createEventCollector, } from "./interceptors/logging.js";
+export { chooseFirst, chooseCheapest, chooseMostExpensive, chooseByAsset, chooseByNetwork, chooseByScheme, chooseByIndex, chooseNone, chooseWithInspection, chooseWithFilter, } from "./choosers.js";
+export { suppressConsoleErrors } from "./testing/console.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,YAAY,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACtE,YAAY,EACV,eAAe,EACf,eAAe,EACf,cAAc,GACf,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAC5D,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAE7C,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAC3E,YAAY,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EACL,4BAA4B,EAC5B,KAAK,gCAAgC,GACtC,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,wBAAwB,EACxB,KAAK,4BAA4B,GAClC,MAAM,iBAAiB,CAAC;AAEzB,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACxE,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAE3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAE7D,OAAO,EACL,uBAAuB,EACvB,sBAAsB,EACtB,sBAAsB,EACtB,yBAAyB,EACzB,gBAAgB,EAChB,aAAa,EACb,GAAG,EACH,EAAE,EACF,GAAG,EACH,QAAQ,EACR,WAAW,EACX,QAAQ,EACR,SAAS,GACV,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,YAAY,EACZ,oBAAoB,EACpB,qBAAqB,EACrB,oBAAoB,EACpB,qBAAqB,EACrB,uBAAuB,EACvB,YAAY,EACZ,YAAY,EACZ,SAAS,GACV,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACL,wBAAwB,EACxB,QAAQ,EACR,UAAU,EACV,gBAAgB,EAChB,QAAQ,GACT,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,sBAAsB,EACtB,8BAA8B,EAC9B,8BAA8B,GAC/B,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAClB,UAAU,EACV,wBAAwB,GACzB,MAAM,sBAAsB,CAAC;AAE9B,YAAY,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EACL,wBAAwB,EACxB,+BAA+B,EAC/B,oBAAoB,GACrB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EACL,WAAW,EACX,cAAc,EACd,mBAAmB,EACnB,aAAa,EACb,eAAe,EACf,cAAc,EACd,aAAa,EACb,UAAU,EACV,oBAAoB,EACpB,gBAAgB,GACjB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,17 @@
+export { TestHarness } from "./harness/harness.js";
+export { defaultResourceHandler } from "./harness/resource.js";
+export { accepts } from "./harness/defaults.js";
+export { TEST_SCHEME, TEST_NETWORK, TEST_ASSET } from "./scheme/constants.js";
+export { generateTestId } from "./scheme/types.js";
+export { createTestFacilitatorHandler, } from "./scheme/facilitator.js";
+export { createTestPaymentHandler, } from "./scheme/client.js";
+export { composeInterceptors } from "./interceptors/types.js";
+export { getURLFromRequestInfo } from "./interceptors/utils.js";
+export { matchFacilitatorAccepts, matchFacilitatorVerify, matchFacilitatorSettle, matchFacilitatorSupported, matchFacilitator, matchResource, and, or, not, matchURL, matchMethod, matchAll, matchNone, } from "./interceptors/matchers.js";
+export { jsonResponse, verifyFailedResponse, verifySuccessResponse, settleFailedResponse, settleSuccessResponse, paymentRequiredResponse, networkError, timeoutError, httpError, } from "./interceptors/responses.js";
+export { createFailureInterceptor, failOnce, failNTimes, failUntilCleared, failWhen, } from "./interceptors/failures.js";
+export { createDelayInterceptor, createResponseDelayInterceptor, createVariableDelayInterceptor, } from "./interceptors/delay.js";
+export { createRequestHook, createResponseHook, createHook, createCaptureInterceptor, } from "./interceptors/hooks.js";
+export { createLoggingInterceptor, createConsoleLoggingInterceptor, createEventCollector, } from "./interceptors/logging.js";
+export { chooseFirst, chooseCheapest, chooseMostExpensive, chooseByAsset, chooseByNetwork, chooseByScheme, chooseByIndex, chooseNone, chooseWithInspection, chooseWithFilter, } from "./choosers.js";
+export { suppressConsoleErrors } from "./testing/console.js";

package/dist/src/interceptors/delay.d.ts

@@ -0,0 +1,5 @@
+import type { Interceptor, RequestMatcher } from "./types.js";
+export declare function createDelayInterceptor(match: RequestMatcher, delayMs: number): Interceptor;
+export declare function createResponseDelayInterceptor(match: RequestMatcher, delayMs: number): Interceptor;
+export declare function createVariableDelayInterceptor(match: RequestMatcher, getDelay: (url: string, init?: RequestInit) => number): Interceptor;
+//# sourceMappingURL=delay.d.ts.map

package/dist/src/interceptors/delay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delay.d.ts","sourceRoot":"","sources":["../../../src/interceptors/delay.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAG3D,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,cAAc,EACrB,OAAO,EAAE,MAAM,GACd,WAAW,CAUb;AAED,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,cAAc,EACrB,OAAO,EAAE,MAAM,GACd,WAAW,CAWb;AAED,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,cAAc,EACrB,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,MAAM,GACpD,WAAW,CAWb"}

package/dist/src/interceptors/delay.js

@@ -0,0 +1,30 @@
+import { getURLFromRequestInfo } from "./utils.js";
+export function createDelayInterceptor(match, delayMs) {
+    return (fetch) => async (input, init) => {
+        const url = getURLFromRequestInfo(input);
+        if (match(url, init)) {
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+        return fetch(input, init);
+    };
+}
+export function createResponseDelayInterceptor(match, delayMs) {
+    return (fetch) => async (input, init) => {
+        const url = getURLFromRequestInfo(input);
+        const response = await fetch(input, init);
+        if (match(url, init)) {
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+        return response;
+    };
+}
+export function createVariableDelayInterceptor(match, getDelay) {
+    return (fetch) => async (input, init) => {
+        const url = getURLFromRequestInfo(input);
+        if (match(url, init)) {
+            const delayMs = getDelay(url, init);
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+        return fetch(input, init);
+    };
+}

package/dist/src/interceptors/failures.d.ts

@@ -0,0 +1,12 @@
+import type { Interceptor, RequestMatcher } from "./types.js";
+export declare function createFailureInterceptor(match: RequestMatcher, failFn: () => Response | Error | Promise<Response | Error>): Interceptor;
+export declare function failOnce(match: RequestMatcher, failFn: () => Response | Error): Interceptor;
+export declare function failNTimes(n: number, match: RequestMatcher, failFn: () => Response | Error): Interceptor;
+export declare function failUntilCleared(match: RequestMatcher, failFn: () => Response | Error): Interceptor & {
+    clear(): void;
+};
+export declare function failWhen(match: RequestMatcher, shouldFail: (ctx: {
+    url: string;
+    attemptCount: number;
+}) => boolean, failFn: () => Response | Error): Interceptor;
+//# sourceMappingURL=failures.d.ts.map

package/dist/src/interceptors/failures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"failures.d.ts","sourceRoot":"","sources":["../../../src/interceptors/failures.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAG3D,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,cAAc,EACrB,MAAM,EAAE,MAAM,QAAQ,GAAG,KAAK,GAAG,OAAO,CAAC,QAAQ,GAAG,KAAK,CAAC,GACzD,WAAW,CAcb;AAED,wBAAgB,QAAQ,CACtB,KAAK,EAAE,cAAc,EACrB,MAAM,EAAE,MAAM,QAAQ,GAAG,KAAK,GAC7B,WAAW,CAab;AAED,wBAAgB,UAAU,CACxB,CAAC,EAAE,MAAM,EACT,KAAK,EAAE,cAAc,EACrB,MAAM,EAAE,MAAM,QAAQ,GAAG,KAAK,GAC7B,WAAW,CAab;AAED,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,cAAc,EACrB,MAAM,EAAE,MAAM,QAAQ,GAAG,KAAK,GAC7B,WAAW,GAAG;IAAE,KAAK,IAAI,IAAI,CAAA;CAAE,CAajC;AAED,wBAAgB,QAAQ,CACtB,KAAK,EAAE,cAAc,EACrB,UAAU,EAAE,CAAC,GAAG,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,KAAK,OAAO,EACnE,MAAM,EAAE,MAAM,QAAQ,GAAG,KAAK,GAC7B,WAAW,CAqBb"}

package/dist/src/interceptors/failures.js

@@ -0,0 +1,62 @@
+import { getURLFromRequestInfo } from "./utils.js";
+export function createFailureInterceptor(match, failFn) {
+    return (fetch) => async (input, init) => {
+        const url = getURLFromRequestInfo(input);
+        if (match(url, init)) {
+            const result = await failFn();
+            if (result instanceof Error) {
+                throw result;
+            }
+            return result;
+        }
+        return fetch(input, init);
+    };
+}
+export function failOnce(match, failFn) {
+    let triggered = false;
+    return createFailureInterceptor((url, init) => {
+        if (triggered)
+            return false;
+        return match(url, init);
+    }, () => {
+        triggered = true;
+        return failFn();
+    });
+}
+export function failNTimes(n, match, failFn) {
+    let count = 0;
+    return createFailureInterceptor((url, init) => {
+        if (count >= n)
+            return false;
+        return match(url, init);
+    }, () => {
+        count++;
+        return failFn();
+    });
+}
+export function failUntilCleared(match, failFn) {
+    let active = true;
+    const interceptor = createFailureInterceptor((url, init) => active && match(url, init), failFn);
+    interceptor.clear = () => {
+        active = false;
+    };
+    return interceptor;
+}
+export function failWhen(match, shouldFail, failFn) {
+    const attemptCounts = new Map();
+    return (fetch) => async (input, init) => {
+        const url = getURLFromRequestInfo(input);
+        if (match(url, init)) {
+            const attemptCount = (attemptCounts.get(url) ?? 0) + 1;
+            attemptCounts.set(url, attemptCount);
+            if (shouldFail({ url, attemptCount })) {
+                const result = failFn();
+                if (result instanceof Error) {
+                    throw result;
+                }
+                return result;
+            }
+        }
+        return fetch(input, init);
+    };
+}

package/dist/src/interceptors/hooks.d.ts

@@ -0,0 +1,20 @@
+import type { Interceptor, RequestMatcher } from "./types.js";
+export declare function createRequestHook(match: RequestMatcher, hook: (url: string, init?: RequestInit) => void | Promise<void>): Interceptor;
+export declare function createResponseHook(match: RequestMatcher, hook: (url: string, response: Response, init?: RequestInit) => void | Promise<void>): Interceptor;
+export declare function createHook(match: RequestMatcher, hooks: {
+    onRequest?: (url: string, init?: RequestInit) => void | Promise<void>;
+    onResponse?: (url: string, response: Response, init?: RequestInit) => void | Promise<void>;
+}): Interceptor;
+type CapturedRequest = {
+    url: string;
+    init?: RequestInit | undefined;
+    response: Response;
+    timestamp: number;
+};
+export declare function createCaptureInterceptor(match: RequestMatcher): {
+    interceptor: Interceptor;
+    captured: CapturedRequest[];
+    clear: () => void;
+};
+export {};
+//# sourceMappingURL=hooks.d.ts.map

package/dist/src/interceptors/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../../src/interceptors/hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAG3D,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,cAAc,EACrB,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GAC9D,WAAW,CAUb;AAED,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,cAAc,EACrB,IAAI,EAAE,CACJ,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,QAAQ,EAClB,IAAI,CAAC,EAAE,WAAW,KACf,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GACxB,WAAW,CAWb;AAED,wBAAgB,UAAU,CACxB,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE;IACL,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtE,UAAU,CAAC,EAAE,CACX,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,QAAQ,EAClB,IAAI,CAAC,EAAE,WAAW,KACf,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B,GACA,WAAW,CAgBb;AAED,KAAK,eAAe,GAAG;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,QAAQ,EAAE,QAAQ,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,cAAc,GAAG;IAC/D,WAAW,EAAE,WAAW,CAAC;IACzB,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB,CA0BA"}

package/dist/src/interceptors/hooks.js

@@ -0,0 +1,56 @@
+import { getURLFromRequestInfo } from "./utils.js";
+export function createRequestHook(match, hook) {
+    return (fetch) => async (input, init) => {
+        const url = getURLFromRequestInfo(input);
+        if (match(url, init)) {
+            await hook(url, init);
+        }
+        return fetch(input, init);
+    };
+}
+export function createResponseHook(match, hook) {
+    return (fetch) => async (input, init) => {
+        const url = getURLFromRequestInfo(input);
+        const response = await fetch(input, init);
+        if (match(url, init)) {
+            await hook(url, response, init);
+        }
+        return response;
+    };
+}
+export function createHook(match, hooks) {
+    return (fetch) => async (input, init) => {
+        const url = getURLFromRequestInfo(input);
+        if (match(url, init) && hooks.onRequest) {
+            await hooks.onRequest(url, init);
+        }
+        const response = await fetch(input, init);
+        if (match(url, init) && hooks.onResponse) {
+            await hooks.onResponse(url, response, init);
+        }
+        return response;
+    };
+}
+export function createCaptureInterceptor(match) {
+    const captured = [];
+    const interceptor = (fetch) => async (input, init) => {
+        const url = getURLFromRequestInfo(input);
+        const response = await fetch(input, init);
+        if (match(url, init)) {
+            captured.push({
+                url,
+                init,
+                response: response.clone(), // Clone so the original can still be consumed
+                timestamp: Date.now(),
+            });
+        }
+        return response;
+    };
+    return {
+        interceptor,
+        captured,
+        clear: () => {
+            captured.length = 0;
+        },
+    };
+}

package/dist/src/interceptors/logging.d.ts

@@ -0,0 +1,20 @@
+import type { Interceptor } from "./types.js";
+export type LogEvent = {
+    type: "request" | "response" | "error";
+    url: string;
+    method?: string;
+    status?: number;
+    error?: string;
+    timestamp: number;
+};
+export declare function createLoggingInterceptor(log: (event: LogEvent) => void): Interceptor;
+export declare function createConsoleLoggingInterceptor(prefix?: string, log?: {
+    log: (msg: string) => void;
+    error: (msg: string) => void;
+}): Interceptor;
+export declare function createEventCollector(): {
+    interceptor: Interceptor;
+    events: LogEvent[];
+    clear: () => void;
+};
+//# sourceMappingURL=logging.d.ts.map

package/dist/src/interceptors/logging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging.d.ts","sourceRoot":"","sources":["../../../src/interceptors/logging.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAG3C,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,EAAE,SAAS,GAAG,UAAU,GAAG,OAAO,CAAC;IACvC,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,GAC7B,WAAW,CAoCb;AAED,wBAAgB,+BAA+B,CAC7C,MAAM,SAAmB,EACzB,GAAG,GAAE;IACH,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3B,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CACpB,GACV,WAAW,CAUb;AAED,wBAAgB,oBAAoB,IAAI;IACtC,WAAW,EAAE,WAAW,CAAC;IACzB,MAAM,EAAE,QAAQ,EAAE,CAAC;IACnB,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB,CAUA"}

package/dist/src/interceptors/logging.js

@@ -0,0 +1,57 @@
+import { getURLFromRequestInfo } from "./utils.js";
+export function createLoggingInterceptor(log) {
+    return (fetch) => async (input, init) => {
+        const url = getURLFromRequestInfo(input);
+        const method = init?.method ?? "GET";
+        log({
+            type: "request",
+            url,
+            method,
+            timestamp: Date.now(),
+        });
+        try {
+            const response = await fetch(input, init);
+            log({
+                type: "response",
+                url,
+                method,
+                status: response.status,
+                timestamp: Date.now(),
+            });
+            return response;
+        }
+        catch (error) {
+            log({
+                type: "error",
+                url,
+                method,
+                error: error instanceof Error ? error.message : String(error),
+                timestamp: Date.now(),
+            });
+            throw error;
+        }
+    };
+}
+export function createConsoleLoggingInterceptor(prefix = "[test-harness]", log = console) {
+    return createLoggingInterceptor((event) => {
+        if (event.type === "request") {
+            log.log(`${prefix} ${event.method} ${event.url}`);
+        }
+        else if (event.type === "response") {
+            log.log(`${prefix} ${event.method} ${event.url} -> ${event.status}`);
+        }
+        else {
+            log.error(`${prefix} ${event.method} ${event.url} ERROR: ${event.error}`);
+        }
+    });
+}
+export function createEventCollector() {
+    const events = [];
+    return {
+        interceptor: createLoggingInterceptor((event) => events.push(event)),
+        events,
+        clear: () => {
+            events.length = 0;
+        },
+    };
+}

package/dist/src/interceptors/matchers.d.ts

@@ -0,0 +1,15 @@
+import type { RequestMatcher } from "./types.js";
+export declare const matchFacilitatorAccepts: RequestMatcher;
+export declare const matchFacilitatorVerify: RequestMatcher;
+export declare const matchFacilitatorSettle: RequestMatcher;
+export declare const matchFacilitatorSupported: RequestMatcher;
+export declare const matchFacilitator: RequestMatcher;
+export declare const matchResource: RequestMatcher;
+export declare function and(...matchers: RequestMatcher[]): RequestMatcher;
+export declare function or(...matchers: RequestMatcher[]): RequestMatcher;
+export declare function not(matcher: RequestMatcher): RequestMatcher;
+export declare function matchURL(pattern: string | RegExp): RequestMatcher;
+export declare function matchMethod(method: string): RequestMatcher;
+export declare const matchAll: RequestMatcher;
+export declare const matchNone: RequestMatcher;
+//# sourceMappingURL=matchers.d.ts.map

package/dist/src/interceptors/matchers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchers.d.ts","sourceRoot":"","sources":["../../../src/interceptors/matchers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,eAAO,MAAM,uBAAuB,EAAE,cACA,CAAC;AAEvC,eAAO,MAAM,sBAAsB,EAAE,cACA,CAAC;AAEtC,eAAO,MAAM,sBAAsB,EAAE,cACA,CAAC;AAEtC,eAAO,MAAM,yBAAyB,EAAE,cACA,CAAC;AAEzC,eAAO,MAAM,gBAAgB,EAAE,cAIC,CAAC;AAEjC,eAAO,MAAM,aAAa,EAAE,cAAgD,CAAC;AAE7E,wBAAgB,GAAG,CAAC,GAAG,QAAQ,EAAE,cAAc,EAAE,GAAG,cAAc,CAEjE;AAED,wBAAgB,EAAE,CAAC,GAAG,QAAQ,EAAE,cAAc,EAAE,GAAG,cAAc,CAEhE;AAED,wBAAgB,GAAG,CAAC,OAAO,EAAE,cAAc,GAAG,cAAc,CAE3D;AAED,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,cAAc,CAKjE;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,CAG1D;AAED,eAAO,MAAM,QAAQ,EAAE,cAA2B,CAAC;AAEnD,eAAO,MAAM,SAAS,EAAE,cAA4B,CAAC"}

package/dist/src/interceptors/matchers.js

@@ -0,0 +1,30 @@
+export const matchFacilitatorAccepts = (url) => url.includes("/facilitator/accepts");
+export const matchFacilitatorVerify = (url) => url.includes("/facilitator/verify");
+export const matchFacilitatorSettle = (url) => url.includes("/facilitator/settle");
+export const matchFacilitatorSupported = (url) => url.includes("/facilitator/supported");
+export const matchFacilitator = (url) => matchFacilitatorAccepts(url) ||
+    matchFacilitatorVerify(url) ||
+    matchFacilitatorSettle(url) ||
+    matchFacilitatorSupported(url);
+export const matchResource = (url) => !matchFacilitator(url);
+export function and(...matchers) {
+    return (url, init) => matchers.every((m) => m(url, init));
+}
+export function or(...matchers) {
+    return (url, init) => matchers.some((m) => m(url, init));
+}
+export function not(matcher) {
+    return (url, init) => !matcher(url, init);
+}
+export function matchURL(pattern) {
+    if (typeof pattern === "string") {
+        return (url) => url.includes(pattern);
+    }
+    return (url) => pattern.test(url);
+}
+export function matchMethod(method) {
+    const upperMethod = method.toUpperCase();
+    return (_url, init) => (init?.method?.toUpperCase() ?? "GET") === upperMethod;
+}
+export const matchAll = () => true;
+export const matchNone = () => false;