Posted by: ahmedashfaque | September 11, 2014

Software testing in the agile world

In traditional software development model, there is a distinct phase for software testing software projects. This phase starts after source code writing phase is over. This happens in the classical waterfall model. Now that a large number of projects have adopted the agile model, how software testing function has changed on these agile software projects?

Some of the popular models which can be dubbed as an agile model include Extreme Programming, Scrum, Spiral Model, Cleanroom etc. As is well known that agile software project model basically involves reducing the project size. A large project is divided into many small iterations. Each iteration can be a full small project where a small bunch of software requirements are taken and then converted into a software feature by designing for it and then writing source code for it. In the next iteration, again a small bunch of requirements are taken and a software feature is developed based on these requirements. The new software features are built on top of existing features so that essentially the software product is made through building software features one by one and on top of existing features.

To enable this kind of working, some methods were evolved. Some of these methods include test driven development, story boards, planning games, sprints,  requirement back logs etc. (These methods belong to different agile models.). Even though how iterations are carried out may differ from one agile model to another; the intent of all of the agile models is the same viz. to reduce project size by dividing the project into small iterations. These iterations can run from a couple of weeks to a maximum of 2-3 months.

The fundamental shift which has happened in agile models as far as software testing is concerned is that the source code is written in units and then these unit pieces of source code is integrated to the main build. These two operations happen inside each iteration several times. Then again source code is written in many iterations. The implication is that software testing has to be done at unit level, integration level and lastly above iteration level. Consequently we have unit testing, integration testing and regression testing (done above iteration level).

Unit testing makes sure that each unit of source code is defect free. Integration testing makes sure that the main build is still defect free after a piece of source code is integrated on top of existing source code which is present in the main build. Regression testing makes sure that existing features still work when new features are added in the next iteration.

Apart from these new kind of testing (unit, integration and regression) the usual system and user acceptance testing is also performed in agile models. These tests are done similar to how it is done in traditional software development model. The difference here is that, in traditional model, these tests are done at large project level whereas in agile model, these tests are done at much smaller iteration level.


Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s


%d bloggers like this: