GrowthOS — Test Suite E2E

import { defineConfig, devices } from '@playwright/test';

export default defineConfig({
  testDir: './e2e',
  timeout: 30_000,
  expect: { timeout: 5_000 },

  /* Paralelismo total — cada test en su propio worker */
  fullyParallel: true,

  /* En CI no se permiten .only() y se reintenta 2 veces */
  forbidOnly: !!process.env.CI,
  retries: process.env.CI ? 2 : 0,
  workers: process.env.CI ? 1 : undefined,

  reporter: [
    ['html'],
    ['junit', { outputFile: 'results.xml' }],
    ['github'],   // anotaciones en PRs
  ],

  use: {
    baseURL: 'http://localhost:3000',
    trace: 'on-first-retry',       // traza zip en primer reintento
    screenshot: 'only-on-failure',   // captura solo si falla
    video: 'retain-on-failure',      // vídeo solo si falla
  },

  projects: [
    { name: 'chromium', use: { ...devices['Desktop Chrome'] } },
    { name: 'firefox',  use: { ...devices['Desktop Firefox'] } },
    { name: 'webkit',   use: { ...devices['Desktop Safari'] } },
    { name: 'mobile',   use: { ...devices['iPhone 13'] } },
  ],
});

test('checkout plan Pro — pago exitoso',
  async ({ page, testUser }) => {

    /* 1. Mock de Stripe: evitamos llamadas reales */
    await page.route('**/api/stripe/create-session', route => {
      route.fulfill({
        status: 200,
        contentType: 'application/json',
        body: JSON.stringify({
          sessionId: 'cs_test_mock_abc123',
          url: '/checkout/success?session=cs_test_mock_abc123'
        }),
      });
    });

    await page.route('**/api/stripe/webhook', route => {
      route.fulfill({ status: 200,
        body: JSON.stringify({ received: true }) });
    });

    /* 2. Navegar al plan Pro */
    await page.goto('/precios');
    await expect(page.getByTestId('plan-pro')).toBeVisible();

    /* 3. Verificar redireccion a éxito */
    const [_] = await Promise.all([
      page.waitForURL('**/checkout/success**'),
      page.getByRole('button', { name: 'Contratar Pro' }).click(),
    ]);

    await expect(
      page.getByRole('heading', { name: '¡Pago completado!' })
    ).toBeVisible();

    /* 4. Badge Pro en la cuenta */
    await page.goto('/dashboard');
    await expect(
      page.getByTestId('plan-badge')
    ).toHaveText('Pro');
  }
);

import { test as base } from '@playwright/test';
import { ApiClient } from '../support/api-client';

type Fixtures = {
  testUser: { email: string; password: string; id: string };
  authPage: Page;  // página ya autenticada
};

export const test = base.extend<Fixtures>({

  /* Crea un usuario único por test → tests aislados */
  testUser: async ({}, use) => {
    const api = new ApiClient(process.env.API_URL!);
    const user = await api.createUser({
      email: `test-${Date.now()}@growthos.test`,
      password: 'Cultiva2024!',
      plan: 'free',
    });
    await use(user);
    /* Teardown automático al terminar el test */
    await api.deleteUser(user.id);
  },

  /* Página pre-autenticada usando estado de sesión en storage */
  authPage: async ({ browser, testUser }, use) => {
    const ctx = await browser.newContext({
      storageState: await getStorageState(testUser),
    });
    await use(await ctx.newPage());
    await ctx.close();
  },
});

export { expect } from '@playwright/test';

import { test, expect } from '../fixtures';
import AxeBuilder from '@axe-core/playwright';

const criticalPages = [
  '/login', '/registro', '/dashboard', '/precios'
];

for (const route of criticalPages) {
  test(`${route} sin violaciones WCAG 2.1 AA`,
    async ({ page }) => {
      await page.goto(route);

      const results = await new AxeBuilder({ page })
        .withTags(['wcag2a', 'wcag2aa'])
        .exclude('#intercom-widget') // widget 3rd-party
        .analyze();

      expect(results.violations).toEqual([]);
    }
  );
}