project-root/
├── pages/            # 📄 Page classes with locators and methods
│   ├── home_page.py
│   ├── product_page.py
│   ├── cart_page.py
│   └── payment_page.py
├── tests/            # 🧪 Test files calling page objects
│   └── test_weather_shopper.py
├── factories/        # 🏭 Factory classes for object creation
│   ├── browser_factory.py
│   └── page_factory.py
├── utils/            # 🛠️ Utilities and helpers
│   ├── test_helpers.py
│   ├── logger.py
│   └── fixtures/
│       └── browser_fixtures.py
├── config/           # ⚙️ Configuration settings
│   └── config.py
├── conftest.py       # 🧩 Pytest hooks and central fixtures
├── run_tests.py      # 🏃 Script to run tests with options
├── requirements.txt  # 📦 Project dependencies
└── README.md         # 📚 Documentation

class CartPage:
    """Object representation of the Weather Shopper cart page"""
    
    # Locators centralized at the top for easy maintenance
    CART_HEADER = "h2"
    ITEMS_IN_CART = ".cart-item"
    CHECKOUT_BUTTON = "button[type='submit']"
    
    def __init__(self, page):
        self.page = page
        self.logger = logger  # Our magical logger for detailed reporting
    
    def verify_cart_not_empty(self):
        """Verify that cart has at least one item."""
        self.logger.info("Verifying cart is not empty")
        items = self.page.locator(self.ITEMS_IN_CART)
        items.first.wait_for(state="attached")
        count = items.count()
        assert count > 0, f"Cart is empty! Expected at least 1 item but found {count}"
        return count

class PageFactory:
    """Factory for creating page objects on demand."""
    
    @staticmethod
    def get_page_object(page_name, page):
        """Create the appropriate page object based on the name."""
        if page_name == "home":
            return HomePage(page)
        elif page_name == "product":
            return ProductPage(page)
        elif page_name == "cart":
            return CartPage(page)
        elif page_name == "payment":
            return PaymentPage(page)
        else:
            raise ValueError(f"Unknown page name: {page_name}")

def test_add_products_to_cart(browser_setup):
    """Test adding the least expensive products to cart."""
    page, pages = browser_setup
    
    # Navigate to appropriate product page based on temperature
    product_page = pages["home"].navigate_to_product_page()
    
    # Add two products to cart
    product_page.add_least_expensive_by_type("aloe")
    product_page.add_least_expensive_by_type("almond")
    
    # Go to cart and verify
    cart_page = product_page.go_to_cart()
    cart_page.verify_cart_not_empty()

# Enhanced helper functions for better testing experience
def verify_element_with_regex(page, selector, pattern, timeout=5000):
    """Verify element text content matches a regex pattern."""
    element = page.locator(selector).first
    element.wait_for(state="visible", timeout=timeout)
    content = element.text_content()
    
    regex = re.compile(pattern)
    assert regex.search(content), f"Text '{content}' does not match pattern '{pattern}'"
    return content

class Config:
    """Central configuration for the Weather Shopper tests."""
    
    BASE_URL = "https://weathershopper.pythonanywhere.com"
    
    # Product type mapping - centralized configuration
    PRODUCT_TYPES = {
        "moisturizers": {
            "page_title": "Moisturizers",
            "product_types": ["aloe", "almond"]
        },
        "sunscreens": {
            "page_title": "Sunscreens",
            "product_types": ["spf-50", "spf-30"]
        }
    }

@pytest.fixture
def setup(browser_type):
    """Setup fixture that launches browser and provides a page."""
    browser = BrowserFactory.get_browser(browser_type)
    
    # Create new page in the browser
    page = browser.new_page()
    
    # Yield the page to the test
    yield page
    
    # Teardown after test
    browser.close()

def main() -> int:
    """Main entry point for the script."""
    args = parse_args()
    browsers, commands = create_commands(args)
    return run_commands(browsers, commands, args.parallel)

git clone https://github.com/yourusername/weather-shopper-playwright.git
cd weather-shopper-playwright

# Create a virtual environment
python -m venv venv

# Activate it
# On Windows:
venv\Scripts\activate
# On macOS/Linux:
source venv/bin/activate

# Install project requirements
pip install -r requirements.txt

# Install all browser binaries
python -m playwright install

# Or install specific browsers
python -m playwright install chromium firefox webkit

python run_tests.py

# Run with Firefox
python run_tests.py --browser firefox

# Run with WebKit
python run_tests.py --browser webkit

python run_tests.py --headless

# Run a specific test file
python run_tests.py --test tests/test_specific_feature.py

# Run a specific test function (requires pytest format)
python run_tests.py --test "tests/test_weather_shopper.py::test_payment_workflow"

# Run tests across all browsers in parallel
python run_tests.py --browser all --parallel

