The short answer is yes. For software to work properly, all units should integrate and perform as they're expected to. To ensure this is the case, you will need to perform integration tests.
Getting features to work together is like introducing your partner to your family - you never know if they're going to get along at first. Will grandma do her 'false teeth trick' the minute you walk in the door? Will dad tell that stupid joke and burn the dinner again? The only way you're going to find out is by bringing them together and running an 'integration test'. It's the same with software applications.
Why is integration testing necessary?
To ensure third-party applications and internal modules work seamlessly together within your software, you’ve got to combine them, test the combination and evaluate the results.
One common example of an integration is the payment gateway for an eCommerce site. The integration between the application under test (AUT) and the payment process at every point where these features exchange data must be carefully tested across all possible scenarios. The test cases for this would include (but are not limited to):
- Normal checkout with success
- Normal checkout and user cancelled
- Normal checkout and cart browser closed/ connection cut
- Normal checkout and transaction declined (card expired, unsupported payment type, etc)
Other examples include any accessing and using third party APIs, web services, plugins and anything else your developers did not create themselves.
NOTE: Integration testing can sometimes be confused with end-to-end testing, so you can check out this OnPath blog post where we compare the two and clear that up.
Benefits of integration testing
The overall benefit is that integration testing improves the reliability of your software. That's because it's a type of functional testing. Here are a few more advantages of doing integration tests:
- It effectively executes important user-based scenarios.
- It might uncover adhoc tests you hadn't thought of earlier.
- It ensures that internal modules and components communicate properly.
- It performs regression testing on important connection points.
When you weigh up the benefits you realize that integration testing allows your end-user to a have a frictionless user journey.
Integration testing best practices
Integration testing isn't always a walk in the park, but it's worth investing time and effort in careful planning and test development. We've put together some best practices for performing integration tests to guide your investments:
- Integration testing should take place after your developers have performed unit tests, and ideally after you've performed granular functional tests.
- Maintain good QA practices by separate these test plans, so that integration tests can be run at the right time during the dev/QA cycle, plus be reported properly.
- Remember - you're not testing for business logic here, that is done during the detailed functional testing. Focus on the bigger picture and what the connection points between the various systems are returning.
- If you have access to the backend files and data, check the logs and run some SQL queries to confirm data is as expected.
- Log any defects with good detail, capturing test sequence, data used, state of the system, and anything else useful for the developers to track down the issue.
- Test for the end-user experience. Might as well make the most of the time spent!
If you're still unsure of where to begin, you may want to organize a professional testing service to help you implement an integration testing framework.
Long story short
'Testers don’t like to break things; they like to dispel the illusion that things work.'— Kaner, Bach, Pettichord
Quality assurance testing is done to ensure the end-user experience is seamless. When your software application combines different modules and third-party apps that need to work together for the application to function as expected, integration testing is necessary.