qa360 2.1.2 → 2.1.4

package/core/src/assertions/types.ts

@@ -0,0 +1,229 @@
+/**
+ * QA360 Assertions Engine - Type Definitions
+ *
+ * Comprehensive assertions for UI testing
+ */
+
+/**
+ * Assertion types
+ */
+export type AssertionType =
+  | 'visible'        // Element is visible in viewport
+  | 'hidden'         // Element is hidden or not in DOM
+  | 'attached'       // Element is in DOM
+  | 'detached'       // Element is not in DOM
+  | 'text'           // Element has exact text content
+  | 'contains'       // Element contains text
+  | 'matches'        // Element text matches regex
+  | 'value'          // Input/element has value
+  | 'attribute'      // Element has attribute value
+  | 'class'          // Element has CSS class
+  | 'count'          // Count of elements matches
+  | 'url'            // Current URL matches pattern
+  | 'urlContains'    // URL contains string
+  | 'title'          // Page title matches
+  | 'titleContains'  // Title contains string
+  | 'enabled'        // Element is enabled
+  | 'disabled'       // Element is disabled
+  | 'checked'        // Checkbox/radio is checked
+  | 'unchecked'      // Checkbox/radio is unchecked
+  | 'focused'        // Element has focus
+  | 'empty'          // Element is empty (no text/children)
+  | 'notEmpty'       // Element has content
+  | 'readOnly'       // Element is read-only
+  | 'editable'       // Element is editable
+  | 'selected'       // Option is selected
+  | 'href'           // Link has href
+  | 'src'            // Image/element has src
+  | 'placeholder'    // Input has placeholder
+  | 'id'             // Element has specific ID
+  | 'tagName'        // Element has specific tag name
+  | 'css'            // Element has CSS property value
+  | 'boundingBox'    // Element has position/size
+  | 'inViewport'     // Element is in viewport
+  | 'hasAttribute';  // Element has attribute (any value)
+
+/**
+ * Assertion operators
+ */
+export type AssertionOperator =
+  | 'eq'             // Equals
+  | 'ne'             // Not equals
+  | 'contains'       // Contains
+  | 'notContains'    // Does not contain
+  | 'matches'        // Matches regex
+  | 'notMatches'     // Does not match regex
+  | 'gt'             // Greater than
+  | 'gte'            // Greater than or equal
+  | 'lt'             // Less than
+  | 'lte'            // Less than or equal
+  | 'startsWith'     // Starts with
+  | 'endsWith'       // Ends with
+  | 'isEmpty'        // Is empty
+  | 'notEmpty';      // Is not empty
+
+/**
+ * Assertion definition
+ */
+export interface Assertion {
+  /** Assertion type */
+  type: AssertionType;
+
+  /** CSS selector for element (not needed for url, title) */
+  selector?: string;
+
+  /** Expected value */
+  expected?: any;
+
+  /** Operator for comparison (default: 'eq') */
+  operator?: AssertionOperator;
+
+  /** Whether to negate the assertion */
+  not?: boolean;
+
+  /** Timeout in milliseconds (default: 5000) */
+  timeout?: number;
+
+  /** Assertion message/description */
+  message?: string;
+
+  /** Whether this is a soft assertion (doesn't stop test) */
+  soft?: boolean;
+}
+
+/**
+ * Assertion result
+ */
+export interface AssertionResult {
+  /** The assertion that was run */
+  assertion: Assertion;
+
+  /** Whether the assertion passed */
+  passed: boolean;
+
+  /** Actual value received */
+  actual?: any;
+
+  /** Expected value */
+  expected?: any;
+
+  /** Error message if failed */
+  error?: string;
+
+  /** Duration in milliseconds */
+  duration: number;
+
+  /** Timestamp */
+  timestamp: string;
+}
+
+/**
+ * Assertion suite
+ */
+export interface AssertionSuite {
+  /** Suite name */
+  name: string;
+
+  /** List of assertions */
+  assertions: Assertion[];
+
+  /** Run all assertions in parallel */
+  parallel?: boolean;
+
+  /** Stop on first failure */
+  stopOnFailure?: boolean;
+}
+
+/**
+ * Assertion run options
+ */
+export interface AssertionRunOptions {
+  /** Playwright Page object */
+  page: any;
+
+  /** Default timeout for assertions */
+  timeout?: number;
+
+  /** Whether to throw on failure */
+  throwOnFailure?: boolean;
+
+  /** Callback for assertion results */
+  onResult?: (result: AssertionResult) => void;
+
+  /** Stop on first failure */
+  stopOnFailure?: boolean;
+
+  /** Run assertions in parallel */
+  parallel?: boolean;
+
+  /** Name for the assertion group */
+  name?: string;
+}
+
+/**
+ * Assertion error
+ */
+export class AssertionError extends Error {
+  assertion: Assertion;
+  actual?: any;
+  expected?: any;
+
+  constructor(
+    message: string,
+    assertion: Assertion,
+    actual?: any,
+    expected?: any
+  ) {
+    super(message);
+    this.name = 'AssertionError';
+    this.assertion = assertion;
+    this.actual = actual;
+    this.expected = expected;
+  }
+
+  toString(): string {
+    const expected = this.expected !== undefined ? ` expected: ${JSON.stringify(this.expected)}` : '';
+    const actual = this.actual !== undefined ? ` actual: ${JSON.stringify(this.actual)}` : '';
+    return `${this.message}${expected}${actual}`;
+  }
+}
+
+/**
+ * Soft assertion collection
+ */
+export class SoftAssertionError extends Error {
+  results: AssertionResult[];
+
+  constructor(results: AssertionResult[]) {
+    const failures = results.filter(r => !r.passed);
+    super(`${failures.length} soft assertion(s) failed:\n${failures.map(f => `  - ${f.error || f.assertion.message || f.assertion.type}`).join('\n')}`);
+    this.name = 'SoftAssertionError';
+    this.results = results;
+  }
+}
+
+/**
+ * Assertion group result
+ */
+export interface AssertionGroupResult {
+  /** Group name */
+  name: string;
+
+  /** Individual results */
+  results: AssertionResult[];
+
+  /** Overall pass status */
+  passed: boolean;
+
+  /** Total duration */
+  duration: number;
+
+  /** Number of passed assertions */
+  passedCount: number;
+
+  /** Number of failed assertions */
+  failedCount: number;
+
+  /** Number of skipped assertions */
+  skippedCount: number;
+}

