Testing Ecosystem

Test Doubles and Test Data

Learn to isolate the unit under test from its collaborators with test doubles (dummy, stub, spy, mock, fake), and to handle test data without drowning in setup. This guide continues the Reservo case right where the fundamentals guide left off: now booking and canceling touch the outside world through a `BookingService` that orchestrates four collaborators — a `Clock` for the time, a `PaymentGateway` to charge and refund, an `EmailSender` to confirm, and a `BookingRepository` to persist. That's exactly where doubles become necessary: you can't test against a real payment service on every run. You'll learn the precise vocabulary from Meszaros's taxonomy, how to stub what goes IN to the unit, how to verify with mocks and spies what comes OUT, how to build a fake that actually works, and how to spot "mock hell," where tests get coupled to implementation. It closes with the Builder pattern for test data that reads by intent, and a final project where you choose and justify the right double for each collaborator of the `BookingService`.

64 lecciones

Testing Backend Applications Guide

Learn backend testing end to end: pytest fundamentals, fixtures, mocking with unittest.mock and pytest-mock, integration testing with test databases and factories, E2E testing with the FastAPI TestClient, coverage with pytest-cov, the TDD workflow, and CI with GitHub Actions. Build a production-grade test suite with 80%+ coverage.

48 lecciones

E2E Testing with Playwright

Learn end-to-end (E2E) testing through the browser with Playwright, in its Python flavor (`pytest-playwright`). E2E sits at the tip of the test pyramid: few tests, more expensive to run, but they test the WHOLE system the way a real user would. Working on a minimal Reservo page (pick a room, tier, and hours, get a quote, book, and see the confirmation), you'll practice user-centric locators (`get_by_role`, `get_by_label`, `get_by_test_id`) instead of brittle CSS/XPath selectors, actions with auto-waiting, and web-first assertions with `expect()` that automatically retry up to a timeout — the technique that kills flakiness at the root, with not a single fixed `sleep`. You'll cover how to structure a suite with the `page` fixture, `conftest.py`, and per-test browser context isolation, how to handle real-world UI (dialogs, navigation, file uploads), and how to debug with the trace viewer and UI mode before running everything in CI. It closes with a final project: the complete E2E suite for Reservo's booking flow, with edge cases and the CI pipeline.

64 lecciones

Performance and Load Testing with k6

Learn the difference between "does it work?" and "does it hold up under load?" with performance and load testing using k6, the industry-standard tool. You'll cover the test types (smoke, load, stress, spike, soak), the anatomy of a k6 script and its VU (virtual user) model, the metrics that actually matter (p95/p99 latency, throughput/RPS, error rate — and why the average lies), load profiles with `stages`, and thresholds: limits that make a test PASS or FAIL automatically, like a performance quality gate. The case study is a Reservo API (`GET /rooms`, `POST /quote`, `POST /book`) running locally: since k6 isn't installed in this guide's environment, its scripts and output are shown as clearly labeled content verified against the official docs, while the real metrics (p95, RPS, error rate) are actually computed with a Python load generator hitting the API. It closes with a final project: a complete smoke → load → stress load test, with thresholds, business-flow checks (quote → book), and the CI pipeline.

64 lecciones

Test Failure Diagnosis

