@curl-runner/cli 1.9.0 → 1.11.0

package/src/snapshot/snapshot-differ.test.ts

@@ -0,0 +1,358 @@
+import { describe, expect, test } from 'bun:test';
+import type { Snapshot } from '../types/config';
+import { SnapshotDiffer } from './snapshot-differ';
+
+describe('SnapshotDiffer', () => {
+  describe('basic comparison', () => {
+    test('should match identical snapshots', () => {
+      const differ = new SnapshotDiffer({});
+      const snapshot: Snapshot = {
+        status: 200,
+        body: { id: 1, name: 'test' },
+        hash: 'abc123',
+        updatedAt: '2024-01-01',
+      };
+
+      const result = differ.compare(snapshot, snapshot);
+      expect(result.match).toBe(true);
+      expect(result.differences).toHaveLength(0);
+    });
+
+    test('should detect status changes', () => {
+      const differ = new SnapshotDiffer({});
+      const expected: Snapshot = { status: 200, hash: 'a', updatedAt: '' };
+      const received: Snapshot = { status: 201, hash: 'b', updatedAt: '' };
+
+      const result = differ.compare(expected, received);
+      expect(result.match).toBe(false);
+      expect(result.differences).toHaveLength(1);
+      expect(result.differences[0]).toEqual({
+        path: 'status',
+        expected: 200,
+        received: 201,
+        type: 'changed',
+      });
+    });
+
+    test('should detect body value changes', () => {
+      const differ = new SnapshotDiffer({});
+      const expected: Snapshot = {
+        body: { name: 'old' },
+        hash: 'a',
+        updatedAt: '',
+      };
+      const received: Snapshot = {
+        body: { name: 'new' },
+        hash: 'b',
+        updatedAt: '',
+      };
+
+      const result = differ.compare(expected, received);
+      expect(result.match).toBe(false);
+      expect(result.differences[0].path).toBe('body.name');
+      expect(result.differences[0].type).toBe('changed');
+    });
+
+    test('should detect added fields', () => {
+      const differ = new SnapshotDiffer({});
+      const expected: Snapshot = {
+        body: { id: 1 },
+        hash: 'a',
+        updatedAt: '',
+      };
+      const received: Snapshot = {
+        body: { id: 1, newField: 'value' },
+        hash: 'b',
+        updatedAt: '',
+      };
+
+      const result = differ.compare(expected, received);
+      expect(result.match).toBe(false);
+      expect(result.differences[0].path).toBe('body.newField');
+      expect(result.differences[0].type).toBe('added');
+    });
+
+    test('should detect removed fields', () => {
+      const differ = new SnapshotDiffer({});
+      const expected: Snapshot = {
+        body: { id: 1, oldField: 'value' },
+        hash: 'a',
+        updatedAt: '',
+      };
+      const received: Snapshot = {
+        body: { id: 1 },
+        hash: 'b',
+        updatedAt: '',
+      };
+
+      const result = differ.compare(expected, received);
+      expect(result.match).toBe(false);
+      expect(result.differences[0].path).toBe('body.oldField');
+      expect(result.differences[0].type).toBe('removed');
+    });
+  });
+
+  describe('array comparison', () => {
+    test('should compare array elements', () => {
+      const differ = new SnapshotDiffer({});
+      const expected: Snapshot = {
+        body: { items: [1, 2, 3] },
+        hash: 'a',
+        updatedAt: '',
+      };
+      const received: Snapshot = {
+        body: { items: [1, 2, 4] },
+        hash: 'b',
+        updatedAt: '',
+      };
+
+      const result = differ.compare(expected, received);
+      expect(result.match).toBe(false);
+      expect(result.differences[0].path).toBe('body.items[2]');
+    });
+
+    test('should detect added array elements', () => {
+      const differ = new SnapshotDiffer({});
+      const expected: Snapshot = {
+        body: { items: [1, 2] },
+        hash: 'a',
+        updatedAt: '',
+      };
+      const received: Snapshot = {
+        body: { items: [1, 2, 3] },
+        hash: 'b',
+        updatedAt: '',
+      };
+
+      const result = differ.compare(expected, received);
+      expect(result.match).toBe(false);
+      expect(result.differences[0].path).toBe('body.items[2]');
+      expect(result.differences[0].type).toBe('added');
+    });
+  });
+
+  describe('exclusions', () => {
+    test('should exclude exact paths', () => {
+      const differ = new SnapshotDiffer({
+        exclude: ['body.timestamp'],
+      });
+      const expected: Snapshot = {
+        body: { id: 1, timestamp: '2024-01-01' },
+        hash: 'a',
+        updatedAt: '',
+      };
+      const received: Snapshot = {
+        body: { id: 1, timestamp: '2024-12-31' },
+        hash: 'b',
+        updatedAt: '',
+      };
+
+      const result = differ.compare(expected, received);
+      expect(result.match).toBe(true);
+    });
+
+    test('should exclude wildcard paths (*.field)', () => {
+      const differ = new SnapshotDiffer({
+        exclude: ['*.createdAt'],
+      });
+      const expected: Snapshot = {
+        body: { user: { createdAt: '2024-01-01' }, post: { createdAt: '2024-01-01' } },
+        hash: 'a',
+        updatedAt: '',
+      };
+      const received: Snapshot = {
+        body: { user: { createdAt: '2024-12-31' }, post: { createdAt: '2024-12-31' } },
+        hash: 'b',
+        updatedAt: '',
+      };
+
+      const result = differ.compare(expected, received);
+      expect(result.match).toBe(true);
+    });
+
+    test('should exclude array wildcard paths (body[*].id)', () => {
+      const differ = new SnapshotDiffer({
+        exclude: ['body.items[*].id'],
+      });
+      const expected: Snapshot = {
+        body: {
+          items: [
+            { id: 1, name: 'a' },
+            { id: 2, name: 'b' },
+          ],
+        },
+        hash: 'a',
+        updatedAt: '',
+      };
+      const received: Snapshot = {
+        body: {
+          items: [
+            { id: 99, name: 'a' },
+            { id: 100, name: 'b' },
+          ],
+        },
+        hash: 'b',
+        updatedAt: '',
+      };
+
+      const result = differ.compare(expected, received);
+      expect(result.match).toBe(true);
+    });
+  });
+
+  describe('match rules', () => {
+    test('should accept any value with wildcard (*)', () => {
+      const differ = new SnapshotDiffer({
+        match: { 'body.id': '*' },
+      });
+      const expected: Snapshot = {
+        body: { id: 1 },
+        hash: 'a',
+        updatedAt: '',
+      };
+      const received: Snapshot = {
+        body: { id: 999 },
+        hash: 'b',
+        updatedAt: '',
+      };
+
+      const result = differ.compare(expected, received);
+      expect(result.match).toBe(true);
+    });
+
+    test('should match regex patterns', () => {
+      const differ = new SnapshotDiffer({
+        match: { 'body.version': 'regex:^v\\d+\\.\\d+' },
+      });
+      const expected: Snapshot = {
+        body: { version: 'v1.0.0' },
+        hash: 'a',
+        updatedAt: '',
+      };
+      const received: Snapshot = {
+        body: { version: 'v2.5.3' },
+        hash: 'b',
+        updatedAt: '',
+      };
+
+      const result = differ.compare(expected, received);
+      expect(result.match).toBe(true);
+    });
+
+    test('should fail on non-matching regex', () => {
+      const differ = new SnapshotDiffer({
+        match: { 'body.version': 'regex:^v\\d+\\.\\d+' },
+      });
+      const expected: Snapshot = {
+        body: { version: 'v1.0' },
+        hash: 'a',
+        updatedAt: '',
+      };
+      const received: Snapshot = {
+        body: { version: 'invalid' },
+        hash: 'b',
+        updatedAt: '',
+      };
+
+      const result = differ.compare(expected, received);
+      expect(result.match).toBe(false);
+    });
+  });
+
+  describe('type mismatches', () => {
+    test('should detect type changes', () => {
+      const differ = new SnapshotDiffer({});
+      const expected: Snapshot = {
+        body: { count: 42 },
+        hash: 'a',
+        updatedAt: '',
+      };
+      const received: Snapshot = {
+        body: { count: '42' },
+        hash: 'b',
+        updatedAt: '',
+      };
+
+      const result = differ.compare(expected, received);
+      expect(result.match).toBe(false);
+      expect(result.differences[0].type).toBe('type_mismatch');
+    });
+
+    test('should detect object to array change', () => {
+      const differ = new SnapshotDiffer({});
+      const expected: Snapshot = {
+        body: { data: { key: 'value' } },
+        hash: 'a',
+        updatedAt: '',
+      };
+      const received: Snapshot = {
+        body: { data: ['value'] },
+        hash: 'b',
+        updatedAt: '',
+      };
+
+      const result = differ.compare(expected, received);
+      expect(result.match).toBe(false);
+      expect(result.differences[0].type).toBe('type_mismatch');
+    });
+  });
+
+  describe('nested objects', () => {
+    test('should compare deeply nested values', () => {
+      const differ = new SnapshotDiffer({});
+      const expected: Snapshot = {
+        body: { level1: { level2: { level3: { value: 'old' } } } },
+        hash: 'a',
+        updatedAt: '',
+      };
+      const received: Snapshot = {
+        body: { level1: { level2: { level3: { value: 'new' } } } },
+        hash: 'b',
+        updatedAt: '',
+      };
+
+      const result = differ.compare(expected, received);
+      expect(result.match).toBe(false);
+      expect(result.differences[0].path).toBe('body.level1.level2.level3.value');
+    });
+  });
+
+  describe('header comparison', () => {
+    test('should compare headers', () => {
+      const differ = new SnapshotDiffer({});
+      const expected: Snapshot = {
+        headers: { 'content-type': 'application/json' },
+        hash: 'a',
+        updatedAt: '',
+      };
+      const received: Snapshot = {
+        headers: { 'content-type': 'text/html' },
+        hash: 'b',
+        updatedAt: '',
+      };
+
+      const result = differ.compare(expected, received);
+      expect(result.match).toBe(false);
+      expect(result.differences[0].path).toBe('headers.content-type');
+    });
+
+    test('should exclude headers', () => {
+      const differ = new SnapshotDiffer({
+        exclude: ['headers.date', 'headers.x-request-id'],
+      });
+      const expected: Snapshot = {
+        headers: { 'content-type': 'application/json', date: '2024-01-01' },
+        hash: 'a',
+        updatedAt: '',
+      };
+      const received: Snapshot = {
+        headers: { 'content-type': 'application/json', date: '2024-12-31' },
+        hash: 'b',
+        updatedAt: '',
+      };
+
+      const result = differ.compare(expected, received);
+      expect(result.match).toBe(true);
+    });
+  });
+});