package/core/src/auth/__tests__/api-key-provider.test.ts

@@ -0,0 +1,282 @@
+/**
+ * API Key Provider - Unit Tests
+ *
+ * Tests API key authentication in headers and query parameters.
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { APIKeyProvider, APIKeyAuthConfig, authCache } from '../index.js';
+
+describe('APIKeyProvider', () => {
+  let provider: APIKeyProvider;
+
+  beforeEach(() => {
+    provider = new APIKeyProvider();
+    vi.clearAllMocks();
+    // Clear cache before each test to ensure isolation
+    authCache.clear();
+  });
+
+  // ============================================================
+  // Constructor Tests
+  // ============================================================
+  describe('constructor', () => {
+    it('should have type api_key', () => {
+      expect(provider.type).toBe('api_key');
+    });
+  });
+
+  // ============================================================
+  // authenticate with header location
+  // ============================================================
+  describe('authenticate with header', () => {
+    it('should authenticate with default header name', async () => {
+      const config: APIKeyAuthConfig = {
+        type: 'api_key',
+        key: 'my-secret-api-key-123'
+      };
+
+      const result = await provider.authenticate(config);
+
+      expect(result.success).toBe(true);
+      expect(result.credentials?.headers?.['X-API-Key']).toBe('my-secret-api-key-123');
+    });
+
+    it('should use custom header name', async () => {
+      const config: APIKeyAuthConfig = {
+        type: 'api_key',
+        key: 'secret-key',
+        header_name: 'X-Custom-Auth',
+        cache: { enabled: false }
+      };
+
+      const result = await provider.authenticate(config);
+
+      expect(result.success).toBe(true);
+      expect(result.credentials?.headers?.['X-Custom-Auth']).toBe('secret-key');
+    });
+
+    it('should add prefix to key', async () => {
+      const config: APIKeyAuthConfig = {
+        type: 'api_key',
+        key: 'actual-key',
+        prefix: 'Bearer ',
+        cache: { enabled: false }
+      };
+
+      const result = await provider.authenticate(config);
+
+      expect(result.success).toBe(true);
+      expect(result.credentials?.headers?.['X-API-Key']).toBe('Bearer actual-key');
+    });
+
+    it('should handle prefix without space', async () => {
+      const config: APIKeyAuthConfig = {
+        type: 'api_key',
+        key: 'actual-key',
+        prefix: 'Token',
+        cache: { enabled: false }
+      };
+
+      const result = await provider.authenticate(config);
+
+      expect(result.success).toBe(true);
+      // Prefix is used as-is, no automatic space added
+      expect(result.credentials?.headers?.['X-API-Key']).toBe('Tokenactual-key');
+    });
+
+    it('should handle both custom header and prefix', async () => {
+      const config: APIKeyAuthConfig = {
+        type: 'api_key',
+        key: 'my-key',
+        header_name: 'Authorization',
+        prefix: 'Bearer '
+      };
+
+      const result = await provider.authenticate(config);
+
+      expect(result.success).toBe(true);
+      expect(result.credentials?.headers?.['Authorization']).toBe('Bearer my-key');
+    });
+  });
+
+  // ============================================================
+  // authenticate with query location
+  // ============================================================
+  describe('authenticate with query params', () => {
+    it('should put key in query params', async () => {
+      const config: APIKeyAuthConfig = {
+        type: 'api_key',
+        key: 'query-key-123',
+        location: 'query'
+      };
+
+      const result = await provider.authenticate(config);
+
+      expect(result.success).toBe(true);
+      expect(result.credentials?.queryParams?.['api_key']).toBe('query-key-123');
+    });
+
+    it('should handle prefix with query params', async () => {
+      const config: APIKeyAuthConfig = {
+        type: 'api_key',
+        key: 'bare-key',
+        location: 'query',
+        prefix: 'key:'
+      };
+
+      const result = await provider.authenticate(config);
+
+      expect(result.success).toBe(true);
+      expect(result.credentials?.queryParams?.['api_key']).toBe('key:bare-key');
+    });
+  });
+
+  // ============================================================
+  // Caching
+  // ============================================================
+  describe('caching', () => {
+    it('should cache credentials when enabled', async () => {
+      const { authCache } = await import('../index.js');
+
+      const config: APIKeyAuthConfig = {
+        type: 'api_key',
+        key: 'cached-key',
+        cache: { enabled: true, ttl: 60 }
+      };
+
+      await provider.authenticate(config);
+
+      // Cache key is 'api_key:default' when no header_name is provided
+      expect(authCache.has('api_key:default')).toBe(true);
+
+      // Clean up
+      authCache.clear('api_key:default');
+    });
+
+    it('should not cache when disabled', async () => {
+      const { authCache } = await import('../index.js');
+
+      const config: APIKeyAuthConfig = {
+        type: 'api_key',
+        key: 'uncached-key',
+        cache: { enabled: false }
+      };
+
+      await provider.authenticate(config);
+
+      expect(authCache.has('api_key:default')).toBe(false);
+    });
+  });
+
+  // ============================================================
+  // clear
+  // ============================================================
+  describe('clear', () => {
+    it('should clear cached credentials', async () => {
+      const { authCache } = await import('../index.js');
+
+      const config: APIKeyAuthConfig = {
+        type: 'api_key',
+        key: 'test-key',
+        cache: { enabled: true }
+      };
+
+      await provider.authenticate(config);
+      await provider.clear(config);
+
+      expect(authCache.has('api_key:default')).toBe(false);
+    });
+  });
+
+  // ============================================================
+  // validate
+  // ============================================================
+  describe('validate', () => {
+    it('should validate non-empty key', async () => {
+      const config: APIKeyAuthConfig = {
+        type: 'api_key',
+        key: 'valid-key'
+      };
+
+      const isValid = await provider.validate(config);
+      expect(isValid).toBe(true);
+    });
+
+    it('should reject empty key', async () => {
+      const config: APIKeyAuthConfig = {
+        type: 'api_key',
+        key: ''
+      };
+
+      const isValid = await provider.validate(config);
+      expect(isValid).toBe(false);
+    });
+
+    it('should validate cached credentials', async () => {
+      const config: APIKeyAuthConfig = {
+        type: 'api_key',
+        key: 'cached-key',
+        cache: { enabled: true }
+      };
+
+      await provider.authenticate(config);
+      const isValid = await provider.validate(config);
+
+      expect(isValid).toBe(true);
+    });
+  });
+
+  // ============================================================
+  // Edge Cases
+  // ============================================================
+  describe('edge cases', () => {
+    it('should handle special characters in key', async () => {
+      const config: APIKeyAuthConfig = {
+        type: 'api_key',
+        key: 'key-with-special-chars_!@#$%^&*()'
+      };
+
+      const result = await provider.authenticate(config);
+
+      expect(result.success).toBe(true);
+      expect(result.credentials?.headers?.['X-API-Key']).toBe('key-with-special-chars_!@#$%^&*()');
+    });
+
+    it('should handle Unicode in key', async () => {
+      const config: APIKeyAuthConfig = {
+        type: 'api_key',
+        key: ' clé-avec-accents-éèà '
+      };
+
+      const result = await provider.authenticate(config);
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should handle very long key', async () => {
+      const longKey = 'a'.repeat(5000);
+      const config: APIKeyAuthConfig = {
+        type: 'api_key',
+        key: longKey
+      };
+
+      const result = await provider.authenticate(config);
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should handle key with whitespace', async () => {
+      const config: APIKeyAuthConfig = {
+        type: 'api_key',
+        key: '  spaced-key  '
+      };
+
+      const result = await provider.authenticate(config);
+
+      expect(result.success).toBe(true);
+      // Key is not trimmed by default - preserve exact value
+      expect(result.credentials?.headers?.['X-API-Key']).toBe('  spaced-key  ');
+    });
+  });
+});