qa360 2.1.2 → 2.1.4

package/tests/gherkin.e2e.spec.ts

@@ -0,0 +1,310 @@
+// QA360 Gherkin E2E Tests
+// Validates complete Gherkin + Traceability workflow
+
+import { test, expect } from '@playwright/test';
+
+test.describe('QA360 Gherkin + Traceability E2E', () => {
+  const baseURL = process.env.QA360_BASE_URL || 'https://qa360-cloud-preview.vercel.app';
+  const apiKey = process.env.QA360_API_KEY || '176402b75ec5a56176fc99a1139f3bd16268cd4b1e71798d5dd55c76f33b69de';
+
+  test('should generate and display Gherkin report for httpbin pack', async ({ page, request }) => {
+    // Step 1: Execute pack to generate Gherkin report
+    const runResponse = await request.post(`${baseURL}/api/pack`, {
+      headers: {
+        'content-type': 'application/json',
+        'x-qa360-api-key': apiKey
+      },
+      data: { pack: 'httpbin' }
+    });
+
+    expect(runResponse.ok()).toBeTruthy();
+    const runData = await runResponse.json();
+    expect(runData.success).toBe(true);
+    expect(runData.runId).toBeDefined();
+    expect(runData.gherkinAvailable).toBe(true);
+
+    // Step 2: Verify Gherkin report API endpoint
+    const gherkinResponse = await request.get(`${baseURL}/api/report/gherkin?pack=httpbin&runId=${runData.runId}`);
+    expect(gherkinResponse.ok()).toBeTruthy();
+    
+    const gherkinData = await gherkinResponse.json();
+    expect(gherkinData.pack).toBe('httpbin');
+    expect(gherkinData.runId).toBe(runData.runId);
+    expect(gherkinData.summary).toBeDefined();
+    expect(gherkinData.routes).toBeDefined();
+    expect(gherkinData.routes.length).toBeGreaterThan(0);
+
+    // Validate Gherkin structure
+    const firstRoute = gherkinData.routes[0];
+    expect(firstRoute.method).toBeDefined();
+    expect(firstRoute.path).toBeDefined();
+    expect(firstRoute.scenarios).toBeDefined();
+    expect(firstRoute.scenarios.length).toBeGreaterThan(0);
+
+    const firstScenario = firstRoute.scenarios[0];
+    expect(firstScenario.feature).toBe('HTTPBin API Testing');
+    expect(firstScenario.scenario).toBeDefined();
+    expect(firstScenario.steps).toBeDefined();
+    expect(firstScenario.steps.length).toBe(3); // Given, When, Then
+    expect(firstScenario.sourceSpec).toBeDefined();
+
+    // Validate steps structure
+    const steps = firstScenario.steps;
+    expect(steps[0].type).toBe('Given');
+    expect(steps[1].type).toBe('When');
+    expect(steps[2].type).toBe('Then');
+    steps.forEach(step => {
+      expect(step.text).toBeDefined();
+      expect(step.status).toMatch(/^(passed|failed)$/);
+      expect(step.durationMs).toBeGreaterThanOrEqual(0);
+    });
+
+    // Step 3: Navigate to QA360 Cloud UI
+    await page.goto(baseURL);
+    await expect(page.locator('h1')).toContainText('QA360 Cloud Preview');
+
+    // Step 4: Execute pack from UI
+    await page.locator(`[data-pack="httpbin"] .run-btn`).click();
+    
+    // Wait for execution to complete
+    await expect(page.locator('.status.success')).toBeVisible({ timeout: 30000 });
+    
+    // Step 5: Click Gherkin View link
+    const gherkinLink = page.locator('a:has-text("📋 Gherkin View")');
+    await expect(gherkinLink).toBeVisible();
+    await gherkinLink.click();
+
+    // Step 6: Verify Gherkin modal opens
+    const modal = page.locator('#gherkin-modal');
+    await expect(modal).toBeVisible();
+    await expect(page.locator('#gherkin-title')).toContainText('📋 Gherkin Report - httpbin');
+
+    // Step 7: Verify summary section
+    await expect(page.locator('.summary')).toBeVisible();
+    await expect(page.locator('.summary')).toContainText('Test Execution Summary');
+    await expect(page.locator('.stat-item')).toHaveCount(6); // Routes, Scenarios, Steps, Passed, Failed, Pass Rate
+
+    // Step 8: Verify route sections
+    const routeSections = page.locator('.route-section');
+    await expect(routeSections).toHaveCount(4); // HTTPBin has 4 routes
+
+    // Step 9: Test route expansion
+    const firstRouteHeader = routeSections.first().locator('.route-header');
+    await expect(firstRouteHeader).toBeVisible();
+    await expect(firstRouteHeader).toContainText('GET');
+    await expect(firstRouteHeader).toContainText('/status/200');
+
+    // Click to expand first route
+    await firstRouteHeader.click();
+    const firstRouteScenarios = routeSections.first().locator('.route-scenarios');
+    await expect(firstRouteScenarios).toHaveClass(/expanded/);
+
+    // Step 10: Verify scenario content
+    const scenario = firstRouteScenarios.locator('.scenario').first();
+    await expect(scenario).toBeVisible();
+    await expect(scenario).toContainText('Feature: HTTPBin API Testing');
+    await expect(scenario).toContainText('Scenario:');
+
+    // Step 11: Verify steps display
+    const stepElements = scenario.locator('.step');
+    await expect(stepElements).toHaveCount(3);
+    
+    await expect(stepElements.nth(0)).toContainText('Given');
+    await expect(stepElements.nth(1)).toContainText('When');
+    await expect(stepElements.nth(2)).toContainText('Then');
+
+    // Step 12: Test filters
+    const passedFilter = page.locator('.filter-btn:has-text("✅ Passed")');
+    await passedFilter.click();
+    await expect(passedFilter).toHaveClass(/active/);
+
+    const failedFilter = page.locator('.filter-btn:has-text("❌ Failed")');
+    await failedFilter.click();
+    await expect(failedFilter).toHaveClass(/active/);
+
+    // Step 13: Test search functionality
+    const searchInput = page.locator('.search-input');
+    await searchInput.fill('HTTPBin');
+    await page.waitForTimeout(500); // Allow search to process
+
+    // Step 14: Test Expand All functionality
+    const expandAllBtn = page.locator('.filter-btn:has-text("Expand All")');
+    await expandAllBtn.click();
+    await expect(expandAllBtn).toContainText('Collapse All');
+
+    // Verify all routes are expanded
+    const allRouteScenarios = page.locator('.route-scenarios');
+    for (let i = 0; i < await allRouteScenarios.count(); i++) {
+      await expect(allRouteScenarios.nth(i)).toHaveClass(/expanded/);
+    }
+
+    // Step 15: Test source code viewer
+    const viewCodeLink = scenario.locator('a:has-text("💻 View Code")');
+    await viewCodeLink.click();
+
+    const sourceModal = page.locator('.source-modal');
+    await expect(sourceModal).toBeVisible();
+    await expect(sourceModal).toContainText('Source Code');
+    await expect(sourceModal).toContainText('HTTPBin API Test Suite');
+    await expect(sourceModal).toContainText('const { test, expect }');
+
+    // Close source modal
+    await sourceModal.locator('button').click();
+    await expect(sourceModal).not.toBeVisible();
+
+    // Step 16: Test PDF export link
+    const pdfLink = scenario.locator('a:has-text("📄 Export PDF")');
+    await expect(pdfLink).toBeVisible();
+    expect(await pdfLink.getAttribute('href')).toContain('/api/report/pdf');
+
+    // Step 17: Close Gherkin modal
+    await page.locator('.gherkin-close').click();
+    await expect(modal).not.toBeVisible();
+  });
+
+  test('should validate Gherkin report index endpoint', async ({ request }) => {
+    // Test the report index endpoint
+    const indexResponse = await request.get(`${baseURL}/api/report/index`);
+    expect(indexResponse.ok()).toBeTruthy();
+
+    const indexData = await indexResponse.json();
+    expect(indexData.reports).toBeDefined();
+    expect(indexData.total).toBeGreaterThanOrEqual(0);
+    expect(indexData.availablePacks).toBeDefined();
+    expect(Array.isArray(indexData.reports)).toBe(true);
+    expect(Array.isArray(indexData.availablePacks)).toBe(true);
+
+    // If reports exist, validate structure
+    if (indexData.reports.length > 0) {
+      const report = indexData.reports[0];
+      expect(report.pack).toBeDefined();
+      expect(report.runId).toBeDefined();
+      expect(report.timestamp).toBeDefined();
+      expect(report.duration).toBeGreaterThanOrEqual(0);
+      expect(report.passRate).toBeGreaterThanOrEqual(0);
+      expect(report.passRate).toBeLessThanOrEqual(100);
+      expect(report.totalTests).toBeGreaterThanOrEqual(0);
+      expect(report.passed).toBeGreaterThanOrEqual(0);
+      expect(report.failed).toBeGreaterThanOrEqual(0);
+      expect(report.routes).toBeGreaterThanOrEqual(0);
+    }
+  });
+
+  test('should validate PDF export functionality', async ({ request }) => {
+    // First run a pack to generate a report
+    const runResponse = await request.post(`${baseURL}/api/pack`, {
+      headers: {
+        'content-type': 'application/json',
+        'x-qa360-api-key': apiKey
+      },
+      data: { pack: 'httpbin' }
+    });
+
+    expect(runResponse.ok()).toBeTruthy();
+    const runData = await runResponse.json();
+
+    // Test PDF export endpoint
+    const pdfResponse = await request.get(`${baseURL}/api/report/pdf?pack=httpbin&runId=${runData.runId}`);
+    expect(pdfResponse.ok()).toBeTruthy();
+
+    const contentType = pdfResponse.headers()['content-type'];
+    expect(contentType).toContain('text/html');
+
+    const htmlContent = await pdfResponse.text();
+    expect(htmlContent).toContain('QA360 Cloud Intelligence');
+    expect(htmlContent).toContain('Enterprise Testing Platform');
+    expect(htmlContent).toContain('Test Execution Summary');
+    expect(htmlContent).toContain('HTTPBin API Testing');
+    expect(htmlContent).toContain('Document Signature:');
+  });
+
+  test('should validate multi-pack Gherkin generation', async ({ request }) => {
+    const packs = ['httpbin', 'petstore', 'custom-api'];
+    const results = [];
+
+    // Execute multiple packs
+    for (const pack of packs) {
+      const runResponse = await request.post(`${baseURL}/api/pack`, {
+        headers: {
+          'content-type': 'application/json',
+          'x-qa360-api-key': apiKey
+        },
+        data: { pack }
+      });
+
+      expect(runResponse.ok()).toBeTruthy();
+      const runData = await runResponse.json();
+      expect(runData.gherkinAvailable).toBe(true);
+
+      // Verify Gherkin report
+      const gherkinResponse = await request.get(`${baseURL}/api/report/gherkin?pack=${pack}&runId=${runData.runId}`);
+      expect(gherkinResponse.ok()).toBeTruthy();
+
+      const gherkinData = await gherkinResponse.json();
+      expect(gherkinData.pack).toBe(pack);
+      expect(gherkinData.routes).toBeDefined();
+      expect(gherkinData.routes.length).toBeGreaterThan(0);
+
+      results.push({ pack, runId: runData.runId, routes: gherkinData.routes.length });
+    }
+
+    // Verify all packs generated reports
+    expect(results).toHaveLength(3);
+    results.forEach(result => {
+      expect(result.pack).toBeDefined();
+      expect(result.runId).toBeDefined();
+      expect(result.routes).toBeGreaterThan(0);
+    });
+
+    // Verify index shows all reports
+    const indexResponse = await request.get(`${baseURL}/api/report/index?limit=10`);
+    const indexData = await indexResponse.json();
+    
+    const recentPacks = indexData.reports.slice(0, 3).map(r => r.pack);
+    packs.forEach(pack => {
+      expect(recentPacks).toContain(pack);
+    });
+  });
+
+  test('should validate ETag caching on Gherkin endpoints', async ({ request }) => {
+    // Generate a report
+    const runResponse = await request.post(`${baseURL}/api/pack`, {
+      headers: {
+        'content-type': 'application/json',
+        'x-qa360-api-key': apiKey
+      },
+      data: { pack: 'httpbin' }
+    });
+
+    const runData = await runResponse.json();
+
+    // First request to get ETag
+    const firstResponse = await request.get(`${baseURL}/api/report/gherkin?pack=httpbin&runId=${runData.runId}`);
+    expect(firstResponse.ok()).toBeTruthy();
+    
+    const etag = firstResponse.headers()['etag'];
+    expect(etag).toBeDefined();
+
+    // Second request with If-None-Match header
+    const secondResponse = await request.get(`${baseURL}/api/report/gherkin?pack=httpbin&runId=${runData.runId}`, {
+      headers: {
+        'if-none-match': etag
+      }
+    });
+
+    expect(secondResponse.status()).toBe(304); // Not Modified
+
+    // Test index endpoint caching
+    const indexResponse1 = await request.get(`${baseURL}/api/report/index`);
+    const indexEtag = indexResponse1.headers()['etag'];
+    expect(indexEtag).toBeDefined();
+
+    const indexResponse2 = await request.get(`${baseURL}/api/report/index`, {
+      headers: {
+        'if-none-match': indexEtag
+      }
+    });
+
+    expect(indexResponse2.status()).toBe(304);
+  });
+});

