Облачные Платформы Тестирования: Полное Руководство по BrowserStack, Sauce Labs, AWS Device Farm и Другим

// Пример Java с возможностями BrowserStack
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import java.net.URL;

public class BrowserStackTest {
    public static final String USERNAME = "ваш_логин";
    public static final String AUTOMATE_KEY = "ваш_ключ_доступа";
    public static final String URL = "https://" + USERNAME + ":" + AUTOMATE_KEY + "@hub-cloud.browserstack.com/wd/hub";

    public static void main(String[] args) throws Exception {
        DesiredCapabilities caps = new DesiredCapabilities();
        
        // Конфигурация браузера и ОС
        caps.setCapability("os", "Windows");
        caps.setCapability("os_version", "11");
        caps.setCapability("browser", "Chrome");
        caps.setCapability("browser_version", "latest");
        
        // Специфичные возможности BrowserStack
        caps.setCapability("name", "Тест Облачной Платформы");
        caps.setCapability("build", "browserstack-build-1");
        caps.setCapability("project", "Проект Облачного Тестирования");
        
        // Возможности отладки
        caps.setCapability("browserstack.debug", "true");
        caps.setCapability("browserstack.console", "verbose");
        caps.setCapability("browserstack.networkLogs", "true");
        
        // Локальное тестирование
        caps.setCapability("browserstack.local", "true");
        caps.setCapability("browserstack.localIdentifier", "Test123");
        
        WebDriver driver = new RemoteWebDriver(new URL(URL), caps);
        driver.get("https://www.example.com");
        
        System.out.println("Заголовок страницы: " + driver.getTitle());
        
        driver.quit();
    }
}

// cypress.config.js для BrowserStack
const { defineConfig } = require('cypress');

module.exports = defineConfig({
  e2e: {
    baseUrl: 'https://www.example.com',
    setupNodeEvents(on, config) {
      // Специфичная конфигурация BrowserStack
      require('cypress-browserstack')(on, config);
      return config;
    },
  },
});

// browserstack.json
{
  "auth": {
    "username": "ВАШ_ЛОГИН",
    "access_key": "ВАШ_КЛЮЧ_ДОСТУПА"
  },
  "browsers": [
    {
      "browser": "chrome",
      "os": "Windows 11",
      "versions": ["latest", "latest-1"]
    },
    {
      "browser": "edge",
      "os": "Windows 10",
      "versions": ["latest"]
    },
    {
      "browser": "safari",
      "os": "OS X Monterey",
      "versions": ["latest"]
    }
  ],
  "run_settings": {
    "cypress_config_file": "./cypress.config.js",
    "project_name": "Проект Облачного Тестирования",
    "build_name": "build-1",
    "parallels": 5,
    "specs": ["cypress/e2e/**/*.cy.js"]
  },
  "connection_settings": {
    "local": false,
    "local_identifier": null
  }
}

// playwright.config.js для BrowserStack
const { defineConfig, devices } = require('@playwright/test') (как обсуждается в [TestComplete Commercial Tool: ROI Analysis and Enterprise Test Automation](/blog/testcomplete-commercial));
const cp = require('child_process');
const clientPlaywrightVersion = cp.execSync('npx playwright --version').toString().trim().split(' ')[1];

module.exports = defineConfig({
  testDir: './tests',
  timeout: 30000,
  retries: 2,
  workers: 5,
  
  use: {
    baseURL: 'https://www.example.com',
    trace: 'on-first-retry',
    screenshot: 'only-on-failure',
  },

  projects: [
    {
      name: 'chrome-win11',
      use: {
        ...devices['Desktop Chrome'],
        browserName: 'chromium',
        connectOptions: {
          wsEndpoint: `wss://cdp.browserstack.com/playwright?caps=${encodeURIComponent(JSON.stringify({
            'browser': 'chrome',
            'browser_version': 'latest',
            'os': 'Windows',
            'os_version': '11',
            'name': 'Playwright Тест Облака',
            'build': 'playwright-build-1',
            'project': 'Проект Облачного Тестирования',
            'browserstack.username': process.env.BROWSERSTACK_USERNAME,
            'browserstack.accessKey': process.env.BROWSERSTACK_ACCESS_KEY,
            'browserstack.local': process.env.BROWSERSTACK_LOCAL || false,
            'browserstack.debug': true,
            'client.playwrightVersion': clientPlaywrightVersion
          }))}`
        }
      }
    }
  ]
});

// Пример Node.js Appium для BrowserStack
const { remote } = require('webdriverio');

const capabilities = {
  'platformName': 'Android',
  'platformVersion': '13.0',
  'deviceName': 'Google Pixel 7',
  'app': 'bs://ваш_id_приложения_здесь', // Сначала загрузите приложение
  'automationName': 'UiAutomator2',
  
  // Возможности BrowserStack
  'bstack:options': {
    'userName': process.env.BROWSERSTACK_USERNAME,
    'accessKey': process.env.BROWSERSTACK_ACCESS_KEY,
    'projectName': 'Тестирование Мобильных Приложений',
    'buildName': 'Android Build 1',
    'sessionName': 'Тест Pixel 7',
    'debug': true,
    'networkLogs': true,
    'deviceLogs': true,
    'appiumLogs': true,
    'video': true,
    'geoLocation': 'US'
  }
};

async function runTest() {
  const driver = await remote({
    protocol: 'https',
    hostname: 'hub-cloud.browserstack.com',
    port: 443,
    path: '/wd/hub',
    capabilities: capabilities
  });

  try {
    // Ваш код теста здесь
    const element = await driver.$('~loginButton');
    await element.click();
    
    console.log('Тест выполнен успешно');
  } catch (error) {
    console.error('Тест не прошел:', error);
  } finally {
    await driver.deleteSession();
  }
}

runTest();

# Пример Python с возможностями Sauce Labs
from selenium import webdriver
from selenium.webdriver.remote.remote_connection import RemoteConnection
import os

username = os.environ.get('SAUCE_USERNAME')
access_key = os.environ.get('SAUCE_ACCESS_KEY')

# Возможности Sauce Labs
sauce_options = {
    'username': username,
    'accessKey': access_key,
    'name': 'Тест Облачной Платформы',
    'build': 'sauce-build-1',
    'tags': ['cloud-testing', 'selenium'],
    
    # Запись и отладка
    'recordVideo': True,
    'recordScreenshots': True,
    'recordLogs': True,
    'extendedDebugging': True,
    'capturePerformance': True,
    
    # Таймауты
    'maxDuration': 3600,
    'commandTimeout': 300,
    'idleTimeout': 90
}

capabilities = {
    'browserName': 'chrome',
    'browserVersion': 'latest',
    'platformName': 'Windows 11',
    'sauce:options': sauce_options
}

# Выбор дата-центра
sauce_url = f'https://{username}:{access_key}@ondemand.us-west-1.saucelabs.com:443/wd/hub'
# Для EU: ondemand.eu-central-1.saucelabs.com
# Для US East: ondemand.us-east-4.saucelabs.com