# From our refactored run_tests.py
def run_commands(browsers: List[str], commands: List[List[str]], 
                parallel: bool = False) -> int:
    """Run commands in parallel or sequentially."""
    if parallel and len(browsers) > 1:
        # Parallel execution using multiprocessing
        with multiprocessing.Pool(len(browsers)) as pool:
            results = pool.map(_run_command, commands)
    else:
        # Sequential execution
        results = []
        for i, cmd in enumerate(commands):
            if len(browsers) > 1:
                print(f"\nStarting tests with {browsers[i]} browser...")
            results.append(_run_command(cmd))
    
    return max(results) if results else 1

def test_buy_moisturizers_workflow(browser_setup):
    """Test the complete moisturizer purchase workflow."""
    # 1. SETUP: Get initialized page objects from the fixture
    _, pages = browser_setup
    home_page = pages["home"]
    
    # 2. ACTION: Navigate to product page based on temperature
    product_page = home_page.navigate_to_product_page()
    
    # 3. ACTION: Add products to cart
    product_page.add_least_expensive_by_type("aloe")
    product_page.add_least_expensive_by_type("almond")
    
    # 4. ACTION: Navigate to cart
    cart_page = product_page.go_to_cart()
    
    # 5. VERIFICATION: Check cart contents
    item_count = cart_page.verify_cart_not_empty()
    assert item_count == 2, f"Expected 2 items in cart, found {item_count}"
    
    # 6. ACTION: Proceed to payment
    payment_page = cart_page.checkout()
    
    # 7. ACTION & VERIFICATION: Complete payment and verify success
    payment_page.fill_payment_form("4242424242424242", "1225", "123")
    payment_page.verify_payment_success()

class ProductPage:
    """Object representation of the product selection page."""
    
    # Locators
    PRODUCT_CARDS = ".product-card"
    PRICE_SELECTOR = ".product-price"
    ADD_BUTTON = "button"
    CART_BUTTON = "#cart"
    
    def add_least_expensive_by_type(self, product_type):
        """Add the least expensive product of a specific type to the cart."""
        products = self._find_products_by_type(product_type)
        cheapest = self._find_cheapest(products)
        self._click_add_for_product(cheapest)

@pytest.fixture(scope="session")
def browser_setup(setup):
    """
    Setup fixture for browser with logging initialization.
    Uses session scope to create a single browser instance for all tests.
    """
    # Get browser type from environment variable or default
    import os
    browser_type = os.environ.get("PYTEST_LOG_BROWSER", "chromium")
    
    # Set up logger with timestamp-based log files
    LoggerSetup.setup_logger(browser_type, session=False)
    logger.info(f"Starting test session with {browser_type} browser")
    
    # Initialize page objects and other setup
    # ...

# From browser_factory.py in the factories directory
class BrowserFactory:
    """Factory for creating and managing browser instances."""
    
    @staticmethod
    def get_browser(browser_type="chromium", headless=False):
        """Get a browser instance of the specified type."""
        if browser_type not in ["chromium", "firefox", "webkit"]:
            raise ValueError(f"Unsupported browser type: {browser_type}")
        
        playwright = sync_playwright().start()
        browser_launcher = getattr(playwright, browser_type)
        return browser_launcher.launch(headless=headless)

# From test_helpers.py
def verify_page_title(page, expected_title, exact_match=True):
    """Verify the page title matches the expected title."""
    actual_title = page.title()
    
    if exact_match:
        assert actual_title == expected_title, \
            f"Page title mismatch. Expected: '{expected_title}', Got: '{actual_title}'"
    else:
        # Use regex for partial matching
        pattern = re.compile(expected_title)
        assert pattern.search(actual_title), \
            f"Page title '{actual_title}' does not contain pattern '{expected_title}'"
    
    return actual_title

class Config:
    """Central configuration for Weather Shopper tests."""
    
    BASE_URL = "https://weathershopper.pythonanywhere.com"
    
    # Product type mapping - centralized configuration
    PRODUCT_TYPES = {
        "moisturizers": {
            "page_title": "Moisturizers",
            "product_types": ["aloe", "almond"]
        },
        "sunscreens": {
            "page_title": "Sunscreens",
            "product_types": ["spf-50", "spf-30"]
        }
    }

python run_tests.py --browser all --parallel

# When running in parallel, ensure each browser gets its own log file
if args.parallel and args.browser == 'all':
    # Use environment variable to ensure each browser gets a unique log file
    cmd = ["env", f"PYTEST_LOG_BROWSER={browser}"] + cmd

# Sample GitHub Actions workflow
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Set up Python
        uses: actions/setup-python@v2
        with:
          python-version: '3.9'
      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
          python -m playwright install
      - name: Run tests
        run: python run_tests.py --browser all --parallel --headless

# Setting up browser-specific log files
LoggerSetup.setup_logger(browser_type, session=False)
logger.info(f"Starting test with {browser_type}")

def test_new_feature(browser_setup):
    _, pages = browser_setup
    home_page = pages["home"]
    # Continue with test steps...

# In pages/new_feature_page.py
class NewFeaturePage:
    def __init__(self, page):
        self.page = page
        
    # Add methods and locators...

# In factories/page_factory.py
elif page_name == "new_feature":
    return NewFeaturePage(page)

python run_tests.py --browser all --parallel --headless