AI Copilot para Test Automation: GitHub Copilot, Amazon CodeWhisperer y el Futuro de QA

Comparación de Cronograma:
- Enfoque manual: 3 meses para 500 casos de prueba
- Con GitHub Copilot: 6 semanas para 800 casos de prueba
- Mejora de calidad: 23% menos bugs en producción en el primer trimestre

# Test login with valid credentials, invalid password, and empty fields

def test_login_valid_credentials(self):
    """Test successful login with valid username and password"""
    self.driver.get("https://example.com/login")
    self.driver.find_element(By.ID, "username").send_keys("testuser@example.com")
    self.driver.find_element(By.ID, "password").send_keys("SecurePass123!")
    self.driver.find_element(By.CSS_SELECTOR, "button[type='submit']").click()

    # Verify successful login
    assert self.driver.current_url == "https://example.com/dashboard"
    assert "Welcome" in self.driver.find_element(By.CLASS_NAME, "greeting").text

def test_login_invalid_password(self):
    """Test login failure with incorrect password"""
    self.driver.get("https://example.com/login")
    self.driver.find_element(By.ID, "username").send_keys("testuser@example.com")
    self.driver.find_element(By.ID, "password").send_keys("WrongPassword")
    self.driver.find_element(By.CSS_SELECTOR, "button[type='submit']").click()

    # Verify error message
    error_element = self.driver.find_element(By.CLASS_NAME, "error-message")
    assert "Invalid credentials" in error_element.text

def test_login_empty_fields(self):
    """Test validation with empty username and password"""
    self.driver.get("https://example.com/login")
    self.driver.find_element(By.CSS_SELECTOR, "button[type='submit']").click()

    # Verify validation messages
    username_error = self.driver.find_element(By.ID, "username-error")
    password_error = self.driver.find_element(By.ID, "password-error")
    assert "Username is required" in username_error.text
    assert "Password is required" in password_error.text

// Page Object for product search page with filters, sorting, and pagination

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

export class ProductSearchPage {
  readonly page: Page;
  readonly searchInput: Locator;
  readonly searchButton: Locator;
  readonly filterSidebar: Locator;
  readonly priceFilter: Locator;
  readonly categoryFilter: Locator;
  readonly sortDropdown: Locator;
  readonly productCards: Locator;
  readonly paginationNext: Locator;
  readonly paginationPrevious: Locator;
  readonly resultsCount: Locator;

  constructor(page: Page) {
    this.page = page;
    this.searchInput = page.locator('input[data-testid="search-input"]');
    this.searchButton = page.locator('button[data-testid="search-button"]');
    this.filterSidebar = page.locator('.filters-sidebar');
    this.priceFilter = page.locator('select[name="price-range"]');
    this.categoryFilter = page.locator('input[name="category"]');
    this.sortDropdown = page.locator('select[name="sort"]');
    this.productCards = page.locator('.product-card');
    this.paginationNext = page.locator('button[aria-label="Next page"]');
    this.paginationPrevious = page.locator('button[aria-label="Previous page"]');
    this.resultsCount = page.locator('.results-count');
  }

  async searchForProduct(query: string) {
    await this.searchInput.fill(query);
    await this.searchButton.click();
    await this.page.waitForLoadState('networkidle');
  }

  async applyPriceFilter(range: string) {
    await this.priceFilter.selectOption(range);
    await this.page.waitForSelector('.product-card');
  }

  async filterByCategory(category: string) {
    await this.categoryFilter.click();
    await this.page.locator(`text=${category}`).click();
  }

  async sortBy(option: 'price-asc' | 'price-desc' | 'rating' | 'newest') {
    await this.sortDropdown.selectOption(option);
    await this.page.waitForLoadState('networkidle');
  }

  async getProductCount(): Promise<number> {
    return await this.productCards.count();
  }

  async goToNextPage() {
    await this.paginationNext.click();
    await this.page.waitForLoadState('networkidle');
  }

  async getResultsCountText(): Promise<string> {
    return await this.resultsCount.textContent() || '';
  }
}

# Create pytest test suite for REST API testing user management endpoints
# GET /users, POST /users, PUT /users/{id}, DELETE /users/{id}

import pytest
import requests
from typing import Dict, Any

BASE_URL = "https://api.example.com/v1"
HEADERS = {"Content-Type": "application/json"}

