qa360 2.1.7 → 2.2.0

package/core/src/adapters/__tests__/k6-perf.test.ts

@@ -0,0 +1,538 @@
+/**
+ * K6PerfAdapter - Real Unit Tests
+ * Tests actual adapter logic without executing k6
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { K6PerfAdapter } from '../k6-perf.js';
+
+// Mock child_process to avoid actually running k6
+vi.mock('child_process', () => ({
+  spawn: vi.fn().mockReturnValue({
+    stdout: { on: vi.fn() },
+    stderr: { on: vi.fn() },
+    on: vi.fn((event, callback) => {
+      if (event === 'error') {
+        // Don't call error by default
+      }
+    }),
+    kill: vi.fn()
+  })
+}));
+
+// Mock fs to avoid file operations
+vi.mock('fs', async () => {
+  const actual = await vi.importActual('fs');
+  return {
+    ...actual,
+    writeFileSync: vi.fn(),
+    unlinkSync: vi.fn(),
+    existsSync: vi.fn().mockReturnValue(false),
+    readFileSync: vi.fn()
+  };
+});
+
+describe('K6PerfAdapter', () => {
+  let adapter: K6PerfAdapter;
+
+  beforeEach(() => {
+    adapter = new K6PerfAdapter('/tmp/test');
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  // ============================================================
+  // validateConfig - Static method tests
+  // ============================================================
+  describe('validateConfig', () => {
+    it('should validate config with valid baseUrl', () => {
+      const result = K6PerfAdapter.validateConfig({
+        baseUrl: 'https://api.example.com'
+      });
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('should reject config without baseUrl', () => {
+      const result = K6PerfAdapter.validateConfig({} as any);
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain('Performance test requires baseUrl');
+    });
+
+    it('should reject config with invalid URL', () => {
+      const result = K6PerfAdapter.validateConfig({
+        baseUrl: 'not-a-valid-url'
+      });
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain('Performance test baseUrl must be a valid URL');
+    });
+
+    it('should validate VUs range', () => {
+      const validConfig = K6PerfAdapter.validateConfig({
+        baseUrl: 'https://api.example.com',
+        vus: 50
+      });
+      expect(validConfig.valid).toBe(true);
+
+      const tooLow = K6PerfAdapter.validateConfig({
+        baseUrl: 'https://api.example.com',
+        vus: 0
+      });
+      expect(tooLow.valid).toBe(false);
+      expect(tooLow.errors.some(e => e.includes('VUs must be between'))).toBe(true);
+
+      const tooHigh = K6PerfAdapter.validateConfig({
+        baseUrl: 'https://api.example.com',
+        vus: 1001
+      });
+      expect(tooHigh.valid).toBe(false);
+    });
+
+    it('should validate duration format', () => {
+      const validSeconds = K6PerfAdapter.validateConfig({
+        baseUrl: 'https://api.example.com',
+        duration: '30s'
+      });
+      expect(validSeconds.valid).toBe(true);
+
+      const validMinutes = K6PerfAdapter.validateConfig({
+        baseUrl: 'https://api.example.com',
+        duration: '5m'
+      });
+      expect(validMinutes.valid).toBe(true);
+
+      const validHours = K6PerfAdapter.validateConfig({
+        baseUrl: 'https://api.example.com',
+        duration: '1h'
+      });
+      expect(validHours.valid).toBe(true);
+
+      const invalid = K6PerfAdapter.validateConfig({
+        baseUrl: 'https://api.example.com',
+        duration: '30 seconds'
+      });
+      expect(invalid.valid).toBe(false);
+      expect(invalid.errors.some(e => e.includes('Duration must be in format'))).toBe(true);
+    });
+
+    it('should accept all valid options together', () => {
+      const result = K6PerfAdapter.validateConfig({
+        baseUrl: 'https://api.example.com',
+        vus: 10,
+        duration: '1m',
+        timeout: 120000,
+        budgets: { perf_p95_ms: 500 }
+      });
+      expect(result.valid).toBe(true);
+    });
+  });
+
+  // ============================================================
+  // generateK6Script - Script generation (via reflection)
+  // ============================================================
+  describe('generateK6Script (via reflection)', () => {
+    const generateK6Script = (adapter: any, config: any) => {
+      return adapter.generateK6Script.call(adapter, config);
+    };
+
+    it('should generate valid k6 script', () => {
+      const script = generateK6Script(adapter, {
+        baseUrl: 'https://api.example.com',
+        duration: '30s',
+        vus: 5
+      });
+
+      expect(script).toContain("import http from 'k6/http'");
+      expect(script).toContain("import { check, sleep } from 'k6'");
+      expect(script).toContain('export let options');
+      expect(script).toContain('export default function()');
+    });
+
+    it('should include baseUrl in script', () => {
+      const script = generateK6Script(adapter, {
+        baseUrl: 'https://test.example.com/api'
+      });
+
+      expect(script).toContain('https://test.example.com/api');
+    });
+
+    it('should use default duration and VUs', () => {
+      const script = generateK6Script(adapter, {
+        baseUrl: 'https://api.example.com'
+      });
+
+      expect(script).toContain('"duration": "30s"');
+      expect(script).toContain('"vus": 5');
+    });
+
+    it('should use custom duration and VUs', () => {
+      const script = generateK6Script(adapter, {
+        baseUrl: 'https://api.example.com',
+        duration: '1m',
+        vus: 20
+      });
+
+      expect(script).toContain('"duration": "1m"');
+      expect(script).toContain('"vus": 20');
+    });
+
+    it('should include p95 threshold from budget', () => {
+      const script = generateK6Script(adapter, {
+        baseUrl: 'https://api.example.com',
+        budgets: { perf_p95_ms: 500 }
+      });
+
+      expect(script).toContain("'p(95)<500'");
+    });
+
+    it('should use default p95 budget of 2000ms', () => {
+      const script = generateK6Script(adapter, {
+        baseUrl: 'https://api.example.com'
+      });
+
+      expect(script).toContain("'p(95)<2000'");
+    });
+
+    it('should include error rate threshold', () => {
+      const script = generateK6Script(adapter, {
+        baseUrl: 'https://api.example.com'
+      });
+
+      expect(script).toContain("'http_req_failed'");
+      expect(script).toContain("'rate<0.1'");
+    });
+
+    it('should include User-Agent header', () => {
+      const script = generateK6Script(adapter, {
+        baseUrl: 'https://api.example.com'
+      });
+
+      expect(script).toContain('QA360-k6-Perf/1.0');
+    });
+
+    it('should include check functions', () => {
+      const script = generateK6Script(adapter, {
+        baseUrl: 'https://api.example.com'
+      });
+
+      expect(script).toContain('check(response');
+      expect(script).toContain('status is 200-299');
+    });
+
+    it('should handle custom scenarios', () => {
+      const script = generateK6Script(adapter, {
+        baseUrl: 'https://api.example.com',
+        scenarios: {
+          smoke: { executor: 'constant-vus', vus: 1, duration: '10s' },
+          load: { executor: 'ramping-vus', startVUs: 0, stages: [{ duration: '1m', target: 50 }] }
+        }
+      });
+
+      expect(script).toContain('"smoke"');
+      expect(script).toContain('"load"');
+      expect(script).toContain('ramping-vus');
+    });
+  });
+
+  // ============================================================
+  // parseTextMetrics - Metrics parsing from text
+  // ============================================================
+  describe('parseTextMetrics (via reflection)', () => {
+    const parseTextMetrics = (adapter: any, output: string) => {
+      return adapter.parseTextMetrics.call(adapter, output);
+    };
+
+    it('should parse p95 duration', () => {
+      const output = 'http_req_duration............: avg=150.23ms p(95)=250.45ms';
+      const metrics = parseTextMetrics(adapter, output);
+      
+      expect(metrics.http_req_duration_p95).toBe(250.45);
+    });
+
+    it('should parse avg duration', () => {
+      const output = 'http_req_duration............: avg=150.23ms p(95)=250.45ms';
+      const metrics = parseTextMetrics(adapter, output);
+      
+      expect(metrics.http_req_duration_avg).toBe(150.23);
+    });
+
+    it('should parse error rate', () => {
+      const output = 'http_req_failed...............: 2.5%';
+      const metrics = parseTextMetrics(adapter, output);
+      
+      expect(metrics.http_req_failed_rate).toBe(2.5);
+    });
+
+    it('should parse request count', () => {
+      const output = 'http_reqs...................: 1500';
+      const metrics = parseTextMetrics(adapter, output);
+      
+      expect(metrics.http_reqs_total).toBe(1500);
+    });
+
+    it('should parse iterations', () => {
+      const output = 'iterations..................: 1000';
+      const metrics = parseTextMetrics(adapter, output);
+      
+      expect(metrics.iterations).toBe(1000);
+    });
+
+    it('should return defaults for missing metrics', () => {
+      const metrics = parseTextMetrics(adapter, 'no metrics here');
+      
+      expect(metrics.http_req_duration_p95).toBe(0);
+      expect(metrics.http_req_duration_avg).toBe(0);
+      expect(metrics.http_req_failed_rate).toBe(0);
+      expect(metrics.http_reqs_total).toBe(0);
+    });
+
+    it('should handle mixed output', () => {
+      const output = `
+        running (30s), 5/5 VUs
+        http_req_duration............: avg=123.45ms p(95)=456.78ms
+        http_req_failed...............: 1.2%
+        http_reqs...................: 500
+        iterations..................: 490
+      `;
+      const metrics = parseTextMetrics(adapter, output);
+      
+      expect(metrics.http_req_duration_p95).toBe(456.78);
+      expect(metrics.http_req_duration_avg).toBe(123.45);
+      expect(metrics.http_req_failed_rate).toBe(1.2);
+      expect(metrics.http_reqs_total).toBe(500);
+      expect(metrics.iterations).toBe(490);
+    });
+  });
+
+  // ============================================================
+  // parseTextThresholds - Threshold parsing from text
+  // ============================================================
+  describe('parseTextThresholds (via reflection)', () => {
+    const parseTextThresholds = (adapter: any, output: string) => {
+      return adapter.parseTextThresholds.call(adapter, output);
+    };
+
+    it('should parse passed threshold', () => {
+      const output = '✓ http_req_duration p(95) < 2000ms';
+      const thresholds = parseTextThresholds(adapter, output);
+      
+      const key = Object.keys(thresholds)[0];
+      expect(thresholds[key].passed).toBe(true);
+    });
+
+    it('should parse failed threshold', () => {
+      const output = '✗ http_req_duration p(95) < 500ms';
+      const thresholds = parseTextThresholds(adapter, output);
+      
+      const key = Object.keys(thresholds)[0];
+      expect(thresholds[key].passed).toBe(false);
+    });
+
+    it('should handle PASS/FAIL text', () => {
+      const output = `
+        http_req_duration PASS
+        http_req_failed FAIL
+      `;
+      const thresholds = parseTextThresholds(adapter, output);
+      
+      const keys = Object.keys(thresholds);
+      expect(keys.some(k => thresholds[k].passed)).toBe(true);
+      expect(keys.some(k => !thresholds[k].passed)).toBe(true);
+    });
+
+    it('should return empty for no thresholds', () => {
+      const thresholds = parseTextThresholds(adapter, 'no thresholds here');
+      
+      expect(Object.keys(thresholds)).toHaveLength(0);
+    });
+  });
+
+  // ============================================================
+  // generateJUnit - JUnit XML generation
+  // ============================================================
+  describe('generateJUnit (via reflection)', () => {
+    const generateJUnit = (adapter: any, metrics: any, success: boolean, config: any) => {
+      return adapter.generateJUnit.call(adapter, metrics, success, config);
+    };
+
+    it('should generate valid XML structure', () => {
+      const metrics = {
+        http_req_duration_p95: 150,
+        http_req_duration_avg: 100,
+        http_req_failed_rate: 0,
+        http_reqs_total: 1000,
+        vus_max: 5,
+        iterations: 950
+      };
+      
+      const junit = generateJUnit(adapter, metrics, true, { baseUrl: 'https://api.example.com' });
+      
+      expect(junit).toContain('<?xml version="1.0" encoding="UTF-8"?>');
+      expect(junit).toContain('<testsuite');
+      expect(junit).toContain('name="k6 Performance Test"');
+      expect(junit).toContain('</testsuite>');
+    });
+
+    it('should include baseUrl in test name', () => {
+      const metrics = {
+        http_req_duration_p95: 150,
+        http_req_duration_avg: 100,
+        http_req_failed_rate: 0,
+        http_reqs_total: 1000,
+        vus_max: 5,
+        iterations: 950
+      };
+      
+      const junit = generateJUnit(adapter, metrics, true, { baseUrl: 'https://test.com/api' });
+      
+      expect(junit).toContain('https://test.com/api');
+    });
+
+    it('should not include failure for success', () => {
+      const metrics = {
+        http_req_duration_p95: 150,
+        http_req_duration_avg: 100,
+        http_req_failed_rate: 0,
+        http_reqs_total: 1000,
+        vus_max: 5,
+        iterations: 950
+      };
+      
+      const junit = generateJUnit(adapter, metrics, true, { baseUrl: 'https://api.example.com' });
+      
+      expect(junit).not.toContain('<failure');
+      expect(junit).toContain('failures="0"');
+    });
+
+    it('should include failure details for failed test', () => {
+      const metrics = {
+        http_req_duration_p95: 3000,
+        http_req_duration_avg: 2500,
+        http_req_failed_rate: 15,
+        http_reqs_total: 1000,
+        vus_max: 5,
+        iterations: 950
+      };
+      
+      const junit = generateJUnit(adapter, metrics, false, { 
+        baseUrl: 'https://api.example.com',
+        budgets: { perf_p95_ms: 500 }
+      });
+      
+      expect(junit).toContain('<failure');
+      expect(junit).toContain('failures="1"');
+      expect(junit).toContain('3000ms');
+      expect(junit).toContain('500ms');
+    });
+
+    it('should include timestamp', () => {
+      const metrics = {
+        http_req_duration_p95: 150,
+        http_req_duration_avg: 100,
+        http_req_failed_rate: 0,
+        http_reqs_total: 1000,
+        vus_max: 5,
+        iterations: 950
+      };
+      
+      const junit = generateJUnit(adapter, metrics, true, { baseUrl: 'https://api.example.com' });
+      
+      expect(junit).toMatch(/timestamp="\d{4}-\d{2}-\d{2}T/);
+    });
+  });
+
+  // ============================================================
+  // getDefaultMetrics - Default metrics structure
+  // ============================================================
+  describe('getDefaultMetrics (via reflection)', () => {
+    const getDefaultMetrics = (adapter: any) => {
+      return adapter.getDefaultMetrics.call(adapter);
+    };
+
+    it('should return all expected metric keys', () => {
+      const metrics = getDefaultMetrics(adapter);
+      
+      expect(metrics).toHaveProperty('http_req_duration_p95');
+      expect(metrics).toHaveProperty('http_req_duration_avg');
+      expect(metrics).toHaveProperty('http_req_failed_rate');
+      expect(metrics).toHaveProperty('http_reqs_total');
+      expect(metrics).toHaveProperty('vus_max');
+      expect(metrics).toHaveProperty('iterations');
+    });
+
+    it('should initialize all metrics to 0', () => {
+      const metrics = getDefaultMetrics(adapter);
+      
+      expect(metrics.http_req_duration_p95).toBe(0);
+      expect(metrics.http_req_duration_avg).toBe(0);
+      expect(metrics.http_req_failed_rate).toBe(0);
+      expect(metrics.http_reqs_total).toBe(0);
+      expect(metrics.vus_max).toBe(0);
+      expect(metrics.iterations).toBe(0);
+    });
+  });
+
+  // ============================================================
+  // Constructor and instance
+  // ============================================================
+  describe('constructor', () => {
+    it('should create adapter instance', () => {
+      const adapter = new K6PerfAdapter();
+      expect(adapter).toBeInstanceOf(K6PerfAdapter);
+    });
+
+    it('should use provided working directory', () => {
+      const adapter = new K6PerfAdapter('/custom/path');
+      expect((adapter as any).workingDir).toBe('/custom/path');
+    });
+
+    it('should default to current directory', () => {
+      const adapter = new K6PerfAdapter();
+      expect((adapter as any).workingDir).toBe(process.cwd());
+    });
+
+    it('should have redactor initialized', () => {
+      const adapter = new K6PerfAdapter();
+      expect((adapter as any).redactor).toBeDefined();
+    });
+  });
+
+  // ============================================================
+  // Performance budget logic
+  // ============================================================
+  describe('Performance budget evaluation', () => {
+    it('should pass when p95 is under budget', () => {
+      const metrics = { http_req_duration_p95: 400, http_req_failed_rate: 5 };
+      const budget = 500;
+      const success = metrics.http_req_duration_p95 <= budget && metrics.http_req_failed_rate < 10;
+      
+      expect(success).toBe(true);
+    });
+
+    it('should fail when p95 exceeds budget', () => {
+      const metrics = { http_req_duration_p95: 600, http_req_failed_rate: 5 };
+      const budget = 500;
+      const success = metrics.http_req_duration_p95 <= budget && metrics.http_req_failed_rate < 10;
+      
+      expect(success).toBe(false);
+    });
+
+    it('should fail when error rate is too high', () => {
+      const metrics = { http_req_duration_p95: 400, http_req_failed_rate: 15 };
+      const budget = 500;
+      const success = metrics.http_req_duration_p95 <= budget && metrics.http_req_failed_rate < 10;
+      
+      expect(success).toBe(false);
+    });
+
+    it('should pass with exact budget value', () => {
+      const metrics = { http_req_duration_p95: 500, http_req_failed_rate: 9.9 };
+      const budget = 500;
+      const success = metrics.http_req_duration_p95 <= budget && metrics.http_req_failed_rate < 10;
+      
+      expect(success).toBe(true);
+    });
+  });
+});