npm - @fluojs/testing - Versions diffs - 2.0.0 → 3.0.0 - Mend

@fluojs/testing 2.0.0 → 3.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (41) hide show

package/dist/portability/error-representation-abort-portability.js ADDED Viewed

@@ -0,0 +1,190 @@
+import { defineModule } from '@fluojs/runtime';
+function createDeferred() {
+  let resolve = () => {};
+  const promise = new Promise(resolvePromise => {
+    resolve = resolvePromise;
+  });
+  return {
+    promise,
+    resolve
+  };
+}
+function createAbortProbe() {
+  const providerAborted = createDeferred();
+  const providerStarted = createDeferred();
+  const requestFinished = createDeferred();
+  let providerCalls = 0;
+  const representationWrites = [];
+  const middleware = {
+    async handle(context, next) {
+      const send = context.response.send.bind(context.response);
+      context.response.send = body => {
+        if (body !== undefined) {
+          representationWrites.push(body);
+        }
+        return send(body);
+      };
+      await next();
+    }
+  };
+  const requestObserver = {
+    onRequestFinish() {
+      requestFinished.resolve();
+    }
+  };
+  const html = {
+    render({
+      request
+    }) {
+      providerCalls += 1;
+      providerStarted.resolve();
+      return new Promise((resolve, reject) => {
+        const signal = request.signal;
+        if (signal === undefined) {
+          reject(new Error('The adapter did not expose an AbortSignal to the HTML error provider.'));
+          return;
+        }
+        const completeAfterAbort = () => {
+          providerAborted.resolve();
+          resolve('<html><body>late error document</body></html>');
+        };
+        if (signal.aborted) {
+          completeAfterAbort();
+          return;
+        }
+        signal.addEventListener('abort', completeAfterAbort, {
+          once: true
+        });
+      });
+    }
+  };
+  return {
+    assertNoCommit(name) {
+      if (providerCalls !== 1) {
+        throw new Error(`${name} did not execute exactly one in-flight HTML error provider before abort.`);
+      }
+      if (representationWrites.length !== 0) {
+        throw new Error(`${name} committed an HTML or canonical JSON fallback response after abort: ${JSON.stringify(representationWrites)}.`);
+      }
+    },
+    bootstrapOptions: {
+      cors: false,
+      errorRepresentation: {
+        html
+      },
+      middleware: [middleware]
+    },
+    providerAborted: providerAborted.promise,
+    providerStarted: providerStarted.promise,
+    requestFinished: requestFinished.promise,
+    requestObserver
+  };
+}
+function hasListenTarget(value) {
+  return typeof value === 'object' && value !== null && 'getListenTarget' in value && typeof value.getListenTarget === 'function';
+}
+function resolveListeningUrl(app, name) {
+  const adapter = Reflect.get(app, 'adapter');
+  if (!hasListenTarget(adapter)) {
+    throw new Error(`${name} abort portability check could not resolve its listener URL.`);
+  }
+  return adapter.getListenTarget().url;
+}
+async function withTimeout(promise, name, phase) {
+  let timeout;
+  const timeoutPromise = new Promise((_resolve, reject) => {
+    timeout = setTimeout(() => {
+      reject(new Error(`${name} timed out while waiting for ${phase}.`));
+    }, 2_000);
+  });
+  try {
+    await Promise.race([promise, timeoutPromise]);
+  } finally {
+    if (timeout !== undefined) {
+      clearTimeout(timeout);
+    }
+  }
+}
+async function closeAfterAbortAssertion(app, name, assertion) {
+  let assertionError;
+  try {
+    await assertion();
+  } catch (error) {
+    assertionError = error;
+  }
+  try {
+    await app.close();
+  } catch (cleanupError) {
+    throw assertionError === undefined ? cleanupError : new AggregateError([assertionError, cleanupError], `${name} abort assertion and cleanup both failed.`);
+  }
+  if (assertionError !== undefined) {
+    throw assertionError;
+  }
+}
+function createEmptyModule() {
+  class AppModule {}
+  defineModule(AppModule, {});
+  return AppModule;
+}
+/**
+ * Verifies that a disconnected network request commits neither HTML nor canonical JSON fallback.
+ *
+ * @param options Adapter bootstrap and identity callbacks.
+ * @returns A promise that resolves after native disconnect and no-representation-write checks pass.
+ */
+export async function assertNetworkHttpErrorRepresentationAbortPortability(options) {
+  const probe = createAbortProbe();
+  const app = await options.bootstrap(createEmptyModule(), options.createBootstrapOptions({
+    ...probe.bootstrapOptions,
+    observers: [probe.requestObserver],
+    port: 0
+  }));
+  await closeAfterAbortAssertion(app, options.name, async () => {
+    await app.listen();
+    const {
+      request
+    } = await import('node:http');
+    const clientRequest = request(`${resolveListeningUrl(app, options.name)}/abort-error-representation`, {
+      headers: {
+        accept: 'text/html'
+      }
+    });
+    clientRequest.on('error', () => {});
+    try {
+      clientRequest.end();
+      await withTimeout(probe.providerStarted, options.name, 'the HTML error provider to start');
+      clientRequest.destroy();
+      await withTimeout(probe.providerAborted, options.name, 'the provider request signal to abort');
+      await withTimeout(probe.requestFinished, options.name, 'the aborted request lifecycle to finish');
+      probe.assertNoCommit(options.name);
+    } finally {
+      clientRequest.destroy();
+    }
+  });
+}
+/**
+ * Verifies that an aborted Web request commits neither HTML nor canonical JSON fallback.
+ *
+ * @param options Adapter bootstrap and identity callbacks.
+ * @returns A promise that resolves after Web abort and no-representation-write checks pass.
+ */
+export async function assertWebHttpErrorRepresentationAbortPortability(options) {
+  const probe = createAbortProbe();
+  const app = await options.bootstrap(createEmptyModule(), options.createBootstrapOptions(probe.bootstrapOptions));
+  await closeAfterAbortAssertion(app, options.name, async () => {
+    const abortController = new AbortController();
+    const dispatch = app.dispatch(new Request('https://runtime.test/abort-error-representation', {
+      headers: {
+        accept: 'text/html'
+      },
+      signal: abortController.signal
+    }));
+    await withTimeout(probe.providerStarted, options.name, 'the HTML error provider to start');
+    abortController.abort();
+    await withTimeout(probe.providerAborted, options.name, 'the provider request signal to abort');
+    await withTimeout(dispatch.then(() => undefined), options.name, 'the aborted Web request dispatch to finish');
+    probe.assertNoCommit(options.name);
+  });
+}

