@curl-runner/cli 1.16.0 → 1.16.2

package/src/utils/response-store.test.ts

@@ -1,213 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import type { ExecutionResult } from '../types/config';
-import {
-  createStoreContext,
-  extractStoreValues,
-  getValueByPath,
-  mergeStoreContext,
-  valueToString,
-} from './response-store';
-
-describe('getValueByPath', () => {
-  const testObj = {
-    status: 200,
-    body: {
-      id: 123,
-      user: {
-        name: 'John',
-        email: 'john@example.com',
-      },
-      items: [
-        { id: 1, name: 'Item 1' },
-        { id: 2, name: 'Item 2' },
-      ],
-    },
-    headers: {
-      'content-type': 'application/json',
-      'x-request-id': 'abc123',
-    },
-  };
-
-  test('should get top-level value', () => {
-    expect(getValueByPath(testObj, 'status')).toBe(200);
-  });
-
-  test('should get nested value', () => {
-    expect(getValueByPath(testObj, 'body.id')).toBe(123);
-    expect(getValueByPath(testObj, 'body.user.name')).toBe('John');
-    expect(getValueByPath(testObj, 'body.user.email')).toBe('john@example.com');
-  });
-
-  test('should get header value', () => {
-    expect(getValueByPath(testObj, 'headers.content-type')).toBe('application/json');
-    expect(getValueByPath(testObj, 'headers.x-request-id')).toBe('abc123');
-  });
-
-  test('should get array element by index', () => {
-    expect(getValueByPath(testObj, 'body.items.0.id')).toBe(1);
-    expect(getValueByPath(testObj, 'body.items.1.name')).toBe('Item 2');
-  });
-
-  test('should get array element using bracket notation', () => {
-    expect(getValueByPath(testObj, 'body.items[0].id')).toBe(1);
-    expect(getValueByPath(testObj, 'body.items[1].name')).toBe('Item 2');
-  });
-
-  test('should return undefined for non-existent path', () => {
-    expect(getValueByPath(testObj, 'body.nonexistent')).toBeUndefined();
-    expect(getValueByPath(testObj, 'body.user.age')).toBeUndefined();
-    expect(getValueByPath(testObj, 'nonexistent.path')).toBeUndefined();
-  });
-
-  test('should return undefined for null or undefined object', () => {
-    expect(getValueByPath(null, 'any.path')).toBeUndefined();
-    expect(getValueByPath(undefined, 'any.path')).toBeUndefined();
-  });
-
-  test('should handle primitive values correctly', () => {
-    expect(getValueByPath('string', 'length')).toBeUndefined();
-    expect(getValueByPath(123, 'toString')).toBeUndefined();
-  });
-});
-
-describe('valueToString', () => {
-  test('should convert string to string', () => {
-    expect(valueToString('hello')).toBe('hello');
-  });
-
-  test('should convert number to string', () => {
-    expect(valueToString(123)).toBe('123');
-    expect(valueToString(45.67)).toBe('45.67');
-  });
-
-  test('should convert boolean to string', () => {
-    expect(valueToString(true)).toBe('true');
-    expect(valueToString(false)).toBe('false');
-  });
-
-  test('should convert null and undefined to empty string', () => {
-    expect(valueToString(null)).toBe('');
-    expect(valueToString(undefined)).toBe('');
-  });
-
-  test('should JSON stringify objects', () => {
-    expect(valueToString({ a: 1 })).toBe('{"a":1}');
-  });
-
-  test('should JSON stringify arrays', () => {
-    expect(valueToString([1, 2, 3])).toBe('[1,2,3]');
-  });
-});
-
-describe('extractStoreValues', () => {
-  const mockResult: ExecutionResult = {
-    request: {
-      url: 'https://api.example.com/users',
-      method: 'POST',
-    },
-    success: true,
-    status: 201,
-    headers: {
-      'content-type': 'application/json',
-      'x-request-id': 'req-12345',
-    },
-    body: {
-      id: 456,
-      data: {
-        token: 'jwt-token-here',
-        user: {
-          id: 789,
-          name: 'Test User',
-        },
-      },
-    },
-    metrics: {
-      duration: 150,
-      size: 1024,
-    },
-  };
-
-  test('should extract status', () => {
-    const result = extractStoreValues(mockResult, {
-      statusCode: 'status',
-    });
-    expect(result.statusCode).toBe('201');
-  });
-
-  test('should extract body fields', () => {
-    const result = extractStoreValues(mockResult, {
-      userId: 'body.id',
-      token: 'body.data.token',
-      userName: 'body.data.user.name',
-    });
-    expect(result.userId).toBe('456');
-    expect(result.token).toBe('jwt-token-here');
-    expect(result.userName).toBe('Test User');
-  });
-
-  test('should extract header values', () => {
-    const result = extractStoreValues(mockResult, {
-      contentType: 'headers.content-type',
-      requestId: 'headers.x-request-id',
-    });
-    expect(result.contentType).toBe('application/json');
-    expect(result.requestId).toBe('req-12345');
-  });
-
-  test('should extract metrics', () => {
-    const result = extractStoreValues(mockResult, {
-      duration: 'metrics.duration',
-    });
-    expect(result.duration).toBe('150');
-  });
-
-  test('should handle non-existent paths', () => {
-    const result = extractStoreValues(mockResult, {
-      missing: 'body.nonexistent',
-    });
-    expect(result.missing).toBe('');
-  });
-
-  test('should extract multiple values', () => {
-    const result = extractStoreValues(mockResult, {
-      id: 'body.id',
-      status: 'status',
-      contentType: 'headers.content-type',
-    });
-    expect(result.id).toBe('456');
-    expect(result.status).toBe('201');
-    expect(result.contentType).toBe('application/json');
-  });
-});
-
-describe('createStoreContext', () => {
-  test('should create empty context', () => {
-    const context = createStoreContext();
-    expect(context).toEqual({});
-  });
-});
-
-describe('mergeStoreContext', () => {
-  test('should merge contexts', () => {
-    const existing = { a: '1', b: '2' };
-    const newValues = { c: '3', d: '4' };
-    const merged = mergeStoreContext(existing, newValues);
-    expect(merged).toEqual({ a: '1', b: '2', c: '3', d: '4' });
-  });
-
-  test('should override existing values', () => {
-    const existing = { a: '1', b: '2' };
-    const newValues = { b: 'new', c: '3' };
-    const merged = mergeStoreContext(existing, newValues);
-    expect(merged).toEqual({ a: '1', b: 'new', c: '3' });
-  });
-
-  test('should not mutate original contexts', () => {
-    const existing = { a: '1' };
-    const newValues = { b: '2' };
-    const merged = mergeStoreContext(existing, newValues);
-    expect(existing).toEqual({ a: '1' });
-    expect(newValues).toEqual({ b: '2' });
-    expect(merged).toEqual({ a: '1', b: '2' });
-  });
-});

