Phase 7: Testing, Quality & Professionalism

import pytest
from myapp.models import Task, TaskManager

# ── Basic fixture — setup only ──
@pytest.fixture
def sample_task():
    return Task(title="Write tests", priority=3)

# ── Fixture with teardown — use yield ──
@pytest.fixture
def task_manager(tmp_path):
    # tmp_path is a built-in pytest fixture — gives a temp directory
    db_file = tmp_path / "test_tasks.json"
    manager = TaskManager(filepath=str(db_file))
    yield manager         # everything above = setup
    db_file.unlink(missing_ok=True)  # everything below = teardown (always runs)

# ── Fixture using another fixture ──
@pytest.fixture
def manager_with_tasks(task_manager):
    task_manager.add("Task A", priority=1)
    task_manager.add("Task B", priority=5)
    task_manager.add("Task C", priority=3, due="2026-01-01")
    return task_manager

# ── Tests request fixtures by name ──
def test_task_creation(sample_task):
    assert sample_task.title == "Write tests"
    assert sample_task.priority == 3
    assert sample_task.done == False

def test_pending_count(manager_with_tasks):
    pending = list(manager_with_tasks.pending())
    assert len(pending) == 3

def test_sorted_by_priority(manager_with_tasks):
    pending = list(manager_with_tasks.pending())
    assert pending[0].priority == 5   # highest first

@pytest.fixture(scope="session")
def anthropic_client():
    """Created once for the whole test run — expensive import."""
    import anthropic
    return anthropic.Anthropic()
    # No teardown needed — client has no cleanup

@pytest.fixture(scope="session")
def test_database():
    """In-memory DB — created once, shared across all tests."""
    from sqlmodel import create_engine, SQLModel
    engine = create_engine("sqlite://")
    SQLModel.metadata.create_all(engine)
    yield engine
    SQLModel.metadata.drop_all(engine)

@pytest.fixture          # function scope — fresh session per test
def db_session(test_database):
    from sqlmodel import Session
    with Session(test_database) as session:
        yield session
        session.rollback()   # undo every change after each test

from unittest.mock import Mock, MagicMock, patch, call

# ── Mock — a fake object that records calls ──
mock = Mock()
mock.some_method("arg1", key="val")

# Inspect what happened
print(mock.some_method.call_count)          # 1
mock.some_method.assert_called_once_with("arg1", key="val")
mock.some_method.assert_called_with("arg1", key="val")

# Configure return values
mock.get_user.return_value = {"id": 1, "name": "Jude"}
result = mock.get_user(1)
assert result["name"] == "Jude"

# Configure to raise an exception
mock.dangerous_call.side_effect = ConnectionError("Network down")
with pytest.raises(ConnectionError):
    mock.dangerous_call()

from unittest.mock import patch, MagicMock
import pytest

# The code under test (in weather.py):
# import requests
# def get_weather(city): return requests.get(...).json()

# ── patch as decorator ──
@patch("weather.requests.get")   # patch in the module that USES it
def test_get_weather_success(mock_get):
    # Configure what the mock returns
    mock_response = MagicMock()
    mock_response.json.return_value = {
        "current": {"temperature_2m": 28.5, "wind_speed_10m": 12.0}
    }
    mock_get.return_value = mock_response

    from weather import get_weather
    result = get_weather("Bossier City")

    assert result["temp_c"] == 28.5
    mock_get.assert_called_once()   # verify it was called

# ── patch as context manager ──
def test_get_weather_timeout():
    with patch("weather.requests.get") as mock_get:
        mock_get.side_effect = TimeoutError()
        from weather import get_weather
        with pytest.raises(TimeoutError):
            get_weather("Bossier City")

# ── patch as fixture (pytest style — cleaner) ──
@pytest.fixture
def mock_requests(monkeypatch):
    mock_response = MagicMock()
    mock_response.json.return_value = {"data": "test"}
    mock_response.status_code = 200
    monkeypatch.setattr("requests.get", MagicMock(return_value=mock_response))
    return mock_response

