@testsmith/api-spector 0.6.0 → 0.6.2

package/out/main/chunks/{snapshots-Y33M1SEy.js → broker-client-WEymdqAK.js}

@@ -3,10 +3,11 @@ const promises = require("fs/promises");
 const path = require("path");
 const crypto = require("crypto");
 const undici = require("undici");
-const requestExec = require("./request-exec-5_3279w1.js");
+const requestExec = require("./request-exec-DAFA6Fap.js");
 const Ajv = require("ajv");
 const jsYaml = require("js-yaml");
 require("http");
+const escape = require("./escape-BwPM4Tf6.js");
 const MATCH_KEY = "__match";
 function isMatcher$1(node) {
   return typeof node === "object" && node !== null && !Array.isArray(node) && typeof node[MATCH_KEY] === "string";
@@ -873,7 +874,7 @@ function findOperation(spec, method, reqUrl, requestBaseUrl) {
 function validateRequestAgainstSpec(spec, req, envVars, requestBaseUrl) {
   const violations = [];
   const vars = envVars;
-  const url = req.url.replace(/\{\{([^}]+)\}\}/g, (_, k) => vars[k] ?? `{{${k}}}`);
+  const url = requestExec.interpolate(req.url, vars);
   const match = findOperation(spec, req.method, url, requestBaseUrl);
   if (!match) {
     violations.push({
@@ -932,7 +933,7 @@ async function runProviderVerification(requests, envVars, collectionVars = {}, s
   const activeRequests = requests.filter((r) => !r.disabled);
   const results = activeRequests.map((req) => {
     const violations = validateRequestAgainstSpec(spec, req, vars, requestBaseUrl);
-    const url = req.url.replace(/\{\{([^}]+)\}\}/g, (_, k) => vars[k] ?? `{{${k}}}`);
+    const url = requestExec.interpolate(req.url, vars);
     return {
       requestId: req.id,
       requestName: req.name,
@@ -1121,7 +1122,7 @@ function checkSchemaCompatibility(consumerSchema, providerSchema, path2 = "") {
   return violations;
 }
 function getProviderResponseSchema(spec, req, envVars, statusCode, requestBaseUrl) {
-  const url = req.url.replace(/\{\{([^}]+)\}\}/g, (_, k) => envVars[k] ?? `{{${k}}}`);
+  const url = requestExec.interpolate(req.url, envVars);
   const match = findOperation(spec, req.method, url, requestBaseUrl);
   if (!match) return null;
   const responses = match.operation["responses"] ?? {};
@@ -1280,7 +1281,7 @@ async function listResults(dir) {
   }
   return out;
 }
-async function canIDeploy(dir, pacticipant, version, env) {
+async function canIDeploy$1(dir, pacticipant, version, env) {
   const file = resultPath(dir, pacticipant, version);
   let currentlyDeployed;
   if (env) {
@@ -1323,7 +1324,7 @@ async function loadEnvironment(dir, env) {
     return null;
   }
 }
-async function recordDeployment(dir, env, pacticipant, version, now) {
+async function recordDeployment$1(dir, env, pacticipant, version, now) {
   const state = await loadEnvironment(dir, env) ?? { name: env, deployed: {} };
   const previous = state.deployed[pacticipant];
   state.deployed[pacticipant] = { version, recordedAt: now };
@@ -1756,7 +1757,7 @@ const ajv = new Ajv({ allErrors: true, strict: false });
 const WRITE_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH", "DELETE"]);
 function specContextFor(spec, req, vars, requestBaseUrl) {
   if (!spec) return null;
-  const url = req.url.replace(/\{\{([^}]+)\}\}/g, (_, k) => vars[k] ?? `{{${k}}}`);
+  const url = requestExec.interpolate(req.url, vars);
   const match = findOperation(spec, req.method, url, requestBaseUrl);
   if (!match) return null;
   const op = match.operation;
@@ -1982,9 +1983,7 @@ async function runFuzz(opts) {
     skippedNoBody
   };
 }
-function esc(s) {
-  return String(s ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
+const esc = escape.escapeHtml;
 function modeLabel(mode) {
   if (mode === "bidirectional") return "Bi-directional";
   if (mode === "provider-live") return "Provider (live)";
@@ -2299,12 +2298,117 @@ async function deleteSnapshot(workspaceDir, relPath) {
   } catch {
   }
 }
+const DEFAULT_CLOUD_ENDPOINT = "https://api-spector.dev";
+function resolveCloudEndpoint() {
+  return (process.env["API_SPECTOR_CLOUD_ENDPOINT"] || DEFAULT_CLOUD_ENDPOINT).replace(/\/+$/, "");
+}
+function brokerConfigFromEnv() {
+  return {
+    endpoint: resolveCloudEndpoint(),
+    token: process.env["API_SPECTOR_TOKEN"] || ""
+  };
+}
+async function brokerFetch(cfg, path2, method, body) {
+  if (!cfg.token) throw new Error("No API token. Set API_SPECTOR_TOKEN (create one in the cloud dashboard under Tokens).");
+  const url = cfg.endpoint + path2;
+  let res;
+  try {
+    res = await undici.fetch(url, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        Authorization: `Bearer ${cfg.token}`
+      },
+      body: body === void 0 ? void 0 : JSON.stringify(body)
+    });
+  } catch (err) {
+    throw new Error(`Could not reach ${url}: ${err.message}`);
+  }
+  const text = await res.text();
+  let json;
+  try {
+    json = text ? JSON.parse(text) : {};
+  } catch {
+    json = { raw: text };
+  }
+  return { status: res.status, ok: res.ok, json };
+}
+function fail(r, what) {
+  const detail = r.json?.error || r.json?.message || (r.status === 401 ? "Unauthorized (check API_SPECTOR_TOKEN)" : `HTTP ${r.status}`);
+  throw new Error(`${what}: ${detail}`);
+}
+async function publishPact(cfg, input) {
+  const r = await brokerFetch(cfg, "/api/contracts", "PUT", {
+    consumer: input.consumer,
+    consumerVersion: input.consumerVersion,
+    provider: input.provider,
+    content: input.pact
+  });
+  if (!r.ok) fail(r, "Publish pact failed");
+}
+async function publishSpec(cfg, input) {
+  const r = await brokerFetch(cfg, "/api/provider-contracts", "PUT", {
+    pacticipant: input.pacticipant,
+    version: input.version,
+    spec: input.spec,
+    // Optional provider self-verification (its own tests run against this spec).
+    ...input.results ? { results: input.results } : {}
+  });
+  if (!r.ok) fail(r, "Publish spec failed");
+}
+async function canIDeploy(cfg, input) {
+  const q = new URLSearchParams({ pacticipant: input.pacticipant, version: input.version, environment: input.environment }).toString();
+  const r = await brokerFetch(cfg, "/can-i-deploy?" + q, "GET");
+  if (r.status !== 200 && r.status !== 409) fail(r, "can-i-deploy failed");
+  return { deployable: r.status === 200, reason: r.json?.summary?.reason || "" };
+}
+async function deployPreview(cfg, input) {
+  const q = new URLSearchParams({ pacticipant: input.pacticipant, version: input.version, environment: input.environment }).toString();
+  const r = await brokerFetch(cfg, "/api/deploy-preview?" + q, "GET");
+  if (!r.ok) fail(r, "deploy-preview failed");
+  return r.json;
+}
+async function recordDeployment(cfg, input) {
+  const path2 = `/pacticipants/${encodeURIComponent(input.pacticipant)}/versions/${encodeURIComponent(input.version)}/deployed-versions/environment/${encodeURIComponent(input.environment)}`;
+  const r = await brokerFetch(cfg, path2, "POST", {});
+  if (!r.ok) fail(r, "record-deployment failed");
+}
+async function checkCompatibility(cfg, input) {
+  const q = new URLSearchParams({ consumer: input.consumer, consumerVersion: input.consumerVersion, provider: input.provider, providerVersion: input.providerVersion }).toString();
+  const r = await brokerFetch(cfg, "/api/compatibility?" + q, "GET");
+  if (r.status !== 200 && r.status !== 409) fail(r, "Compatibility check failed");
+  return { compatible: r.json?.compatible === true, checks: r.json?.checks ?? [] };
+}
+async function fetchContracts(cfg, input = {}) {
+  const q = new URLSearchParams();
+  if (input.consumer) q.set("consumer", input.consumer);
+  if (input.provider) q.set("provider", input.provider);
+  const suffix = q.toString() ? "?" + q.toString() : "";
+  const r = await brokerFetch(cfg, "/api/contracts" + suffix, "GET");
+  if (!r.ok) fail(r, "Fetch contracts failed");
+  return r.json?.contracts ?? [];
+}
+async function publishVerification(cfg, input) {
+  const r = await brokerFetch(cfg, "/api/verifications", "POST", {
+    contractId: input.contractId,
+    providerVersion: input.providerVersion,
+    success: input.success,
+    ...input.buildUrl ? { buildUrl: input.buildUrl } : {}
+  });
+  if (!r.ok) fail(r, "Publish verification failed");
+}
+exports.brokerConfigFromEnv = brokerConfigFromEnv;
 exports.canIDeploy = canIDeploy;
+exports.canIDeploy$1 = canIDeploy$1;
 exports.captureSnapshot = captureSnapshot;
+exports.checkCompatibility = checkCompatibility;
 exports.dashboardToHtml = dashboardToHtml;
 exports.deleteSnapshot = deleteSnapshot;
+exports.deployPreview = deployPreview;
 exports.designContractToPact = designContractToPact;
 exports.exportPact = exportPact;
+exports.fetchContracts = fetchContracts;
 exports.fuzzReportToHtml = fuzzReportToHtml;
 exports.hasContract = hasContract;
 exports.importPact = importPact;
@@ -2314,10 +2418,15 @@ exports.listSnapshots = listSnapshots;
 exports.loadDesignContractRequests = loadDesignContractRequests;
 exports.loadSnapshot = loadSnapshot;
 exports.pactToCollection = pactToCollection;
+exports.publishPact = publishPact;
+exports.publishSpec = publishSpec;
+exports.publishVerification = publishVerification;
 exports.recordDeployment = recordDeployment;
+exports.recordDeployment$1 = recordDeployment$1;
 exports.recordResult = recordResult;
 exports.relPathOf = relPathOf;
 exports.reportToHtml = reportToHtml;
+exports.resolveCloudEndpoint = resolveCloudEndpoint;
 exports.runBidirectional = runBidirectional;
 exports.runConsumerContracts = runConsumerContracts;
 exports.runFuzz = runFuzz;

package/out/main/chunks/{cli-common-BKYgsbGB.js → cli-common-vASoDfQH.js}

@@ -1,6 +1,7 @@
 "use strict";
 const promises = require("fs/promises");
 const path = require("path");
+const dataFiles = require("./data-files-Br2h3Dt2.js");
 require("crypto");
 const C = {
   reset: "\x1B[0m",
@@ -57,8 +58,8 @@ async function loadCollections(workspace, dir, opts = {}) {
   const cols = [];
   for (const relPath of workspace.collections) {
     try {
-      const raw = await promises.readFile(path.join(dir, relPath), "utf8");
-      const col = JSON.parse(raw);
+      const fullPath = path.join(dir, relPath);
+      const col = await dataFiles.inlineDataSets(JSON.parse(await promises.readFile(fullPath, "utf8")), path.dirname(fullPath));
       if (!opts.filterName || col.name === opts.filterName) cols.push(col);
     } catch {
       opts.onError?.(relPath);

package/out/main/chunks/data-files-Br2h3Dt2.js

@@ -0,0 +1,85 @@
+"use strict";
+const path = require("path");
+const promises = require("fs/promises");
+function toCSV(ds) {
+  const escape = (s) => s.includes(",") || s.includes('"') || s.includes("\n") ? `"${s.replace(/"/g, '""')}"` : s;
+  return [ds.columns, ...ds.rows].map((row) => row.map(escape).join(",")).join("\n");
+}
+function parseCSV(text) {
+  const lines = text.trim().split(/\r?\n/).filter(Boolean);
+  if (lines.length === 0) return { columns: [], rows: [] };
+  function splitRow(line) {
+    const cells = [];
+    let cur = "";
+    let inQuote = false;
+    for (let i = 0; i < line.length; i++) {
+      const ch = line[i];
+      if (ch === '"') {
+        if (inQuote && line[i + 1] === '"') {
+          cur += '"';
+          i++;
+        } else inQuote = !inQuote;
+      } else if (ch === "," && !inQuote) {
+        cells.push(cur.trim());
+        cur = "";
+      } else {
+        cur += ch;
+      }
+    }
+    cells.push(cur.trim());
+    return cells;
+  }
+  const columns = splitRow(lines[0]);
+  const rows = lines.slice(1).map(splitRow);
+  return { columns, rows };
+}
+const DATA_DIR = "data";
+const hasRows = (ds) => !!ds && ds.columns.length > 0;
+const refFor = (id) => `${DATA_DIR}/${id}.csv`;
+async function externalizeDataSets(col, colDir) {
+  const clone = JSON.parse(JSON.stringify(col));
+  const writes = [];
+  const removals = [];
+  const handle = (h) => {
+    if (hasRows(h.dataSet)) {
+      const ref = refFor(h.id);
+      writes.push({ path: path.join(colDir, ref), content: toCSV(h.dataSet) });
+      h.dataSetRef = ref;
+    } else if (h.dataSet || h.dataSetRef) {
+      removals.push(path.join(colDir, refFor(h.id)));
+      delete h.dataSetRef;
+    }
+    delete h.dataSet;
+  };
+  handle(clone);
+  const walk = (f) => {
+    handle(f);
+    f.folders.forEach(walk);
+  };
+  walk(clone.rootFolder);
+  if (writes.length) await promises.mkdir(path.join(colDir, DATA_DIR), { recursive: true });
+  await Promise.all(writes.map((w) => promises.writeFile(w.path, w.content, "utf8")));
+  await Promise.all(removals.map((p) => promises.unlink(p).catch(() => {
+  })));
+  return clone;
+}
+async function inlineDataSets(col, colDir) {
+  const load = async (h) => {
+    if (!h.dataSetRef) return;
+    try {
+      const text = await promises.readFile(path.join(colDir, h.dataSetRef), "utf8");
+      h.dataSet = parseCSV(text);
+    } catch {
+    }
+    delete h.dataSetRef;
+  };
+  await load(col);
+  const walk = async (f) => {
+    await load(f);
+    await Promise.all(f.folders.map(walk));
+  };
+  await walk(col.rootFolder);
+  return col;
+}
+exports.externalizeDataSets = externalizeDataSets;
+exports.inlineDataSets = inlineDataSets;

package/out/main/chunks/escape-BwPM4Tf6.js

@@ -0,0 +1,9 @@
+"use strict";
+function escapeHtml(s) {
+  return String(s ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function escapeXml(s) {
+  return escapeHtml(s).replace(/'/g, "&apos;");
+}
+exports.escapeHtml = escapeHtml;
+exports.escapeXml = escapeXml;

package/out/main/chunks/{handle-BFaeFA0A.js → handle-CL-nWtYA.js}

@@ -39,7 +39,13 @@ const IPC = {
   secret: {
     checkMasterKey: "secret:checkMasterKey",
     setMasterKey: "secret:setMasterKey",
-    set: "secret:set"
+    set: "secret:set",
+    has: "secret:has",
+    delete: "secret:delete"
+  },
+  // ─── AI (optional; key lives only in the OS keychain) ────────────────────────
+  ai: {
+    generateDocs: "ai:generateDocs"
   },
   // ─── Global variables ──────────────────────────────────────────────────────
   globals: {
@@ -163,6 +169,7 @@ const IPC = {
     branches: "git:branches",
     checkout: "git:checkout",
     deleteBranch: "git:deleteBranch",
+    fetch: "git:fetch",
     pull: "git:pull",
     push: "git:push",
     remotes: "git:remotes",
@@ -172,7 +179,9 @@ const IPC = {
     writeCiFile: "git:writeCiFile",
     resolveOurs: "git:resolveOurs",
     resolveTheirs: "git:resolveTheirs",
-    markResolved: "git:markResolved"
+    markResolved: "git:markResolved",
+    readConflict: "git:readConflict",
+    writeResolved: "git:writeResolved"
   },
   // ─── Recorder ──────────────────────────────────────────────────────────────
   record: {

package/out/main/chunks/{import-D9LH0isB.js → import-DdXhO56X.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const uuid = require("uuid");
-const soapHandler = require("./soap-handler-CWn3o6Py.js");
-require("./handle-BFaeFA0A.js");
+const soapHandler = require("./soap-handler-BAPCALkN.js");
+require("./handle-CL-nWtYA.js");
 require("https");
 require("http");
 require("@xmldom/xmldom");

package/out/main/chunks/{request-collection-BQIo1765.js → request-collection-Hqh3I3rs.js}

@@ -25,17 +25,49 @@ function findFolder(root, id) {
   }
   return null;
 }
+function flattenFolderRequests(folder, requests) {
+  const out = [];
+  for (const child of orderedChildren(folder)) {
+    if (child.type === "request") {
+      const r = requests[child.id];
+      if (r && !r.disabled) out.push(r);
+    } else {
+      const sub = folder.folders.find((f) => f.id === child.id);
+      if (sub && !sub.disabled) out.push(...flattenFolderRequests(sub, requests));
+    }
+  }
+  return out;
+}
 function makeHook(req, collectionVars, hookType, scopeId, scopeAncestors, scopePath, mainRequestId) {
   return { request: req, collectionVars, isHook: true, hookType, scopeId, scopeAncestors, scopePath, mainRequestId };
 }
 function buildFolderPlan(folder, requests, collectionVars, filterTags, scopeId, ancestorIds, parentPath, wrappers, isRoot) {
   const result = [];
   const scopePath = isRoot ? [] : [...parentPath, folder.name];
-  const folderReqs = folder.requestIds.map((id) => requests[id]).filter((r) => r && !r.disabled);
-  const beforeAllHooks = folderReqs.filter((r) => r.hookType === "beforeAll");
-  const beforeHooks = folderReqs.filter((r) => r.hookType === "before");
-  const afterHooks = folderReqs.filter((r) => r.hookType === "after");
-  const afterAllHooks = folderReqs.filter((r) => r.hookType === "afterAll");
+  const folderReqs = orderedChildren(folder).filter((c) => c.type === "request").map((c) => requests[c.id]).filter((r) => r && !r.disabled);
+  const beforeAllHooks = [];
+  const beforeHooks = [];
+  const afterHooks = [];
+  const afterAllHooks = [];
+  const hookFolderIds = /* @__PURE__ */ new Set();
+  const pushHook = (ht, reqs) => {
+    if (ht === "beforeAll") beforeAllHooks.push(...reqs);
+    else if (ht === "before") beforeHooks.push(...reqs);
+    else if (ht === "after") afterHooks.push(...reqs);
+    else if (ht === "afterAll") afterAllHooks.push(...reqs);
+  };
+  for (const child of orderedChildren(folder)) {
+    if (child.type === "request") {
+      const r = requests[child.id];
+      if (r && !r.disabled && r.hookType) pushHook(r.hookType, [r]);
+    } else {
+      const sub = folder.folders.find((f) => f.id === child.id);
+      if (sub && !sub.disabled && sub.hookType) {
+        hookFolderIds.add(sub.id);
+        pushHook(sub.hookType, flattenFolderRequests(sub, requests));
+      }
+    }
+  }
   const regularReqs = folderReqs.filter((r) => !r.hookType);
   const myWrapper = { scopeId, ancestors: ancestorIds, scopePath, before: beforeHooks, after: afterHooks };
   const allWrappers = [...wrappers, myWrapper];
@@ -63,7 +95,8 @@ function buildFolderPlan(folder, requests, collectionVars, filterTags, scopeId,
       }
     } else {
       const sub = subById.get(child.id);
-      if (!sub) continue;
+      if (!sub || sub.disabled) continue;
+      if (hookFolderIds.has(sub.id)) continue;
       const folderTags = sub.tags ?? [];
       const effectiveFilter = filterTags.length === 0 ? filterTags : folderTags.some((t) => filterTags.includes(t)) ? [] : filterTags;
       result.push(...buildFolderPlan(
@@ -168,12 +201,36 @@ function buildRunPlan(collection, folderId, filterTags) {
 function expandRunPlanWithData(items, ds) {
   if (!ds || ds.rows.length === 0) return items;
   return ds.rows.flatMap((row, ri) => {
-    const rowVars = {};
-    ds.columns.forEach((col, ci) => {
-      if (col) rowVars[col] = row[ci] ?? "";
-    });
-    return items.map((item) => ({ ...item, dataRow: { ...item.dataRow, ...rowVars }, iterationLabel: `${ri + 1}/${ds.rows.length}` }));
+    const parsed = parseDataRow(ds.columns, row);
+    return items.map((item) => ({
+      ...item,
+      dataRow: { ...item.dataRow, ...parsed.dataRow },
+      iterationLabel: `${ri + 1}/${ds.rows.length}`,
+      ...parsed.expectStatus ? { expectStatus: parsed.expectStatus } : {},
+      ...parsed.owaspTag ? { owaspTag: parsed.owaspTag } : {}
+    }));
+  });
+}
+const RESERVED_STATUS = /* @__PURE__ */ new Set(["expectstatus", "expect_status", "expectedstatus", "expected_status"]);
+const RESERVED_OWASP = /* @__PURE__ */ new Set(["owasp", "owasp_tag", "category"]);
+function parseDataRow(columns, row) {
+  const dataRow = {};
+  let expectStatus;
+  let owaspTag;
+  columns.forEach((col, ci) => {
+    if (!col) return;
+    const key = col.toLowerCase();
+    const val = row[ci] ?? "";
+    if (RESERVED_STATUS.has(key)) {
+      const nums = val.split(/[\s,|]+/).map((x) => parseInt(x, 10)).filter((n) => Number.isFinite(n));
+      if (nums.length) expectStatus = nums;
+    } else if (RESERVED_OWASP.has(key)) {
+      if (val.trim()) owaspTag = val.trim().toUpperCase();
+    } else {
+      dataRow[col] = val;
+    }
   });
+  return { dataRow, expectStatus, owaspTag };
 }
 function nearestFolderDataSet(item, collection) {
   const chain = [item.scopeId, ...item.scopeAncestors ?? []].filter(Boolean);
@@ -192,11 +249,14 @@ function expandFolderDataSets(items, collection) {
       continue;
     }
     ds.rows.forEach((row, ri) => {
-      const rowVars = {};
-      ds.columns.forEach((col, ci) => {
-        if (col) rowVars[col] = row[ci] ?? "";
+      const parsed = parseDataRow(ds.columns, row);
+      out.push({
+        ...item,
+        dataRow: { ...item.dataRow, ...parsed.dataRow },
+        iterationLabel: `${ri + 1}/${ds.rows.length}`,
+        ...parsed.expectStatus ? { expectStatus: parsed.expectStatus } : {},
+        ...parsed.owaspTag ? { owaspTag: parsed.owaspTag } : {}
       });
-      out.push({ ...item, dataRow: { ...item.dataRow, ...rowVars }, iterationLabel: `${ri + 1}/${ds.rows.length}` });
     });
   }
   return out;

package/out/main/chunks/{request-exec-5_3279w1.js → request-exec-DAFA6Fap.js}

@@ -24,7 +24,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 const undici = require("undici");
 const promises = require("fs/promises");
 const nodeTls = require("tls");
-const handle = require("./handle-BFaeFA0A.js");
+const handle = require("./handle-CL-nWtYA.js");
 const fs = require("node:fs");
 const os = require("node:os");
 const path$1 = require("node:path");
@@ -582,6 +582,15 @@ function registerSecretHandlers(ipc) {
     secretStore[ref] = ss.encryptString(value).toString("base64");
     await persistSecretStore();
   });
+  handle.handleIpc(ipc, handle.IPC.secret.has, async (_e, ref) => {
+    return { has: await getSecret(ref) != null };
+  });
+  handle.handleIpc(ipc, handle.IPC.secret.delete, async (_e, ref) => {
+    if (ref in secretStore) {
+      delete secretStore[ref];
+      await persistSecretStore();
+    }
+  });
 }
 function decryptSecret(encrypted, salt, iv, password) {
   const saltBuf = Buffer.from(salt, "base64");
@@ -2159,6 +2168,15 @@ async function executeRunnerRequest(opts) {
       await persistGlobals();
       onScriptOutput?.("post", r.consoleOutput, r.error);
     }
+    if (opts.expectStatus && opts.expectStatus.length > 0) {
+      const tag = opts.owaspTag ? `[${opts.owaspTag}] ` : "";
+      const passed = opts.expectStatus.includes(exchange.status);
+      testResults = [...testResults, {
+        name: `${tag}expected status ${opts.expectStatus.join(" or ")}`,
+        passed,
+        error: passed ? void 0 : `got ${exchange.status} ${exchange.statusText}`
+      }];
+    }
     const status = deriveRunStatus(postScriptError, testResults, exchange.status);
     if (exchange.status >= 400 && testResults.length === 0) {
       testResults = [...testResults, syntheticHttpFailure(exchange.status, exchange.statusText)];

package/out/main/chunks/{soap-handler-CWn3o6Py.js → soap-handler-BAPCALkN.js}

@@ -1,5 +1,5 @@
 "use strict";
-const handle = require("./handle-BFaeFA0A.js");
+const handle = require("./handle-CL-nWtYA.js");
 const https = require("https");
 const http = require("http");
 const xmldom = require("@xmldom/xmldom");
@@ -315,7 +315,7 @@ function registerSoapHandlers(ipc) {
   handle.handleIpc(ipc, handle.IPC.wsdl.import, async (_event, opts) => {
     const { validateWsdlImport } = await Promise.resolve().then(() => require("./ipc-validate-sqUFqRmE.js"));
     validateWsdlImport(opts);
-    const { importWsdl } = await Promise.resolve().then(() => require("./import-D9LH0isB.js"));
+    const { importWsdl } = await Promise.resolve().then(() => require("./import-DdXhO56X.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 });

package/out/main/compare.js

@@ -4,8 +4,9 @@ const promises = require("fs/promises");
 const jsYaml = require("js-yaml");
 const undici = require("undici");
 const coverage = require("./chunks/coverage-C54mZEh_.js");
-const cliCommon = require("./chunks/cli-common-BKYgsbGB.js");
+const cliCommon = require("./chunks/cli-common-vASoDfQH.js");
 require("path");
+require("./chunks/data-files-Br2h3Dt2.js");
 require("crypto");
 const HTTP_METHODS = ["get", "put", "post", "delete", "options", "head", "patch", "trace"];
 function resolveRef(spec, ref) {