@curl-runner/cli 1.16.0 → 1.16.2

package/src/diff/response-differ.ts

@@ -1,489 +0,0 @@
-import type {
-  Baseline,
-  DiffCompareResult,
-  DiffConfig,
-  DiffSummary,
-  ExecutionResult,
-  GlobalDiffConfig,
-  JsonValue,
-  ResponseDiff,
-} from '../types/config';
-import { BaselineManager } from './baseline-manager';
-
-/**
- * Compares responses against baselines with support for exclusions and match rules.
- */
-export class ResponseDiffer {
-  private excludePaths: Set<string>;
-  private matchRules: Map<string, string>;
-  private includeTimings: boolean;
-
-  constructor(config: DiffConfig) {
-    this.excludePaths = new Set(config.exclude || []);
-    this.matchRules = new Map(Object.entries(config.match || {}));
-    this.includeTimings = config.includeTimings || false;
-  }
-
-  /**
-   * Compares current response against baseline.
-   */
-  compare(
-    baseline: Baseline,
-    current: Baseline,
-    baselineLabel: string,
-    currentLabel: string,
-    requestName: string,
-  ): DiffCompareResult {
-    const differences: ResponseDiff[] = [];
-
-    // Compare status
-    if (baseline.status !== undefined || current.status !== undefined) {
-      if (baseline.status !== current.status && !this.isExcluded('status')) {
-        differences.push({
-          path: 'status',
-          baseline: baseline.status,
-          current: current.status,
-          type: 'changed',
-        });
-      }
-    }
-
-    // Compare headers
-    if (baseline.headers || current.headers) {
-      const headerDiffs = this.compareObjects(
-        baseline.headers || {},
-        current.headers || {},
-        'headers',
-      );
-      differences.push(...headerDiffs);
-    }
-
-    // Compare body
-    if (baseline.body !== undefined || current.body !== undefined) {
-      const bodyDiffs = this.deepCompare(baseline.body, current.body, 'body');
-      differences.push(...bodyDiffs);
-    }
-
-    const result: DiffCompareResult = {
-      requestName,
-      hasDifferences: differences.length > 0,
-      isNewBaseline: false,
-      baselineLabel,
-      currentLabel,
-      differences,
-    };
-
-    // Add timing diff if enabled
-    if (this.includeTimings && baseline.timing !== undefined && current.timing !== undefined) {
-      const changePercent = ((current.timing - baseline.timing) / baseline.timing) * 100;
-      result.timingDiff = {
-        baseline: baseline.timing,
-        current: current.timing,
-        changePercent,
-      };
-    }
-
-    return result;
-  }
-
-  /**
-   * Deep comparison of two values with path tracking.
-   */
-  deepCompare(baseline: unknown, current: unknown, path: string): ResponseDiff[] {
-    if (this.isExcluded(path)) {
-      return [];
-    }
-
-    if (this.matchesRule(path, current)) {
-      return [];
-    }
-
-    if (baseline === null && current === null) {
-      return [];
-    }
-    if (baseline === undefined && current === undefined) {
-      return [];
-    }
-
-    const baselineType = this.getType(baseline);
-    const currentType = this.getType(current);
-
-    if (baselineType !== currentType) {
-      return [
-        {
-          path,
-          baseline,
-          current,
-          type: 'type_mismatch',
-        },
-      ];
-    }
-
-    if (baselineType !== 'object' && baselineType !== 'array') {
-      if (baseline !== current) {
-        return [
-          {
-            path,
-            baseline,
-            current,
-            type: 'changed',
-          },
-        ];
-      }
-      return [];
-    }
-
-    if (baselineType === 'array') {
-      return this.compareArrays(baseline as JsonValue[], current as JsonValue[], path);
-    }
-
-    return this.compareObjects(
-      baseline as Record<string, unknown>,
-      current as Record<string, unknown>,
-      path,
-    );
-  }
-
-  /**
-   * Compares two arrays.
-   */
-  private compareArrays(baseline: JsonValue[], current: JsonValue[], path: string): ResponseDiff[] {
-    const differences: ResponseDiff[] = [];
-    const maxLen = Math.max(baseline.length, current.length);
-
-    for (let i = 0; i < maxLen; i++) {
-      const itemPath = `${path}[${i}]`;
-
-      if (i >= baseline.length) {
-        if (!this.isExcluded(itemPath)) {
-          differences.push({
-            path: itemPath,
-            baseline: undefined,
-            current: current[i],
-            type: 'added',
-          });
-        }
-      } else if (i >= current.length) {
-        if (!this.isExcluded(itemPath)) {
-          differences.push({
-            path: itemPath,
-            baseline: baseline[i],
-            current: undefined,
-            type: 'removed',
-          });
-        }
-      } else {
-        const itemDiffs = this.deepCompare(baseline[i], current[i], itemPath);
-        differences.push(...itemDiffs);
-      }
-    }
-
-    return differences;
-  }
-
-  /**
-   * Compares two objects.
-   */
-  private compareObjects(
-    baseline: Record<string, unknown>,
-    current: Record<string, unknown>,
-    path: string,
-  ): ResponseDiff[] {
-    const differences: ResponseDiff[] = [];
-    const allKeys = new Set([...Object.keys(baseline), ...Object.keys(current)]);
-
-    for (const key of allKeys) {
-      const keyPath = path ? `${path}.${key}` : key;
-      const hasBaseline = key in baseline;
-      const hasCurrent = key in current;
-
-      if (!hasBaseline && hasCurrent) {
-        if (!this.isExcluded(keyPath)) {
-          differences.push({
-            path: keyPath,
-            baseline: undefined,
-            current: current[key],
-            type: 'added',
-          });
-        }
-      } else if (hasBaseline && !hasCurrent) {
-        if (!this.isExcluded(keyPath)) {
-          differences.push({
-            path: keyPath,
-            baseline: baseline[key],
-            current: undefined,
-            type: 'removed',
-          });
-        }
-      } else {
-        const keyDiffs = this.deepCompare(baseline[key], current[key], keyPath);
-        differences.push(...keyDiffs);
-      }
-    }
-
-    return differences;
-  }
-
-  /**
-   * Checks if a path should be excluded from comparison.
-   */
-  isExcluded(path: string): boolean {
-    if (this.excludePaths.has(path)) {
-      return true;
-    }
-
-    for (const pattern of this.excludePaths) {
-      if (pattern.startsWith('*.')) {
-        const suffix = pattern.slice(2);
-        if (path.endsWith(`.${suffix}`)) {
-          return true;
-        }
-        const lastPart = path.split('.').pop();
-        if (lastPart === suffix) {
-          return true;
-        }
-      }
-
-      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;
-    }
-
-    if (rule === '*') {
-      return true;
-    }
-
-    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;
-  }
-}
-
-/**
- * Orchestrates response diffing between runs.
- */
-export class DiffOrchestrator {
-  private manager: BaselineManager;
-
-  constructor(globalConfig: GlobalDiffConfig = {}) {
-    this.manager = new BaselineManager(globalConfig);
-  }
-
-  /**
-   * Compares execution results against a baseline.
-   */
-  async compareWithBaseline(
-    yamlPath: string,
-    results: ExecutionResult[],
-    currentLabel: string,
-    baselineLabel: string,
-    config: DiffConfig,
-  ): Promise<DiffSummary> {
-    const baselineFile = await this.manager.load(yamlPath, baselineLabel);
-    const diffResults: DiffCompareResult[] = [];
-
-    for (const result of results) {
-      if (result.skipped || !result.success) {
-        continue;
-      }
-
-      const requestName = result.request.name || result.request.url;
-      const currentBaseline = this.manager.createBaseline(result, config);
-
-      if (!baselineFile) {
-        // No baseline exists - mark as new
-        diffResults.push({
-          requestName,
-          hasDifferences: false,
-          isNewBaseline: true,
-          baselineLabel,
-          currentLabel,
-          differences: [],
-        });
-        continue;
-      }
-
-      const storedBaseline = baselineFile.baselines[requestName];
-
-      if (!storedBaseline) {
-        // Request not in baseline - mark as new
-        diffResults.push({
-          requestName,
-          hasDifferences: false,
-          isNewBaseline: true,
-          baselineLabel,
-          currentLabel,
-          differences: [],
-        });
-        continue;
-      }
-
-      const differ = new ResponseDiffer(config);
-      const compareResult = differ.compare(
-        storedBaseline,
-        currentBaseline,
-        baselineLabel,
-        currentLabel,
-        requestName,
-      );
-      diffResults.push(compareResult);
-    }
-
-    return {
-      totalRequests: diffResults.length,
-      unchanged: diffResults.filter((r) => !r.hasDifferences && !r.isNewBaseline).length,
-      changed: diffResults.filter((r) => r.hasDifferences).length,
-      newBaselines: diffResults.filter((r) => r.isNewBaseline).length,
-      results: diffResults,
-    };
-  }
-
-  /**
-   * Compares two stored baselines (offline comparison).
-   */
-  async compareTwoBaselines(
-    yamlPath: string,
-    label1: string,
-    label2: string,
-    config: DiffConfig,
-  ): Promise<DiffSummary> {
-    const file1 = await this.manager.load(yamlPath, label1);
-    const file2 = await this.manager.load(yamlPath, label2);
-
-    if (!file1) {
-      throw new Error(`Baseline '${label1}' not found`);
-    }
-    if (!file2) {
-      throw new Error(`Baseline '${label2}' not found`);
-    }
-
-    const allRequestNames = new Set([
-      ...Object.keys(file1.baselines),
-      ...Object.keys(file2.baselines),
-    ]);
-
-    const diffResults: DiffCompareResult[] = [];
-    const differ = new ResponseDiffer(config);
-
-    for (const requestName of allRequestNames) {
-      const baseline1 = file1.baselines[requestName];
-      const baseline2 = file2.baselines[requestName];
-
-      if (!baseline1) {
-        diffResults.push({
-          requestName,
-          hasDifferences: true,
-          isNewBaseline: false,
-          baselineLabel: label1,
-          currentLabel: label2,
-          differences: [
-            {
-              path: '',
-              baseline: undefined,
-              current: 'exists',
-              type: 'added',
-            },
-          ],
-        });
-        continue;
-      }
-
-      if (!baseline2) {
-        diffResults.push({
-          requestName,
-          hasDifferences: true,
-          isNewBaseline: false,
-          baselineLabel: label1,
-          currentLabel: label2,
-          differences: [
-            {
-              path: '',
-              baseline: 'exists',
-              current: undefined,
-              type: 'removed',
-            },
-          ],
-        });
-        continue;
-      }
-
-      const compareResult = differ.compare(baseline1, baseline2, label1, label2, requestName);
-      diffResults.push(compareResult);
-    }
-
-    return {
-      totalRequests: diffResults.length,
-      unchanged: diffResults.filter((r) => !r.hasDifferences).length,
-      changed: diffResults.filter((r) => r.hasDifferences).length,
-      newBaselines: 0,
-      results: diffResults,
-    };
-  }
-
-  /**
-   * Saves current results as baseline.
-   */
-  async saveBaseline(
-    yamlPath: string,
-    label: string,
-    results: ExecutionResult[],
-    config: DiffConfig,
-  ): Promise<void> {
-    await this.manager.saveBaseline(yamlPath, label, results, config);
-  }
-
-  /**
-   * Lists available baseline labels.
-   */
-  async listLabels(yamlPath: string): Promise<string[]> {
-    return this.manager.listLabels(yamlPath);
-  }
-
-  /**
-   * Gets the baseline manager instance.
-   */
-  getManager(): BaselineManager {
-    return this.manager;
-  }
-}

