@curl-runner/cli 1.13.0 → 1.15.0

package/src/diff/baseline-manager.test.ts

@@ -0,0 +1,181 @@
+import { describe, expect, test } from 'bun:test';
+import type { ExecutionResult } from '../types/config';
+import { BaselineManager } from './baseline-manager';
+
+describe('BaselineManager', () => {
+  describe('getBaselinePath', () => {
+    test('should generate correct baseline path', () => {
+      const manager = new BaselineManager({});
+      expect(manager.getBaselinePath('tests/api.yaml', 'staging')).toBe(
+        'tests/__baselines__/api.staging.baseline.json',
+      );
+    });
+
+    test('should use custom directory', () => {
+      const manager = new BaselineManager({ dir: '.baselines' });
+      expect(manager.getBaselinePath('api.yaml', 'prod')).toBe('.baselines/api.prod.baseline.json');
+    });
+
+    test('should handle nested paths', () => {
+      const manager = new BaselineManager({});
+      expect(manager.getBaselinePath('tests/integration/users.yaml', 'staging')).toBe(
+        'tests/integration/__baselines__/users.staging.baseline.json',
+      );
+    });
+
+    test('should handle labels with special characters', () => {
+      const manager = new BaselineManager({});
+      expect(manager.getBaselinePath('api.yaml', 'v1.0.0')).toBe(
+        '__baselines__/api.v1.0.0.baseline.json',
+      );
+    });
+  });
+
+  describe('getBaselineDir', () => {
+    test('should return correct directory', () => {
+      const manager = new BaselineManager({});
+      expect(manager.getBaselineDir('tests/api.yaml')).toBe('tests/__baselines__');
+    });
+
+    test('should use custom directory', () => {
+      const manager = new BaselineManager({ dir: 'snapshots' });
+      expect(manager.getBaselineDir('api.yaml')).toBe('snapshots');
+    });
+  });
+
+  describe('createBaseline', () => {
+    const mockResult: ExecutionResult = {
+      request: { url: 'https://api.example.com', name: 'Get Users' },
+      success: true,
+      status: 200,
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Request-Id': 'abc123',
+      },
+      body: {
+        id: 1,
+        name: 'Test',
+        timestamp: '2024-01-01',
+      },
+      metrics: {
+        duration: 150,
+      },
+    };
+
+    test('should create baseline with all fields', () => {
+      const manager = new BaselineManager({});
+      const baseline = manager.createBaseline(mockResult, {});
+
+      expect(baseline.status).toBe(200);
+      expect(baseline.body).toEqual(mockResult.body);
+      expect(baseline.headers).toBeDefined();
+      expect(baseline.hash).toBeDefined();
+      expect(baseline.capturedAt).toBeDefined();
+      expect(baseline.timing).toBeUndefined();
+    });
+
+    test('should include timing when configured', () => {
+      const manager = new BaselineManager({});
+      const baseline = manager.createBaseline(mockResult, { includeTimings: true });
+
+      expect(baseline.timing).toBe(150);
+    });
+
+    test('should normalize headers (lowercase, sorted)', () => {
+      const manager = new BaselineManager({});
+      const baseline = manager.createBaseline(mockResult, {});
+
+      expect(baseline.headers).toEqual({
+        'content-type': 'application/json',
+        'x-request-id': 'abc123',
+      });
+    });
+  });
+
+  describe('hash', () => {
+    test('should generate consistent hashes', () => {
+      const manager = new BaselineManager({});
+      const content = { id: 1, name: 'test' };
+
+      const hash1 = manager.hash(content);
+      const hash2 = manager.hash(content);
+
+      expect(hash1).toBe(hash2);
+    });
+
+    test('should generate different hashes for different content', () => {
+      const manager = new BaselineManager({});
+
+      const hash1 = manager.hash({ id: 1 });
+      const hash2 = manager.hash({ id: 2 });
+
+      expect(hash1).not.toBe(hash2);
+    });
+
+    test('should produce 8 character hash', () => {
+      const manager = new BaselineManager({});
+      const hash = manager.hash({ data: 'test' });
+
+      expect(hash).toHaveLength(8);
+    });
+  });
+
+  describe('mergeConfig', () => {
+    test('should return null if not enabled', () => {
+      const config = BaselineManager.mergeConfig({}, undefined);
+      expect(config).toBeNull();
+    });
+
+    test('should return null if explicitly disabled', () => {
+      const config = BaselineManager.mergeConfig({}, { enabled: false });
+      expect(config).toBeNull();
+    });
+
+    test('should handle boolean true', () => {
+      const config = BaselineManager.mergeConfig({}, true);
+      expect(config).toEqual({
+        enabled: true,
+        exclude: [],
+        match: {},
+        includeTimings: false,
+      });
+    });
+
+    test('should merge global and request excludes', () => {
+      const config = BaselineManager.mergeConfig(
+        { exclude: ['*.timestamp'] },
+        { enabled: true, exclude: ['body.id'] },
+      );
+      expect(config?.exclude).toEqual(['*.timestamp', 'body.id']);
+    });
+
+    test('should merge match rules', () => {
+      const config = BaselineManager.mergeConfig(
+        { match: { 'body.id': '*' } },
+        { enabled: true, match: { 'body.token': 'regex:^[a-z]+$' } },
+      );
+      expect(config?.match).toEqual({
+        'body.id': '*',
+        'body.token': 'regex:^[a-z]+$',
+      });
+    });
+
+    test('should use global enabled', () => {
+      const config = BaselineManager.mergeConfig({ enabled: true }, undefined);
+      expect(config?.enabled).toBe(true);
+    });
+
+    test('should inherit includeTimings from global', () => {
+      const config = BaselineManager.mergeConfig({ enabled: true, includeTimings: true }, true);
+      expect(config?.includeTimings).toBe(true);
+    });
+
+    test('should allow request to override includeTimings', () => {
+      const config = BaselineManager.mergeConfig(
+        { enabled: true, includeTimings: false },
+        { enabled: true, includeTimings: true },
+      );
+      expect(config?.includeTimings).toBe(true);
+    });
+  });
+});

