Integration testing is a type of software testing where components of the software are gradually integrated and then tested as a unified group. Usually, these components work well individually, but they may break when combined with other members. With integration testing, testers want to find defects that surface due to code conflicts between software modules when integrated.
Conflicts between software modules happen for many reasons, such as incompatibility between subsystem versions, data format conflict, or different processing logic. Integration testing pinpoints those communication issues between software components. It usually occurs after unit testing and before system testing.
Software is often built from many individual software components or modules. These modules may pass unit testing and work perfectly fine individually, yet collapse when put together for various reasons:
Inconsistent code logic:
They are coded by different programmers whose sense and approach to development differ, so when integrated, the modules cause functional or usability issues. Integration testing ensures that the code behind these components is aligned, resulting in a working application.
Clients change their needs frequently. Modifying the code of 1 module to adapt to new requirements sometimes means changing its code logic entirely, which affects the entire application. These changes are not always reflected in unit testing, hence the need for integration testing to uncover the missing defects.
Data can change when transferred across modules. The data can be read and processed if correctly formatted when moving, resulting in bugs. Integration testing is required to pinpoint where the issue lies for troubleshooting.
Third-party services and API integrations:
Since data can change when transferred, API and third-party services may receive false input and generate incorrect responses. Integration testing ensures that these integrations can communicate well with each other.
Inadequate exception handling:
Developers usually account for exceptions in their code, but sometimes, they can only fully see all exception scenarios once the modules are pieced together. Integration testing allows them to recognize those missing exception scenarios and make revisions.
External Hardware Interfaces:
Bugs can also arise when a software-hardware incompatibility is easily found with proper integration testing.
Integration testing protects you from those downfalls. There are numerous benefits to this practice:
- Software is built from a complex network of sub components. With integration testing, we ensure they work together harmoniously, delivering the intended functionalities.
- Modern software must also connect with various external systems via APIs to deliver specific functionalities, and conflicts can also happen with them, requiring integration testing.
- Verify the flow of data and information throughout the entire system.
- Increased confidence in system behavior mainly if performed early in the testing life cycle, following the shift left testing approach.
There are several strategies to perform integration testing, each of which has its advantages and disadvantages, with the two most common approaches being:
- Big Bang Approach
- Incremental Approach
Big Bang Integration Testing
Big Bang Integration testing is an integration testing approach in which all modules are integrated and tested simultaneously as a singular entity. The integration process is carried out once all components have been successfully unit tested.
- Suitable for simple and small-sized systems with low levels of dependency among software components
- Little to no planning beforehand is required
- Easy to set up since all modules are integrated simultaneously
- Management and coordination efforts are minimized since there is only one primary testing phase
- It is costly and time-consuming for large systems with many units, as testers must wait until all modules have been developed to start testing.
- Waiting for all modules to be developed before testing also means late defect detection.
- It is hard to isolate and pinpoint bugs in specific modules.
- Hard to debug due to the complexity of multiple integrated modules
Best Practices when using Big Bang testing:
- Clearly define the interactions between each unit/function before testing to minimize missing defects
- Perform extensive logging for more accurate fault localization
- Perform Big Bang testing for simple applications
Incremental Integration Testing
Incremental integration testing is an approach in which two or more modules with closely related logic and functionality are grouped and tested first, then gradually moving on to other module groups instead of trying everything simultaneously. The process ends when all modules have been integrated and tested. Incremental integration testing is more strategic than Big Bang testing, requiring substantial planning beforehand.
- Earlier defect detection compared to Big Bang testing since the modules are integrated and tested as soon as they are developed. QA teams can begin testing before all modules are available.
- Easier fault localization since the modules are tested in relatively small groups.
- The strategic nature of incremental integration testing can be leveraged in project management. For example, QA managers can choose which module to test first based on urgency, priority, or resource availability.
- The risk of encountering catastrophic failures is also significantly reduced since issues are addressed early on from the root.
- Require thorough planning beforehand.
- The total number of tests to perform can be huge, depending on the scale of the project, requiring significant organizational resources.
- Coordinating a large integration testing project with this approach may be complex.
- Require a complete definition and logic of the system before it can be broken down into small units.
- In earlier stages of the project, certain system functionalities may not yet be available, leading to a dependence on stubs and drivers (which are essentially mock components that will be used as substitutes for actual details)
- The lack of system functionalities in earlier stages may lead to system “blindspots” later if not carefully documented.
Incremental integration testing can be further divided into three more minor approaches; each also comes with advantages and disadvantages that QA teams must consider carefully for their projects. These approaches are named based on the level of impact the software components being integrated have on the overall system, including:
In this Software Testing Tutorial, we will learn what is integration testing. When all the units are integrated together and you test the integrated module then its known as integration testing.