Test-Driven Development with Python Obey the Testing Goat Using Django, Selenium, and JavaScript (Harry J.W. Percival)（Z-Library）

【One-Line Pitch】 A hands-on, story-driven guide to web development using Test-Driven Development (TDD) with Python, Django, Selenium, and JavaScript, perfect for developers who want to build robust applications by writing tests first and "obeying the testing goat." 【Book Arc】 - **Opening (~0%–10%)**: Introduces the core philosophy of TDD—"do nothing until you have a test"—and sets up the project environment, including installing Django, Selenium, and creating the first functional test (FT) that drives development. - **Early (~10%–23%)**: Walks through the first TDD cycle: writing a failing FT, creating a Django app, and using unit tests to build the home page. Emphasizes the importance of testing both the "what" (user behavior) and the "how" (code logic). - **Early–Middle (~23%–39%)**: Focuses on saving user input to a database, introducing the Django test client, and handling POST requests. Covers the "redirect after POST" pattern and the concept of regression testing to prevent old bugs from reappearing. - **Middle (~39%–48%)**: Explores working incrementally, adding URL parameters to support multiple to-do lists, and refactoring views to keep them simple. Highlights the value of removing redundant code and tests as the design evolves. - **Late (~48%–52%)**: Shifts to "prettification"—layout and styling—and discusses what to test (or not) about front-end changes. Introduces Docker for running the app in a consistent environment and managing ports for testing. 【Key Takeaways】 - **TDD is a discipline, not a tool** (Early): The mantra "do nothing until you have a test" forces you to think about desired behavior before implementation, reducing bugs and guiding design. It's about a mindset shift, not just using testing libraries. - **Functional tests (FTs) capture user stories** (Early): Writing FTs in plain language (e.g., "Edith types 'Buy peacock feathers'") ensures you're building what the user actually needs, not just what the code can do. They serve as living documentation. - **Unit tests drive code structure** (Early): While FTs test behavior from the outside, unit tests (like calling view functions directly) help you design clean, modular code. The book deliberately shows the "manual" way before introducing the Django test client to build understanding. - **The Django test client is pragmatic but has trade-offs** (Early): It simplifies testing views and templates, but it pushes you toward integration tests rather than fully isolated unit tests. The book acknowledges this and revisits the distinction later. - **Always redirect after a POST** (Early): This pattern prevents duplicate submissions and keeps the URL clean. It's a simple rule that improves user experience and is easy to test with `assertRedirects`. - **Refactoring is part of the TDD cycle** (Middle): As features grow, you'll simplify views and remove redundant tests. This keeps the codebase maintainable and ensures tests stay relevant—"doesn't that feel good?" - **URL parameters enable scalable features** (Middle): Using `<int:list_id>` in URL patterns allows each user to have their own list, moving from a single shared list to a multi-user app. This is a natural step in incremental development. - **Front-end testing has limits** (Late): When adding styling, you test that assets load correctly, not pixel-perfect layouts. The book advises using tools like Docker to ensure consistent environments, avoiding "works on my machine" issues. 【Reading Tips】 - **Skim the early setup chapters** (~0%–10%) if you're already familiar with Django and Selenium; the key insight is the TDD philosophy, not the installation steps. - **Deep-read the TDD cycle chapters** (~10%–39%): Follow along with the code examples—type them out and run the tests yourself. The "red-green-refactor" rhythm is best learned by doing. - **Pay attention to the "why" behind choices** (e.g., why not use the test client from the start): These explanations reveal the author's teaching strategy and deepen your understanding of testing trade-offs. - **Don't skip the refactoring sections** (Middle): They show how TDD supports code evolution, which is as important as writing tests in the first place. - **Use the book as a reference for testing patterns**: Even if you don't build a to-do app, the patterns (FTs, unit tests, redirects, URL params) are transferable to any Django project. 【Coverage Limits】 This guide covers the core TDD workflow, Django basics, and testing strategies from the excerpts, but does not cover advanced topics like JavaScript integration, deployment, or the later chapters on forms and validation in detail.