@nextcommerce/campaigns-os 1.50.0 → 1.52.0

package/src/qa-node.mjs

@@ -33,11 +33,15 @@ function cmd(verb, rest = "") {
 }
 import { isSameAnalyticsCapturePage, runAnalyticsCorrectnessChecks, runAnalyticsParityChecks, runBrowserChecks, runBrowserTestOrders, testEmail, upsellActionCoverageWithoutOrders, validatedOrderCreationLimit } from "./qa-browser.mjs";
 import { assessReceiptPurchase } from "./qa-analytics-correctness.mjs";
+import { trackingQaAssertion, trackingRunScopeRows } from "./qa-tracking-params.mjs";
+import { contentParamNotRequestedRows, contentParamQaAssertion } from "./qa-content-params.mjs";
+import { policyLinkNotRequestedRows, policyLinkQaAssertion } from "./qa-policy-links.mjs";
 import { createVerdict, isFindingAssertion, QA_ASSERTION_FAMILY_VOCABULARY, SESSION_ENDING_DISPOSITIONS, SEVERITY, STATUS, validateVerdict } from "./qa-verdict.mjs";
 import { normalizeSdkMetaName, lookupSdkIgnoredMetaTag } from "./sdk-meta-tags.mjs";
 import { annotateQaAssertionCauses, formatCauseReportLines, formatCauseTag } from "./finding-cause.mjs";
 import { promoteQaVerdict, writeQaSidecar } from "./qa-sidecar.mjs";
 import { publishQaVerdict, qaPortalUrl, qaVerdictPublishBlock, QA_VERDICT_PUBLISHERS, skippedQaVerdictPublish } from "./qa-verdict-publish.mjs";
+import { redactPersisted } from "./qa-url-privacy.mjs";
 import {
   isLocalServePacket,
   LOCAL_PROOF_BUILD_ENVIRONMENT,
@@ -203,7 +207,7 @@ Options:
                                   block before browser launch. The default cap is 6; overflow names the exact raise.
                                   "tiers" is spec-driven: one strict-selection order per selector tier the
                                   CampaignSpec declares on the checkout page (order-bump rows marked
-                                  is_upsell are add-ons, never tiers), plus one coupon order per declared
+                                  is_order_bump or is_upsell are add-ons, never tiers), plus one coupon order per declared
                                   offer code (checkout exit_intent / promo_code_input); "tiers:common" and
                                   "tiers:full" cross every tier with those path shapes. --select-package
                                   <ref[:qty],...> narrows a tiers run to the listed declared tiers;
@@ -2328,6 +2332,7 @@ async function runResolvedQa(args, resolved, { runSessionActive = false, liveCam
       proxyBase: resolved.proxyBase,
     });
   assertions.push(...liveCampaignRefAssertions({ pages: [...livePages.values()], spec: liveSpec, liveCampaign: liveRead }));
