Why unit tests are critical to reliable code and reduced costs

Mark DeArmond

Why unit tests are critical to reliable code and reduced costs

There are plenty of situations where technology leaders will effectively skip doing something today that they can put off until tomorrow. Sometimes the chickens don’t come home to roost; other times, they do—and to a costly degree. But in the fast-paced world of developing websites, mobile apps, and software as a whole, it's crucial to ensure the code works well and functions as intended, from the start.

The more people that touch the code increases the possibilities of something breaking unintentionally. When leading a team of engineers, developing best practices is crucial to keeping a product up and running. An important way that we, at Credera, help ensure this happens is through a practice called unit testing. In this article, we're breaking down the unit test and sharing why they're so crucial in the development lifecycle.

What, exactly, is a unit test?

A unit test is a type of software testing where individual units or components of a software application are tested in isolation from the rest of the system. The primary goal is to make sure each unit of the software performs as designed. A “unit,” in this context, is the smallest testable part of an application—typically, a single function, method, or procedure. For example, when hovering over a button on a website, does it animate in the way the designer intended?

Why a “unit”?

The name "unit test" might sound a bit technical, but the idea is straightforward. Think of a unit test like checking each ingredient before making a cake. Instead of testing the whole cake, you're making sure each ingredient, like the flour or sugar, is good on its own. In the tech world, a unit test amounts to checking each tiny part of a software application and making sure it works the way it's supposed to.

Anatomy of a unit test

Unit tests are typically written by developers and are automated, meaning they can be executed automatically without human intervention. A unit test usually follows a simple structure:

Arrange: This phase involves preparing the test and may include creating variables (e.g., an ingredient, as in the example below), setting up mock objects or dummy data, or making any other necessary preparations.

Act: The unit test then executes the function or method you’re intending to test.

Assert: The unit test checks the output or behavior of the executed code against the expected result. If the actual result matches the expected result, the test is considered successful; otherwise, it fails.

An example

Let's look at an example using our cake recipe as the subject of our software application. In the application file, we have a function, isIngredientGood and it checks if an ingredient is considered good. For simplicity, we will consider an ingredient as good if it is not marked as spoiled.

In the test file, we have two tests:

Line 10: Checks if the isIngredientGood function correctly considers “flour” as good (or true).

Line 21: Checks if the isIngredientGood function correctly considers “spoiled” as bad (or false).

How unit tests affect the bottom line

Now let’s address the elephant in the room: cost. Unit testing is often skipped initially due to the additional expenses it incurs. However, it's crucial to recognize this initial investment in unit testing can prevent much larger costs in the long run.

While you might save $100 by skipping unit testing at the beginning, the potential consequences of bugs and their ripple effects could lead to losses of $1,000 or more later on. In the grand scale of some projects, these losses can escalate to tens or even hundreds of times more than the initial savings as seen in this well-known graph illustrating how the cost of fixing a defect changes over time.

The proven value of unit testing

Despite concerns about its economic value, a Microsoft team of 32 developers transitioned from ad hoc to standardized unit testing using the NUnit framework. After a year of implementing a standardized and automated unit testing approach for version two of a product, they observed “a 20.9% decrease in test defects, with a cost of approximately 30% more development time compared to version one”—in which they continued with ad-hoc and manual unit testing.

This approach also led to a “relative decrease in customer-detected defects in the first two years of field use.” While some industrial teams have seen larger defect reductions (up to 91%) with iterative test writing, these results suggest the overall benefits of automated unit testing.

Additional benefits of unit testing

Aside from the previously mentioned value and impact of unit testing, there are numerous other benefits to taking a standardized, automated approach, including:

Early detection of bugs

Unit tests allow developers to catch and fix bugs at an early stage of development. By testing individual units in isolation, issues can be identified and addressed before they propagate into more complex and interconnected parts of the codebase.

Safeguarding code changes

As software projects evolve, developers often need to make changes to the codebase. Unit tests act as a safety net, ensuring modifications or additions to the code do not inadvertently break existing functionality. This is especially crucial in large and collaborative development environments.

Improved code quality

Writing unit tests encourages developers to adopt best practices in coding, such as modular design and adherence to coding standards. This, in turn, leads to a higher overall code quality.

Documentation and code understanding

Unit tests serve as a form of documentation. When developers read or write unit tests, they gain insights into how the code is expected to behave. This aids in understanding the purpose and functionality of different code components.

Support for refactoring

Unit tests facilitate refactoring—the process of restructuring code without altering its external behavior. Developers can confidently refactor their code, knowing that if the unit tests pass, the changes have not introduced defects.

Time and cost savings

While writing unit tests requires an initial investment of time, it pays off in the long run by reducing the time spent on debugging and fixing issues later in the development cycle. The cost of fixing a bug increases exponentially as it progresses through the development stages.

Unit testing: The unsung hero

In software development, unit tests contribute to building resilient and dependable applications. They empower developers to catch issues early, inspire confidence in code changes, provide a safety net for continuous improvement, and save time and money by preventing future bugs. In all types of projects, embracing the practice unit tests is undoubtedly valuable.

If your organization could benefit from a more rigorous and standardized approach to development and testing of product and its underlying code, please get in touch and see how Credera can help.