package/src/diff/baseline-manager.ts

@@ -0,0 +1,266 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import type {
+  Baseline,
+  BaselineFile,
+  DiffConfig,
+  ExecutionResult,
+  GlobalDiffConfig,
+} from '../types/config';
+
+const BASELINE_VERSION = 1;
+const DEFAULT_BASELINE_DIR = '__baselines__';
+
+/**
+ * Manages baseline files: reading, writing, and listing.
+ */
+export class BaselineManager {
+  private baselineDir: string;
+  private writeLocks: Map<string, Promise<void>> = new Map();
+
+  constructor(globalConfig: GlobalDiffConfig = {}) {
+    this.baselineDir = globalConfig.dir || DEFAULT_BASELINE_DIR;
+  }
+
+  /**
+   * Gets the baseline file path for a label.
+   */
+  getBaselinePath(yamlPath: string, label: string): string {
+    const dir = path.dirname(yamlPath);
+    const basename = path.basename(yamlPath, path.extname(yamlPath));
+    return path.join(dir, this.baselineDir, `${basename}.${label}.baseline.json`);
+  }
+
+  /**
+   * Gets the baseline directory for a YAML file.
+   */
+  getBaselineDir(yamlPath: string): string {
+    return path.join(path.dirname(yamlPath), this.baselineDir);
+  }
+
+  /**
+   * Loads baseline file for a specific label.
+   */
+  async load(yamlPath: string, label: string): Promise<BaselineFile | null> {
+    const baselinePath = this.getBaselinePath(yamlPath, label);
+    try {
+      const file = Bun.file(baselinePath);
+      if (!(await file.exists())) {
+        return null;
+      }
+      const content = await file.text();
+      return JSON.parse(content) as BaselineFile;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Saves baseline file with write queue for parallel safety.
+   */
+  async save(yamlPath: string, label: string, data: BaselineFile): Promise<void> {
+    const baselinePath = this.getBaselinePath(yamlPath, label);
+
+    const existingLock = this.writeLocks.get(baselinePath);
+    const writePromise = (async () => {
+      if (existingLock) {
+        await existingLock;
+      }
+
+      const dir = path.dirname(baselinePath);
+      await fs.mkdir(dir, { recursive: true });
+
+      const content = JSON.stringify(data, null, 2);
+      await Bun.write(baselinePath, content);
+    })();
+
+    this.writeLocks.set(baselinePath, writePromise);
+    await writePromise;
+    this.writeLocks.delete(baselinePath);
+  }
+
+  /**
+   * Gets a single baseline by request name.
+   */
+  async get(yamlPath: string, label: string, requestName: string): Promise<Baseline | null> {
+    const file = await this.load(yamlPath, label);
+    return file?.baselines[requestName] || null;
+  }
+
+  /**
+   * Lists all available baseline labels for a YAML file.
+   */
+  async listLabels(yamlPath: string): Promise<string[]> {
+    const dir = this.getBaselineDir(yamlPath);
+    const basename = path.basename(yamlPath, path.extname(yamlPath));
+
+    try {
+      const files = await fs.readdir(dir);
+      const labels: string[] = [];
+
+      for (const file of files) {
+        const match = file.match(new RegExp(`^${basename}\\.(.+)\\.baseline\\.json$`));
+        if (match) {
+          labels.push(match[1]);
+        }
+      }
+
+      return labels.sort();
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Creates a baseline from execution result.
+   */
+  createBaseline(result: ExecutionResult, config: DiffConfig): Baseline {
+    const baseline: Baseline = {
+      hash: '',
+      capturedAt: new Date().toISOString(),
+    };
+
+    if (result.status !== undefined) {
+      baseline.status = result.status;
+    }
+
+    if (result.headers) {
+      baseline.headers = this.normalizeHeaders(result.headers);
+    }
+
+    if (result.body !== undefined) {
+      baseline.body = result.body;
+    }
+
+    if (config.includeTimings && result.metrics?.duration !== undefined) {
+      baseline.timing = result.metrics.duration;
+    }
+
+    baseline.hash = this.hash(baseline);
+
+    return baseline;
+  }
+
+  /**
+   * Normalizes headers for consistent comparison.
+   */
+  private normalizeHeaders(headers: Record<string, string>): Record<string, string> {
+    const normalized: Record<string, string> = {};
+    const sortedKeys = Object.keys(headers).sort();
+    for (const key of sortedKeys) {
+      normalized[key.toLowerCase()] = headers[key];
+    }
+    return normalized;
+  }
+
+  /**
+   * Generates a hash for baseline content.
+   */
+  hash(content: unknown): string {
+    const str = JSON.stringify(content);
+    const hasher = new Bun.CryptoHasher('md5');
+    hasher.update(str);
+    return hasher.digest('hex').slice(0, 8);
+  }
+
+  /**
+   * Saves execution results as a baseline.
+   */
+  async saveBaseline(
+    yamlPath: string,
+    label: string,
+    results: ExecutionResult[],
+    config: DiffConfig,
+  ): Promise<void> {
+    const baselines: Record<string, Baseline> = {};
+
+    for (const result of results) {
+      if (result.skipped || !result.success) {
+        continue;
+      }
+      const name = result.request.name || result.request.url;
+      baselines[name] = this.createBaseline(result, config);
+    }
+
+    const file: BaselineFile = {
+      version: BASELINE_VERSION,
+      label,
+      capturedAt: new Date().toISOString(),
+      baselines,
+    };
+
+    await this.save(yamlPath, label, file);
+  }
+
+  /**
+   * Deletes baselines older than specified days.
+   */
+  async cleanOldBaselines(yamlPath: string, olderThanDays: number): Promise<number> {
+    const dir = this.getBaselineDir(yamlPath);
+    const cutoff = Date.now() - olderThanDays * 24 * 60 * 60 * 1000;
+    let deleted = 0;
+
+    try {
+      const files = await fs.readdir(dir);
+
+      for (const file of files) {
+        if (!file.endsWith('.baseline.json')) {
+          continue;
+        }
+
+        const filePath = path.join(dir, file);
+        const stat = await fs.stat(filePath);
+
+        if (stat.mtimeMs < cutoff) {
+          await fs.unlink(filePath);
+          deleted++;
+        }
+      }
+    } catch {
+      // Directory doesn't exist or other error
+    }
+
+    return deleted;
+  }
+
+  /**
+   * Merges request-level config with global config.
+   */
+  static mergeConfig(
+    globalConfig: GlobalDiffConfig | undefined,
+    requestConfig: DiffConfig | boolean | undefined,
+  ): DiffConfig | null {
+    if (!requestConfig && !globalConfig?.enabled) {
+      return null;
+    }
+
+    if (requestConfig === true) {
+      return {
+        enabled: true,
+        exclude: globalConfig?.exclude || [],
+        match: globalConfig?.match || {},
+        includeTimings: globalConfig?.includeTimings || false,
+      };
+    }
+
+    if (typeof requestConfig === 'object' && requestConfig.enabled !== false) {
+      return {
+        enabled: true,
+        exclude: [...(globalConfig?.exclude || []), ...(requestConfig.exclude || [])],
+        match: { ...(globalConfig?.match || {}), ...(requestConfig.match || {}) },
+        includeTimings: requestConfig.includeTimings ?? globalConfig?.includeTimings ?? false,
+      };
+    }
+
+    if (globalConfig?.enabled && requestConfig === undefined) {
+      return {
+        enabled: true,
+        exclude: globalConfig.exclude || [],
+        match: globalConfig.match || {},
+        includeTimings: globalConfig.includeTimings || false,
+      };
+    }
+
+    return null;
+  }
+}