package/src/utils/response-store.ts

@@ -1,108 +0,0 @@
-import type { ExecutionResult, ResponseStoreContext, StoreConfig } from '../types/config';
-
-/**
- * Extracts a value from an object using a dot-notation path.
- * Supports paths like: "body.id", "body.data.token", "headers.content-type", "status"
- *
- * @param obj - The object to extract from
- * @param path - Dot-notation path to the value
- * @returns The extracted value or undefined if not found
- */
-export function getValueByPath(obj: unknown, path: string): unknown {
-  const parts = path.split('.');
-  let current: unknown = obj;
-
-  for (const part of parts) {
-    if (current === null || current === undefined) {
-      return undefined;
-    }
-
-    if (typeof current !== 'object') {
-      return undefined;
-    }
-
-    // Handle array index access like "items.0.id" or "items[0].id"
-    const arrayMatch = part.match(/^(\w+)\[(\d+)\]$/);
-    if (arrayMatch) {
-      const [, key, indexStr] = arrayMatch;
-      const index = Number.parseInt(indexStr, 10);
-      current = (current as Record<string, unknown>)[key];
-      if (Array.isArray(current)) {
-        current = current[index];
-      } else {
-        return undefined;
-      }
-    } else if (/^\d+$/.test(part) && Array.isArray(current)) {
-      // Direct numeric index for arrays
-      current = current[Number.parseInt(part, 10)];
-    } else {
-      current = (current as Record<string, unknown>)[part];
-    }
-  }
-
-  return current;
-}
-
-/**
- * Converts a value to a string for storage.
- * Objects and arrays are JSON stringified.
- */
-export function valueToString(value: unknown): string {
-  if (value === undefined || value === null) {
-    return '';
-  }
-  if (typeof value === 'string') {
-    return value;
-  }
-  if (typeof value === 'number' || typeof value === 'boolean') {
-    return String(value);
-  }
-  return JSON.stringify(value);
-}
-
-/**
- * Extracts values from an execution result based on the store configuration.
- *
- * @param result - The execution result to extract from
- * @param storeConfig - Configuration mapping variable names to JSON paths
- * @returns Object containing the extracted values as strings
- */
-export function extractStoreValues(
-  result: ExecutionResult,
-  storeConfig: StoreConfig,
-): ResponseStoreContext {
-  const extracted: ResponseStoreContext = {};
-
-  // Build an object that represents the full response structure
-  const responseObj: Record<string, unknown> = {
-    status: result.status,
-    headers: result.headers || {},
-    body: result.body,
-    metrics: result.metrics,
-  };
-
-  for (const [varName, path] of Object.entries(storeConfig)) {
-    const value = getValueByPath(responseObj, path);
-    extracted[varName] = valueToString(value);
-  }
-
-  return extracted;
-}
-
-/**
- * Creates a new response store context.
- */
-export function createStoreContext(): ResponseStoreContext {
-  return {};
-}
-
-/**
- * Merges new values into an existing store context.
- * New values override existing ones with the same key.
- */
-export function mergeStoreContext(
-  existing: ResponseStoreContext,
-  newValues: ResponseStoreContext,
-): ResponseStoreContext {
-  return { ...existing, ...newValues };
-}

