Управление авторизацией и 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' })                  |
+-----------------------------------------------------------------------------+
                                     │
                                     ▼ (Запись артефактов на диск)
+-----------------------------------------------------------------------------+
|                      .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';