qa360 2.1.2 → 2.1.4

package/tests/contracts.spec.js

@@ -0,0 +1,239 @@
+// tests/contracts.spec.js - Tests contractuels pour validation automatique
+import { test, expect } from '@playwright/test';
+
+const BASE_URL = process.env.BASE_URL || 'https://qa360-cloud-preview.vercel.app';
+
+test.describe('API Contracts Validation', () => {
+  
+  test('POST /api/runpack should return 201 with valid schema', async ({ request }) => {
+    const response = await request.post(`${BASE_URL}/api/runpack`, {
+      headers: {
+        'Content-Type': 'application/json',
+        'Origin': BASE_URL
+      },
+      data: { pack: 'httpbin' }
+    });
+
+    expect(response.status()).toBe(201);
+    
+    const data = await response.json();
+    
+    // Validate RunpackResponse schema
+    expect(data).toHaveProperty('success', true);
+    expect(data).toHaveProperty('pack', 'httpbin');
+    expect(data).toHaveProperty('runId');
+    expect(typeof data.runId).toBe('string');
+    expect(data.runId).toMatch(/^[0-9a-f-]{36}$/); // UUID format
+    
+    expect(data).toHaveProperty('summary');
+    expect(data.summary).toHaveProperty('tests');
+    expect(data.summary.tests).toHaveProperty('passed');
+    expect(data.summary.tests).toHaveProperty('failed');
+    expect(data.summary.tests).toHaveProperty('skipped');
+    expect(typeof data.summary.tests.passed).toBe('number');
+    expect(typeof data.summary.tests.failed).toBe('number');
+    expect(typeof data.summary.tests.skipped).toBe('number');
+    expect(data.summary).toHaveProperty('durationMs');
+    expect(typeof data.summary.durationMs).toBe('number');
+    
+    expect(data).toHaveProperty('routes');
+    expect(Array.isArray(data.routes)).toBe(true);
+    expect(data.routes.length).toBeGreaterThan(0);
+    
+    // Validate first route
+    const route = data.routes[0];
+    expect(route).toHaveProperty('method');
+    expect(route).toHaveProperty('path');
+    expect(route).toHaveProperty('status');
+    expect(route).toHaveProperty('durationMs');
+    expect(typeof route.method).toBe('string');
+    expect(typeof route.path).toBe('string');
+    expect(typeof route.status).toBe('string');
+    expect(typeof route.durationMs).toBe('number');
+    
+    expect(data).toHaveProperty('links');
+    expect(data.links).toHaveProperty('reportJson');
+    expect(data.links).toHaveProperty('pdf');
+    expect(data.links).toHaveProperty('deepLink');
+    expect(typeof data.links.reportJson).toBe('string');
+    expect(typeof data.links.pdf).toBe('string');
+    expect(typeof data.links.deepLink).toBe('string');
+  });
+
+  test('GET /api/report/gherkin should return 200 with valid schema', async ({ request }) => {
+    const response = await request.get(`${BASE_URL}/api/report/gherkin?pack=httpbin&runId=test-123`);
+    
+    expect(response.status()).toBe(200);
+    
+    const data = await response.json();
+    
+    // Validate GherkinReport schema
+    expect(data).toHaveProperty('pack', 'httpbin');
+    expect(data).toHaveProperty('runId', 'test-123');
+    expect(data).toHaveProperty('timestamp');
+    expect(typeof data.timestamp).toBe('string');
+    
+    expect(data).toHaveProperty('summary');
+    expect(data.summary).toHaveProperty('tests');
+    expect(data.summary.tests).toHaveProperty('passed');
+    expect(data.summary.tests).toHaveProperty('failed');
+    expect(data.summary.tests).toHaveProperty('skipped');
+    
+    expect(data).toHaveProperty('routes');
+    expect(Array.isArray(data.routes)).toBe(true);
+    expect(data.routes.length).toBeGreaterThan(0);
+    
+    expect(data).toHaveProperty('gherkin');
+    expect(data.gherkin).toHaveProperty('feature');
+    expect(data.gherkin).toHaveProperty('scenarios');
+    expect(Array.isArray(data.gherkin.scenarios)).toBe(true);
+    
+    // Validate first scenario
+    const scenario = data.gherkin.scenarios[0];
+    expect(scenario).toHaveProperty('name');
+    expect(scenario).toHaveProperty('steps');
+    expect(scenario).toHaveProperty('status');
+    expect(scenario).toHaveProperty('durationMs');
+    expect(Array.isArray(scenario.steps)).toBe(true);
+    
+    // Validate first step
+    const step = scenario.steps[0];
+    expect(step).toHaveProperty('keyword');
+    expect(step).toHaveProperty('text');
+    expect(typeof step.keyword).toBe('string');
+    expect(typeof step.text).toBe('string');
+    
+    expect(data).toHaveProperty('artifacts');
+    expect(data.artifacts).toHaveProperty('video');
+    expect(data.artifacts).toHaveProperty('logs');
+    expect(data.artifacts).toHaveProperty('screenshots');
+  });
+
+  test('GET /api/report/index should return 200 with valid schema', async ({ request }) => {
+    const response = await request.get(`${BASE_URL}/api/report/index?pack=httpbin`);
+    
+    expect(response.status()).toBe(200);
+    
+    const data = await response.json();
+    
+    // Validate RunIndexResponse schema
+    expect(data).toHaveProperty('pack', 'httpbin');
+    expect(data).toHaveProperty('runs');
+    expect(Array.isArray(data.runs)).toBe(true);
+    expect(data).toHaveProperty('total');
+    expect(data).toHaveProperty('limit');
+    expect(data).toHaveProperty('offset');
+    expect(typeof data.total).toBe('number');
+    expect(typeof data.limit).toBe('number');
+    expect(typeof data.offset).toBe('number');
+  });
+
+  test('GET /api/kpi should return 200 with valid schema', async ({ request }) => {
+    const response = await request.get(`${BASE_URL}/api/kpi`);
+    
+    expect(response.status()).toBe(200);
+    
+    const data = await response.json();
+    
+    // Validate KPI response
+    expect(data).toHaveProperty('success', true);
+    expect(data).toHaveProperty('kpis');
+    expect(data).toHaveProperty('timestamp');
+    expect(typeof data.kpis).toBe('object');
+    expect(typeof data.timestamp).toBe('string');
+  });
+
+  test('POST /api/runpack with invalid request should return 400', async ({ request }) => {
+    const response = await request.post(`${BASE_URL}/api/runpack`, {
+      headers: {
+        'Content-Type': 'application/json',
+        'Origin': BASE_URL
+      },
+      data: { invalid: 'data' }
+    });
+
+    expect(response.status()).toBe(400);
+    
+    const data = await response.json();
+    expect(data).toHaveProperty('error');
+    expect(data.error).toContain('invalid');
+  });
+
+  test('POST /api/runpack with unknown pack should return 400', async ({ request }) => {
+    const response = await request.post(`${BASE_URL}/api/runpack`, {
+      headers: {
+        'Content-Type': 'application/json',
+        'Origin': BASE_URL
+      },
+      data: { pack: 'unknown-pack' }
+    });
+
+    expect(response.status()).toBe(400);
+    
+    const data = await response.json();
+    expect(data).toHaveProperty('error', 'invalid_pack');
+    expect(data).toHaveProperty('message');
+    expect(data.message).toContain('Expected one of');
+  });
+
+  test('All supported packs should work', async ({ request }) => {
+    const packs = ['httpbin', 'petstore', 'custom-api', 'graphql-swapi', 'realworld-api'];
+    
+    for (const pack of packs) {
+      const response = await request.post(`${BASE_URL}/api/runpack`, {
+        headers: {
+          'Content-Type': 'application/json',
+          'Origin': BASE_URL
+        },
+        data: { pack }
+      });
+
+      expect(response.status()).toBe(201);
+      
+      const data = await response.json();
+      expect(data.success).toBe(true);
+      expect(data.pack).toBe(pack);
+      expect(data.routes.length).toBeGreaterThan(0);
+    }
+  });
+});
+
+test.describe('Deep Links Validation', () => {
+  
+  test('Deep link should be accessible after deploy', async ({ page }) => {
+    // Test that deep link page loads
+    await page.goto(`${BASE_URL}/r/httpbin/test-123`);
+    
+    // Should not be 404
+    expect(page.url()).toContain('/r/httpbin/test-123');
+    
+    // Should load report content
+    await expect(page.locator('h1, .title')).toContainText(/test report|httpbin/i);
+    
+    // Should have routes table
+    await expect(page.locator('table, .routes-table')).toBeVisible();
+  });
+
+  test('Modal should work on detail page', async ({ page }) => {
+    await page.goto(`${BASE_URL}/r/httpbin/test-123`);
+    
+    // Wait for content to load
+    await page.waitForSelector('table', { timeout: 10000 });
+    
+    // Click modal button if exists
+    const modalButton = page.locator('button:has-text("Modal")').first();
+    if (await modalButton.isVisible()) {
+      await modalButton.click();
+      
+      // Modal should appear
+      await expect(page.locator('.modal')).toBeVisible();
+      
+      // Should have Gherkin steps
+      await expect(page.locator('.gherkin-step')).toBeVisible();
+      
+      // Close modal
+      await page.locator('.modal-close').click();
+      await expect(page.locator('.modal')).not.toBeVisible();
+    }
+  });
+});

