Recap — Test Generation, Edge Cases, Fixture Design

# Test Generation, Edge Cases, Fixture Design AI is exceptionally good at writing tests. The function or class is essentially a spec; tests verify the spec. This is one of the easiest 10x wins from AI coding. ## The basic pattern ``` [code that needs tests] ↓ AI generates test functions ↓ You review; add edge cases AI missed ↓ Run tests; verify they pass on existing code ↓ Commit ``` ## Good test-generation prompt > "Generate pytest tests for the function below. Cover: > 1. Happy path (typical valid input). > 2. Edge cases: empty input, None, oversized data. > 3. Error cases: invalid types, out-of-range values. > Use fixtures where appropriate. Test names should describe behavior." Specific. AI generates structured tests. ## Generic vs effective tests Generic: ```python def test_calculate_total(): items = [{"price": 10}, {"price": 20}] assert calculate_total(items) == 30 ``` Effective: ```python def test_calculate_total_with_normal_items(): items = [{"price": 10}, {"price": 20}] assert calculate_total(items) == 30 def test_calculate_total_with_empty_list_returns_zero(): assert calculate_total([]) == 0 def test_calculate_total_with_none_raises(): with pytest.raises(TypeError): calculate_total(None) def test_calculate_total_handles_float_prices(): items = [{"price": 9.99}, {"price": 0.01}] assert calculate_total(items) == 10.0 def test_calculate_total_with_negative_price_raises(): with pytest.raises(ValueError): calculate_total([{"price": -10}]) def test_calculate_total_with_missing_price_raises(): with pytest.raises(KeyError): calculate_total([{}]) ``` Multiple test cases, each named for behavior, covering happy + edge + error. To get effective tests, prompt for them: ask for specific categories. ## Edge cases AI commonly misses When prompting, explicitly ask for these: - **Empty input**: empty list, empty string, empty dict. - **Single element**: list of length 1, single character string. - **None**: most APIs should handle or raise on None. - **Very large input**: max-size strings, large lists. - **Boundary values**: 0, -1, MAX_INT, dates at boundaries. - **Wrong type**: pass int where str expected. - **Concurrent access** (if async): multiple concurrent calls. - **Unicode / special characters**: emoji, non-ASCII. Prompt: > "Add tests for these edge cases too: empty, single element, None, max size, boundary values, wrong types, unicode." ## Fixture design For repeated test setup, use fixtures: ```python @pytest.fixture def sample_user(): return User(id=1, name="Alice", email="alice@example.com") @pytest.fixture def db_with_orders(db, sample_user): db.add(sample_user) db.add(Order(user_id=1, total=100)) db.add(Order(user_id=1, total=200)) db.commit() return db ``` Prompt: > "Create fixtures for: a sample user; a db session with 2 sample orders. Use them in the tests." AI generates fixtures + tests that use them. Cleaner than inline setup in each test. ## Parametrize for many cases ```python @pytest.mark.parametrize("items,expected", [ ([{"price": 10}, {"price": 20}], 30), ([], 0), ([{"price": 9.99}, {"price": 0.01}], 10.0), ([{"price": 100}], 100), ]) def test_calculate_total(items, expected): assert calculate_total(items) == expected ``` One test function, many cases. Cleaner than 4 separate tests for similar things. Prompt: > "Combine the happy-path tests into a parametrized test. Keep edge cases (None, empty, error cases) as separate tests." ## Mocking external dependencies ```python def test_send_email_calls_smtp(mocker): mock_smtp = mocker.patch("my_module.smtplib.SMTP") send_email("to@example.com", "subject", "body") mock_smtp.return_value.send_message.assert_called_once() ``` Prompt: > "Add tests for send_email. Mock the SMTP library so no real email is sent. Verify the email content." AI generates tests with mocking. Critical for code with external dependencies. ## Async test generation ```python @pytest.mark.asyncio async def test_fetch_user(): user = await fetch_user(123) assert user.id == 123 ``` Prompt: > "Tests for this async function. Use pytest-asyncio. Mock the httpx client." AI generates async tests. Don't forget `@pytest.mark.asyncio`. ## Coverage analysis After tests: ```bash pytest --cov=src --cov-report=term-missing ``` Output shows uncovered lines. Feed to AI: > "These lines aren't covered by tests. Add tests that cover them." AI generates tests for the gaps. Easy way to push coverage up. ## What to test For each function: - Happy path (1-2 tests). - Edge cases (3-5 tests). - Error cases (1-3 tests). For classes: - Each public method. - State transitions (if stateful). - Invariants. For routes / endpoints: - Success response (200). - Validation errors (422). - Auth errors (401/403). - Resource not found (404). - Server errors (500) — usually via mock. ## What NOT to test - Library code (it has its own tests). -