Selenium-автоматизация: пошаговое создание эффективных тестов

Для кого эта статья:

• Новички в тестировании программного обеспечения, желающие освоить автоматизированное тестирование
• Тестировщики и QA-инженеры, интересующиеся использованием Selenium для улучшения тестирования

• Разработчики программного обеспечения, стремящиеся интегрировать автоматизированные тесты в CI/CD процессы

  Помните ту радость, когда вручную протестировали 50 пользовательских сценариев, а на следующий день менеджер попросил повторить всё заново из-за обновления кода? Эти времена позади. Selenium — инструмент, превращающий многочасовой ручной труд в автоматизированный процесс. В этой статье я покажу, как построить надежную систему автотестирования с нуля: от установки компонентов до интеграции с CI/CD, с конкретными примерами кода и решениями для типичных проблем. Вы сможете запустить свой первый автотест уже через 30 минут после прочтения. 🚀

Хотите освоить профессию тестировщика, но не знаете, с чего начать? Курс тестировщика ПО от Skypro — это практический подход к обучению с фокусом на реальные проекты. На курсе вы не просто изучите теорию, но и освоите Selenium под руководством опытных наставников из IT-компаний. Каждому студенту гарантирована стажировка с возможностью трудоустройства. Обучение доступно даже без технического бэкграунда!

Основы Selenium WebDriver для автоматизации тестирования

Selenium WebDriver — это ядро экосистемы Selenium, которое позволяет управлять браузером программно, эмулируя действия реального пользователя. Фактически это API, обеспечивающий взаимодействие с браузером через "родной" для него интерфейс, а не через JavaScript-инъекции, как это делалось в устаревшем Selenium RC.

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

Михаил Дронов, Lead QA Engineer

Когда наша команда приступила к разработке крупного банковского портала, мы столкнулись с классической дилеммой: как обеспечить стабильное качество при еженедельных релизах? Ручное регрессионное тестирование занимало три дня, что делало короткие спринты практически невозможными.

Мы приняли решение внедрить Selenium. Сначала автоматизировали только критический путь — регистрацию, авторизацию и основные транзакции. Это сократило время тестирования до 40 минут. Через три месяца покрытие автотестами достигло 75%, а время тестирования сократилось до 2 часов вместо трёх дней. Это позволило нам перейти к еженедельным релизам без потери качества.

Ключевым фактором успеха стало понимание архитектуры WebDriver и правильное структурирование тестов по паттерну Page Object. Вместо тысяч строк запутанного кода мы получили модульную, масштабируемую систему.

Давайте рассмотрим ключевые компоненты архитектуры Selenium WebDriver:

Selenium поддерживает множество языков программирования, что делает его универсальным инструментом для различных команд и проектов:

• Java — наиболее распространенный выбор для корпоративных проектов благодаря экосистеме и совместимости
• Python — идеален для быстрого старта и Data Science проектов благодаря простоте синтаксиса
• C# — предпочтителен для команд, работающих с .NET стеком
• JavaScript — естественный выбор для фронтенд-команд, использующих Node.js
• Ruby — популярен в комбинации с Cucumber для BDD-подхода

Независимо от выбранного языка, концепции работы с WebDriver остаются одинаковыми, что позволяет легко переносить знания и лучшие практики между проектами. 🔄

Установка и настройка Selenium для эффективного тестирования

Установка Selenium требует настройки нескольких компонентов, но этот процесс можно разбить на логические шаги. Я покажу, как настроить окружение для наиболее популярных языков программирования.

Для начала работы вам потребуется:

• Установленная JDK (для Java) или интерпретатор выбранного языка
• Система управления зависимостями (Maven/Gradle для Java, pip для Python)
• Драйверы для нужных браузеров
• IDE или текстовый редактор

Шаг 1: Установка клиентской библиотеки Selenium

Для Python:

pip install selenium

Для Java с Maven добавьте в pom.xml:

<dependency>
<groupId>org.seleniumhq.selenium</groupId>
<artifactId>selenium-java</artifactId>
<version>4.11.0</version>
</dependency>

