Перейти к основному содержимому

Параллелизм

Введение​

Playwright Test выполняет тесты параллельно. Для этого он запускает несколько рабочих процессов, которые работают одновременно. По умолчанию, тестовые файлы выполняются параллельно. Тесты в одном файле выполняются по порядку, в одном и том же рабочем процессе.

Вы можете контролировать количество параллельных рабочих процессов и ограничить количество сбоев во всем наборе тестов для повышения эффективности.

Рабочие процессы​

Все тесты выполняются в рабочих процессах. Эти процессы являются процессами операционной системы, работающими независимо, под управлением тестового раннера. Все рабочие процессы имеют идентичные окружения, и каждый запускает свой собственный браузер.

Вы не можете общаться между рабочими процессами. Playwright Test повторно использует один рабочий процесс настолько, насколько это возможно, чтобы ускорить тестирование, поэтому несколько тестовых файлов обычно выполняются в одном рабочем процессе один за другим.

Рабочие процессы всегда завершаются после сбоя теста, чтобы гарантировать чистую среду для последующих тестов.

Ограничение рабочих процессов​

Вы можете контролировать максимальное количество параллельных рабочих процессов через командную строку или в файле конфигурации.

Из командной строки:

npx playwright test --workers 4

В файле конфигурации:

playwright.config.ts
import { defineConfig } from '@playwright/test';

export default defineConfig({
// Ограничьте количество рабочих процессов на CI, используйте значение по умолчанию локально
workers: process.env.CI ? 2 : undefined,
});

Отключение параллелизма​

Вы можете отключить любой параллелизм, разрешив только один рабочий процесс в любой момент времени. Либо установите опцию workers: 1 в файле конфигурации, либо передайте --workers=1 в командную строку.

npx playwright test --workers=1

Параллелизация тестов в одном файле​

По умолчанию тесты в одном файле выполняются по порядку. Если у вас много независимых тестов в одном файле, вы можете захотеть выполнить их параллельно с помощью test.describe.configure().

Обратите внимание, что параллельные тесты выполняются в отдельных рабочих процессах и не могут разделять состояние или глобальные переменные. Каждый тест выполняет все соответствующие хуки только для себя, включая beforeAll и afterAll.

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

test.describe.configure({ mode: 'parallel' });

test('runs in parallel 1', async ({ page }) => { /* ... */ });
test('runs in parallel 2', async ({ page }) => { /* ... */ });

В качестве альтернативы, вы можете включить этот полностью параллельный режим для всех тестов в файле конфигурации:

playwright.config.ts
import { defineConfig } from '@playwright/test';

export default defineConfig({
fullyParallel: true,
});

Вы также можете включить полностью параллельный режим только для нескольких проектов:

playwright.config.ts
import { defineConfig } from '@playwright/test';

export default defineConfig({
// выполняет все тесты во всех файлах конкретного проекта параллельно
projects: [
{
name: 'chromium',
use: { ...devices['Desktop Chrome'] },
fullyParallel: true,
},
]
});

Последовательный режим​

Вы можете аннотировать взаимозависимые тесты как последовательные. Если один из последовательных тестов не проходит, все последующие тесты пропускаются. Все тесты в группе повторяются вместе.

примечание

Использование последовательного режима не рекомендуется. Обычно лучше сделать ваши тесты изолированными, чтобы их можно было выполнять независимо.

import { test, type Page } from '@playwright/test';

// Аннотируйте весь файл как последовательный.
test.describe.configure({ mode: 'serial' });

let page: Page;

test.beforeAll(async ({ browser }) => {
page = await browser.newPage();
});

test.afterAll(async () => {
await page.close();
});

test('runs first', async () => {
await page.goto('https://playwright.dev/');
});

test('runs second', async () => {
await page.getByText('Get Started').click();
});

Блокировки тестов​

Некоторые тесты в вашем наборе могут обращаться к общему ресурсу, который не поддерживает одновременный доступ, например к внешнему сервису или глобальной настройке учётной записи. Для таких тестов можно объявить именованные блокировки, чтобы тесты с одинаковым именем блокировки никогда не выполнялись одновременно, а все остальные тесты продолжали выполняться параллельно. Блокировки действуют между файлами, рабочими процессами и проектами.

settings.spec.ts
import { test, expect } from '@playwright/test';

test('update user settings', { lock: 'user-settings' }, async ({ page }) => {
// ...
});
profile.spec.ts
import { test, expect } from '@playwright/test';

// Никогда не выполняется одновременно с тестом 'update user settings' выше,
// даже в другом проекте.
test('rename user', { lock: 'user-settings' }, async ({ page }) => {
// ...
});

Тест может объявить несколько блокировок и будет выполняться только тогда, когда все они станут доступны. Также можно объявить блокировки для группы с помощью test.describe(), применив их ко всем тестам внутри неё.