+  const qcResults = [];
   if (args.browser === true) {
     const browserAssertions = await runBrowserChecks(resolved.topologies, args, {
       brandContract: resolved.brandContract,
@@ -2338,6 +2343,8 @@ async function runResolvedQa(args, resolved, { runSessionActive = false, liveCam
         : residueSeverityForThemeGate(gate.status),
       supportedPaymentMethods: supportedPaymentMethodsFromSpec(resolved.spec),
       bindingExpected,
+      spec: resolved.spec,
+      qcResults,
     });
     // A page-binding row from the browser is the key the SDK actually sent;
     // it takes the place of that page's static read.
@@ -2346,9 +2353,20 @@ async function runResolvedQa(args, resolved, { runSessionActive = false, liveCam
       if (at >= 0) assertions[at] = observed;
       else assertions.push(observed);
     }
-  }
-
-  const testOrders = await runAnalyticsOrderSequence({ args, resolved, runId, assertions });
+  } else {
+    // The browser checks were not requested: each declared content parameter
+    // (param, page) is listed as excluded, never left silent.
+    const rows = contentParamNotRequestedRows(resolved.spec, resolved.topologies);
+    qcResults.push(...rows);
+    assertions.push(...rows.map(contentParamQaAssertion));
+    // Each configured policy link field likewise lists its presence and
+    // availability rows as excluded; no probe is sent.
+    const policyRows = policyLinkNotRequestedRows(resolved.spec, resolved.topologies);
+    qcResults.push(...policyRows);
+    assertions.push(...policyRows.map(policyLinkQaAssertion));
+  }
+
+  const testOrders = await runAnalyticsOrderSequence({ args, resolved, runId, assertions, qcResults });
   const remainingAssertionBudget = Math.max(0, QA_VERDICT_ASSERTION_LIMIT - assertions.length);
   let commercialResult;
   try {
@@ -2375,6 +2393,7 @@ async function runResolvedQa(args, resolved, { runSessionActive = false, liveCam
     testOrders,
     commercial: commercialResult.commercial,
     runSessionActive,
+    qcResults,
   });
 }
 
@@ -2389,7 +2408,7 @@ function reportCommercialRunnerError(args, error, write = (message) => process.s
 // one canonical typed-card run captures its settled terminal and only then do
 // we finalize the stable purchase-fires assertion. There is no receipt replay
 // and no second order.
-async function runAnalyticsOrderSequence({ args, resolved, runId, assertions }, overrides = {}) {
+async function runAnalyticsOrderSequence({ args, resolved, runId, assertions, qcResults = null }, overrides = {}) {
   const operations = {
     runInventory: runAnalyticsCorrectnessChecks,
     runParity: runAnalyticsParityChecks,
@@ -2427,6 +2446,7 @@ async function runAnalyticsOrderSequence({ args, resolved, runId, assertions },
     assertions,
     captureAnalytics: analyticsLeg === "run",
   });
+  if (Array.isArray(qcResults) && Array.isArray(result.qc_results)) qcResults.push(...result.qc_results);
   if (analyticsLeg === "run") {
     assertions.push(operations.assessReceipt(result.receiptAnalytics, { waivers: resolved.qaWaivers }));
   }
@@ -2554,7 +2574,7 @@ function applyLocalServeAnalyticsReview(assertions, localServe) {
   }
 }
 
-async function finalizeQaRun({ args, resolved, runId, startedAt, assertions, testOrders, commercial = null, runSessionActive = false, browser = null }) {
+async function finalizeQaRun({ args, resolved, runId, startedAt, assertions, testOrders, commercial = null, runSessionActive = false, browser = null, qcResults = [] }) {
   const entryUrls = deriveEntryUrls(resolved.topologies);
   const pageUrls = derivePageUrls(resolved.topologies);
   const testedUrls = deriveTestedUrlsFromAssertions(assertions, pageUrls);
@@ -2575,7 +2595,10 @@ async function finalizeQaRun({ args, resolved, runId, startedAt, assertions, tes
     currentRunId: runId,
     isFinding: isFindingAssertion,
   });
-  const verdict = createVerdict({
+  // The verdict as it is persisted: the local file, the committed sidecar and
+  // the published copy all read this one projection (no URL query in any
+  // string or key), whichever runner, return path or field produced a value.
+  const verdict = redactPersisted(createVerdict({
     runId,
     mapId: resolved.mapId,
     localSpecId: resolved.localSpecId,
@@ -2596,7 +2619,7 @@ async function finalizeQaRun({ args, resolved, runId, startedAt, assertions, tes
     commercial,
     causeSummary,
     browser,
-  });
+  }));
 
   const validationErrors = validateVerdict(verdict);
   if (validationErrors.length) throw new Error(`QA verdict failed local validation:\n- ${validationErrors.join("\n- ")}`);
@@ -2678,6 +2701,9 @@ async function finalizeQaRun({ args, resolved, runId, startedAt, assertions, tes
     browser: verdict.browser || null,
     commercial: verdict.commercial || null,
     next_actions: buildQaCloseoutActions({ packetPath: resolved.packetPath, localPath, runSessionActive, disposition: verdict.disposition }),
+    // The QC rows the QA stage records; readers re-derive them from the qc.*
+    // assertions of the verdict written above.
+    qc_results: qcResults,
     verdict,
   };
 }
@@ -2944,6 +2970,23 @@ async function runPageChecks(page, args, {
     ["decline", page.expected_decline_url],
   ]) {
     if (!expectedUrl) continue;
+    const deadProxy = findDeadUpsellProxy(html, kind, page);
+    if (deadProxy) {
+      assertions.push(assertion({
+        id: `route-link:${page.page_id}:${kind}`,
+        family: "funnel-flow",
+        page,
+        status: STATUS.FAIL,
+        severity: SEVERITY.BLOCKER,
+        expected: expectedUrl,
+        actual: deadProxy,
+        evidence: {
+          expected: expectedUrl,
+          note: `The page's ${kind} button only forwards its click to the SDK's data-next-upsell-action inside the offer, and the offer has none, so the shopper's click does nothing. Render the in-offer action (it may be hidden).`,
+        },
+      }));
+      continue;
+    }
     const staticFound = htmlIncludesRouteReference(html, expectedUrl);
     const sdkAction = staticFound ? null : findSdkRouteAction(html, kind, page);
     const found = staticFound || Boolean(sdkAction);
@@ -3050,21 +3093,32 @@ async function maybeRunTestOrders(
     const coverage = upsellActionCoverageWithoutOrders(resolved.topologies);
     if (coverage) assertions.push(coverage);
   }
+  // Tracking parameters ride browser test orders only: a run without one
+  // says so with a run-scope excluded row per tracking check.
+  const notRequestedRows = () => {
+    const rows = trackingRunScopeRows({ runId });
+    assertions.push(...rows.map(trackingQaAssertion));
+    return rows;
+  };
   if ((!mode || mode === "off") && (!legacyMode || legacyMode === "off")) {
-    return { orders: [], receiptAnalytics: emptyReceiptAnalytics() };
+    return { orders: [], receiptAnalytics: emptyReceiptAnalytics(), qc_results: notRequestedRows() };
   }
   if (mode && mode !== "off") {
     // Test Orders use global test cards: they bypass the payment gateway, create
     // no transactions, and need no merchant setup or approval. `--test-order
     // <mode>` is sufficient intent — no permission flags or packet policy gate.
-    const result = await operations.runBrowser(resolved.topologies, args, runId, { captureAnalytics });
+    const result = await operations.runBrowser(resolved.topologies, args, runId, { captureAnalytics, spec: resolved.spec });
     assertions.push(...result.assertions);
-    return { orders: result.orders, receiptAnalytics: result.receiptAnalytics || emptyReceiptAnalytics() };
+    return {
+      orders: result.orders,
+      receiptAnalytics: result.receiptAnalytics || emptyReceiptAnalytics(),
+      qc_results: Array.isArray(result.qc_results) ? result.qc_results : [],
+    };
   }
 
   const orders = await operations.runLegacy({ args: { ...args, "test-order": legacyMode }, resolved, runId, assertions });
   // Direct API diagnostics never qualify as canonical receipt proof.
-  return { orders, receiptAnalytics: emptyReceiptAnalytics() };
+  return { orders, receiptAnalytics: emptyReceiptAnalytics(), qc_results: notRequestedRows() };
 }
 
 async function maybeRunLegacyApiTestOrders({ args, resolved, runId, assertions }) {
@@ -3929,6 +3983,43 @@ function htmlIncludesRouteReference(html, expectedUrl) {
   return html.includes(expectedUrl) || html.includes(path);
 }
 
+// A data-upsell-proxy button forwards its click to the SDK action inside the
+// offer. With no such action, the route's URL can still sit in the page's meta
+// tags, so the reference match would pass a control that does nothing.
+function findDeadUpsellProxy(html, kind, page) {
+  if (page.page_type !== "upsell" || kind === "next") return null;
+  const action = kind === "accept" ? "add" : "skip";
+  if (!new RegExp(`\\bdata-upsell-proxy\\s*=\\s*["']${action}["']`, "i").test(html)) return null;
+  const target = new RegExp(`\\bdata-next-upsell-action\\s*=\\s*["']${action}["']`, "i");
+  if (upsellOfferElements(html).some((offer) => target.test(offer))) return null;
+  return `data-upsell-proxy="${action}" with no data-next-upsell-action="${action}" inside the offer to forward to`;
+}
+
+// The markup of each [data-next-upsell="offer"] element, read to its closing
+// tag by depth of that tag name: the proxy forwards only to actions inside it.
+function upsellOfferElements(html) {
+  const offers = [];
+  const attrRe = /\bdata-next-upsell\s*=\s*["']offer["']/gi;
+  let attr;
+  while ((attr = attrRe.exec(html))) {
+    const start = html.lastIndexOf("<", attr.index);
+    const name = /^<([a-z][\w-]*)/i.exec(html.slice(start))?.[1];
+    if (!name) continue;
+    const tagRe = new RegExp(`<(/?)${name}\\b[^>]*>`, "gi");
+    tagRe.lastIndex = start;
+    let depth = 0;
+    let end = html.length;
+    let match;
+    while ((match = tagRe.exec(html))) {
+      if (match[1]) depth -= 1;
+      else if (!match[0].endsWith("/>")) depth += 1;
+      if (depth === 0) { end = match.index; break; }
+    }
+    offers.push(html.slice(start, end));
+  }
+  return offers;
+}
+
 function findSdkRouteAction(html, kind, page) {
   if (page.page_type !== "upsell") return null;
   if (kind === "accept" && /\bdata-next-upsell-action\s*=\s*["']add["']/i.test(html)) {
@@ -4009,6 +4100,7 @@ export const __qaNodeTestHooks = Object.freeze({
   analyticsCorrectnessDisabledAssertion,
   runAnalyticsOrderSequence,
   maybeRunTestOrders,
+  finalizeQaRun,
   campaignOutputDir,
   polishBlockedAssertions,
   polishGateAssertion,

package/src/qa-order-bump.mjs

@@ -287,6 +287,25 @@ export function orderBumpEvidenceScript() {
     };
 
 
+    // Text painted with a zero-alpha colour (`color: transparent`, or any
+    // colour function whose alpha is 0) occupies its box and draws nothing.
+    // Computed colours come back as a function: comma form, where a fourth
+    // argument is the alpha (`rgba(0, 0, 0, 0)`, `hsla(…, 0)`), or space form
+    // with the alpha after a slash (`color(srgb 0 0 0 / 0)`).
+    const transparentInk = (style) => {
+      const ink = String(style.webkitTextFillColor || style.color || "").trim().toLowerCase();
+      if (ink === "transparent") return true;
+      const fn = ink.match(/^[a-z-]+\((.*)\)$/);
+      if (!fn) return false;
+      const args = fn[1];
+      const alpha = args.includes("/")
+        ? args.slice(args.lastIndexOf("/") + 1).trim()
+        : (args.split(",").length === 4 ? args.split(",")[3].trim() : null);
+      if (alpha === null) return false;
+      const value = alpha.endsWith("%") ? Number.parseFloat(alpha) / 100 : Number.parseFloat(alpha);
+      return Number.isFinite(value) && value === 0;
+    };
+
     // The positive signals, in the order that settles which vocabulary the
     // marker speaks. Returns null when a rendered marker carries none.
     const checkedSignal = (marker) => {
@@ -296,7 +315,9 @@ export function orderBumpEvidenceScript() {
       // rendering — never the box's.
       const tick = pseudoTick(marker);
       if (tick) return { signal: "pseudo", checked: tick.shown };
-      if (/check|\u2713/.test(marker.textContent || "")) return { signal: "glyph", checked: true };
+      // A glyph tick that is always in the DOM can be shown and hidden by its
+      // colour alone, so the text is a tick only when it is painted.
+      if (/check|\u2713/.test(marker.textContent || "")) return { signal: "glyph", checked: !transparentInk(style) };
       if (style.backgroundColor === acceptedFillColor) return { signal: "fill", checked: true };
       if (hiddenByAMatchingRule(marker)) return { signal: "display_toggled", checked: true };
       return null;