@dynatrace/rum-javascript-sdk 1.331.18 → 1.333.2

package/dist/testing/snapshot.js

@@ -0,0 +1,385 @@
+/**
+ * Snapshot testing utilities for Dynatrace RUM event verification.
+ * Provides mechanisms to compare captured events against stored snapshots
+ * with support for masking volatile fields.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+/**
+ * Default properties that are ignored (replaced with "[IGNORED]") in snapshots to prevent flaky tests.
+ * These fields typically contain volatile values like timestamps, IDs, and durations
+ * that change between test runs.
+ */
+export const DEFAULT_IGNORED_FIELDS = [
+    // Base timing fields
+    "start_time",
+    "duration",
+    "timestamp",
+    // Session/Instance identity fields
+    "dt.rum.sid",
+    "dt.rum.browser.sid",
+    "dt.rum.instance.id",
+    "user_session.id",
+    "user.anonymous_id",
+    // View/Page
+    "view.foreground_time",
+    "view.instance_id",
+    "page.instance_id",
+    // User action
+    "user_action.instance_id",
+    "user_action.interrupted_by_instance_id",
+    "user_action.interrupted_instance_id",
+    "positions",
+    // Browser/Frame instance fields
+    "browser.frame.instance_id",
+    "browser.frame.parent_instance_id",
+    "browser.tab.instance_id",
+    // Distributed tracing fields
+    "trace.id",
+    "span.id",
+    // Self-monitoring
+    "dt.rum.sfm_events",
+    "dt.rum.agent.version",
+    "dt.support.last_user_input"
+];
+/**
+ * Default properties that are removed entirely from snapshots to prevent flaky tests.
+ * These fields vary in count or presence between test runs.
+ */
+export const DEFAULT_REMOVED_FIELDS = [
+    // Performance timing fields (W3C Navigation/Resource Timing)
+    "performance.*",
+    // Web Vitals timing fields
+    "fcp.*",
+    "fp.*",
+    "ttfb.*",
+    "lcp.*",
+    "fid.*",
+    "inp.*",
+    "cls.*",
+    // Long tasks
+    "long_task.*",
+    // Viewport/screen dimensions (vary by test environment)
+    "browser.window.*",
+    "device.screen.*",
+    "device.battery.level"
+];
+/**
+ * Default event patterns that are ignored during snapshot comparison.
+ * These events are volatile and may or may not be recorded depending on browser performance.
+ */
+export const DEFAULT_IGNORED_EVENTS = [
+    { "characteristics.has_long_task": true },
+    { "characteristics.is_self_monitoring": true }
+];
+/**
+ * Placeholder value used to replace ignored property values.
+ */
+export const IGNORED_PLACEHOLDER = "[IGNORED]";
+/**
+ * Processes events by ignoring and removing specified properties.
+ * - Ignored properties have their values replaced with "[IGNORED]" placeholder
+ * - Removed properties are deleted entirely from the event
+ *
+ * @param events        Array of event objects to process
+ * @param ignoredFields Array of field paths to ignore (values replaced with placeholder)
+ * @param removedFields Array of field paths to remove entirely
+ * @returns             Deep copy of events with specified fields processed
+ */
+export function processEventProperties(events, ignoredFields = DEFAULT_IGNORED_FIELDS, removedFields = DEFAULT_REMOVED_FIELDS) {
+    return events.map(event => processSingleEvent(event, ignoredFields, removedFields));
+}
+/**
+ * Filters out events that match any of the ignore patterns.
+ * An event matches a pattern if all properties in the pattern exist in the event with the same values.
+ *
+ * @param events         Array of events to filter
+ * @param ignorePatterns Array of patterns to match against
+ * @returns              Filtered array excluding events that match any pattern
+ */
+export function filterIgnoredEvents(events, ignorePatterns = DEFAULT_IGNORED_EVENTS) {
+    if (ignorePatterns.length === 0) {
+        return events;
+    }
+    return events.filter(event => !matchesAnyPattern(event, ignorePatterns));
+}
+/**
+ * Checks if an event matches any of the provided patterns.
+ *
+ * @param event    Event to check
+ * @param patterns Patterns to match against
+ * @returns        True if the event matches any pattern
+ */
+function matchesAnyPattern(event, patterns) {
+    return patterns.some(pattern => matchesPattern(event, pattern));
+}
+/**
+ * Checks if an event matches a single pattern.
+ * A match occurs when all properties in the pattern exist in the event with equal values.
+ *
+ * @param event   Event to check
+ * @param pattern Pattern to match against
+ * @returns       True if all pattern properties match
+ */
+function matchesPattern(event, pattern) {
+    return Object.keys(pattern).every(key => key in event && event[key] === pattern[key]);
+}
+/**
+ * Processes a single event by ignoring and removing specified properties.
+ * - Ignored properties: values replaced with "[IGNORED]" placeholder
+ * - Removed properties: fields deleted entirely
+ * Both support exact field names and wildcard patterns (`prefix.*`).
+ *
+ * @param event         Event object to process
+ * @param ignoredFields Array of field names/patterns to ignore (replace values)
+ * @param removedFields Array of field names/patterns to remove entirely
+ * @returns             Deep copy of event with fields processed
+ */
+function processSingleEvent(event, ignoredFields, removedFields) {
+    const result = deepClone(event);
+    // Process ignored properties (replace values with placeholder)
+    for (const fieldPath of ignoredFields) {
+        if (fieldPath.endsWith(".*")) {
+            const prefix = fieldPath.slice(0, -1); // Remove "*", keep the dot
+            ignoreFieldsWithPrefix(result, prefix);
+        }
+        else if (fieldPath in result) {
+            result[fieldPath] = IGNORED_PLACEHOLDER;
+        }
+    }
+    // Process removed properties (delete entirely)
+    for (const fieldPath of removedFields) {
+        if (fieldPath.endsWith(".*")) {
+            const prefix = fieldPath.slice(0, -1); // Remove "*", keep the dot
+            removeFieldsWithPrefix(result, prefix);
+        }
+        else {
+            delete result[fieldPath];
+        }
+    }
+    return result;
+}
+/**
+ * Replaces values of all fields in an object that start with the given prefix with the ignored placeholder.
+ * Used for wildcard patterns like `inp.*` to ignore `inp.start_time`, `inp.duration`, etc.
+ *
+ * @param obj    Object to modify
+ * @param prefix Prefix to match (including trailing dot, e.g., "inp.")
+ */
+function ignoreFieldsWithPrefix(obj, prefix) {
+    for (const key of Object.keys(obj)) {
+        if (key.startsWith(prefix)) {
+            obj[key] = IGNORED_PLACEHOLDER;
+        }
+    }
+}
+/**
+ * Removes all fields in an object that start with the given prefix.
+ * Used for wildcard patterns like `inp.*` to remove `inp.start_time`, `inp.duration`, etc.
+ *
+ * @param obj    Object to modify
+ * @param prefix Prefix to match (including trailing dot, e.g., "inp.")
+ */
+function removeFieldsWithPrefix(obj, prefix) {
+    for (const key of Object.keys(obj)) {
+        if (key.startsWith(prefix)) {
+            delete obj[key];
+        }
+    }
+}
+/**
+ * Type guard to check if a value is a Record<string, unknown>.
+ *
+ * @param value Value to check
+ * @returns     True if value is a non-null object
+ */
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Type guard to check if a value is an array of Record<string, unknown>.
+ *
+ * @param value Value to check
+ * @returns     True if value is an array where all elements are records
+ */
+function isRecordArray(value) {
+    return Array.isArray(value) && value.every(isRecord);
+}
+/**
+ * Creates a deep clone of an object.
+ *
+ * @param obj Object to clone
+ * @returns   Deep clone of the object
+ */
+function deepClone(obj) {
+    return JSON.parse(JSON.stringify(obj));
+}
+/**
+ * Reads a snapshot file from disk.
+ * Returns an object indicating whether the file exists and its parsed contents.
+ *
+ * @param snapshotPath Absolute path to the snapshot file
+ * @returns            Object with exists flag and parsed data
+ * @throws             Error if the file contains invalid JSON or is not an array of records
+ */
+export function readSnapshot(snapshotPath) {
+    if (!existsSync(snapshotPath)) {
+        return { exists: false };
+    }
+    const content = readFileSync(snapshotPath, "utf8");
+    const parsed = safeParseJson(content, snapshotPath);
+    if (!isRecordArray(parsed)) {
+        throw new Error(`Invalid snapshot format in "${snapshotPath}": expected an array of objects`);
+    }
+    return { exists: true, data: parsed };
+}
+/**
+ * Safely parses a JSON string, wrapping errors with context.
+ *
+ * @param content  JSON string to parse
+ * @param filePath Path to the file (for error messages)
+ * @returns        Parsed value
+ * @throws         Error with context if parsing fails
+ */
+function safeParseJson(content, filePath) {
+    try {
+        return JSON.parse(content);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to parse snapshot file "${filePath}": ${message}`);
+    }
+}
+/**
+ * Writes snapshot data to disk.
+ * Creates parent directories if they don't exist.
+ * Events are sorted by characteristics for consistent ordering.
+ * Uses deterministic JSON serialization with sorted keys for consistent diffs.
+ *
+ * @param snapshotPath Absolute path to the snapshot file
+ * @param data         Array of events to write
+ */
+export function writeSnapshot(snapshotPath, data) {
+    const dir = dirname(snapshotPath);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    const sortedData = sortEventsByCharacteristics(data);
+    const serialized = serializeSnapshot(sortedData);
+    writeFileSync(snapshotPath, serialized, "utf8");
+}
+/**
+ * Serializes snapshot data to a deterministic JSON string.
+ * Sorts object keys to ensure consistent output across different Node.js versions.
+ *
+ * @param data Array of events to serialize
+ * @returns    Pretty-printed JSON string with sorted keys
+ */
+function serializeSnapshot(data) {
+    return JSON.stringify(data, sortedReplacer, 2) + "\n";
+}
+/**
+ * JSON replacer function that sorts object keys for deterministic serialization.
+ *
+ * @param key   Current key (unused)
+ * @param value Current value
+ * @returns     Value with sorted keys if it's an object
+ */
+function sortedReplacer(key, value) {
+    if (!isRecord(value)) {
+        return value;
+    }
+    const sortedKeys = Object.keys(value).sort();
+    const sorted = {};
+    for (const sortedKey of sortedKeys) {
+        sorted[sortedKey] = value[sortedKey];
+    }
+    return sorted;
+}
+/**
+ * Sorts events by their characteristics signature for order-independent comparison.
+ * Events with the same characteristics are further sorted by other stable properties.
+ * This ensures consistent ordering regardless of event arrival order.
+ *
+ * @param events Array of events to sort
+ * @returns      New array with events sorted by characteristics
+ */
+export function sortEventsByCharacteristics(events) {
+    return [...events].sort((a, b) => {
+        const sigA = getCharacteristicsSignature(a);
+        const sigB = getCharacteristicsSignature(b);
+        if (sigA !== sigB) {
+            return sigA.localeCompare(sigB);
+        }
+        // If characteristics are the same, sort by other stable properties
+        return getSecondarySignature(a).localeCompare(getSecondarySignature(b));
+    });
+}
+/**
+ * Generates a signature string from an event's characteristics fields.
+ * Characteristics fields are boolean flags like "characteristics.has_navigation".
+ *
+ * @param event Event object
+ * @returns     Signature string representing the event's characteristics
+ */
+function getCharacteristicsSignature(event) {
+    const characteristicsKeys = Object.keys(event)
+        .filter(key => key.startsWith("characteristics.") && event[key] === true)
+        .sort();
+    return characteristicsKeys.join(",");
+}
+/**
+ * Generates a secondary signature for events with the same characteristics.
+ * Uses stable identifying properties like name, type, url, etc.
+ *
+ * @param event Event object
+ * @returns     Secondary signature string
+ */
+function getSecondarySignature(event) {
+    // Keys must match RumEventKeys enum values for consistency
+    const stableKeys = [
+        "url.full",
+        "view.sequence.number",
+        "view.url.full",
+        "page.url.full",
+        "user_action.type",
+        "interaction.name",
+        "navigation.type",
+        "exception.type",
+        "exception.message"
+    ];
+    return stableKeys
+        .map((key) => {
+        const value = getValueByKey(event, key);
+        if (value !== void 0) {
+            return `${key}:${String(value)}`;
+        }
+        return void 0;
+    })
+        .filter(Boolean)
+        .join("|");
+}
+/**
+ * Gets a value from an object, trying both literal key and nested path.
+ *
+ * @param obj Object to get value from
+ * @param key Key (may be literal or dot-notation path)
+ * @returns   Value or undefined
+ */
+function getValueByKey(obj, key) {
+    // First try literal key (e.g., "request.url" as a single key)
+    if (key in obj) {
+        return obj[key];
+    }
+    // Then try nested path (e.g., obj.request.url)
+    const parts = key.split(".");
+    let current = obj;
+    for (const part of parts) {
+        if (!isRecord(current) || !(part in current)) {
+            return void 0;
+        }
+        current = current[part];
+    }
+    return current;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"snapshot.js","sourceRoot":"","sources":["../../source/testing/snapshot.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Snapshot testing utilities for Dynatrace RUM event verification.\n * Provides mechanisms to compare captured events against stored snapshots\n * with support for masking volatile fields.\n */\n\nimport {\n    existsSync,\n    mkdirSync,\n    readFileSync,\n    writeFileSync\n} from \"node:fs\";\nimport { dirname } from \"node:path\";\n\n/**\n * Result of reading a snapshot file.\n */\ninterface SnapshotReadResult {\n    /**\n     * Whether the snapshot file exists.\n     */\n    exists: boolean;\n\n    /**\n     * The parsed snapshot data, or undefined if the file doesn't exist.\n     */\n    data?: Record<string, unknown>[];\n}\n\n/**\n * Pattern to match events that should be completely ignored during snapshot comparison.\n * Events matching any of these patterns will be filtered out before comparison.\n */\nexport type EventIgnorePattern = Record<string, unknown>;\n\n/**\n * Options for configuring snapshot comparison behavior.\n */\nexport interface SnapshotOptions {\n    /**\n     * Properties to ignore before comparison. Values are replaced with \"[IGNORED]\" placeholder.\n     * Supports exact field names and wildcard patterns (`prefix.*`).\n     *\n     * Examples:\n     * - `\"start_time\"` → value replaced with \"[IGNORED]\"\n     * - `\"inp.*\"` → all fields starting with `inp.` have values replaced with \"[IGNORED]\"\n     *\n     * Default: DEFAULT_IGNORED_FIELDS\n     */\n    ignoredFields?: string[];\n\n    /**\n     * Properties to remove entirely before comparison.\n     * Supports exact field names and wildcard patterns (`prefix.*`).\n     *\n     * Examples:\n     * - `\"start_time\"` → field is removed from the event\n     * - `\"inp.*\"` → all fields starting with `inp.` are removed\n     *\n     * Default: DEFAULT_REMOVED_FIELDS\n     */\n    removedFields?: string[];\n\n    /**\n     * Event patterns to completely ignore during snapshot comparison.\n     * Events matching any of these patterns will be filtered out.\n     * Default: DEFAULT_IGNORED_EVENTS\n     */\n    ignoreEvents?: EventIgnorePattern[];\n\n    /**\n     * Custom snapshot name. If not provided, auto-generated from test name.\n     */\n    name?: string;\n}\n\n/**\n * Default properties that are ignored (replaced with \"[IGNORED]\") in snapshots to prevent flaky tests.\n * These fields typically contain volatile values like timestamps, IDs, and durations\n * that change between test runs.\n */\nexport const DEFAULT_IGNORED_FIELDS: readonly string[] = [\n    // Base timing fields\n    \"start_time\",\n    \"duration\",\n    \"timestamp\",\n\n    // Session/Instance identity fields\n    \"dt.rum.sid\",\n    \"dt.rum.browser.sid\",\n    \"dt.rum.instance.id\",\n    \"user_session.id\",\n    \"user.anonymous_id\",\n\n    // View/Page\n    \"view.foreground_time\",\n    \"view.instance_id\",\n    \"page.instance_id\",\n\n    // User action\n    \"user_action.instance_id\",\n    \"user_action.interrupted_by_instance_id\",\n    \"user_action.interrupted_instance_id\",\n    \"positions\",\n\n    // Browser/Frame instance fields\n    \"browser.frame.instance_id\",\n    \"browser.frame.parent_instance_id\",\n    \"browser.tab.instance_id\",\n\n    // Distributed tracing fields\n    \"trace.id\",\n    \"span.id\",\n\n    // Self-monitoring\n    \"dt.rum.sfm_events\",\n    \"dt.rum.agent.version\",\n    \"dt.support.last_user_input\"\n] as const;\n\n/**\n * Default properties that are removed entirely from snapshots to prevent flaky tests.\n * These fields vary in count or presence between test runs.\n */\nexport const DEFAULT_REMOVED_FIELDS: readonly string[] = [\n    // Performance timing fields (W3C Navigation/Resource Timing)\n    \"performance.*\",\n\n    // Web Vitals timing fields\n    \"fcp.*\",\n    \"fp.*\",\n    \"ttfb.*\",\n    \"lcp.*\",\n    \"fid.*\",\n    \"inp.*\",\n    \"cls.*\",\n\n    // Long tasks\n    \"long_task.*\",\n\n    // Viewport/screen dimensions (vary by test environment)\n    \"browser.window.*\",\n    \"device.screen.*\",\n    \"device.battery.level\"\n] as const;\n\n/**\n * Default event patterns that are ignored during snapshot comparison.\n * These events are volatile and may or may not be recorded depending on browser performance.\n */\nexport const DEFAULT_IGNORED_EVENTS: readonly EventIgnorePattern[] = [\n    { \"characteristics.has_long_task\": true },\n    { \"characteristics.is_self_monitoring\": true }\n];\n\n/**\n * Placeholder value used to replace ignored property values.\n */\nexport const IGNORED_PLACEHOLDER = \"[IGNORED]\";\n\n/**\n * Processes events by ignoring and removing specified properties.\n * - Ignored properties have their values replaced with \"[IGNORED]\" placeholder\n * - Removed properties are deleted entirely from the event\n *\n * @param events        Array of event objects to process\n * @param ignoredFields Array of field paths to ignore (values replaced with placeholder)\n * @param removedFields Array of field paths to remove entirely\n * @returns             Deep copy of events with specified fields processed\n */\nexport function processEventProperties(\n    events: Record<string, unknown>[],\n    ignoredFields: readonly string[] = DEFAULT_IGNORED_FIELDS,\n    removedFields: readonly string[] = DEFAULT_REMOVED_FIELDS\n): Record<string, unknown>[] {\n    return events.map(event => processSingleEvent(event, ignoredFields, removedFields));\n}\n\n/**\n * Filters out events that match any of the ignore patterns.\n * An event matches a pattern if all properties in the pattern exist in the event with the same values.\n *\n * @param events         Array of events to filter\n * @param ignorePatterns Array of patterns to match against\n * @returns              Filtered array excluding events that match any pattern\n */\nexport function filterIgnoredEvents(\n    events: Record<string, unknown>[],\n    ignorePatterns: readonly EventIgnorePattern[] = DEFAULT_IGNORED_EVENTS\n): Record<string, unknown>[] {\n    if (ignorePatterns.length === 0) {\n        return events;\n    }\n\n    return events.filter(event => !matchesAnyPattern(event, ignorePatterns));\n}\n\n/**\n * Checks if an event matches any of the provided patterns.\n *\n * @param event    Event to check\n * @param patterns Patterns to match against\n * @returns        True if the event matches any pattern\n */\nfunction matchesAnyPattern(\n    event: Record<string, unknown>,\n    patterns: readonly EventIgnorePattern[]\n): boolean {\n    return patterns.some(pattern => matchesPattern(event, pattern));\n}\n\n/**\n * Checks if an event matches a single pattern.\n * A match occurs when all properties in the pattern exist in the event with equal values.\n *\n * @param event   Event to check\n * @param pattern Pattern to match against\n * @returns       True if all pattern properties match\n */\nfunction matchesPattern(\n    event: Record<string, unknown>,\n    pattern: EventIgnorePattern\n): boolean {\n    return Object.keys(pattern).every(key => key in event && event[key] === pattern[key]);\n}\n\n/**\n * Processes a single event by ignoring and removing specified properties.\n * - Ignored properties: values replaced with \"[IGNORED]\" placeholder\n * - Removed properties: fields deleted entirely\n * Both support exact field names and wildcard patterns (`prefix.*`).\n *\n * @param event         Event object to process\n * @param ignoredFields Array of field names/patterns to ignore (replace values)\n * @param removedFields Array of field names/patterns to remove entirely\n * @returns             Deep copy of event with fields processed\n */\nfunction processSingleEvent(\n    event: Record<string, unknown>,\n    ignoredFields: readonly string[],\n    removedFields: readonly string[]\n): Record<string, unknown> {\n    const result = deepClone(event);\n\n    // Process ignored properties (replace values with placeholder)\n    for (const fieldPath of ignoredFields) {\n        if (fieldPath.endsWith(\".*\")) {\n            const prefix = fieldPath.slice(0, -1); // Remove \"*\", keep the dot\n            ignoreFieldsWithPrefix(result, prefix);\n        } else if (fieldPath in result) {\n            result[fieldPath] = IGNORED_PLACEHOLDER;\n        }\n    }\n\n    // Process removed properties (delete entirely)\n    for (const fieldPath of removedFields) {\n        if (fieldPath.endsWith(\".*\")) {\n            const prefix = fieldPath.slice(0, -1); // Remove \"*\", keep the dot\n            removeFieldsWithPrefix(result, prefix);\n        } else {\n            delete result[fieldPath];\n        }\n    }\n\n    return result;\n}\n\n/**\n * Replaces values of all fields in an object that start with the given prefix with the ignored placeholder.\n * Used for wildcard patterns like `inp.*` to ignore `inp.start_time`, `inp.duration`, etc.\n *\n * @param obj    Object to modify\n * @param prefix Prefix to match (including trailing dot, e.g., \"inp.\")\n */\nfunction ignoreFieldsWithPrefix(obj: Record<string, unknown>, prefix: string): void {\n    for (const key of Object.keys(obj)) {\n        if (key.startsWith(prefix)) {\n            obj[key] = IGNORED_PLACEHOLDER;\n        }\n    }\n}\n\n/**\n * Removes all fields in an object that start with the given prefix.\n * Used for wildcard patterns like `inp.*` to remove `inp.start_time`, `inp.duration`, etc.\n *\n * @param obj    Object to modify\n * @param prefix Prefix to match (including trailing dot, e.g., \"inp.\")\n */\nfunction removeFieldsWithPrefix(obj: Record<string, unknown>, prefix: string): void {\n    for (const key of Object.keys(obj)) {\n        if (key.startsWith(prefix)) {\n            delete obj[key];\n        }\n    }\n}\n\n/**\n * Type guard to check if a value is a Record<string, unknown>.\n *\n * @param value Value to check\n * @returns     True if value is a non-null object\n */\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n    return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n\n/**\n * Type guard to check if a value is an array of Record<string, unknown>.\n *\n * @param value Value to check\n * @returns     True if value is an array where all elements are records\n */\nfunction isRecordArray(value: unknown): value is Record<string, unknown>[] {\n    return Array.isArray(value) && value.every(isRecord);\n}\n\n/**\n * Creates a deep clone of an object.\n *\n * @param obj Object to clone\n * @returns   Deep clone of the object\n */\nfunction deepClone<T>(obj: T): T {\n    return JSON.parse(JSON.stringify(obj));\n}\n\n/**\n * Reads a snapshot file from disk.\n * Returns an object indicating whether the file exists and its parsed contents.\n *\n * @param snapshotPath Absolute path to the snapshot file\n * @returns            Object with exists flag and parsed data\n * @throws             Error if the file contains invalid JSON or is not an array of records\n */\nexport function readSnapshot(snapshotPath: string): SnapshotReadResult {\n    if (!existsSync(snapshotPath)) {\n        return { exists: false };\n    }\n\n    const content = readFileSync(snapshotPath, \"utf8\");\n    const parsed = safeParseJson(content, snapshotPath);\n\n    if (!isRecordArray(parsed)) {\n        throw new Error(\n            `Invalid snapshot format in \"${snapshotPath}\": expected an array of objects`\n        );\n    }\n\n    return { exists: true, data: parsed };\n}\n\n/**\n * Safely parses a JSON string, wrapping errors with context.\n *\n * @param content  JSON string to parse\n * @param filePath Path to the file (for error messages)\n * @returns        Parsed value\n * @throws         Error with context if parsing fails\n */\nfunction safeParseJson(content: string, filePath: string): unknown {\n    try {\n        return JSON.parse(content);\n    } catch (error) {\n        const message = error instanceof Error ? error.message : String(error);\n        throw new Error(`Failed to parse snapshot file \"${filePath}\": ${message}`);\n    }\n}\n\n/**\n * Writes snapshot data to disk.\n * Creates parent directories if they don't exist.\n * Events are sorted by characteristics for consistent ordering.\n * Uses deterministic JSON serialization with sorted keys for consistent diffs.\n *\n * @param snapshotPath Absolute path to the snapshot file\n * @param data         Array of events to write\n */\nexport function writeSnapshot(snapshotPath: string, data: Record<string, unknown>[]): void {\n    const dir = dirname(snapshotPath);\n    if (!existsSync(dir)) {\n        mkdirSync(dir, { recursive: true });\n    }\n\n    const sortedData = sortEventsByCharacteristics(data);\n    const serialized = serializeSnapshot(sortedData);\n    writeFileSync(snapshotPath, serialized, \"utf8\");\n}\n\n/**\n * Serializes snapshot data to a deterministic JSON string.\n * Sorts object keys to ensure consistent output across different Node.js versions.\n *\n * @param data Array of events to serialize\n * @returns    Pretty-printed JSON string with sorted keys\n */\nfunction serializeSnapshot(data: Record<string, unknown>[]): string {\n    return JSON.stringify(data, sortedReplacer, 2) + \"\\n\";\n}\n\n/**\n * JSON replacer function that sorts object keys for deterministic serialization.\n *\n * @param key   Current key (unused)\n * @param value Current value\n * @returns     Value with sorted keys if it's an object\n */\nfunction sortedReplacer(key: string, value: unknown): unknown {\n    if (!isRecord(value)) {\n        return value;\n    }\n\n    const sortedKeys = Object.keys(value).sort();\n    const sorted: Record<string, unknown> = {};\n    for (const sortedKey of sortedKeys) {\n        sorted[sortedKey] = value[sortedKey];\n    }\n    return sorted;\n}\n\n/**\n * Sorts events by their characteristics signature for order-independent comparison.\n * Events with the same characteristics are further sorted by other stable properties.\n * This ensures consistent ordering regardless of event arrival order.\n *\n * @param events Array of events to sort\n * @returns      New array with events sorted by characteristics\n */\nexport function sortEventsByCharacteristics(events: Record<string, unknown>[]): Record<string, unknown>[] {\n    return [...events].sort((a, b) => {\n        const sigA = getCharacteristicsSignature(a);\n        const sigB = getCharacteristicsSignature(b);\n\n        if (sigA !== sigB) {\n            return sigA.localeCompare(sigB);\n        }\n\n        // If characteristics are the same, sort by other stable properties\n        return getSecondarySignature(a).localeCompare(getSecondarySignature(b));\n    });\n}\n\n/**\n * Generates a signature string from an event's characteristics fields.\n * Characteristics fields are boolean flags like \"characteristics.has_navigation\".\n *\n * @param event Event object\n * @returns     Signature string representing the event's characteristics\n */\nfunction getCharacteristicsSignature(event: Record<string, unknown>): string {\n    const characteristicsKeys = Object.keys(event)\n        .filter(key => key.startsWith(\"characteristics.\") && event[key] === true)\n        .sort();\n\n    return characteristicsKeys.join(\",\");\n}\n\n/**\n * Generates a secondary signature for events with the same characteristics.\n * Uses stable identifying properties like name, type, url, etc.\n *\n * @param event Event object\n * @returns     Secondary signature string\n */\nfunction getSecondarySignature(event: Record<string, unknown>): string {\n    // Keys must match RumEventKeys enum values for consistency\n    const stableKeys = [\n        \"url.full\",\n        \"view.sequence.number\",\n        \"view.url.full\",\n        \"page.url.full\",\n        \"user_action.type\",\n        \"interaction.name\",\n        \"navigation.type\",\n        \"exception.type\",\n        \"exception.message\"\n    ];\n\n    return stableKeys\n        .map((key) => {\n            const value = getValueByKey(event, key);\n            if (value !== void 0) {\n                return `${key}:${String(value)}`;\n            }\n            return void 0;\n        })\n        .filter(Boolean)\n        .join(\"|\");\n}\n\n/**\n * Gets a value from an object, trying both literal key and nested path.\n *\n * @param obj Object to get value from\n * @param key Key (may be literal or dot-notation path)\n * @returns   Value or undefined\n */\nfunction getValueByKey(obj: Record<string, unknown>, key: string): unknown {\n    // First try literal key (e.g., \"request.url\" as a single key)\n    if (key in obj) {\n        return obj[key];\n    }\n\n    // Then try nested path (e.g., obj.request.url)\n    const parts = key.split(\".\");\n    let current: unknown = obj;\n\n    for (const part of parts) {\n        if (!isRecord(current) || !(part in current)) {\n            return void 0;\n        }\n        current = current[part];\n    }\n\n    return current;\n}\n"]}

package/dist/testing/test.d.ts

@@ -1,3 +1,4 @@
+import type { SnapshotOptions } from "./snapshot.js";
 export interface WaitForBeaconsOptions {
     /**
      * The minimum number of beacon requests to wait for
@@ -50,6 +51,14 @@ export interface DynatraceTesting {
      * ```
      */
     clearEvents(): void;
+    /**
+     * Compares captured events against a stored snapshot file.
+     * On first run, creates the snapshot. On subsequent runs, compares and fails if different.
+     * Volatile fields (timestamps, IDs, etc.) are masked by default to prevent flaky tests.
+     *
+     * @param options Configuration for snapshot comparison
+     */
+    toMatchEventSnapshot(options?: SnapshotOptions): Promise<void>;
 }
 export interface BeaconRequest {
     url: string;