Learn to diagnose why a test fails — the skill no "how to write tests" guide covers. A red test is information, not an enemy: this guide teaches you the scientific method of debugging (hypothesis → experiment) applied to pytest failures, starting with reading a failure report without drowning (the traceback, assert-rewriting, `--showlocals`, `--tb=short/long/line`) and isolating a failure down to its minimal reproduction. From there you move into the interactive debugger with `pytest --pdb` and the core `pdb` commands, learn to diagnose flaky tests (that sometimes pass, sometimes don't) and tests with order dependence or shared state, and close with binary search: using `git bisect` to find exactly which commit broke a test. All the hands-on material is Reservo test suites with deliberately planted failures of different kinds, which you learn to diagnose one by one. The final project hands you a broken suite with several failures of different types and asks for a complete diagnosis log — symptom, hypothesis, experiment, cause, and fix — for each one.

64 lecciones

Test Automation Framework Architecture

Learn to move from "loose test scripts" to a maintainable test automation framework with pytest. This guide covers fixture architecture as the backbone of the framework, the `conftest.py` hierarchy, how to organize the suite into layers (unit/integration) or by feature, custom markers and configuration (`pytest.ini`/`pyproject.toml`) as the framework's contract, a shared utilities and assertions library instead of copy-paste, how to extend pytest with custom plugins and hooks, and data and environment architecture that keeps the framework portable between local and CI. It closes with a capstone project: design and build a real test framework for Reservo, with shared fixtures, markers, a helper library, and per-environment configuration.

64 lecciones

Reviewing AI-Generated Tests

Develop the judgment to critically review tests written by an AI (Copilot, Claude, Cursor, and similar tools). AI generates tests fast and plausibly, but they can be tautological (they always pass, they prove nothing), test the implementation instead of the behavior, forget edge and error cases, have weak assertions that produce false greens, or use unrealistic data and misleading names. This guide teaches how to spot each of these defects, apply a systematic review checklist, and decide, with judgment, which test is trustworthy, which needs strengthening, and which needs rewriting. It closes with a capstone project: review a Reservo suite that was "generated by AI" with defects of several types, mark each one with its category, fix it, and deliver a review report along with the corrected suite.

64 lecciones

Contract and Integration Testing

Learn two disciplines that pick up right where unit tests with doubles leave off: contract testing (verifying that two components that talk to each other agree on their contract, consumer/provider) and integration testing (verifying that components actually work TOGETHER, crossing the seam, against real resources). The thread running through it: a green unit test can hide a broken integration, because the double was lying. Working on the Reservo case extended with a real SQLite-backed `BookingRepository` (alongside the familiar fake), you'll practice writing a consumer-driven contract test that runs the same battery against the fake and against the real implementation, verifying the contract from both sides (consumer and provider), and writing integration tests that cross the system's real boundaries — a SQLite transaction, a file, a minimal HTTP boundary — deciding what to keep real and what to double. It closes with data isolation in integration testing (transaction rollback, temporary resources) and a final project that combines a contract verified against both implementations with a full integration test of the `BookingService`.

64 lecciones

Property-Based and Advanced Testing

Learn property-based testing with Hypothesis: instead of writing tests for the examples you thought of, you define a property (an invariant) that must hold for EVERY input, and let Hypothesis generate and search for the case that breaks it. This guide covers your first test with `@given` and basic strategies, how to describe the input space with composite strategies (`@st.composite`), the patterns for finding properties (invariant, round-trip, oracle, metamorphic, idempotence), shrinking (how Hypothesis reduces a failing case to the minimal example), stateful property-based testing with `RuleBasedStateMachine`, and a set of additional advanced techniques (parametrized fixtures, a taste of mutation testing, fuzzing). It closes with a capstone project: find and fix a real Reservo bug using property-based testing.

64 lecciones

Testing in CI/CD

Learn to run your test suite automatically on every change with continuous integration. This guide covers what a pipeline is, how to write your first GitHub Actions workflow that runs pytest on every push, how to reproduce a failure that only shows up in CI locally (the environment gap, pinned dependencies), the matrix of Python versions and operating systems, how to speed up the suite with dependency caching and parallelism (`pytest-xdist`), quality gates (coverage thresholds that break the build), and what to do with flaky tests that only fail in CI. It closes with a capstone project: build a complete CI pipeline for Reservo with a version matrix, a coverage gate, caching, and parallelism, delivering the YAML workflow along with the local-parity setup.

64 lecciones

Test Strategy and Quality Engineering

You can't test everything, so the real question is what to test, at what level, and how much. This guide teaches how to decide a project's test strategy and the foundations of quality engineering: quality as a discipline for the whole team, not just whoever writes tests. It covers the test pyramid and its critiques (the ice-cream-cone anti-pattern, the testing trophy alternative), risk-based testing (prioritizing by impact × probability), when a test isn't worth it and should be deleted, quality metrics beyond coverage (mutation score, flaky rate, defect escape rate), the flaky budget and suite health, and quality as a team discipline (shift-left, reviewing tests, the definition of "done"). It crowns the Testing guide ecosystem: it closes with a capstone project where you write the complete test strategy document for Reservo, backed by measured evidence.

64 lecciones

Docker Essentials Guide

Master Docker for AI applications: build optimized images, containerize FastAPI + LLM apps, orchestrate multi-service stacks with Docker Compose (API + ChromaDB + Redis), and apply production best practices including multi-stage builds, secrets management, and health checks. Your gateway to production deployment.

64 lecciones

Monitoring & Observability Guide

Master the observability of AI systems in production with OpenTelemetry, the industry standard for 2026. Learn to instrument LLM applications with traces for prompts, embeddings, and tool calls, build dashboards for latency and cost, design alerting strategies, implement AI-specific monitoring (prompt quality, token usage, model drift), and debug production issues like hallucinations and cost spikes. Integrates with LangSmith and monitoring backends.

64 lecciones

Debugging and Troubleshooting

Take an unknown failure — a thirty-line traceback, a silently wrong result, a regression buried under two hundred commits, or a test that fails once every thirty runs — and learn to reproduce it, corner it down to the exact line, and explain it with evidence, before asking a model anything; and when you do ask, learn to verify whether the answer is correct. The six modules move from reading the failure (what a traceback is already telling you) to the method that goes from symptom to root cause, to the debugger for stopping the program and looking inside, to logging for diagnosing what already happened, to bisection for cornering regressions and intermittent failures, and close with AI in the loop: using it after you understand the error, not instead of understanding it. The final project is a debugging dossier on a repository with five failures of different natures — including a regression that requires `git bisect run` — resolved with protocol, evidence, and a regression test.

48 lecciones