Для JavaScript (Node.js):

npm install selenium-webdriver

Шаг 2: Установка драйверов браузеров

Каждый браузер требует соответствующий драйвер. Существует два подхода к управлению драйверами:

Для ручной установки:

1. ChromeDriver: скачайте с https://chromedriver.chromium.org/downloads
2. GeckoDriver (Firefox): скачайте с https://github.com/mozilla/geckodriver/releases
3. Поместите исполняемый файл в PATH или укажите путь при инициализации драйвера

Для автоматического управления в Java:

<dependency>
<groupId>io.github.bonigarcia</groupId>
<artifactId>webdrivermanager</artifactId>
<version>5.4.1</version>
</dependency>

В коде:

WebDriverManager.chromedriver().setup();
WebDriver driver = new ChromeDriver();

В новых версиях Selenium 4.6+ можно использовать встроенный Selenium Manager:

WebDriver driver = new ChromeDriver(); // Автоматическая загрузка драйвера

Шаг 3: Настройка фреймворка для тестирования

Для организованного тестирования рекомендуется использовать фреймворки:

• Java: JUnit или TestNG
• Python: pytest или unittest
• JavaScript: Mocha, Jest или Jasmine

Пример базовой структуры проекта на Java с Maven:

src/
main/
java/
com/yourcompany/pages/ # Классы страниц по паттерну Page Object
test/
java/
com/yourcompany/tests/ # Тестовые классы
resources/
testdata/ # Тестовые данные
pom.xml # Зависимости и конфигурация

Анна Соколова, QA Automation Lead

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

Решение пришло, когда мы стандартизировали окружение через Docker. Создали контейнер с фиксированными версиями браузеров и драйверов. Тесты запускались в этом контейнере, что устранило "эффект моего компьютера", когда тест работает у одного инженера, но падает у другого.

Дополнительно настроили Selenium Grid для параллельного запуска тестов в разных браузерах. Время выполнения всего тестового набора сократилось с 4 часов до 40 минут.

Ключевой урок: инвестируйте время в настройку инфраструктуры в начале проекта. Это окупится многократно за счет стабильности тестов и сокращения времени на отладку.

После установки проверьте, что всё работает, запустив простой тест:

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.junit.Test;

public class SimpleTest {
@Test
public void openGoogle() {
WebDriver driver = new ChromeDriver();
driver.get("https://www.google.com");
System.out.println("Title: " + driver.getTitle());
driver.quit();
}
}

Если тест запустился успешно, вы готовы к созданию полноценных автотестов! 🛠️

Создание первого автотеста: от локаторов до выполнения

Перейдем от теории к практике — создадим первый полноценный автотест. Я разберу процесс шаг за шагом, с конкретными примерами кода и объяснением каждого этапа.

Представим сценарий: нам нужно протестировать форму авторизации на сайте. Тест должен ввести логин/пароль, нажать кнопку входа и проверить успешную авторизацию.

Шаг 1: Локаторы — ключ к взаимодействию с элементами

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

Основные типы локаторов в порядке предпочтения:

• ID — самый надежный локатор, если элемент имеет уникальный ID
• CSS-селекторы — гибкие и быстрые
• XPath — мощные, но могут быть сложными и менее производительными
• Имя класса, имя тега, имя — подходят для простых случаев
• Текст ссылки — для ссылок с уникальным текстом

Пример поиска элементов разными способами:

// По ID
WebElement loginField = driver.findElement(By.id("login"));

// По имени
WebElement passwordField = driver.findElement(By.name("password"));

// По CSS-селектору
WebElement loginButton = driver.findElement(By.cssSelector(".auth-form button[type='submit']"));

// По XPath
WebElement errorMessage = driver.findElement(By.xpath("//div[contains(@class, 'error-message')]"));

// По тексту ссылки
WebElement forgotPasswordLink = driver.findElement(By.linkText("Забыли пароль?"));

Шаг 2: Действия с элементами

После нахождения элемента можно выполнять различные действия:

