You want to test your application properly but don’t know which testing strategy to go with? Kudos to you for realizing you need automated UI testing.
As you may already know, the three most common types of software testing are unit, integration, and end-to-end (E2E) testing. However, in this post, I will focus on end-to-end testing vs. integration testing, which are higher-level tests than unit tests.
If, however, you’re interested in understanding unit testing as well, check out this post.
Now, let’s start with a bit on the fundamentals.
Why Do We Test?
When building new software, I personally write tests for two simple reasons:
- To save time
- To write better code
When I started as a developer, I hated tests. What really got me hooked is when I realized how my code’s quality improved as I began introducing automated tests. Testing your own code also increases your personal responsibility for the code.
Regarding saving time, the earlier you find bugs, the faster and cheaper it is to fix them. Studies have shown it to be as much as 100X more expensive to fix a bug that escaped to production as it is to fix a bug you found in the design and coding stage.
Integration Tests in Software Development
In contrast to unit testing, in which you test a small isolated unit, integration testing usually involves testing a particular functionality—usually referred to as a module—that has dependencies on another functionality (e.g., a function calling another function). The goal of these tests is to check the connectivity and communication between different components of the application.
Integration Testing Objectives
There are three main objectives to running integration tests:
- Integration tests ensure synchronization between modules when they work together to accomplish a specific task, especially as these modules could have been built by different developers or teams.
- These tests also help validate the application’s interfaces so that the data flowing from one module to another is appropriate.
- They ensure that the connectivity between modules works as it was conceived to work.
Approaches to Integration Testing
Now that we know the purpose of integration testing and have seen an example let’s see how we can implement it.
Depending on your project size, team, budget, and other factors, different integration testing approaches could work better for you. Here’s a brief overview of the three most popular approaches.
The Bottom-Up Approach
In this first approach, the bottom-up approach, testers focus on integrating smaller modules that are usually built first into bigger ones that could be built later. Running these tests requires that higher-level modules be simulated—these simulated modules are called drivers.
Less complex modules are then progressively integrated into bigger ones right up until the application is complete. The main advantage here is the ability to fail fast, as smaller modules are easier to detect and quicker to fix.
The Top-Down Approach
The opposite of the bottom-up approach is the top-down approach. Here, priority is given to the larger, more complex modules, and the lower-level ones are simulated. In this case, the simulated modules are called stubs.
You can learn more about stubs and drivers here.
The Big Bang Approach
Finally, we have the big bang approach. With this approach, all modules are tested together at the same time. Of course, this means that all modules have to be ready. As such, this can be a very time-consuming approach. Also, detecting errors can be a bit more difficult compared to the other approaches. But if your application is small, the big bang approach can be a great go-to.
Benefits of Integration Tests
Overall, I will say that integration testing is a must. As someone who spends a lot of time writing these types of tests, I can tell you that they will add value to your project in terms of the confidence they bring. Some benefits are that
- They make sure modules work together and meet expected standards.
- Since integration tests are higher level (than unit tests), they tend to improve the application’s overall test coverage.
- Integration tests lay the groundwork for higher-level tests like E2E testing.
End-to-End Tests in Software Development
Funny enough, E2E testing looks very much like manual testing. When doing E2E tests, you are looking to test the product the same way a real user experiences it. You want to make sure everything works as expected (functionality and performance). But, again, this is all done in an automated manner.
There are two main objectives to E2E testing:
- E2E tests simulate a user’s step-by-step experience.
- They also allow you to validate different subsystems and layers of the application.
Read more: End-to-End Testing vs Integration Testing