Python Testing & Debugging Beyond unittest

What this site covers

This site is built for engineers who already know the basics of Python testing and now need patterns that scale. The guides focus on production-grade trade-offs: fixture design for large suites, stricter mocking contracts, coverage that means something, reproducible debugging workflows, and generated-input testing for the edges nobody enumerated. Every guide is written for real codebases — monorepos, async services, databases and message brokers, and CI pipelines that have to stay fast and green.

184 guides across six tracks, each one built around runnable code, the failure modes you will actually hit, and the diagnostics that separate a hypothesis from a fix.

Explore the six tracks

• Advanced Pytest Architecture & Configuration — scale fixtures, plugin hooks, discovery and coverage across large suites. Start with Mastering Pytest Fixtures, Advanced Parametrization Techniques, Coverage Measurement and Enforcement, and the new Assertion Introspection & Test Reporting and Test Layout & Import Modes.
• Advanced Mocking & Test Doubles in Python — tighten isolation with Autospec & Strict Mocking, Patching Strategies for Complex Codebases, Faking the Filesystem and Environment, and the new Spies, Fakes & Hand-Rolled Test Doubles and Patching Async Code & Coroutines.
• Property-Based & Fuzz Testing Strategies — go beyond examples with Hypothesis Framework Fundamentals, Advanced Property-Based Testing, Coverage-Guided Fuzzing with Atheris, and the new Designing Strategies for Domain Data and Hypothesis Integration with pytest & Frameworks.
• Systematic Debugging & Performance Profiling — diagnose failures with Interactive Debugging with pdb and ipdb, Memory Profiling with tracemalloc, Debugging Tests in CI and Containers, and the new Reading Tracebacks & Exception Chains and Logging & Observability for Debugging.
• Testing Async & Concurrent Python — a new track for coroutines, tasks and threads: pytest-asyncio in Depth, Testing with AnyIO & Trio, Testing Threads & Race Conditions, and Timeouts, Cancellation & Deadlines.
• Integration, Database & Service Testing — a new track for tests that touch real systems: Database Fixtures & Transactional Tests, Spinning Up Services with Testcontainers, Test Data Factories & Builders, and Contract Testing for HTTP APIs.

Start with the problem you have

• A test fails only in CI. Work the environment checklist in reproducing CI-only test failures locally, then capture what you need with attaching debugpy to a container.
• Collection or the suite is slow. Prune the walk in cutting collection time with norecursedirs, then parallelise safely with pytest-xdist vs pytest-parallel.
• A mock is passing for the wrong reason. Read assert_called_with vs call_args_list and lock the contract with create_autospec vs patch(autospec=True).
• A patch has no effect. Find the binding in where to patch, or the timing in patching decorators applied at import time.
• Memory grows and nobody knows why. Diff snapshots in finding memory leaks with tracemalloc snapshots, then name the retainer with finding reference cycles with gc and objgraph.
• Coverage reports zero under parallel runs. The combine step is missing — see why pytest-cov reports 0% under xdist.
• An async test hangs or flakes. Pin the loop scope in pytest-asyncio in depth, bound every wait with timeouts, cancellation and deadlines, and find the stuck await with task stacks.
• Integration tests leak data between runs. Wrap each test in a rolled-back transaction with database fixtures and transactional tests, and start real dependencies with Testcontainers.
• A test fails only after another one runs. Bisect the order with bisecting test order dependencies, or replay the worker in debugging a test that only fails under xdist.
• An async service is slow at eight percent CPU. Something is blocking the loop: finding blocking calls with asyncio debug mode.

Suggested reading order

1. Begin with the pytest architecture guides to understand fixture resolution, collection, configuration and coverage measurement.
2. Move into mocking, patching and dependency injection when you need better isolation boundaries — and into faking the filesystem and environment when tests start leaking state into each other.
3. Add property-based testing, and then coverage-guided fuzzing, once your baseline architecture is deterministic and your parsers handle untrusted input.
4. Move to the async and integration tracks when your tests cross event loops, threads, databases or network services — testing async and concurrent Python and integration, database and service testing.
5. Reach for the debugging and profiling workflows whenever a failure resists reproduction, a suite starts leaking memory and time, or a failure appears only inside CI.

Who this is for

The material assumes strong Python fundamentals and targets mid-to-senior developers, QA/SDET engineers, and maintainers who need to improve reliability, debugging speed, and CI performance. Every page states its version requirements, gives runnable code, and ends with the edge cases that break the pattern.