Керування авторизацією та Storage State

+-----------------------------------------------------------------------------+
|               Традиційний підхід (Антипатерн: Логін у кожному тесті)        |
|                                                                             |
|  Test 1: [UI Login: 3s] -> [Test Logic: 1s] = 4s                            |
|  Test 2: [UI Login: 3s] -> [Test Logic: 0.5s] = 3.5s                        |
|  Test 3: [UI Login: 3s] -> [Test Logic: 2s] = 5s                            |
|  РАЗОМ на 100 тестів: ~300 секунд (5 хвилин) марно на введення пароля!      |
+-----------------------------------------------------------------------------+

+-----------------------------------------------------------------------------+
|               Архітектура Playwright: Storage State Reuse 2026              |
|                                                                             |
|  Setup Project (1 раз): [API/UI Login: 1.5s] -> Збереження у storageState    |
|                                                      │                      |
|                       ┌──────────────────────────────┴────────────────┐     |
|                       ▼                                               ▼     |
|  Worker 1 (Context with storageState)        Worker 2 (Context with storageState)
|  Test 1: [Test Logic: 1s]                    Test 2: [Test Logic: 0.5s]     |
|  Test 3: [Test Logic: 2s]                    Test 4: [Test Logic: 1.2s]     |
|  РАЗОМ на 100 тестів: ~35 секунд сумарного часу виконання                   |
+-----------------------------------------------------------------------------+

+-----------------------------------------------------------------------------+
|                          1. SETUP PROJECT (setup)                           |
|                                                                             |
|   auth.setup.ts  ──► POST /api/auth/login ──► Отримання JWT + Set-Cookie    |
|                            │                                                |
|                            ▼                                                |
|   page.context().storageState({ path: '.auth/admin.json' })                 |
|   page.context().storageState({ path: '.auth/user.json' })                  |
+-----------------------------------------------------------------------------+
                                     │
                                     ▼ (Запис JSON-артефактів на диск)
+-----------------------------------------------------------------------------+
|                      .auth/ Directory (Git-ignored)                         |
|   - admin.json (Cookies + LocalStorage з роллю Administrator)               |
|   - user.json  (Cookies + LocalStorage з роллю Standard Customer)           |
+-----------------------------------------------------------------------------+
                                     │
            ┌────────────────────────┴────────────────────────┐
            ▼                                                 ▼
+------------------------------------+   +------------------------------------+
|  Project: "admin-tests"            |   |  Project: "customer-tests"         |
|  use: {                            |   |  use: {                            |
|    storageState: '.auth/admin.json'|   |    storageState: '.auth/user.json' |
|  }                                 |   |  }                                 |
|                                    |   |                                    |
|  Worker A: dashboard.spec.ts       |   |  Worker C: profile.spec.ts         |
|  Worker B: settings.spec.ts        |   |  Worker D: orders.spec.ts          |
+------------------------------------+   +------------------------------------+

{
  "cookies": [
    {
      "name": "session_token",
      "value": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
      "domain": "localhost",
      "path": "/",
      "expires": 1789038400,
      "httpOnly": true,
      "secure": false,
      "sameSite": "Lax"
    }
  ],
  "origins": [
    {
      "origin": "http://localhost:3000",
      "localStorage": [
        {
          "name": "user_meta",
          "value": "{\"id\":\"usr_01\",\"role\":\"admin\",\"theme\":\"dark\"}"
        }
      ]
    }
  ]
}

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

/** Шляхи до серіалізованих станів ролей */
export const ADMIN_AUTH_FILE = path.join(__dirname, '.auth/admin.json');
export const USER_AUTH_FILE = path.join(__dirname, '.auth/user.json');

export default defineConfig({
  testDir: './e2e',
  fullyParallel: true,
  forbidOnly: !!process.env.CI,
  retries: process.env.CI ? 2 : 0,
  workers: process.env.CI ? '100%' : undefined,

  projects: [
    // 1. Проєкт підготовки авторизації (Запускається першим)
    {
      name: 'setup',
      testMatch: /.*\.setup\.ts/,
    },

    // 2. Тести з правами адміністратора
    {
      name: 'admin-chromium',
      testMatch: /.*admin.*\.spec\.ts/,
      use: {
        ...devices['Desktop Chrome'],
        storageState: ADMIN_AUTH_FILE,
      },
      dependencies: ['setup'], // Сувора залежність від завершення setup
    },

    // 3. Тести з правами звичайного користувача
    {
      name: 'user-chromium',
      testMatch: /.*user.*\.spec\.ts/,
      use: {
        ...devices['Desktop Chrome'],
        storageState: USER_AUTH_FILE,
      },
      dependencies: ['setup'],
    },

    // 4. Публічні тести (Гість / Unauthenticated)
    {
      name: 'public-chromium',
      testMatch: /.*public.*\.spec\.ts/,
      use: {
        ...devices['Desktop Chrome'],
        // storageState не вказується — чистий контекст інкогніто
      },
    },
  ],
});