driver = webdriver.Remote(
    command_executor=sauce_url,
    desired_capabilities=capabilities
)

try:
    driver.get('https://www.example.com')
    print(f'Заголовок страницы: {driver.title}')
    
    # Отметить тест как пройденный
    driver.execute_script('sauce:job-result=passed')
except Exception as e:
    print(f'Тест не прошел: {e}')
    driver.execute_script('sauce:job-result=failed')
finally:
    driver.quit()

// cypress.config.js для Sauce Labs
const { defineConfig } = require('cypress');

module.exports = defineConfig({
  e2e: {
    baseUrl: 'https://www.example.com',
    setupNodeEvents(on, config) {
      // Конфигурация Sauce Labs
    },
  },
});

// sauce-config.yml
apiVersion: v1alpha
kind: cypress
sauce:
  region: us-west-1
  metadata:
    name: Набор Cypress Облачного Тестирования
    build: Build $BUILD_ID
    tags:
      - cloud-testing
      - cypress
  concurrency: 5
  
docker:
  image: saucelabs/stt-cypress-mocha-node:v8.7.0
  
cypress:
  configFile: cypress.config.js
  version: 12.5.0
  
suites:
  - name: "Тесты Chrome Desktop"
    browser: chrome
    config:
      env:
        environment: production
    platformName: "Windows 11"
    screenResolution: "1920x1080"
    
  - name: "Тесты Firefox Desktop"
    browser: firefox
    platformName: "Windows 10"
    screenResolution: "1920x1080"
    
  - name: "Тесты Safari Desktop"
    browser: webkit
    platformName: "macOS 13"
    screenResolution: "1920x1080"

artifacts:
  download:
    when: always
    match:
      - console.log
      - "*.mp4"
    directory: ./artifacts

// playwright.config.js для Sauce Labs
const { defineConfig, devices } = require('@playwright/test');

module.exports = defineConfig({
  testDir: './tests',
  timeout: 30000,
  retries: 2,
  
  use: {
    baseURL: 'https://www.example.com',
    trace: 'on-first-retry',
  },

  projects: [
    {
      name: 'saucelabs-chrome',
      use: {
        ...devices['Desktop Chrome'],
        connectOptions: {
          wsEndpoint: {
            url: 'wss://ondemand.us-west-1.saucelabs.com/v1/playwright',
            headers: {
              'Authorization': `Basic ${Buffer.from(
                `${process.env.SAUCE_USERNAME}:${process.env.SAUCE_ACCESS_KEY}`
              ).toString('base64')}`
            }
          },
          options: {
            browserName: 'chromium',
            browserVersion: 'latest',
            platformName: 'Windows 11',
            'sauce:options': {
              name: 'Playwright Облачный Тест',
              build: 'playwright-build-1',
              tags: ['cloud-testing'],
              extendedDebugging: true,
              capturePerformance: true
            }
          }
        }
      }
    }
  ]
});

# Пример Ruby Appium для Sauce Labs
require 'appium_lib'
require 'selenium-webdriver'

caps = {
  platformName: 'Android',
  'appium:platformVersion' => '13',
  'appium:deviceName' => 'Google Pixel 7 GoogleAPI Emulator',
  'appium:automationName' => 'UiAutomator2',
  'appium:app' => 'storage:filename=YourApp.apk',
  'appium:autoGrantPermissions' => true,
  'appium:noReset' => false,
  
  'sauce:options' => {
    username: ENV['SAUCE_USERNAME'],
    accessKey: ENV['SAUCE_ACCESS_KEY'],
    name: 'Android Тест Мобильного Приложения',
    build: 'android-build-1',
    deviceOrientation: 'portrait',
    appiumVersion: '2.0.0',
    recordVideo: true,
    recordScreenshots: true
  }
}

appium_lib = {
  server_url: 'https://ondemand.us-west-1.saucelabs.com:443/wd/hub',
  wait_timeout: 30,
  wait_interval: 1
}

driver = Appium::Driver.new({ caps: caps, appium_lib: appium_lib }, true)

begin
  driver.start_driver
  
  # Ваш код теста
  element = driver.find_element(:accessibility_id, 'loginButton')
  element.click
  
  puts 'Тест пройден'
  driver.execute_script('sauce:job-result=passed')
rescue => e
  puts "Тест не прошел: #{e.message}"
  driver.execute_script('sauce:job-result=failed')
ensure
  driver.quit
end

// Пример C# с возможностями LambdaTest
using OpenQA.Selenium;
using OpenQA.Selenium.Remote;
using System;

namespace CloudTestingPlatform
{
    class LambdaTestExample
    {
        static void Main(string[] args)
        {
            string username = Environment.GetEnvironmentVariable("LT_USERNAME");
            string accessKey = Environment.GetEnvironmentVariable("LT_ACCESS_KEY");
            string gridUrl = $"https://{username}:{accessKey}@hub.lambdatest.com/wd/hub";

            var capabilities = new DesiredCapabilities();
            
            // Конфигурация браузера
            capabilities.SetCapability("browserName", "Chrome");
            capabilities.SetCapability("browserVersion", "latest");
            capabilities.SetCapability("platform", "Windows 11");
            
            // Специфичные опции LambdaTest
            var ltOptions = new Dictionary<string, object>
            {
                {"username", username},
                {"accessKey", accessKey},
                {"name", "Тест Облачной Платформы"},
                {"build", "lambdatest-build-1"},
                {"project", "Проект Облачного Тестирования"},
                {"selenium_version", "4.15.0"},
                {"driver_version", "latest"},
                
                // Опции отладки
                {"video", true},
                {"visual", true},
                {"network", true},
                {"console", true},
                {"terminal", true},
                
                // Опции производительности
                {"w3c", true},
                {"plugin", "c#-nunit"}
            };
            
            capabilities.SetCapability("LT:Options", ltOptions);

            var driver = new RemoteWebDriver(new Uri(gridUrl), capabilities);

            try
            {
                driver.Navigate().GoToUrl("https://www.example.com");
                Console.WriteLine($"Заголовок страницы: {driver.Title}");
                
                // Отметить тест как пройденный
                ((IJavaScriptExecutor)driver).ExecuteScript("lambda-status=passed");
            }
            catch (Exception e)
            {
                Console.WriteLine($"Тест не прошел: {e.Message}");
                ((IJavaScriptExecutor)driver).ExecuteScript("lambda-status=failed");
            }
            finally
            {
                driver.Quit();
            }
        }
    }
}

// lambdatest-config.json
{
  "lambdatest_auth": {
    "username": "ВАШ_ЛОГИН",
    "access_key": "ВАШ_КЛЮЧ_ДОСТУПА"
  },
  "browsers": [
    {
      "browser": "Chrome",
      "platform": "Windows 11",
      "versions": ["latest", "latest-1"]
    },
    {
      "browser": "MicrosoftEdge",
      "platform": "Windows 10",
      "versions": ["latest"]
    },
    {
      "browser": "Safari",
      "platform": "macOS Monterey",
      "versions": ["latest"]
    }
  ],
  "run_settings": {
    "cypress_config_file": "cypress.config.js",
    "reporter_config_file": "base_reporter_config.json",
    "build_name": "Cloud Testing Build",
    "parallels": 5,
    "specs": ["cypress/e2e/**/*.cy.js"],
    "ignore_files": [],
    "network": true,
    "headless": false,
    "npm_dependencies": {
      "cypress": "12.5.0"
    },
    "feature_file_suppport": false
  },
  "tunnel_settings": {
    "tunnel": false,
    "tunnel_name": null
  }
}