// Ввод текста
loginField.sendKeys("user@example.com");
passwordField.sendKeys("password123");

// Клик
loginButton.click();

// Очистка поля
loginField.clear();

// Проверка отображения
boolean isVisible = errorMessage.isDisplayed();

// Проверка доступности
boolean isEnabled = loginButton.isEnabled();

// Получение текста
String errorText = errorMessage.getText();

// Получение атрибута
String placeholder = loginField.getAttribute("placeholder");

Шаг 3: Ожидания — критически важная часть надежных тестов

Веб-страницы загружаются и обновляются асинхронно, поэтому необходимы механизмы ожидания:

// Неявное ожидание (глобальная настройка)
driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);

// Явное ожидание (для конкретного условия)
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement welcomeMessage = wait.until(ExpectedConditions.visibilityOfElementLocated(
By.cssSelector(".welcome-message")
));

// Проверка текста после ожидания
assertEquals("Добро пожаловать!", welcomeMessage.getText());

Шаг 4: Написание полного теста

Теперь объединим всё вместе в полноценный тест с использованием JUnit:

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;

import java.time.Duration;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

public class LoginTest {
private WebDriver driver;
private WebDriverWait wait;

@Before
public void setUp() {
driver = new ChromeDriver();
driver.manage().window().maximize();
wait = new WebDriverWait(driver, Duration.ofSeconds(10));
}

@Test
public void testSuccessfulLogin() {
// Открыть страницу логина
driver.get("https://example.com/login");

// Найти элементы формы
WebElement loginField = driver.findElement(By.id("login"));
WebElement passwordField = driver.findElement(By.id("password"));
WebElement loginButton = driver.findElement(By.cssSelector("button[type='submit']"));

// Ввести данные
loginField.sendKeys("test@example.com");
passwordField.sendKeys("password123");

// Нажать кнопку входа
loginButton.click();

// Дождаться появления элемента, подтверждающего успешный вход
WebElement welcomeMessage = wait.until(
ExpectedConditions.visibilityOfElementLocated(By.className("welcome-message"))
);

// Проверить успешный вход
assertTrue(welcomeMessage.isDisplayed());
assertEquals("Добро пожаловать, Тестовый Пользователь!", welcomeMessage.getText());

// Проверить URL после входа
assertTrue(driver.getCurrentUrl().contains("/dashboard"));
}

@After
public void tearDown() {
if (driver != null) {
driver.quit();
}
}
}

Шаг 5: Запуск и анализ результатов

После запуска теста возможны следующие результаты:

• Успех — все проверки пройдены
• Провал — тест обнаружил ошибку (не совпадает текст, элемент не найден и т.д.)
• Ошибка — проблема в самом тесте или окружении

При анализе ошибок обращайте внимание на:

• NoSuchElementException — элемент не найден (неверный локатор или элемент не успел загрузиться)
• TimeoutException — истекло время ожидания
• StaleElementReferenceException — элемент был найден, но страница обновилась
• ElementNotInteractableException — элемент найден, но недоступен для взаимодействия

Не забывайте: хороший тест должен быть изолированным, повторяемым и очищать за собой данные. 🧹

Продвинутые техники работы с Selenium WebDriver

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

Page Object Model (POM) — основа поддерживаемой архитектуры

Page Object Model — паттерн проектирования, который представляет каждую страницу приложения как отдельный класс с интерфейсом для взаимодействия. Это позволяет:

• Отделить логику тестов от деталей реализации страниц
• Повторно использовать код для разных тестовых сценариев
• Легко поддерживать тесты при изменении UI

Пример класса страницы логина:

