@testsmith/api-spector 0.3.1 → 0.3.2

package/out/main/chunks/{snapshots-CQliv7WB.js → snapshots-UFd3XgSS.js}

@@ -1,12 +1,77 @@
 "use strict";
-const promises = require("fs/promises");
 const undici = require("undici");
+const authBuilder = require("./auth-builder-CUs9yzOF.js");
+const promises = require("fs/promises");
 const jsYaml = require("js-yaml");
 const Ajv = require("ajv");
-const authBuilder = require("./auth-builder-CRQayp8x.js");
 const path = require("path");
 const crypto = require("crypto");
+const MATCH_KEY = "__match";
+function isMatcher(node) {
+  return typeof node === "object" && node !== null && !Array.isArray(node) && typeof node[MATCH_KEY] === "string";
+}
+function compileMatcher(m) {
+  switch (m[MATCH_KEY]) {
+    case "type":
+      return compileMatcherExample(m.value, false);
+    case "integer":
+      return { type: "integer" };
+    case "decimal":
+    case "number":
+      return { type: "number" };
+    case "boolean":
+      return { type: "boolean" };
+    case "string":
+      return { type: "string" };
+    case "null":
+      return { type: "null" };
+    case "regex":
+      return { type: "string", pattern: m.regex ?? ".*" };
+    case "datetime":
+    case "timestamp":
+      return { type: "string", format: "date-time" };
+    case "date":
+      return { type: "string", format: "date" };
+    case "time":
+      return { type: "string", format: "time" };
+    case "eachLike": {
+      const schema = { type: "array", items: compileMatcherExample(m.value, false) };
+      schema["minItems"] = typeof m.min === "number" ? m.min : 1;
+      return schema;
+    }
+    default:
+      return {};
+  }
+}
+function compileMatcherExample(node, exact = true) {
+  if (isMatcher(node)) return compileMatcher(node);
+  if (node === null) return { type: "null" };
+  const t = typeof node;
+  if (t === "boolean") return exact ? { const: node } : { type: "boolean" };
+  if (t === "number") return exact ? { const: node } : Number.isInteger(node) ? { type: "integer" } : { type: "number" };
+  if (t === "string") return exact ? { const: node } : { type: "string" };
+  if (Array.isArray(node)) {
+    if (node.length === 0) return { type: "array" };
+    const schema = { type: "array", items: node.map((n) => compileMatcherExample(n, exact)) };
+    if (exact) schema["minItems"] = node.length;
+    return schema;
+  }
+  if (t === "object") {
+    const obj = node;
+    const properties = {};
+    const required = [];
+    for (const [key, value] of Object.entries(obj)) {
+      properties[key] = compileMatcherExample(value, exact);
+      required.push(key);
+    }
+    return { type: "object", properties, required, additionalProperties: true };
+  }
+  return {};
+}
 const ajv$1 = new Ajv({ allErrors: true, strict: false });
+function hasContract(contract) {
+  return !!contract && (contract.statusCode !== void 0 || !!contract.bodySchema || !!contract.bodyMatcher || !!contract.headers?.length);
+}
 function validateConsumerResponse(contract, actualStatus, actualHeaders, bodyText) {
   const violations = [];
   if (contract.statusCode !== void 0 && actualStatus !== contract.statusCode) {
@@ -47,33 +112,51 @@ function validateConsumerResponse(contract, actualStatus, actualHeaders, bodyTex
       });
       return violations;
     }
