fix(ggr-nginx): route UI session delete to selenoid without breaking create

README.md

@@ -1,111 +1,149 @@
-# OTUS Selenium Homework 2 (BDD + Cucumber)
+# OTUS Homework 4: Selenoid + GGR + Nginx
 
-## Цель проекта
+В этом проекте я собрал инфраструктуру для запуска UI-тестов через Selenoid и добавил Ansible-деплой для локального стенда и удаленных VM.
-Реализовать BDD-подход на `https://otus.ru` с использованием Selenium WebDriver 4+, Cucumber (русские feature), JUnit 5, Guice DI, listeners, Stream API, Jsoup и проверок качества (Checkstyle + SpotBugs).
 
-## Стек технологий
+## Что реализовано
-- Java 21
+- UI-тесты из HW1 запускаются через удаленный `RemoteWebDriver` (Selenoid).
-- Maven
+- Поддержаны браузеры: `chrome`, `firefox`, `mobile_chrome`.
-- Selenium `4.40.0`
+- Подняты сервисы: `selenoid`, `selenoid-ui`, `ggr`, `nginx`.
-- JUnit `5.14.2` + JUnit Platform Suite `1.14.2`
+- Один inventory для всех стендов: `localhost` (WSL), `vm1`, `vm2`.
-- Cucumber (`cucumber-java` `7.34.2`, `cucumber-junit-platform-engine` `7.34.2`)
-- Guice `7.0.0`
-- Jsoup `1.22.1`
-- Guava `33.5.0-jre`
-- SLF4J `2.0.17`
-- Logback `1.5.31`
-- Checkstyle
-- SpotBugs
 
-## Реализованные BDD-сценарии
+Точки доступа:
-1. Выбор браузера через feature.
+- UI: `http://<host_ip>/`
-   - Шаг: `Дано Открыт браузер Chrome`
+- WebDriver: `http://<host_ip>/wd/hub`
-   - Фабрика драйвера выбирается по `browser` property (`chrome`)
 
-2. Поиск курса по имени и случайный выбор при множественных результатах.
+## Версии в проекте
-   - Название курса задается в feature
+Настройки лежат в `ansible/inventory/group_vars/all.yml`.
-   - Выбирается случайный курс из найденных
-   - Проверяется заголовок открытой страницы курса
 
-3. Поиск курсов, стартующих в указанную дату или позже.
+Браузеры:
-   - Дата задается в feature (`dd.MM.yyyy`)
+- Chrome: `128.0`, `127.0`
-   - Выполняется фильтрация `startDate >= dateFrom`
+- Firefox: `125.0`, `124.0`
-   - В консоль выводится: название + дата старта
 
-4. Раздел «Обучение» -> «Подготовительные курсы».
+Образы инфраструктуры:
-   - Открывается пункт `Подготовительные курсы` из меню `Обучение`
+- `aerokube/selenoid:1.11.3`
-   - При необходимости нажимается `Показать еще ...`, чтобы загрузить весь список
+- `aerokube/selenoid-ui:1.10.11`
-   - Из списка выбираются самый дорогой и самый дешевый
+- `aerokube/ggr:1.7.2`
-   - Выбор реализован через Stream API + `filter`
+- `aerokube/ggr-ui:latest-release`
-   - Информация о курсах выводится в консоль
+- `nginx:1.28.2`
 
-5. Общий каталог курсов: самый дорогой и самый дешевый по полной стоимости со скидкой.
+## Что нужно подготовить перед запуском
-   - Открывается `https://otus.ru/catalog/courses`
+На каждой VM должен быть пользователь `ansible`:
-   - Для каждого курса берется цена сравнения:
+- вход по SSH-ключу;
-   - В приоритете `Полная` -> `Полная стоимость со скидкой`
+- `sudo` без пароля (`NOPASSWD`).
-   - Для упрощенных online-страниц используется fallback по видимой цене
-   - Через `filter` выбираются max/min, результат выводится в консоль
 
-## Архитектура
+Ниже один простой вариант первичной подготовки VM.
-- 2-уровневый тест-дизайн: `BDD steps` + `page objects`
-- DI через Guice для step definitions и страниц
-- Фабрика драйвера:
-  - `DriverFactory` (интерфейс)
-  - `ChromeDriverFactory` (реализация)
-  - `WebDriverProvider` (жизненный цикл драйвера + декоратор listener)
-- Подсветка через listener:
-  - Подсветка ставится в `beforeClick`
-  - Снимается в `afterClick`
-  - Стиль элемента возвращается в исходное состояние
 
-## Структура проекта
+1. На локальной машине генерирую ключи (если их еще нет):
-- `src/main/java/ru/kovbasa/config` — DI-конфигурация
-- `src/main/java/ru/kovbasa/driver` — фабрика и провайдер WebDriver
-- `src/main/java/ru/kovbasa/listeners` — listener подсветки
-- `src/main/java/ru/kovbasa/pages` — Page Object классы
-- `src/main/java/ru/kovbasa/elements` — типизированные UI-элементы
-- `src/test/resources/features` — `.feature` файлы (русский язык)
-- `src/test/java/ru/kovbasa/bdd` — Cucumber runner
-- `src/test/java/ru/kovbasa/bdd/steps` — step definitions
-- `src/test/java/ru/kovbasa/bdd/hooks` — lifecycle hooks
-
-## Требования к окружению
-1. Установлен JDK 21 (доступен в `PATH`)
-2. Установлен Google Chrome
-3. Установлен Maven 3.9+
-4. Есть доступ в интернет и к `otus.ru` (тесты запускаются на живом сайте)
-
-## Запуск
-### 1. Запуск всех тестов
 ```bash
-mvn test
+ssh-keygen -f ~/.ssh/id_ed25519
 ```
 
-### 2. Запуск конкретного Cucumber runner
+2. Захожу на VM под `root`:
 ```bash
-mvn "-Dtest=ru.kovbasa.bdd.CucumberTest" test
+ssh root@10.10.2.127
 ```
 
-### 3. Локальная полная проверка (необязательно для сдачи ДЗ)
+3. Под `root` создаю пользователя `ansible`, добавляю в `sudo` и в `sudoers`:
 ```bash
-mvn verify
+useradd -m -s /bin/bash ansible
+usermod -aG sudo ansible
+echo "ansible ALL=(ALL) NOPASSWD:ALL" > /etc/sudoers.d/ansible
+chmod 440 /etc/sudoers.d/ansible
 ```
 
-## Параметры запуска
+4. Под `root` кладу публичный ключ в профиль `ansible`:
-Пробрасываются через Maven Surefire:
-- `base.url` (по умолчанию `https://otus.ru`)
-- `course.name` (по умолчанию `Python Developer`)
-- `browser` (по умолчанию `chrome`)
-
-Пример переопределения:
 ```bash
-mvn "-Dbrowser=chrome" "-Dcourse.name=Python" test
+install -d -m 700 -o ansible -g ansible /home/ansible/.ssh
+cat >> /home/ansible/.ssh/authorized_keys
+```
+После запуска этой команды вставляю содержимое `~/.ssh/id_ed25519.pub`, затем `Ctrl+D`.
+
+5. Под `root` выставляю права:
+```bash
+chown ansible:ansible /home/ansible/.ssh/authorized_keys
+chmod 600 /home/ansible/.ssh/authorized_keys
 ```
 
-## Quality Gates
+6. Проверяю вход под `ansible`:
-- Checkstyle и SpotBugs выполняются в фазе `verify` (опционально)
+```bash
+ssh -i ~/.ssh/id_ed25519 ansible@10.10.2.127 "whoami && sudo -n true && echo sudo_ok"
+```
 
-## Примечания
+## Как добавить новые VM
-- Тесты зависят от текущей верстки/контента `otus.ru`.
+1. Добавляю хост в `ansible/inventory/hosts.ini`.
-- По умолчанию в `mvn test` запускается только `CucumberTest`.
+2. Создаю `ansible/inventory/host_vars/vmN.yml`:
-- Для сдачи ДЗ достаточно успешного запуска `mvn test`.
+```yaml
+ansible_host: <ip>
+ansible_user: ansible
+ggr_selenoid_host_override: selenoid
+```
+
+## Запуск Ansible
+В PowerShell синтаксис `VAR=value command` не работает, поэтому запускаю через `wsl bash -lc`.
+
+Важно: `--limit` должен быть внутри кавычек команды.
+
+### localhost (WSL)
+```powershell
+wsl bash -lc "cd /mnt/c/Users/spawn/IdeaProjects/otus-autotests/homework_1/ansible && ANSIBLE_ROLES_PATH=./roles ansible-playbook -i inventory/hosts.ini playbooks/site.yml --limit localhost"
+```
+
+### VM1
+```powershell
+wsl bash -lc "cd /mnt/c/Users/spawn/IdeaProjects/otus-autotests/homework_1/ansible && ANSIBLE_ROLES_PATH=./roles ansible-playbook -i inventory/hosts.ini playbooks/site.yml --limit vm1"
+```
+
+### VM2
+```powershell
+wsl bash -lc "cd /mnt/c/Users/spawn/IdeaProjects/otus-autotests/homework_1/ansible && ANSIBLE_ROLES_PATH=./roles ansible-playbook -i inventory/hosts.ini playbooks/site.yml --limit vm2"
+```
+
+Если ключ используется из `/mnt/c/...`, в WSL может быть ошибка `UNPROTECTED PRIVATE KEY FILE`.  
+Я использую копию ключа в WSL-профиле:
+```bash
+mkdir -p ~/.ssh
+cp /mnt/c/Users/spawn/.ssh/id_ed25519 ~/.ssh/id_ed25519
+cp /mnt/c/Users/spawn/.ssh/id_ed25519.pub ~/.ssh/id_ed25519.pub
+chmod 700 ~/.ssh
+chmod 600 ~/.ssh/id_ed25519
+chmod 644 ~/.ssh/id_ed25519.pub
+```
+
+## Команды для запуска тестов
+### Все UI-тесты (Chrome)
+```bash
+mvn "-Dexecution.mode=selenoid" "-Dbrowser=chrome" "-Dbrowser.version=128.0" "-Dselenoid.url=http://10.10.2.112/wd/hub" test
+```
+
+### Конкретный UI-тест
+```bash
+mvn "-Dexecution.mode=selenoid" "-Dbrowser=chrome" "-Dbrowser.version=128.0" "-Dselenoid.url=http://10.10.2.112/wd/hub" "-Dtest=ru.kovbasa.tests.CourseSearchTest" test
+```
+
+### Mobile Chrome
+```bash
+mvn "-Dexecution.mode=selenoid" "-Dbrowser=mobile_chrome" "-Dbrowser.version=128.0" "-Dselenoid.url=http://10.10.2.112/wd/hub" test
+```
+
+### Firefox
+```bash
+mvn "-Dexecution.mode=selenoid" "-Dbrowser=firefox" "-Dbrowser.version=125.0" "-Dselenoid.url=http://10.10.2.112/wd/hub" test
+```
+
+### Citrus (HW3 API)
+Citrus: вынесен в отдельный модуль `citrus-tests`, реализовано на базе HW3;
+```bash
+mvn -f citrus-tests/pom.xml test
+```
+
+### Запуск тестов через Ansible
+```powershell
+wsl bash -lc "cd /mnt/c/Users/spawn/IdeaProjects/otus-autotests/homework_1/ansible && ANSIBLE_ROLES_PATH=./roles ansible-playbook -i inventory/hosts.ini playbooks/site.yml --limit vm1 -e run_tests_via_ansible=true"
+```
+
+## Запуск с Linux/macOS
+На Linux/macOS:
+```bash
+cd ansible
+ANSIBLE_ROLES_PATH=./roles ansible-playbook -i inventory/hosts.ini playbooks/site.yml --limit vm1
+```