public class LoginPage {
private WebDriver driver;
private WebDriverWait wait;

// Локаторы
private By loginFieldLocator = By.id("login");
private By passwordFieldLocator = By.id("password");
private By loginButtonLocator = By.cssSelector("button[type='submit']");
private By errorMessageLocator = By.className("error-message");

public LoginPage(WebDriver driver) {
this.driver = driver;
this.wait = new WebDriverWait(driver, Duration.ofSeconds(10));
}

// Открытие страницы
public LoginPage open() {
driver.get("https://example.com/login");
return this;
}

// Ввод логина
public LoginPage enterLogin(String login) {
driver.findElement(loginFieldLocator).sendKeys(login);
return this;
}

// Ввод пароля
public LoginPage enterPassword(String password) {
driver.findElement(passwordFieldLocator).sendKeys(password);
return this;
}

// Клик по кнопке логина
public DashboardPage clickLoginButton() {
driver.findElement(loginButtonLocator).click();
return new DashboardPage(driver);
}

// Метод для комплексного логина
public DashboardPage loginAs(String login, String password) {
enterLogin(login);
enterPassword(password);
return clickLoginButton();
}

// Получение текста ошибки
public String getErrorMessage() {
return wait.until(ExpectedConditions.visibilityOfElementLocated(errorMessageLocator)).getText();
}
}

Использование Page Object в тесте:

@Test
public void testSuccessfulLogin() {
LoginPage loginPage = new LoginPage(driver);
DashboardPage dashboardPage = loginPage
.open()
.enterLogin("test@example.com")
.enterPassword("password123")
.clickLoginButton();

assertTrue(dashboardPage.isPageLoaded());
assertEquals("Добро пожаловать!", dashboardPage.getWelcomeMessage());
}

Работа со сложными элементами интерфейса

Современные веб-интерфейсы содержат множество сложных элементов. Вот как с ними работать:

JavaScript Executor — когда обычные методы бессильны

Иногда стандартные методы Selenium не справляются с задачей. В таких случаях на помощь приходит JavaScript:

JavascriptExecutor js = (JavascriptExecutor) driver;

// Скролл к элементу
WebElement element = driver.findElement(By.id("elementAtBottom"));
js.executeScript("arguments[0].scrollIntoView(true);", element);

// Клик по элементу через JS (когда обычный клик не работает)
js.executeScript("arguments[0].click();", element);

// Установка значения напрямую (обход валидации при вводе)
js.executeScript("arguments[0].value='test@example.com';", driver.findElement(By.id("email")));

// Выполнение асинхронного JS и ожидание результата
Long windowHeight = (Long) js.executeScript("return window.innerHeight;");

Скриншоты и видеозапись для отладки

Для анализа проблем полезно сохранять скриншоты в момент падения теста:

public void takeScreenshot(String fileName) {
File scrFile = ((TakesScreenshot)driver).getScreenshotAs(OutputType.FILE);
try {
FileUtils.copyFile(scrFile, new File("./screenshots/" + fileName + ".png"));
} catch (IOException e) {
e.printStackTrace();
}
}

// В JUnit используем Rule для автоматических скриншотов при падении теста
@Rule
public TestWatcher watcher = new TestWatcher() {
@Override
protected void failed(Throwable e, Description description) {
takeScreenshot(description.getMethodName());
}
};

Data-Driven Testing — управление тестовыми данными

Для параметризации тестов и повторного использования сценариев с разными данными:

@RunWith(Parameterized.class)
public class LoginParameterizedTest {
@Parameterized.Parameters
public static Collection<Object[]> data() {
return Arrays.asList(new Object[][] {
{ "valid@email.com", "validPassword", true, null },
{ "invalid@email.com", "wrongPassword", false, "Неверный логин или пароль" },
{ "", "anyPassword", false, "Введите email" },
{ "valid@email.com", "", false, "Введите пароль" }
});
}

private String email;
private String password;
private boolean shouldLogin;
private String expectedError;

public LoginParameterizedTest(String email, String password, 
boolean shouldLogin, String expectedError) {
this.email = email;
this.password = password;
this.shouldLogin = shouldLogin;
this.expectedError = expectedError;
}

// Тест, использующий параметры
@Test
public void loginWithDifferentCredentials() {
LoginPage loginPage = new LoginPage(driver).open();
loginPage.enterLogin(email).enterPassword(password).clickLoginButton();

if (shouldLogin) {
assertTrue(new DashboardPage(driver).isPageLoaded());
} else {
assertEquals(expectedError, loginPage.getErrorMessage());
}
}
}