package/src/snapshot/snapshot-differ.ts

@@ -0,0 +1,296 @@
+import type { JsonValue, Snapshot, SnapshotConfig, SnapshotDiff } from '../types/config';
+
+interface DiffResult {
+  match: boolean;
+  differences: SnapshotDiff[];
+}
+
+/**
+ * Compares snapshots with support for exclusions, wildcards, and regex patterns.
+ */
+export class SnapshotDiffer {
+  private excludePaths: Set<string>;
+  private matchRules: Map<string, string>;
+
+  constructor(config: SnapshotConfig) {
+    this.excludePaths = new Set(config.exclude || []);
+    this.matchRules = new Map(Object.entries(config.match || {}));
+  }
+
+  /**
+   * Compares two snapshots and returns differences.
+   */
+  compare(expected: Snapshot, received: Snapshot): DiffResult {
+    const differences: SnapshotDiff[] = [];
+
+    // Compare status
+    if (expected.status !== undefined || received.status !== undefined) {
+      if (expected.status !== received.status && !this.isExcluded('status')) {
+        differences.push({
+          path: 'status',
+          expected: expected.status,
+          received: received.status,
+          type: 'changed',
+        });
+      }
+    }
+
+    // Compare headers
+    if (expected.headers || received.headers) {
+      const headerDiffs = this.compareObjects(
+        expected.headers || {},
+        received.headers || {},
+        'headers',
+      );
+      differences.push(...headerDiffs);
+    }
+
+    // Compare body
+    if (expected.body !== undefined || received.body !== undefined) {
+      const bodyDiffs = this.deepCompare(expected.body, received.body, 'body');
+      differences.push(...bodyDiffs);
+    }
+
+    return {
+      match: differences.length === 0,
+      differences,
+    };
+  }
+
+  /**
+   * Deep comparison of two values with path tracking.
+   */
+  deepCompare(expected: unknown, received: unknown, path: string): SnapshotDiff[] {
+    // Check if path is excluded
+    if (this.isExcluded(path)) {
+      return [];
+    }
+
+    // Check match rules (wildcards, regex)
+    if (this.matchesRule(path, received)) {
+      return [];
+    }
+
+    // Both null/undefined
+    if (expected === null && received === null) {
+      return [];
+    }
+    if (expected === undefined && received === undefined) {
+      return [];
+    }
+
+    // Type mismatch
+    const expectedType = this.getType(expected);
+    const receivedType = this.getType(received);
+    if (expectedType !== receivedType) {
+      return [
+        {
+          path,
+          expected,
+          received,
+          type: 'type_mismatch',
+        },
+      ];
+    }
+
+    // Primitives
+    if (expectedType !== 'object' && expectedType !== 'array') {
+      if (expected !== received) {
+        return [
+          {
+            path,
+            expected,
+            received,
+            type: 'changed',
+          },
+        ];
+      }
+      return [];
+    }
+
+    // Arrays
+    if (expectedType === 'array') {
+      return this.compareArrays(expected as JsonValue[], received as JsonValue[], path);
+    }
+
+    // Objects
+    return this.compareObjects(
+      expected as Record<string, unknown>,
+      received as Record<string, unknown>,
+      path,
+    );
+  }
+
+  /**
+   * Compares two arrays.
+   */
+  private compareArrays(
+    expected: JsonValue[],
+    received: JsonValue[],
+    path: string,
+  ): SnapshotDiff[] {
+    const differences: SnapshotDiff[] = [];
+
+    // Check length difference
+    const maxLen = Math.max(expected.length, received.length);
+
+    for (let i = 0; i < maxLen; i++) {
+      const itemPath = `${path}[${i}]`;
+
+      if (i >= expected.length) {
+        // Added item
+        if (!this.isExcluded(itemPath)) {
+          differences.push({
+            path: itemPath,
+            expected: undefined,
+            received: received[i],
+            type: 'added',
+          });
+        }
+      } else if (i >= received.length) {
+        // Removed item
+        if (!this.isExcluded(itemPath)) {
+          differences.push({
+            path: itemPath,
+            expected: expected[i],
+            received: undefined,
+            type: 'removed',
+          });
+        }
+      } else {
+        // Compare items
+        const itemDiffs = this.deepCompare(expected[i], received[i], itemPath);
+        differences.push(...itemDiffs);
+      }
+    }
+
+    return differences;
+  }
+
+  /**
+   * Compares two objects.
+   */
+  private compareObjects(
+    expected: Record<string, unknown>,
+    received: Record<string, unknown>,
+    path: string,
+  ): SnapshotDiff[] {
+    const differences: SnapshotDiff[] = [];
+    const allKeys = new Set([...Object.keys(expected), ...Object.keys(received)]);
+
+    for (const key of allKeys) {
+      const keyPath = path ? `${path}.${key}` : key;
+      const hasExpected = key in expected;
+      const hasReceived = key in received;
+
+      if (!hasExpected && hasReceived) {
+        // Added key
+        if (!this.isExcluded(keyPath)) {
+          differences.push({
+            path: keyPath,
+            expected: undefined,
+            received: received[key],
+            type: 'added',
+          });
+        }
+      } else if (hasExpected && !hasReceived) {
+        // Removed key
+        if (!this.isExcluded(keyPath)) {
+          differences.push({
+            path: keyPath,
+            expected: expected[key],
+            received: undefined,
+            type: 'removed',
+          });
+        }
+      } else {
+        // Compare values
+        const keyDiffs = this.deepCompare(expected[key], received[key], keyPath);
+        differences.push(...keyDiffs);
+      }
+    }
+
+    return differences;
+  }
+
+  /**
+   * Checks if a path should be excluded from comparison.
+   */
+  isExcluded(path: string): boolean {
+    // Exact match
+    if (this.excludePaths.has(path)) {
+      return true;
+    }
+
+    for (const pattern of this.excludePaths) {
+      // Wildcard prefix (e.g., '*.timestamp')
+      if (pattern.startsWith('*.')) {
+        const suffix = pattern.slice(2);
+        if (path.endsWith(`.${suffix}`)) {
+          return true;
+        }
+        // Also match root level (e.g., 'timestamp' matches '*.timestamp')
+        const lastPart = path.split('.').pop();
+        if (lastPart === suffix) {
+          return true;
+        }
+      }
+
+      // Array wildcard (e.g., 'body[*].id')
+      if (pattern.includes('[*]')) {
+        const regex = new RegExp(
+          `^${pattern.replace(/\[\*\]/g, '\\[\\d+\\]').replace(/\./g, '\\.')}$`,
+        );
+        if (regex.test(path)) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Checks if a value matches a custom rule for its path.
+   */
+  matchesRule(path: string, value: unknown): boolean {
+    const rule = this.matchRules.get(path);
+    if (!rule) {
+      return false;
+    }
+
+    // Wildcard: accept any value
+    if (rule === '*') {
+      return true;
+    }
+
+    // Regex pattern
+    if (rule.startsWith('regex:')) {
+      const pattern = rule.slice(6);
+      try {
+        const regex = new RegExp(pattern);
+        return regex.test(String(value));
+      } catch {
+        return false;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Gets the type of a value for comparison.
+   */
+  private getType(value: unknown): string {
+    if (value === null) {
+      return 'null';
+    }
+    if (value === undefined) {
+      return 'undefined';
+    }
+    if (Array.isArray(value)) {
+      return 'array';
+    }
+    return typeof value;
+  }
+}