ansible/ansible.cfg

@@ -0,0 +1,5 @@
+[defaults]
+inventory = inventory/hosts.ini
+host_key_checking = False
+retry_files_enabled = False
+interpreter_python = auto_silent

ansible/inventory/group_vars/all.yml

@@ -0,0 +1,37 @@
+---
+run_apt_upgrade: false
+ansible_ssh_private_key_file: /home/spawn/.ssh/id_ed25519
+ansible_ssh_common_args: "-o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o ConnectTimeout=10 -o ServerAliveInterval=10 -o ServerAliveCountMax=3"
+
+selenoid_dir: /opt/selenoid
+selenoid_compose_file: docker-compose.selenoid.yml
+selenoid_limit: 2
+selenoid_ui_port: 8080
+selenoid_container_network: "selenoid_default"
+selenoid_host_port: 4444
+selenoid_image: "aerokube/selenoid:1.11.3"
+selenoid_ui_image: "aerokube/selenoid-ui:1.10.11"
+selenoid_chrome_versions:
+  - "128.0"
+  - "127.0"
+selenoid_firefox_versions:
+  - "125.0"
+  - "124.0"
+
+ggr_dir: /opt/ggr
+ggr_compose_file: docker-compose.ggr.yml
+ggr_gateway_port: 4445
+ggr_ui_listen_port: 8888
+ggr_ui_public_port: 8888
+ggr_nginx_public_port: 80
+ggr_quota_name: guest
+ggr_image: "aerokube/ggr:1.7.2"
+ggr_ui_image: "aerokube/ggr-ui:latest-release"
+nginx_image: "nginx:1.28.2"
+
+run_tests_via_ansible: false
+test_runner_execute_mode: control
+test_runner_project_dir: /opt/otus-autotests/homework_1
+test_runner_control_project_dir: /mnt/c/Users/spawn/IdeaProjects/otus-autotests/homework_1
+test_runner_ui_test_class: ru.kovbasa.tests.CourseSearchTest
+test_runner_browser: chrome

ansible/inventory/host_vars/localhost.yml

@@ -0,0 +1,3 @@
+---
+ansible_connection: local
+ggr_selenoid_host_override: selenoid

ansible/inventory/host_vars/vm1.yml

@@ -0,0 +1,4 @@
+---
+ansible_host: 10.10.2.112
+ansible_user: ansible
+ggr_selenoid_host_override: selenoid

ansible/inventory/host_vars/vm2.yml

@@ -0,0 +1,4 @@
+---
+ansible_host: 10.10.2.127
+ansible_user: ansible
+ggr_selenoid_host_override: selenoid

ansible/inventory/hosts.ini

@@ -0,0 +1,9 @@
+[selenoid_nodes]
+localhost
+vm1
+vm2
+
+[ggr_gateway]
+localhost
+vm1
+vm2

ansible/playbooks/provision.yml

@@ -0,0 +1,20 @@
+---
+- name: Provision Selenoid Nodes
+  hosts: selenoid_nodes
+  become: true
+  tags:
+    - provision
+  roles:
+    - common
+    - docker
+    - selenoid
+
+- name: Provision GGR Gateway
+  hosts: ggr_gateway
+  become: true
+  tags:
+    - provision
+  roles:
+    - common
+    - docker
+    - ggr_gateway

ansible/playbooks/site.yml

@@ -0,0 +1,4 @@
+---
+- import_playbook: provision.yml
+- import_playbook: verify.yml
+- import_playbook: tests.yml

ansible/playbooks/tests.yml

@@ -0,0 +1,11 @@
+---
+- name: Run tests on provisioned host
+  hosts: ggr_gateway
+  become: true
+  tags:
+    - tests
+  tasks:
+    - name: Execute test runner role when enabled
+      ansible.builtin.include_role:
+        name: test_runner
+      when: run_tests_via_ansible | bool

ansible/playbooks/verify.yml

@@ -0,0 +1,8 @@
+---
+- name: Verify deployed grid endpoints
+  hosts: ggr_gateway
+  become: true
+  tags:
+    - verify
+  roles:
+    - verify

ansible/roles/common/tasks/main.yml

@@ -0,0 +1,19 @@
+---
+- name: Update apt cache
+  ansible.builtin.apt:
+    update_cache: true
+    cache_valid_time: 3600
+
+- name: Upgrade apt packages (optional)
+  ansible.builtin.apt:
+    upgrade: dist
+  when: run_apt_upgrade | bool
+
+- name: Install base packages
+  ansible.builtin.apt:
+    name:
+      - ca-certificates
+      - curl
+      - gnupg
+      - lsb-release
+    state: present

ansible/roles/docker/tasks/main.yml

@@ -0,0 +1,32 @@
+---
+- name: Check whether docker CLI is already available
+  ansible.builtin.command: docker --version
+  register: docker_cli_check
+  changed_when: false
+  failed_when: false
+
+- name: Install Docker packages when docker is missing
+  ansible.builtin.apt:
+    name:
+      - docker.io
+      - docker-compose-v2
+    state: present
+  when: docker_cli_check.rc != 0
+
+- name: Enable Docker service when installed by role and systemd is available
+  ansible.builtin.service:
+    name: docker
+    state: started
+    enabled: true
+  when:
+    - docker_cli_check.rc != 0
+    - ansible_service_mgr == "systemd"
+
+- name: Add current ansible user to docker group
+  ansible.builtin.user:
+    name: "{{ ansible_user }}"
+    groups: docker
+    append: true
+  when:
+    - ansible_user is defined
+    - docker_cli_check.rc != 0

ansible/roles/ggr_gateway/tasks/main.yml

@@ -0,0 +1,37 @@
+- name: Create GGR directory structure
+  ansible.builtin.file:
+    path: "{{ ggr_dir }}/{{ item }}"
+    state: directory
+    mode: "0755"
+  loop:
+    - quota
+    - nginx
+
+- name: Render GGR quota file
+  ansible.builtin.template:
+    src: quota.xml.j2
+    dest: "{{ ggr_dir }}/quota/{{ ggr_quota_name }}.xml"
+    mode: "0644"
+
+- name: Render nginx config
+  ansible.builtin.template:
+    src: nginx.conf.j2
+    dest: "{{ ggr_dir }}/nginx/default.conf"
+    mode: "0644"
+
+- name: Render docker compose for GGR gateway
+  ansible.builtin.template:
+    src: docker-compose.ggr.yml.j2
+    dest: "{{ ggr_dir }}/{{ ggr_compose_file }}"
+    mode: "0644"
+
+- name: Stop previous GGR gateway stack and remove orphans
+  ansible.builtin.command:
+    cmd: docker compose -f {{ ggr_compose_file }} down --remove-orphans
+    chdir: "{{ ggr_dir }}"
+  changed_when: false
+
+- name: Start GGR gateway stack
+  ansible.builtin.command:
+    cmd: docker compose -f {{ ggr_compose_file }} up -d --force-recreate
+    chdir: "{{ ggr_dir }}"

ansible/roles/ggr_gateway/templates/docker-compose.ggr.yml.j2

@@ -0,0 +1,46 @@
+services:
+  ggr:
+    image: "{{ ggr_image }}"
+    container_name: ggr
+    restart: unless-stopped
+    ports:
+      - "{{ ggr_gateway_port }}:4444"
+    volumes:
+      - "./quota:/etc/grid-router/quota:ro"
+    command:
+      - "-listen"
+      - ":4444"
+      - "-quotaDir"
+      - "/etc/grid-router/quota"
+      - "-guests-allowed"
+
+  ggr-ui:
+    image: "{{ ggr_ui_image }}"
+    container_name: ggr-ui
+    restart: unless-stopped
+    ports:
+      - "{{ ggr_ui_public_port }}:8888"
+    volumes:
+      - "./quota:/etc/grid-router/quota:ro"
+    command:
+      - "-listen"
+      - ":8888"
+      - "-quota-dir"
+      - "/etc/grid-router/quota"
+
+  nginx:
+    image: "{{ nginx_image }}"
+    container_name: grid-nginx
+    restart: unless-stopped
+    depends_on:
+      - ggr
+      - ggr-ui
+    ports:
+      - "{{ ggr_nginx_public_port }}:80"
+    volumes:
+      - "./nginx/default.conf:/etc/nginx/conf.d/default.conf:ro"
+
+networks:
+  default:
+    name: "{{ selenoid_container_network }}"
+    external: true

ansible/roles/ggr_gateway/templates/nginx.conf.j2

