All about unit testing: 11 best practices and overview

11 unit testing best practices#

1. Write tests for a number of scenarios#

When writing a test case, be sure that you’re considering all possible scenarios. In other words, don’t just write a test for the happy path. Think about other scenarios as well, such as error handling.

2. Write good test names#

A good unit test name should explicitly reflect the intent of the test case. Follow consistent naming conventions, and only use shorthand if they’re easily understood by a reader. Writing good test names supports code readability, which will make it easier for yourself and others to extend that code into the future.

3. Set up automated tests#

Opt for automated unit testing with the help of a unit testing framework. An even better practice is automating tests in your continuous integration (CI/CD) pipeline.

The alternative to automated testing is manual testing, wherein we manually execute test cases and gather their results. As you can imagine, manually testing small units is incredibly tedious. It’s also less reliable. Automated tests are surely the way to go here.

4. Write deterministic tests#

False positives and negatives are common in software testing, and we must be diligent in order to minimize them. The goal is to have consistent outputs for tests in order to verify the desired function. Unit tests should therefore be deterministic. In other words, as long as the test code isn’t changed, a deterministic test should have consistent behavior every time the test is run.

5. Arrange, Act, and Assert (AAA)#

The AAA protocol is a recommended approach for structuring unit tests. As a unit testing best practice, it improves your test’s readability by giving it a logical flow. AAA is sometimes referred to as the “Given/When/Then” protocol.

You can use the AAA protocol to structure your unit tests with the following steps:

• Arrange: Arrange the setup and initialization for the test
• Act: Act on the unit for the given test
• Assert: Assert or verify the outcome

The following code demonstrates the AAA structure in testing the absolute value function in Python:

def test_abs_for_a_negative_number():
 
  # Arrange
  negative = -2
   
  # Act
  answer = abs(negative)
   
  # Assert
  assert answer == 2

Test-driven development (TDD) is a software development process through which we enhance our test cases and software code in parallel. In contrast to a typical development methodology, TDD involves writing test code before production code. TDD has several advantages, including increasing the code coverage of unit tests.

The process of TDD looks as follows:

• Develop a unit test for a desired feature
• Write the shortest possible code to pass that newly created test
• When the test passes, refactor your code to improve maintainability and readability
• If another feature is needed, repeat this process

The following figure illustrates the TDD development process:

Each test should focus on a single use case, and verify the output is as expected for that tested method. By focusing on one use case, you’ll have a clearer line of sight into the root problem in the event that a test fails (as opposed to testing for multiple use cases).

8. Avoid logic in tests#

To reduce the chance of bugs, your test code should have little to no logical conditions or manual string concatenations.

9. Reduce test dependencies#

Tests should not be dependent on each other. By reducing dependencies between units, test runners can simultaneously run tests on different pieces of code. A unit can be considered testable only if its dependencies are staged (i.e. stubs) within the test code. No real-world or external dependencies should affect the outcome of the test.

10. Aim for maximum test coverage#

While we can aim for 100% test coverage, this might not be always desirable or possible. Such comprehensive testing may have budget and time requirements beyond our ability. In some cases, such comprehensive testing is theoretically impossible (i.e. undecidable). That being said, we should aim for the most possible coverage given our constraints.

11. Keep proper test documentation#

Maintaining test documentation will help both developers and, in some cases, the end users (e.g. in the case of an API).

Testing documentation should fulfill the following criteria:

• Reviewable: A test by any given resource is reviewable by others.
• Repeatable: A test is documented such that it can be repeated multiple times. This enables us to verify that a bug is fixed in an updated piece of code by repeating the same test.
• Archivable: Tests and related bugs can be archived in documentation, serving as a valuable resource for future extensions of the project.

Wrapping up and next steps#

Wherever you are in your coding journey, learning to unit test will ensure that you can check your balances in the applications that you develop. In some companies, unit testing is taken care of by quality assurance (QA) engineers, but for the rest, software developers are responsible for mastering this craft. By validating your code as you write it, unit testing is invaluable in ensuring your development project comes together with minimal bugs. If it seems like a tedious task to test your application on a small scale of units, remember that you have various testing frameworks at your disposal to streamline the process!

One of the most popular unit testing frameworks is JUnit. If you work with Java, you might consider diving into unit testing with our course, Pragmatic Unit Testing in Java 8 with JUnit 5. JUnit is one of the most popular unit testing frameworks. You can use JUnit to write test methods with special directives, automate test executions with test runners, indicate test failures with different assertions, and record your test results. This course includes tutorials and all the information you need to leverage JUnit to efficiently test and develop your Java applications.

Happy learning!

Continue learning about software testing#

• Software testing 101: Get started with software testing types
• Performance testing tutorial: Automation, Gatling, and Jenkins
• Sass tutorial: Unit testing with Sass True