from unittest.mock import patch
from datetime      import datetime

# ── Freeze time — test time-sensitive code reliably ──
@patch("myapp.tasks.datetime")
def test_task_created_today(mock_dt):
    mock_dt.now.return_value = datetime(2026, 6, 15)
    task = create_task("Test")
    assert task.created_date == "2026-06-15"

# ── Patch environment variables ──
def test_api_key_missing(monkeypatch):
    monkeypatch.delenv("OPENAI_API_KEY", raising=False)
    with pytest.raises(RuntimeError, match="OPENAI_API_KEY"):
        from myapp.config import get_settings
        get_settings()

def test_with_test_api_key(monkeypatch):
    monkeypatch.setenv("OPENAI_API_KEY", "test-key-123")
    from myapp.config import get_settings
    settings = get_settings()
    assert settings.openai_api_key == "test-key-123"

import pytest
from myapp.models import Task

# ── Basic parametrize — one argument ──
@pytest.mark.parametrize("priority", [1, 2, 3, 4, 5])
def test_valid_priorities(priority):
    task = Task(title="Test", priority=priority)
    assert task.priority == priority

# ── Parametrize — multiple arguments ──
@pytest.mark.parametrize("title, priority, expect_error", [
    ("Valid title",  3, False),   # normal case
    ("",             3, True),    # empty title
    ("Valid",        0, True),    # priority too low
    ("Valid",        6, True),    # priority too high
    ("   ",          3, True),    # whitespace only title
    ("A" * 201,     3, True),    # title too long
])
def test_task_validation(title, priority, expect_error):
    if expect_error:
        with pytest.raises(ValueError):
            Task(title=title, priority=priority)
    else:
        task = Task(title=title, priority=priority)
        assert task.priority == priority

# ── Parametrize with pytest.param — add IDs and marks ──
@pytest.mark.parametrize("email, valid", [
    pytest.param("jude@example.com", True,  id="valid_email"),
    pytest.param("not-an-email",     False, id="missing_at"),
    pytest.param("@nodomain",        False, id="missing_local"),
    pytest.param("a@b.c",            True,  id="minimal_valid"),
    pytest.param("",                 False, id="empty"),
])
def test_email_validation(email, valid):
    from myapp.utils import is_valid_email
    assert is_valid_email(email) == valid

pip install pytest-cov

# Run tests with coverage report
pytest --cov=myapp --cov-report=term-missing

# Output:
---------- coverage: platform win32 ----------
Name                  Stmts   Miss  Cover   Missing
-----------------------------------------------------
myapp/__init__.py         0      0   100%
myapp/models.py          45      3    93%   78-80
myapp/services.py        62      8    87%   34, 55-60, 89
myapp/auth.py            38     12    68%   45-52, 67-70
-----------------------------------------------------
TOTAL                   145     23    84%

# Generate HTML report (browsable)
pytest --cov=myapp --cov-report=html
# Open htmlcov/index.html — click each file to see line-by-line coverage

# Fail if coverage drops below threshold
pytest --cov=myapp --cov-fail-under=80

from typing import Optional

def get_task_title(task_id: int) -> str:
    task = db.get(task_id)   # returns Optional[Task]
    return task.title          # mypy ERROR: task could be None!
                                # Tests might not catch this if db.get() always returns a value

# Fix:
def get_task_title(task_id: int) -> Optional[str]:
    task = db.get(task_id)
    return task.title if task else None


# ── mypy catches wrong argument types ──
def set_priority(task_id: int, priority: int) -> None:
    pass

set_priority("42", 3)   # mypy ERROR: Argument 1 has type "str", expected "int"

# ── mypy catches unreachable code ──
def process(items: list[str]) -> str:
    if not items:
        return ""
    return items[0]
    return "unreachable"   # mypy: Statement is unreachable

pip install mypy

# Basic check
mypy myapp/

