Unit Testing: An Introduction

If you’ve worked in software testing, you’ve probably heard of the term “unit testing”, but what is unit testing? Well, put simply, unit testing is a way of testing a “unit” or the smallest piece of code that can be logically isolated in a system. But why is testing the smallest unit so important and what are the advantages and disadvantages of doing so? In this blog post, we set out to give you all the foundational knowledge you need to understand unit testing.

What is unit testing?

Unit testing is a cornerstone of software development and focuses on examining individual components of code in isolation. These components are typically classes, modules, or functions. If end-to-end tests evaluate entire systems, unit tests are the polar opposite and serve as microscopic sanity checks for tiny bits of code.

Despite their narrow focus, the cumulative impact of unit tests is substantial. Jeff Atwood, Stack Overflow co-founder, once described unit testing adoption as one of the most significant advancements in software development. This sentiment remains widely shared today.

However, while most agree unit testing is important, no one can agree on the definition of a unit. For example, in functional language, a unit often refers to a single function, while in object-oriented languages, a unit could range from being a single method up to an entire class.

Debates also exist around how to handle dependencies (or "collaborators") in unit tests. Some advocate for replacing all collaborators with mocks or stubs, while others suggest only substituting the most complex ones. Martin Fowler pragmatically suggests that the exact definition is less important than the practice itself, with whom, we agree.

The two major types of testing

Unit tests can be performed using one of two software testing approaches—manual testing or automated testing. 

Manual testing, while thorough, is time-consuming and challenging to scale, as each test has to be written manually, making it difficult for engineers to isolate independent units and test all possible faults by hand. Consequently, automated unit testing has become the industry standard. Tools like JUnit and Selenium have revolutionized the testing landscape in this regard.

The advantages of unit testing

Unit testing offers a number of benefits that give businesses the confidence they need in their code and ultimately their product. In addition to their immense benefit as part of the wider software development cycle, unit testing has a number of advantages:

Early bug detection

Unit testing allows developers to break down their code into its smallest components and find bugs earlier, well before releases and before the code gets uploaded into larger processes. This approach helps to detect issues when they are easier and cheaper to fix. 

Improved code quality

Writing unit tests encourages developers to write cleaner, more modular code. To make code units testable, it often needs to be well-structured and loosely coupled. This naturally leads to better overall code quality and adherence to best practices like the Single Responsibility Principle.

Easier refactoring

With a comprehensive suite of unit tests, developers can refactor code with confidence. The unit tests serve as a safety net, ensuring that existing functionality remains intact after changes are made. This allows for continuous improvement of the codebase without fear of introducing regressions.

Better documentation and design

Unit tests serve as a form of executable documentation, describing how individual components are expected to behave. This aids in onboarding new team members and understanding code behavior. Additionally, the process of writing tests often reveals design flaws or areas for improvement. If code is difficult to test, it may indicate that it’s excessively complex, so unit testing can help identify areas that can be streamlined, leading to insights that can improve overall system design and maintainability.

You might be interested in: Unit Testing vs. Integration Testing

The  disadvantages of unit testing

Now that we’ve covered the advantages, let's take a look at some of the drawbacks of unit testing. 

Time-consuming

Writing comprehensive unit tests often takes longer than writing the actual code. And when it comes to unit testing, it is done by the developers, whereas integration testing, system testing, and UAT testing is performed by QA teams. Developers need to consider various scenarios, edge cases, and potential inputs. This time investment can be significant, especially for complex functions or classes.

Incomplete coverage

While unit tests are great for verifying individual components, they don't test how these components interact in a full system. This can lead to integration issues or system-level bugs that only surface when components are combined.

Maintenance overhead

As the codebase evolves, unit tests must be updated to reflect changes in functionality, interfaces, or dependencies. This ongoing maintenance can be time-consuming and may be neglected under tight deadlines, leading to outdated or irrelevant tests.

Potential for brittle tests

Tests that are too specific or tightly coupled to implementation details can break easily when the code is refactored or modified. This leads to high maintenance costs and can discourage developers from making necessary changes.

Limited scope

Unit tests focus on functional correctness but don't address non-functional requirements like performance, scalability, or usability. These aspects are crucial for overall software quality but require different testing approaches.

When should you use unit testing?

Now that we have covered what unit testing is, how it works, and what advantages and disadvantages there are, it's important to explore some scenarios in which you might want to undertake unit testing. Here are some examples:

Complex logic

Complex logic often involves multiple decision paths, nested conditions, or intricate algorithms. Unit testing is crucial here because:

• It helps verify each possible path through the code.
• It ensures all conditions and their combinations are handled correctly.
• It can uncover edge cases that might be missed in manual testing.

Example: Consider a function that calculates insurance premiums based on multiple factors like age, health conditions, lifestyle, and coverage amount. You'd want to test various combinations of these inputs to ensure the calculation is always correct.

Edge cases

Edge cases are unusual or extreme situations that can cause software to fail. Unit testing can help find these super-specific bugs by:

• Helping identify boundary conditions where bugs often occur.
• Improving robustness by handling unexpected inputs.
• Increasing confidence in the code's ability to handle rare scenarios.

Example: For a function that processes arrays, you might test with an empty array, an array with one element, and an extremely large array to ensure it handles all cases correctly.

Refactoring

Refactoring involves restructuring existing code without changing its external behavior. Unit tests are valuable during refactoring because they:

• Act as a safety net to catch unintended changes in behavior.
• Allow for confident code improvements.
• Help verify that the refactored code still meets all requirements.

Example: If you're refactoring a complex method into smaller, more manageable functions, running the existing unit tests after each change ensures the overall behavior remains intact.

Security-sensitive functions

For functions that handle sensitive data or operations, unit tests are essential to:

• Verify that input validation is working correctly to prevent injection attacks.
• Ensure that access control checks are always enforced.
• Test encryption and decryption operations for correctness.

Example: For a function that validates user passwords, unit tests can confirm that it rejects weak passwords, handles special characters correctly, and properly hashes and salts the password before storage.

These are just a few key examples that highlight how, despite some disadvantages, unit testing is still a very important part of software testing and the software development cycle.

Final thoughts 

Unit testing is an essential practice for robust, reliable software development. By examining individual components of code in isolation, it enables developers to catch issues early, maintain high code quality, and confidently refactor and improve the codebase. While unit testing does come with a set of challenges, like time investment and ongoing maintenance, the benefits typically outweigh these drawbacks. With the right approach and tooling, unit testing can become a powerful ally in delivering a stable, high-quality product. So if you haven’t already introduced unit testing into your software testing strategy, perhaps it’s about time you did.  

With over a decade of experience and teams of ISTQB-certified engineers, we can help you get started with unit testing without consuming in-house resources. Get in touch to learn more about our approach to unit testing and how we can help you integrate it into your existing QA strategy.