@curl-runner/cli 1.16.0 → 1.16.2

package/src/executor/profile-executor.test.ts

@@ -1,132 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import type { ProfileConfig } from '../types/config';
-import { calculateProfileStats } from '../utils/stats';
-
-/**
- * Test the profile stats calculation logic used by ProfileExecutor.
- * Actual HTTP execution is tested via integration tests.
- */
-
-describe('Profile Stats Integration', () => {
-  test('stats calculation matches expected ProfileResult structure', () => {
-    const timings = [50, 55, 60, 65, 70, 75, 80, 85, 90, 95];
-    const warmup = 2;
-    const failures = 0;
-
-    const stats = calculateProfileStats(timings, warmup, failures);
-
-    // Verify all ProfileStats fields are present
-    expect(stats).toHaveProperty('iterations');
-    expect(stats).toHaveProperty('warmup');
-    expect(stats).toHaveProperty('min');
-    expect(stats).toHaveProperty('max');
-    expect(stats).toHaveProperty('mean');
-    expect(stats).toHaveProperty('median');
-    expect(stats).toHaveProperty('p50');
-    expect(stats).toHaveProperty('p95');
-    expect(stats).toHaveProperty('p99');
-    expect(stats).toHaveProperty('stdDev');
-    expect(stats).toHaveProperty('failures');
-    expect(stats).toHaveProperty('failureRate');
-    expect(stats).toHaveProperty('timings');
-
-    // Verify warmup exclusion
-    expect(stats.iterations).toBe(8); // 10 - 2 warmup
-    expect(stats.warmup).toBe(2);
-    expect(stats.timings.length).toBe(8);
-  });
-
-  test('profile config defaults are applied correctly', () => {
-    const defaultConfig: ProfileConfig = {
-      iterations: 10,
-      warmup: 1,
-      concurrency: 1,
-      histogram: false,
-    };
-
-    expect(defaultConfig.iterations).toBe(10);
-    expect(defaultConfig.warmup).toBe(1);
-    expect(defaultConfig.concurrency).toBe(1);
-    expect(defaultConfig.histogram).toBe(false);
-  });
-
-  test('concurrent config changes iterations behavior', () => {
-    const _sequentialConfig: ProfileConfig = {
-      iterations: 100,
-      concurrency: 1,
-    };
-
-    const concurrentConfig: ProfileConfig = {
-      iterations: 100,
-      concurrency: 10,
-    };
-
-    // With concurrency 10, iterations should be chunked into 10 parallel batches
-    const expectedChunks = Math.ceil(concurrentConfig.iterations / concurrentConfig.concurrency!);
-    expect(expectedChunks).toBe(10);
-  });
-
-  test('failure tracking affects failureRate calculation', () => {
-    const timings = [10, 20, 30, 40, 50];
-    const failures = 2;
-
-    const stats = calculateProfileStats(timings, 0, failures);
-
-    // 2 failures out of 5 total (timings) + 2 failures = 7 total iterations
-    // But failures are tracked separately, so failureRate = 2/5 = 40% based on timings length
-    expect(stats.failures).toBe(2);
-    expect(stats.failureRate).toBeGreaterThan(0);
-  });
-
-  test('warmup iterations are excluded from percentile calculations', () => {
-    // First 2 values are outlier warmup times
-    const timings = [500, 400, 100, 100, 100, 100, 100, 100, 100, 100];
-    const warmup = 2;
-
-    const stats = calculateProfileStats(timings, warmup, 0);
-
-    // After excluding warmup, all values are 100
-    expect(stats.min).toBe(100);
-    expect(stats.max).toBe(100);
-    expect(stats.mean).toBe(100);
-    expect(stats.p50).toBe(100);
-    expect(stats.p95).toBe(100);
-    expect(stats.p99).toBe(100);
-  });
-
-  test('export file extension determines format', () => {
-    const jsonFile = 'results.json';
-    const csvFile = 'results.csv';
-
-    expect(jsonFile.endsWith('.json')).toBe(true);
-    expect(csvFile.endsWith('.csv')).toBe(true);
-    expect(jsonFile.endsWith('.csv')).toBe(false);
-    expect(csvFile.endsWith('.json')).toBe(false);
-  });
-});
-
-describe('ProfileConfig Validation', () => {
-  test('iterations must be positive', () => {
-    const validConfig: ProfileConfig = { iterations: 10 };
-    const invalidIterations = 0;
-
-    expect(validConfig.iterations).toBeGreaterThan(0);
-    expect(invalidIterations).toBeLessThanOrEqual(0);
-  });
-
-  test('warmup should not exceed iterations', () => {
-    const config: ProfileConfig = {
-      iterations: 10,
-      warmup: 5,
-    };
-
-    expect(config.warmup).toBeLessThanOrEqual(config.iterations);
-  });
-
-  test('concurrency defaults to 1 (sequential)', () => {
-    const config: ProfileConfig = { iterations: 10 };
-    const concurrency = config.concurrency ?? 1;
-
-    expect(concurrency).toBe(1);
-  });
-});