-    let data;
+    violations.push(...validateBody(schema, bodyText));
+  }
+  if (contract.bodyMatcher?.trim()) {
+    let example;
     try {
-      data = JSON.parse(bodyText);
+      example = JSON.parse(contract.bodyMatcher);
     } catch {
       violations.push({
         type: "schema_violation",
-        message: "Response body is not valid JSON — cannot validate against schema"
+        message: "Contract bodyMatcher is not valid JSON"
       });
       return violations;
     }
-    try {
-      const validate = ajv$1.compile(schema);
-      if (!validate(data)) {
-        for (const err of validate.errors ?? []) {
-          violations.push({
-            type: "schema_violation",
-            message: err.message ?? "Schema violation",
-            path: err.instancePath || "/"
-          });
-        }
+    violations.push(...validateBody(compileMatcherExample(example), bodyText));
+  }
+  return violations;
+}
+function validateBody(schema, bodyText) {
+  const violations = [];
+  let data;
+  try {
+    data = JSON.parse(bodyText);
+  } catch {
+    violations.push({
+      type: "schema_violation",
+      message: "Response body is not valid JSON — cannot validate against schema"
+    });
+    return violations;
+  }
+  try {
+    const validate = ajv$1.compile(schema);
+    if (!validate(data)) {
+      for (const err of validate.errors ?? []) {
+        violations.push({
+          type: "schema_violation",
+          message: err.message ?? "Schema violation",
+          path: err.instancePath || "/"
+        });
       }
-    } catch (e) {
-      violations.push({
-        type: "schema_violation",
-        message: `Schema compile error: ${e instanceof Error ? e.message : String(e)}`
-      });
     }
+  } catch (e) {
+    violations.push({
+      type: "schema_violation",
+      message: `Schema compile error: ${e instanceof Error ? e.message : String(e)}`
+    });
   }
   return violations;
 }
@@ -132,9 +215,7 @@ async function executeContract(req, vars) {
 }
 async function runConsumerContracts(requests, envVars, collectionVars = {}) {
   const vars = { ...envVars, ...collectionVars };
-  const contractRequests = requests.filter(
-    (r) => !r.disabled && r.contract && (r.contract.statusCode !== void 0 || r.contract.bodySchema || r.contract.headers?.length)
-  );
+  const contractRequests = requests.filter((r) => !r.disabled && hasContract(r.contract));
   const start = Date.now();
   const results = await Promise.all(contractRequests.map((r) => executeContract(r, vars)));
   const passed = results.filter((r) => r.passed).length;
@@ -309,6 +390,125 @@ async function runProviderVerification(requests, envVars, specUrl, specPath, req
     durationMs: Date.now() - start
   };
 }
+function rebaseUrl(fullUrl, providerBaseUrl) {
+  if (!providerBaseUrl) return fullUrl;
+  try {
+    const orig = new URL(fullUrl, "http://placeholder.invalid");
+    const base = new URL(providerBaseUrl);
+    const basePath = base.pathname.replace(/\/$/, "");
+    base.pathname = (basePath + orig.pathname).replace(/\/{2,}/g, "/");
+    base.search = orig.search;
+    return base.toString();
+  } catch {
+    return fullUrl;
+  }
+}
+async function setupState(stateHandlerUrl, state, action) {
+  if (!stateHandlerUrl) {
+    return {
+      type: "provider_state_failed",
+      message: `Interaction requires provider state "${state}" but no --states-url / stateHandlerUrl was configured`,
+      expected: state
+    };
+  }
+  try {
+    const resp = await undici.fetch(stateHandlerUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ state, action })
+    });
+    if (!resp.ok) {
+      return {
+        type: "provider_state_failed",
+        message: `State handler returned HTTP ${resp.status} setting up "${state}"`,
+        expected: state,
+        actual: String(resp.status)
+      };
+    }
+    return null;
+  } catch (err) {
+    return {
+      type: "provider_state_failed",
+      message: `State handler unreachable for "${state}": ${err instanceof Error ? err.message : String(err)}`,
+      expected: state
+    };
+  }
+}
+async function verifyInteraction(req, vars, providerBaseUrl, stateHandlerUrl) {
+  const url = rebaseUrl(authBuilder.buildUrl(req.url, req.params, vars), providerBaseUrl);
+  const start = Date.now();
+  const violations = [];
+  const states = req.contract?.providerStates ?? [];
+  for (const state of states) {
+    const v = await setupState(stateHandlerUrl, state, "setup");
+    if (v) violations.push(v);
+  }
+  if (violations.length > 0) {
+    return { requestId: req.id, requestName: req.name, method: req.method, url, passed: false, violations, durationMs: Date.now() - start };
+  }
+  try {
+    const headers = new undici.Headers();
+    for (const h of req.headers) {
+      if (h.enabled && h.key) headers.set(authBuilder.interpolate(h.key, vars), authBuilder.interpolate(h.value, vars));
+    }
+    const authHeaders = await authBuilder.buildAuthHeaders(req.auth, vars);
+    for (const [k, v] of Object.entries(authHeaders)) headers.set(k, v);
+    let body;
+    if (req.body.mode === "json" && req.body.json) {
+      body = authBuilder.interpolate(req.body.json, vars);
+      if (!headers.has("content-type")) headers.set("Content-Type", "application/json");
+    } else if (req.body.mode === "raw" && req.body.raw) {
+      body = authBuilder.interpolate(req.body.raw, vars);
+    }
+    const resp = await undici.fetch(url, {
+      method: req.method,
+      headers,
+      body: !["GET", "HEAD"].includes(req.method) ? body : void 0
+    });
+    const bodyText = await resp.text();
+    const rawHeaders = {};
+    resp.headers.forEach((v, k) => {
+      rawHeaders[k] = v;
+    });
+    violations.push(...validateConsumerResponse(req.contract, resp.status, rawHeaders, bodyText));
+    return {
+      requestId: req.id,
+      requestName: req.name,
+      method: req.method,
+      url,
+      passed: violations.length === 0,
+      violations,
+      durationMs: Date.now() - start,
+      actualStatus: resp.status
+    };
+  } catch (err) {
+    violations.push({
+      type: "status_mismatch",
+      message: `Request failed: ${err instanceof Error ? err.message : String(err)}`
+    });
+    return { requestId: req.id, requestName: req.name, method: req.method, url, passed: false, violations, durationMs: Date.now() - start };
+  } finally {
+    for (const state of states) await setupState(stateHandlerUrl, state, "teardown");
+  }
+}
+async function runLiveProviderVerification(requests, envVars, collectionVars = {}, providerBaseUrl, stateHandlerUrl) {
+  const vars = { ...envVars, ...collectionVars };
+  const start = Date.now();
+  const contractRequests = requests.filter((r) => !r.disabled && hasContract(r.contract));
+  const results = [];
+  for (const req of contractRequests) {
+    results.push(await verifyInteraction(req, vars, providerBaseUrl, stateHandlerUrl));
+  }
+  const passed = results.filter((r) => r.passed).length;
+  return {
+    mode: "provider-live",
+    total: results.length,
+    passed,
+    failed: results.length - passed,
+    results,
+    durationMs: Date.now() - start
+  };
+}
 function checkSchemaCompatibility(consumerSchema, providerSchema, path2 = "") {
   const violations = [];
   if (!consumerSchema || !providerSchema) return violations;
@@ -417,9 +617,7 @@ async function runBidirectional(requests, envVars, collectionVars = {}, specUrl,
   const spec = await loadSpec(specUrl, specPath);
   const vars = { ...envVars, ...collectionVars };
   const start = Date.now();
-  const contractRequests = requests.filter(
-    (r) => !r.disabled && r.contract && (r.contract.statusCode !== void 0 || r.contract.bodySchema || r.contract.headers?.length)
-  );
+  const contractRequests = requests.filter((r) => !r.disabled && hasContract(r.contract));
   const results = await Promise.all(contractRequests.map(async (req) => {
     const url = authBuilder.buildUrl(req.url, req.params, vars);
     const violations = [];
@@ -475,6 +673,143 @@ async function runBidirectional(requests, envVars, collectionVars = {}, specUrl,
     durationMs: Date.now() - start
   };
 }
+function esc(s) {
+  return String(s ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function modeLabel(mode) {
+  if (mode === "bidirectional") return "Bi-directional";
+  if (mode === "provider-live") return "Provider (live)";
+  return mode.charAt(0).toUpperCase() + mode.slice(1);
+}
+const STYLE = `
+:root { color-scheme: dark; }
+* { box-sizing: border-box; }
+body { margin: 0; font: 14px/1.5 -apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Helvetica,Arial,sans-serif;
+  background: #0f1115; color: #e5e7eb; }
+.wrap { max-width: 960px; margin: 0 auto; padding: 32px 24px 64px; }
+h1 { font-size: 20px; margin: 0 0 4px; }
+.sub { color: #8b929e; font-size: 13px; margin: 0 0 24px; }
+.meta { display: flex; flex-wrap: wrap; gap: 8px 20px; color: #9aa1ad; font-size: 12px; margin-bottom: 12px; }
+.meta b { color: #cbd2dc; font-weight: 600; }
+.headline { font-size: 24px; font-weight: 700; }
+.headline.ok { color: #34d399; } .headline.bad { color: #f87171; }
+.bar { display: flex; height: 10px; border-radius: 6px; overflow: hidden; background: #1b1f27; margin: 14px 0 6px; }
+.bar > i { display: block; height: 100%; }
+.bar .ok { background: #34d399; } .bar .bad { background: #f87171; }
+.cards { display: flex; flex-direction: column; gap: 10px; margin-top: 24px; }
+.card { border: 1px solid #232834; border-radius: 10px; overflow: hidden; background: #141821; }
+.card.fail { border-color: #7f1d1d; }
+.row { display: flex; align-items: center; gap: 12px; padding: 12px 16px; }
+.card.fail summary .row { background: rgba(127,29,29,.18); }
+.pill { font-size: 10px; font-weight: 700; padding: 2px 8px; border-radius: 5px; flex-shrink: 0; letter-spacing: .03em; }
+.pill.ok { background: rgba(16,84,55,.55); color: #34d399; }
+.pill.bad { background: rgba(127,29,29,.55); color: #f87171; }
+.method { font: 700 12px ui-monospace,SFMono-Regular,Menlo,monospace; width: 56px; flex-shrink: 0; color: #93c5fd; }
+.name { flex: 1; color: #f3f4f6; font-weight: 500; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.url { color: #6b7280; font: 11px ui-monospace,monospace; max-width: 280px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.dur { color: #6b7280; font-size: 11px; }
+.code { font: 700 12px ui-monospace,monospace; }
+.code.s2 { color: #34d399; } .code.s3 { color: #fbbf24; } .code.s4, .code.s5 { color: #f87171; }
+.viol { padding: 14px 16px; border-top: 1px solid #1f2530; display: flex; flex-direction: column; gap: 10px; }
+.v { border-left: 2px solid #dc2626; background: rgba(127,29,29,.12); border-radius: 0 6px 6px 0; padding: 8px 12px; }
+.v .t { font: 700 10px ui-monospace,monospace; color: #f87171; text-transform: uppercase; letter-spacing: .04em; }
+.v .path { font: 10px ui-monospace,monospace; color: #8b929e; background: #1b1f27; padding: 1px 6px; border-radius: 4px; margin-left: 8px; }
+.v .m { color: #fecaca; font-size: 13px; margin: 4px 0 0; }
+.v .ea { font: 11px ui-monospace,monospace; margin-top: 4px; display: flex; gap: 18px; }
+.v .ea .lab { color: #6b7280; }
+.v .ea .exp { color: #34d399; } .v .ea .act { color: #f87171; }
+.pass-note { color: #34d399; font-size: 13px; padding: 12px 16px; border-top: 1px solid #1f2530; }
+table { border-collapse: collapse; width: 100%; margin-top: 16px; font-size: 13px; }
+th, td { border: 1px solid #232834; padding: 8px 12px; text-align: left; }
+th { background: #141821; color: #cbd2dc; font-weight: 600; }
+td.cell { text-align: center; }
+.b { display: inline-block; min-width: 56px; padding: 2px 8px; border-radius: 5px; font-size: 11px; font-weight: 700; }
+.b.ok { background: rgba(16,84,55,.55); color: #34d399; }
+.b.bad { background: rgba(127,29,29,.55); color: #f87171; }
+.b.na { background: #1b1f27; color: #6b7280; }
+.foot { color: #6b7280; font-size: 11px; margin-top: 40px; text-align: center; }
+summary { cursor: pointer; list-style: none; }
+summary::-webkit-details-marker { display: none; }
+`;
+function page(title, body) {
+  return `<!doctype html>
+<html lang="en"><head><meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${esc(title)}</title>
+<style>${STYLE}</style>
+</head><body><div class="wrap">${body}
+<p class="foot">Generated by API Spector · contract reporting</p>
+</div></body></html>`;
+}
+function statusClass(code) {
+  if (code === void 0) return "";
+  return "s" + String(code)[0];
+}
+function violationHtml(r) {
+  if (r.violations.length === 0) return `<div class="pass-note">All expectations met.</div>`;
+  const items = r.violations.map((v) => {
+    const path2 = v.path ? `<span class="path">${esc(v.path)}</span>` : "";
+    const ea = v.expected || v.actual ? `<div class="ea">${v.expected ? `<span><span class="lab">expected </span><span class="exp">${esc(v.expected)}</span></span>` : ""}${v.actual ? `<span><span class="lab">actual </span><span class="act">${esc(v.actual)}</span></span>` : ""}</div>` : "";
+    return `<div class="v"><div><span class="t">${esc(v.type.replace(/_/g, " "))}</span>${path2}</div><p class="m">${esc(v.message)}</p>${ea}</div>`;
+  }).join("");
+  return `<div class="viol">${items}</div>`;
+}
+function cardHtml(r) {
+  const pill = r.passed ? `<span class="pill ok">PASS</span>` : `<span class="pill bad">FAIL</span>`;
+  const status = r.actualStatus !== void 0 ? `<span class="code ${statusClass(r.actualStatus)}">${r.actualStatus}</span>` : "";
+  const dur = r.durationMs !== void 0 ? `<span class="dur">${r.durationMs}ms</span>` : "";
+  return `<details class="card ${r.passed ? "" : "fail"}" ${r.passed ? "" : "open"}>
+  <summary><div class="row">${pill}<span class="method">${esc(r.method)}</span><span class="name">${esc(r.requestName)}</span><span class="url">${esc(r.url)}</span>${status}${dur}</div></summary>
+  ${violationHtml(r)}
+</details>`;
+}
+function reportToHtml(report, meta = {}) {
+  const okPct = report.total ? Math.round(report.passed / report.total * 100) : 100;
+  const badPct = 100 - okPct;
+  const headlineCls = report.failed === 0 ? "ok" : "bad";
+  const headline = report.failed === 0 ? "✓ All passed" : `✗ ${report.failed} failed`;
+  const metaRows = [
+    `<span><b>Mode</b> ${esc(modeLabel(report.mode))}</span>`,
+    meta.provider ? `<span><b>Provider</b> ${esc(meta.provider)}</span>` : "",
+    meta.consumer ? `<span><b>Consumer</b> ${esc(meta.consumer)}</span>` : "",
+    meta.spec ? `<span><b>Spec</b> ${esc(meta.spec)}</span>` : "",
+    `<span><b>Duration</b> ${report.durationMs}ms</span>`,
+    meta.generatedAt ? `<span><b>Generated</b> ${esc(meta.generatedAt)}</span>` : ""
+  ].filter(Boolean).join("");
+  const failed = report.results.filter((r) => !r.passed);
+  const passed = report.results.filter((r) => r.passed);
+  const cards = [...failed, ...passed].map(cardHtml).join("");
+  const body = `
+<h1>${esc(meta.title ?? "Contract Verification Report")}</h1>
+<p class="sub"><span class="headline ${headlineCls}">${esc(headline)}</span> &nbsp; ${report.passed} / ${report.total} interactions passed</p>
+<div class="meta">${metaRows}</div>
+<div class="bar"><i class="ok" style="width:${okPct}%"></i><i class="bad" style="width:${badPct}%"></i></div>
+<div class="cards">${cards || '<p class="sub">No interactions ran.</p>'}</div>`;
+  return page(meta.title ?? "Contract Verification Report", body);
+}
+function dashboardToHtml(records, generatedAt) {
+  const pacticipants = [...new Set(records.map((r) => r.pacticipant))].sort();
+  const versions = [...new Set(records.map((r) => r.version))].sort();
+  const byKey = new Map(records.map((r) => [`${r.pacticipant}@@${r.version}`, r]));
+  const header = `<tr><th>Pacticipant \\ Version</th>${versions.map((v) => `<th>${esc(v)}</th>`).join("")}</tr>`;
+  const rows = pacticipants.map((p) => {
+    const cells = versions.map((v) => {
+      const rec = byKey.get(`${p}@@${v}`);
+      if (!rec) return `<td class="cell"><span class="b na">—</span></td>`;
+      const cls = rec.passed ? "ok" : "bad";
+      const label = rec.passed ? `${rec.report.total}/${rec.report.total}` : `${rec.report.passed}/${rec.report.total}`;
+      return `<td class="cell" title="${esc(rec.recordedAt)}"><span class="b ${cls}">${esc(label)}</span></td>`;
+    }).join("");
+    return `<tr><td><b>${esc(p)}</b></td>${cells}</tr>`;
+  }).join("");
+  const totalPass = records.filter((r) => r.passed).length;
+  const body = `
+<h1>Contract Dashboard</h1>
+<p class="sub">${records.length} recorded verification${records.length === 1 ? "" : "s"} · ${totalPass} passing</p>
+<div class="meta">${generatedAt ? `<span><b>Generated</b> ${esc(generatedAt)}</span>` : ""}</div>
+${records.length ? `<table>${header}${rows}</table>` : '<p class="sub">No recorded results yet. Run a verification with <code>--record --app-version &lt;ver&gt;</code>.</p>'}`;
+  return page("Contract Dashboard", body);
+}
 const SNAPSHOT_DIR = "contracts";
 function safeName(raw) {
   return raw.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "spec";
@@ -578,11 +913,16 @@ async function deleteSnapshot(workspaceDir, relPath) {
   } catch {
   }
 }
+exports.MATCH_KEY = MATCH_KEY;
 exports.captureSnapshot = captureSnapshot;
+exports.dashboardToHtml = dashboardToHtml;
 exports.deleteSnapshot = deleteSnapshot;
+exports.hasContract = hasContract;
 exports.listSnapshots = listSnapshots;
 exports.loadSnapshot = loadSnapshot;
 exports.relPathOf = relPathOf;
+exports.reportToHtml = reportToHtml;
 exports.runBidirectional = runBidirectional;
 exports.runConsumerContracts = runConsumerContracts;
+exports.runLiveProviderVerification = runLiveProviderVerification;
 exports.runProviderVerification = runProviderVerification;

package/out/main/chunks/{soap-handler-Cpj-JwyA.js → soap-handler-B9x_YCtj.js}

@@ -1,4 +1,5 @@
 "use strict";
+const handle = require("./handle-C0IQL-Vl.js");
 const https = require("https");
 const http = require("http");
 const xmldom = require("@xmldom/xmldom");
@@ -305,16 +306,16 @@ if (opName) {
 `;
 }
 function registerSoapHandlers(ipc) {
-  ipc.handle("wsdl:fetch", async (_event, url, extraHeaders = {}) => {
-    const { validateWsdlFetchUrl } = await Promise.resolve().then(() => require("./ipc-validate-CscN4HfG.js"));
+  handle.handleIpc(ipc, handle.IPC.wsdl.fetch, async (_event, url, extraHeaders = {}) => {
+    const { validateWsdlFetchUrl } = await Promise.resolve().then(() => require("./ipc-validate-k6KI8adf.js"));
     validateWsdlFetchUrl(url);
     const wsdlText = await fetchUrl(url, extraHeaders);
     return parseWsdl(wsdlText);
   });
-  ipc.handle("wsdl:import", async (_event, opts) => {
-    const { validateWsdlImport } = await Promise.resolve().then(() => require("./ipc-validate-CscN4HfG.js"));
+  handle.handleIpc(ipc, handle.IPC.wsdl.import, async (_event, opts) => {
+    const { validateWsdlImport } = await Promise.resolve().then(() => require("./ipc-validate-k6KI8adf.js"));
     validateWsdlImport(opts);
-    const { importWsdl } = await Promise.resolve().then(() => require("./import-C9qdkBCH.js"));
+    const { importWsdl } = await Promise.resolve().then(() => require("./import-C5Ngq8hk.js"));
     const wsdlText = opts.xml ?? (opts.url ? await fetchUrl(opts.url) : "");
     if (!wsdlText) throw new Error("wsdl:import requires either `url` or `xml`");
     return importWsdl(wsdlText, { name: opts.name, existingMockPorts: opts.existingMockPorts });