@testsmith/api-spector 0.4.8 → 0.5.0

package/bin/cli.js

@@ -22,6 +22,9 @@ const COMMANDS = {
   record:   { entrypoint: 'record.js',  runner: 'node' },
   agents:   { entrypoint: 'agents.js',  runner: 'node' },
   contract: { entrypoint: 'contract.js',runner: 'node' },
+  coverage: { entrypoint: 'coverage.js',runner: 'node' },
+  'generate-tests': { entrypoint: 'generate-tests.js', runner: 'node' },
+  compare:  { entrypoint: 'compare.js', runner: 'node' },
   wsdl:     { entrypoint: 'wsdl.js',    runner: 'node' },
 }
 
@@ -35,6 +38,9 @@ function printHelp() {
   console.log('    api-spector mock     --workspace <path>   Start mock servers from CLI')
   console.log('    api-spector record   --upstream <url>     Record API traffic as mock stubs')
   console.log('    api-spector contract list|run             Manage & run pinned contract snapshots')
+  console.log('    api-spector coverage --spec <file>        Measure OpenAPI test coverage')
+  console.log('    api-spector generate-tests --spec <file>  Generate tests from an OpenAPI spec')
+  console.log('    api-spector compare <old> <new>           Diff specs; find breaking changes + impact')
   console.log('    api-spector wsdl     describe|import-*    Inspect a WSDL or import as collection/mock')
   console.log('')
   console.log('  Options:')

package/out/main/chunks/coverage-C54mZEh_.js

@@ -0,0 +1,146 @@
+"use strict";
+const HTTP_METHODS = ["get", "put", "post", "delete", "options", "head", "patch", "trace"];
+function normalizePath(url) {
+  let u = (url || "").trim();
+  u = u.split("#")[0].split("?")[0];
+  u = u.replace(/\{\{[^}]*\}\}/g, "");
+  u = u.replace(/^[a-z0-9+.-]+:\/\/[^/]*/i, "");
+  u = u.replace(/\/{2,}/g, "/");
+  if (!u.startsWith("/")) u = "/" + u;
+  u = u.replace(/\/+$/, "");
+  return u === "" ? "/" : u;
+}
+function segments(path) {
+  return path.split("/").filter(Boolean);
+}
+function isParam(seg) {
+  return seg.startsWith("{") && seg.endsWith("}");
+}
+function pathMatches(requestUrl, template) {
+  const reqSegs = segments(normalizePath(requestUrl));
+  const tplSegs = segments(template);
+  if (reqSegs.length < tplSegs.length) return false;
+  const tail = reqSegs.slice(reqSegs.length - tplSegs.length);
+  return tplSegs.every((seg, i) => isParam(seg) ? tail[i] !== void 0 && tail[i] !== "" : tail[i] === seg);
+}
+function resolveRef(spec, ref) {
+  const parts = ref.replace(/^#\//, "").split("/");
+  return parts.reduce((o, k) => o?.[decodeURIComponent(k.replace(/~1/g, "/").replace(/~0/g, "~"))], spec);
+}
+function deref(spec, node, depth = 0, seen = /* @__PURE__ */ new Set()) {
+  if (!node || typeof node !== "object" || depth > 8) return node;
+  if (Array.isArray(node)) return node.map((n) => deref(spec, n, depth + 1, seen));
+  if ("$ref" in node) {
+    const target = resolveRef(spec, node.$ref);
+    if (!target || seen.has(target)) return {};
+    return deref(spec, target, depth + 1, /* @__PURE__ */ new Set([...seen, target]));
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(node)) out[k] = deref(spec, v, depth + 1, seen);
+  return out;
+}
+function flattenSchemaPaths(schema, prefix = "", depth = 0) {
+  if (!schema || typeof schema !== "object" || depth > 8) return [];
+  const type = Array.isArray(schema.type) ? schema.type[0] : schema.type;
+  const out = [];
+  if (type === "object" || schema.properties) {
+    for (const [name, sub] of Object.entries(schema.properties ?? {})) {
+      const path = prefix ? `${prefix}.${name}` : name;
+      out.push(path);
+      out.push(...flattenSchemaPaths(sub, path, depth + 1));
+    }
+  } else if (type === "array" && schema.items) {
+    out.push(...flattenSchemaPaths(schema.items, `${prefix}[]`, depth + 1));
+  }
+  return out;
+}
+function flattenValuePaths(value, prefix = "", depth = 0) {
+  if (value == null || typeof value !== "object" || depth > 8) return [];
+  const out = [];
+  if (Array.isArray(value)) {
+    for (const el of value) out.push(...flattenValuePaths(el, `${prefix}[]`, depth + 1));
+  } else {
+    for (const [k, v] of Object.entries(value)) {
+      const path = prefix ? `${prefix}.${k}` : k;
+      out.push(path);
+      out.push(...flattenValuePaths(v, path, depth + 1));
+    }
+  }
+  return [...new Set(out)];
+}
+function successResponseSchema(spec, responses) {
+  const code = Object.keys(responses ?? {}).filter((c) => /^2\d\d$/.test(c)).sort()[0];
+  if (!code) return void 0;
+  const schema = responses[code]?.content?.["application/json"]?.schema ?? responses[code]?.content?.["application/json;charset=utf-8"]?.schema;
+  return schema ? deref(spec, schema) : void 0;
+}
+function enumerateOperations(spec) {
+  const doc = spec ?? {};
+  const ops = [];
+  for (const [path, item] of Object.entries(doc.paths ?? {})) {
+    if (!item || typeof item !== "object") continue;
+    for (const [method, op] of Object.entries(item)) {
+      if (!HTTP_METHODS.includes(method.toLowerCase())) continue;
+      if (!op || typeof op !== "object") continue;
+      const declaredStatuses = Object.keys(op.responses ?? {}).filter((c) => /^\d{3}$/.test(c));
+      ops.push({ method: method.toUpperCase(), path, operationId: op.operationId, declaredStatuses, responses: op.responses });
+    }
+  }
+  return ops;
+}
+function round(n) {
+  return Math.round(n * 10) / 10;
+}
+function computeCoverage(spec, requests, observations = []) {
+  const doc = spec ?? {};
+  const operations = enumerateOperations(spec).map((op) => {
+    const mapped = requests.filter((r) => r.method.toUpperCase() === op.method && pathMatches(r.url, op.path));
+    const obs = observations.filter((o) => o.method.toUpperCase() === op.method && pathMatches(o.url, op.path));
+    const asserted = mapped.map((r) => r.expectedStatus).filter((s) => typeof s === "number");
+    const seen = obs.map((o) => o.status);
+    const covered = /* @__PURE__ */ new Set([...asserted, ...seen]);
+    const coveredStatuses2 = op.declaredStatuses.filter((code) => covered.has(Number(code)));
+    const hasNegativeTest = [...covered].some((s) => s >= 400);
+    const declaredProperties2 = flattenSchemaPaths(successResponseSchema(doc, op.responses ?? {}));
+    const observedPaths = new Set(obs.flatMap((o) => o.responsePaths ?? []));
+    const coveredProperties2 = declaredProperties2.filter((p) => observedPaths.has(p));
+    return {
+      method: op.method,
+      path: op.path,
+      operationId: op.operationId,
+      tested: mapped.length > 0 || obs.length > 0,
+      requests: mapped.map((r) => r.name),
+      declaredStatuses: op.declaredStatuses,
+      coveredStatuses: coveredStatuses2,
+      hasNegativeTest,
+      declaredProperties: declaredProperties2,
+      coveredProperties: coveredProperties2
+    };
+  });
+  const tested = operations.filter((o) => o.tested).length;
+  const declaredStatuses = operations.reduce((n, o) => n + o.declaredStatuses.length, 0);
+  const coveredStatuses = operations.reduce((n, o) => n + o.coveredStatuses.length, 0);
+  const declaredProperties = operations.reduce((n, o) => n + o.declaredProperties.length, 0);
+  const coveredProperties = operations.reduce((n, o) => n + o.coveredProperties.length, 0);
+  const withoutNegativeTest = operations.filter((o) => o.tested && !o.hasNegativeTest).length;
+  return {
+    spec: { title: doc.info?.title, version: doc.info?.version },
+    totals: {
+      operations: operations.length,
+      tested,
+      untested: operations.length - tested,
+      operationPct: operations.length ? round(tested / operations.length * 100) : 0,
+      declaredStatuses,
+      coveredStatuses,
+      statusPct: declaredStatuses ? round(coveredStatuses / declaredStatuses * 100) : 0,
+      withoutNegativeTest,
+      declaredProperties,
+      coveredProperties,
+      propertyPct: declaredProperties ? round(coveredProperties / declaredProperties * 100) : 0
+    },
+    operations
+  };
+}
+exports.computeCoverage = computeCoverage;
+exports.flattenValuePaths = flattenValuePaths;
+exports.pathMatches = pathMatches;

package/out/main/chunks/{handle-rimXXdJH.js → handle-b6bp3fb0.js}

@@ -75,6 +75,10 @@ const IPC = {
     startFlow: "oauth2:startFlow",
     refreshToken: "oauth2:refreshToken"
   },
+  // ─── HashiCorp Vault (interactive OIDC login) ──────────────────────────────
+  vault: {
+    oidcLogin: "vault:oidcLogin"
+  },
   // ─── Mock servers ──────────────────────────────────────────────────────────
   mock: {
     start: "mock:start",
@@ -100,10 +104,28 @@ const IPC = {
     fetch: "wsdl:fetch",
     import: "wsdl:import"
   },
+  // ─── gRPC ──────────────────────────────────────────────────────────────────
+  grpc: {
+    /** Load a .proto (source or path) and enumerate its services/methods. */
+    loadProto: "grpc:loadProto",
+    /** Invoke a method (unary or server-streaming). Streams back messages. */
+    invoke: "grpc:invoke",
+    /** Cancel an in-flight call. */
+    cancel: "grpc:cancel",
+    /** Event: a received message frame. */
+    message: "grpc:message",
+    /** Event: call status change (running / completed / error, with code). */
+    status: "grpc:status"
+  },
   // ─── Docs generation ───────────────────────────────────────────────────────
   docs: {
     generate: "docs:generate"
   },
+  // ─── OpenAPI coverage ────────────────────────────────────────────────────────
+  coverage: {
+    /** Read + parse an OpenAPI spec (file path, URL, or raw text). */
+    loadSpec: "coverage:loadSpec"
+  },
   // ─── Contract testing ──────────────────────────────────────────────────────
   contract: {
     run: "contract:run",

package/out/main/chunks/{import-DcenB5Q_.js → import-BeY7gjWL.js}

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