package/tests/e2e/assertions.test.mjs

@@ -0,0 +1,370 @@
+#!/usr/bin/env node
+/**
+ * QA360 Assertions Engine E2E Tests (No Mocks)
+ *
+ * Real tests using actual browser and local HTTP server
+ * Tests all assertion types: visible, text, value, attribute, etc.
+ * Usage: node tests/e2e/assertions.test.mjs
+ */
+
+import { chromium } from '@playwright/test';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import http from 'http';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Test utilities
+let testsPassed = 0;
+let testsFailed = 0;
+
+function log(message, type = 'info') {
+  const colors = {
+    info: '\x1b[36m',
+    success: '\x1b[32m',
+    error: '\x1b[31m',
+    warning: '\x1b[33m',
+    dim: '\x1b[90m',
+  };
+  const reset = '\x1b[0m';
+  console.log(`${colors[type] || ''}${message}${reset}`);
+}
+
+function assert(condition, message) {
+  if (condition) {
+    testsPassed++;
+    log(`  OK ${message}`, 'success');
+  } else {
+    testsFailed++;
+    log(`  FAIL ${message}`, 'error');
+    throw new Error(`Assertion failed: ${message}`);
+  }
+}
+
+function assertEqual(actual, expected, message) {
+  if (actual === expected) {
+    testsPassed++;
+    log(`  OK ${message}`, 'success');
+  } else {
+    testsFailed++;
+    log(`  FAIL ${message}`, 'error');
+    log(`     Expected: "${expected}"`, 'dim');
+    log(`     Got: "${actual}"`, 'dim');
+    throw new Error(`Assertion failed: ${message}`);
+  }
+}
+
+// Simple HTTP server with test elements
+class TestServer {
+  constructor() {
+    this.server = null;
+    this.port = 0;
+  }
+
+  start() {
+    return new Promise((resolve) => {
+      this.server = http.createServer((req, res) => {
+        res.writeHead(200, { 'Content-Type': 'text/html' });
+        res.end(`
+          <!DOCTYPE html>
+          <html>
+          <head><title>Assertions Test Page</title></head>
+          <body>
+            <h1>Assertions Test Page</h1>
+            <div id="visible-element" data-testid="visible">Visible Content</div>
+            <div id="hidden-element" style="display:none" data-testid="hidden">Hidden Content</div>
+            <p id="text-content" data-testid="text-para">Hello World</p>
+            <p id="partial-text" data-testid="partial-para">The quick brown fox</p>
+            <input type="text" id="text-input" value="initial value" data-testid="text-input-el" />
+            <input type="email" id="email-input" value="test@example.com" data-testid="email-input-el" />
+            <button id="btn-primary" class="btn btn-primary" data-action="submit" data-testid="attr-btn">Submit</button>
+            <a href="/target" id="link-element" data-testid="link-el">Link</a>
+            <input type="text" id="enabled-input" data-testid="enabled-el" />
+            <input type="text" id="disabled-input" disabled data-testid="disabled-el" />
+            <input type="checkbox" id="checked-checkbox" checked data-testid="checked-el" />
+            <input type="checkbox" id="unchecked-checkbox" data-testid="unchecked-el" />
+            <ul id="list" data-testid="list-el">
+              <li>Item 1</li>
+              <li>Item 2</li>
+              <li>Item 3</li>
+            </ul>
+            <input type="text" id="search-input" placeholder="Search..." data-testid="placeholder-el" />
+            <div id="multi-class" class="container wrapper main" data-testid="multi-class-el">Multi Class</div>
+            <div id="empty-div" data-testid="empty-el"></div>
+            <div id="not-empty-div" data-testid="not-empty-el">Has content</div>
+            <input type="text" id="readonly-input" readonly value="readonly" data-testid="readonly-el" />
+            <input type="text" id="editable-input" value="editable" data-testid="editable-el" />
+          </body>
+          </html>
+        `);
+      });
+
+      this.server.listen(0, () => {
+        this.port = this.server.address().port;
+        log(`  Test server started on port ${this.port}`, 'dim');
+        resolve();
+      });
+    });
+  }
+
+  stop() {
+    return new Promise((resolve) => {
+      if (this.server) {
+        this.server.close(() => {
+          log('  Test server stopped', 'dim');
+          resolve();
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+}
+
+// ============================================================================
+// ASSERTION TESTS
+// ============================================================================
+
+async function testVisibleAssertion() {
+  log('\n[Test 1] Visible assertion', 'info');
+
+  const server = new TestServer();
+  await server.start();
+
+  let browser;
+  try {
+    browser = await chromium.launch({ headless: true });
+    const page = await browser.newPage();
+    await page.goto(`http://localhost:${server.port}`);
+
+    const isVisible = await page.isVisible('[data-testid="visible"]');
+    assert(isVisible, 'Visible element is detected as visible');
+
+    const isHidden = await page.isHidden('[data-testid="hidden"]');
+    assert(isHidden, 'Hidden element is detected as hidden');
+
+  } finally {
+    if (browser) await browser.close();
+    await server.stop();
+  }
+}
+
+async function testTextAssertion() {
+  log('\n[Test 2] Text content assertion', 'info');
+
+  const server = new TestServer();
+  await server.start();
+
+  let browser;
+  try {
+    browser = await chromium.launch({ headless: true });
+    const page = await browser.newPage();
+    await page.goto(`http://localhost:${server.port}`);
+
+    const text = await page.textContent('[data-testid="text-para"]');
+    assertEqual(text, 'Hello World', 'Text content matches exactly');
+
+    const partialText = await page.textContent('[data-testid="partial-para"]');
+    assert(partialText.includes('brown fox'), 'Partial text is contained');
+
+  } finally {
+    if (browser) await browser.close();
+    await server.stop();
+  }
+}
+
+async function testValueAssertion() {
+  log('\n[Test 3] Input value assertion', 'info');
+
+  const server = new TestServer();
+  await server.start();
+
+  let browser;
+  try {
+    browser = await chromium.launch({ headless: true });
+    const page = await browser.newPage();
+    await page.goto(`http://localhost:${server.port}`);
+
+    const value = await page.inputValue('[data-testid="text-input-el"]');
+    assertEqual(value, 'initial value', 'Input value matches');
+
+    const emailValue = await page.inputValue('[data-testid="email-input-el"]');
+    assertEqual(emailValue, 'test@example.com', 'Email input value matches');
+
+  } finally {
+    if (browser) await browser.close();
+    await server.stop();
+  }
+}
+
+async function testAttributeAssertion() {
+  log('\n[Test 4] Attribute assertion', 'info');
+
+  const server = new TestServer();
+  await server.start();
+
+  let browser;
+  try {
+    browser = await chromium.launch({ headless: true });
+    const page = await browser.newPage();
+    await page.goto(`http://localhost:${server.port}`);
+
+    const className = await page.getAttribute('[data-testid="attr-btn"]', 'class');
+    assert(className.includes('btn-primary'), 'Class attribute contains btn-primary');
+
+    const action = await page.getAttribute('[data-testid="attr-btn"]', 'data-action');
+    assertEqual(action, 'submit', 'Data-action attribute matches');
+
+    const href = await page.getAttribute('[data-testid="link-el"]', 'href');
+    assertEqual(href, '/target', 'Href attribute matches');
+
+  } finally {
+    if (browser) await browser.close();
+    await server.stop();
+  }
+}
+
+async function testEnabledDisabledAssertion() {
+  log('\n[Test 5] Enabled/Disabled assertion', 'info');
+
+  const server = new TestServer();
+  await server.start();
+
+  let browser;
+  try {
+    browser = await chromium.launch({ headless: true });
+    const page = await browser.newPage();
+    await page.goto(`http://localhost:${server.port}`);
+
+    const isEnabled = await page.isEnabled('[data-testid="enabled-el"]');
+    assert(isEnabled, 'Enabled input is enabled');
+
+    const isDisabled = await page.isDisabled('[data-testid="disabled-el"]');
+    assert(isDisabled, 'Disabled input is disabled');
+
+  } finally {
+    if (browser) await browser.close();
+    await server.stop();
+  }
+}
+
+async function testCheckedAssertion() {
+  log('\n[Test 6] Checked/Unchecked assertion', 'info');
+
+  const server = new TestServer();
+  await server.start();
+
+  let browser;
+  try {
+    browser = await chromium.launch({ headless: true });
+    const page = await browser.newPage();
+    await page.goto(`http://localhost:${server.port}`);
+
+    const isChecked = await page.isChecked('[data-testid="checked-el"]');
+    assert(isChecked, 'Checked checkbox is checked');
+
+    const isUnchecked = await page.isChecked('[data-testid="unchecked-el"]');
+    assert(!isUnchecked, 'Unchecked checkbox is not checked');
+
+  } finally {
+    if (browser) await browser.close();
+    await server.stop();
+  }
+}
+
+async function testCountAssertion() {
+  log('\n[Test 7] Element count assertion', 'info');
+
+  const server = new TestServer();
+  await server.start();
+
+  let browser;
+  try {
+    browser = await chromium.launch({ headless: true });
+    const page = await browser.newPage();
+    await page.goto(`http://localhost:${server.port}`);
+
+    const count = await page.locator('#list li').count();
+    assertEqual(count, 3, 'List has 3 items');
+
+  } finally {
+    if (browser) await browser.close();
+    await server.stop();
+  }
+}
+
+async function testComplexAssertions() {
+  log('\n[Test 8] Complex multi-step assertions', 'info');
+
+  const server = new TestServer();
+  await server.start();
+
+  let browser;
+  try {
+    browser = await chromium.launch({ headless: true });
+    const page = await browser.newPage();
+    await page.goto(`http://localhost:${server.port}`);
+
+    const title = await page.title();
+    assertEqual(title, 'Assertions Test Page', 'Page title correct');
+
+    const element = await page.$('[data-testid="visible"]');
+    assert(element !== null, 'Element exists');
+
+    const text = await page.textContent('[data-testid="text-para"]');
+    const value = await page.inputValue('[data-testid="text-input-el"]');
+    assert(text === 'Hello World' && value === 'initial value', 'Multiple assertions pass');
+
+    log('  OK Complex multi-step assertions passed', 'success');
+    testsPassed++;
+
+  } finally {
+    if (browser) await browser.close();
+    await server.stop();
+  }
+}
+
+// ============================================================================
+// MAIN
+// ============================================================================
+
+async function main() {
+  log('\nQA360 Assertions E2E Tests (No Mocks)', 'info');
+  log('='.repeat(60), 'info');
+
+  const tests = [
+    testVisibleAssertion,
+    testTextAssertion,
+    testValueAssertion,
+    testAttributeAssertion,
+    testEnabledDisabledAssertion,
+    testCheckedAssertion,
+    testCountAssertion,
+    testComplexAssertions,
+  ];
+
+  for (const test of tests) {
+    try {
+      await test();
+    } catch (error) {
+      if (!error.message.includes('Assertion failed')) {
+        log(`  ERROR ${error.message}`, 'error');
+      }
+    }
+  }
+
+  log('\n' + '='.repeat(60), 'info');
+  log(`\nResults: ${testsPassed} passed, ${testsFailed} failed`, 'info');
+
+  if (testsFailed > 0) {
+    process.exit(1);
+  } else {
+    log('\nAll E2E tests passed!', 'success');
+  }
+}
+
+main().catch(error => {
+  console.error(error);
+  process.exit(1);
+});