A good unit test

A good unit test should be:

1. Idempotent: It’s every engineer favorite word :) Meaning it can be run over and over and is always green.

2. Independent/Atomic: Meaning it does not dependent on any other tests to run before and can be run at any order or randomly within a test suite

If we are not able to achieve the above, then our unit test will become flaky and a bad (very bad) unit test. It will be flagged with an ignore tag or worst either commented out or deleted all together.

In addition, our unit test should be fast: It should run quickly so it does not delay the development process. This means that all the unit test dependencies should be mocked.

Side note - the only place where not mocking might be okay (and it is debatable) is for an orm heavy app where we can launch a database in memory. I still think it should be mocked but there is a counter argument to be said that not mocking might lead to a more accurate test through relying on actual db data and operations rather than orm mocks.

The unit test title should explain what it does. I recommend testWhenShould pattern in the title but other patterns are okay too. I also recommend having three sections: setup, execute and validate.

In the end, your test should be similar to this:

test*When*Should* {
//setup
.
dependencyOne = mockDependencyOne.return({…});
dependencyTwo = mockDependencyTwo.return({…});
objectToBeTested = new ObjectToBeTested(dependencyOne, dependencyTwo);
//execute
result = objectToBeTested.someFunc();
//validate
assertEquals(result, expectedResult)
}

Unit test code is no less important than product code and should follow the guidelines of elegant code too.

Elegant code

Finally, one last tip I posted about before. When you fix a bug, check why the previous unit tests did not uncover it and update them accordingly.

Fix a bug / Write a unit test

---

Mastering Software Engineering Course on Maven

If you liked this article, I will be teaching a “Mastering Software Engineering” course on Maven where I will teach hard-learned lessons I acquired developing large-scale products at companies such as Uber, Airbnb, and Microsoft.

---