The Clean Test Automation Monthly is a monthly blog post that shares interesting or useful test automation content which I read during the current month. This blog post is always published on the last day of the month.
Let's begin!
Test Design
Test Planning – What Makes A Good Plan? argues that a good enough test plan defines what we will test, explains how we are going to do it, identifies the required skills, and lists the things we need before we can start testing. So, what does this have to do with automated testing? Quite a bit, actually. If we go through these things with out team before writing any code, we can ensure that everyone is on the same page, define testing guidelines for our project, and arrange training if needed.
Lessons learned in test-driven development: Software tester edition shares a tester's perspective on test-driven development (TDD). It identifies the pros and cons of TDD, and describes how we can find a balance between TDD and traditional testing.
Mock Objects & Stubs: Your Key to Bulletproof Test Isolation provides a quick introduction to test doubles, identifies the difference between a stub and a mock, and describes how we can use them to isolate the system under test from its dependencies.
Why I Don’t Use Mocking Frameworks and Why You Might Not Need Them Either explains why the author doesn't use mocking frameworks like Mockito. It highlights the issues caused by mocks, and explains how the author writes both code and tests which don't require mocks.
This blog post also provides an example which demonstrates how we can refactor a service method so that we can write unit tests which don't require mocks. Unfortunately, this example don't do the author any favors because the new unit test tests only a small portion of the refactored code.
And yet, I decided to include this post in this newsletter because I think that it's generally a good idea to minimize the number of test doubles used by our automated tests.
Flaky Tests: When Perfection Becomes the Enemy of Progress defines the term flaky test, identifies the cause of flakiness, and describes three classic and harmful solutions which are often used to tackle flaky tests. Finally, the blog post describes how Docker deals with flaky tests by using an internal tool which ignores known issues.
Refactor or Rewrite? Making the Right Call in Test Automation defines the terms refactor and rewrite, and explores when it's better to refactor existing tests and when it’s worth to rewrite them from the scratch.
Test names should be sentences describes the purpose of an automated test, argues that a good test name is a sentence which describes what went wrong if the test fails, and explains what might be wrong if we cannot figure out a good name for a test.
Backend
Let’s Explore the Best REST API Clients and Testing Tools (2025 Edition) highlights 15 REST API clients and testing tools. This post identifies the key features of every tool and provides a short evaluation which helps us to select the best tool for the job.
STF Milestone 4: Parameterized test classes identifies a situation when we want to run a set of test methods by using the same arguments and describes how we can solve this problem by writing parameterized test classes with JUnit 5.
How to Configure Mockito Agent for Java 21+ Without Warning is an interesting blog post which explains how we can get rid of the warning that's caused by Mockito when we are using Java 21 or newer. This blog post describes why the warning is displayed and explains how we can solve this problem when we are running our tests with Maven, Gradle, and IntelliJ Idea.
Thymeleaf View Testing with Spring Boot and HtmlUnit is a practical blog post that helps us to write tests for Thymeleaf views with Spring MockMvc and HtmlUnit.
Test Flyway Java Migrations with Spring Boot describes how we can write integration tests for Java-based Flyway migrations when we are using Spring Boot.
UI / End-to-End
Supercharging Playwright Tests with Chrome DevTools Protocol describes how we can leverage the Chrome DevTools Protocol (CDP) when we are writing automated tests with Playwright. This post helps us to speed up our Playwright tests by blocking images, capture console logs, and simulate slow network speed.
Why Playwright Tracing Beats Logging for Debugging UI Tests demonstrates why Playwright tracing is a better debugging tool than reading text-based Playwright logs. It also introduces a workaround for a Playwright bug that prevents the trace file from being saved when the Playwright tests are written with Python.