conftest.py

"""
Pytest Configuration and Fixtures
Professional setup with screenshot capture, Allure integration, and optimized performance
Incorporates enterprise-level best practices
"""

import pytest
import logging
import allure
from pathlib import Path
from datetime import datetime
from utils.browser_factory import BrowserFactory

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)


def pytest_addoption(parser):
    """Add custom command line options"""
    parser.addoption(
        "--browser",
        action="store",
        default="chrome",
        help="Browser to run tests on: chrome, firefox, or edge"
    )
    parser.addoption(
        "--headless",
        action="store_true",
        default=False,
        help="Run tests in headless mode"
    )


@pytest.fixture(scope='class')
def driver(request):
    """
    WebDriver fixture with class scope for optimal performance.
    Creates one driver instance per test class.
    Includes automatic screenshot capture on test failure.
    
    This fixture also assigns the driver to the test class for 
    Page Object Model pattern (accessible via self.driver).
    
    Args:
        request: Pytest request object
        
    Yields:
        WebDriver: Configured browser driver instance
    """
    browser_name = request.config.getoption("--browser")
    factory = BrowserFactory()
    driver = factory.create_driver(browser_name)
    
    # Get context name safely (handles both class and function scoped tests)
    test_context = request.cls.__name__ if request.cls else "function_tests"
    logger.info(f"Driver created for {test_context}")
    
    # Assign driver to test class for POM pattern (e.g., self.driver)
    if request.cls:
        request.cls.driver = driver
    
    yield driver
    
    # Teardown: quit driver after all tests in class
    logger.info(f"Closing driver for {test_context}")
    driver.quit()


@pytest.hookimpl(tryfirst=True, hookwrapper=True)
def pytest_runtest_makereport(item, call):
    """
    Pytest hook to capture screenshots on test failure.
    Attaches screenshot and page source to Allure report automatically.
    Works with any WebDriver fixture name by detecting screenshot capability.
    """
    outcome = yield
    report = outcome.get_result()
    
    # Only capture screenshot on test failure during test execution
    if report.when == 'call' and report.failed:
        # Find driver in test arguments (supports any fixture name with screenshot capability)
        driver = None
        for fixture_value in item.funcargs.values():
            if hasattr(fixture_value, 'save_screenshot'):
                driver = fixture_value
                break
        
        if driver:
            # Create screenshots directory if not exists
            screenshot_dir = Path("reports/screenshots")
            screenshot_dir.mkdir(parents=True, exist_ok=True)
            
            # Generate unique filename
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            test_name = item.name
            screenshot_path = screenshot_dir / f"{test_name}_{timestamp}.png"
            
            try:
                # Capture and save screenshot to file (for local debugging)
                driver.save_screenshot(str(screenshot_path))
                logger.info(f"Screenshot saved: {screenshot_path}")
                
                # Attach screenshot to Allure report (for CI/CD)
                allure.attach(
                    driver.get_screenshot_as_png(),
                    name=f"Failure_{test_name}",
                    attachment_type=allure.attachment_type.PNG
                )
                
                # Attach page source for debugging
                allure.attach(
                    driver.page_source,
                    name=f"Page_Source_{test_name}",
                    attachment_type=allure.attachment_type.HTML
                )
                
                # Attach browser console logs if available (Chrome only)
                try:
                    if driver.capabilities.get('browserName') == 'chrome':
                        console_logs = driver.get_log('browser')
                        if console_logs:
                            log_text = "\n".join([f"{log['level']}: {log['message']}" for log in console_logs])
                            allure.attach(
                                log_text,
                                name=f"Console_Logs_{test_name}",
                                attachment_type=allure.attachment_type.TEXT
                            )
                except Exception:
                    pass  # Browser logs not critical
                
            except Exception as e:
                logger.error(f"Failed to capture screenshot: {e}")


def pytest_configure(config):
    """Configure pytest with custom markers"""
    config.addinivalue_line(
        "markers", "smoke: mark test as smoke test (quick validation)"
    )
    config.addinivalue_line(
        "markers", "regression: mark test as regression test (full suite)"
    )
    config.addinivalue_line(
        "markers", "user_flows: mark test as user flow test (end-to-end scenarios)"
    )
    config.addinivalue_line(
        "markers", "product: mark test as product test (product-related features)"
    )
    config.addinivalue_line(
        "markers", "ui: mark test as UI test (for conditional screenshot capture)"
    )