test('reset the database', { lock: ['database', 'external-api'] }, async () => {
// ...
});

Также можно добавить блокировки для содержащего тест файла или группы describe с помощью test.describe.configure(). Повторные вызовы добавляют блокировки, не удаляя существующие.

test.describe.configure({ lock: 'user-settings' });

Playwright захватывает все блокировки теста перед его запуском и освобождает их после его завершения.

Встроенная блокировка -exclusive- позволяет выполнять тест изолированно: он запускается только тогда, когда никакие другие тесты не выполняются, и до его завершения другие тесты не запускаются. Все остальные тесты по-прежнему выполняются параллельно друг с другом. Это полезно для отдельных тестов, чувствительных к любой одновременной активности, например тестов, которые измеряют производительность или перезапускают общий сервис.

test('restart the server', { lock: '-exclusive-' }, async () => {
// Пока выполняется этот тест, никакие другие тесты не выполняются.
});
примечание

В режиме по умолчанию и в последовательном режиме все тесты в файле выполняются вместе по порядку, поэтому блокировка, объявленная для любого теста, удерживается на протяжении выполнения всего файла.

Отключение полностью параллельного режима​

Если ваша конфигурация применяет параллельный режим ко всем тестам с помощью testConfig.fullyParallel, вам всё равно может понадобиться запускать некоторые тесты с настройками по умолчанию. Режим можно переопределить на уровне describe:

test.describe('runs in parallel with other describes', () => {
test.describe.configure({ mode: 'default' });
test('in order 1', async ({ page }) => {});
test('in order 2', async ({ page }) => {});
});

Как избежать общего состояния в параллельных тестах​

Playwright запускает тесты в отдельных рабочих процессах, каждый из которых использует собственный изолированный BrowserContext, поэтому файлы cookie, хранилища и глобальные переменные в памяти уже изолированы. Нестабильность возникает из-за состояния, которое существует за пределами отдельного теста. Ниже приведены решения для распространённых случаев.

Выделяйте каждому тесту собственные данные на сервере​

Два теста, которые создают или редактируют одну и ту же запись, вступают в состояние гонки. Формируйте уникальный идентификатор на основе testInfo.testId, чтобы параллельные тесты никогда не конфликтовали:

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

test('creates an order', async ({ page }, testInfo) => {
const orderId = `order-${testInfo.testId}`;
await page.goto(`/orders/new?id=${orderId}`);
await expect(page.getByText(orderId)).toBeVisible();
});

Если несколько тестов могут использовать один набор данных, создавайте его один раз для каждого рабочего процесса — см. раздел Изоляция тестовых данных между параллельными рабочими процессами.

Записывайте данные по уникальному пути к файлу​

Если несколько тестов записывают данные по одному и тому же пути, они перезаписывают результаты друг друга. Метод testInfo.outputPath() возвращает путь, выделенный для текущего теста:

import { test } from '@playwright/test';
import fs from 'fs';

test('exports a CSV', async ({ page }, testInfo) => {
const file = testInfo.outputPath('export.csv');
await fs.promises.writeFile(file, 'a,b,c', 'utf8');
});

Обеспечивайте независимость тестов​

Прежде всего, изолируйте тесты друг от друга. Тест, который передаёт состояние через переменную уровня модуля или зависит от побочных эффектов другого теста, работает при последовательном запуске тестов в определённом порядке, но перестаёт работать, как только они запускаются параллельно или в другом порядке. Подготавливайте всё необходимое для теста в самом тесте или в фикстуре и никогда не полагайтесь на то, что другой тест уже был выполнен.

Распределение тестов между несколькими машинами с помощью шардинга​

Playwright Test может разделить набор тестов, чтобы он мог выполняться на нескольких машинах. См. руководство по разделению для получения более подробной информации.

npx playwright test --shard=2/3

Ограничение сбоев и быстрое завершение​

Вы можете ограничить количество неудачных тестов во всем наборе тестов, установив опцию конфигурации maxFailures или передав флаг командной строки --max-failures.

При запуске с установленным "максимальным количеством сбоев" Playwright Test остановится после достижения этого количества неудачных тестов и пропустит любые тесты, которые еще не были выполнены. Это полезно, чтобы избежать траты ресурсов на сломанные наборы тестов.

Передача опции командной строки:

npx playwright test --max-failures=10

Установка в файле конфигурации:

playwright.config.ts
import { defineConfig } from '@playwright/test';

export default defineConfig({
// Ограничьте количество сбоев на CI, чтобы сэкономить ресурсы
maxFailures: process.env.CI ? 10 : undefined,
});

Индекс рабочего процесса и параллельный индекс​

Каждому рабочему процессу назначаются два идентификатора: уникальный индекс рабочего процесса, нумерация которого начинается с 0, и индекс параллельного выполнения в диапазоне от 0 до workers - 1. При перезапуске рабочего процесса, например после сбоя, новый рабочий процесс получает тот же parallelIndex и новый workerIndex.