package/src/utils/stats.test.ts

@@ -1,161 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import {
-  calculateMean,
-  calculatePercentile,
-  calculateProfileStats,
-  calculateStdDev,
-  exportToCSV,
-  exportToJSON,
-  generateHistogram,
-} from './stats';
-
-describe('calculatePercentile', () => {
-  test('returns 0 for empty array', () => {
-    expect(calculatePercentile([], 50)).toBe(0);
-  });
-
-  test('returns single value for array of 1', () => {
-    expect(calculatePercentile([100], 50)).toBe(100);
-    expect(calculatePercentile([100], 99)).toBe(100);
-  });
-
-  test('calculates p50 (median) correctly', () => {
-    expect(calculatePercentile([1, 2, 3, 4, 5], 50)).toBe(3);
-    expect(calculatePercentile([1, 2, 3, 4], 50)).toBe(2.5);
-  });
-
-  test('calculates p95 correctly', () => {
-    const values = Array.from({ length: 100 }, (_, i) => i + 1);
-    expect(calculatePercentile(values, 95)).toBeCloseTo(95.05, 1);
-  });
-
-  test('calculates p99 correctly', () => {
-    const values = Array.from({ length: 100 }, (_, i) => i + 1);
-    expect(calculatePercentile(values, 99)).toBeCloseTo(99.01, 1);
-  });
-
-  test('handles unsorted input (requires pre-sorting)', () => {
-    // Note: function expects sorted input
-    const sorted = [10, 20, 30, 40, 50].sort((a, b) => a - b);
-    expect(calculatePercentile(sorted, 50)).toBe(30);
-  });
-});
-
-describe('calculateMean', () => {
-  test('returns 0 for empty array', () => {
-    expect(calculateMean([])).toBe(0);
-  });
-
-  test('calculates mean correctly', () => {
-    expect(calculateMean([1, 2, 3, 4, 5])).toBe(3);
-    expect(calculateMean([10, 20, 30])).toBe(20);
-    expect(calculateMean([100])).toBe(100);
-  });
-});
-
-describe('calculateStdDev', () => {
-  test('returns 0 for empty array', () => {
-    expect(calculateStdDev([], 0)).toBe(0);
-  });
-
-  test('returns 0 for single value', () => {
-    expect(calculateStdDev([100], 100)).toBe(0);
-  });
-
-  test('calculates standard deviation correctly', () => {
-    const values = [2, 4, 4, 4, 5, 5, 7, 9];
-    const mean = calculateMean(values);
-    expect(calculateStdDev(values, mean)).toBeCloseTo(2, 0);
-  });
-});
-
-describe('calculateProfileStats', () => {
-  test('calculates stats correctly with no warmup', () => {
-    const timings = [10, 20, 30, 40, 50];
-    const stats = calculateProfileStats(timings, 0, 0);
-
-    expect(stats.iterations).toBe(5);
-    expect(stats.warmup).toBe(0);
-    expect(stats.min).toBe(10);
-    expect(stats.max).toBe(50);
-    expect(stats.mean).toBe(30);
-    expect(stats.failures).toBe(0);
-    expect(stats.failureRate).toBe(0);
-  });
-
-  test('excludes warmup iterations from stats', () => {
-    const timings = [100, 10, 20, 30, 40]; // First value is warmup outlier
-    const stats = calculateProfileStats(timings, 1, 0);
-
-    expect(stats.iterations).toBe(4);
-    expect(stats.warmup).toBe(1);
-    expect(stats.min).toBe(10);
-    expect(stats.max).toBe(40);
-    expect(stats.mean).toBe(25);
-  });
-
-  test('calculates failure rate correctly', () => {
-    const timings = [10, 20, 30];
-    const stats = calculateProfileStats(timings, 0, 2);
-
-    expect(stats.failures).toBe(2);
-    expect(stats.failureRate).toBeCloseTo(66.67, 1);
-  });
-
-  test('handles empty timings', () => {
-    const stats = calculateProfileStats([], 0, 0);
-
-    expect(stats.iterations).toBe(0);
-    expect(stats.min).toBe(0);
-    expect(stats.max).toBe(0);
-    expect(stats.mean).toBe(0);
-  });
-});
-
-describe('generateHistogram', () => {
-  test('returns "No data" for empty array', () => {
-    const result = generateHistogram([]);
-    expect(result).toEqual(['No data']);
-  });
-
-  test('generates histogram with correct bucket count', () => {
-    const timings = Array.from({ length: 100 }, (_, i) => i);
-    const result = generateHistogram(timings, 5, 20);
-
-    expect(result.length).toBe(5);
-  });
-
-  test('histogram lines contain bucket ranges', () => {
-    const timings = [10, 20, 30, 40, 50];
-    const result = generateHistogram(timings, 2, 10);
-
-    expect(result[0]).toContain('ms -');
-    expect(result[0]).toContain('ms │');
-  });
-});
-
-describe('exportToCSV', () => {
-  test('exports stats to CSV format', () => {
-    const stats = calculateProfileStats([10, 20, 30], 0, 0);
-    const csv = exportToCSV(stats, 'Test Request');
-
-    expect(csv).toContain('iteration,latency_ms');
-    expect(csv).toContain('1,10');
-    expect(csv).toContain('2,20');
-    expect(csv).toContain('3,30');
-  });
-});
-
-describe('exportToJSON', () => {
-  test('exports stats to JSON format', () => {
-    const stats = calculateProfileStats([10, 20, 30], 0, 0);
-    const json = exportToJSON(stats, 'Test Request');
-    const parsed = JSON.parse(json);
-
-    expect(parsed.request).toBe('Test Request');
-    expect(parsed.summary.iterations).toBe(3);
-    expect(parsed.summary.min).toBe(10);
-    expect(parsed.summary.max).toBe(30);
-    expect(parsed.timings).toEqual([10, 20, 30]);
-  });
-});