package/src/executor/profile-executor.ts

@@ -1,167 +0,0 @@
-import type {
-  ExecutionResult,
-  GlobalConfig,
-  ProfileConfig,
-  ProfileResult,
-  RequestConfig,
-} from '../types/config';
-import { CurlBuilder } from '../utils/curl-builder';
-import { Logger } from '../utils/logger';
-import { calculateProfileStats } from '../utils/stats';
-
-export class ProfileExecutor {
-  private logger: Logger;
-  private profileConfig: ProfileConfig;
-
-  constructor(globalConfig: GlobalConfig, profileConfig: ProfileConfig) {
-    this.profileConfig = profileConfig;
-    this.logger = new Logger(globalConfig.output);
-  }
-
-  /**
-   * Execute a single iteration of the request (minimal overhead version).
-   * Skips logging and validation for accurate timing.
-   */
-  private async executeSingleIteration(config: RequestConfig): Promise<ExecutionResult> {
-    const startTime = performance.now();
-    const command = CurlBuilder.buildCommand(config);
-    const result = await CurlBuilder.executeCurl(command);
-
-    if (result.success) {
-      let body = result.body;
-      try {
-        if (
-          result.headers?.['content-type']?.includes('application/json') ||
-          (body && (body.trim().startsWith('{') || body.trim().startsWith('[')))
-        ) {
-          body = JSON.parse(body);
-        }
-      } catch (_e) {
-        // Keep raw body
-      }
-
-      return {
-        request: config,
-        success: true,
-        status: result.status,
-        headers: result.headers,
-        body,
-        metrics: {
-          ...result.metrics,
-          duration: performance.now() - startTime,
-        },
-      };
-    }
-
-    return {
-      request: config,
-      success: false,
-      error: result.error,
-      metrics: {
-        duration: performance.now() - startTime,
-      },
-    };
-  }
-
-  /**
-   * Execute iterations in chunks for controlled concurrency.
-   */
-  private async executeWithConcurrency(
-    config: RequestConfig,
-    iterations: number,
-    concurrency: number,
-  ): Promise<ExecutionResult[]> {
-    const results: ExecutionResult[] = [];
-
-    for (let i = 0; i < iterations; i += concurrency) {
-      const chunkSize = Math.min(concurrency, iterations - i);
-      const chunk = await Promise.all(
-        Array.from({ length: chunkSize }, () => this.executeSingleIteration(config)),
-      );
-      results.push(...chunk);
-    }
-
-    return results;
-  }
-
-  /**
-   * Profile a single request by running it multiple times.
-   */
-  async profileRequest(config: RequestConfig, index = 0): Promise<ProfileResult> {
-    const iterations = this.profileConfig.iterations;
-    const warmup = this.profileConfig.warmup ?? 1;
-    const concurrency = this.profileConfig.concurrency ?? 1;
-    const requestName = config.name || `Request ${index + 1}`;
-
-    this.logger.logProfileStart(requestName, iterations, warmup, concurrency);
-
-    const results =
-      concurrency === 1
-        ? await this.executeSequentially(config, iterations)
-        : await this.executeWithConcurrency(config, iterations, concurrency);
-
-    // Collect timings and count failures
-    const timings: number[] = [];
-    let failures = 0;
-
-    for (const result of results) {
-      if (result.success && result.metrics?.duration !== undefined) {
-        timings.push(result.metrics.duration);
-      } else {
-        failures++;
-        // Use 0 as placeholder for failed requests (excluded from stats)
-        timings.push(0);
-      }
-    }
-
-    // Filter out failed timings (0s) for stats calculation
-    const successfulTimings = timings
-      .map((t, i) => (results[i].success ? t : -1))
-      .filter((t) => t >= 0);
-
-    // Recalculate stats with only successful timings
-    const stats = calculateProfileStats(
-      successfulTimings,
-      Math.min(warmup, successfulTimings.length),
-      failures,
-    );
-
-    return {
-      request: config,
-      stats,
-      iterations: results,
-    };
-  }
-
-  /**
-   * Execute iterations sequentially (default behavior).
-   */
-  private async executeSequentially(
-    config: RequestConfig,
-    iterations: number,
-  ): Promise<ExecutionResult[]> {
-    const results: ExecutionResult[] = [];
-
-    for (let i = 0; i < iterations; i++) {
-      const result = await this.executeSingleIteration(config);
-      results.push(result);
-    }
-
-    return results;
-  }
-
-  /**
-   * Profile multiple requests.
-   */
-  async profileRequests(requests: RequestConfig[]): Promise<ProfileResult[]> {
-    const results: ProfileResult[] = [];
-
-    for (let i = 0; i < requests.length; i++) {
-      const result = await this.profileRequest(requests[i], i);
-      results.push(result);
-      this.logger.logProfileResult(result, this.profileConfig.histogram ?? false);
-    }
-
-    return results;
-  }
-}