class TestUserManagementAPI:

    @pytest.fixture
    def auth_token(self) -> str:
        """Fixture to get authentication token"""
        response = requests.post(
            f"{BASE_URL}/auth/login",
            json={"username": "testuser", "password": "testpass"},
            headers=HEADERS
        )
        return response.json()["token"]

    @pytest.fixture
    def test_user_data(self) -> Dict[str, Any]:
        """Fixture providing test user data"""
        return {
            "username": "newuser",
            "email": "newuser@example.com",
            "firstName": "Test",
            "lastName": "User"
        }

    def test_get_all_users(self, auth_token: str):
        """Test retrieving all users"""
        response = requests.get(
            f"{BASE_URL}/users",
            headers={**HEADERS, "Authorization": f"Bearer {auth_token}"}
        )

        assert response.status_code == 200
        assert isinstance(response.json(), list)
        assert len(response.json()) > 0
        assert "username" in response.json()[0]

    def test_create_user(self, auth_token: str, test_user_data: Dict[str, Any]):
        """Test creating a new user"""
        response = requests.post(
            f"{BASE_URL}/users",
            json=test_user_data,
            headers={**HEADERS, "Authorization": f"Bearer {auth_token}"}
        )

        assert response.status_code == 201
        created_user = response.json()
        assert created_user["username"] == test_user_data["username"]
        assert created_user["email"] == test_user_data["email"]
        assert "id" in created_user

        return created_user["id"]

    def test_update_user(self, auth_token: str):
        """Test updating existing user"""
        user_id = 1  # Assuming test user with ID 1 exists
        update_data = {"firstName": "Updated", "lastName": "Name"}

        response = requests.put(
            f"{BASE_URL}/users/{user_id}",
            json=update_data,
            headers={**HEADERS, "Authorization": f"Bearer {auth_token}"}
        )

        assert response.status_code == 200
        updated_user = response.json()
        assert updated_user["firstName"] == update_data["firstName"]
        assert updated_user["lastName"] == update_data["lastName"]

    def test_delete_user(self, auth_token: str):
        """Test deleting a user"""
        # First create a user to delete
        test_user = {
            "username": "delete_test_user",
            "email": "delete@example.com",
            "firstName": "Delete",
            "lastName": "Test"
        }

        create_response = requests.post(
            f"{BASE_URL}/users",
            json=test_user,
            headers={**HEADERS, "Authorization": f"Bearer {auth_token}"}
        )
        user_id = create_response.json()["id"]

        # Now delete the user
        delete_response = requests.delete(
            f"{BASE_URL}/users/{user_id}",
            headers={**HEADERS, "Authorization": f"Bearer {auth_token}"}
        )

        assert delete_response.status_code == 204

        # Verify user is deleted
        get_response = requests.get(
            f"{BASE_URL}/users/{user_id}",
            headers={**HEADERS, "Authorization": f"Bearer {auth_token}"}
        )
        assert get_response.status_code == 404

    def test_create_user_validation(self, auth_token: str):
        """Test user creation with invalid data"""
        invalid_data = {"username": ""}  # Missing required fields

        response = requests.post(
            f"{BASE_URL}/users",
            json=invalid_data,
            headers={**HEADERS, "Authorization": f"Bearer {auth_token}"}
        )

        assert response.status_code == 400
        assert "error" in response.json()

// test login

// Test login functionality with valid credentials, verify redirect to dashboard,
// check user profile displays correctly, and session token is stored

# Paso 1: Estructura básica
# Create test for multi-step checkout process

# Paso 2: Agregar detalles
# Include cart validation, shipping address form, payment processing,
# and order confirmation verification

# Paso 3: Refinar
# Add error scenarios: expired card, insufficient inventory, invalid promo code

# Configure pytest with pytest-xdist for parallel execution on 4 CPUs
# with separate browser instances and shared test data fixture

import pytest
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
import multiprocessing

@pytest.fixture(scope="session")
def shared_test_data():
    """Shared test data across all workers"""
    return {
        "base_url": "https://staging.example.com",
        "test_users": [
            {"username": f"testuser{i}@example.com", "password": "Test1234!"}
            for i in range(10)
        ]
    }

@pytest.fixture(scope="function")
def driver(worker_id):
    """Create separate browser instance for each test"""
    chrome_options = Options()
    chrome_options.add_argument("--headless")
    chrome_options.add_argument("--no-sandbox")
    chrome_options.add_argument("--disable-dev-shm-usage")

    # Assign different ports for each worker to avoid conflicts
    if worker_id != "master":
        port = 9515 + int(worker_id.replace("gw", ""))
        chrome_options.add_argument(f"--remote-debugging-port={port}")

    driver = webdriver.Chrome(options=chrome_options)
    driver.implicitly_wait(10)

    yield driver

    driver.quit()

def pytest_configure(config):
    """Configure pytest for parallel execution"""
    if config.option.numprocesses is None:
        config.option.numprocesses = multiprocessing.cpu_count()

Usuario: "Crea una prueba que verifique el proceso de checkout con código de descuento"

Copilot: [Genera prueba completa con:
- Selección de producto
- Validación de carrito
- Aplicación de cupón
- Verificación de cálculo de precio
- Completado de formulario de pago
- Verificación de confirmación de pedido]