Better Testing

AI agents generate more and more code, faster than ever. You write unit tests to make sure that code actually works. You know assertions, test doubles, and code coverage. But is that enough?

Most developers stop at example-based testing: for a known input, a known output is checked. This works – as long as all relevant cases have been considered. But what about the cases no one thought of?

In this training, you will learn testing methods that go far beyond what most teams use in their day-to-day work. You will learn how to make sure your tests actually check the right thing. You will learn how to safeguard existing code before you change it. You will discover how to automatically find edge cases you never would have thought of. You will understand why high code coverage alone is no guarantee of quality. And you will learn how to confront your software with unexpected inputs and uncover bugs that remain hidden even at 100 % code coverage.

These methods are universal. They work in any programming language and with any test framework. In this training, I teach the concepts using PHP examples and the tools of the PHP ecosystem. But the insights you gain apply to any codebase: whether PHP, C#, Go, Java, Python, Rust, or TypeScript.

• Your test is green. But how do you know it is checking the right thing?
• What happens when your code returns correct results but has unwanted side effects?
• How do you verify behaviour that cannot be expressed in a return value?
• What do you do when you do not even know what the correct answer would be?

• You need to change code that no one on the team understands. There are no tests and no documentation.
• How can you safely modernise code when you do not know what it actually does?
• How do you document actual behaviour before you change anything?
• How do you get from a safety net to a real test suite?

• You test with examples, but you cannot write down every example. What are your tests missing?
• How do you find edge cases you never would have thought of?
• When a test fails, the input is often huge and incomprehensible. How do you get to the actual problem?
• For which kinds of code does this approach pay off, and where does it reach its limits?

• You have high code coverage, but bugs still make it into production. Why?
• Your tests are green, but would they even notice a real bug in the code?
• How do you measure whether your tests are actually any good – beyond coverage numbers?
• What do deliberately introduced faults in the code reveal about the quality of your test suite?

• Your tests prove that your code is correct. But is it also robust?
• What happens when your code receives inputs no one anticipated?
• Why does even 100 % code coverage not protect against all bugs?
• How do you find security vulnerabilities before attackers do?

This training is for developers who already have experience with automated testing and want to expand their testing methodology. The concepts are relevant regardless of the programming language you use. The practical examples and exercises use PHP, but the methods you learn transfer directly to other languages and their ecosystems.

• Experience in software development with an object-oriented programming language
• Basic experience with automated testing (writing and running unit tests)
• For the practical examples: familiarity with PHP is helpful but not required

• You recognise when a green test is misleading and know how to make sure it checks the right thing
• You can safeguard unfamiliar code before you change it
• You find edge cases you never would have thought of when writing tests by hand
• You know what code coverage really tells you – and what it does not
• You can systematically test the robustness of your code against unexpected inputs
• You choose the right testing method for each situation and can justify your decision