Эти продвинутые техники позволят вашим тестам легко масштабироваться, оставаться поддерживаемыми и эффективно находить ошибки. 🚀

Интеграция Selenium в CI/CD для непрерывного тестирования

Автоматизация тестирования раскрывает свой полный потенциал только при интеграции в процесс непрерывной интеграции и доставки (CI/CD). Это позволяет запускать тесты автоматически при каждом изменении кода, обеспечивая раннее обнаружение ошибок. 🔄

Подготовка тестов к запуску в CI/CD

Перед интеграцией убедитесь, что ваши тесты соответствуют следующим требованиям:

• Независимость — каждый тест должен работать изолировано, не зависеть от результатов предыдущих тестов
• Идемпотентность — тесты должны давать одинаковый результат при многократном запуске
• Стабильность — минимизация "хрупких" тестов, зависящих от точного расположения элементов или времени загрузки
• Информативность — тесты должны предоставлять четкую информацию о причине падения
• Управляемость — возможность запуска определенных групп тестов через теги или категории

Настройка Selenium в режиме Headless для CI/CD

В среде CI/CD обычно нет графического интерфейса, поэтому браузеры нужно запускать в режиме headless:

// Chrome в режиме headless
ChromeOptions options = new ChromeOptions();
options.addArguments("--headless", "--disable-gpu", "--window-size=1920,1080");
WebDriver driver = new ChromeDriver(options);

// Firefox в режиме headless
FirefoxOptions options = new FirefoxOptions();
options.addArguments("--headless");
WebDriver driver = new FirefoxDriver(options);

Интеграция с популярными CI/CD платформами

Рассмотрим процесс интеграции с наиболее распространенными системами:

1. Jenkins

Пример конфигурации Pipeline в Jenkinsfile:

pipeline {
agent any
stages {
stage('Checkout') {
steps {
git 'https://github.com/your-repo/selenium-tests.git'
}
}
stage('Build') {
steps {
sh 'mvn clean compile'
}
}
stage('Test') {
steps {
sh 'mvn test'
}
post {
always {
junit '**/target/surefire-reports/*.xml'
archiveArtifacts artifacts: 'target/screenshots/**/*.png', allowEmptyArchive: true
}
}
}
}
}

2. GitLab CI/CD

Пример .gitlab-ci.yml:

image: maven:3.8.4-openjdk-11

variables:
MAVEN_OPTS: "-Dmaven.repo.local=.m2/repository"

cache:
paths:
- .m2/repository/

stages:
- build
- test

build:
stage: build
script:
- mvn clean compile

test:
stage: test
script:
- mvn test
artifacts:
reports:
junit: target/surefire-reports/TEST-*.xml
paths:
- target/screenshots/
expire_in: 1 week

3. GitHub Actions

Пример .github/workflows/selenium-tests.yml:

name: Selenium Tests

on:
push:
branches: [ main, develop ]
pull_request:
branches: [ main ]

jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Set up JDK 11
uses: actions/setup-java@v2
with:
java-version: '11'
distribution: 'adopt'
- name: Install Chrome
run: |
wget -q -O – https://dl-ssl.google.com/linux/linux_signing_key.pub | sudo apt-key add -
echo "deb [arch=amd64] http://dl.google.com/linux/chrome/deb/ stable main" | sudo tee /etc/apt/sources.list.d/google.list
sudo apt-get update
sudo apt-get install -y google-chrome-stable
- name: Run tests
run: mvn test
- name: Publish Test Report
uses: mikepenz/action-junit-report@v2
if: always()
with:
report_paths: '**/target/surefire-reports/TEST-*.xml'
- name: Archive screenshots
uses: actions/upload-artifact@v2
if: failure()
with:
name: selenium-screenshots
path: target/screenshots/

Параллелизация тестов для ускорения

Для сокращения времени выполнения можно запускать тесты параллельно. В TestNG это делается так:

<suite name="Parallel Test Suite" parallel="methods" thread-count="5">
<test name="Parallel Tests">
<classes>
<class name="com.example.LoginTest" />
<class name="com.example.DashboardTest" />
</classes>
</test>
</suite>

В JUnit 5:

@Execution(ExecutionMode.CONCURRENT)
class ConcurrentTestClass {
// тесты будут выполняться параллельно
}

Selenium Grid для распределенного тестирования

Selenium Grid позволяет запускать тесты на разных машинах с различными браузерами и операционными системами:

// Настройка удаленного драйвера
DesiredCapabilities capabilities = new DesiredCapabilities();
capabilities.setBrowserName("chrome");
capabilities.setPlatform(Platform.WINDOWS);

// Подключение к Selenium Grid
WebDriver driver = new RemoteWebDriver(
new URL("http://selenium-hub:4444/wd/hub"), 
capabilities
);

Дмитрий Климов, DevOps Engineer

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

Мы решили интегрировать тесты в наш CI/CD пайплайн на базе Jenkins. Первая проблема возникла сразу: тесты постоянно падали на сервере CI. Оказалось, тесты были написаны с учетом графического интерфейса, а сервер работал без него.

Мы адаптировали тесты для работы в режиме headless и столкнулись со второй проблемой — скорость. Полный набор из 200+ тестов занимал более 2 часов, что замедляло доставку.

Решением стал Selenium Grid в Docker-контейнерах. Мы настроили hub и несколько nodes, распределив тесты между ними. Время выполнения сократилось до 15 минут. Дополнительно внедрили стратегию выборочного запуска тестов, основанную на изменённых файлах в коммите.

Ключевым стало создание информативных отчётов с Allure. Разработчики получали не просто сообщение "тесты упали", а подробный отчёт с шагами воспроизведения, скриншотами и временной шкалой. Это сократило время на отладку проблем на 60%.

Генерация отчетов о тестировании

Подробные отчеты помогают быстро анализировать результаты тестов. Популярные инструменты:

• Allure — интерактивные отчеты с графиками и скриншотами
• Extent Reports — настраиваемые HTML-отчеты с богатым функционалом
• ReportPortal — аналитическая платформа для управления тестами

Пример интеграции Allure с Maven:

<dependency>
<groupId>io.qameta.allure</groupId>
<artifactId>allure-junit5</artifactId>
<version>2.17.3</version>
<scope>test</scope>
</dependency>

<plugin>
<groupId>io.qameta.allure</groupId>
<artifactId>allure-maven</artifactId>
<version>2.10.0</version>
</plugin>

Использование аннотаций Allure в тестах:

@Epic("Авторизация")
@Feature("Вход в систему")
public class LoginTest {
@Test
@Severity(SeverityLevel.CRITICAL)
@Story("Успешный вход в систему с валидными данными")
@Description("Проверка входа в систему с корректными учетными данными")
public void testSuccessfulLogin() {
// код теста

// Добавление скриншота в отчет
Allure.addAttachment("Screenshot", new ByteArrayInputStream(
((TakesScreenshot) driver).getScreenshotAs(OutputType.BYTES)
));
}
}

Интеграция Selenium в CI/CD превращает автоматизированное тестирование из полезного дополнения в неотъемлемую часть процесса разработки, обеспечивая быстрое обнаружение ошибок и уверенность в качестве продукта. 🛡️

Selenium трансформирует подход к тестированию веб-приложений, преобразуя его из искусства в инженерную дисциплину. Освоив все этапы — от базовой настройки до интеграции в CI/CD — вы получаете мощный инструмент обеспечения качества. Ключевым фактором успеха остаётся архитектурный подход: грамотное использование Page Object Model, продуманная обработка ожиданий и построение независимых, повторяемых тестов. Регулярно обновляйте знания о Selenium и сопутствующих инструментах, чтобы поддерживать актуальность автоматизации. Помните: автоматизация — не замена ручного тестирования, а его расширение, позволяющее сосредоточить творческий потенциал команды на исследовательском тестировании и сложных сценариях.