Testing & Debugging

from unittest.mock import Mock, patch
import requests

class WeatherService:
    def get_temperature(self, city):
        response = requests.get(f"https://api.weather.com/{city}")
        return response.json()["temp"]

# Using Mock
def test_weather_service_with_mock():
    service = WeatherService()
    
    # Create a mock response
    mock_response = Mock()
    mock_response.json.return_value = {"temp": 72}
    
    # Patch requests.get to return our mock
    with patch('requests.get', return_value=mock_response) as mock_get:
        temp = service.get_temperature("Houston")
        assert temp == 72

        # Verify the API was called correctly
        mock_get.assert_called_once_with("https://api.weather.com/Houston")

# Using pytest-mock (cleaner syntax)
def test_weather_service_with_pytest_mock(mocker):
    service = WeatherService()
    
    # Stub the response
    mock_get = mocker.patch('requests.get')
    mock_get.return_value.json.return_value = {"temp": 72}
    
    temp = service.get_temperature("Houston")
    assert temp == 72

import pytest
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

# Using a test database
@pytest.fixture
def db_session():
    # Create test database
    engine = create_engine('sqlite:///:memory:')
    Base.metadata.create_all(engine)
    Session = sessionmaker(bind=engine)
    session = Session()
    
    yield session
    
    # Cleanup
    session.close()

def test_user_repository_creates_user(db_session):
    # Integration test - actually talks to database
    user = User(name="Alice", email="alice@example.com")
    db_session.add(user)
    db_session.commit()
    
    # Query it back
    result = db_session.query(User).filter_by(name="Alice").first()
    assert result is not None
    assert result.email == "alice@example.com"

def test_user_repository_with_duplicate_email_fails(db_session):
    # Test business logic + database constraints
    user1 = User(name="Alice", email="test@example.com")
    user2 = User(name="Bob", email="test@example.com")
    
    db_session.add(user1)
    db_session.commit()
    
    db_session.add(user2)
    with pytest.raises(IntegrityError):
        db_session.commit()

# API E2E Test (using pytest + requests)
def test_complete_user_signup_flow(api_client):
    # User signs up
    response = api_client.post("/api/signup", json={
        "email": "newuser@example.com",
        "password": "SecurePass123!",
        "name": "New User"
    })
    assert response.status_code == 201
    user_id = response.json()["user_id"]
    
    # User receives confirmation email (check mock email service)
    emails = get_sent_emails()
    assert len(emails) == 1
    assert "newuser@example.com" in emails[0]["to"]
    
    # User logs in
    response = api_client.post("/api/login", json={
        "email": "newuser@example.com",
        "password": "SecurePass123!"
    })
    assert response.status_code == 200
    token = response.json()["token"]
    
    # User accesses protected resource
    response = api_client.get(
        "/api/profile",
        headers={"Authorization": f"Bearer {token}"}
    )
    assert response.status_code == 200
    assert response.json()["name"] == "New User"

# Web UI E2E Test (using Selenium)
from selenium import webdriver
from selenium.webdriver.common.by import By

def test_user_can_complete_checkout(browser):
    # Navigate to product page
    browser.get("https://example.com/products/widget")
    
    # Add to cart
    add_button = browser.find_element(By.ID, "add-to-cart")
    add_button.click()
    
    # Go to checkout
    browser.get("https://example.com/checkout")
    
    # Fill in form
    browser.find_element(By.ID, "email").send_keys("buyer@example.com")
    browser.find_element(By.ID, "card-number").send_keys("4242424242424242")
    
    # Submit order
    browser.find_element(By.ID, "submit-order").click()
    
    # Verify confirmation
    confirmation = browser.find_element(By.CLASS_NAME, "order-confirmation")
    assert "Thank you" in confirmation.text

# Install coverage tool
pip install pytest-cov

# Run tests with coverage
pytest --cov=myapp --cov-report=html

# View detailed HTML report
# Coverage report saved to htmlcov/index.html

# Example output:
# Name                 Stmts   Miss  Cover
# ----------------------------------------
# myapp/__init__.py       10      0   100%
# myapp/models.py         45      3    93%
# myapp/views.py          67     12    82%
# myapp/utils.py          23      0   100%
# ----------------------------------------
# TOTAL                  145     15    90%

# Using Locust for load testing
from locust import HttpUser, task, between

class WebsiteUser(HttpUser):
    wait_time = between(1, 3)  # Wait 1-3 seconds between tasks
    
    @task(3)  # Run this task 3x more often than other tasks
    def view_products(self):
        self.client.get("/products")
    
    @task(1)
    def view_product_detail(self):
        product_id = random.randint(1, 100)
        self.client.get(f"/products/{product_id}")
    
    @task(1)
    def add_to_cart(self):
        self.client.post("/cart", json={
            "product_id": random.randint(1, 100),
            "quantity": 1
        })

# Run with: locust -f loadtest.py --host=https://example.com
# Opens web UI at http://localhost:8089 to configure users and spawn rate

# Test for SQL injection vulnerability
def test_sql_injection_prevention():
    # Malicious input attempting SQL injection
    malicious_input = "1' OR '1'='1"
    
    # Should be safely handled by parameterized queries
    result = db.execute(
        "SELECT * FROM users WHERE id = ?", 
        (malicious_input,)
    )
    
    # Should return no results, not all users
    assert result.rowcount == 0

# Test authentication
def test_requires_authentication():
    response = client.get("/api/profile")
    assert response.status_code == 401
    
    response = client.get(
        "/api/profile",
        headers={"Authorization": "Bearer invalid_token"}
    )
    assert response.status_code == 401

# Test rate limiting
def test_rate_limiting():
    # Make 100 rapid requests
    responses = [client.post("/api/login") for _ in range(100)]
    
    # Some should be rate limited
    status_codes = [r.status_code for r in responses]
    assert 429 in status_codes  # Too Many Requests

# TDD Example: Building a shopping cart

# Step 1: RED - Write failing test
def test_empty_cart_has_zero_total():
    cart = ShoppingCart()
    assert cart.total() == 0
# Result: NameError: ShoppingCart is not defined ❌

# Step 2: GREEN - Make it pass (minimal code)
class ShoppingCart:
    def total(self):
        return 0

# Run test again: PASSES ✓

# Step 3: RED - Next test
def test_cart_with_one_item():
    cart = ShoppingCart()
    cart.add_item(Item("Book", 10.00))
    assert cart.total() == 10.00
# Result: AttributeError: 'ShoppingCart' has no attribute 'add_item' ❌

# Step 4: GREEN - Make it pass
class ShoppingCart:
    def __init__(self):
        self.items = []
    
    def add_item(self, item):
        self.items.append(item)
    
    def total(self):
        return sum(item.price for item in self.items)

# Run test: PASSES ✓

# Step 5: REFACTOR - Improve without breaking tests
# (Tests stay green throughout refactoring)