Test-Driven Development (Continuous Unit Testing for Agile Software Development)
Testing forms an integral part of the modern software development flow. From customer- facing acceptance tests to code-focused unit tests, automated testing is part of the fabric of a modern build process and deployment pipeline. But it’s not enough that there are some tests: to be a help, not a hindrance, tests need to communicate not just verify, and testing needs to be a development habit, not an afterthought.
In Kevlin Henney’s Test-Driven Development course, you will learn about good unit tests (GUTs) and test-driven development (TDD) by seeing what it takes, putting them into practice in the language and testing framework chosen for the course, and reviewing what you’ve learned.
What practices support readable and maintainable tests? What test pitfalls hold developers and products back? How do you make testing fun and not a chore? Attend this course to answer these questions and more.
- What do we mean by unit tests? Unit tests exist alongside integration tests, system-level tests and tests of software qualities, such as performance
- How do unit tests fit into the testing and development landscape? The testing responsibility of developers and the role that tests play in supporting change
- What do we mean by good unit tests (GUTs)? Qualities of good tests and recognising common testing pitfalls, such as aligning test cases with methods
- The elements of TDD. From red–green–refactor to PDSA
- Data-driven tests and how to choose test data. Test parameterisation and the use of representative examples
- How to structure the anatomy of tests? Kinds of naming and the use of given–when– then to structure test method flow and test class nesting
- Testing workflow. Passive, interactive and reactive testing: plain ol’ unit testing (POUT), test-driven development (TDD), iterative test-last (ITL) and defect-driven testing (DDT)
- How to adjust test strength? Identifying and adjusting overfitting and underfitting tests
- Should we track coverage? Different kinds of coverage and how not to be misled by them
- Why is writing some tests hard? Listening to your tests and understanding any resistance in terms of complexity and lack of knowledge
- Mocks, stubs and other test doubles. Different techniques for addressing external and legacy dependencies in tests and when to use values instead of test doubles
Course slides (PDF) are made available to course attendees during and after
the course. Slides are updated as the course progresses, including new
material created in response to questions · Slides include code samples that
Kevlin creates during lectures and in the hands-on sessions, which Kevlin also
undertakes alongside attendees to include discussion points and variations
The course is suitable for developers working the language chosen for the course. Any
previous exposure to unit testing or agile development concepts is beneficial but not
- PCs with internet access.
- All hands-on labs use an online code-and-test environment, so no special software is required