# Strict mode — catches more issues, requires full annotations
mypy --strict myapp/

# Check a single file
mypy myapp/models.py

[tool.mypy]
python_version = "3.12"
strict          = true     # enables all strict checks
warn_return_any = true
warn_unused_ignores = true

# Ignore third-party libraries with no stubs
[[tool.mypy.overrides]]
module = ["anthropic.*", "bs4.*"]
ignore_missing_imports = true

pip install ruff

# Check for issues
ruff check .

# Fix auto-fixable issues (import sorting, unused imports, etc.)
ruff check --fix .

# Format code (like black)
ruff format .

# Check + format in one command
ruff check --fix . && ruff format .

# Check a single file
ruff check myapp/models.py

# Show all available rules
ruff rule --all

[tool.ruff]
line-length    = 100
target-version = "py312"

[tool.ruff.lint]
select = [
    "E",    # pycodestyle errors
    "F",    # pyflakes (undefined names, unused imports)
    "I",    # isort (import sorting)
    "UP",   # pyupgrade (use f-strings, newer syntax)
    "B",    # bugbear (common bugs and design issues)
    "SIM",  # simplify (simplifiable conditions)
    "N",    # pep8-naming conventions
]
ignore = [
    "E501",  # line too long — handled by formatter
]

[tool.ruff.lint.per-file-ignores]
"tests/*" = ["S101"]  # allow assert in tests

# F401 — imported but unused
import os, sys, json   # ruff: 'os' imported but unused

# F841 — assigned but never used
result = expensive_call()   # ruff: local variable 'result' is assigned but never used

# UP — use f-strings instead of format()
name = "Jude"
"Hello, {}".format(name)   # ruff UP032: use f-string
f"Hello, {name}"           # correct

# B — common bugs
def append_to(item, lst=[]):  # ruff B006: mutable default argument!
    lst.append(item)
    return lst

# SIM — simplifiable conditions
if x == True:   # ruff SIM210: use 'if x:'
    pass

if not x == None:  # ruff SIM201: use 'if x is not None:'
    pass

# E711 — comparison to None
if x == None:   # ruff E711: use 'is None'
    pass

repos:
  # ── Ruff: lint and format ──
  - repo: https://github.com/astral-sh/ruff-pre-commit
    rev: v0.4.0
    hooks:
      - id: ruff
        args: [--fix]         # auto-fix what can be auto-fixed
      - id: ruff-format       # format like black

  # ── Basic file hygiene ──
  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v4.6.0
    hooks:
      - id: trailing-whitespace     # remove trailing spaces
      - id: end-of-file-fixer       # ensure files end with newline
      - id: check-yaml              # validate YAML syntax
      - id: check-toml              # validate TOML syntax
      - id: check-json              # validate JSON syntax
      - id: check-merge-conflict    # catch unresolved merge conflicts
      - id: debug-statements        # catch leftover breakpoint()/pdb.set_trace()
      - id: detect-private-key      # !! catch accidentally committed secrets

  # ── mypy: type checking ──
  - repo: https://github.com/pre-commit/mirrors-mypy
    rev: v1.10.0
    hooks:
      - id: mypy
        additional_dependencies: [pydantic, sqlmodel]

# Skip ALL hooks (emergency commit — use sparingly)
git commit --no-verify -m "Emergency fix"

# Skip a specific hook
SKIP=mypy git commit -m "WIP — types to fix later"

# Run just one hook manually
pre-commit run ruff
pre-commit run mypy --all-files

# Update all hooks to latest versions
pre-commit autoupdate

import cProfile, pstats, io

# ── Profile a function ──
def profile(func, *args, **kwargs):
    pr = cProfile.Profile()
    pr.enable()
    result = func(*args, **kwargs)
    pr.disable()

    s      = io.StringIO()
    stats  = pstats.Stats(pr, stream=s).sort_stats("cumulative")
    stats.print_stats(20)   # top 20 functions by cumulative time
    print(s.getvalue())
    return result

