supercov 4.24.8 → 4.25.0

package/runtime/javascript/snapshots.mjs

@@ -0,0 +1,108 @@
+/**
+ * Two events JSON.stringify would write alike: the same keys in the same
+ * order, with the same values. Comparing is several times cheaper than
+ * writing both, and a test's pages hand over thousands of events each time
+ * one of them leaves.
+ */
+function sameEvent(left, right) {
+    if (left === right)
+        return true;
+    if (left === null || right === null || typeof left !== "object" || typeof right !== "object")
+        return false;
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    if (leftKeys.length !== rightKeys.length)
+        return false;
+    for (let index = 0; index < leftKeys.length; index += 1) {
+        const key = leftKeys[index];
+        if (key !== rightKeys[index])
+            return false;
+        const leftValue = left[key];
+        const rightValue = right[key];
+        if (leftValue === rightValue)
+            continue;
+        if (leftValue === null || rightValue === null || typeof leftValue !== "object" || typeof rightValue !== "object" ||
+            JSON.stringify(leftValue) !== JSON.stringify(rightValue))
+            return false;
+    }
+    return true;
+}
+/**
+ * One snapshot holding everything in `snapshots`, each observation once: a
+ * document that left gave its evidence, and the next one on its origin
+ * restored the same evidence and added to it.
+ */
+export function mergeSnapshots(snapshots) {
+    const hits = new Set();
+    const events = new Map();
+    const decisions = new Map();
+    const logicals = new Map();
+    const vectorsOf = (map, key, initial) => {
+        let entry = map.get(key);
+        if (!entry) {
+            entry = { ...initial, seen: new Map() };
+            map.set(key, entry);
+        }
+        return entry;
+    };
+    let previousEvents;
+    for (const snapshot of snapshots) {
+        for (const id of snapshot?.hits ?? [])
+            hits.add(id);
+        // A document restores the evidence the one before it on its origin
+        // left, in order, before adding its own: the events it repeats from
+        // the snapshot before are in `events` already, and are compared
+        // instead of serialized.
+        const list = snapshot?.events ?? [];
+        let start = 0;
+        if (previousEvents !== undefined) {
+            const shared = Math.min(previousEvents.length, list.length);
+            while (start < shared && sameEvent(previousEvents[start], list[start]))
+                start += 1;
+        }
+        for (let index = start; index < list.length; index += 1)
+            events.set(JSON.stringify(list[index]), list[index]);
+        previousEvents = list;
+        for (const decision of snapshot?.decisions ?? []) {
+            const entry = vectorsOf(decisions, decision.id, { id: decision.id });
+            for (const vector of decision.vectors ?? [])
+                entry.seen.set(JSON.stringify(vector), vector);
+        }
+        for (const logical of snapshot?.logicals ?? []) {
+            const entry = vectorsOf(logicals, logical.id, { id: logical.id });
+            for (const vector of logical.vectors ?? [])
+                entry.seen.set(JSON.stringify(vector), vector);
+        }
+    }
+    return {
+        decisions: [...decisions.values()].map(({ seen, id }) => ({ id, vectors: [...seen.values()] })),
+        hits: [...hits],
+        events: [...events.values()],
+        logicals: [...logicals.values()].map(({ seen, id }) => ({ id, vectors: [...seen.values()] })),
+    };
+}
+/**
+ * A snapshot as JSON.parse would give it from the text a page's runtime
+ * wrote compactly (runtime.mjs, compactSnapshotText): each event in its own
+ * key order, its strings from the shared table. Anything else is returned
+ * as it is.
+ */
+export function expandSnapshot(value) {
+    if (!value || typeof value !== "object" || value.supercovCompactSnapshot !== 1)
+        return value;
+    const { order, rest, strings, shapes, rows, hits } = value;
+    const events = [];
+    for (let position = 0; position < rows.length;) {
+        const fields = shapes[rows[position++]];
+        const event = {};
+        for (const field of fields) {
+            const raw = rows[position++];
+            event[field.slice(1)] = field[0] === "s" ? strings[raw] : raw;
+        }
+        events.push(event);
+    }
+    const snapshot = {};
+    for (const key of order)
+        snapshot[key] = key === "events" ? events : key === "hits" ? hits.map((index) => strings[index]) : rest[key];
+    return snapshot;
+}

package/runtime/javascript/transport.mjs

@@ -7,6 +7,42 @@ export const COVERAGE_PHASE_COOKIE = "__supercov_phase";
 // so the two cannot be one.
 export const COVERAGE_SCOPE_SITE_COOKIE = "__supercov_scope_site";
 export const COVERAGE_PHASE_SITE_COOKIE = "__supercov_phase_site";
+// The phase a new document starts in: the last action's, since a document
+// loads because of one (a navigation, a click that navigates). An assertion
+// that starts while it loads does not change it.
+export const COVERAGE_DOCUMENT_PHASE_COOKIE = "__supercov_document_phase";
+export const COVERAGE_DOCUMENT_PHASE_SITE_COOKIE = "__supercov_document_phase_site";
+/**
+ * Runs at the start of every document of a context, as an init script, so it
+ * reads nothing from this module. A document starts in the phase its cookie
+ * names. Only this attempt's phase is taken: a copy of the script that a
+ * context kept from an earlier test leaves a later test's phase alone.
+ */
+export function startDocumentInPhase({ attemptId, phaseCookie, phaseSiteCookie }) {
+    try {
+        let phase;
+        for (const part of document.cookie.split(";")) {
+            const at = part.indexOf("=");
+            const name = part.slice(0, at).trim();
+            if (name !== phaseCookie && name !== phaseSiteCookie)
+                continue;
+            const value = decodeURIComponent(part.slice(at + 1));
+            if (!value.startsWith(`${attemptId}:`))
+                continue;
+            phase = value;
+            if (name === phaseCookie)
+                break;
+        }
+        if (!phase)
+            return;
+        const coverageGlobal = globalThis;
+        coverageGlobal.__SUPERCOV_PHASE_ID__ = phase;
+        coverageGlobal.__SUPERCOV_ACTIVATE_PROBE_CONTEXT__?.(coverageGlobal.__SUPERCOV_MCDC_TEST_ID__ ?? "unscoped", phase);
+    }
+    catch {
+        // A document that cannot read cookies keeps its stored phase.
+    }
+}
 export const COVERAGE_CARRIER_ENV = "SUPERCOV_CONTEXT";
 export const DEFAULT_SERVER_EVIDENCE_ROOT = "/tmp/supercov-server-evidence";
 // Buffer as it was when Supercov loaded. Tests replace globals -- axios's set