package/dist/portability/error-representation-portability-fixture.d.ts ADDED Viewed

@@ -0,0 +1,58 @@
+import { type HttpErrorRepresentationOptions, type Middleware } from '@fluojs/http';
+import { type ModuleType } from '@fluojs/runtime';
+type ErrorRepresentationBootstrapOptions = {
+    readonly cors: false;
+    readonly errorRepresentation: HttpErrorRepresentationOptions | undefined;
+    readonly middleware: Middleware[];
+};
+type RepresentationResponses = {
+    readonly binary: Response;
+    readonly binaryHead: Response;
+    readonly committed: Response;
+    readonly head: Response;
+    readonly html: Response;
+    readonly json: Response;
+    readonly jsonHead: Response;
+    readonly plain: Response;
+    readonly plainHead: Response;
+    readonly success: Response;
+    readonly successHead: Response;
+    readonly unsupported: Response;
+    readonly unsupportedHead: Response;
+};
+/**
+ * Verifies provider-less canonical JSON metadata and body suppression for a HEAD response.
+ *
+ * @param name Adapter name included in assertion failures.
+ * @param response Provider-less HEAD response returned by the adapter.
+ * @returns A promise that resolves when the response preserves the portable contract.
+ */
+export declare function assertProviderlessHeadResponse(name: string, response: Response): Promise<void>;
+/**
+ * Verifies negotiated error and successful HEAD responses returned by an adapter.
+ *
+ * @param name Adapter name included in assertion failures.
+ * @param responses Responses collected from the shared representation fixture.
+ * @returns A promise that resolves when every response preserves the portable contract.
+ */
+export declare function assertRepresentationResponses(name: string, responses: RepresentationResponses): Promise<void>;
+/**
+ * Creates the shared application module used by error-representation portability checks.
+ *
+ * @returns A module containing success, error, HEAD, and committed-response routes.
+ */
+export declare function createRepresentationFixture(): ModuleType;
+/**
+ * Creates bootstrap options with the shared HTML error-representation provider enabled.
+ *
+ * @returns Common adapter bootstrap options for negotiated representation checks.
+ */
+export declare function createErrorRepresentationOptions(): ErrorRepresentationBootstrapOptions;
+/**
+ * Creates bootstrap options without an HTML error-representation provider.
+ *
+ * @returns Common adapter bootstrap options for canonical JSON fallback checks.
+ */
+export declare function createProviderlessErrorRepresentationOptions(): ErrorRepresentationBootstrapOptions;
+export {};
+//# sourceMappingURL=error-representation-portability-fixture.d.ts.map

