Unified Integration Testing (UIT) Best Practice Prepared by: Gurunathan Thirunavukkarasu & Sivasundar Nagarajan
Contents Testing Goals:... 3 The testing phases are:... 3 Integration Testing Overview... 4 Objective of Integration Testing:... 4 Why Integration Testing needed:... 5 How does Integration Testing fit into the Software Development Life Cycle... 5 Categories of Unified Integration Tests:... 5 PrerequiUITes for Integration Testing:...6 Entry Criteria:... 8 Integration Testing Steps:... Error! Bookmark not defined. How to write an Integration Test Case?... 8 Unified Integration Testing Cycle :... Error! Bookmark not defined. Integration Testing Flow :... Error! Bookmark not defined. Working towards Effective Integration Testing:... 10 Benefits of UIT:... 11 Conclusion... 11
Testing Objectives: There is an exponentially increasing cost associated with finding defects later in the development life cycle. This is mainly due to the additional business costs of using incorrect data to make critical business decisions. Given the importance of early detection of defects, the goals of testing an application has to be established. The testing phases are: Unit Testing: The objective of Unit testing involves testing of error conditions, business transformation rules, mapping fields at staging and core levels. Duplication of values, correctness of keys, Data type constraints, etc are performed during the Error checking process. In unit testing the various processes involved are: Data completeness Data transformation Data Quality Performance and Scalability Integration n Testing: The objective of Integration Testing is to ensure that workflows are executed as scheduled with correct dependency. E.g. To check target tables are populated with correct number of records, to check for the execution and dependencies of the workflows from source to staging etc. Regression Testing: The objective of System Testing is to ensure that the required business functions are implemented correctly i.e. to check if the functionality of the system meets the business specifications.
User-ac acceptance ceptance Testing: The objective of this testing to ensure that System meets the expectations of the business users. It aims to prove that the entire system operates effectively in a production environment and that the system successfully supports the business processes from the user's perspective. Integration Testing Overview: Integration testing, which is testing in which software components, hardware components, or both are combined and tested to evaluate the interaction between them Integration testing concentrates entirely on module interactions, assuming that the details within each module are accurate. At the other extreme, module and integration testing can be combined, verifying the details of each module's implementation in an integration context. Integration testing concentrates entirely on module interactions, assuming that the details within each module are accurate. At the other extreme, module and integration testing can be combined, verifying the details of each module's implementation in an integration context. Integration testing is combining module testing with the lowest level of subsystem, and then performing pure integration testing at higher levels. Objective of Unified Integration Testing (UIT): The purpose of Integration testing is to verify functional, performance and reliability requirements placed on major design items. These "design items", i.e. assemblages (or groups of units), are exercised through their interfaces using Black box testing, success and error cases being simulated via appropriate parameter and data inputs. Unified integration testing practice helps to collaborate with different teams like System Engineering, Development and System testing and bringing a common understanding what exactly to be tested during integration phase. By doing this exercise, IT tester has to test the interfacing module on critical requirements / functionalities during this phase and identifying most of the critical defects. It reduces the defects in system testing cycle and achieving the quality code on time. All test cases are constructed to test that all components within assemblages interact correctly, for example, across procedure calls or process activations. The overall idea is the "building block" approach in which verified assemblages are added to a verified base which is then used to support the Integration testing of further assemblages.
Why Unified Integration Testing needed: We do integration testing because a set of modules that work fine individually rarely works together correctly the first time. There are different sort of reasons for disconnect between teams, Differences in the understanding of business requirements between multiple developers cause them to assume different things should happen for the same test cases. The modules still have errors that were not uncovered in unit testing. Integration testing may add new test scenarios based on the Application Design, some of which may have been difficult to generate during unit testing, that result in additional errors being uncovered. Categories of Unified Integration Tests: Different approaches already in place for the integration testing, but UIT has the below categories for the testing. Interface integrity Internal and external interfaces are tested as each module is integrated Functional validity Tests to uncover functional errors in each module after it is integrated End-to-end validity Tests are designed to ensure that a completely integrated system works together from end-to-end How does UIT fit into the SDLC: Integration testing in the software testing model comes before system testing and after the unit testing has been done. 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. Integration testing does not deal with the integration of the whole system but deals with the integration of a process in the system In the integration testing stage there are three things that are created, to ensure that the integration of the modules is successful and that it runs successfully as well, a test plan, test cases and test data is produced to effectively test that the integration is successful.
Unified Integration Testing Cycle: The Cycle for IUT window is for 3 weeks only for each project. Unit Testing Integration Testing System Testing HLD& AD understanding IUT cases review Reading the HLD& AD for understanding the scope & objective of the project /feature Preparing white box scenarios based on AD & HLD ITP Baseline Test Execution System Test hand over Review the Integration Test Plan with Dev & System testing team and base lining the plan Executing the test cases. Reporting the issues to Dev team. Retesting after code fix. Verification of test results Passing the test case. Uploading Results Handing over the project/feature to System Testing Team with results Uploading the project/feature document with results into Document repository
Unified Integration Testing Flow: Create Test Strategy Create Test Plan / Design Define Scope, Goals, Risks, Perform Entrance/Exit Tests Criteria, Environment, etc. Create Test Scenarios/ Suites/Sets Create Manual Test Cases Automate Test Cases Execute Test Cases Analyze Results If passes If Test case failure if Application Failure Document Results Re-Develop Test Cases Report/Track Defects and Fixes
Prerequisites for Unified Integration Testing: Before we begin Integration Testing it is important that all the components have been successfully unit tested. Entry Criteria: Software functional and design specifications reviewed and approved Code reviewed and approved Unit Test Plan for each module reviewed and approved 100% unit test passed UIT typically involves the following Steps: Create a Test Plan Create Test Cases and Test Data If applicable create scripts to run test cases Once the components have been integrated execute the test cases Fix the bugs if any and re test the code Repeat the test cycle until the components have been successfully integrated What is UIT Plan consist? 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 of an IT tester Prerequisite s 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 for UIT? 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 right way to do integration tests is the opposite of writing unit tests. In a unit test, the approach is to test one and only one class in complete isolation by calling one method and stubbing out or mocking up everything else. In integration tests, you should test not only just one operation, but also perform other related operations to ensure that the operation under test really does what it is expected to do. Test cases are written which explicitly examine the interfaces between the various units. These test cases can be black box test cases, whereby the tester understands that a test case requires
multiple program units to interact. Alternatively, white-box test cases are written which explicitly exercise the interfaces that are known to the tester. Test case example: Insert rows in a database or call a web service to create an entity When testing an operation that creates new data, Ensure the operation was carried out properly by calling other operations that read the data by reading the row again or calling another web service to get the created entity. It should fail if the data was not inserted properly (for example, insert child rows). This is a posit sitive ive test. Calling other operations that would fail if the insert was successful, for example inserting the same row again would produce a constraint violation. This is a negative test. It is important to do both positive and negative tests in integration tests, even if you are doing it in unit tests to ensure that the tests cover all major behaviors of the system. So the UIT 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 application works when the different components are brought together. A dedicated testing team may be created to execute the Integration test cases. Therefore the Integration Test Cases should be as detailed as possible. Exit Criteria: All the test cases have been executed and passed All the severe and moderated defects found have been fixed Interface of each subcomponent has been exercised at least once. UIT Checklist:
Working towards effective UIT: There are various factors that affect Software Integration, 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 versions 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. Automate Build Process where necessary: A Lot of errors occurs because the wrong versions 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. 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. 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.
Benefits of UIT: Collaboration with all stakeholders and have a common understanding. Requirement issues/defects would be captured in early phase itself. Saving cost & time. Quality code could be handed over to system testing. Increase IT efficiency and thus minimize the defects in ST phase. IT Effectiveness after implementing UIT: Success Graph.(Close to 40% of defects caught in IT phase itself just in 3 weeks which saves lot of cost & time) Conclusion UIT becomes more important in software development life cycle. UIT practice increases the IT efficiency trend in testing process. UIT is a continuous improvement process and can be carried over even after the Integration testing is completed. UIT approach yields good result in reality and would minimize the defects, time, and delays and cost over-run. Disconnect between the different stakeholders are minimized and working towards for effective integration testing and quality output to system testing.