 |
 |
|
 |
 |
Software Testing in Iterative Model
QAI-STC 2006
4
The salient features of iterative model are as follows,
Quick feedback loop from business stakeholders to engineering and then back to
business stakeholders
Ability to refine requirements and design
Early defect detection
Focus on implementing the high priority and the high risk features at an early stage of
development
Short delivery mechanism to improve the quality of output.
7HVWLQJLQ,WHUDWLYH0RGHO±,QGXVWU\9LHZ
The key to successful use of an iterative software development lifecycle is rigorous
validation of requirements and testing of each version of the software against those
requirements within each cycle of the model.
The software developed at each of the iterations will go through the following test phases:
Unit testing (UT)
Component testing (CT)
Integration testing (IT)
Once the entire product requirements are met, that is, during the final iterations, the product
goes through the following test phases:
System integration testing (SIT)
Acceptance testing
How ever some practitioners suggest performing system integration test at of the each
iterations.
Note: Please refer to Appendix-II to understand the different test phases.
3.1 Unit Test Process
The main focus of unit testing is to uncover the code level defects. If N is the current
iteration, unit tests for iteration N are designed in the same iteration by the developers and
peer developers review them. Tests are executed in the same iterations, and the defects
encountered during the testing are fixed during the same iteration.
3.2 Component Test Process
There are no guidelines on the time frame for carrying out the component tests, the
following process can be followed - if N is the current iteration; the tests are designed,
reviewed, and base-lined in the N iteration based on the scope of the current iteration and
th
the tests are executed in the N+1 iteration.
3.3 Integration Test Process
Testing process is similar to that of component testing. A regression test suite or an
accumulated test suite is run to test the interfaces of the components of the current iteration
with the components of the previous iterations.
Software Testing in Iterative Model
QAI-STC 2006
5
3.4 System Integration Test Process
Agile development projects face significant risk of insufficient testing of the
application, particularly outside of a pure code coverage perspective. To decrease the risk of
insufficient testing, the following tests are applied to the overall system when the product is
completely ready:
Stress tests
Load tests
Performance tests
Reliability tests
Security tests at system level
How ever some practitioners suggest running relevant system integration tests optionally
with reduced test scope even in the iterations.
Note: Please refer to Appendix-III for the definitions of the different testing types.
3.5 Acceptance Test Process
A test performed by an end user or system owner to verify that the delivered
software functions correctly and meets requirements. Usually these tests are derived from
use cases of the particular iteration to be tested. The testing process is similar to that of
component testing.
3.6 Test Automation
The iterative model emphasizes on the test automation due to the following test
requirements:
Running integration and regression tests for every iterations
Running more tests in a short span of time (within the time span of an iteration)
Even though there is need for automation, there is no emphasis on the time frame for
development of the automation tool.
3.7 Defect Fixing and Verification
Managing defects within an iterative process is one of the most complex elements of
a project. Its always recommended to factor in the defect fixing and regression activities in
the development and test plans. A common approach followed to manage defects is as
follows - if N is the current cycle; unit testing and defect filing, fixing, and regression
happens in the N iteration. The CT, IT, and SIT happen in N+1 iteration and the defects are
th
filed. Defect resolution (fixation + regression) happens in N+1or N+2 iteration depending on
the defect priority.
Software Testing in Iterative Model
QAI-STC 2006
6
4 Testing Approaches Adopted for Iterative Model
At Novell, Bangalore many product teams follow the iterative model of product
development. The product teams have tailored the model for the development and testing
activities based on the project needs and characteristics, such as:
Product size: small, medium, or large scale
Project duration
Team size
Release type: new, enhancement, or maintenance release
Geographical distribution
Project phase at which the model has been adopted
This section focuses on the different testing approaches followed at Novell Bangalore for the
iterative model.
4.1 Approach A
This is a large-scale project, where the product is built from scratch. The main
reason for adopting this model is to track and control the product development activities as it
involves a lot of interdependent components and cross functional teams
Project Characteristics
Product size: Large scale
Project duration: 24 months
Team size: 42 people
Iteration size: 2 to 6 weeks
Release type: New product release
Geographical distribution: Cross functional teams spread across different
geographical locations.
Test Team's Participation
Only unit test, component test, and integration test teams participate in each of the
iterations.
ST follows the classical waterfall or V model for test design, automation and execution.
Test Design
Unit test cases for the iteration N are designed and base-lined in iteration N-1or N
th
iteration.
Component test cases and integration test cases for the iteration N are designed and base-
lined in iteration N.
System integration testing followed the traditional V-Model, that is,. system integration test
cases design and baseline process are not inline with the iterations. The test design starts
once the base-lined product requirements documentation and HLD are made available.
Software Testing in Iterative Model
QAI-STC 2006
7
Test Automation
Test frameworks for UT, CT, and IT are made available before the iteration process stared.
Unit test automation for iteration N was starts in the iteration N-1or N.
Component and unit test automation for iteration N starts in iterations N and N+1
System integration test automation tool development starts as soon as the system
integration test cases are base-lined, and are independent of the iteration model.
Test Execution and Defect Tracking
Unit testing for the software in iteration N is done in iteration N. The closure of the defects
found by unit testing is done in iteration N itself.
Component and integration test execution for software in iteration N are done in iteration
N+1 along with defect regression for the defects filed on the software of N-1 iteration.
Along with component and integration test suite of the given iteration, the accumulated test
suites are executed.
Execution efforts increase for every iteration, as the tests get accumulated with every
iteration.
System integration test cases get executed during the last iterations when the product is
almost feature complete as in the classical waterfall or V-model
4.2 Approach B
This is medium scale project, where product is in the maintenance state. The team
works on multiple related products, which also follow the iterative model and all the products
get bundled and released at the same time. Development of all the products of the software
bundle happen concurrently using the common iteration process. The main objective of
adopting this model is to be in sync with other project schedules and to handle multiple
products in the same iteration cycles.
Project Characteristics
Product Size: medium scale
Project duration: 9 months
Team size: 10 people
Iteration size: 1-3 weeks
Release type: Maintenance release
Geographical distribution: Product team at one geographical location
Project phase at which the model has been adopted: During coding phase.
Test Team's Participation
The entire test team; unit test team, component test team, integration test team, and system
integration test teams participate in the iterations.
 |
|
 |
|