Вы можете прочитать индекс из переменных окружения process.env.TEST_WORKER_INDEX и process.env.TEST_PARALLEL_INDEX, или получить к ним доступ через testInfo.workerIndex и testInfo.parallelIndex.

Изоляция данных теста между параллельными рабочими процессами​

Вы можете использовать process.env.TEST_WORKER_INDEX или testInfo.workerIndex, упомянутые выше, чтобы изолировать данные пользователя в базе данных между тестами, выполняемыми на разных рабочих процессах. Все тесты, выполняемые рабочим процессом, используют одного и того же пользователя.

Создайте файл playwright/fixtures.ts, который будет создавать фикстуру dbUserName и инициализировать нового пользователя в тестовой базе данных. Используйте testInfo.workerIndex, чтобы различать рабочие процессы.

playwright/fixtures.ts
import { test as baseTest, expect } from '@playwright/test';
// Импортируйте утилиты проекта для управления пользователями в тестовой базе данных.
import { createUserInTestDatabase, deleteUserFromTestDatabase } from './my-db-utils';

export * from '@playwright/test';
export const test = baseTest.extend<{}, { dbUserName: string }>({
// Возвращает имя пользователя базы данных, уникальное для рабочего процесса.
dbUserName: [async ({ }, use) => {
// Используйте workerIndex как уникальный идентификатор для каждого рабочего процесса.
const userName = `user-${test.info().workerIndex}`;
// Инициализируйте пользователя в базе данных.
await createUserInTestDatabase(userName);
await use(userName);
// Очистите после завершения тестов.
await deleteUserFromTestDatabase(userName);
}, { scope: 'worker' }],
});

Теперь каждый тестовый файл должен импортировать test из нашего файла фикстур вместо @playwright/test.

tests/example.spec.ts
// Важно: импортируйте наши фикстуры.
import { test, expect } from '../playwright/fixtures';

test('test', async ({ dbUserName }) => {
// Используйте имя пользователя в тесте.
});

Управление порядком тестов​

Playwright Test выполняет тесты из одного файла в порядке их объявления, если вы не параллелизируете тесты в одном файле.

Нет гарантии порядка выполнения тестов между файлами, так как Playwright Test по умолчанию выполняет тестовые файлы параллельно. Однако, если вы отключите параллелизм, вы можете управлять порядком тестов, либо называя ваши файлы в алфавитном порядке, либо используя файл "списка тестов".

Сортировка тестовых файлов в алфавитном порядке​

Когда вы отключаете параллельное выполнение тестов, Playwright Test выполняет тестовые файлы в алфавитном порядке. Вы можете использовать какую-то конвенцию именования, чтобы управлять порядком тестов, например 001-user-signin-flow.spec.ts, 002-create-new-document.spec.ts и так далее.

Использование файла "списка тестов"​

warning

Списки тестов не рекомендуются и поддерживаются только на уровне лучших усилий. Некоторые функции, такие как расширение VS Code и трассировка, могут не работать должным образом со списками тестов.

Вы можете разместить ваши тесты в вспомогательных функциях в нескольких файлах. Рассмотрите следующий пример, где тесты не определены напрямую в файле, а скорее в обертке функции.

feature-a.spec.ts
import { test, expect } from '@playwright/test';

export default function createTests() {
test('feature-a example test', async ({ page }) => {
// ... тест здесь
});
}

feature-b.spec.ts
import { test, expect } from '@playwright/test';

export default function createTests() {
test.use({ viewport: { width: 500, height: 500 } });

test('feature-b example test', async ({ page }) => {
// ... тест здесь
});
}

Вы можете создать файл списка тестов, который будет управлять порядком тестов - сначала выполнить тесты feature-b, затем тесты feature-a. Обратите внимание, как каждый тестовый файл обернут в блок test.describe(), который вызывает функцию, где определены тесты. Таким образом, вызовы test.use() влияют только на тесты из одного файла.

test.list.ts
import { test } from '@playwright/test';
import featureBTests from './feature-b.spec.ts';
import featureATests from './feature-a.spec.ts';

test.describe(featureBTests);
test.describe(featureATests);

Теперь отключите параллельное выполнение, установив количество рабочих процессов равным одному, и укажите ваш файл списка тестов.

playwright.config.ts
import { defineConfig } from '@playwright/test';

export default defineConfig({
workers: 1,
testMatch: 'test.list.ts',
});
примечание

Не определяйте ваши тесты напрямую во вспомогательном файле. Это может привести к неожиданным результатам, так как ваши тесты теперь зависят от порядка import/require выражений. Вместо этого оберните тесты в функцию, которая будет явно вызвана файлом списка тестов, как в примере выше.