package/tests/no-console-errors.spec.js

@@ -0,0 +1,136 @@
+// tests/no-console-errors.spec.js - Test gate "no console errors"
+import { test, expect } from '@playwright/test';
+
+const BASE_URL = process.env.BASE_URL || 'https://qa360-cloud-preview.vercel.app';
+
+test.describe('No Console Errors Gate', () => {
+  
+  test('Homepage should load without console errors', async ({ page }) => {
+    const consoleErrors = [];
+    
+    // Intercepter les erreurs console
+    page.on('console', msg => {
+      if (msg.type() === 'error') {
+        consoleErrors.push({
+          type: msg.type(),
+          text: msg.text(),
+          location: msg.location()
+        });
+      }
+    });
+
+    // Intercepter les erreurs JavaScript non gérées
+    page.on('pageerror', error => {
+      consoleErrors.push({
+        type: 'pageerror',
+        text: error.message,
+        stack: error.stack
+      });
+    });
+
+    // Charger la page d'accueil
+    await page.goto(BASE_URL);
+    
+    // Attendre que le contenu se charge
+    await page.waitForSelector('#packs-container', { timeout: 10000 });
+    
+    // Attendre un peu pour que tous les scripts s'exécutent
+    await page.waitForTimeout(2000);
+    
+    // Vérifier qu'aucune erreur console n'est apparue
+    if (consoleErrors.length > 0) {
+      console.error('Console errors detected:', consoleErrors);
+      expect(consoleErrors).toHaveLength(0);
+    }
+    
+    // Vérifier que la page s'est chargée correctement
+    await expect(page.locator('#packs-container')).toBeVisible();
+    
+    // Vérifier qu'aucune bannière d'erreur n'est affichée
+    const errorBanner = page.locator('#packs-error');
+    if (await errorBanner.isVisible()) {
+      const errorText = await errorBanner.textContent();
+      throw new Error(`Error banner visible: ${errorText}`);
+    }
+  });
+
+  test('Pack execution should not generate console errors', async ({ page }) => {
+    const consoleErrors = [];
+    
+    page.on('console', msg => {
+      if (msg.type() === 'error') {
+        consoleErrors.push({
+          type: msg.type(),
+          text: msg.text(),
+          location: msg.location()
+        });
+      }
+    });
+
+    page.on('pageerror', error => {
+      consoleErrors.push({
+        type: 'pageerror',
+        text: error.message,
+        stack: error.stack
+      });
+    });
+
+    await page.goto(BASE_URL);
+    
+    // Attendre que les packs se chargent
+    await page.waitForSelector('.run-btn', { timeout: 10000 });
+    
+    // Cliquer sur le premier bouton Run
+    const runButton = page.locator('.run-btn').first();
+    await runButton.click();
+    
+    // Attendre que l'exécution se termine (toast ou mise à jour)
+    await page.waitForTimeout(5000);
+    
+    // Vérifier qu'aucune erreur console n'est apparue pendant l'exécution
+    if (consoleErrors.length > 0) {
+      console.error('Console errors during pack execution:', consoleErrors);
+      expect(consoleErrors).toHaveLength(0);
+    }
+  });
+
+  test('Deep-link page should load without console errors', async ({ page }) => {
+    const consoleErrors = [];
+    
+    page.on('console', msg => {
+      if (msg.type() === 'error') {
+        consoleErrors.push({
+          type: msg.type(),
+          text: msg.text(),
+          location: msg.location()
+        });
+      }
+    });
+
+    page.on('pageerror', error => {
+      consoleErrors.push({
+        type: 'pageerror',
+        text: error.message,
+        stack: error.stack
+      });
+    });
+
+    // Tester une page de rapport détaillé
+    await page.goto(`${BASE_URL}/r/httpbin/test-123`);
+    
+    // Attendre que le contenu se charge
+    await page.waitForSelector('table, .loading', { timeout: 10000 });
+    
+    // Attendre un peu pour que tous les scripts s'exécutent
+    await page.waitForTimeout(2000);
+    
+    // Vérifier qu'aucune erreur console n'est apparue
+    if (consoleErrors.length > 0) {
+      console.error('Console errors on deep-link page:', consoleErrors);
+      expect(consoleErrors).toHaveLength(0);
+    }
+    
+    // Vérifier que la page s'est chargée correctement
+    await expect(page.locator('h1, .title')).toBeVisible();
+  });
+});