// скрипт в package.json
{
  "scripts": {
    "test:lambdatest": "lambdatest-cypress run --config-file lambdatest-config.json"
  }
}

// playwright.config.js для LambdaTest
const { defineConfig, devices } = require('@playwright/test');

const capabilities = {
  'browserName': 'Chrome',
  'browserVersion': 'latest',
  'LT:Options': {
    'platform': 'Windows 11',
    'build': 'Playwright Cloud Testing Build',
    'name': 'Playwright Тест',
    'user': process.env.LT_USERNAME,
    'accessKey': process.env.LT_ACCESS_KEY,
    'network': true,
    'video': true,
    'console': true,
    'tunnel': false,
    'tunnelName': '',
    'geoLocation': 'US'
  }
};

module.exports = defineConfig({
  testDir: './tests',
  timeout: 60000,
  retries: 2,
  workers: 5,
  
  use: {
    baseURL: 'https://www.example.com',
    trace: 'retain-on-failure',
    connectOptions: {
      wsEndpoint: `wss://cdp.lambdatest.com/playwright?capabilities=${encodeURIComponent(JSON.stringify(capabilities))}`
    }
  },

  projects: [
    {
      name: 'chrome-windows',
      use: { 
        ...devices['Desktop Chrome'],
        capabilities
      }
    },
    {
      name: 'webkit-mac',
      use: {
        ...devices['Desktop Safari'],
        capabilities: {
          ...capabilities,
          'browserName': 'pw-webkit',
          'LT:Options': {
            ...capabilities['LT:Options'],
            'platform': 'macOS Monterey'
          }
        }
      }
    }
  ]
});

# hyperexecute.yaml
version: 0.1
globalTimeout: 90
testSuiteTimeout: 90
testSuiteStep: 90

runson: windows

autosplit: true
retryOnFailure: true
maxRetries: 2
concurrency: 5

pre:
  - npm install

cacheKey: '{{ checksum "package-lock.json" }}'
cacheDirectories:
  - node_modules

testDiscovery:
  type: raw
  mode: dynamic
  command: grep -rni 'describe' tests -ir --include=\*.spec.js | sed 's/:.*//'

testRunnerCommand: npm test $test

env:
  ENVIRONMENT: production
  HYPEREXECUTE: true

jobLabel: ['cloud-testing', 'hyperexecute', 'playwright']

# AWS CLI - Создать пул устройств
aws devicefarm create-device-pool \
  --project-arn "arn:aws:devicefarm:us-west-2:123456789012:project:a1b2c3d4" \
  --name "Android Устройства Высокого Класса" \
  --description "Последние флагманские Android устройства" \
  --rules '[
    {
      "attribute": "PLATFORM",
      "operator": "EQUALS",
      "value": "ANDROID"
    },
    {
      "attribute": "OS_VERSION",
      "operator": "GREATER_THAN_OR_EQUALS",
      "value": "12"
    },
    {
      "attribute": "FORM_FACTOR",
      "operator": "EQUALS",
      "value": "PHONE"
    }
  ]'

// Пример Node.js для AWS Device Farm с Appium
const { remote } = require('webdriverio');
const AWS = require('aws-sdk');

// AWS Device Farm использует локальный сервер Appium
const capabilities = {
  platformName: 'Android',
  'appium:automationName': 'UiAutomator2',
  'appium:deviceName': 'Android Device',
  'appium:app': process.env.APP_PATH, // Путь загруженного приложения
  'appium:autoGrantPermissions': true,
  'appium:noReset': false,
  'appium:newCommandTimeout': 300
};

async function runDeviceFarmTest() {
  const driver = await remote({
    hostname: 'localhost',
    port: 4723,
    path: '/wd/hub',
    logLevel: 'info',
    capabilities: capabilities
  });

  try {
    // Ожидание загрузки приложения
    await driver.pause(3000);
    
    // Пример тестовых взаимодействий
    const loginButton = await driver.$('~loginButton');
    await loginButton.waitForDisplayed({ timeout: 5000 });
    await loginButton.click();
    
    const usernameField = await driver.$('~usernameField');
    await usernameField.setValue('testuser@example.com');
    
    const passwordField = await driver.$('~passwordField');
    await passwordField.setValue('SecurePassword123');
    
    const submitButton = await driver.$('~submitButton');
    await submitButton.click();
    
    // Проверка успешного входа
    const welcomeMessage = await driver.$('~welcomeMessage');
    await welcomeMessage.waitForDisplayed({ timeout: 10000 });
    
    const text = await welcomeMessage.getText();
    console.log(`Приветственное сообщение: ${text}`);
    
    // Тест пройден
    console.log('Тест выполнен успешно');
  } catch (error) {
    console.error('Тест не прошел:', error);
    throw error;
  } finally {
    await driver.deleteSession();
  }
}

// Точка входа для Device Farm
if (require.main === module) {
  runDeviceFarmTest()
    .then(() => process.exit(0))
    .catch((error) => {
      console.error(error);
      process.exit(1);
    });
}

module.exports = { runDeviceFarmTest };

// Тест Espresso Android для AWS Device Farm
package com.example.cloudtesting;

import androidx.test.ext.junit.rules.ActivityScenarioRule;
import androidx.test.ext.junit.runners.AndroidJUnit4;
import androidx.test.espresso.Espresso;
import androidx.test.espresso.action.ViewActions;
import androidx.test.espresso.assertion.ViewAssertions;
import androidx.test.espresso.matcher.ViewMatchers;

import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;

@RunWith(AndroidJUnit4.class)
public class DeviceFarmEspressoTest {
    
    @Rule
    public ActivityScenarioRule<MainActivity> activityRule = 
        new ActivityScenarioRule<>(MainActivity.class);

    @Test
    public void testLoginFlow() {
        // Ввести имя пользователя
        Espresso.onView(ViewMatchers.withId(R.id.username_field))
            .perform(ViewActions.typeText("testuser@example.com"));
        
        // Ввести пароль
        Espresso.onView(ViewMatchers.withId(R.id.password_field))
            .perform(ViewActions.typeText("SecurePassword123"));
        
        // Закрыть клавиатуру
        Espresso.closeSoftKeyboard();
        
        // Нажать кнопку входа
        Espresso.onView(ViewMatchers.withId(R.id.login_button))
            .perform(ViewActions.click());
        
        // Проверить, что мы на домашнем экране
        Espresso.onView(ViewMatchers.withId(R.id.welcome_message))
            .check(ViewAssertions.matches(
                ViewMatchers.withText("Добро пожаловать, Тестовый Пользователь!")
            ));
    }
    