@@ -0,0 +1,81 @@
+server {
+    listen 80;
+    server_name _;
+
+    location /ws/ {
+        proxy_pass http://selenoid:4444/;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "upgrade";
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+
+    location /vnc/ {
+        proxy_pass http://selenoid:4444/vnc/;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "upgrade";
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+
+    location = /wd/hub/session {
+        proxy_pass http://ggr:4444/wd/hub/session;
+        proxy_http_version 1.1;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+
+    location /wd/hub/ {
+        proxy_pass http://ggr:4444/wd/hub/;
+        proxy_http_version 1.1;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+
+    location /wd/hub/session/ {
+        proxy_pass http://selenoid:4444/wd/hub/session/;
+        proxy_http_version 1.1;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+
+    location /session/ {
+        rewrite ^/session/(.*)$ /wd/hub/session/$1 break;
+        proxy_pass http://selenoid:4444;
+        proxy_http_version 1.1;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+
+    location /ggr/ {
+        proxy_pass http://ggr-ui:8888/;
+        proxy_http_version 1.1;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+
+    location / {
+        proxy_pass http://selenoid-ui:8080/;
+        proxy_http_version 1.1;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+}

ansible/roles/ggr_gateway/templates/quota.xml.j2

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<qa:browsers xmlns:qa="urn:config.gridrouter.qatools.ru">
+  <browser name="chrome" defaultVersion="{{ selenoid_chrome_versions | first }}">
+{% for version in selenoid_chrome_versions %}
+    <version number="{{ version }}">
+      <region name="default">
+        <host name="{{ ggr_selenoid_host_override | default(ansible_host | default(inventory_hostname)) }}" port="{{ selenoid_host_port }}" count="{{ selenoid_limit }}"/>
+      </region>
+    </version>
+{% endfor %}
+  </browser>
+  <browser name="firefox" defaultVersion="{{ selenoid_firefox_versions | first }}">
+{% for version in selenoid_firefox_versions %}
+    <version number="{{ version }}">
+      <region name="default">
+        <host name="{{ ggr_selenoid_host_override | default(ansible_host | default(inventory_hostname)) }}" port="{{ selenoid_host_port }}" count="{{ selenoid_limit }}"/>
+      </region>
+    </version>
+{% endfor %}
+  </browser>
+</qa:browsers>

ansible/roles/selenoid/tasks/main.yml

@@ -0,0 +1,68 @@
+---
+- name: Create Selenoid directory
+  ansible.builtin.file:
+    path: "{{ selenoid_dir }}"
+    state: directory
+    mode: "0755"
+
+- name: Create logs directory
+  ansible.builtin.file:
+    path: "{{ selenoid_dir }}/{{ item }}"
+    state: directory
+    mode: "0777"
+  loop:
+    - logs
+
+- name: Render browsers.json
+  ansible.builtin.template:
+    src: browsers.json.j2
+    dest: "{{ selenoid_dir }}/browsers.json"
+    mode: "0644"
+
+- name: Render docker compose for Selenoid
+  ansible.builtin.template:
+    src: docker-compose.selenoid.yml.j2
+    dest: "{{ selenoid_dir }}/{{ selenoid_compose_file }}"
+    mode: "0644"
+
+- name: Ensure default chrome version is in the configured versions list
+  ansible.builtin.assert:
+    that:
+      - (selenoid_chrome_versions | length) >= 2
+      - (selenoid_firefox_versions | length) >= 2
+    fail_msg: "Invalid Selenoid config: provide at least 2 chrome and 2 firefox versions"
+
+- name: Check shared Docker network for grid stack
+  ansible.builtin.command:
+    cmd: docker network inspect {{ selenoid_container_network }}
+  register: shared_grid_network
+  changed_when: false
+  failed_when: false
+
+- name: Create shared Docker network for grid stack
+  ansible.builtin.command:
+    cmd: docker network create {{ selenoid_container_network }}
+  when: shared_grid_network.rc != 0
+
+- name: Stop previous Selenoid stack and remove orphans
+  ansible.builtin.command:
+    cmd: docker compose -f {{ selenoid_compose_file }} down --remove-orphans
+    chdir: "{{ selenoid_dir }}"
+  changed_when: false
+
+- name: Pull required Chrome images for Selenoid
+  ansible.builtin.command:
+    cmd: "docker pull selenoid/vnc:chrome_{{ item }}"
+  loop: "{{ selenoid_chrome_versions }}"
+  changed_when: false
+
+- name: Pull required Firefox images for Selenoid
+  ansible.builtin.command:
+    cmd: "docker pull selenoid/vnc:firefox_{{ item }}"
+  loop: "{{ selenoid_firefox_versions }}"
+  changed_when: false
+
+- name: Start Selenoid stack
+  ansible.builtin.command:
+    cmd: docker compose -f {{ selenoid_compose_file }} up -d
+    chdir: "{{ selenoid_dir }}"

ansible/roles/selenoid/templates/browsers.json.j2

@@ -0,0 +1,26 @@
+{
+  "chrome": {
+    "default": "{{ selenoid_chrome_versions | first }}",
+    "versions": {
+{% for version in selenoid_chrome_versions %}
+      "{{ version }}": {
+        "image": "selenoid/vnc:chrome_{{ version }}",
+        "port": "4444",
+        "path": "/"
+      }{% if not loop.last %},{% endif %}
+{% endfor %}
+    }
+  },
+  "firefox": {
+    "default": "{{ selenoid_firefox_versions | first }}",
+    "versions": {
+{% for version in selenoid_firefox_versions %}
+      "{{ version }}": {
+        "image": "selenoid/vnc:firefox_{{ version }}",
+        "port": "4444",
+        "path": "/wd/hub"
+      }{% if not loop.last %},{% endif %}
+{% endfor %}
+    }
+  }
+}

ansible/roles/selenoid/templates/docker-compose.selenoid.yml.j2

@@ -0,0 +1,46 @@
+services:
+  selenoid:
+    image: "{{ selenoid_image }}"
+    container_name: selenoid
+    restart: unless-stopped
+    environment:
+      - DOCKER_API_VERSION=1.45
+    ports:
+      - "{{ selenoid_host_port }}:4444"
+    volumes:
+      - "./browsers.json:/etc/selenoid/browsers.json:ro"
+      - "/var/run/docker.sock:/var/run/docker.sock"
+      - "./logs:/opt/selenoid/logs"
+    command:
+      - "-limit"
+      - "{{ selenoid_limit }}"
+      - "-conf"
+      - "/etc/selenoid/browsers.json"
+      - "-log-output-dir"
+      - "/opt/selenoid/logs"
+      - "-container-network"
+      - "{{ selenoid_container_network }}"
+      - "-timeout"
+      - "3m"
+      - "-session-attempt-timeout"
+      - "2m"
+      - "-service-startup-timeout"
+      - "2m"
+
+  selenoid-ui:
+    image: "{{ selenoid_ui_image }}"
+    container_name: selenoid-ui
+    restart: unless-stopped
+    depends_on:
+      - selenoid
+    ports:
+      - "{{ selenoid_ui_port }}:8080"
+    command:
+      - "--selenoid-uri"
+      - "http://selenoid:4444"
+
+networks:
+  default:
+    name: "{{ selenoid_container_network }}"
+    external: true
+

ansible/roles/test_runner/tasks/main.yml

@@ -0,0 +1,38 @@
+---
+- name: Install Java and Maven for test execution
+  ansible.builtin.apt:
+    name:
+      - openjdk-21-jdk
+      - maven
+    state: present
+    update_cache: true
+  when: test_runner_execute_mode == "target"
+
+- name: Run UI smoke test via Selenoid endpoint
+  ansible.builtin.command:
+    cmd: >
+      mvn
+      "-Dexecution.mode=selenoid"
+      "-Dbrowser={{ test_runner_browser }}"
+      "-Dbrowser.version={{ selenoid_chrome_versions[0] }}"
+      "-Dselenoid.url=http://{{ (ansible_host | default('127.0.0.1')) if test_runner_execute_mode == 'control' else '127.0.0.1' }}/wd/hub"
+      "-Dtest={{ test_runner_ui_test_class }}"
+      test
+    chdir: "{{ test_runner_control_project_dir if test_runner_execute_mode == 'control' else test_runner_project_dir }}"
+  environment:
+    JAVA_HOME: /usr/lib/jvm/java-21-openjdk-amd64
+  delegate_to: "{{ 'localhost' if test_runner_execute_mode == 'control' else omit }}"
+  become: false
+  register: ui_test_result
+  changed_when: false
+
+- name: Run Citrus API tests
+  ansible.builtin.command:
+    cmd: mvn -f citrus-tests/pom.xml test
+    chdir: "{{ test_runner_control_project_dir if test_runner_execute_mode == 'control' else test_runner_project_dir }}"
+  environment:
+    JAVA_HOME: /usr/lib/jvm/java-21-openjdk-amd64
+  delegate_to: "{{ 'localhost' if test_runner_execute_mode == 'control' else omit }}"
+  become: false
+  register: citrus_test_result
+  changed_when: false

ansible/roles/verify/tasks/main.yml

@@ -0,0 +1,40 @@
+---
+- name: Wait for Selenoid status endpoint
+  ansible.builtin.uri:
+    url: "http://127.0.0.1:{{ selenoid_host_port }}/status"
+    method: GET
+    status_code: 200
+  register: selenoid_status_response
+  retries: 20
+  delay: 3
+  until: selenoid_status_response.status == 200
+
+- name: Wait for GGR ping endpoint
+  ansible.builtin.uri:
+    url: "http://127.0.0.1:{{ ggr_gateway_port }}/ping"
+    method: GET
+    status_code: 200
+  register: ggr_ping_response
+  retries: 20
+  delay: 3
+  until: ggr_ping_response.status == 200
+
+- name: Wait for gateway UI endpoint
+  ansible.builtin.uri:
+    url: "http://127.0.0.1:{{ ggr_nginx_public_port }}/"
+    method: GET
+    status_code: 200
+  register: ggr_ui_response
+  retries: 20
+  delay: 3
+  until: ggr_ui_response.status == 200
+
+- name: Wait for gateway webdriver status endpoint
+  ansible.builtin.uri:
+    url: "http://127.0.0.1:{{ ggr_nginx_public_port }}/wd/hub/status"
+    method: GET
+    status_code: 200
+  register: wd_status_response
+  retries: 20
+  delay: 3
+  until: wd_status_response.status == 200

citrus-tests/pom.xml

@@ -0,0 +1,75 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>ru.kovbasa</groupId>
+    <artifactId>citrus-tests</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <name>citrus-tests</name>
+
+    <properties>
+        <maven.compiler.release>21</maven.compiler.release>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+
+        <citrus.version>3.2.1</citrus.version>
+        <surefire.version>2.22.2</surefire.version>
+        <log4j2.version>2.25.1</log4j2.version>
+
+        <petstore.base.url>https://petstore.swagger.io</petstore.base.url>
+        <petstore.base.path>/v2</petstore.base.path>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.consol.citrus</groupId>
+            <artifactId>citrus-core</artifactId>
+            <version>${citrus.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.consol.citrus</groupId>
+            <artifactId>citrus-http</artifactId>
+            <version>${citrus.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.consol.citrus</groupId>
+            <artifactId>citrus-testng</artifactId>
+            <version>${citrus.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.logging.log4j</groupId>
+            <artifactId>log4j-slf4j-impl</artifactId>
+            <version>${log4j2.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.15.0</version>
+                <configuration>
+                    <release>${maven.compiler.release}</release>
+                </configuration>
+            </plugin>
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>${surefire.version}</version>
+                <configuration>
+                    <systemPropertyVariables>
+                        <petstore.base.url>${petstore.base.url}</petstore.base.url>
+                        <petstore.base.path>${petstore.base.path}</petstore.base.path>
+                    </systemPropertyVariables>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>

citrus-tests/src/test/java/ru/kovbasa/citrus/PetstoreNegativeScenariosTest.java

@@ -0,0 +1,57 @@
+package ru.kovbasa.citrus;
+
+import com.consol.citrus.annotations.CitrusTest;
+import com.consol.citrus.message.MessageType;
+import com.consol.citrus.testng.spring.TestNGCitrusSpringSupport;
+import org.springframework.http.HttpStatus;
+import org.testng.annotations.Test;
+
+import java.util.concurrent.ThreadLocalRandom;
+
+import static com.consol.citrus.http.actions.HttpActionBuilder.http;
+import static com.consol.citrus.validation.json.JsonPathMessageValidationContext.Builder.jsonPath;
+
+public class PetstoreNegativeScenariosTest extends TestNGCitrusSpringSupport {
+
+    @CitrusTest
+    @Test(description = "GET /pet/{id} returns 404 for unknown id")
+    public void getMissingPetReturnsNotFound() {
+        long petId = ThreadLocalRandom.current().nextLong(1_000_000L, Integer.MAX_VALUE);
+        variable("petId", String.valueOf(petId));
+
+        run(http()
+                .client("petstoreClient")
+                .send()
+                .get("/pet/${petId}"));
+
+        run(http()
+                .client("petstoreClient")
+                .receive()
+                .response(HttpStatus.NOT_FOUND)
+                .message()
+                .validate(jsonPath().expression("$.message", "Pet not found")));
+    }
+
+    @CitrusTest
+    @Test(description = "POST /pet with malformed JSON returns 400")
+    public void createPetWithMalformedJsonReturnsError() {
+        run(http()
+                .client("petstoreClient")
+                .send()
+                .post("/pet")
+                .message()
+                .type(MessageType.JSON)
+                .header("Content-Type", "application/json")
+                .body("""
+                        {
+                          "id": 123456,
+                          "name": "Broken pet",
+                          "photoUrls": ["https://petstore.test/photo.jpg"]
+                        """));
+
+        run(http()
+                .client("petstoreClient")
+                .receive()
+                .response(HttpStatus.BAD_REQUEST));
+    }
+}

citrus-tests/src/test/java/ru/kovbasa/citrus/PetstorePositiveScenariosTest.java

@@ -0,0 +1,81 @@
+package ru.kovbasa.citrus;
+
+import com.consol.citrus.annotations.CitrusTest;
+import com.consol.citrus.message.MessageType;
+import com.consol.citrus.testng.spring.TestNGCitrusSpringSupport;
+import org.springframework.http.HttpStatus;
+import org.testng.annotations.Test;
+
+import java.util.concurrent.ThreadLocalRandom;
+
+import static com.consol.citrus.http.actions.HttpActionBuilder.http;
+import static com.consol.citrus.validation.json.JsonPathMessageValidationContext.Builder.jsonPath;
+
+public class PetstorePositiveScenariosTest extends TestNGCitrusSpringSupport {
+
+    @CitrusTest
+    @Test(description = "POST /pet creates resource and GET /pet/{id} returns created pet")
+    public void createPetAndGetById() {
+        long petId = ThreadLocalRandom.current().nextLong(1_000_000L, Integer.MAX_VALUE);
+        String petName = "Rex-" + petId;
+
+        variable("petId", String.valueOf(petId));
+        variable("petName", petName);
+
+        run(http()
+                .client("petstoreClient")
+                .send()
+                .post("/pet")
+                .message()
+                .type(MessageType.JSON)
+                .header("Content-Type", "application/json")
+                .body("""
+                        {
+                          "id": ${petId},
+                          "category": {
+                            "id": 1,
+                            "name": "Dogs"
+                          },
+                          "name": "${petName}",
+                          "photoUrls": ["https://petstore.test/photo.jpg"],
+                          "tags": [{
+                            "id": 1,
+                            "name": "api-test"
+                          }],
+                          "status": "available"
+                        }
+                        """));
+
+        run(http()
+                .client("petstoreClient")
+                .receive()
+                .response(HttpStatus.OK)
+                .message()
+                .validate(jsonPath().expression("$.id", "${petId}"))
+                .validate(jsonPath().expression("$.name", "${petName}"))
+                .validate(jsonPath().expression("$.status", "available")));
+
+        run(http()
+                .client("petstoreClient")
+                .send()
+                .get("/pet/${petId}"));
+
+        run(http()
+                .client("petstoreClient")
+                .receive()
+                .response(HttpStatus.OK)
+                .message()
+                .validate(jsonPath().expression("$.id", "${petId}"))
+                .validate(jsonPath().expression("$.name", "${petName}")));
+
+        run(http()
+                .client("petstoreClient")
+                .send()
+                .delete("/pet/${petId}"));
+
+        run(http()
+                .client("petstoreClient")
+                .receive()
+                .response(HttpStatus.OK));
+    }
+}

citrus-tests/src/test/resources/citrus-context.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xmlns:citrus="http://www.citrusframework.org/schema/config"
+       xmlns:citrus-http="http://www.citrusframework.org/schema/http/config"
+       xmlns:context="http://www.springframework.org/schema/context"
+       xsi:schemaLocation="
+       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
+       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
+       http://www.citrusframework.org/schema/config http://www.citrusframework.org/schema/config/citrus-config.xsd
+       http://www.citrusframework.org/schema/http/config http://www.citrusframework.org/schema/http/config/citrus-http-config.xsd">
+
+    <context:property-placeholder location="classpath:citrus.properties"/>
+
+    <citrus:global-variables>
+        <citrus:file path="classpath:citrus.properties"/>
+    </citrus:global-variables>
+
+    <citrus-http:client id="petstoreClient"
+                        request-url="${petstore.base.url}${petstore.base.path}"
+                        timeout="10000"/>
+
+</beans>

citrus-tests/src/test/resources/citrus.properties

@@ -0,0 +1,5 @@
+default.test.author=spawn
+default.test.package=ru.kovbasa.citrus
+
+petstore.base.url=https://petstore.swagger.io
+petstore.base.path=/v2

citrus-tests/src/test/resources/log4j2.properties

@@ -0,0 +1,11 @@
+status = WARN
+name = citrus-log4j2
+
+appender.console.type = Console
+appender.console.name = Console
+appender.console.layout.type = PatternLayout
+appender.console.layout.pattern = %d{HH:mm:ss.SSS} %-5p %c{1} - %m%n
+
+rootLogger.level = INFO
+rootLogger.appenderRefs = stdout
+rootLogger.appenderRef.stdout.ref = Console

pom.xml

@@ -16,18 +16,20 @@
         <!-- Конфиг тестов -->
         <base.url>https://otus.ru</base.url>
         <course.name>Python Developer</course.name>
+        <execution.mode>local</execution.mode>
         <browser>chrome</browser>
+        <browser.version></browser.version>
+        <selenoid.url>http://localhost/wd/hub</selenoid.url>
 
         <!-- Dependencies -->
-        <selenium.version>4.40.0</selenium.version>
+        <selenium.version>4.41.0</selenium.version>
-        <junit.version>5.14.2</junit.version>
+        <junit.version>6.0.2</junit.version>
-        <junit.platform.suite.version>1.14.2</junit.platform.suite.version>
+        <webdrivermanager.version>6.3.3</webdrivermanager.version>
-        <cucumber.version>7.34.2</cucumber.version>
         <guice.version>7.0.0</guice.version>
-        <guava.version>33.5.0-jre</guava.version>
         <jsoup.version>1.22.1</jsoup.version>
         <slf4j.version>2.0.17</slf4j.version>
-        <logback.version>1.5.31</logback.version>
+        <logback.version>1.5.32</logback.version>
+        <guava.version>33.5.0-jre</guava.version>
 
         <!-- Plugins -->
         <maven.compiler.version>3.15.0</maven.compiler.version>
@@ -47,6 +49,13 @@
             <version>${selenium.version}</version>
         </dependency>
 
+        <!-- WebDriverManager -->
+        <dependency>
+            <groupId>io.github.bonigarcia</groupId>
+            <artifactId>webdrivermanager</artifactId>
+            <version>${webdrivermanager.version}</version>
+        </dependency>
+
         <!-- JUnit -->
         <dependency>
             <groupId>org.junit.jupiter</groupId>
@@ -55,27 +64,6 @@
             <scope>test</scope>
         </dependency>
 
-        <dependency>
-            <groupId>org.junit.platform</groupId>
-            <artifactId>junit-platform-suite</artifactId>
-            <version>${junit.platform.suite.version}</version>
-            <scope>test</scope>
-        </dependency>
-
-        <dependency>
-            <groupId>io.cucumber</groupId>
-            <artifactId>cucumber-java</artifactId>
-            <version>${cucumber.version}</version>
-            <scope>test</scope>
-        </dependency>
-
-        <dependency>
-            <groupId>io.cucumber</groupId>
-            <artifactId>cucumber-junit-platform-engine</artifactId>
-            <version>${cucumber.version}</version>
-            <scope>test</scope>
-        </dependency>
-
         <!-- Guice -->
         <dependency>
             <groupId>com.google.inject</groupId>
@@ -83,13 +71,6 @@
             <version>${guice.version}</version>
         </dependency>
 
-        <!-- Force modern Guava to avoid deprecated Unsafe usage on new JDKs -->
-        <dependency>
-            <groupId>com.google.guava</groupId>
-            <artifactId>guava</artifactId>
-            <version>${guava.version}</version>
-        </dependency>
-
         <!-- Jsoup -->
         <dependency>
             <groupId>org.jsoup</groupId>
@@ -110,6 +91,12 @@
             <version>${logback.version}</version>
         </dependency>
 
+        <!-- Guava -->
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>${guava.version}</version>
+        </dependency>
     </dependencies>
 
     <build>
@@ -132,16 +119,13 @@
                 <version>${surefire.version}</version>
                 <configuration>
                     <useModulePath>false</useModulePath>
-                    <argLine>
-                        -Djava.util.logging.config.file=${project.basedir}/src/test/resources/logging.properties
-                    </argLine>
-                    <includes>
-                        <include>**/CucumberTest.java</include>
-                    </includes>
                     <systemPropertyVariables>
                         <base.url>${base.url}</base.url>
                         <course.name>${course.name}</course.name>
+                        <execution.mode>${execution.mode}</execution.mode>
                         <browser>${browser}</browser>
+                        <browser.version>${browser.version}</browser.version>
+                        <selenoid.url>${selenoid.url}</selenoid.url>
                     </systemPropertyVariables>
                 </configuration>
             </plugin>

src/main/java/ru/kovbasa/config/DriverModule.java

@@ -1,16 +1,30 @@
 package ru.kovbasa.config;
 
 import com.google.inject.AbstractModule;
+import com.google.inject.Provides;
 import com.google.inject.Singleton;
+import ru.kovbasa.driver.ChromeDriverFactory;
 import ru.kovbasa.driver.DriverFactory;
-import ru.kovbasa.driver.SelectableDriverFactory;
+import ru.kovbasa.driver.MobileChromeDriverFactory;
+import ru.kovbasa.driver.RemoteDriverFactory;
 import ru.kovbasa.driver.WebDriverProvider;
 
 public class DriverModule extends AbstractModule {
 
     @Override
     protected void configure() {
-        bind(DriverFactory.class).to(SelectableDriverFactory.class).in(Singleton.class);
         bind(WebDriverProvider.class).in(Singleton.class);
     }
+
+    @Provides
+    @Singleton
+    public DriverFactory provideDriverFactory() {
+        if (TestConfig.isSelenoidMode()) {
+            if (TestConfig.isMobileBrowser()) {
+                return new MobileChromeDriverFactory();
+            }
+            return new RemoteDriverFactory();
+        }
+        return new ChromeDriverFactory();
+    }
 }

src/main/java/ru/kovbasa/config/TestConfig.java

@@ -2,18 +2,61 @@ package ru.kovbasa.config;
 
 public final class TestConfig {
 
+    private static final String BASE_URL =
+            System.getProperty("base.url", "https://otus.ru");
+
+    private static final String COURSE_NAME =
+            System.getProperty("course.name", "Python Developer");
+
+    private static final String EXECUTION_MODE =
+            System.getProperty("execution.mode", "local");
+
+    private static final String BROWSER =
+            System.getProperty("browser", "chrome");
+
+    private static final String BROWSER_VERSION =
+            System.getProperty("browser.version", "");
+
+    private static final String SELENOID_URL =
+            System.getProperty("selenoid.url", "http://localhost/wd/hub");
+
+
     private TestConfig() {
     }
 
     public static String getBaseUrl() {
-        return System.getProperty("base.url", "https://otus.ru");
+        return BASE_URL;
     }
 
     public static String getCourseName() {
-        return System.getProperty("course.name", "Python Developer");
+        return COURSE_NAME;
+    }
+
+    public static String getExecutionMode() {
+        return EXECUTION_MODE;
     }
 
     public static String getBrowser() {
-        return System.getProperty("browser", "chrome");
+        return BROWSER;
+    }
+
+    public static String getSelenoidUrl() {
+        return SELENOID_URL;
+    }
+
+    public static String getBrowserVersion() {
+        return BROWSER_VERSION;
+    }
+
+    public static boolean isSelenoidMode() {
+        return "selenoid".equalsIgnoreCase(EXECUTION_MODE);
+    }
+
+    public static boolean isMobileBrowser() {
+        return "mobile_chrome".equalsIgnoreCase(BROWSER);
+    }
+
+    public static boolean isFirefoxBrowser() {
+        return "firefox".equalsIgnoreCase(BROWSER);
     }
 }

src/main/java/ru/kovbasa/driver/MobileChromeDriverFactory.java

@@ -0,0 +1,20 @@
+package ru.kovbasa.driver;
+
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.chrome.ChromeOptions;
+
+import java.util.Map;
+
+public class MobileChromeDriverFactory extends RemoteDriverFactory {
+
+    @Override
+    public WebDriver createDriver() {
+        final ChromeOptions options = new ChromeOptions();
+        options.setCapability("browserName", "chrome");
+        applyCommonCapabilities(options);
+        options.setCapability("goog:chromeOptions", Map.of(
+                "mobileEmulation", Map.of("deviceName", "Pixel 7")
+        ));
+        return createRemote(options);
+    }
+}

src/main/java/ru/kovbasa/driver/RemoteDriverFactory.java

@@ -0,0 +1,60 @@
+package ru.kovbasa.driver;
+
+import org.openqa.selenium.MutableCapabilities;
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.chrome.ChromeOptions;
+import org.openqa.selenium.firefox.FirefoxOptions;
+import org.openqa.selenium.remote.RemoteWebDriver;
+import ru.kovbasa.config.TestConfig;
+
+import java.net.MalformedURLException;
+import java.net.URI;
+import java.util.List;
+import java.util.Map;
+
+public class RemoteDriverFactory implements DriverFactory {
+
+    @Override
+    public WebDriver createDriver() {
+        final MutableCapabilities options = TestConfig.isFirefoxBrowser()
+                ? buildFirefoxOptions()
+                : buildChromeOptions();
+        return createRemote(options);
+    }
+
+    protected MutableCapabilities buildChromeOptions() {
+        final ChromeOptions options = new ChromeOptions();
+        options.addArguments("--disable-notifications");
+        applyCommonCapabilities(options);
+        return options;
+    }
+
+    protected MutableCapabilities buildFirefoxOptions() {
+        final FirefoxOptions options = new FirefoxOptions();
+        applyCommonCapabilities(options);
+        return options;
+    }
+
+    protected void applyCommonCapabilities(MutableCapabilities options) {
+        final String browserVersion = TestConfig.getBrowserVersion();
+        if (!browserVersion.isBlank()) {
+            options.setCapability("browserVersion", browserVersion);
+        }
+        options.setCapability("selenoid:options", Map.of(
+                "name", "otus-ui-tests",
+                "sessionTimeout", "15m",
+                "env", List.of("TZ=UTC"),
+                "labels", Map.of("manual", "true"),
+                "enableVNC", true,
+                "enableVideo", false
+        ));
+    }
+
+    protected WebDriver createRemote(MutableCapabilities capabilities) {
+        try {
+            return new RemoteWebDriver(URI.create(TestConfig.getSelenoidUrl()).toURL(), capabilities);
+        } catch (MalformedURLException e) {
+            throw new IllegalStateException("Invalid selenoid.url: " + TestConfig.getSelenoidUrl(), e);
+        }
+    }
+}

src/main/java/ru/kovbasa/driver/SelectableDriverFactory.java

@@ -1,19 +0,0 @@
-package ru.kovbasa.driver;
-
-import org.openqa.selenium.WebDriver;
-import ru.kovbasa.config.TestConfig;
-
-public class SelectableDriverFactory implements DriverFactory {
-
-    private final DriverFactory chromeFactory = new ChromeDriverFactory();
-
-    @Override
-    public WebDriver createDriver() {
-        final String browser = TestConfig.getBrowser().toLowerCase();
-        if (!"chrome".equals(browser)) {
-            throw new IllegalArgumentException(
-                    "Unsupported browser: " + browser + ". Supported browser: chrome");
-        }
-        return chromeFactory.createDriver();
-    }
-}

src/main/java/ru/kovbasa/driver/WebDriverProvider.java

@@ -3,6 +3,9 @@ package ru.kovbasa.driver;
 import com.google.inject.Inject;
 import org.openqa.selenium.WebDriver;
 import org.openqa.selenium.support.events.EventFiringDecorator;
+
+import io.github.bonigarcia.wdm.WebDriverManager;
+import ru.kovbasa.config.TestConfig;
 import ru.kovbasa.listeners.HighlightElementListener;
 
 public final class WebDriverProvider {
@@ -23,6 +26,9 @@ public final class WebDriverProvider {
     }
 
     private WebDriver createDecoratedDriver() {
+        if (!TestConfig.isSelenoidMode()) {
+            WebDriverManager.chromedriver().setup();
+        }
         final WebDriver raw = driverFactory.createDriver();
         return new EventFiringDecorator(new HighlightElementListener())
                 .decorate(raw);

src/main/java/ru/kovbasa/elements/CourseCard.java

@@ -7,14 +7,11 @@ import java.time.LocalDate;
 import java.time.Year;
 import java.time.format.DateTimeFormatter;
 import java.util.Locale;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 
 public class CourseCard extends BaseElement {
 
     private final By titleLocator = By.cssSelector("h6 .sc-hrqzy3-1");
     private final By dateLocator = By.cssSelector(".sc-157icee-1 .sc-hrqzy3-1");
-    private static final Pattern PRICE_PATTERN = Pattern.compile("(\\d[\\d\\s]*)\\s*[₽р]");
 
     public CourseCard(WebElement element) {
         super(element);
@@ -54,24 +51,4 @@ public class CourseCard extends BaseElement {
 
         return LocalDate.parse(normalized, formatter);
     }
-
-    public int price() {
-        final String text = element.getText();
-        final Matcher matcher = PRICE_PATTERN.matcher(text);
-
-        int maxPrice = -1;
-        while (matcher.find()) {
-            final String raw = matcher.group(1).replace(" ", "");
-            final int parsed = Integer.parseInt(raw);
-            if (parsed > maxPrice) {
-                maxPrice = parsed;
-            }
-        }
-
-        if (maxPrice < 0) {
-            throw new RuntimeException("Цена курса не найдена в карточке: " + title());
-        }
-
-        return maxPrice;
-    }
 }

src/main/java/ru/kovbasa/listeners/HighlightElementListener.java

@@ -1,7 +1,5 @@
 package ru.kovbasa.listeners;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 import org.openqa.selenium.JavascriptExecutor;
 import org.openqa.selenium.StaleElementReferenceException;
 import org.openqa.selenium.WebDriver;
@@ -10,7 +8,6 @@ import org.openqa.selenium.WrapsDriver;
 import org.openqa.selenium.support.events.WebDriverListener;
 
 public class HighlightElementListener implements WebDriverListener {
-    private static final Logger LOG = LoggerFactory.getLogger(HighlightElementListener.class);
 
     private static final String HIGHLIGHT_STYLE =
             "outline: 4px solid red !important; " +
@@ -23,11 +20,16 @@ public class HighlightElementListener implements WebDriverListener {
     public void beforeClick(WebElement element) {
         try {
             clearHighlight();
+
+            final String tag = safeGetTag(element);
+            final String href = safeGetAttr(element, "href");
+            final String cls = safeGetAttr(element, "class");
+            System.out.println("beforeClick: tag=" + tag + " href=" + href + " class=" + cls);
+
             final WebElement tile = findTileContainer(element);
             applyHighlight(tile);
-            pauseForVisibility();
+        } catch (Exception e) {
-        } catch (RuntimeException e) {
+            System.out.println("Highlight listener error: " + e.getMessage());
-            LOG.debug("beforeClick highlight skipped", e);
         }
     }
 
@@ -60,8 +62,8 @@ public class HighlightElementListener implements WebDriverListener {
             js.executeScript("arguments[0].setAttribute('style', arguments[1] + '; ' + arguments[2]);",
                     element, original, HIGHLIGHT_STYLE);
         } catch (StaleElementReferenceException ignored) {
-        } catch (RuntimeException e) {
+        } catch (Exception e) {
-            LOG.debug("applyHighlight skipped", e);
+            System.out.println("applyHighlight error: " + e.getMessage());
         }
     }
 
@@ -82,8 +84,8 @@ public class HighlightElementListener implements WebDriverListener {
             final String original = highlightedOriginalStyle == null ? "" : highlightedOriginalStyle;
             js.executeScript("arguments[0].setAttribute('style', arguments[1]);", highlightedElement, original);
         } catch (StaleElementReferenceException ignored) {
-        } catch (RuntimeException e) {
+        } catch (Exception e) {
-            LOG.debug("clearHighlight skipped", e);
+            System.out.println("clearHighlight error: " + e.getMessage());
         } finally {
             highlightedElement = null;
             highlightedOriginalStyle = null;
@@ -132,8 +134,7 @@ public class HighlightElementListener implements WebDriverListener {
                     return current;
                 }
             }
-        } catch (RuntimeException e) {
+        } catch (Exception ignored) {
-            LOG.debug("findTileContainer fallback to original element", e);
         }
         return element;
     }
@@ -147,12 +148,4 @@ public class HighlightElementListener implements WebDriverListener {
         try { return el.getTagName(); }
         catch (Exception e) { return null; }
     }
-
-    private void pauseForVisibility() {
-        try {
-            Thread.sleep(120);
-        } catch (InterruptedException e) {
-            Thread.currentThread().interrupt();
-        }
-    }
 }

src/main/java/ru/kovbasa/pages/CatalogPage.java

@@ -5,15 +5,12 @@ import java.time.Duration;
 import java.time.LocalDate;
 import java.util.ArrayList;
 import java.util.Comparator;
-import java.util.LinkedHashMap;
 import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.concurrent.ThreadLocalRandom;
 
 import org.openqa.selenium.By;
 import org.openqa.selenium.JavascriptExecutor;
 import org.openqa.selenium.NoSuchElementException;
+import org.openqa.selenium.StaleElementReferenceException;
 import org.openqa.selenium.WebDriver;
 import org.openqa.selenium.WebElement;
 import org.openqa.selenium.interactions.Actions;
@@ -30,11 +27,7 @@ public class CatalogPage {
     private final WebDriver driver;
 
     private final By courseCards = By.cssSelector("a.sc-zzdkm7-0");
-    private final By courseLinks = By.cssSelector("a[href*='/lessons/'], a[href*='/online/']");
+    private final By courseLinks = By.cssSelector("a[href*='/lessons/']");
-    private final By learningMenu = By.cssSelector("span[title='Обучение']");
-    private final By prepCoursesLink = By.xpath(
-            "//a[contains(normalize-space(),'Подготовительные курсы')]");
-    private final By showMoreButton = By.xpath("//button[contains(normalize-space(),'Показать еще')]");
 
     @Inject
     public CatalogPage(WebDriverProvider provider) {
@@ -43,6 +36,8 @@ public class CatalogPage {
 
     public CatalogPage open() {
         driver.get(TestConfig.getBaseUrl() + "/catalog/courses");
+        final WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(20));
+        wait.until((ExpectedCondition<Boolean>) drv -> !drv.findElements(courseCards).isEmpty());
         return this;
     }
 
@@ -58,15 +53,6 @@ public class CatalogPage {
                         "Course not found in catalog by name: " + name));
     }
 
-    public List<WebElement> findCoursesByName(String name) {
-        final WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(15));
-        wait.until((ExpectedCondition<Boolean>) drv -> !drv.findElements(courseLinks).isEmpty());
-
-        return driver.findElements(courseLinks).stream()
-                .filter(e -> e.getText().toLowerCase().contains(name.toLowerCase()))
-                .toList();
-    }
-
     public CoursePage clickCourseByName(String name) {
         PageUtils.removeBottomBanner(driver);
 
@@ -83,44 +69,39 @@ public class CatalogPage {
         return new CoursePage(driver);
     }
 
-    public CoursePage clickRandomCourseByName(String name) {
-        PageUtils.removeBottomBanner(driver);
-
-        final List<WebElement> courses = findCoursesByName(name);
-        if (courses.isEmpty()) {
-            throw new NoSuchElementException("Course not found in catalog by name: " + name);
-        }
-
-        final WebElement chosen = courses.get(ThreadLocalRandom.current().nextInt(courses.size()));
-
-        ((JavascriptExecutor) driver)
-                .executeScript("arguments[0].scrollIntoView({block:'center'});", chosen);
-
-        new Actions(driver)
-                .moveToElement(chosen)
-                .perform();
-        chosen.click();
-
-        return new CoursePage(driver);
-    }
-
     public List<CourseCard> getAllCourseCards() {
+        final WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(20));
+        wait.until((ExpectedCondition<Boolean>) drv -> !drv.findElements(courseCards).isEmpty());
         return driver.findElements(courseCards).stream()
                 .map(CourseCard::new)
                 .toList();
     }
 
     public List<CourseItem> getAllCourses() {
-        return getAllCourseCards().stream()
+        final WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(20));
-                .map(card -> {
+        wait.until((ExpectedCondition<Boolean>) drv -> !drv.findElements(courseCards).isEmpty());
-                    try {
+
-                        return new CourseItem(card.title(), card.startDate());
+        for (int attempt = 1; attempt <= 3; attempt++) {
-                    } catch (RuntimeException e) {
+            try {
-                        return null;
+                final List<CourseItem> parsedCourses = new ArrayList<>();
+                for (WebElement cardElement : driver.findElements(courseCards)) {
+                    final CourseItem item = toCourseItem(new CourseCard(cardElement));
+                    if (item != null) {
+                        parsedCourses.add(item);
                     }
-                })
+                }
-                .filter(Objects::nonNull)
+
-                .toList();
+                if (!parsedCourses.isEmpty()) {
+                    return parsedCourses;
+                }
+            } catch (StaleElementReferenceException ignored) {
+                // Dynamic catalog can re-render the card list; retry with fresh references.
+            }
+        }
+
+        throw new IllegalStateException(
+                "No parsable courses found in catalog after retries. Check course card/date locators."
+        );
     }
 
     public List<CourseItem> findEarliestCourses() {
@@ -128,8 +109,9 @@ public class CatalogPage {
 
         final LocalDate minDate = all.stream()
                 .map(CourseItem::startDate)
-                .reduce((left, right) -> left.isBefore(right) ? left : right)
+                .min(LocalDate::compareTo)
-                .orElseThrow();
+                .orElseThrow(() -> new IllegalStateException(
+                        "Unable to determine earliest date from parsed courses"));
 
         return all.stream()
                 .filter(c -> c.startDate().isEqual(minDate))
@@ -142,8 +124,9 @@ public class CatalogPage {
 
         final LocalDate maxDate = all.stream()
                 .map(CourseItem::startDate)
-                .reduce((left, right) -> left.isAfter(right) ? left : right)
+                .max(LocalDate::compareTo)
-                .orElseThrow();
+                .orElseThrow(() -> new IllegalStateException(
+                        "Unable to determine latest date from parsed courses"));
 
         return all.stream()
                 .filter(c -> c.startDate().isEqual(maxDate))
@@ -151,205 +134,48 @@ public class CatalogPage {
                 .toList();
     }
 
-    public List<CourseItem> findCoursesStartingFrom(LocalDate dateFrom) {
-        return getAllCourses().stream()
-                .filter(course -> !course.startDate().isBefore(dateFrom))
-                .sorted(Comparator.comparing(CourseItem::startDate).thenComparing(CourseItem::title))
-                .toList();
-    }
-
-    public CatalogPage openPreparatoryCourses() {
-        driver.get(TestConfig.getBaseUrl());
-        PageUtils.removeBottomBanner(driver);
-
-        final WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(15));
-        final WebElement menu = wait.until(drv -> drv.findElement(learningMenu));
-        menu.click();
-
-        final WebElement prep = wait.until(drv -> drv.findElements(prepCoursesLink).stream()
-                .filter(WebElement::isDisplayed)
-                .findFirst()
-                .orElse(null));
-
-        ((JavascriptExecutor) driver)
-                .executeScript("arguments[0].scrollIntoView({block:'center'});", prep);
-        prep.click();
-
-        wait.until(drv -> drv.findElements(
-                By.xpath("//*[contains(normalize-space(),'Подготовительные курсы')]")
-        ).stream().anyMatch(WebElement::isDisplayed));
-
-        expandAllCourses();
-        return this;
-    }
-
-    public List<PricedCourseItem> getAllCoursesWithPrice() {
-        return getAllCourseCards().stream()
-                .map(card -> {
-                    try {
-                        return new PricedCourseItem(card.title(), card.price());
-                    } catch (RuntimeException e) {
-                        return null;
-                    }
-                })
-                .filter(Objects::nonNull)
-                .toList();
-    }
-
-    public List<CourseLinkItem> getPreparatoryCourseLinks() {
-        final WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(15));
-        wait.until((ExpectedCondition<Boolean>) drv -> !drv.findElements(courseLinks).isEmpty());
-
-        final Map<String, String> titleByUrl = new LinkedHashMap<>();
-        for (WebElement link : driver.findElements(courseLinks)) {
-            if (!link.isDisplayed()) {
-                continue;
-            }
-            final String title = link.getText().trim();
-            final String url = link.getAttribute("href");
-            if (title.isEmpty() || url == null || !isCourseUrl(url)) {
-                continue;
-            }
-            titleByUrl.putIfAbsent(url, title);
-        }
-
-        final List<Map.Entry<String, String>> onlineEntries = titleByUrl.entrySet().stream()
-                .filter(entry -> entry.getKey().contains("/online/"))
-                .toList();
-
-        final List<CourseLinkItem> items = new ArrayList<>();
-        if (!onlineEntries.isEmpty()) {
-            onlineEntries.forEach(entry -> items.add(new CourseLinkItem(cleanTitle(entry.getValue()), entry.getKey())));
-            return items;
-        }
-
-        titleByUrl.forEach((url, title) -> items.add(new CourseLinkItem(cleanTitle(title), url)));
-        return items;
-    }
-
-    public List<PricedCourseItem> getPreparatoryCoursesWithDiscountedFullPrice() {
-        final List<CourseLinkItem> links = getPreparatoryCourseLinks();
-        return links.stream()
-                .map(link -> {
-                    driver.get(link.url());
-                    final CoursePage coursePage = new CoursePage(driver);
-                    final int price = coursePage.getPriceForComparison();
-                    String title = link.title();
-                    try {
-                        title = coursePage.getCourseTitle();
-                    } catch (RuntimeException ignored) { }
-                    return new PricedCourseItem(title, price);
-                })
-                .toList();
-    }
-
-    public List<CourseLinkItem> getCatalogLessonCourseLinks() {
-        open();
-
-        final WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(15));
-        wait.until((ExpectedCondition<Boolean>) drv -> !drv.findElements(courseLinks).isEmpty());
-
-        final Map<String, String> titleByUrl = new LinkedHashMap<>();
-        for (WebElement link : driver.findElements(courseLinks)) {
-            if (!link.isDisplayed()) {
-                continue;
-            }
-            final String title = link.getText().trim();
-            final String url = link.getAttribute("href");
-            if (title.isEmpty() || url == null || !url.contains("/lessons/")) {
-                continue;
-            }
-            titleByUrl.putIfAbsent(url, cleanTitle(title));
-        }
-
-        final List<CourseLinkItem> items = new ArrayList<>();
-        titleByUrl.forEach((url, title) -> items.add(new CourseLinkItem(title, url)));
-        return items;
-    }
-
-    public List<PricedCourseItem> getCatalogCoursesWithDiscountedFullPrice() {
-        final List<CourseLinkItem> links = getCatalogLessonCourseLinks();
-        return links.stream()
-                .map(link -> {
-                    driver.get(link.url());
-                    final CoursePage coursePage = new CoursePage(driver);
-                    final int price = coursePage.getPriceForComparison();
-                    String title = link.title();
-                    try {
-                        title = coursePage.getCourseTitle();
-                    } catch (RuntimeException ignored) { }
-                    return new PricedCourseItem(title, price);
-                })
-                .toList();
-    }
-
-    private void expandAllCourses() {
-        final WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(5));
-
-        while (true) {
-            try {
-                final WebElement button = wait.until(drv -> drv.findElements(showMoreButton).stream()
-                        .filter(WebElement::isDisplayed)
-                        .findFirst()
-                        .orElse(null));
-
-                ((JavascriptExecutor) driver)
-                        .executeScript("arguments[0].scrollIntoView({block:'center'});", button);
-                button.click();
-                wait.until(drv -> !drv.findElements(courseLinks).isEmpty());
-            } catch (RuntimeException ignored) {
-                break;
-            }
-        }
-    }
-
-    private boolean isCourseUrl(String url) {
-        return url.contains("/lessons/") || url.contains("/online/");
-    }
-
-    private String cleanTitle(String rawTitle) {
-        final String[] lines = rawTitle.split("\\R");
-        for (int i = lines.length - 1; i >= 0; i--) {
-            final String line = lines[i].trim();
-            if (!line.isEmpty()) {
-                return line;
-            }
-        }
-        return rawTitle.trim();
-    }
-
-    public PricedCourseItem findMostExpensiveCourse() {
-        return getAllCoursesWithPrice().stream()
-                .reduce((left, right) -> left.price() >= right.price() ? left : right)
-                .orElseThrow(() -> new NoSuchElementException("Priced course cards are not found"));
-    }
-
-    public PricedCourseItem findCheapestCourse() {
-        return getAllCoursesWithPrice().stream()
-                .reduce((left, right) -> left.price() <= right.price() ? left : right)
-                .orElseThrow(() -> new NoSuchElementException("Priced course cards are not found"));
-    }
-
     public CoursePage openCourse(CourseItem course) {
         PageUtils.removeBottomBanner(driver);
 
-        final WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
+        final WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(12));
+        wait.until((ExpectedCondition<Boolean>) drv -> !drv.findElements(courseCards).isEmpty());
 
-        final WebElement card = wait.until(drv ->
+        for (int attempt = 1; attempt <= 5; attempt++) {
-                drv.findElements(courseCards).stream()
+            try {
-                        .filter(c -> new CourseCard(c).title().equals(course.title()))
+                for (WebElement card : driver.findElements(courseCards)) {
-                        .findFirst()
+                    final CourseCard courseCard = new CourseCard(card);
-                        .orElse(null)
+                    final String candidateTitle;
-        );
+                    final LocalDate candidateDate;
+                    try {
+                        candidateTitle = courseCard.title();
+                        candidateDate = courseCard.startDate();
+                    } catch (RuntimeException ignored) {
+                        continue;
+                    }
+                    if (!candidateTitle.equals(course.title()) || !candidateDate.equals(course.startDate())) {
+                        continue;
+                    }
 
-        ((JavascriptExecutor) driver)
+                    ((JavascriptExecutor) driver)
-                .executeScript("arguments[0].scrollIntoView({block:'center'});", card);
+                            .executeScript("arguments[0].scrollIntoView({block:'center'});", card);
 
-        new Actions(driver)
+                    new Actions(driver).moveToElement(card).perform();
-                .moveToElement(card)
+                    card.click();
-                .perform();
+                    return new CoursePage(driver);
-        card.click();
+                }
+            } catch (StaleElementReferenceException ignored) {
+                // Re-query cards when DOM updates during search/click.
+            }
+        }
 
-        return new CoursePage(driver);
+        throw new NoSuchElementException("Course card not found for title: " + course.title());
+    }
+
+    private CourseItem toCourseItem(CourseCard card) {
+        try {
+            return new CourseItem(card.title(), card.startDate());
+        } catch (RuntimeException e) {
+            return null;
+        }
     }
 }

src/main/java/ru/kovbasa/pages/CourseLinkItem.java

@@ -1,4 +0,0 @@
-package ru.kovbasa.pages;
-
-public record CourseLinkItem(String title, String url) {
-}

src/main/java/ru/kovbasa/pages/CoursePage.java

@@ -4,31 +4,18 @@ import org.jsoup.Jsoup;
 import org.jsoup.nodes.Document;
 import org.jsoup.nodes.Element;
 import org.openqa.selenium.By;
-import org.openqa.selenium.JavascriptExecutor;
-import org.openqa.selenium.NoSuchElementException;
 import org.openqa.selenium.WebDriver;
-import org.openqa.selenium.WebElement;
-import org.openqa.selenium.interactions.Actions;
-import org.openqa.selenium.support.ui.WebDriverWait;
 import ru.kovbasa.elements.Button;
-import ru.kovbasa.utils.PageUtils;
 
 import java.time.LocalDate;
 import java.time.format.DateTimeFormatter;
 import java.util.Locale;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 
 public class CoursePage {
-    private static final Pattern PRICE_PATTERN = Pattern.compile("(\\d[\\d\\s\\u00A0]*)\\s*₽");
-
 
     private final WebDriver driver;
 
     private final By enrollButton = By.cssSelector("button[data-testid='enroll-button']");
-    private final By fullPriceTab = By.xpath("//div[normalize-space()='Полная']/parent::div");
-    private final By fullDiscountLabel = By.xpath("//p[contains(normalize-space(),'Полная стоимость со скидкой')]");
-    private final By anyPriceText = By.xpath("//*[contains(normalize-space(),'₽')]");
 
     public CoursePage(WebDriver driver) {
         this.driver = driver;
@@ -72,68 +59,4 @@ public class CoursePage {
     public void clickEnroll() {
         getEnrollButton().click();
     }
-
-    public int getDiscountedFullPrice() {
-        PageUtils.removeBottomBanner(driver);
-
-        final WebDriverWait wait = new WebDriverWait(driver, java.time.Duration.ofSeconds(10));
-        final WebElement tab = wait.until(drv -> drv.findElements(fullPriceTab).stream()
-                .filter(WebElement::isDisplayed)
-                .findFirst()
-                .orElse(null));
-
-        ((JavascriptExecutor) driver).executeScript("arguments[0].scrollIntoView({block:'center'});", tab);
-        try {
-            tab.click();
-        } catch (RuntimeException ignored) {
-            new Actions(driver).moveToElement(tab).click().perform();
-        }
-
-        final WebElement label = wait.until(drv -> drv.findElements(fullDiscountLabel).stream()
-                .filter(WebElement::isDisplayed)
-                .findFirst()
-                .orElse(null));
-
-        final WebElement priceElement = findPriceElementNearLabel(label);
-        final String rawPrice = priceElement.getText();
-        return parsePrice(rawPrice);
-    }
-
-    public int getPriceForComparison() {
-        if (hasDisplayed(fullPriceTab)) {
-            try {
-                return getDiscountedFullPrice();
-            } catch (RuntimeException ignored) { }
-        }
-
-        final WebDriverWait wait = new WebDriverWait(driver, java.time.Duration.ofSeconds(10));
-        final WebElement priceElement = wait.until(drv -> drv.findElements(anyPriceText).stream()
-                .filter(WebElement::isDisplayed)
-                .filter(el -> PRICE_PATTERN.matcher(el.getText()).find())
-                .findFirst()
-                .orElse(null));
-
-        return parsePrice(priceElement.getText());
-    }
-
-    private WebElement findPriceElementNearLabel(WebElement label) {
-        try {
-            return label.findElement(By.xpath("following-sibling::div[1]"));
-        } catch (NoSuchElementException ignored) {
-            return label.findElement(By.xpath("following::div[contains(normalize-space(),'₽')][1]"));
-        }
-    }
-
-    private int parsePrice(String rawPrice) {
-        final Matcher matcher = PRICE_PATTERN.matcher(rawPrice);
-        if (!matcher.find()) {
-            throw new IllegalArgumentException("Не удалось распарсить цену из строки: " + rawPrice);
-        }
-        final String normalized = matcher.group(1).replace('\u00A0', ' ').replace(" ", "");
-        return Integer.parseInt(normalized);
-    }
-
-    private boolean hasDisplayed(By by) {
-        return driver.findElements(by).stream().anyMatch(WebElement::isDisplayed);
-    }
 }

src/main/java/ru/kovbasa/pages/MainPage.java

@@ -4,6 +4,7 @@ import com.google.inject.Inject;
 import org.openqa.selenium.By;
 import org.openqa.selenium.ElementClickInterceptedException;
 import org.openqa.selenium.JavascriptExecutor;
+import org.openqa.selenium.NoSuchElementException;
 import org.openqa.selenium.WebDriver;
 import org.openqa.selenium.WebElement;
 import org.openqa.selenium.interactions.Actions;
@@ -20,7 +21,8 @@ public class MainPage {
 
     private final WebDriver driver;
 
-    private final By menuLearning = By.cssSelector("span[title='Обучение']");
+    private final By menuLearningByTitle = By.cssSelector("span[title='Обучение']");
+    private final By menuLearningByText = By.xpath("//span[normalize-space()='Обучение']");
     private final By categories = By.cssSelector("a[href*='/categories/']");
 
     @Inject
@@ -36,20 +38,22 @@ public class MainPage {
     public String clickRandomCategory() {
         PageUtils.removeBottomBanner(driver);
 
-        final WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
+        final WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(20));
 
-        final WebElement menu = wait.until(drv -> drv.findElement(menuLearning));
+        List<WebElement> els = findVisibleCategories(wait);
-        menu.click();
+        if (els.isEmpty()) {
-
+            clickLearningMenu(wait);
-        final List<WebElement> els = wait.until(drv -> {
+            els = wait.until(drv -> {
-            final List<WebElement> found = drv.findElements(categories).stream()
+                final List<WebElement> found = drv.findElements(categories).stream()
-                    .filter(WebElement::isDisplayed)
+                        .filter(WebElement::isDisplayed)
-                    .toList();
+                        .toList();
-            return found.isEmpty() ? null : found;
+                return found.isEmpty() ? null : found;
-        });
+            });
+        }
 
         final WebElement chosen = els.get(ThreadLocalRandom.current().nextInt(els.size()));
         final String href = chosen.getAttribute("href");
+        System.out.println("Selected category href = " + href);
 
         ((JavascriptExecutor) driver)
                 .executeScript("arguments[0].scrollIntoView({block:'center'});", chosen);
@@ -67,4 +71,29 @@ public class MainPage {
 
         return href;
     }
+
+    private List<WebElement> findVisibleCategories(WebDriverWait wait) {
+        return wait.until(drv -> drv.findElements(categories).stream()
+                .filter(WebElement::isDisplayed)
+                .toList());
+    }
+
+    private void clickLearningMenu(WebDriverWait wait) {
+        WebElement menu = null;
+        try {
+            menu = wait.until(drv -> drv.findElement(menuLearningByTitle));
+        } catch (NoSuchElementException ignored) {
+        } catch (org.openqa.selenium.TimeoutException ignored) {
+        }
+
+        if (menu == null) {
+            menu = wait.until(drv -> drv.findElement(menuLearningByText));
+        }
+
+        try {
+            menu.click();
+        } catch (ElementClickInterceptedException ignored) {
+            ((JavascriptExecutor) driver).executeScript("arguments[0].click();", menu);
+        }
+    }
 }

src/main/java/ru/kovbasa/pages/PricedCourseItem.java

@@ -1,4 +0,0 @@
-package ru.kovbasa.pages;
-
-public record PricedCourseItem(String title, int price) {
-}

src/test/java/ru/kovbasa/bdd/CucumberTest.java

@@ -1,17 +0,0 @@
-package ru.kovbasa.bdd;
-
-import org.junit.platform.suite.api.ConfigurationParameter;
-import org.junit.platform.suite.api.IncludeEngines;
-import org.junit.platform.suite.api.SelectClasspathResource;
-import org.junit.platform.suite.api.Suite;
-
-import static io.cucumber.junit.platform.engine.Constants.GLUE_PROPERTY_NAME;
-import static io.cucumber.junit.platform.engine.Constants.PLUGIN_PROPERTY_NAME;
-
-@Suite
-@IncludeEngines("cucumber")
-@SelectClasspathResource("features")
-@ConfigurationParameter(key = GLUE_PROPERTY_NAME, value = "ru.kovbasa.bdd")
-@ConfigurationParameter(key = PLUGIN_PROPERTY_NAME, value = "pretty")
-public class CucumberTest {
-}

src/test/java/ru/kovbasa/bdd/hooks/Hooks.java

@@ -1,15 +0,0 @@
-package ru.kovbasa.bdd.hooks;
-
-import com.google.inject.Injector;
-import io.cucumber.java.After;
-import ru.kovbasa.config.InjectorProvider;
-import ru.kovbasa.driver.WebDriverProvider;
-
-public class Hooks {
-
-    @After
-    public void afterScenario() {
-        final Injector injector = InjectorProvider.getInjector();
-        injector.getInstance(WebDriverProvider.class).quit();
-    }
-}

src/test/java/ru/kovbasa/bdd/steps/CatalogSteps.java

@@ -1,159 +0,0 @@
-package ru.kovbasa.bdd.steps;
-
-import com.google.inject.Injector;
-import io.cucumber.java.ru.Дано;
-import io.cucumber.java.ru.И;
-import io.cucumber.java.ru.Когда;
-import io.cucumber.java.ru.Тогда;
-import org.junit.jupiter.api.Assertions;
-import ru.kovbasa.config.InjectorProvider;
-import ru.kovbasa.pages.CatalogPage;
-import ru.kovbasa.pages.CourseItem;
-import ru.kovbasa.pages.CoursePage;
-import ru.kovbasa.pages.PricedCourseItem;
-
-import java.time.LocalDate;
-import java.time.format.DateTimeFormatter;
-import java.util.List;
-import java.util.Locale;
-
-public class CatalogSteps {
-
-    private static final DateTimeFormatter DATE_FORMATTER =
-            DateTimeFormatter.ofPattern("dd.MM.yyyy", Locale.forLanguageTag("ru"));
-
-    private CoursePage openedCoursePage;
-    private List<CourseItem> coursesStartingFromDate;
-    private LocalDate searchDate;
-    private PricedCourseItem mostExpensiveCourse;
-    private PricedCourseItem cheapestCourse;
-    private PricedCourseItem mostExpensiveCatalogCourse;
-    private PricedCourseItem cheapestCatalogCourse;
-
-    @Дано("Открыт браузер {word}")
-    public void openBrowser(String browser) {
-        System.setProperty("browser", browser.toLowerCase(Locale.ROOT));
-    }
-
-    @Когда("Открыт каталог курсов")
-    public void openCatalog() {
-        getCatalogPage().open();
-    }
-
-    @Когда("Найден курс {string} и выбран случайный из найденных")
-    public void findCourseAndOpenRandom(String courseName) {
-        openedCoursePage = getCatalogPage().clickRandomCourseByName(courseName);
-    }
-
-    @Тогда("Заголовок страницы курса содержит {string}")
-    public void coursePageTitleContains(String expectedCourseName) {
-        final String title = openedCoursePage.getCourseTitle();
-        Assertions.assertTrue(
-                title.toLowerCase(Locale.ROOT).contains(expectedCourseName.toLowerCase(Locale.ROOT)),
-                "Заголовок страницы курса должен содержать: " + expectedCourseName + ", фактически: " + title
-        );
-    }
-
-    @Когда("Найдены курсы со стартом {string} или позже")
-    public void findCoursesFromDate(String date) {
-        searchDate = LocalDate.parse(date, DATE_FORMATTER);
-        coursesStartingFromDate = getCatalogPage().findCoursesStartingFrom(searchDate);
-    }
-
-    @Тогда("В консоль выведены найденные курсы и даты старта")
-    public void printCoursesAndStartDates() {
-        Assertions.assertFalse(coursesStartingFromDate.isEmpty(), "Не найдено курсов по заданной дате");
-
-        coursesStartingFromDate.forEach(course -> System.out.println(
-                "Курс: " + course.title() + ", дата старта: " + course.startDate().format(DATE_FORMATTER)
-        ));
-
-        final boolean allAfterOrEqual = coursesStartingFromDate.stream()
-                .allMatch(course -> !course.startDate().isBefore(searchDate));
-
-        Assertions.assertTrue(
-                allAfterOrEqual,
-                "Среди найденных есть курсы с датой старта раньше " + searchDate.format(DATE_FORMATTER)
-        );
-    }
-
-    @Когда("Открыт раздел Обучение и Подготовительные курсы")
-    public void openPreparatoryCourses() {
-        getCatalogPage().openPreparatoryCourses();
-    }
-
-    @И("Выбраны самый дорогой и самый дешевый курсы с помощью filter")
-    public void findMostExpensiveAndCheapestByFilter() {
-        final List<PricedCourseItem> pricedCourses = getCatalogPage().getPreparatoryCoursesWithDiscountedFullPrice();
-        Assertions.assertFalse(pricedCourses.isEmpty(), "Не найдено курсов с ценой");
-
-        final int maxPrice = pricedCourses.stream().mapToInt(PricedCourseItem::price).max().orElseThrow();
-        final int minPrice = pricedCourses.stream().mapToInt(PricedCourseItem::price).min().orElseThrow();
-
-        mostExpensiveCourse = pricedCourses.stream()
-                .filter(course -> course.price() == maxPrice)
-                .findFirst()
-                .orElseThrow();
-
-        cheapestCourse = pricedCourses.stream()
-                .filter(course -> course.price() == minPrice)
-                .findFirst()
-                .orElseThrow();
-    }
-
-    @Тогда("В консоль выведена информация о самом дорогом и самом дешевом курсе")
-    public void printMostExpensiveAndCheapestCourse() {
-        System.out.println(
-                "Самый дорогой курс: " + mostExpensiveCourse.title() + ", цена: " + mostExpensiveCourse.price()
-        );
-        System.out.println(
-                "Самый дешевый курс: " + cheapestCourse.title() + ", цена: " + cheapestCourse.price()
-        );
-
-        Assertions.assertTrue(
-                mostExpensiveCourse.price() >= cheapestCourse.price(),
-                "Цена самого дорогого курса должна быть не меньше цены самого дешевого"
-        );
-    }
-
-    @Когда("В каталоге курсов выбраны самый дорогой и самый дешевый курсы по полной стоимости со скидкой с помощью filter")
-    public void findMostExpensiveAndCheapestInCatalogByFullDiscountedPrice() {
-        final List<PricedCourseItem> pricedCourses = getCatalogPage().getCatalogCoursesWithDiscountedFullPrice();
-        Assertions.assertFalse(pricedCourses.isEmpty(), "Не найдено курсов с ценой в общем каталоге");
-
-        final int maxPrice = pricedCourses.stream().mapToInt(PricedCourseItem::price).max().orElseThrow();
-        final int minPrice = pricedCourses.stream().mapToInt(PricedCourseItem::price).min().orElseThrow();
-
-        mostExpensiveCatalogCourse = pricedCourses.stream()
-                .filter(course -> course.price() == maxPrice)
-                .findFirst()
-                .orElseThrow();
-
-        cheapestCatalogCourse = pricedCourses.stream()
-                .filter(course -> course.price() == minPrice)
-                .findFirst()
-                .orElseThrow();
-    }
-
-    @Тогда("В консоль выведена информация о самом дорогом и самом дешевом курсе в каталоге")
-    public void printMostExpensiveAndCheapestCourseInCatalog() {
-        System.out.println(
-                "Самый дорогой курс в каталоге: "
-                        + mostExpensiveCatalogCourse.title() + ", цена: " + mostExpensiveCatalogCourse.price()
-        );
-        System.out.println(
-                "Самый дешевый курс в каталоге: "
-                        + cheapestCatalogCourse.title() + ", цена: " + cheapestCatalogCourse.price()
-        );
-
-        Assertions.assertTrue(
-                mostExpensiveCatalogCourse.price() >= cheapestCatalogCourse.price(),
-                "Цена самого дорогого курса в каталоге должна быть не меньше цены самого дешевого"
-        );
-    }
-
-    private CatalogPage getCatalogPage() {
-        final Injector injector = InjectorProvider.getInjector();
-        return injector.getInstance(CatalogPage.class);
-    }
-}

src/test/java/ru/kovbasa/config/GuiceExtension.java

@@ -0,0 +1,29 @@
+package ru.kovbasa.config;
+
+import com.google.inject.Injector;
+import org.junit.jupiter.api.extension.AfterEachCallback;
+import org.junit.jupiter.api.extension.BeforeEachCallback;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.api.extension.TestInstancePostProcessor;
+import ru.kovbasa.driver.WebDriverProvider;
+
+public class GuiceExtension implements TestInstancePostProcessor, BeforeEachCallback, AfterEachCallback {
+
+    @Override
+    public void postProcessTestInstance(Object testInstance, ExtensionContext context) {
+        final Injector injector = InjectorProvider.getInjector();
+        injector.injectMembers(testInstance);
+    }
+
+    @Override
+    public void beforeEach(ExtensionContext context) {
+        final Injector injector = InjectorProvider.getInjector();
+        injector.getInstance(WebDriverProvider.class).getDriver();
+    }
+
+    @Override
+    public void afterEach(ExtensionContext context) {
+        final Injector injector = InjectorProvider.getInjector();
+        injector.getInstance(WebDriverProvider.class).quit();
+    }
+}

src/test/java/ru/kovbasa/tests/CategoryRandomTest.java

@@ -0,0 +1,35 @@
+package ru.kovbasa.tests;
+
+import com.google.inject.Inject;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.Test;
+import ru.kovbasa.config.GuiceExtension;
+import ru.kovbasa.driver.WebDriverProvider;
+import ru.kovbasa.pages.MainPage;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@ExtendWith(GuiceExtension.class)
+public class CategoryRandomTest {
+
+    @Inject
+    private MainPage main;
+
+    @Inject
+    private WebDriverProvider webDriverProvider;
+
+    @Test
+    void randomCategoryOpensCorrectCatalog() {
+        main.open();
+
+        final String selectedHref = main.clickRandomCategory();
+        final String category = selectedHref.substring(selectedHref.lastIndexOf("/") + 1);
+        final String currentUrl = webDriverProvider.getDriver().getCurrentUrl();
+
+        assertTrue(
+                currentUrl.contains(category),
+                "Catalog URL should contain selected category. Selected: "
+                        + selectedHref + ", current: " + currentUrl
+        );
+    }
+}

src/test/java/ru/kovbasa/tests/CourseSearchTest.java

@@ -0,0 +1,33 @@
+package ru.kovbasa.tests;
+
+import com.google.inject.Inject;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.Test;
+import ru.kovbasa.config.GuiceExtension;
+import ru.kovbasa.config.TestConfig;
+import ru.kovbasa.pages.CatalogPage;
+import ru.kovbasa.pages.CoursePage;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@ExtendWith(GuiceExtension.class)
+public class CourseSearchTest {
+
+    @Inject
+    private CatalogPage catalog;
+
+    @Test
+    void findCourseByName() {
+        catalog.open();
+
+        final String courseName = TestConfig.getCourseName();
+
+        final CoursePage page = catalog.clickCourseByName(courseName);
+
+        final String title = page.getCourseTitle();
+        assertTrue(
+                title.toLowerCase().contains(courseName.toLowerCase()),
+                "Course page title should contain searched course name"
+        );
+    }
+}

src/test/java/ru/kovbasa/tests/CoursesDatesTest.java

@@ -0,0 +1,74 @@
+package ru.kovbasa.tests;
+
+import com.google.inject.Inject;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.Test;
+import ru.kovbasa.config.GuiceExtension;
+import ru.kovbasa.pages.CatalogPage;
+import ru.kovbasa.pages.CourseItem;
+import ru.kovbasa.pages.CoursePage;
+
+import java.time.LocalDate;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@ExtendWith(GuiceExtension.class)
+public class CoursesDatesTest {
+
+    @Inject
+    private CatalogPage catalog;
+
+    @Test
+    void earliestCourseHasCorrectTitleAndDate() {
+        catalog.open();
+
+        final List<CourseItem> earliestCourses = catalog.findEarliestCourses();
+
+        for (CourseItem course : earliestCourses) {
+            final CoursePage page = catalog.openCourse(course);
+
+            final String pageTitle = page.getCourseTitle();
+            assertTrue(
+                    pageTitle.toLowerCase().contains(course.title().toLowerCase()),
+                    "Earliest course title on page should contain title from catalog: " + course.title()
+            );
+
+            final LocalDate pageDate = page.getCourseStartDate(course.startDate());
+            assertEquals(
+                    course.startDate(),
+                    pageDate,
+                    "Earliest course start date should match for course: " + course.title()
+            );
+
+            catalog.open();
+        }
+    }
+
+    @Test
+    void latestCourseHasCorrectTitleAndDate() {
+        catalog.open();
+
+        final List<CourseItem> latestCourses = catalog.findLatestCourses();
+
+        for (CourseItem course : latestCourses) {
+            final CoursePage page = catalog.openCourse(course);
+
+            final String pageTitle = page.getCourseTitle();
+            assertTrue(
+                    pageTitle.toLowerCase().contains(course.title().toLowerCase()),
+                    "Latest course title on page should contain title from catalog: " + course.title()
+            );
+
+            final LocalDate pageDate = page.getCourseStartDate(course.startDate());
+            assertEquals(
+                    course.startDate(),
+                    pageDate,
+                    "Latest course start date should match for course: " + course.title()
+            );
+
+            catalog.open();
+        }
+    }
+}

src/test/resources/features/catalog.feature

@@ -1,29 +0,0 @@
-# language: ru
-
-Функция: Каталог курсов OTUS
-  Как пользователь
-  Я хочу работать с каталогом курсов через BDD
-  Чтобы проверять поиск, фильтрацию по датам и выбор по цене
-
-  Сценарий: Выбор браузера и поиск курса по названию со случайным выбором
-    Дано Открыт браузер Chrome
-    Когда Открыт каталог курсов
-    И Найден курс "Python" и выбран случайный из найденных
-    Тогда Заголовок страницы курса содержит "Python"
-
-  Сценарий: Поиск курсов, стартующих в указанную дату или позже
-    Дано Открыт браузер Chrome
-    Когда Открыт каталог курсов
-    И Найдены курсы со стартом "01.01.2025" или позже
-    Тогда В консоль выведены найденные курсы и даты старта
-
-  Сценарий: Поиск самого дорогого и самого дешевого подготовительного курса
-    Дано Открыт браузер Chrome
-    Когда Открыт раздел Обучение и Подготовительные курсы
-    И Выбраны самый дорогой и самый дешевый курсы с помощью filter
-    Тогда В консоль выведена информация о самом дорогом и самом дешевом курсе
-
-  Сценарий: Поиск самого дорогого и самого дешевого курса в каталоге по полной стоимости со скидкой
-    Дано Открыт браузер Chrome
-    Когда В каталоге курсов выбраны самый дорогой и самый дешевый курсы по полной стоимости со скидкой с помощью filter
-    Тогда В консоль выведена информация о самом дорогом и самом дешевом курсе в каталоге

src/test/resources/logback-test.xml

@@ -1,15 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<configuration>
-    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
-        <encoder>
-            <pattern>%d{HH:mm:ss} %-5level %logger{36} - %msg%n</pattern>
-        </encoder>
-    </appender>
-
-    <logger name="io.github.bonigarcia.wdm" level="WARN"/>
-    <logger name="org.openqa.selenium" level="WARN"/>
-
-    <root level="WARN">
-        <appender-ref ref="STDOUT"/>
-    </root>
-</configuration>

src/test/resources/logging.properties

@@ -1,8 +0,0 @@
-handlers= java.util.logging.ConsoleHandler
-.level= WARNING
-
-java.util.logging.ConsoleHandler.level = SEVERE
-java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter
-
-org.openqa.selenium.devtools.level = SEVERE
-org.openqa.selenium.devtools.CdpVersionFinder.level = SEVERE