package/tests/pdf.spec.ts

@@ -0,0 +1,252 @@
+// QA360 PDF Generation Tests
+// Validates real PDF generation with Puppeteer and SHA256 validation
+
+import { test, expect } from '@playwright/test';
+import crypto from 'crypto';
+
+test.describe('QA360 PDF Generation', () => {
+  const baseURL = process.env.QA360_BASE_URL || 'https://qa360-cloud-preview.vercel.app';
+  const apiKey = process.env.QA360_API_KEY || '176402b75ec5a56176fc99a1139f3bd16268cd4b1e71798d5dd55c76f33b69de';
+
+  test('should generate HTML PDF report', async ({ request }) => {
+    // First run a pack to generate a report
+    const runResponse = await request.post(`${baseURL}/api/pack`, {
+      headers: {
+        'content-type': 'application/json',
+        'x-qa360-api-key': apiKey
+      },
+      data: { pack: 'httpbin' }
+    });
+
+    expect(runResponse.ok()).toBeTruthy();
+    const runData = await runResponse.json();
+    expect(runData.runId).toBeDefined();
+
+    // Test HTML PDF export (default)
+    const pdfResponse = await request.get(`${baseURL}/api/report/pdf?pack=httpbin&runId=${runData.runId}`);
+    expect(pdfResponse.ok()).toBeTruthy();
+
+    const contentType = pdfResponse.headers()['content-type'];
+    expect(contentType).toContain('text/html');
+
+    const htmlContent = await pdfResponse.text();
+    
+    // Validate HTML structure
+    expect(htmlContent).toContain('<!DOCTYPE html>');
+    expect(htmlContent).toContain('QA360 Cloud Intelligence');
+    expect(htmlContent).toContain('Enterprise Testing Platform');
+    expect(htmlContent).toContain('Test Execution Summary');
+    expect(htmlContent).toContain('HTTPBin API Testing');
+    expect(htmlContent).toContain('Document Signature:');
+    
+    // Validate branding elements
+    expect(htmlContent).toContain('Generated by QA360 © 2025 XyqoTech');
+    expect(htmlContent).toContain('qa360-cloud-preview.vercel.app');
+    
+    // Validate CSS styling
+    expect(htmlContent).toContain('@page');
+    expect(htmlContent).toContain('format: A4');
+    expect(htmlContent).toContain('margin: 2cm');
+    
+    // Validate report content
+    expect(htmlContent).toContain(`Pack: httpbin`);
+    expect(htmlContent).toContain(`Run ID: ${runData.runId}`);
+    expect(htmlContent).toContain('Given');
+    expect(htmlContent).toContain('When');
+    expect(htmlContent).toContain('Then');
+  });
+
+  test('should generate real PDF with Puppeteer', async ({ request }) => {
+    // First run a pack to generate a report
+    const runResponse = await request.post(`${baseURL}/api/pack`, {
+      headers: {
+        'content-type': 'application/json',
+        'x-qa360-api-key': apiKey
+      },
+      data: { pack: 'httpbin' }
+    });
+
+    expect(runResponse.ok()).toBeTruthy();
+    const runData = await runResponse.json();
+
+    // Test real PDF generation
+    const pdfResponse = await request.get(`${baseURL}/api/report/pdf?pack=httpbin&runId=${runData.runId}&real=true`);
+    expect(pdfResponse.ok()).toBeTruthy();
+
+    const contentType = pdfResponse.headers()['content-type'];
+    expect(contentType).toBe('application/pdf');
+
+    const contentDisposition = pdfResponse.headers()['content-disposition'];
+    expect(contentDisposition).toContain('attachment');
+    expect(contentDisposition).toContain(`qa360-report-httpbin-${runData.runId}.pdf`);
+
+    const pdfBuffer = await pdfResponse.body();
+    expect(pdfBuffer).toBeDefined();
+    expect(pdfBuffer.length).toBeGreaterThan(0);
+
+    // Validate PDF magic bytes
+    const pdfHeader = pdfBuffer.slice(0, 4).toString();
+    expect(pdfHeader).toBe('%PDF');
+
+    // Validate PDF size (should be reasonable)
+    const pdfSizeMB = pdfBuffer.length / (1024 * 1024);
+    expect(pdfSizeMB).toBeLessThan(1.5); // Less than 1.5MB as specified
+
+    // Validate content length header
+    const contentLength = pdfResponse.headers()['content-length'];
+    expect(parseInt(contentLength)).toBe(pdfBuffer.length);
+  });
+
+  test('should validate SHA256 signature in PDF reports', async ({ request }) => {
+    // Generate a report
+    const runResponse = await request.post(`${baseURL}/api/pack`, {
+      headers: {
+        'content-type': 'application/json',
+        'x-qa360-api-key': apiKey
+      },
+      data: { pack: 'httpbin' }
+    });
+
+    const runData = await runResponse.json();
+
+    // Get Gherkin report to calculate expected signature
+    const gherkinResponse = await request.get(`${baseURL}/api/report/gherkin?pack=httpbin&runId=${runData.runId}`);
+    const gherkinData = await gherkinResponse.json();
+
+    // Calculate expected signature
+    const content = `${gherkinData.pack}:${gherkinData.runId}:${gherkinData.timestamp}:${gherkinData.summary.totalSteps}`;
+    const expectedSignature = crypto.createHash('sha256').update(content).digest('hex').substring(0, 16);
+
+    // Get HTML PDF and validate signature
+    const pdfResponse = await request.get(`${baseURL}/api/report/pdf?pack=httpbin&runId=${runData.runId}`);
+    const htmlContent = await pdfResponse.text();
+
+    expect(htmlContent).toContain(`Document Signature: ${expectedSignature}`);
+  });
+
+  test('should handle PDF generation errors gracefully', async ({ request }) => {
+    // Test with non-existent report
+    const pdfResponse = await request.get(`${baseURL}/api/report/pdf?pack=httpbin&runId=non-existent-id`);
+    expect(pdfResponse.status()).toBe(404);
+
+    const errorData = await pdfResponse.json();
+    expect(errorData.error).toContain('Gherkin report not found');
+  });
+
+  test('should validate PDF caching headers', async ({ request }) => {
+    // Generate a report
+    const runResponse = await request.post(`${baseURL}/api/pack`, {
+      headers: {
+        'content-type': 'application/json',
+        'x-qa360-api-key': apiKey
+      },
+      data: { pack: 'httpbin' }
+    });
+
+    const runData = await runResponse.json();
+
+    // Test PDF caching
+    const pdfResponse = await request.get(`${baseURL}/api/report/pdf?pack=httpbin&runId=${runData.runId}`);
+    expect(pdfResponse.ok()).toBeTruthy();
+
+    const cacheControl = pdfResponse.headers()['cache-control'];
+    expect(cacheControl).toContain('public');
+    expect(cacheControl).toContain('max-age=3600');
+  });
+
+  test('should support multiple pack PDF generation', async ({ request }) => {
+    const packs = ['httpbin', 'petstore'];
+    const results = [];
+
+    // Generate reports for multiple packs
+    for (const pack of packs) {
+      const runResponse = await request.post(`${baseURL}/api/pack`, {
+        headers: {
+          'content-type': 'application/json',
+          'x-qa360-api-key': apiKey
+        },
+        data: { pack }
+      });
+
+      expect(runResponse.ok()).toBeTruthy();
+      const runData = await runResponse.json();
+
+      // Generate PDF
+      const pdfResponse = await request.get(`${baseURL}/api/report/pdf?pack=${pack}&runId=${runData.runId}`);
+      expect(pdfResponse.ok()).toBeTruthy();
+
+      const htmlContent = await pdfResponse.text();
+      expect(htmlContent).toContain(`Pack: ${pack}`);
+      expect(htmlContent).toContain(`Run ID: ${runData.runId}`);
+
+      results.push({ pack, runId: runData.runId });
+    }
+
+    expect(results).toHaveLength(2);
+  });
+
+  test('should validate PDF performance requirements', async ({ request }) => {
+    // Generate a report
+    const runResponse = await request.post(`${baseURL}/api/pack`, {
+      headers: {
+        'content-type': 'application/json',
+        'x-qa360-api-key': apiKey
+      },
+      data: { pack: 'httpbin' }
+    });
+
+    const runData = await runResponse.json();
+
+    // Measure PDF generation time
+    const startTime = Date.now();
+    const pdfResponse = await request.get(`${baseURL}/api/report/pdf?pack=httpbin&runId=${runData.runId}&real=true`);
+    const endTime = Date.now();
+
+    expect(pdfResponse.ok()).toBeTruthy();
+
+    const generationTime = endTime - startTime;
+    console.log(`PDF generation time: ${generationTime}ms`);
+
+    // Should generate PDF in reasonable time (less than 30 seconds for Vercel timeout)
+    expect(generationTime).toBeLessThan(30000);
+
+    // Validate PDF size
+    const pdfBuffer = await pdfResponse.body();
+    const pdfSizeMB = pdfBuffer.length / (1024 * 1024);
+    
+    console.log(`PDF size: ${pdfSizeMB.toFixed(2)}MB`);
+    expect(pdfSizeMB).toBeLessThan(1.5); // Less than 1.5MB as specified
+  });
+
+  test('should validate PDF accessibility and structure', async ({ request }) => {
+    // Generate a report
+    const runResponse = await request.post(`${baseURL}/api/pack`, {
+      headers: {
+        'content-type': 'application/json',
+        'x-qa360-api-key': apiKey
+      },
+      data: { pack: 'httpbin' }
+    });
+
+    const runData = await runResponse.json();
+
+    // Get HTML PDF
+    const pdfResponse = await request.get(`${baseURL}/api/report/pdf?pack=httpbin&runId=${runData.runId}`);
+    const htmlContent = await pdfResponse.text();
+
+    // Validate accessibility elements
+    expect(htmlContent).toContain('<title>QA360 Gherkin Report - httpbin</title>');
+    expect(htmlContent).toContain('lang="en"');
+    expect(htmlContent).toContain('charset="UTF-8"');
+
+    // Validate semantic structure
+    expect(htmlContent).toContain('<h1>');
+    expect(htmlContent).toContain('<h2>');
+    expect(htmlContent).toContain('<h3>');
+    
+    // Validate print styles
+    expect(htmlContent).toContain('@page');
+    expect(htmlContent).toContain('print-color-adjust: exact');
+    expect(htmlContent).toContain('page-break-before: always');
+  });
+});