    @Test
    public void testNavigationDrawer() {
        // Открыть выдвижную панель навигации
        Espresso.onView(ViewMatchers.withContentDescription("Открыть выдвижную панель навигации"))
            .perform(ViewActions.click());
        
        // Нажать на настройки
        Espresso.onView(ViewMatchers.withText("Настройки"))
            .perform(ViewActions.click());
        
        // Проверить отображение экрана настроек
        Espresso.onView(ViewMatchers.withId(R.id.settings_title))
            .check(ViewAssertions.matches(ViewMatchers.isDisplayed()));
    }
}

// XCUITest iOS для AWS Device Farm
import XCTest

class DeviceFarmXCUITest: XCTestCase {
    
    var app: XCUIApplication!
    
    override func setUp() {
        super.setUp()
        continueAfterFailure = false
        app = XCUIApplication()
        app.launch()
    }
    
    override func tearDown() {
        super.tearDown()
    }
    
    func testLoginFlow() {
        // Ввести имя пользователя
        let usernameField = app.textFields["usernameField"]
        XCTAssertTrue(usernameField.waitForExistence(timeout: 5))
        usernameField.tap()
        usernameField.typeText("testuser@example.com")
        
        // Ввести пароль
        let passwordField = app.secureTextFields["passwordField"]
        XCTAssertTrue(passwordField.exists)
        passwordField.tap()
        passwordField.typeText("SecurePassword123")
        
        // Нажать кнопку входа
        let loginButton = app.buttons["loginButton"]
        XCTAssertTrue(loginButton.exists)
        loginButton.tap()
        
        // Проверить приветственное сообщение
        let welcomeMessage = app.staticTexts["welcomeMessage"]
        XCTAssertTrue(welcomeMessage.waitForExistence(timeout: 10))
        XCTAssertEqual(welcomeMessage.label, "Добро пожаловать, Тестовый Пользователь!")
    }
    
    func testNavigationFlow() {
        // Нажать вкладку профиля
        let profileTab = app.tabBars.buttons["Профиль"]
        XCTAssertTrue(profileTab.waitForExistence(timeout: 5))
        profileTab.tap()
        
        // Проверить экран профиля
        let profileTitle = app.navigationBars["Профиль"]
        XCTAssertTrue(profileTitle.exists)
        
        // Нажать кнопку настроек
        let settingsButton = app.buttons["settingsButton"]
        settingsButton.tap()
        
        // Проверить экран настроек
        let settingsTitle = app.navigationBars["Настройки"]
        XCTAssertTrue(settingsTitle.waitForExistence(timeout: 5))
    }
    
    func testPerformanceScenario() {
        measure {
            // Запуск приложения несколько раз для измерения производительности
            app.launch()
            
            let mainView = app.otherElements["mainView"]
            XCTAssertTrue(mainView.waitForExistence(timeout: 5))
            
            app.terminate()
        }
    }
}

# .github/workflows/device-farm-tests.yml
name: Мобильные Тесты AWS Device Farm

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

jobs:
  device-farm-android:
    runs-on: ubuntu-latest
    
    steps:
      - uses: actions/checkout@v3
      
      - name: Настроить JDK 11
        uses: actions/setup-java@v3
        with:
          java-version: '11'
          distribution: 'temurin'
      
      - name: Собрать Android Приложение
        run: |
          cd android
          ./gradlew assembleDebug
          ./gradlew assembleAndroidTest
      
      - name: Настроить Учетные Данные AWS
        uses: aws-actions/configure-aws-credentials@v2
        with:
          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          aws-region: us-west-2
      
      - name: Загрузить Приложение в Device Farm
        id: upload-app
        run: |
          APP_ARN=$(aws devicefarm create-upload \
            --project-arn ${{ secrets.DEVICE_FARM_PROJECT_ARN }} \
            --name app-debug.apk \
            --type ANDROID_APP \
            --query 'upload.arn' \
            --output text)
          
          aws devicefarm put-upload \
            --arn $APP_ARN \
            --file android/app/build/outputs/apk/debug/app-debug.apk
          
          echo "app_arn=$APP_ARN" >> $GITHUB_OUTPUT
      
      - name: Загрузить Пакет Тестов
        id: upload-tests
        run: |
          TEST_ARN=$(aws devicefarm create-upload \
            --project-arn ${{ secrets.DEVICE_FARM_PROJECT_ARN }} \
            --name app-debug-androidTest.apk \
            --type INSTRUMENTATION_TEST_PACKAGE \
            --query 'upload.arn' \
            --output text)
          
          aws devicefarm put-upload \
            --arn $TEST_ARN \
            --file android/app/build/outputs/apk/androidTest/debug/app-debug-androidTest.apk
          
          echo "test_arn=$TEST_ARN" >> $GITHUB_OUTPUT
      
      - name: Запланировать Выполнение Теста
        id: schedule-run
        run: |
          RUN_ARN=$(aws devicefarm schedule-run \
            --project-arn ${{ secrets.DEVICE_FARM_PROJECT_ARN }} \
            --app-arn ${{ steps.upload-app.outputs.app_arn }} \
            --device-pool-arn ${{ secrets.DEVICE_FARM_POOL_ARN }} \
            --name "Выполнение GitHub Actions - ${{ github.run_number }}" \
            --test type=INSTRUMENTATION,testPackageArn=${{ steps.upload-tests.outputs.test_arn }} \
            --query 'run.arn' \
            --output text)
          
          echo "run_arn=$RUN_ARN" >> $GITHUB_OUTPUT
      
      - name: Дождаться Результатов Тестов
        run: |
          while true; do
            STATUS=$(aws devicefarm get-run \
              --arn ${{ steps.schedule-run.outputs.run_arn }} \
              --query 'run.status' \
              --output text)
            
            echo "Текущий статус: $STATUS"
            
            if [ "$STATUS" = "COMPLETED" ]; then
              break
            elif [ "$STATUS" = "ERRORED" ] || [ "$STATUS" = "FAILED" ]; then
              echo "Выполнение теста не удалось со статусом: $STATUS"
              exit 1
            fi
            
            sleep 30
          done
      
      - name: Получить Результаты Тестов
        run: |
          aws devicefarm get-run \
            --arn ${{ steps.schedule-run.outputs.run_arn }} \
            --query 'run.counters' \
            --output table
          
          RESULT=$(aws devicefarm get-run \
            --arn ${{ steps.schedule-run.outputs.run_arn }} \
            --query 'run.result' \
            --output text)
          
          if [ "$RESULT" != "PASSED" ]; then
            echo "Тесты не пройдены с результатом: $RESULT"
            exit 1
          fi

