1# Python Testing Patterns — Advanced Reference
2 
3Advanced testing patterns including async code, monkeypatching, temporary files, conftest setup, property-based testing, database testing, CI/CD integration, and configuration.
4 
5## Pattern 6: Testing Async Code
6 
7```python
8# test_async.py
9import pytest
10import asyncio
11 
12async def fetch_data(url: str) -> dict:
13    """Fetch data asynchronously."""
14    await asyncio.sleep(0.1)
15    return {"url": url, "data": "result"}
16 
17 
18@pytest.mark.asyncio
19async def test_fetch_data():
20    """Test async function."""
21    result = await fetch_data("https://api.example.com")
22    assert result["url"] == "https://api.example.com"
23    assert "data" in result
24 
25 
26@pytest.mark.asyncio
27async def test_concurrent_fetches():
28    """Test concurrent async operations."""
29    urls = ["url1", "url2", "url3"]
30    tasks = [fetch_data(url) for url in urls]
31    results = await asyncio.gather(*tasks)
32 
33    assert len(results) == 3
34    assert all("data" in r for r in results)
35 
36 
37@pytest.fixture
38async def async_client():
39    """Async fixture."""
40    client = {"connected": True}
41    yield client
42    client["connected"] = False
43 
44 
45@pytest.mark.asyncio
46async def test_with_async_fixture(async_client):
47    """Test using async fixture."""
48    assert async_client["connected"] is True
49```
50 
51## Pattern 7: Monkeypatch for Testing
52 
53```python
54# test_environment.py
55import os
56import pytest
57 
58def get_database_url() -> str:
59    """Get database URL from environment."""
60    return os.environ.get("DATABASE_URL", "sqlite:///:memory:")
61 
62 
63def test_database_url_default():
64    """Test default database URL."""
65    # Will use actual environment variable if set
66    url = get_database_url()
67    assert url
68 
69 
70def test_database_url_custom(monkeypatch):
71    """Test custom database URL with monkeypatch."""
72    monkeypatch.setenv("DATABASE_URL", "postgresql://localhost/test")
73    assert get_database_url() == "postgresql://localhost/test"
74 
75 
76def test_database_url_not_set(monkeypatch):
77    """Test when env var is not set."""
78    monkeypatch.delenv("DATABASE_URL", raising=False)
79    assert get_database_url() == "sqlite:///:memory:"
80 
81 
82class Config:
83    """Configuration class."""
84 
85    def __init__(self):
86        self.api_key = "production-key"
87 
88    def get_api_key(self):
89        return self.api_key
90 
91 
92def test_monkeypatch_attribute(monkeypatch):
93    """Test monkeypatching object attributes."""
94    config = Config()
95    monkeypatch.setattr(config, "api_key", "test-key")
96    assert config.get_api_key() == "test-key"
97```
98 
99## Pattern 8: Temporary Files and Directories
100 
101```python
102# test_file_operations.py
103import pytest
104from pathlib import Path
105 
106def save_data(filepath: Path, data: str):
107    """Save data to file."""
108    filepath.write_text(data)
109 
110 
111def load_data(filepath: Path) -> str:
112    """Load data from file."""
113    return filepath.read_text()
114 
115 
116def test_file_operations(tmp_path):
117    """Test file operations with temporary directory."""
118    # tmp_path is a pathlib.Path object
119    test_file = tmp_path / "test_data.txt"
120 
121    # Save data
122    save_data(test_file, "Hello, World!")
123 
124    # Verify file exists
125    assert test_file.exists()
126 
127    # Load and verify data
128    data = load_data(test_file)
129    assert data == "Hello, World!"
130 
131 
132def test_multiple_files(tmp_path):
133    """Test with multiple temporary files."""
134    files = {
135        "file1.txt": "Content 1",
136        "file2.txt": "Content 2",
137        "file3.txt": "Content 3"
138    }
139 
140    for filename, content in files.items():
141        filepath = tmp_path / filename
142        save_data(filepath, content)
143 
144    # Verify all files created
145    assert len(list(tmp_path.iterdir())) == 3
146 
147    # Verify contents
148    for filename, expected_content in files.items():
149        filepath = tmp_path / filename
150        assert load_data(filepath) == expected_content
151```
152 
153## Pattern 9: Custom Fixtures and Conftest
154 
155```python
156# conftest.py
157"""Shared fixtures for all tests."""
158import pytest
159 
160@pytest.fixture(scope="session")
161def database_url():
162    """Provide database URL for all tests."""
163    return "postgresql://localhost/test_db"
164 
165 
166@pytest.fixture(autouse=True)
167def reset_database(database_url):
168    """Auto-use fixture that runs before each test."""
169    # Setup: Clear database
170    print(f"Clearing database: {database_url}")
171    yield
172    # Teardown: Clean up
173    print("Test completed")
174 
175 
176@pytest.fixture
177def sample_user():
178    """Provide sample user data."""
179    return {
180        "id": 1,
181        "name": "Test User",
182        "email": "[email protected]"
183    }
184 
185 
186@pytest.fixture
187def sample_users():
188    """Provide list of sample users."""
189    return [
190        {"id": 1, "name": "User 1"},
191        {"id": 2, "name": "User 2"},
192        {"id": 3, "name": "User 3"},
193    ]
194 
195 
196# Parametrized fixture
197@pytest.fixture(params=["sqlite", "postgresql", "mysql"])
198def db_backend(request):
199    """Fixture that runs tests with different database backends."""
200    return request.param
201 
202 
203def test_with_db_backend(db_backend):
204    """This test will run 3 times with different backends."""
205    print(f"Testing with {db_backend}")
206    assert db_backend in ["sqlite", "postgresql", "mysql"]
207```
208 
209## Pattern 10: Property-Based Testing
210 
211```python
212# test_properties.py
213from hypothesis import given, strategies as st
214import pytest
215 
216def reverse_string(s: str) -> str:
217    """Reverse a string."""
218    return s[::-1]
219 
220 
221@given(st.text())
222def test_reverse_twice_is_original(s):
223    """Property: reversing twice returns original."""
224    assert reverse_string(reverse_string(s)) == s
225 
226 
227@given(st.text())
228def test_reverse_length(s):
229    """Property: reversed string has same length."""
230    assert len(reverse_string(s)) == len(s)
231 
232 
233@given(st.integers(), st.integers())
234def test_addition_commutative(a, b):
235    """Property: addition is commutative."""
236    assert a + b == b + a
237 
238 
239@given(st.lists(st.integers()))
240def test_sorted_list_properties(lst):
241    """Property: sorted list is ordered."""
242    sorted_lst = sorted(lst)
243 
244    # Same length
245    assert len(sorted_lst) == len(lst)
246 
247    # All elements present
248    assert set(sorted_lst) == set(lst)
249 
250    # Is ordered
251    for i in range(len(sorted_lst) - 1):
252        assert sorted_lst[i] <= sorted_lst[i + 1]
253```
254 
255## Testing Database Code
256 
257```python
258# test_database_models.py
259import pytest
260from sqlalchemy import create_engine, Column, Integer, String
261from sqlalchemy.ext.declarative import declarative_base
262from sqlalchemy.orm import sessionmaker, Session
263 
264Base = declarative_base()
265 
266 
267class User(Base):
268    """User model."""
269    __tablename__ = "users"
270 
271    id = Column(Integer, primary_key=True)
272    name = Column(String(50))
273    email = Column(String(100), unique=True)
274 
275 
276@pytest.fixture(scope="function")
277def db_session() -> Session:
278    """Create in-memory database for testing."""
279    engine = create_engine("sqlite:///:memory:")
280    Base.metadata.create_all(engine)
281 
282    SessionLocal = sessionmaker(bind=engine)
283    session = SessionLocal()
284 
285    yield session
286 
287    session.close()
288 
289 
290def test_create_user(db_session):
291    """Test creating a user."""
292    user = User(name="Test User", email="[email protected]")
293    db_session.add(user)
294    db_session.commit()
295 
296    assert user.id is not None
297    assert user.name == "Test User"
298 
299 
300def test_query_user(db_session):
301    """Test querying users."""
302    user1 = User(name="User 1", email="[email protected]")
303    user2 = User(name="User 2", email="[email protected]")
304 
305    db_session.add_all([user1, user2])
306    db_session.commit()
307 
308    users = db_session.query(User).all()
309    assert len(users) == 2
310 
311 
312def test_unique_email_constraint(db_session):
313    """Test unique email constraint."""
314    from sqlalchemy.exc import IntegrityError
315 
316    user1 = User(name="User 1", email="[email protected]")
317    user2 = User(name="User 2", email="[email protected]")
318 
319    db_session.add(user1)
320    db_session.commit()
321 
322    db_session.add(user2)
323 
324    with pytest.raises(IntegrityError):
325        db_session.commit()
326```
327 
328## CI/CD Integration
329 
330```yaml
331# .github/workflows/test.yml
332name: Tests
333 
334on: [push, pull_request]
335 
336jobs:
337  test:
338    runs-on: ubuntu-latest
339 
340    strategy:
341      matrix:
342        python-version: ["3.9", "3.10", "3.11", "3.12"]
343 
344    steps:
345      - uses: actions/checkout@v3
346 
347      - name: Set up Python
348        uses: actions/setup-python@v4
349        with:
350          python-version: ${{ matrix.python-version }}
351 
352      - name: Install dependencies
353        run: |
354          pip install -e ".[dev]"
355          pip install pytest pytest-cov
356 
357      - name: Run tests
358        run: |
359          pytest --cov=myapp --cov-report=xml
360 
361      - name: Upload coverage
362        uses: codecov/codecov-action@v3
363        with:
364          file: ./coverage.xml
365```
366 
367## Configuration Files
368 
369```ini
370# pytest.ini
371[pytest]
372testpaths = tests
373python_files = test_*.py
374python_classes = Test*
375python_functions = test_*
376addopts =
377    -v
378    --strict-markers
379    --tb=short
380    --cov=myapp
381    --cov-report=term-missing
382markers =
383    slow: marks tests as slow
384    integration: marks integration tests
385    unit: marks unit tests
386    e2e: marks end-to-end tests
387```
388 
389```toml
390# pyproject.toml
391[tool.pytest.ini_options]
392testpaths = ["tests"]
393python_files = ["test_*.py"]
394addopts = [
395    "-v",
396    "--cov=myapp",
397    "--cov-report=term-missing",
398]
399 
400[tool.coverage.run]
401source = ["myapp"]
402omit = ["*/tests/*", "*/migrations/*"]
403 
404[tool.coverage.report]
405exclude_lines = [
406    "pragma: no cover",
407    "def __repr__",
408    "raise AssertionError",
409    "raise NotImplementedError",
410]
411```
412