package/dist/portability/error-representation-portability-fixture.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"error-representation-portability-fixture.d.ts","sourceRoot":"","sources":["../../src/portability/error-representation-portability-fixture.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,8BAA8B,EACnC,KAAK,UAAU,EAGhB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAgB,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAEhE,KAAK,mCAAmC,GAAG;IACzC,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IACrB,QAAQ,CAAC,mBAAmB,EAAE,8BAA8B,GAAG,SAAS,CAAC;IACzE,QAAQ,CAAC,UAAU,EAAE,UAAU,EAAE,CAAC;CACnC,CAAC;AAEF,KAAK,uBAAuB,GAAG;IAC7B,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC;IAC3B,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC;IAC/B,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC;IAC/B,QAAQ,CAAC,eAAe,EAAE,QAAQ,CAAC;CACpC,CAAC;AAsCF;;;;;;GAMG;AACH,wBAAsB,8BAA8B,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAKpG;AAED;;;;;;GAMG;AACH,wBAAsB,6BAA6B,CACjD,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,uBAAuB,GACjC,OAAO,CAAC,IAAI,CAAC,CAgEf;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,IAAI,UAAU,CAyDxD;AAED;;;;GAIG;AACH,wBAAgB,gCAAgC,IAAI,mCAAmC,CAYtF;AAED;;;;GAIG;AACH,wBAAgB,4CAA4C,IAAI,mCAAmC,CAMlG"}

package/dist/portability/error-representation-portability-fixture.js ADDED Viewed