// Jenkinsfile для AWS Device Farm
pipeline {
    agent any
    
    environment {
        AWS_REGION = 'us-west-2'
        DEVICE_FARM_PROJECT_ARN = credentials('device-farm-project-arn')
        DEVICE_FARM_POOL_ARN = credentials('device-farm-pool-arn')
    }
    
    stages {
        stage('Собрать Android Приложение') {
            steps {
                dir('android') {
                    sh './gradlew clean assembleDebug assembleAndroidTest'
                }
            }
        }
        
        stage('Загрузить в Device Farm') {
            steps {
                script {
                    // Загрузить приложение
                    def appUpload = sh(
                        script: """
                            aws devicefarm create-upload \
                                --project-arn ${DEVICE_FARM_PROJECT_ARN} \
                                --name app-debug.apk \
                                --type ANDROID_APP \
                                --query 'upload.[arn,url]' \
                                --output text
                        """,
                        returnStdout: true
                    ).trim().split()
                    
                    env.APP_ARN = appUpload[0]
                    env.APP_URL = appUpload[1]
                    
                    sh "curl -T android/app/build/outputs/apk/debug/app-debug.apk '${APP_URL}'"
                    
                    // Загрузить пакет тестов
                    def testUpload = sh(
                        script: """
                            aws devicefarm create-upload \
                                --project-arn ${DEVICE_FARM_PROJECT_ARN} \
                                --name app-debug-androidTest.apk \
                                --type INSTRUMENTATION_TEST_PACKAGE \
                                --query 'upload.[arn,url]' \
                                --output text
                        """,
                        returnStdout: true
                    ).trim().split()
                    
                    env.TEST_ARN = testUpload[0]
                    env.TEST_URL = testUpload[1]
                    
                    sh "curl -T android/app/build/outputs/apk/androidTest/debug/app-debug-androidTest.apk '${TEST_URL}'"
                }
            }
        }
        
        stage('Запустить Тесты на Device Farm') {
            steps {
                script {
                    env.RUN_ARN = sh(
                        script: """
                            aws devicefarm schedule-run \
                                --project-arn ${DEVICE_FARM_PROJECT_ARN} \
                                --app-arn ${APP_ARN} \
                                --device-pool-arn ${DEVICE_FARM_POOL_ARN} \
                                --name "Jenkins Build ${BUILD_NUMBER}" \
                                --test type=INSTRUMENTATION,testPackageArn=${TEST_ARN} \
                                --query 'run.arn' \
                                --output text
                        """,
                        returnStdout: true
                    ).trim()
                    
                    echo "Выполнение теста запланировано: ${RUN_ARN}"
                }
            }
        }
        
        stage('Дождаться Результатов') {
            steps {
                script {
                    timeout(time: 60, unit: 'MINUTES') {
                        waitUntil {
                            def status = sh(
                                script: """
                                    aws devicefarm get-run \
                                        --arn ${RUN_ARN} \
                                        --query 'run.status' \
                                        --output text
                                """,
                                returnStdout: true
                            ).trim()
                            
                            echo "Текущий статус: ${status}"
                            
                            return status == 'COMPLETED' || status == 'ERRORED' || status == 'FAILED'
                        }
                    }
                    
                    def result = sh(
                        script: """
                            aws devicefarm get-run \
                                --arn ${RUN_ARN} \
                                --query 'run.result' \
                                --output text
                        """,
                        returnStdout: true
                    ).trim()
                    
                    if (result != 'PASSED') {
                        error("Тесты не пройдены с результатом: ${result}")
                    }
                }
            }
        }
        
        stage('Скачать Артефакты') {
            steps {
                script {
                    sh """
                        aws devicefarm list-artifacts \
                            --arn ${RUN_ARN} \
                            --type FILE \
                            --query 'artifacts[*].[name,url]' \
                            --output text | while read name url; do
                                curl -o "artifacts/\${name}" "\${url}"
                            done
                    """
                }
                archiveArtifacts artifacts: 'artifacts/**', allowEmptyArchive: true
            }
        }
    }
    
    post {
        always {
            echo "Детали выполнения теста: https://us-west-2.console.aws.amazon.com/devicefarm/home"
        }
    }
}

# Запустить Robo test через gcloud CLI
gcloud firebase test android run \
  --type robo \
  --app app/build/outputs/apk/debug/app-debug.apk \
  --device model=Pixel7,version=33,locale=ru,orientation=portrait \
  --device model=galaxys23,version=33,locale=ru,orientation=portrait \
  --timeout 5m \
  --results-bucket=gs://your-bucket-name \
  --results-dir=robo-test-results

{
  "robo_script": [
    {
      "action_type": "WAIT_FOR_ELEMENT",
      "optional": false,
      "resource_name": "username_field"
    },
    {
      "action_type": "ENTER_TEXT",
      "resource_name": "username_field",
      "input_text": "testuser@example.com"
    },
    {
      "action_type": "ENTER_TEXT",
      "resource_name": "password_field",
      "input_text": "TestPassword123"
    },
    {
      "action_type": "CLICK",
      "resource_name": "login_button"
    },
    {
      "action_type": "WAIT_FOR_ELEMENT",
      "optional": false,
      "resource_name": "home_screen",
      "timeout": 10000
    }
  ]
}

# Запустить с Robo script
gcloud firebase test android run \
  --type robo \
  --app app-debug.apk \
  --robo-script robo_script.json \
  --device model=Pixel7,version=33

# Запустить инструментальные тесты Espresso
gcloud firebase test android run \
  --type instrumentation \
  --app app/build/outputs/apk/debug/app-debug.apk \
  --test app/build/outputs/apk/androidTest/debug/app-debug-androidTest.apk \
  --device model=Pixel7,version=33,locale=ru,orientation=portrait \
  --device model=Pixel6,version=32,locale=ru,orientation=portrait \
  --device model=galaxys22,version=32,locale=ru,orientation=landscape \
  --timeout 30m \
  --results-bucket=gs://your-bucket-name \
  --results-dir=espresso-test-results \
  --environment-variables coverage=true,coverageFile="/sdcard/coverage.ec" \
  --directories-to-pull /sdcard

# Тестовая матрица с несколькими измерениями
gcloud firebase test android run \
  --type instrumentation \
  --app app-debug.apk \
  --test app-debug-androidTest.apk \
  --device-ids Pixel7,Pixel6,galaxys22 \
  --os-version-ids 33,32 \
  --locales ru,en,es \
  --orientations portrait,landscape

# Собрать iOS приложение для тестирования
xcodebuild build-for-testing \
  -workspace YourApp.xcworkspace \
  -scheme YourApp \
  -sdk iphoneos \
  -configuration Debug \
  -derivedDataPath build