package/src/executor/max-concurrency.test.ts

@@ -1,139 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import type { GlobalConfig, RequestConfig } from '../types/config';
-
-/**
- * Simulates the chunked execution logic from executeParallel
- * Returns the chunks that would be created based on maxConcurrency
- */
-function getExecutionChunks(
-  requests: RequestConfig[],
-  maxConcurrency: number | undefined,
-): RequestConfig[][] {
-  if (!maxConcurrency || maxConcurrency >= requests.length) {
-    return [requests]; // All requests in a single batch
-  }
-
-  const chunks: RequestConfig[][] = [];
-  for (let i = 0; i < requests.length; i += maxConcurrency) {
-    chunks.push(requests.slice(i, i + maxConcurrency));
-  }
-  return chunks;
-}
-
-/**
- * Creates mock requests for testing
- */
-function createMockRequests(count: number): RequestConfig[] {
-  return Array.from({ length: count }, (_, i) => ({
-    url: `https://api.example.com/request/${i + 1}`,
-    method: 'GET' as const,
-    name: `Request ${i + 1}`,
-  }));
-}
-
-describe('maxConcurrency parallel execution', () => {
-  describe('chunk creation', () => {
-    test('should execute all requests at once when maxConcurrency is not set', () => {
-      const requests = createMockRequests(10);
-      const chunks = getExecutionChunks(requests, undefined);
-      expect(chunks).toHaveLength(1);
-      expect(chunks[0]).toHaveLength(10);
-    });
-
-    test('should execute all requests at once when maxConcurrency >= requests.length', () => {
-      const requests = createMockRequests(5);
-      const chunks = getExecutionChunks(requests, 10);
-      expect(chunks).toHaveLength(1);
-      expect(chunks[0]).toHaveLength(5);
-    });
-
-    test('should create correct chunks when maxConcurrency is 1', () => {
-      const requests = createMockRequests(3);
-      const chunks = getExecutionChunks(requests, 1);
-      expect(chunks).toHaveLength(3);
-      expect(chunks[0]).toHaveLength(1);
-      expect(chunks[1]).toHaveLength(1);
-      expect(chunks[2]).toHaveLength(1);
-    });
-
-    test('should create correct chunks when maxConcurrency is 2', () => {
-      const requests = createMockRequests(5);
-      const chunks = getExecutionChunks(requests, 2);
-      expect(chunks).toHaveLength(3);
-      expect(chunks[0]).toHaveLength(2);
-      expect(chunks[1]).toHaveLength(2);
-      expect(chunks[2]).toHaveLength(1);
-    });
-
-    test('should create correct chunks when maxConcurrency is 3', () => {
-      const requests = createMockRequests(10);
-      const chunks = getExecutionChunks(requests, 3);
-      expect(chunks).toHaveLength(4);
-      expect(chunks[0]).toHaveLength(3);
-      expect(chunks[1]).toHaveLength(3);
-      expect(chunks[2]).toHaveLength(3);
-      expect(chunks[3]).toHaveLength(1);
-    });
-
-    test('should handle edge case with maxConcurrency equal to requests length', () => {
-      const requests = createMockRequests(5);
-      const chunks = getExecutionChunks(requests, 5);
-      expect(chunks).toHaveLength(1);
-      expect(chunks[0]).toHaveLength(5);
-    });
-
-    test('should preserve request order across chunks', () => {
-      const requests = createMockRequests(6);
-      const chunks = getExecutionChunks(requests, 2);
-
-      // Verify order is preserved
-      expect(chunks[0][0].name).toBe('Request 1');
-      expect(chunks[0][1].name).toBe('Request 2');
-      expect(chunks[1][0].name).toBe('Request 3');
-      expect(chunks[1][1].name).toBe('Request 4');
-      expect(chunks[2][0].name).toBe('Request 5');
-      expect(chunks[2][1].name).toBe('Request 6');
-    });
-  });
-
-  describe('GlobalConfig maxConcurrency validation', () => {
-    test('should accept valid maxConcurrency values', () => {
-      const config1: GlobalConfig = { execution: 'parallel', maxConcurrency: 1 };
-      expect(config1.maxConcurrency).toBe(1);
-
-      const config2: GlobalConfig = { execution: 'parallel', maxConcurrency: 5 };
-      expect(config2.maxConcurrency).toBe(5);
-
-      const config3: GlobalConfig = { execution: 'parallel', maxConcurrency: 100 };
-      expect(config3.maxConcurrency).toBe(100);
-    });
-
-    test('should allow undefined maxConcurrency', () => {
-      const config: GlobalConfig = { execution: 'parallel' };
-      expect(config.maxConcurrency).toBeUndefined();
-    });
-  });
-
-  describe('integration with other settings', () => {
-    test('maxConcurrency should coexist with continueOnError', () => {
-      const config: GlobalConfig = {
-        execution: 'parallel',
-        maxConcurrency: 5,
-        continueOnError: true,
-      };
-      expect(config.maxConcurrency).toBe(5);
-      expect(config.continueOnError).toBe(true);
-    });
-
-    test('maxConcurrency should coexist with CI settings', () => {
-      const config: GlobalConfig = {
-        execution: 'parallel',
-        maxConcurrency: 3,
-        ci: { strictExit: true, failOn: 2 },
-      };
-      expect(config.maxConcurrency).toBe(3);
-      expect(config.ci?.strictExit).toBe(true);
-      expect(config.ci?.failOn).toBe(2);
-    });
-  });
-});