@testsmith/api-spector 0.2.3 → 0.2.5

package/out/main/runner.js

@@ -4,7 +4,7 @@ const promises = require("fs/promises");
 const path = require("path");
 const undici = require("undici");
 const authBuilder = require("./chunks/auth-builder-B7-LgcGr.js");
-const requestCollection = require("./chunks/request-collection-DMVlm0PA.js");
+const requestCollection = require("./chunks/request-collection-CElFJzre.js");
 require("crypto");
 require("dayjs");
 require("vm");
@@ -12,6 +12,7 @@ require("tv4");
 require("jsonpath-plus");
 require("@xmldom/xmldom");
 require("ajv");
+require("./chunks/ipc-validate-CscN4HfG.js");
 function buildJsonReport(results, summary, meta = {}) {
   return JSON.stringify({
     timestamp: meta.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
@@ -267,7 +268,7 @@ function buildHtmlReport(results, summary, meta = {}) {
     const html = document.documentElement
     const isLight = html.classList.toggle('light')
     document.getElementById('themeBtn').textContent = isLight ? '🌙' : '☀️'
-    try { localStorage.setItem('theme', isLight ? 'light' : 'dark') } catch {}
+    try { localStorage.setItem('theme', isLight ? 'light' : 'dark') } catch {} /* private mode / quota — non-fatal */
   }
   // Restore saved preference or respect OS preference
   (function() {
@@ -277,7 +278,7 @@ function buildHtmlReport(results, summary, meta = {}) {
         document.documentElement.classList.add('light')
         document.getElementById('themeBtn').textContent = '🌙'
       }
-    } catch {}
+    } catch {} /* private mode / quota — non-fatal */
   })()
 <\/script>
 </body>
@@ -402,7 +403,7 @@ async function loadEnvironments(workspace, dir) {
   }
   return envs;
 }