import { test as setup, expect } from '@playwright/test';
import { ADMIN_AUTH_FILE, USER_AUTH_FILE } from '../playwright.config';

setup.describe('Глобальна ініціалізація авторизаційних станів', () => {
  setup('авторизація суперадміністратора через API та збереження сесії', async ({ request, page }) => {
    // 1. Виконуємо швидкий HTTP-запит до API автентифікації (без відкриття браузерного UI)
    const loginResponse = await request.post('/api/auth/login', {
      data: {
        email: process.env.E2E_ADMIN_EMAIL ?? '[email protected]',
        password: process.env.E2E_ADMIN_PASSWORD ?? 'SecureEnterprisePassword2026!',
      },
    });

    expect(loginResponse.ok()).toBeTruthy();
    const { token, user } = (await loginResponse.json()) as { token: string; user: { id: string; role: string } };

    // 2. Переходимо на базовий домен, щоб зареєструвати localStorage у правильному Origin
    await page.goto('/favicon.ico');

    // 3. Інжектуємо дані в localStorage через evaluate
    await page.evaluate(
      ({ authToken, userData }) => {
        localStorage.setItem('auth_token', authToken);
        localStorage.setItem('user_profile', JSON.stringify(userData));
      },
      { authToken: token, userData: user }
    );

    // 4. Зберігаємо об'єднаний стан (куки від API-відповіді + localStorage) у файл
    await page.context().storageState({ path: ADMIN_AUTH_FILE });
  });

  setup('авторизація стандартного користувача через UI форму (якщо немає API)', async ({ page }) => {
    // Альтернативний сценарій через UI (якщо авторизація включає CSRF або складні редиректи)
    await page.goto('/login');
    await page.getByLabel('E-mail').fill(process.env.E2E_USER_EMAIL ?? '[email protected]');
    await page.getByLabel('Пароль').fill(process.env.E2E_USER_PASSWORD ?? 'StandardPassword2026!');
    await page.getByRole('button', { name: 'Увійти в акаунт' }).click();

    // Очікуємо успішного переходу на дашборд
    await page.waitForURL('**/dashboard');
    await expect(page.getByRole('heading', { name: 'Мої курси' })).toBeVisible();

    // Зберігаємо стан сесії користувача
    await page.context().storageState({ path: USER_AUTH_FILE });
  });
});

import { test, expect } from '@playwright/test';

test.describe('Панель адміністрування', () => {
  test('адміністратор може змінити ліміти генерації токенів', async ({ page }) => {
    // Вхід уже виконано! Направляємося одразу на закритий екран налаштувань
    await page.goto('/admin/security/token-limits');

    // Перевіряємо наявність захищених елементів інтерфейсу
    await expect(page.getByRole('heading', { name: 'Налаштування безпеки' })).toBeVisible();

    const limitInput = page.getByLabel('Максимум токенів на воркер');
    await limitInput.fill('64');
    await page.getByRole('button', { name: 'Зберегти зміни' }).click();

    await expect(page.getByRole('status')).toHaveText('Зміни успішно застосовано');
  });
});

import { test as base, type Page } from '@playwright/test';
import { ADMIN_AUTH_FILE, USER_AUTH_FILE } from '../../playwright.config';

export interface RoleFixtures {
  adminPage: Page;
  userPage: Page;
}

export const test = base.extend<RoleFixtures>({
  adminPage: async ({ browser }, use) => {
    const context = await browser.newContext({ storageState: ADMIN_AUTH_FILE });
    const page = await context.newPage();
    await use(page);
    await context.close();
  },

  userPage: async ({ browser }, use) => {
    const context = await browser.newContext({ storageState: USER_AUTH_FILE });
    const page = await context.newPage();
    await use(page);
    await context.close();
  },
});

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