@adcp/sdk 13.0.4 → 13.1.1

package/dist/lib/testing/storyboard/validations.mjs

@@ -9,12 +9,14 @@ import { gte as semverGte, valid as validSemver } from "semver";
 import { isJsonContentType } from "../test-controller.mjs";
 import { globToRegExp } from "../../utils/glob.mjs";
 import {
+  parsePath,
   resolvePath,
   resolvePathAll,
   resolvePortableIdentifierPathAll,
   toJsonPointer,
   validatePortableIdentifierPath
 } from "./path.mjs";
+import { canonicalTargetUri } from "../../signing/canonicalize.mjs";
 import { detectShapeDriftHints } from "./shape-drift-hints.mjs";
 import { PROBE_TASK_ALLOWLIST } from "./test-kit.mjs";
 import { validateCanonicalFormatSatisfaction } from "./canonical-format-satisfaction.mjs";
@@ -493,13 +495,67 @@ function validateFieldAbsent(validation, taskResult) {
     actual: value
   };
 }
-function valuesMatch(actual, expected) {
+function comparisonKeyFromPath(path) {
+  const segments = parsePath(path);
+  for (let i = segments.length - 1; i >= 0; i -= 1) {
+    const segment = segments[i];
+    if (typeof segment === "string") return segment;
+  }
+  return void 0;
+}
+function isAgentUrlComparisonKey(key) {
+  const normalized = key?.toLowerCase();
+  return normalized === "agent_url" || normalized?.endsWith("_agent_url") === true;
+}
+function agentUrlValuesMatch(actual, expected) {
+  try {
+    return canonicalTargetUri(actual) === canonicalTargetUri(expected);
+  } catch {
+    return false;
+  }
+}
+function normalizeAgentUrlsForDistinctCount(value, comparisonKey) {
+  if (isAgentUrlComparisonKey(comparisonKey)) {
+    if (typeof value !== "string") return { value, valid: false };
+    try {
+      return { value: canonicalTargetUri(value), valid: true };
+    } catch {
+      return { value, valid: false };
+    }
+  }
+  if (Array.isArray(value)) {
+    const normalized = [];
+    for (const item of value) {
+      const result = normalizeAgentUrlsForDistinctCount(item, comparisonKey);
+      if (!result.valid) return { value, valid: false };
+      normalized.push(result.value);
+    }
+    return { value: normalized, valid: true };
+  }
+  if (typeof value === "object" && value !== null) {
+    const normalized = {};
+    for (const [key, item] of Object.entries(value)) {
+      const result = normalizeAgentUrlsForDistinctCount(item, key);
+      if (!result.valid) return { value, valid: false };
+      normalized[key] = result.value;
+    }
+    return { value: normalized, valid: true };
+  }
+  return { value, valid: true };
+}
+function valuesMatch(actual, expected, comparisonKey) {
+  if (isAgentUrlComparisonKey(comparisonKey)) {
+    return typeof actual === "string" && typeof expected === "string" && agentUrlValuesMatch(actual, expected);
+  }
   if (typeof actual === "object" && actual !== null) {
-    return deepEqualJsonValue(actual, expected);
+    return deepEqualJsonValue(actual, expected, comparisonKey);
   }
   return actual === expected;
 }
-function deepEqualJsonValue(a, b) {
+function deepEqualJsonValue(a, b, comparisonKey) {
+  if (isAgentUrlComparisonKey(comparisonKey)) {
+    return typeof a === "string" && typeof b === "string" && agentUrlValuesMatch(a, b);
+  }
   if (a === b) return true;
   if (typeof a !== typeof b) return false;
   if (a === null || b === null) return a === b;
@@ -508,7 +564,7 @@ function deepEqualJsonValue(a, b) {
     if (!Array.isArray(a) || !Array.isArray(b)) return false;
     if (a.length !== b.length) return false;
     for (let i = 0; i < a.length; i++) {
-      if (!deepEqualJsonValue(a[i], b[i])) return false;
+      if (!deepEqualJsonValue(a[i], b[i], comparisonKey)) return false;
     }
     return true;
   }
@@ -517,21 +573,21 @@ function deepEqualJsonValue(a, b) {
   if (keysA.length !== keysB.length) return false;
   for (const k of keysA) {
     if (!Object.prototype.hasOwnProperty.call(b, k)) return false;
-    if (!deepEqualJsonValue(a[k], b[k])) return false;
+    if (!deepEqualJsonValue(a[k], b[k], k)) return false;
   }
   return true;
 }
 function isRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function containsValueMatches(actual, expected) {
+function containsValueMatches(actual, expected, comparisonKey) {
   if (Array.isArray(expected)) {
     if (!Array.isArray(actual)) return false;
     if (expected.length === 0) return actual.length === 0;
     const used = /* @__PURE__ */ new Set();
     return expected.every((expectedItem) => {
       const matchIndex = actual.findIndex(
-        (actualItem, index) => !used.has(index) && containsValueMatches(actualItem, expectedItem)
+        (actualItem, index) => !used.has(index) && containsValueMatches(actualItem, expectedItem, comparisonKey)
       );
       if (matchIndex === -1) return false;
       used.add(matchIndex);
@@ -541,10 +597,10 @@ function containsValueMatches(actual, expected) {
   if (isRecord(expected)) {
     if (!isRecord(actual)) return false;
     return Object.entries(expected).every(
-      ([key, expectedValue]) => Object.prototype.hasOwnProperty.call(actual, key) && containsValueMatches(actual[key], expectedValue)
+      ([key, expectedValue]) => Object.prototype.hasOwnProperty.call(actual, key) && containsValueMatches(actual[key], expectedValue, key)
     );
   }
-  return valuesMatch(actual, expected);
+  return valuesMatch(actual, expected, comparisonKey);
 }
 function pathUsesWildcardSyntax(path) {
   return /\[(?:\*|)\]/.test(path);
@@ -581,7 +637,8 @@ function validateFieldValue(validation, taskResult) {
   const actual = resolvePath(taskResult.data, validation.path);
   const pointer = toJsonPointer(validation.path);
   if (validation.allowed_values?.length) {
-    const passed2 = validation.allowed_values.some((v) => valuesMatch(actual, v));
+    const comparisonKey = comparisonKeyFromPath(validation.path);
+    const passed2 = validation.allowed_values.some((v) => valuesMatch(actual, v, comparisonKey));
     if (passed2) {
       return {
         check: checkName,
@@ -602,7 +659,7 @@ function validateFieldValue(validation, taskResult) {
       actual: actual ?? null
     };
   }
-  const passed = valuesMatch(actual, validation.value);
+  const passed = valuesMatch(actual, validation.value, comparisonKeyFromPath(validation.path));
   if (passed) {
     return {
       check: checkName,
@@ -652,7 +709,8 @@ function validateFieldValueOrAbsent(validation, taskResult) {
     };
   }
   if (validation.allowed_values?.length) {
-    const passed2 = validation.allowed_values.some((v) => valuesMatch(actual, v));
+    const comparisonKey = comparisonKeyFromPath(validation.path);
+    const passed2 = validation.allowed_values.some((v) => valuesMatch(actual, v, comparisonKey));
     if (passed2) {
       return {
         check: checkName,
@@ -673,7 +731,7 @@ function validateFieldValueOrAbsent(validation, taskResult) {
       actual
     };
   }
-  const passed = valuesMatch(actual, validation.value);
+  const passed = valuesMatch(actual, validation.value, comparisonKeyFromPath(validation.path));
   if (passed) {
     return {
       check: checkName,
@@ -815,7 +873,8 @@ function validateFieldContains(validation, taskResult) {
   const resolved = resolvePathAll(taskResult.data, validation.path);
   const pointer = toJsonPointer(validation.path);
   const candidates = validation.allowed_values?.length ? validation.allowed_values : [validation.value];
-  const matched = resolved.some((actual) => candidates.some((c) => containsValueMatches(actual, c)));
+  const comparisonKey = comparisonKeyFromPath(validation.path);
+  const matched = resolved.some((actual) => candidates.some((c) => containsValueMatches(actual, c, comparisonKey)));
   if (matched) {
     return {
       check: checkName,
@@ -1884,7 +1943,7 @@ function validateFieldEqualsContext(validation, ctx) {
   const actual = resolvePath(resolveTarget(ctx).data, validation.path);
   const expected = comparandResult.value;
   const pointer = toJsonPointer(validation.path);
-  const passed = valuesMatch(actual, expected);
+  const passed = valuesMatch(actual, expected, comparisonKeyFromPath(validation.path));
   if (passed) {
     return {
       check: "field_equals_context",
@@ -1952,7 +2011,8 @@ function validateFieldInContextArray(validation, ctx) {
       actual: allowed
     };
   }
-  if (allowed.some((candidate) => valuesMatch(actual, candidate))) {
+  const comparisonKey = comparisonKeyFromPath(validation.path);
+  if (allowed.some((candidate) => valuesMatch(actual, candidate, comparisonKey))) {
     return {
       check: "field_in_context_array",
       passed: true,
@@ -2020,7 +2080,8 @@ function validateAllFieldsInContextArray(validation, ctx) {
       actual: allowed
     };
   }
-  const passed = actual.every((value) => allowed.some((candidate) => deepEqualJsonValue(value, candidate)));
+  const comparisonKey = comparisonKeyFromPath(validation.path);
+  const passed = actual.every((value) => allowed.some((candidate) => deepEqualJsonValue(value, candidate, comparisonKey)));
   if (passed) {
     return {
       check,
@@ -2432,7 +2493,8 @@ function validateCrossResponseFieldEqual(validation, ctx) {
   }
   const values = cr.resolved.map((tr) => resolvePath(tr.data, path));
   const first = values[0];
-  const allEqual = values.every((v) => deepEqual(v, first));
+  const comparisonKey = comparisonKeyFromPath(path);
+  const allEqual = values.every((v) => valuesMatch(v, first, comparisonKey));
   if (allEqual) {
     return {
       check: validation.check,
@@ -2562,13 +2624,27 @@ function validateCrossResponseCountDistinct(validation, ctx) {
       schema_url: null
     };
   }
-  const distinct = /* @__PURE__ */ new Set();
+  const comparisonKey = comparisonKeyFromPath(path);
+  const exactValues = /* @__PURE__ */ new Set();
   for (const tr of cr.resolved) {
     const v = resolvePath(tr.data, path);
-    if (v === void 0 || v === null) continue;
-    distinct.add(JSON.stringify(v));
+    if (v === void 0 || v === null && !isAgentUrlComparisonKey(comparisonKey)) continue;
+    const normalized = normalizeAgentUrlsForDistinctCount(v, comparisonKey);
+    if (!normalized.valid) {
+      return {
+        check: validation.check,
+        passed: false,
+        description: validation.description,
+        json_pointer: toJsonPointer(path),
+        expected: "valid URI strings in all agent URL identity fields",
+        actual: v,
+        schema_id: null,
+        schema_url: null
+      };
+    }
+    exactValues.add(JSON.stringify(normalized.value));
   }
-  const distinctCount = distinct.size;
+  const distinctCount = exactValues.size;
   const allowed = validation.allowed_values;
   if (allowed.includes(distinctCount)) {
     return {