-async function executeRequest(req, collectionVars, envVars, globals, localVars, verbose, tls) {
+async function executeRequest(req, collectionVars, envVars, globals, localVars, verbose, tls, piiMaskPatterns = []) {
   if (!req.headers) req.headers = [];
   if (!req.params) req.params = [];
   if (!req.body) req.body = { mode: "none" };
@@ -425,7 +426,8 @@ async function executeRequest(req, collectionVars, envVars, globals, localVars,
       envVars: { ...envVars },
       collectionVars: { ...collectionVars },
       globals: { ...globals },
-      localVars: { ...localVars }
+      localVars: { ...localVars },
+      piiMaskPatterns
     });
     preScriptError = r.error;
     localVars = r.updatedLocalVars;
@@ -473,6 +475,12 @@ async function executeRequest(req, collectionVars, envVars, globals, localVars,
       if (gql.operationName?.trim()) gqlBody.operationName = gql.operationName.trim();
       body = JSON.stringify(gqlBody);
       if (!headers.has("content-type")) headers.set("Content-Type", "application/json");
+    } else if (req.body.mode === "soap" && req.body.soap) {
+      body = authBuilder.interpolate(req.body.soap.envelope, vars);
+      if (!headers.has("content-type")) headers.set("Content-Type", "text/xml; charset=utf-8");
+      if (req.body.soap.soapAction && !headers.has("soapaction")) {
+        headers.set("SOAPAction", req.body.soap.soapAction);
+      }
     }
     const dispatcher = await requestCollection.buildDispatcher(void 0, tls);
     const fetchResp = await undici.fetch(resolvedUrl, {
@@ -495,7 +503,8 @@ async function executeRequest(req, collectionVars, envVars, globals, localVars,
       bodySize: Buffer.byteLength(responseBody, "utf8"),
       durationMs
     };
-    let testResults = [];
+    const protocolFaultTests = requestCollection.buildProtocolFaultTests(req.body.mode, responseBody);
+    let testResults = [...protocolFaultTests];
     let consoleOutput = [];
     let postScriptError;
     if (req.postRequestScript?.trim()) {
@@ -504,9 +513,10 @@ async function executeRequest(req, collectionVars, envVars, globals, localVars,
         collectionVars: updatedCollectionVars,
         globals: updatedGlobals,
         localVars,
-        response
+        response,
+        piiMaskPatterns
       });
-      testResults = r.testResults;
+      testResults = [...protocolFaultTests, ...r.testResults];
       consoleOutput = r.consoleOutput;
       postScriptError = r.error;
       updatedEnvVars = r.updatedEnvVars;
@@ -520,7 +530,7 @@ async function executeRequest(req, collectionVars, envVars, globals, localVars,
     const allPassed = testResults.every((t) => t.passed);
     const httpFailed = fetchResp.status >= 400;
     const hasTests = testResults.length > 0;
-    const status = postScriptError ? "error" : hasTests ? allPassed ? "passed" : "failed" : httpFailed ? "failed" : "skipped";
+    const status = postScriptError ? "error" : hasTests ? allPassed ? "passed" : "failed" : httpFailed ? "failed" : "passed";
     if (httpFailed && testResults.length === 0) {
       testResults = [
         ...testResults,
@@ -574,7 +584,8 @@ function printResult(r, verbose) {
   const http = r.httpStatus ? color(` ${r.httpStatus}`, r.httpStatus < 400 ? C.green : C.red) : "";
   const dur = r.durationMs !== void 0 ? color(` ${r.durationMs}ms`, C.gray) : "";
   const method = color(r.method.padEnd(7), C.cyan);
-  console.log(`  ${icon}  ${method}  ${r.name}${http}${dur}`);
+  const hookTag = r.isHook && r.hookType ? color(` [${r.hookType.toUpperCase()}]`, C.yellow) : "";
+  console.log(`  ${icon}  ${method}  ${r.name}${hookTag}${http}${dur}`);
   if (verbose) console.log(color(`       ${r.resolvedUrl}`, C.gray));
   if (r.testResults?.length) {
     for (const t of r.testResults) {
@@ -621,8 +632,9 @@ async function main() {
   if (envName && !env) {
     console.warn(color(`Warning: environment "${envName}" not found. Running without environment.`, C.yellow));
   }
+  const version = `v${"0.2.5"}`;
   console.log("");
-  console.log(color("  API Test Runner", C.bold, C.white));
+  console.log(color("  API Test Runner" + (version ? ` ${version}` : ""), C.bold, C.white));
   console.log(color(`  Workspace:   ${wsPath}`, C.gray));
   console.log(color(`  Environment: ${env?.name ?? "(none)"}`, C.gray));
   if (filterTags.length) console.log(color(`  Tags:        ${filterTags.join(", ")}`, C.gray));
@@ -634,16 +646,21 @@ async function main() {
     for (const secret of secretValuesToMask) out = out.split(secret).join("***");
     return out;
   }
+  const DEFAULT_PII_PATTERNS = ["authorization", "password", "token", "secret", "api-key", "x-api-key"];
+  const piiPatterns = workspace.settings?.piiMaskPatterns ?? DEFAULT_PII_PATTERNS;
   function maskResult(r) {
     return {
       ...r,
       sentRequest: r.sentRequest ? {
-        headers: Object.fromEntries(Object.entries(r.sentRequest.headers).map(([k, v]) => [k, redact(v)])),
-        body: r.sentRequest.body != null ? redact(r.sentRequest.body) : void 0
+        headers: Object.fromEntries(
+          Object.entries(requestCollection.maskHeaders(r.sentRequest.headers, piiPatterns)).map(([k, v]) => [k, redact(v)])
+        ),
+        body: r.sentRequest.body != null ? redact(requestCollection.maskPii(r.sentRequest.body, piiPatterns)) : void 0
       } : void 0,
       receivedResponse: r.receivedResponse ? {
         ...r.receivedResponse,
-        body: redact(r.receivedResponse.body)
+        headers: requestCollection.maskHeaders(r.receivedResponse.headers, piiPatterns),
+        body: redact(requestCollection.maskPii(r.receivedResponse.body, piiPatterns))
       } : void 0
     };
   }
@@ -654,7 +671,7 @@ async function main() {
   let firstColName;
   for (const col of collections) {
     if (colName && col.name.toLowerCase() !== colName.toLowerCase()) continue;
-    const items = requestCollection.collectTagged(col.rootFolder, col.requests, col.collectionVariables ?? {}, filterTags);
+    const items = requestCollection.buildRunPlan(col, null, filterTags);
     if (items.length === 0) continue;
     if (!firstColName) firstColName = col.name;
     let runEnvVars = await authBuilder.buildEnvVars(env);
@@ -677,21 +694,74 @@ async function main() {
     }
     let bailed = false;
     let lastPrintedScope = null;
+    const failedScopes = /* @__PURE__ */ new Set();
+    const skipRequests = /* @__PURE__ */ new Set();
     for (const item of items) {
-      const { result, updatedEnvVars, updatedCollectionVars, updatedGlobals, updatedLocalVars } = await executeRequest(
-        item.request,
-        { ...item.collectionVars, ...runCollectionVars },
-        runEnvVars,
-        runGlobals,
-        { ...runLocalVars },
-        verbose,
-        effectiveTls
-      );
-      runEnvVars = updatedEnvVars;
-      runCollectionVars = updatedCollectionVars;
-      runGlobals = updatedGlobals;
-      runLocalVars = updatedLocalVars;
-      result.scopePath = item.scopePath;
+      const { isHook, hookType, scopeId, scopeAncestors, mainRequestId } = item;
+      let skipReason;
+      if (isHook) {
+        if (hookType === "beforeAll") {
+          if ((scopeAncestors ?? []).some((id) => failedScopes.has(id))) {
+            skipReason = "Skipped — outer scope hook failed";
+          }
+        } else if (hookType === "before") {
+          const allScopes = [...scopeAncestors ?? [], scopeId].filter(Boolean);
+          if (allScopes.some((id) => failedScopes.has(id))) {
+            skipReason = "Skipped — scope hook failed";
+          } else if (mainRequestId && skipRequests.has(mainRequestId)) {
+            skipReason = "Skipped — before hook failed";
+          }
+        }
+      } else {
+        const allScopes = [...scopeAncestors ?? [], scopeId].filter(Boolean);
+        if (allScopes.some((id) => failedScopes.has(id))) {
+          skipReason = "Skipped — beforeAll hook failed";
+        } else if (skipRequests.has(item.request.id)) {
+          skipReason = "Skipped — before hook failed";
+        }
+      }
+      let result;
+      if (skipReason) {
+        result = {
+          requestId: item.request.id,
+          name: item.request.name,
+          method: item.request.method,
+          resolvedUrl: item.request.url,
+          status: "failed",
+          error: skipReason,
+          isHook,
+          hookType,
+          scopeId,
+          scopePath: item.scopePath
+        };
+      } else {
+        const out = await executeRequest(
+          item.request,
+          { ...item.collectionVars, ...runCollectionVars },
+          runEnvVars,
+          runGlobals,
+          { ...runLocalVars },
+          verbose,
+          effectiveTls,
+          piiPatterns
+        );
+        result = out.result;
+        runEnvVars = out.updatedEnvVars;
+        runCollectionVars = out.updatedCollectionVars;
+        runGlobals = out.updatedGlobals;
+        runLocalVars = out.updatedLocalVars;
+        result.isHook = isHook;
+        result.hookType = hookType;
+        result.scopeId = scopeId;
+        result.scopePath = item.scopePath;
+        if (result.status === "failed" || result.status === "error") {
+          if (isHook && hookType === "beforeAll" && scopeId) {
+            failedScopes.add(scopeId);
+          } else if (isHook && hookType === "before" && mainRequestId) {
+            skipRequests.add(mainRequestId);
+          }
+        }
+      }
       const scopeKey = (item.scopePath ?? []).join(" / ");
       if (scopeKey !== lastPrintedScope) {
         if (scopeKey) console.log(color(`    ${scopeKey}`, C.gray, C.bold));

package/out/main/wsdl.js

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+"use strict";
+const promises = require("fs/promises");
+const path = require("path");
+const https = require("https");
+const http = require("http");
+const soapHandler = require("./chunks/soap-handler-Cpj-JwyA.js");
+const _import = require("./chunks/import-C9qdkBCH.js");
+require("@xmldom/xmldom");
+require("uuid");
+function parseArgs(argv) {
+  const args = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const next = argv[i + 1];
+      if (!next || next.startsWith("--")) {
+        args[key] = true;
+      } else {
+        args[key] = next;
+        i++;
+      }
+    }
+  }
+  return args;
+}
+function fetchUrl(url) {
+  return new Promise((resolveP, rejectP) => {
+    const lib = url.startsWith("https") ? https : http;
+    const req = lib.get(url, (res) => {
+      const chunks = [];
+      res.on("data", (c) => chunks.push(c));
+      res.on("end", () => resolveP(Buffer.concat(chunks).toString("utf8")));
+      res.on("error", rejectP);
+    });
+    req.on("error", rejectP);
+    req.setTimeout(15e3, () => {
+      req.destroy();
+      rejectP(new Error("WSDL fetch timed out"));
+    });
+  });
+}
+async function resolveWorkspacePath(wsPath) {
+  const s = await promises.stat(wsPath);
+  if (!s.isDirectory()) return wsPath;
+  const entries = await promises.readdir(wsPath);
+  const spector = entries.find((e) => e.endsWith(".spector"));
+  if (!spector) throw new Error(`No .spector workspace file found in directory: ${wsPath}`);
+  return path.join(wsPath, spector);
+}
+async function loadWorkspace(wsPath) {
+  const resolved = await resolveWorkspacePath(wsPath);
+  const raw = await promises.readFile(resolved, "utf8");
+  return { workspace: JSON.parse(raw), dir: path.dirname(path.resolve(resolved)), file: resolved };
+}
+async function ensureDir(dir) {
+  await promises.mkdir(dir, { recursive: true });
+}
+async function cmdDescribe(args) {
+  const url = typeof args["url"] === "string" ? args["url"] : void 0;
+  if (!url) {
+    console.error("  [error] --url <wsdlUrl> is required");
+    process.exit(2);
+  }
+  const wsdlText = await fetchUrl(url);
+  const parsed = soapHandler.parseWsdl(wsdlText);
+  console.log("");
+  console.log(`  Target namespace: ${parsed.targetNamespace || "(none)"}`);
+  if (parsed.endpoints.length) {
+    console.log("  Endpoints:");
+    for (const e of parsed.endpoints) {
+      console.log(`    [${e.soapVersion}] ${e.binding}  →  ${e.address}`);
+    }
+  }
+  console.log("");
+  if (parsed.operations.length === 0) {
+    console.log("  No operations found.");
+    return;
+  }
+  console.log("  Operation                             Ver   SOAPAction");
+  console.log("  ───────────────────────────────────── ───── ──────────────────────────────");
+  for (const op of parsed.operations) {
+    const name = op.name.slice(0, 37).padEnd(37);
+    const ver = op.soapVersion.padEnd(5);
+    const sa = (op.soapAction ?? "—").slice(0, 30);
+    console.log(`  ${name} ${ver} ${sa}`);
+  }
+  console.log("");
+}
+async function loadExistingMockPorts(workspace, dir) {
+  const ports = [];
+  for (const relPath of workspace.mocks ?? []) {
+    try {
+      const raw = await promises.readFile(path.join(dir, relPath), "utf8");
+      const m = JSON.parse(raw);
+      if (typeof m.port === "number") ports.push(m.port);
+    } catch {
+    }
+  }
+  return ports;
+}
+async function cmdImportCollection(args) {
+  const url = typeof args["url"] === "string" ? args["url"] : void 0;
+  const wsArg = typeof args["workspace"] === "string" ? args["workspace"] : void 0;
+  if (!url) {
+    console.error("  [error] --url <wsdlUrl> is required");
+    process.exit(2);
+  }
+  if (!wsArg) {
+    console.error("  [error] --workspace <path> is required");
+    process.exit(2);
+  }
+  const wsdlText = await fetchUrl(url);
+  const { workspace, dir, file } = await loadWorkspace(wsArg);
+  const name = typeof args["name"] === "string" ? args["name"] : void 0;
+  const { collection } = _import.importWsdl(wsdlText, { name });
+  const relPath = _import.defaultCollectionRelPath(workspace, collection);
+  const fullPath = path.resolve(dir, relPath);
+  await ensureDir(path.dirname(fullPath));
+  await promises.writeFile(fullPath, JSON.stringify(collection, null, 2), "utf8");
+  workspace.collections.push(relPath);
+  await promises.writeFile(file, JSON.stringify(workspace, null, 2), "utf8");
+  console.log(`  ✓ Wrote ${relPath} (${Object.keys(collection.requests).length} requests)`);
+}
+async function cmdImportMock(args) {
+  const url = typeof args["url"] === "string" ? args["url"] : void 0;
+  const wsArg = typeof args["workspace"] === "string" ? args["workspace"] : void 0;
+  if (!url) {
+    console.error("  [error] --url <wsdlUrl> is required");
+    process.exit(2);
+  }
+  if (!wsArg) {
+    console.error("  [error] --workspace <path> is required");
+    process.exit(2);
+  }
+  const wsdlText = await fetchUrl(url);
+  const { workspace, dir, file } = await loadWorkspace(wsArg);
+  const existingPorts = await loadExistingMockPorts(workspace, dir);
+  const name = typeof args["name"] === "string" ? args["name"] : void 0;
+  const { mock } = _import.importWsdl(wsdlText, { name, existingMockPorts: existingPorts });
+  const relPath = _import.defaultMockRelPath(mock);
+  const fullPath = path.resolve(dir, relPath);
+  await ensureDir(path.dirname(fullPath));
+  await promises.writeFile(fullPath, JSON.stringify(mock, null, 2), "utf8");
+  if (!workspace.mocks) workspace.mocks = [];
+  workspace.mocks.push(relPath);
+  await promises.writeFile(file, JSON.stringify(workspace, null, 2), "utf8");
+  console.log(`  ✓ Wrote ${relPath} on port ${mock.port} (${mock.routes.length} dispatch route${mock.routes.length === 1 ? "" : "s"})`);
+  if (args["start"] === true) {
+    console.log("  [note] --start is not supported in CLI mode; launch the mock from the app.");
+  }
+}
+async function main() {
+  const [, , sub, ...rest] = process.argv;
+  const args = parseArgs(rest);
+  if (sub === "describe") return cmdDescribe(args);
+  if (sub === "import-collection") return cmdImportCollection(args);
+  if (sub === "import-mock") return cmdImportMock(args);
+  if (args["help"] || !sub) {
+    console.log(`
+  api-spector wsdl describe          --url <wsdlUrl>
+  api-spector wsdl import-collection --workspace <path> --url <wsdlUrl> [--name <label>]
+  api-spector wsdl import-mock       --workspace <path> --url <wsdlUrl> [--name <label>]
+`);
+    return;
+  }
+  console.error(`  [error] Unknown subcommand "${sub}"`);
+  process.exit(2);
+}
+main().catch((e) => {
+  console.error(`  [error] ${e instanceof Error ? e.message : String(e)}`);
+  process.exit(1);
+});

package/out/preload/index.js

@@ -11,6 +11,10 @@ const api = {
   saveCollection: (relPath, col) => electron.ipcRenderer.invoke("file:saveCollection", relPath, col),
   loadEnvironment: (relPath) => electron.ipcRenderer.invoke("file:loadEnvironment", relPath),
   saveEnvironment: (relPath, env) => electron.ipcRenderer.invoke("file:saveEnvironment", relPath, env),
+  /** Idempotent unlink of a workspace-relative file. Used by collection /
+   *  environment / mock delete flows so the file is removed from disk, not
+   *  just from the workspace manifest. */
+  deleteWorkspaceFile: (relPath) => electron.ipcRenderer.invoke("file:deleteWorkspaceFile", relPath),
   // ─── HTTP execution ────────────────────────────────────────────────────────
   sendRequest: (payload) => electron.ipcRenderer.invoke("request:send", payload),
   // ─── Secrets (encrypted, master-key-based) ───────────────────────────────
@@ -78,6 +82,9 @@ const api = {
   },
   // ─── SOAP / WSDL ──────────────────────────────────────────────────────────
   wsdlFetch: (url, extraHeaders) => electron.ipcRenderer.invoke("wsdl:fetch", url, extraHeaders ?? {}),
+  /** Build a Collection + MockServer from a WSDL. Renderer registers the
+   *  returned objects via the usual loadCollection/loadMock + save flows. */
+  wsdlImport: (opts) => electron.ipcRenderer.invoke("wsdl:import", opts),
   // ─── Docs generation ──────────────────────────────────────────────────────
   generateDocs: (payload) => electron.ipcRenderer.invoke("docs:generate", payload),
   // ─── Contract testing ─────────────────────────────────────────────────────
@@ -102,6 +109,7 @@ const api = {
   gitLog: (limit) => electron.ipcRenderer.invoke("git:log", limit),
   gitBranches: () => electron.ipcRenderer.invoke("git:branches"),
   gitCheckout: (branch, create) => electron.ipcRenderer.invoke("git:checkout", branch, create),
+  gitDeleteBranch: (name, force = false) => electron.ipcRenderer.invoke("git:deleteBranch", name, force),
   gitPull: () => electron.ipcRenderer.invoke("git:pull"),
   gitPush: (setUpstream) => electron.ipcRenderer.invoke("git:push", setUpstream),
   gitRemotes: () => electron.ipcRenderer.invoke("git:remotes"),