qa360 2.1.7 → 2.2.0

package/core/src/adapters/__tests__/playwright-native-api.test.ts

@@ -0,0 +1,792 @@
+/**
+ * Playwright Native API Adapter Tests
+ *
+ * Comprehensive test suite for the browserless Playwright API adapter.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import {
+  PlaywrightNativeApiAdapter,
+  createPlaywrightNativeApiAdapter,
+  PlaywrightNativeApiError,
+  type NativeApiTestConfig,
+  type ApiTestResult
+} from '../playwright-native-api.js';
+
+// Mock Playwright to avoid actual network calls in tests
+vi.mock('playwright', async () => {
+  const actual = await vi.importActual('playwright');
+  return {
+    ...actual,
+    request: {
+      newContext: vi.fn()
+    }
+  };
+});
+
+import * as playwright from 'playwright';
+
+describe('PlaywrightNativeApiAdapter', () => {
+  let adapter: PlaywrightNativeApiAdapter;
+  let mockRequestContext: any;
+
+  beforeEach(() => {
+    adapter = new PlaywrightNativeApiAdapter();
+    vi.clearAllMocks();
+
+    // Create mock request context
+    mockRequestContext = {
+      fetch: vi.fn(),
+      setHTTPCredentials: vi.fn(),
+      dispose: vi.fn(),
+      get: vi.fn(),
+      post: vi.fn(),
+      put: vi.fn(),
+      delete: vi.fn(),
+      patch: vi.fn()
+    };
+
+    vi.mocked(playwright.request.newContext).mockResolvedValue(mockRequestContext);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('Constructor', () => {
+    it('should create adapter instance', () => {
+      expect(adapter).toBeInstanceOf(PlaywrightNativeApiAdapter);
+    });
+
+    it('should have factory function', () => {
+      const instance = createPlaywrightNativeApiAdapter();
+      expect(instance).toBeInstanceOf(PlaywrightNativeApiAdapter);
+    });
+  });
+
+  describe('getCapabilities', () => {
+    it('should return adapter capabilities', () => {
+      const capabilities = PlaywrightNativeApiAdapter.getCapabilities();
+
+      expect(capabilities).toEqual({
+        adapter: 'playwright-native',
+        browserless: true,
+        features: expect.arrayContaining([
+          'REST API testing',
+          'GraphQL support',
+          'Basic auth',
+          'Bearer token auth',
+          'Retry logic with exponential backoff'
+        ])
+      });
+    });
+
+    it('should indicate browserless operation', () => {
+      const capabilities = PlaywrightNativeApiAdapter.getCapabilities();
+      expect(capabilities.browserless).toBe(true);
+    });
+  });
+
+  describe('validateConfig', () => {
+    it('should validate correct config', () => {
+      const result = PlaywrightNativeApiAdapter.validateConfig({
+        baseUrl: 'https://api.example.com',
+        smoke: ['GET /health -> 200']
+      });
+
+      expect(result.valid).toBe(true);
+      expect(result.errors).toEqual([]);
+    });
+
+    it('should reject config without baseUrl', () => {
+      const result = PlaywrightNativeApiAdapter.validateConfig({
+        baseUrl: ''
+      });
+
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain('baseUrl is required in gate config. Add: "baseUrl: https://your-api.com"');
+    });
+
+    it('should reject invalid URL', () => {
+      const result = PlaywrightNativeApiAdapter.validateConfig({
+        baseUrl: 'not-a-valid-url'
+      });
+
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain('baseUrl "not-a-valid-url" is not a valid URL. Expected format: https://api.example.com');
+    });
+
+    it('should reject invalid test spec format', () => {
+      const result = PlaywrightNativeApiAdapter.validateConfig({
+        baseUrl: 'https://api.example.com',
+        smoke: ['invalid format']
+      });
+
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain('Invalid smoke test format: invalid format. Expected: "METHOD /path -> STATUS"');
+    });
+
+    it('should accept multiple test specs', () => {
+      const result = PlaywrightNativeApiAdapter.validateConfig({
+        baseUrl: 'https://api.example.com',
+        smoke: [
+          'GET /health -> 200',
+          'POST /users -> 201',
+          'PUT /users/1 -> 200'
+        ]
+      });
+
+      expect(result.valid).toBe(true);
+    });
+  });
+
+  describe('setAuth', () => {
+    it('should store auth credentials', () => {
+      const auth = {
+        headers: { 'Authorization': 'Bearer token123' }
+      };
+
+      adapter.setAuth(auth);
+      // Auth is stored but not directly exposed
+      expect(adapter).toBeDefined();
+    });
+
+    it('should accept undefined auth', () => {
+      expect(() => adapter.setAuth(undefined)).not.toThrow();
+    });
+  });
+
+  describe('runSmokeTests', () => {
+    it('should run successful smoke tests', async () => {
+      // Mock successful response
+      mockRequestContext.fetch.mockResolvedValue({
+        status: () => 200,
+        headers: () => ({ 'content-type': 'application/json' }),
+        json: async () => ({ status: 'ok' }),
+        text: async () => '{"status":"ok"}'
+      });
+
+      const config: NativeApiTestConfig = {
+        target: {
+          baseUrl: 'https://api.example.com',
+          smoke: ['GET /health -> 200']
+        }
+      };
+
+      const result = await adapter.runSmokeTests(config);
+
+      expect(result.success).toBe(true);
+      expect(result.summary.total).toBe(1);
+      expect(result.summary.passed).toBe(1);
+      expect(result.summary.failed).toBe(0);
+      expect(result.results).toHaveLength(1);
+      expect(result.results[0].status).toBe(200);
+      expect(result.results[0].success).toBe(true);
+    });
+
+    it('should handle multiple smoke tests', async () => {
+      mockRequestContext.fetch
+        .mockResolvedValueOnce({
+          status: () => 200,
+          headers: () => ({ 'content-type': 'application/json' }),
+          json: async () => ({ status: 'ok' }),
+          text: async () => '{"status":"ok"}'
+        })
+        .mockResolvedValueOnce({
+          status: () => 201,
+          headers: () => ({ 'content-type': 'application/json' }),
+          json: async () => ({ id: 1 }),
+          text: async () => '{"id":1}'
+        });
+
+      const config: NativeApiTestConfig = {
+        target: {
+          baseUrl: 'https://api.example.com',
+          smoke: [
+            'GET /health -> 200',
+            'POST /users -> 201'
+          ]
+        }
+      };
+
+      const result = await adapter.runSmokeTests(config);
+
+      expect(result.success).toBe(true);
+      expect(result.summary.total).toBe(2);
+      expect(result.summary.passed).toBe(2);
+      expect(result.results[0].method).toBe('GET');
+      expect(result.results[1].method).toBe('POST');
+    });
+
+    it('should handle failed smoke test', async () => {
+      mockRequestContext.fetch.mockResolvedValue({
+        status: () => 500,
+        headers: () => ({ 'content-type': 'application/json' }),
+        json: async () => ({ error: 'Internal server error' }),
+        text: async () => '{"error":"Internal server error"}'
+      });
+
+      const config: NativeApiTestConfig = {
+        target: {
+          baseUrl: 'https://api.example.com',
+          smoke: ['GET /health -> 200']
+        }
+      };
+
+      const result = await adapter.runSmokeTests(config);
+
+      expect(result.success).toBe(false);
+      expect(result.summary.failed).toBe(1);
+      expect(result.results[0].success).toBe(false);
+      expect(result.results[0].error).toContain('Expected status 200, got 500');
+    });
+
+    it('should generate JUnit XML', async () => {
+      mockRequestContext.fetch.mockResolvedValue({
+        status: () => 200,
+        headers: () => ({ 'content-type': 'application/json' }),
+        json: async () => ({ status: 'ok' }),
+        text: async () => '{"status":"ok"}'
+      });
+
+      const config: NativeApiTestConfig = {
+        target: {
+          baseUrl: 'https://api.example.com',
+          smoke: ['GET /health -> 200']
+        }
+      };
+
+      const result = await adapter.runSmokeTests(config);
+
+      expect(result.junit).toBeDefined();
+      expect(result.junit).toContain('<?xml version="1.0"');
+      expect(result.junit).toContain('<testsuite');
+      expect(result.junit).toContain('API Smoke Tests (Playwright Native)');
+      expect(result.junit).toContain('<testcase');
+    });
+
+    it('should cleanup request context after tests', async () => {
+      mockRequestContext.fetch.mockResolvedValue({
+        status: () => 200,
+        headers: () => ({ 'content-type': 'application/json' }),
+        json: async () => ({}),
+        text: async () => '{}'
+      });
+
+      const config: NativeApiTestConfig = {
+        target: {
+          baseUrl: 'https://api.example.com',
+          smoke: ['GET /health -> 200']
+        }
+      };
+
+      await adapter.runSmokeTests(config);
+
+      expect(mockRequestContext.dispose).toHaveBeenCalled();
+    });
+
+    it('should include error message when tests fail', async () => {
+      mockRequestContext.fetch.mockResolvedValue({
+        status: () => 404,
+        headers: () => ({ 'content-type': 'application/json' }),
+        json: async () => ({ error: 'Not found' }),
+        text: async () => '{"error":"Not found"}'
+      });
+
+      const config: NativeApiTestConfig = {
+        target: {
+          baseUrl: 'https://api.example.com',
+          smoke: ['GET /missing -> 200']
+        }
+      };
+
+      const result = await adapter.runSmokeTests(config);
+
+      expect(result.error).toBeDefined();
+      expect(result.error).toContain('1 endpoint(s) failed');
+    });
+  });
+
+  describe('retry logic', () => {
+    it('should retry on retryable errors', async () => {
+      let attemptCount = 0;
+      mockRequestContext.fetch.mockImplementation(async () => {
+        attemptCount++;
+        if (attemptCount < 3) {
+          throw new Error('ECONNRESET');
+        }
+        return {
+          status: () => 200,
+          headers: () => ({ 'content-type': 'application/json' }),
+          json: async () => ({ status: 'ok' }),
+          text: async () => '{"status":"ok"}'
+        };
+      });
+
+      const config: NativeApiTestConfig = {
+        target: {
+          baseUrl: 'https://api.example.com',
+          smoke: ['GET /health -> 200']
+        },
+        retries: 3
+      };
+
+      const result = await adapter.runSmokeTests(config);
+
+      expect(result.success).toBe(true);
+      expect(result.results[0].attempts).toBe(3);
+    });
+
+    it('should give up after max retries', async () => {
+      mockRequestContext.fetch.mockRejectedValue(new Error('ECONNRESET'));
+
+      const config: NativeApiTestConfig = {
+        target: {
+          baseUrl: 'https://api.example.com',
+          smoke: ['GET /health -> 200']
+        },
+        retries: 2
+      };
+
+      const result = await adapter.runSmokeTests(config);
+
+      expect(result.success).toBe(false);
+      expect(result.results[0].success).toBe(false);
+      expect(result.results[0].attempts).toBe(3); // initial + 2 retries
+    });
+
+    it('should not retry on non-retryable errors', async () => {
+      mockRequestContext.fetch.mockRejectedValue(new Error('Invalid credentials'));
+
+      const config: NativeApiTestConfig = {
+        target: {
+          baseUrl: 'https://api.example.com',
+          smoke: ['GET /health -> 200']
+        },
+        retries: 3
+      };
+
+      const result = await adapter.runSmokeTests(config);
+
+      expect(result.results[0].attempts).toBe(1); // No retries
+    });
+  });
+
+  describe('healthCheck', () => {
+    it('should return true for healthy endpoint', async () => {
+      mockRequestContext.fetch.mockResolvedValue({
+        status: () => 200
+      });
+
+      const result = await adapter.healthCheck('https://api.example.com', '/health');
+
+      expect(result).toBe(true);
+    });
+
+    it('should return true for redirect', async () => {
+      mockRequestContext.fetch.mockResolvedValue({
+        status: () => 301
+      });
+
+      const result = await adapter.healthCheck('https://api.example.com', '/redirect');
+
+      expect(result).toBe(true);
+    });
+
+    it('should return false for server error', async () => {
+      mockRequestContext.fetch.mockResolvedValue({
+        status: () => 500
+      });
+
+      const result = await adapter.healthCheck('https://api.example.com', '/error');
+
+      expect(result).toBe(false);
+    });
+
+    it('should return false on network error', async () => {
+      mockRequestContext.fetch.mockRejectedValue(new Error('Network error'));
+
+      const result = await adapter.healthCheck('https://api.example.com', '/health');
+
+      expect(result).toBe(false);
+    });
+
+    it('should use custom timeout', async () => {
+      mockRequestContext.fetch.mockResolvedValue({
+        status: () => 200
+      });
+
+      await adapter.healthCheck('https://api.example.com', '/health', 10000);
+
+      expect(playwright.request.newContext).toHaveBeenCalledWith(
+        expect.objectContaining({
+          timeout: 10000
+        })
+      );
+    });
+
+    it('should use default /health path', async () => {
+      mockRequestContext.fetch.mockResolvedValue({
+        status: () => 200
+      });
+
+      await adapter.healthCheck('https://api.example.com');
+
+      expect(mockRequestContext.fetch).toHaveBeenCalledWith(
+        'https://api.example.com/health',
+        expect.objectContaining({
+          method: 'GET'
+        })
+      );
+    });
+  });
+
+  describe('authentication', () => {
+    it('should set basic auth credentials', async () => {
+      mockRequestContext.fetch.mockResolvedValue({
+        status: () => 200,
+        headers: () => ({ 'content-type': 'application/json' }),
+        json: async () => ({}),
+        text: async () => '{}'
+      });
+
+      const config: NativeApiTestConfig = {
+        target: {
+          baseUrl: 'https://api.example.com',
+          smoke: ['GET /health -> 200']
+        },
+        basicAuth: {
+          username: 'testuser',
+          password: 'testpass'
+        }
+      };
+
+      await adapter.runSmokeTests(config);
+
+      // Basic auth is now handled via Authorization header
+      const newContextCall = vi.mocked(playwright.request.newContext).mock.calls;
+      expect(newContextCall.length).toBeGreaterThan(0);
+      // The last call should have basic auth in headers
+      const lastCall = newContextCall[newContextCall.length - 1][0];
+      expect(lastCall.extraHTTPHeaders?.Authorization).toContain('Basic ');
+    });
+
+    it('should include auth headers in request', async () => {
+      mockRequestContext.fetch.mockResolvedValue({
+        status: () => 200,
+        headers: () => ({ 'content-type': 'application/json' }),
+        json: async () => ({}),
+        text: async () => '{}'
+      });
+
+      const config: NativeApiTestConfig = {
+        target: {
+          baseUrl: 'https://api.example.com',
+          smoke: ['GET /health -> 200']
+        },
+        auth: {
+          headers: {
+            'Authorization': 'Bearer token123',
+            'X-Custom-Header': 'custom-value'
+          }
+        }
+      };
+
+      await adapter.runSmokeTests(config);
+
+      const newContextCall = vi.mocked(playwright.request.newContext).mock.calls[0][0];
+      expect(newContextCall.extraHTTPHeaders).toEqual(
+        expect.objectContaining({
+          'Authorization': 'Bearer token123',
+          'X-Custom-Header': 'custom-value'
+        })
+      );
+    });
+  });
+
+  describe('response handling', () => {
+    it('should parse JSON responses', async () => {
+      const mockData = { user: { id: 1, name: 'Test' } };
+      mockRequestContext.fetch.mockResolvedValue({
+        status: () => 200,
+        headers: () => ({ 'content-type': 'application/json' }),
+        json: async () => mockData,
+        text: async () => JSON.stringify(mockData)
+      });
+
+      const config: NativeApiTestConfig = {
+        target: {
+          baseUrl: 'https://api.example.com',
+          smoke: ['GET /user -> 200']
+        }
+      };
+
+      const result = await adapter.runSmokeTests(config);
+
+      expect(result.results[0].body).toEqual(mockData);
+    });
+
+    it('should handle text responses', async () => {
+      mockRequestContext.fetch.mockResolvedValue({
+        status: () => 200,
+        headers: () => ({ 'content-type': 'text/plain' }),
+        json: async () => { throw new Error('Not JSON'); },
+        text: async () => 'Plain text response'
+      });
+
+      const config: NativeApiTestConfig = {
+        target: {
+          baseUrl: 'https://api.example.com',
+          smoke: ['GET /text -> 200']
+        }
+      };
+
+      const result = await adapter.runSmokeTests(config);
+
+      expect(result.results[0].body).toBe('Plain text response');
+    });
+
+    it('should capture response headers', async () => {
+      const mockHeaders = {
+        'content-type': 'application/json',
+        'x-request-id': '12345',
+        'x-rate-limit': '100'
+      };
+
+      mockRequestContext.fetch.mockResolvedValue({
+        status: () => 200,
+        headers: () => mockHeaders,
+        json: async () => ({}),
+        text: async () => '{}'
+      });
+
+      const config: NativeApiTestConfig = {
+        target: {
+          baseUrl: 'https://api.example.com',
+          smoke: ['GET /health -> 200']
+        }
+      };
+
+      const result = await adapter.runSmokeTests(config);
+
+      expect(result.results[0].headers).toEqual(mockHeaders);
+    });
+
+    it('should limit response body size', async () => {
+      const longText = 'x'.repeat(1000);
+      mockRequestContext.fetch.mockResolvedValue({
+        status: () => 200,
+        headers: () => ({ 'content-type': 'text/plain' }),
+        json: async () => { throw new Error('Not JSON'); },
+        text: async () => longText
+      });
+
+      const config: NativeApiTestConfig = {
+        target: {
+          baseUrl: 'https://api.example.com',
+          smoke: ['GET /text -> 200']
+        }
+      };
+
+      const result = await adapter.runSmokeTests(config);
+
+      // Body should be limited to 500 chars for non-JSON
+      expect(result.results[0].body?.length).toBeLessThanOrEqual(500);
+    });
+  });
+
+  describe('summary calculation', () => {
+    it('should calculate average response time', async () => {
+      mockRequestContext.fetch.mockResolvedValue({
+        status: () => 200,
+        headers: () => ({ 'content-type': 'application/json' }),
+        json: async () => ({}),
+        text: async () => '{}'
+      });
+
+      const config: NativeApiTestConfig = {
+        target: {
+          baseUrl: 'https://api.example.com',
+          smoke: [
+            'GET /fast -> 200',
+            'GET /slow -> 200',
+            'GET /medium -> 200'
+          ]
+        }
+      };
+
+      const result = await adapter.runSmokeTests(config);
+
+      // Average is calculated (may be 0 in fast mock tests)
+      expect(result.summary.avgResponseTime).toBeGreaterThanOrEqual(0);
+      expect(result.summary.totalAttempts).toBe(3);
+    });
+  });
+
+  describe('error handling', () => {
+    it('should handle request timeout', async () => {
+      mockRequestContext.fetch.mockRejectedValue(new Error('Request timeout'));
+
+      const config: NativeApiTestConfig = {
+        target: {
+          baseUrl: 'https://api.example.com',
+          smoke: ['GET /health -> 200']
+        },
+        timeout: 5000
+      };
+
+      const result = await adapter.runSmokeTests(config);
+
+      expect(result.success).toBe(false);
+      expect(result.results[0].error).toContain('timeout');
+    });
+
+    it('should handle connection refused', async () => {
+      mockRequestContext.fetch.mockRejectedValue(new Error('ECONNREFUSED'));
+
+      const config: NativeApiTestConfig = {
+        target: {
+          baseUrl: 'https://api.example.com',
+          smoke: ['GET /health -> 200']
+        }
+      };
+
+      const result = await adapter.runSmokeTests(config);
+
+      expect(result.success).toBe(false);
+      expect(result.results[0].error).toContain('ECONNREFUSED');
+    });
+  });
+
+  describe('PlaywrightNativeApiError', () => {
+    it('should create error with details', () => {
+      const error = new PlaywrightNativeApiError(
+        'Request failed',
+        'https://api.example.com/endpoint',
+        'GET'
+      );
+
+      expect(error.message).toBe('Request failed');
+      expect(error.endpoint).toBe('https://api.example.com/endpoint');
+      expect(error.method).toBe('GET');
+      expect(error.code).toBe('PLAYWRIGHT_NATIVE_API_ERROR');
+    });
+
+    it('should create error with message only', () => {
+      const error = new PlaywrightNativeApiError('Simple error');
+
+      expect(error.message).toBe('Simple error');
+      expect(error.endpoint).toBeUndefined();
+      expect(error.method).toBeUndefined();
+    });
+  });
+
+  describe('test spec parsing', () => {
+    it('should handle absolute URLs', async () => {
+      mockRequestContext.fetch.mockResolvedValue({
+        status: () => 200,
+        headers: () => ({ 'content-type': 'application/json' }),
+        json: async () => ({}),
+        text: async () => '{}'
+      });
+
+      const config: NativeApiTestConfig = {
+        target: {
+          baseUrl: 'https://api.example.com',
+          smoke: ['GET https://other-api.com/health -> 200']
+        }
+      };
+
+      const result = await adapter.runSmokeTests(config);
+
+      expect(mockRequestContext.fetch).toHaveBeenCalledWith(
+        'https://other-api.com/health',
+        expect.any(Object)
+      );
+    });
+
+    it('should handle relative URLs', async () => {
+      mockRequestContext.fetch.mockResolvedValue({
+        status: () => 200,
+        headers: () => ({ 'content-type': 'application/json' }),
+        json: async () => ({}),
+        text: async () => '{}'
+      });
+
+      const config: NativeApiTestConfig = {
+        target: {
+          baseUrl: 'https://api.example.com',
+          smoke: ['GET /api/v1/users -> 200']
+        }
+      };
+
+      const result = await adapter.runSmokeTests(config);
+
+      expect(mockRequestContext.fetch).toHaveBeenCalledWith(
+        'https://api.example.com/api/v1/users',
+        expect.any(Object)
+      );
+    });
+
+    it('should handle URLs without leading slash', async () => {
+      mockRequestContext.fetch.mockResolvedValue({
+        status: () => 200,
+        headers: () => ({ 'content-type': 'application/json' }),
+        json: async () => ({}),
+        text: async () => '{}'
+      });
+
+      const config: NativeApiTestConfig = {
+        target: {
+          baseUrl: 'https://api.example.com/api',
+          smoke: ['GET users -> 200']
+        }
+      };
+
+      const result = await adapter.runSmokeTests(config);
+
+      expect(mockRequestContext.fetch).toHaveBeenCalledWith(
+        'https://api.example.com/api/users',
+        expect.any(Object)
+      );
+    });
+
+    it('should handle different HTTP methods', async () => {
+      // Mock with different status codes per call
+      let callIndex = 0;
+      const statusCodes = [200, 201, 200, 200, 204];
+      mockRequestContext.fetch.mockImplementation(async () => {
+        return {
+          status: () => statusCodes[callIndex++ % statusCodes.length],
+          headers: () => ({ 'content-type': 'application/json' }),
+          json: async () => ({}),
+          text: async () => '{}'
+        };
+      });
+
+      const config: NativeApiTestConfig = {
+        target: {
+          baseUrl: 'https://api.example.com',
+          smoke: [
+            'GET /resource -> 200',
+            'POST /resource -> 201',
+            'PUT /resource/1 -> 200',
+            'PATCH /resource/1 -> 200',
+            'DELETE /resource/1 -> 204'
+          ]
+        }
+      };
+
+      await adapter.runSmokeTests(config);
+
+      expect(mockRequestContext.fetch).toHaveBeenCalledTimes(5);
+
+      const calls = vi.mocked(mockRequestContext.fetch).mock.calls;
+      expect(calls[0][1]?.method).toBe('GET');
+      expect(calls[1][1]?.method).toBe('POST');
+      expect(calls[2][1]?.method).toBe('PUT');
+      expect(calls[3][1]?.method).toBe('PATCH');
+      expect(calls[4][1]?.method).toBe('DELETE');
+    });
+  });
+});