"Unit testing" focuses on testing a unit
of the code.
"Integration testing" is the next level of testing. This 'level of
testing' focuses on testing the integration of "units of code" or
components.
How does Integration
Testing fit into the Software Development Life Cycle?
Even if a software component is successfully unit
tested, in an enterprise n-tier distributed application it is of little or no value if the
component cannot be successfully integrated with the rest of the application.
Once unit tested components are delivered we then
integrate them together.
These "integrated" components are tested to weed out errors and bugs caused due to the integration. This is a very important step in the Software Development Life Cycle.
These "integrated" components are tested to weed out errors and bugs caused due to the integration. This is a very important step in the Software Development Life Cycle.
It is possible that different programmers developed different
components.
A lot of bugs emerge during the integration step.
In most cases a dedicated testing team focuses on Integration Testing.
Prerequisites for
Integration Testing:
Before we begin Integration Testing it is important
that all the components have been successfully unit tested.
Integration Testing
Steps:
Integration Testing typically involves the
following Steps:
Step 1: Create a Test Plan
Step 2: Create Test Cases and Test Data
Step 3: If applicable create scripts to run test cases
Step 4: Once the components have been integrated execute the test cases
Step 5: Fix the bugs if any and re test the code
Step 6: Repeat the test cycle until the components have been successfully integrated
Step 1: Create a Test Plan
Step 2: Create Test Cases and Test Data
Step 3: If applicable create scripts to run test cases
Step 4: Once the components have been integrated execute the test cases
Step 5: Fix the bugs if any and re test the code
Step 6: Repeat the test cycle until the components have been successfully integrated
What is an
'Integration Test Plan'?
As you may have read in the other articles in the
series, this document typically describes one or more of the following:
- How the tests will be carried out
- The list of things to be Tested
- Roles and Responsibilities
- Prerequisites to begin Testing
- Test Environment
- Assumptions
- What to do after a test is successfully carried out
- What to do if test fails
- Glossary
- How the tests will be carried out
- The list of things to be Tested
- Roles and Responsibilities
- Prerequisites to begin Testing
- Test Environment
- Assumptions
- What to do after a test is successfully carried out
- What to do if test fails
- Glossary
How to write an
Integration Test Case?
Simply put, a Test Case describes exactly how the test should be carried
out.
The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
So the Integration Test cases should typically focus on scenarios where
one component is being called from another. Also the overall application
functionality should be tested to make sure the app works when the different
components are brought together.
The various Integration Test Cases clubbed together form an Integration
Test Suite
Each suite may have a particular focus. In other words different Test Suites may be created to focus on different areas of the application.
Each suite may have a particular focus. In other words different Test Suites may be created to focus on different areas of the application.
As mentioned before a dedicated Testing Team may be created to execute
the Integration test cases. Therefore the Integration Test Cases should be as
detailed as possible.
Working towards
Effective Integration Testing:
There are various factors that affect Software
Integration and hence Integration Testing:
1) Software
Configuration Management: Since Integration Testing focuses on
Integration of components and components can be built by different developers
and even different development teams, it is important the right version of
components are tested. This may sound very basic, but the biggest problem faced
in n-tier development is integrating the right version of components.
Integration testing may run through several iterations and to fix bugs
components may undergo changes. Hence it is important that a good Software
Configuration Management (SCM) policy is in place. We should be able to track
the components and their versions. So each time we integrate the application
components we know exactly what versions go into the build process.
2) Automate Build
Process where Necessary: A Lot of errors occur because the
wrong version of components were sent for the build or there are missing
components. If possible write a script to integrate and deploy the components
this helps reduce manual errors.
3) Document: Document the
Integration process/build process to help eliminate the errors of omission or
oversight. It is possible that the person responsible for integrating the
components forgets to run a required script and the Integration Testing will
not yield correct results.
4) Defect Tracking: Integration Testing
will lose its edge if the defects are not tracked correctly. Each defect should
be documented and tracked. Information should be captured as to how the defect
was fixed. This is valuable information. It can help in future integration and
deployment processes.
Summary:
Integration testing is the most crucial steps in
Software Development Life Cycle. Different components are integrated together
and tested. This can be a daunting task in enterprise applications where
diverse teams build different modules and components. In this article you
learned the steps needed to perform Integration Testing.
Comments
Post a Comment