What is Integration Testing (Tutorial with Integration Testing Example)

Learn about Integration Testing with Examples

Integration testing is a crucial step in software testing, especially when testing large applications that involve multiple tightly coupled modules or components. It aims to ensure that these integrated modules function properly and do not encounter issues.

In the context of testing a complex application using the black box testing method, integration testing becomes essential. It allows us to test the combined behavior of integrated modules and ensures that the requirements are implemented correctly.

List of tutorials covered in this series:

Tutorial #1: What is Integration Testing? (This Tutorial)
Tutorial #2: What is Incremental Testing
Tutorial #3: What is Component Testing
Tutorial #4: Continuous Integration
Tutorial #5 Difference Between Unit Testing and Integration 
Tutorial #6: Top 10 Integration Testing Tools

What is integration testing?

Integration testing aims to test the combined behavior of modules or components that have already been individually tested. It focuses on verifying the interfaces between these modules and ensures that the integrated system functions as expected.

The process of integration testing involves first testing the modules in isolation and then gradually integrating them one by one to check their combinational behavior and validate the correct implementation of requirements.

It is important to note that integration testing is not a standalone activity that occurs at the end of the development cycle. Instead, it is conducted simultaneously with development, as all the modules might not be available for testing at once.

Why Integration Test?

Integration testing is crucial for verifying the proper functioning of integrated modules and ensuring the smooth flow of data between them. Some key reasons why integration testing is necessary are:

1. In real-world scenarios, applications are divided into smaller modules, each assigned to individual developers. Integration testing helps validate whether the logic implemented by each developer aligns with expectations and produces the correct outputs.
2. Data structures and values might change as they move between different modules, leading to issues in subsequent modules. Integration testing helps identify and rectify such issues.
3. Modules often interact with third-party tools or APIs. Integration testing ensures that the data exchanged with these external entities is correct and that the responses generated meet expectations.
4. Frequent requirement changes pose a common challenge in testing. Integration testing becomes crucial in such cases, as developers may deploy changes without thorough unit testing.

Advantages

Integration testing offers several advantages, including:

• Ensures the proper functioning of integrated modules/components.
• Can be initiated even when all the modules are not available, as stubs and drivers can be used to simulate missing modules.
• Helps detect errors related to module interfaces.

Challenges

Integration testing can encounter various challenges, such as:

#1) Integration testing involves testing two or more integrated systems to ensure their proper functioning. It requires thorough testing of integration links and considering the overall environment to ensure the integrated system functions as expected.

#2) Managing integration testing can become complex due to factors like databases, platforms, and environments.

#3) Integrating new systems with legacy systems or combining two different legacy systems can be challenging, as changes and testing efforts are required to ensure compatibility and minimize impacts on existing systems.

#4) Integrating systems developed by different companies presents a significant challenge, as the impact of changes in one system on the other is uncertain.

Types of Integration Testing

Integration testing can be categorized into various types, including:

Big Bang Approach:

The Big Bang approach involves integrating all the modules at once, without gradually integrating them one by one. It tests the system as a whole to verify its expected behavior. However, this approach can make it challenging to pinpoint which module is causing issues in the case of any defects.

The advantages of the Big Bang approach include its suitability for small systems. However, it can be difficult to detect the specific module causing issues and requires all modules for testing, leaving less time for critical module testing in isolation.

Test Integration Approaches

Two fundamental approaches for test integration are:

1. Bottom-up approach: This approach starts with testing the lowest or innermost module of the application and gradually integrates the higher-level modules. It may require using drivers to simulate the higher-level module calls to the lower-level modules. The advantage of this approach is early detection of major faults, but it may delay the identification of higher-level design flaws.
2. Top-down approach: This approach starts with testing the topmost module and progressively integrates the lower-level modules. It may require using stubs to simulate the lower-level modules’ behavior. The advantage of this approach is early detection of higher-level design flaws, but it may delay the identification of major faults at the lower level.

A combination of both approaches, known as “sandwich testing,” can also be used for more complex systems, where both approaches are started simultaneously.

GUI Application Integration Test

For GUI applications, integration testing involves testing the flow of data and interactions between the frontend, middle-layer business logic, third-party integrations, and the backend database.

Integration Testing Example:

Consider the example of an advertising company that posts ads on various websites. The company needs a system to track the number of ad views and clicks for billing purposes. The system architecture includes:

UI – User Interface module
BL – Business Logic module
VAL – Validation module
CNT – Content module
EN – Engine module
Scheduler – Scheduler module
DB – Database module

Integration testing in this case would focus on validating the flow of data between these modules. The data entered in the UI module gets converted into an XML file, which is then interpreted by the BL, VAL, and CNT modules. The EN module reads the resultant XML file and extracts SQL queries that are executed on the database. The results are then converted into XML and displayed through the UI module.

The integration testing would involve validating the correctness of the generated XML files, ensuring data is transferred accurately between modules, and checking if the expected behaviors are met.

Additional test conditions for GUI application integration testing may include verifying interface links, validating menu options, and testing different ways of invoking windows and performing calls between modules.

Steps to Kick off Integration Tests

1. Understand the application’s architecture.
2. Identify the modules and their functionalities.
3. Understand the data flow between modules.
4. Identify entry points and exit points of the application.
5. Segregate the application for testing purposes.
6. Create test conditions based on the identified segregation.
7. Write test cases for each test condition.

Entry/Exit Criteria for Integration Testing

Entry Criteria:

• Integration test plan document is signed off and approved.
• Integration test cases have been prepared.
• Test data has been created.
• Unit testing of developed modules/components is complete.
• All critical and high priority defects are closed.
• The test environment is set up for integration.

Exit Criteria:

• All integration test cases have been executed.
• No critical and high priority (P1 & P2) defects are open.
• Test report has been prepared.

Integration Test Cases

Integration test cases primarily focus on interface testing, integrated links, and data transfer between modules. As the functionality and other aspects of the modules have already been covered during unit testing, integration testing serves to ensure that the integrated modules function correctly.

Is Integration a White box or Black box Technique?

Integration testing can be considered as both a white box and black box technique, depending on the specific context. It can be classified as a black box technique when testing the integration of two web services that fetch and provide data from a database. In contrast, it can be seen as a white box technique when integrating a new feature into a website.

Therefore, it is not strictly categorized as either a black box or white box technique.

Integration Testing Tools

Several tools are available for integration testing. Some popular examples include:

• Rational Integration Tester
• Protractor
• Steam
• TESSY

System Integration Testing

System Integration Testing involves testing the entire integrated system as a whole. It is performed after unit testing of individual modules or components. The purpose is to verify the proper functioning of the integrated system.

Difference between Integration Testing & System Testing

Integration testing focuses on testing the combined behavior of integrated modules or components. It verifies whether the integrated system works as expected and does not encounter issues due to integrated modules.

System testing, on the other hand, tests the entire system as a whole. All individual modules or components are integrated, and the system is tested to ensure it functions as expected without any critical issues.

Conclusion

Integration testing is a crucial step in the testing cycle that helps ensure the proper functioning of integrated modules and the smooth flow of data between them. It allows early detection of issues, saving effort and cost. By understanding the architecture, identifying the modules, and creating specific test conditions and cases, integration testing can be effectively executed.

We hope this tutorial on Integration Testing has provided you with valuable insights and examples.