package/src/utils/stats.ts

@@ -1,151 +0,0 @@
-import type { ProfileStats } from '../types/config';
-
-/**
- * Calculate percentile from sorted array.
- * Uses linear interpolation for non-integer indices.
- */
-export function calculatePercentile(sorted: number[], percentile: number): number {
-  if (sorted.length === 0) {
-    return 0;
-  }
-  if (sorted.length === 1) {
-    return sorted[0];
-  }
-
-  const index = (percentile / 100) * (sorted.length - 1);
-  const lower = Math.floor(index);
-  const upper = Math.ceil(index);
-  const fraction = index - lower;
-
-  if (lower === upper) {
-    return sorted[lower];
-  }
-  return sorted[lower] * (1 - fraction) + sorted[upper] * fraction;
-}
-
-/**
- * Calculate arithmetic mean.
- */
-export function calculateMean(values: number[]): number {
-  if (values.length === 0) {
-    return 0;
-  }
-  return values.reduce((sum, v) => sum + v, 0) / values.length;
-}
-
-/**
- * Calculate standard deviation.
- */
-export function calculateStdDev(values: number[], mean: number): number {
-  if (values.length <= 1) {
-    return 0;
-  }
-  const squaredDiffs = values.map((v) => (v - mean) ** 2);
-  const variance = squaredDiffs.reduce((sum, v) => sum + v, 0) / values.length;
-  return Math.sqrt(variance);
-}
-
-/**
- * Calculate profile statistics from raw timings.
- */
-export function calculateProfileStats(
-  timings: number[],
-  warmup: number,
-  failures: number,
-): ProfileStats {
-  // Exclude warmup iterations
-  const effectiveTimings = timings.slice(warmup);
-  const sorted = [...effectiveTimings].sort((a, b) => a - b);
-
-  const mean = calculateMean(sorted);
-  const totalIterations = timings.length;
-  const effectiveIterations = effectiveTimings.length;
-
-  return {
-    iterations: effectiveIterations,
-    warmup,
-    min: sorted.length > 0 ? sorted[0] : 0,
-    max: sorted.length > 0 ? sorted[sorted.length - 1] : 0,
-    mean: Math.round(mean * 100) / 100,
-    median: Math.round(calculatePercentile(sorted, 50) * 100) / 100,
-    p50: Math.round(calculatePercentile(sorted, 50) * 100) / 100,
-    p95: Math.round(calculatePercentile(sorted, 95) * 100) / 100,
-    p99: Math.round(calculatePercentile(sorted, 99) * 100) / 100,
-    stdDev: Math.round(calculateStdDev(sorted, mean) * 100) / 100,
-    failures,
-    failureRate: totalIterations > 0 ? Math.round((failures / totalIterations) * 10000) / 100 : 0,
-    timings: effectiveTimings,
-  };
-}
-
-/**
- * Generate ASCII histogram for latency distribution.
- */
-export function generateHistogram(timings: number[], buckets = 10, width = 40): string[] {
-  if (timings.length === 0) {
-    return ['No data'];
-  }
-
-  const min = Math.min(...timings);
-  const max = Math.max(...timings);
-  const range = max - min || 1;
-  const bucketSize = range / buckets;
-
-  // Count values per bucket
-  const counts = new Array(buckets).fill(0);
-  for (const t of timings) {
-    const bucket = Math.min(Math.floor((t - min) / bucketSize), buckets - 1);
-    counts[bucket]++;
-  }
-
-  const maxCount = Math.max(...counts);
-  const lines: string[] = [];
-
-  for (let i = 0; i < buckets; i++) {
-    const bucketMin = min + i * bucketSize;
-    const bucketMax = min + (i + 1) * bucketSize;
-    const barLength = maxCount > 0 ? Math.round((counts[i] / maxCount) * width) : 0;
-    const bar = '█'.repeat(barLength);
-    const label = `${bucketMin.toFixed(0).padStart(6)}ms - ${bucketMax.toFixed(0).padStart(6)}ms`;
-    lines.push(`${label} │${bar} ${counts[i]}`);
-  }
-
-  return lines;
-}
-
-/**
- * Export stats to CSV format.
- */
-export function exportToCSV(stats: ProfileStats, _requestName: string): string {
-  const headers = ['iteration', 'latency_ms'];
-  const rows = stats.timings.map((t, i) => `${i + 1},${t}`);
-  return [headers.join(','), ...rows].join('\n');
-}
-
-/**
- * Export stats to JSON format.
- */
-export function exportToJSON(stats: ProfileStats, requestName: string): string {
-  return JSON.stringify(
-    {
-      request: requestName,
-      summary: {
-        iterations: stats.iterations,
-        warmup: stats.warmup,
-        failures: stats.failures,
-        failureRate: stats.failureRate,
-        min: stats.min,
-        max: stats.max,
-        mean: stats.mean,
-        median: stats.median,
-        p50: stats.p50,
-        p95: stats.p95,
-        p99: stats.p99,
-        stdDev: stats.stdDev,
-      },
-      timings: stats.timings,
-    },
-    null,
-    2,
-  );
-}