@@ -0,0 +1,202 @@
+function _applyDecs(e, t, n, r, o, i) { var a, c, u, s, f, l, p, d = Symbol.metadata || Symbol.for("Symbol.metadata"), m = Object.defineProperty, h = Object.create, y = [h(null), h(null)], v = t.length; function g(t, n, r) { return function (o, i) { n && (i = o, o = e); for (var a = 0; a < t.length; a++) i = t[a].apply(o, r ? [i] : []); return r ? i : o; }; } function b(e, t, n, r) { if ("function" != typeof e && (r || void 0 !== e)) throw new TypeError(t + " must " + (n || "be") + " a function" + (r ? "" : " or undefined")); return e; } function applyDec(e, t, n, r, o, i, u, s, f, l, p) { function d(e) { if (!p(e)) throw new TypeError("Attempted to access private element on non-instance"); } var h = [].concat(t[0]), v = t[3], w = !u, D = 1 === o, S = 3 === o, j = 4 === o, E = 2 === o; function I(t, n, r) { return function (o, i) { return n && (i = o, o = e), r && r(o), P[t].call(o, i); }; } if (!w) { var P = {}, k = [], F = S ? "get" : j || D ? "set" : "value"; if (f ? (l || D ? P = { get: _setFunctionName(function () { return v(this); }, r, "get"), set: function (e) { t[4](this, e); } } : P[F] = v, l || _setFunctionName(P[F], r, E ? "" : F)) : l || (P = Object.getOwnPropertyDescriptor(e, r)), !l && !f) { if ((c = y[+s][r]) && 7 !== (c ^ o)) throw Error("Decorating two elements with the same name (" + P[F].name + ") is not supported yet"); y[+s][r] = o < 3 ? 1 : o; } } for (var N = e, O = h.length - 1; O >= 0; O -= n ? 2 : 1) { var T = b(h[O], "A decorator", "be", !0), z = n ? h[O - 1] : void 0, A = {}, H = { kind: ["field", "accessor", "method", "getter", "setter", "class"][o], name: r, metadata: a, addInitializer: function (e, t) { if (e.v) throw new TypeError("attempted to call addInitializer after decoration was finished"); b(t, "An initializer", "be", !0), i.push(t); }.bind(null, A) }; if (w) c = T.call(z, N, H), A.v = 1, b(c, "class decorators", "return") && (N = c);else if (H.static = s, H.private = f, c = H.access = { has: f ? p.bind() : function (e) { return r in e; } }, j || (c.get = f ? E ? function (e) { return d(e), P.value; } : I("get", 0, d) : function (e) { return e[r]; }), E || S || (c.set = f ? I("set", 0, d) : function (e, t) { e[r] = t; }), N = T.call(z, D ? { get: P.get, set: P.set } : P[F], H), A.v = 1, D) { if ("object" == typeof N && N) (c = b(N.get, "accessor.get")) && (P.get = c), (c = b(N.set, "accessor.set")) && (P.set = c), (c = b(N.init, "accessor.init")) && k.unshift(c);else if (void 0 !== N) throw new TypeError("accessor decorators must return an object with get, set, or init properties or undefined"); } else b(N, (l ? "field" : "method") + " decorators", "return") && (l ? k.unshift(N) : P[F] = N); } return o < 2 && u.push(g(k, s, 1), g(i, s, 0)), l || w || (f ? D ? u.splice(-1, 0, I("get", s), I("set", s)) : u.push(E ? P[F] : b.call.bind(P[F])) : m(e, r, P)), N; } function w(e) { return m(e, d, { configurable: !0, enumerable: !0, value: a }); } return void 0 !== i && (a = i[d]), a = h(null == a ? null : a), f = [], l = function (e) { e && f.push(g(e)); }, p = function (t, r) { for (var i = 0; i < n.length; i++) { var a = n[i], c = a[1], l = 7 & c; if ((8 & c) == t && !l == r) { var p = a[2], d = !!a[3], m = 16 & c; applyDec(t ? e : e.prototype, a, m, d ? "#" + p : _toPropertyKey(p), l, l < 2 ? [] : t ? s = s || [] : u = u || [], f, !!t, d, r, t && d ? function (t) { return _checkInRHS(t) === e; } : o); } } }, p(8, 0), p(0, 0), p(8, 1), p(0, 1), l(u), l(s), c = f, v || w(e), { e: c, get c() { var n = []; return v && [w(e = applyDec(e, [t], r, e.name, 5, n)), g(n, 1)]; } }; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _setFunctionName(e, t, n) { "symbol" == typeof t && (t = (t = t.description) ? "[" + t + "]" : ""); try { Object.defineProperty(e, "name", { configurable: !0, value: n ? n + " " + t : t }); } catch (e) {} return e; }
+function _checkInRHS(e) { if (Object(e) !== e) throw TypeError("right-hand side of 'in' should be an object, got " + (null !== e ? typeof e : "null")); return e; }
+import { Controller, Get, Head, Header, HttpCode, NotFoundException } from '@fluojs/http';
+import { defineModule } from '@fluojs/runtime';
+function hasErrorCode(value, code) {
+  if (typeof value !== 'object' || value === null) {
+    return false;
+  }
+  const error = Reflect.get(value, 'error');
+  return typeof error === 'object' && error !== null && Reflect.get(error, 'code') === code;
+}
+function assertStatus(response, expected, name, scenario) {
+  if (response.status !== expected) {
+    throw new Error(`${name} changed ${scenario} status: expected ${String(expected)}, received ${String(response.status)}.`);
+  }
+}
+async function assertHeadRepresentationParity(name, pair) {
+  const contentType = pair.response.headers.get('content-type');
+  const headContentType = pair.headResponse.headers.get('content-type');
+  if (contentType === null || headContentType !== contentType) {
+    throw new Error(`${name} changed ${pair.scenario} HEAD content type parity: GET=${String(contentType)}, HEAD=${String(headContentType)}.`);
+  }
+  if ((await pair.response.arrayBuffer().then(body => body.byteLength)) === 0 || (await pair.headResponse.text()) !== '') {
+    throw new Error(`${name} changed ${pair.scenario} GET body or HEAD body suppression semantics.`);
+  }
+}
+/**
+ * Verifies provider-less canonical JSON metadata and body suppression for a HEAD response.
+ *
+ * @param name Adapter name included in assertion failures.
+ * @param response Provider-less HEAD response returned by the adapter.
+ * @returns A promise that resolves when the response preserves the portable contract.
+ */
+export async function assertProviderlessHeadResponse(name, response) {
+  assertStatus(response, 404, name, 'provider-less canonical JSON HEAD error representation');
+  if (response.headers.get('content-type') !== 'application/json; charset=utf-8' || (await response.text()) !== '') {
+    throw new Error(`${name} changed provider-less canonical JSON HEAD representation metadata or body suppression.`);
+  }
+}
+/**
+ * Verifies negotiated error and successful HEAD responses returned by an adapter.
+ *
+ * @param name Adapter name included in assertion failures.
+ * @param responses Responses collected from the shared representation fixture.
+ * @returns A promise that resolves when every response preserves the portable contract.
+ */
+export async function assertRepresentationResponses(name, responses) {
+  assertStatus(responses.html, 404, name, 'HTML error representation');
+  assertStatus(responses.json, 404, name, 'JSON error representation');
+  assertStatus(responses.head, 404, name, 'HEAD error representation');
+  assertStatus(responses.jsonHead, 404, name, 'canonical JSON HEAD error representation');
+  assertStatus(responses.success, 202, name, 'successful JSON response');
+  assertStatus(responses.successHead, 202, name, 'successful HEAD response');
+  assertStatus(responses.plain, 200, name, 'successful plain text response');
+  assertStatus(responses.plainHead, 200, name, 'successful plain text HEAD response');
+  assertStatus(responses.binary, 200, name, 'successful binary response');
+  assertStatus(responses.binaryHead, 200, name, 'successful binary HEAD response');
+  assertStatus(responses.unsupported, 406, name, 'unsupported error representation');
+  assertStatus(responses.unsupportedHead, 406, name, 'unsupported HEAD error representation');
+  assertStatus(responses.committed, 202, name, 'already-committed response');
+  const [html, json, head, jsonHead, unsupported, unsupportedHead, committed] = await Promise.all([responses.html.text(), responses.json.json(), responses.head.text(), responses.jsonHead.text(), responses.unsupported.json(), responses.unsupportedHead.text(), responses.committed.text()]);
+  if (!responses.html.headers.get('content-type')?.includes('text/html') || !html.includes('404:NOT_FOUND')) {
+    throw new Error(`${name} changed negotiated HTML error representation semantics.`);
+  }
+  if (!hasErrorCode(json, 'NOT_FOUND')) {
+    throw new Error(`${name} changed canonical JSON error representation semantics.`);
+  }
+  if (!responses.head.headers.get('content-type')?.includes('text/html') || head !== '') {
+    throw new Error(`${name} changed HEAD error representation body suppression.`);
+  }
+  if (responses.jsonHead.headers.get('content-type') !== 'application/json; charset=utf-8' || jsonHead !== '') {
+    throw new Error(`${name} changed canonical JSON HEAD error representation metadata or body suppression.`);
+  }
+  if (responses.successHead.headers.get('x-head-contract') !== 'preserved') {
+    throw new Error(`${name} changed successful HEAD explicit header semantics.`);
+  }
+  await assertHeadRepresentationParity(name, {
+    headResponse: responses.successHead,
+    response: responses.success,
+    scenario: 'successful JSON'
+  });
+  await assertHeadRepresentationParity(name, {
+    headResponse: responses.plainHead,
+    response: responses.plain,
+    scenario: 'successful plain text'
+  });
+  await assertHeadRepresentationParity(name, {
+    headResponse: responses.binaryHead,
+    response: responses.binary,
+    scenario: 'successful binary'
+  });
+  if (!hasErrorCode(unsupported, 'NOT_ACCEPTABLE')) {
+    throw new Error(`${name} changed unsupported error representation fallback semantics.`);
+  }
+  if (responses.unsupportedHead.headers.get('content-type') !== 'application/json; charset=utf-8' || unsupportedHead !== '') {
+    throw new Error(`${name} changed unsupported HEAD error representation metadata or body suppression.`);
+  }
+  if (committed !== 'handler-owned') {
+    throw new Error(`${name} rewrote an already-committed response through the error provider.`);
+  }
+}
+/**
+ * Creates the shared application module used by error-representation portability checks.
+ *
+ * @returns A module containing success, error, HEAD, and committed-response routes.
+ */
+export function createRepresentationFixture() {
+  let _initProto, _initClass;
+  let _ErrorRepresentationC;
+  class ErrorRepresentationController {
+    static {
+      ({
+        e: [_initProto],
+        c: [_ErrorRepresentationC, _initClass]
+      } = _applyDecs(this, [Controller('/error-representations')], [[Get('/json'), 2, "json"], [Head('/head'), 2, "head"], [[Head('/success-head'), Header('x-head-contract', 'preserved'), HttpCode(202)], 2, "successHead"], [[Get('/success-head'), HttpCode(202)], 2, "success"], [Head('/plain-head'), 2, "plainHead"], [Get('/plain-head'), 2, "plain"], [Head('/binary-head'), 2, "binaryHead"], [Get('/binary-head'), 2, "binary"], [Get('/committed'), 2, "committed"]]));
+    }
+    constructor() {
+      _initProto(this);
+    }
+    json() {
+      throw new NotFoundException('Matched resource missing.');
+    }
+    head() {
+      throw new NotFoundException('HEAD resource missing.');
+    }
+    successHead() {
+      return {
+        ok: true
+      };
+    }
+    success() {
+      return {
+        ok: true
+      };
+    }
+    plainHead() {
+      return 'plain response';
+    }
+    plain() {
+      return 'plain response';
+    }
+    binaryHead() {
+      return new Uint8Array([1, 2, 3]);
+    }
+    binary() {
+      return new Uint8Array([1, 2, 3]);
+    }
+    async committed(_input, context) {
+      context.response.setStatus(202);
+      await context.response.send('handler-owned');
+      throw new NotFoundException('Committed response must not be replaced.');
+    }
+    static {
+      _initClass();
+    }
+  }
+  class AppModule {}
+  defineModule(AppModule, {
+    controllers: [_ErrorRepresentationC]
+  });
+  return AppModule;
+}
+/**
+ * Creates bootstrap options with the shared HTML error-representation provider enabled.
+ *
+ * @returns Common adapter bootstrap options for negotiated representation checks.
+ */
+export function createErrorRepresentationOptions() {
+  return {
+    cors: false,
+    errorRepresentation: {
+      html: {
+        render({
+          json
+        }) {
+          return `<html><body>${String(json.error.status)}:${json.error.code}</body></html>`;
+        }
+      }
+    },
+    middleware: []
+  };
+}
+/**
+ * Creates bootstrap options without an HTML error-representation provider.
+ *
+ * @returns Common adapter bootstrap options for canonical JSON fallback checks.
+ */
+export function createProviderlessErrorRepresentationOptions() {
+  return {
+    cors: false,
+    errorRepresentation: undefined,
+    middleware: []
+  };
+}

package/dist/portability/error-representation-portability.d.ts ADDED Viewed

@@ -0,0 +1,50 @@
+import type { HttpErrorRepresentationOptions, Middleware, RequestObserver } from '@fluojs/http';
+import type { ModuleType } from '@fluojs/runtime';
+type NetworkApp = {
+    close(): Promise<void>;
+    listen(): Promise<void>;
+};
+type NetworkHarnessOptions<TBootstrapOptions extends object, TApp extends NetworkApp> = {
+    readonly bootstrap: (rootModule: ModuleType, options: TBootstrapOptions) => Promise<TApp>;
+    readonly createBootstrapOptions: (options: NetworkHttpErrorRepresentationBootstrapOptions) => TBootstrapOptions;
+    readonly name: string;
+};
+type WebApp = {
+    close(): Promise<void>;
+    dispatch(request: Request): Promise<Response>;
+};
+type WebHarnessOptions<TBootstrapOptions extends object, TApp extends WebApp> = {
+    readonly bootstrap: (rootModule: ModuleType, options: TBootstrapOptions) => Promise<TApp>;
+    readonly createBootstrapOptions: (options: WebHttpErrorRepresentationBootstrapOptions) => TBootstrapOptions;
+    readonly name: string;
+};
+/** Adapter bootstrap fields required by the network error-representation portability scenario. */
+export type NetworkHttpErrorRepresentationBootstrapOptions = {
+    readonly cors: false;
+    readonly errorRepresentation: HttpErrorRepresentationOptions | undefined;
+    readonly middleware: Middleware[];
+    readonly observers: RequestObserver[];
+    readonly port: 0;
+};
+/** Adapter bootstrap fields required by the Web error-representation portability scenario. */
+export type WebHttpErrorRepresentationBootstrapOptions = {
+    readonly cors: false;
+    readonly errorRepresentation: HttpErrorRepresentationOptions | undefined;
+    readonly middleware: Middleware[];
+};
+/**
+ * Verifies negotiated HTTP error representations through a listening adapter.
+ *
+ * @param options Adapter bootstrap and identity callbacks.
+ * @returns A promise that resolves after JSON, HTML, HEAD, 406, and commit-guard checks pass.
+ */
+export declare function assertNetworkHttpErrorRepresentationPortability<TBootstrapOptions extends object, TApp extends NetworkApp>(options: NetworkHarnessOptions<TBootstrapOptions, TApp>): Promise<void>;
+/**
+ * Verifies negotiated HTTP error representations through a fetch-style adapter.
+ *
+ * @param options Adapter bootstrap and identity callbacks.
+ * @returns A promise that resolves after JSON, HTML, HEAD, 406, and commit-guard checks pass.
+ */
+export declare function assertWebHttpErrorRepresentationPortability<TBootstrapOptions extends object, TApp extends WebApp>(options: WebHarnessOptions<TBootstrapOptions, TApp>): Promise<void>;
+export {};
+//# sourceMappingURL=error-representation-portability.d.ts.map

package/dist/portability/error-representation-portability.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"error-representation-portability.d.ts","sourceRoot":"","sources":["../../src/portability/error-representation-portability.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,8BAA8B,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAChG,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AASlD,KAAK,UAAU,GAAG;IAChB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB,CAAC;AAEF,KAAK,qBAAqB,CAAC,iBAAiB,SAAS,MAAM,EAAE,IAAI,SAAS,UAAU,IAAI;IACtF,QAAQ,CAAC,SAAS,EAAE,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,iBAAiB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1F,QAAQ,CAAC,sBAAsB,EAAE,CAC/B,OAAO,EAAE,8CAA8C,KACpD,iBAAiB,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,KAAK,MAAM,GAAG;IACZ,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;CAC/C,CAAC;AAEF,KAAK,iBAAiB,CAAC,iBAAiB,SAAS,MAAM,EAAE,IAAI,SAAS,MAAM,IAAI;IAC9E,QAAQ,CAAC,SAAS,EAAE,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,iBAAiB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1F,QAAQ,CAAC,sBAAsB,EAAE,CAC/B,OAAO,EAAE,0CAA0C,KAChD,iBAAiB,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,kGAAkG;AAClG,MAAM,MAAM,8CAA8C,GAAG;IAC3D,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IACrB,QAAQ,CAAC,mBAAmB,EAAE,8BAA8B,GAAG,SAAS,CAAC;IACzE,QAAQ,CAAC,UAAU,EAAE,UAAU,EAAE,CAAC;IAClC,QAAQ,CAAC,SAAS,EAAE,eAAe,EAAE,CAAC;IACtC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;CAClB,CAAC;AAEF,8FAA8F;AAC9F,MAAM,MAAM,0CAA0C,GAAG;IACvD,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IACrB,QAAQ,CAAC,mBAAmB,EAAE,8BAA8B,GAAG,SAAS,CAAC;IACzE,QAAQ,CAAC,UAAU,EAAE,UAAU,EAAE,CAAC;CACnC,CAAC;AAyCF;;;;;GAKG;AACH,wBAAsB,+CAA+C,CACnE,iBAAiB,SAAS,MAAM,EAChC,IAAI,SAAS,UAAU,EACvB,OAAO,EAAE,qBAAqB,CAAC,iBAAiB,EAAE,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CA+CxE;AAED;;;;;GAKG;AACH,wBAAsB,2CAA2C,CAC/D,iBAAiB,SAAS,MAAM,EAChC,IAAI,SAAS,MAAM,EACnB,OAAO,EAAE,iBAAiB,CAAC,iBAAiB,EAAE,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAuCpE"}

package/dist/portability/error-representation-portability.js ADDED Viewed

@@ -0,0 +1,153 @@
+import { assertProviderlessHeadResponse, assertRepresentationResponses, createErrorRepresentationOptions, createProviderlessErrorRepresentationOptions, createRepresentationFixture } from './error-representation-portability-fixture.js';
+/** Adapter bootstrap fields required by the network error-representation portability scenario. */
+/** Adapter bootstrap fields required by the Web error-representation portability scenario. */
+function hasListenTarget(value) {
+  return typeof value === 'object' && value !== null && 'getListenTarget' in value && typeof value.getListenTarget === 'function';
+}
+function resolveListeningUrl(app, name) {
+  const adapter = Reflect.get(app, 'adapter');
+  if (!hasListenTarget(adapter)) {
+    throw new Error(`${name} error representation portability check could not resolve its listener URL.`);
+  }
+  return adapter.getListenTarget().url;
+}
+async function closeAfterAssertion(app, name, assertion) {
+  let assertionError;
+  try {
+    await assertion();
+  } catch (error) {
+    assertionError = error;
+  }
+  try {
+    await app.close();
+  } catch (cleanupError) {
+    throw assertionError === undefined ? cleanupError : new AggregateError([assertionError, cleanupError], `${name} representation assertion and cleanup both failed.`);
+  }
+  if (assertionError !== undefined) {
+    throw assertionError;
+  }
+}
+/**
+ * Verifies negotiated HTTP error representations through a listening adapter.
+ *
+ * @param options Adapter bootstrap and identity callbacks.
+ * @returns A promise that resolves after JSON, HTML, HEAD, 406, and commit-guard checks pass.
+ */
+export async function assertNetworkHttpErrorRepresentationPortability(options) {
+  const app = await options.bootstrap(createRepresentationFixture(), options.createBootstrapOptions({
+    ...createErrorRepresentationOptions(),
+    observers: [],
+    port: 0
+  }));
+  await closeAfterAssertion(app, options.name, async () => {
+    await app.listen();
+    const baseUrl = resolveListeningUrl(app, options.name);
+    await assertRepresentationResponses(options.name, {
+      binary: await fetch(`${baseUrl}/error-representations/binary-head`),
+      binaryHead: await fetch(`${baseUrl}/error-representations/binary-head`, {
+        method: 'HEAD'
+      }),
+      committed: await fetch(`${baseUrl}/error-representations/committed`, {
+        headers: {
+          accept: 'text/html'
+        }
+      }),
+      head: await fetch(`${baseUrl}/error-representations/head`, {
+        headers: {
+          accept: 'text/html'
+        },
+        method: 'HEAD'
+      }),
+      html: await fetch(`${baseUrl}/not-registered`, {
+        headers: {
+          accept: 'text/html'
+        }
+      }),
+      json: await fetch(`${baseUrl}/error-representations/json`, {
+        headers: {
+          accept: 'application/json'
+        }
+      }),
+      jsonHead: await fetch(`${baseUrl}/error-representations/head`, {
+        headers: {
+          accept: 'application/json'
+        },
+        method: 'HEAD'
+      }),
+      plain: await fetch(`${baseUrl}/error-representations/plain-head`),
+      plainHead: await fetch(`${baseUrl}/error-representations/plain-head`, {
+        method: 'HEAD'
+      }),
+      success: await fetch(`${baseUrl}/error-representations/success-head`),
+      successHead: await fetch(`${baseUrl}/error-representations/success-head`, {
+        method: 'HEAD'
+      }),
+      unsupported: await fetch(`${baseUrl}/not-registered`, {
+        headers: {
+          accept: 'image/avif'
+        }
+      }),
+      unsupportedHead: await fetch(`${baseUrl}/not-registered`, {
+        headers: {
+          accept: 'image/avif'
+        },
+        method: 'HEAD'
+      })
+    });
+  });
+  const providerlessApp = await options.bootstrap(createRepresentationFixture(), options.createBootstrapOptions({
+    ...createProviderlessErrorRepresentationOptions(),
+    observers: [],
+    port: 0
+  }));
+  await closeAfterAssertion(providerlessApp, options.name, async () => {
+    await providerlessApp.listen();
+    const baseUrl = resolveListeningUrl(providerlessApp, options.name);
+    await assertProviderlessHeadResponse(options.name, await fetch(`${baseUrl}/not-registered`, {
+      method: 'HEAD'
+    }));
+  });
+}
+/**
+ * Verifies negotiated HTTP error representations through a fetch-style adapter.
+ *
+ * @param options Adapter bootstrap and identity callbacks.
+ * @returns A promise that resolves after JSON, HTML, HEAD, 406, and commit-guard checks pass.
+ */
+export async function assertWebHttpErrorRepresentationPortability(options) {
+  const app = await options.bootstrap(createRepresentationFixture(), options.createBootstrapOptions(createErrorRepresentationOptions()));
+  await closeAfterAssertion(app, options.name, async () => {
+    const request = (path, accept, method = 'GET') => new Request(`https://runtime.test${path}`, {
+      headers: {
+        accept
+      },
+      method
+    });
+    await assertRepresentationResponses(options.name, {
+      binary: await app.dispatch(request('/error-representations/binary-head', '*/*')),
+      binaryHead: await app.dispatch(request('/error-representations/binary-head', '*/*', 'HEAD')),
+      committed: await app.dispatch(request('/error-representations/committed', 'text/html')),
+      head: await app.dispatch(request('/error-representations/head', 'text/html', 'HEAD')),
+      html: await app.dispatch(request('/not-registered', 'text/html')),
+      json: await app.dispatch(request('/error-representations/json', 'application/json')),
+      jsonHead: await app.dispatch(request('/error-representations/head', 'application/json', 'HEAD')),
+      plain: await app.dispatch(request('/error-representations/plain-head', '*/*')),
+      plainHead: await app.dispatch(request('/error-representations/plain-head', '*/*', 'HEAD')),
+      success: await app.dispatch(request('/error-representations/success-head', '*/*')),
+      successHead: await app.dispatch(request('/error-representations/success-head', '*/*', 'HEAD')),
+      unsupported: await app.dispatch(request('/not-registered', 'image/avif')),
+      unsupportedHead: await app.dispatch(request('/not-registered', 'image/avif', 'HEAD'))
+    });
+  });
+  const providerlessApp = await options.bootstrap(createRepresentationFixture(), options.createBootstrapOptions(createProviderlessErrorRepresentationOptions()));
+  await closeAfterAssertion(providerlessApp, options.name, async () => {
+    await assertProviderlessHeadResponse(options.name, await providerlessApp.dispatch(new Request('https://runtime.test/not-registered', {
+      method: 'HEAD'
+    })));
+  });
+}