# Создать тестовый архив
cd build/Build/Products
zip -r YourApp.zip Debug-iphoneos/*.app
zip -r YourAppTests.zip Debug-iphoneos/*.xctestrun

# Запустить в Firebase Test Lab
gcloud firebase test ios run \
  --test YourAppTests.zip \
  --device model=iphone14pro,version=16.6,locale=ru,orientation=portrait \
  --device model=iphone13,version=16.6,locale=ru,orientation=portrait \
  --timeout 30m \
  --results-bucket=gs://your-bucket-name \
  --results-dir=ios-test-results

// app/build.gradle
android {
    defaultConfig {
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }
    
    testOptions {
        execution 'ANDROIDX_TEST_ORCHESTRATOR'
    }
}

dependencies {
    androidTestImplementation 'androidx.test.ext:junit:1.1.5'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1'
    androidTestUtil 'androidx.test:orchestrator:1.4.2'
}

// Добавить конфигурацию Firebase Test Lab
// Создать testlab.yml в корне проекта

# testlab.yml
gcloud:
  test: |
    gcloud firebase test android run \
      --type instrumentation \
      --app app/build/outputs/apk/debug/app-debug.apk \
      --test app/build/outputs/apk/androidTest/debug/app-debug-androidTest.apk \
      --device model=Pixel7,version=33 \
      --device model=Pixel6,version=32 \
      --timeout 20m

# Конфигурация матрицы устройств
devices:
  - model: Pixel7
    version: 33
    locale: ru
    orientation: portrait
  
  - model: Pixel6
    version: 32
    locale: ru
    orientation: portrait
  
  - model: galaxys22
    version: 32
    locale: ru
    orientation: portrait

# Конфигурация теста
test_configuration:
  timeout: 20m
  results_bucket: gs://your-bucket-name
  environment_variables:
    - key: coverage
      value: true
    - key: clearPackageData
      value: true

# .github/workflows/firebase-test-lab.yml
name: Firebase Test Lab

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

jobs:
  test:
    runs-on: ubuntu-latest
    
    steps:
      - uses: actions/checkout@v3
      
      - name: Настроить JDK 17
        uses: actions/setup-java@v3
        with:
          java-version: '17'
          distribution: 'temurin'
      
      - name: Собрать Приложение и Тесты
        run: |
          chmod +x gradlew
          ./gradlew assembleDebug assembleDebugAndroidTest
      
      - name: Аутентифицировать в Google Cloud
        uses: google-github-actions/auth@v1
        with:
          credentials_json: ${{ secrets.GCP_SA_KEY }}
      
      - name: Настроить Cloud SDK
        uses: google-github-actions/setup-gcloud@v1
      
      - name: Запустить Тесты в Firebase Test Lab
        run: |
          gcloud firebase test android run \
            --type instrumentation \
            --app app/build/outputs/apk/debug/app-debug.apk \
            --test app/build/outputs/apk/androidTest/debug/app-debug-androidTest.apk \
            --device model=Pixel7,version=33,locale=ru,orientation=portrait \
            --device model=Pixel6,version=32,locale=ru,orientation=portrait \
            --timeout 30m \
            --results-bucket=gs://${{ secrets.GCS_BUCKET }} \
            --results-dir=github-actions-${GITHUB_RUN_NUMBER} \
            --format=json \
            --no-record-video \
            --no-performance-metrics
      
      - name: Скачать Результаты Тестов
        if: always()
        run: |
          gsutil -m cp -r \
            gs://${{ secrets.GCS_BUCKET }}/github-actions-${GITHUB_RUN_NUMBER} \
            ./test-results
      
      - name: Загрузить Результаты Тестов
        if: always()
        uses: actions/upload-artifact@v3
        with:
          name: firebase-test-results
          path: test-results/

# .gitlab-ci.yml
stages:
  - build
  - test

variables:
  ANDROID_COMPILE_SDK: "33"
  ANDROID_BUILD_TOOLS: "33.0.2"

build:
  stage: build
  image: openjdk:17-jdk
  before_script:
    - apt-get update && apt-get install -y wget unzip
    - wget -q https://dl.google.com/android/repository/commandlinetools-linux-9477386_latest.zip
    - unzip -q commandlinetools-linux-9477386_latest.zip -d android-sdk
    - export ANDROID_HOME=$PWD/android-sdk
    - export PATH=$PATH:$ANDROID_HOME/cmdline-tools/bin:$ANDROID_HOME/platform-tools
  script:
    - chmod +x gradlew
    - ./gradlew assembleDebug assembleDebugAndroidTest
  artifacts:
    paths:
      - app/build/outputs/apk/debug/
      - app/build/outputs/apk/androidTest/debug/

firebase_test:
  stage: test
  image: google/cloud-sdk:alpine
  dependencies:
    - build
  before_script:
    - echo $GCP_SA_KEY | base64 -d > ${HOME}/gcp-key.json
    - gcloud auth activate-service-account --key-file ${HOME}/gcp-key.json
    - gcloud config set project $GCP_PROJECT_ID
  script:
    - |
      gcloud firebase test android run \
        --type instrumentation \
        --app app/build/outputs/apk/debug/app-debug.apk \
        --test app/build/outputs/apk/androidTest/debug/app-debug-androidTest.apk \
        --device model=Pixel7,version=33 \
        --device model=Pixel6,version=32 \
        --timeout 30m \
        --results-bucket=gs://$GCS_BUCKET \
        --results-dir=gitlab-ci-${CI_PIPELINE_ID}
  after_script:
    - gsutil -m cp -r gs://$GCS_BUCKET/gitlab-ci-${CI_PIPELINE_ID} ./test-results
  artifacts:
    when: always
    paths:
      - test-results/

# fastlane/Fastfile
platform :android do
  desc "Запустить тесты в Firebase Test Lab"
  lane :firebase_test do
    gradle(task: "assembleDebug assembleDebugAndroidTest")
    
    firebase_test_lab_android(
      project_id: ENV['GCP_PROJECT_ID'],
      model: "Pixel7,Pixel6,galaxys22",
      version: "33,32",
      locale: "ru",
      orientation: "portrait",
      timeout: "30m",
      app_apk: "app/build/outputs/apk/debug/app-debug.apk",
      android_test_apk: "app/build/outputs/apk/androidTest/debug/app-debug-androidTest.apk",
      results_bucket: ENV['GCS_BUCKET'],
      results_dir: "fastlane-#{Time.now.to_i}"
    )
  end
end

platform :ios do
  desc "Запустить тесты в Firebase Test Lab"
  lane :firebase_test do
    build_for_testing(
      workspace: "YourApp.xcworkspace",
      scheme: "YourApp",
      configuration: "Debug"
    )
    
    firebase_test_lab_ios(
      project_id: ENV['GCP_PROJECT_ID'],
      model: "iphone14pro,iphone13",
      version: "16.6",
      locale: "ru",
      orientation: "portrait",
      timeout: "30m",
      app_path: "build/Build/Products/Debug-iphoneos/YourApp.app",
      test_path: "build/Build/Products/Debug-iphoneos/YourAppTests.xctestrun",
      results_bucket: ENV['GCS_BUCKET'],
      results_dir: "fastlane-ios-#{Time.now.to_i}"
    )
  end
end

// Рассчитать оптимальную параллелизацию
function calculateOptimalParallels(totalTests, avgTestDuration, targetDuration, costPerMinute) {
  // Время последовательного выполнения
  const sequentialTime = totalTests * avgTestDuration;
  
  // Требуемые параллели для целевой продолжительности
  const requiredParallels = Math.ceil(sequentialTime / targetDuration);
  
  // Сравнение затрат
  const sequentialCost = sequentialTime * costPerMinute;
  const parallelCost = targetDuration * requiredParallels * costPerMinute;
  
  return {
    sequentialTime: sequentialTime,
    sequentialCost: sequentialCost.toFixed(2),
    optimalParallels: requiredParallels,
    parallelTime: targetDuration,
    parallelCost: parallelCost.toFixed(2),
    savings: (sequentialTime - targetDuration).toFixed(2),
    additionalCost: (parallelCost - sequentialCost).toFixed(2)
  };
}

// Пример расчета
const result = calculateOptimalParallels(
  500,    // всего тестов
  2,      // 2 минуты на тест
  20,     // цель: завершить за 20 минут
  0.10    // $0.10 за минуту (тариф платформы)
);

console.log(result);
// Вывод:
// {
//   sequentialTime: 1000,
//   sequentialCost: "100.00",
//   optimalParallels: 50,
//   parallelTime: 20,
//   parallelCost: "100.00",
//   savings: "980.00",
//   additionalCost: "0.00"
// }

# Декоратор оптимизации сессии
import time
from functools import wraps

def optimize_session(func):
    """
    Декоратор для отслеживания и оптимизации продолжительности сессии
    """
    @wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.time()
        
        try:
            result = func(*args, **kwargs)
            return result
        finally:
            end_time = time.time()
            duration = end_time - start_time
            
            print(f"Продолжительность сессии: {duration:.2f} секунд")
            
            # Предупредить, если сессия превышает порог
            if duration > 300:  # 5 минут
                print(f"ПРЕДУПРЕЖДЕНИЕ: Сессия превысила 5 минут - оптимизируйте тест!")
    
    return wrapper

# Применить к тестовым функциям
@optimize_session
def test_user_login(driver):
    driver.get("https://example.com/login")
    # ... реализация теста
    driver.quit()

# Пакетные операции для сокращения времени сессии
class OptimizedTestExecution:
    def __init__(self, driver):
        self.driver = driver
        self.results = []
    
    def execute_test_batch(self, test_urls):
        """
        Выполнить несколько связанных тестов в одной сессии
        """
        for url in test_urls:
            try:
                self.driver.get(url)
                # Выполнить утверждения
                self.results.append({
                    'url': url,
                    'status': 'пройден',
                    'duration': time.time()
                })
            except Exception as e:
                self.results.append({
                    'url': url,
                    'status': 'не пройден',
                    'error': str(e)
                })
        
        return self.results

# Пример использования
test_urls = [
    "https://example.com/page1",
    "https://example.com/page2",
    "https://example.com/page3"
]

executor = OptimizedTestExecution(driver)
results = executor.execute_test_batch(test_urls)

# Скачать и запустить BrowserStack Local
./BrowserStackLocal --key ВАШ_КЛЮЧ_ДОСТУПА --force-local

# Запустить с пользовательской конфигурацией
./BrowserStackLocal \
  --key ВАШ_КЛЮЧ_ДОСТУПА \
  --local-identifier "my-tunnel-123" \
  --force-local \
  --only-automate \
  --verbose 3

# Конфигурация теста с локальным тестированием
capabilities = {
    'browserstack.local': 'true',
    'browserstack.localIdentifier': 'my-tunnel-123'
}

# Скачать и запустить Sauce Connect
./sc -u ВАШ_ЛОГИН -k ВАШ_КЛЮЧ_ДОСТУПА

# Запустить с идентификатором туннеля
./sc -u ВАШ_ЛОГИН -k ВАШ_КЛЮЧ_ДОСТУПА \
  --tunnel-identifier my-tunnel-123 \
  --readyfile /tmp/sc_ready \
  --logfile /tmp/sc.log

# Конфигурация теста
sauce_options = {
    'tunnelIdentifier': 'my-tunnel-123'
}

# Запустить туннель LambdaTest
./LT --user ВАШ_ЛОГИН --key ВАШ_КЛЮЧ_ДОСТУПА

# С именем туннеля
./LT --user ВАШ_ЛОГИН --key ВАШ_КЛЮЧ_ДОСТУПА \
  --tunnelName my-tunnel-123 \
  --verbose

# Конфигурация теста
lt_options = {
    'tunnel': True,
    'tunnelName': 'my-tunnel-123'
}

// BrowserStack - Отключить видео для более быстрого выполнения
const capabilities = {
    'browserstack.video': false,          // Отключить запись видео
    'browserstack.debug': false,          // Отключить логи консоли
    'browserstack.networkLogs': false,    // Отключить логи сети
    'browserstack.console': 'disable',    // Отключить захват консоли
};

// Включить только при сбое
const capabilitiesConditional = {
    'browserstack.video': process.env.TEST_FAILED === 'true',
};

// Sauce Labs - Видео только при сбое
const sauceOptions = {
    'recordVideo': false,               // Не записывать по умолчанию
    'recordScreenshots': false,         // Без скриншотов
    'recordLogs': false,                // Без логов
    'videoUploadOnPass': false,         // Загружать видео только при сбое
};

// LambdaTest - Оптимизированные настройки
const ltOptions = {
    'video': false,                     // Отключить видео
    'visual': false,                    // Отключить визуальные логи
    'network': false,                   // Отключить логи сети
    'console': false,                   // Отключить логи консоли
    'terminal': false,                  // Отключить логи терминала
};

// Условная запись на основе результата теста
class ConditionalRecordingTest {
    constructor(driver, capabilities) {
        this.driver = driver;
        this.capabilities = capabilities;
        this.testFailed = false;
    }
    
    async runTest() {
        try {
            // Выполнить тест
            await this.executeTestSteps();
        } catch (error) {
            this.testFailed = true;
            
            // Включить запись для неудачного теста
            if (this.capabilities.platform === 'browserstack') {
                await this.driver.executeScript('browserstack_executor: {"action": "setDebug", "arguments": {"value": true}}');
            }
            
            throw error;
        }
    }
    
    async executeTestSteps() {
        // Ваша реализация теста
    }
}

# device-pools.yml
# Определить пулы устройств по приоритету

tier1_critical:
  description: "Критические устройства для каждого запуска теста"
  devices:
    - Chrome Latest / Windows 11
    - Safari Latest / macOS Monterey
    - Chrome Latest / Android 13
    - Safari Latest / iOS 16
  frequency: "каждый коммит"
  cost_per_run: "$5"

tier2_important:
  description: "Важные устройства для ежедневной регрессии"
  devices:
    - Firefox Latest / Windows 11
    - Edge Latest / Windows 11
    - Chrome Latest / Android 12
    - Safari Latest / iOS 15
  frequency: "ежедневно"
  cost_per_run: "$5"

tier3_extended:
  description: "Расширенное покрытие для еженедельного тестирования"
  devices:
    - Chrome Latest-1 / Windows 10
    - Safari Latest-1 / macOS Big Sur
    - Firefox Latest / macOS
    - Различные мобильные устройства (10+)
  frequency: "еженедельно"
  cost_per_run: "$20"

tier4_comprehensive:
  description: "Полное покрытие для пре-релиза"
  devices:
    - Все браузеры
    - Все версии ОС
    - Все мобильные устройства
  frequency: "перед релизом"
  cost_per_run: "$100"

// Динамический выбор устройств на основе контекста
class SmartDeviceSelector {
    constructor(testType, branch, changeSize) {
        this.testType = testType;
        this.branch = branch;
        this.changeSize = changeSize;
    }
    
    selectDevicePool() {
        // Изменения критического пути - полное тестирование
        if (this.isCriticalPath()) {
            return 'tier4_comprehensive';
        }
        
        // Продакшн ветка - расширенное тестирование
        if (this.branch === 'main' || this.branch === 'production') {
            return 'tier2_important';
        }
        
        // Большие изменения - важные устройства
        if (this.changeSize > 500) {
            return 'tier2_important';
        }
        
        // Небольшие изменения - только критические устройства
        return 'tier1_critical';
    }
    
    isCriticalPath() {
        const criticalPaths = [
            'checkout', 'payment', 'authentication',
            'registration', 'search', 'cart'
        ];
        
        return criticalPaths.some(path => 
            this.testType.toLowerCase().includes(path)
        );
    }
    
    estimateCost() {
        const costs = {
            'tier1_critical': 5,
            'tier2_important': 10,
            'tier3_extended': 20,
            'tier4_comprehensive': 100
        };
        
        return costs[this.selectDevicePool()];
    }
}

// Использование в CI/CD
const selector = new SmartDeviceSelector(
    process.env.TEST_TYPE,
    process.env.BRANCH_NAME,
    parseInt(process.env.FILES_CHANGED)
);

const devicePool = selector.selectDevicePool();
const estimatedCost = selector.estimateCost();

console.log(`Выбранный пул устройств: ${devicePool}`);
console.log(`Ожидаемая стоимость: $${estimatedCost}`);

# test_selector.py
import json
import subprocess
from typing import List, Dict

class TestSelector:
    def __init__(self):
        self.test_history = self.load_test_history()
        self.changed_files = self.get_changed_files()
    
    def get_changed_files(self) -> List[str]:
        """Получить список измененных файлов из git"""
        result = subprocess.run(
            ['git', 'diff', '--name-only', 'HEAD^', 'HEAD'],
            capture_output=True,
            text=True
        )
        return result.stdout.strip().split('\n')
    
    def load_test_history(self) -> Dict:
        """Загрузить исторические данные тестов"""
        try:
            with open('test_history.json', 'r') as f:
                return json.load(f)
        except FileNotFoundError:
            return {}
    
    def calculate_priority(self, test_name: str) -> int:
        """
        Рассчитать приоритет теста на основе нескольких факторов:
        - Процент сбоев (выше = больше приоритет)
        - Время выполнения (ниже = больше приоритет)
        - Время с последнего запуска (дольше = больше приоритет)
        - Критичность для бизнеса
        """
        if test_name not in self.test_history:
            return 100  # Новые тесты получают высокий приоритет
        
        test_data = self.test_history[test_name]
        
        failure_rate = test_data.get('failure_rate', 0) * 40
        time_factor = (1 / test_data.get('avg_duration', 1)) * 20
        staleness = test_data.get('days_since_run', 0) * 2
        criticality = test_data.get('criticality', 5) * 10
        
        priority = failure_rate + time_factor + staleness + criticality
        return int(priority)
    
    def select_tests(self, max_tests: int = 50) -> List[str]:
        """Выбрать наиболее важные тесты для запуска"""
        # Получить все тесты
        all_tests = self.get_all_tests()
        
        # Рассчитать приоритеты
        test_priorities = [
            (test, self.calculate_priority(test))
            for test in all_tests
        ]
        
        # Отсортировать по приоритету
        test_priorities.sort(key=lambda x: x[1], reverse=True)
        
        # Выбрать топ N тестов
        selected = [test for test, priority in test_priorities[:max_tests]]
        
        return selected
    
    def get_affected_tests(self) -> List[str]:
        """Получить тесты, затронутые измененными файлами"""
        affected_tests = set()
        
        for changed_file in self.changed_files:
            # Сопоставить исходные файлы с тестовыми файлами
            if changed_file.startswith('src/'):
                # Простое сопоставление: src/components/Login.js -> tests/Login.test.js
                test_file = changed_file.replace('src/', 'tests/').replace('.js', '.test.js')
                affected_tests.add(test_file)
            
            # Проверить сопоставление покрытия тестов
            if changed_file in self.test_history.get('coverage_map', {}):
                affected_tests.update(
                    self.test_history['coverage_map'][changed_file]
                )
        
        return list(affected_tests)
    
    def get_all_tests(self) -> List[str]:
        """Получить список всех тестовых файлов"""
        result = subprocess.run(
            ['find', 'tests', '-name', '*.test.js'],
            capture_output=True,
            text=True
        )
        return result.stdout.strip().split('\n')

# Использование
selector = TestSelector()

# Стратегия 1: Запустить только затронутые тесты
affected_tests = selector.get_affected_tests()
print(f"Запуск {len(affected_tests)} затронутых тестов")

# Стратегия 2: Запустить тесты с наивысшим приоритетом
priority_tests = selector.select_tests(max_tests=50)
print(f"Запуск топ 50 приоритетных тестов")

# Стратегия 3: Гибридный подход
if len(affected_tests) > 0:
    tests_to_run = affected_tests
else:
    tests_to_run = priority_tests[:20]  # Запустить топ 20, если нет затронутых тестов

print(f"Выбранные тесты: {tests_to_run}")

// Selenium WebDriver - Chrome Headless
const { Builder } = require('selenium-webdriver');
const chrome = require('selenium-webdriver/chrome');

// Конфигурация headless
const options = new chrome.Options();
options.addArguments('--headless=new');
options.addArguments('--disable-gpu');
options.addArguments('--no-sandbox');
options.addArguments('--disable-dev-shm-usage');
options.addArguments('--window-size=1920,1080');

const driver = await new Builder()
    .forBrowser('chrome')
    .setChromeOptions(options)
    .build();

// Playwright - Режим headless (по умолчанию)
const { chromium } = require('playwright');

const browser = await chromium.launch({
    headless: true,  // По умолчанию
    args: ['--no-sandbox', '--disable-dev-shm-usage']
});

const context = await browser.newContext({
    viewport: { width: 1920, height: 1080 }
});

# GitHub Actions с кэшированием
name: Оптимизированные Облачные Тесты

on: [push]

jobs:
  test:
    runs-on: ubuntu-latest
    
    steps:
      - uses: actions/checkout@v3
      
      # Кэшировать node модули
      - name: Cache Node Modules
        uses: actions/cache@v3
        with:
          path: node_modules
          key: ${{ runner.os }}-node-${{ hashFiles('package-lock.json') }}
          restore-keys: |
            ${{ runner.os }}-node-
      
      # Кэшировать браузеры Playwright
      - name: Cache Playwright Browsers
        uses: actions/cache@v3
        with:
          path: ~/.cache/ms-playwright
          key: ${{ runner.os }}-playwright-${{ hashFiles('package-lock.json') }}
      
      # Установить зависимости (использует кэш, если доступен)
      - name: Install Dependencies
        run: npm ci
      
      # Запустить тесты
      - name: Run Tests
        run: npm test