profile(build_index, documents)

# ── Command line profiling ──
# python -m cProfile -s cumulative myscript.py

# ── Profile output explanation ──
   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
       1    0.001    0.001    4.523    4.523  main.py:12(build_index)
     500    0.012    0.000    4.510    0.009  rag.py:28(get_embedding)
     500    3.891    0.008    4.498    0.009  openai/resources.py:...
       1    0.000    0.000    0.012    0.012  rag.py:45(chunk_text)

# ncalls   = how many times called
# tottime  = time IN this function only
# cumtime  = total time including called functions ← sort by this

pip install line_profiler

from line_profiler import LineProfiler

def slow_function(items: list) -> list:
    results = []
    for item in items:
        processed = expensive_transform(item)  # ← is this the slow part?
        if passes_filter(processed):            # ← or this?
            results.append(processed)
    return results

profiler = LineProfiler()
profiler.add_function(slow_function)
profiler.run("slow_function(data)")
profiler.print_stats()

# Output shows time per line:
Line #   Hits    Time   Per Hit  % Time  Line Contents
    4    1000    234      0.2      2%     processed = expensive_transform(item)
    5    1000   9834      9.8     98%     if passes_filter(processed):       ← HERE
# passes_filter is the bottleneck — optimize that, not the transform

import timeit

# Compare two approaches
list_approach = timeit.timeit(
    "[x**2 for x in range(1000)]",
    number=10000
)
map_approach = timeit.timeit(
    "list(map(lambda x: x**2, range(1000)))",
    number=10000
)
print(f"List comp: {list_approach:.3f}s")
print(f"map():     {map_approach:.3f}s")

# In Jupyter / IPython: use %timeit magic
# %timeit [x**2 for x in range(1000)]

# ── Level 1: One-liner — for obvious functions ──
def is_overdue(due: date) -> bool:
    """Return True if the due date is before today."""
    return due < date.today()


# ── Level 2: Multi-line — for non-obvious functions ──
def chunk_text(text: str, chunk_size: int = 500, overlap: int = 50) -> list[str]:
    """Split text into overlapping chunks for RAG indexing.

    Chunks overlap to preserve context at boundaries — a sentence
    split across two chunks will appear in both.

    Args:
        text: The input text to split.
        chunk_size: Approximate number of words per chunk.
        overlap: Number of words to repeat between adjacent chunks.

    Returns:
        List of text chunks. Empty list if text is empty.

    Example:
        >>> chunks = chunk_text("one two three", chunk_size=2, overlap=1)
        >>> chunks
        ['one two', 'two three']
    """
    if not text.strip(): return []
    # ... implementation


# ── Level 3: Class docstring — describe purpose and usage ──
class TaskManager:
    """Manages a persistent collection of tasks.

    Tasks are stored as JSON at the given filepath. All operations
    are immediately persisted to disk. Thread-safety is not guaranteed.

    Attributes:
        filepath: Path to the JSON storage file.

    Example:
        >>> mgr = TaskManager("tasks.json")
        >>> task = mgr.add("Write tests", priority=3)
        >>> list(mgr.pending())
        [Task(title='Write tests', priority=3, done=False)]
    """

# Project Name

One sentence. What does this do and who is it for?

## Features
- Feature 1 — described from the user's perspective
- Feature 2
- Feature 3

## Quick Start
```bash
git clone https://github.com/you/project
cd project
python -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
cp .env.example .env  # fill in your keys
python main.py
```

## Usage
Show a real, copy-pasteable example. Not "use --help".
```bash
python cli.py add "Write tests" --priority 4
python cli.py list
python cli.py ai ask "what's due this week?"
```

## Configuration
| Variable | Required | Description |
|---|---|---|
| OPENAI_API_KEY | Yes | Your OpenAI API key |
| DATABASE_URL | No | Defaults to SQLite |

## Development
```bash
pip install -r requirements-dev.txt
pre-commit install
pytest
```

## License
MIT