The Software Testing Life Cycle (or STLC), is a continuous process of validation and authentication. It's an integral part of software development, and needs to be managed with precision.
Before we begin, there are a few points that should be clear. First off, STLC and Systems Development Life Cycle (SDLC) are not the same, although they aren't completely different either. STLC is a part of SDLC, and therefore cannot exist without it. The two are merged in such a way that each step in STLC should coincide with a particular point in SDLC, making it a repeating process even after the completion of a software.
Secondly, STLC should always concur with the following basic points:
The testing process should satisfy the preliminary design and development process.
It should be able to be easily modified as the need arises.
It should meet all needs of the stakeholders.
The software testing life cycle consists of a series of stages through which a software product goes through, and describes the various activities pertaining to testing that are carried out on the product. Here's an explanation of the STLC along with a flowchart.
Introduction to Software Testing Life Cycle
In every organization, testing is an important phase in the development of a software product. However, the way it is carried out differs from one organization to another. It is advisable to carry out the testing process from the initial stages with regard to the SDLC to avoid any complications.
The Need For a Constant Testing Process Conventional methods prescribe testing to be a phase independent of designing and creating. It comes after the entire module is constructed and essentially 'ready for testing'. But something like that cannot be done in software development.
Let's say we were to roughly divide a conventional constructive method into four parts: gathering requirements, design, building, and post-construction. Now, with the depth of coding required to complete each step, bugs are bound to pop up in all stages. But if you don't test, you'll never find out where the bug is.
If a bug was found while gathering requirements, the cost and time taken to resolve the issue would be very small. As the process gets more and more complicated, finding a bug during building or designing would be exponentially tougher to resolve.
Even if you were to employ a testing phase between building and post-construction, the chances of finding all the bugs aren't always 100%. And if you miss one, which gets on to the post-release version, the cost of resolving the bug will be astronomical.
Software Testing Phases
Software testing has its own life cycle that meets every stage of the SDLC. The software testing life cycle diagram can help one understand its various phases. They are:
1. Requirement Stage
2. Test Planning
3. Test Analysis
4. Test Design
5. Test Verification and Construction
6. Test Execution
8. Bug Tracking
9. Reporting and Rework
10. Final Testing and Implementation
This is the initial stage of the software testing process. In this phase, developers take part in analyzing the requirements for designing a product. The role of software testers is also necessary in this phase, as they can think from the 'users' point of view, which developers may not.
Thus a team of developers, testers, and users can be formed to analyze the requirements of the product. Formal meetings of the team can be held in order to document the requirements, which can further be used as software requirements specification or SRS.
Test planning means to predetermine a plan well in advance to reduce further risks. A well-designed test plan document plays an important role in achieving a process-oriented approach. Once the requirements of the project are confirmed, a test plan is documented.
The test plan structure is as follows:
This describes the objective and formulating a rudimentary method of action while keeping it open to any changes that favor progress.
2. Test Items
The items that are required to prepare the test plan document will be listed here, such as the SRS, the project plan, etc.
3. Features to be Tested
This describes the coverage area of the test plan, that is, the list of features to be tested; that are based on the implicit and explicit requirements from the customer. We review base tests and create more to satisfy any specific goals and then setup automation scripts.
4. Features Not to be Tested
Incorporated or comprised features that can be skipped from the testing phase are listed here. Features that are out of scope of testing, like incomplete modules or those on low severity (for example, GUI features that don't hamper the process), can be included in the list.
We move to the approach after one has been decided. This process needs to incorporate all requirements in their set order of priority, eventually satisfying all of them.
6. Item Pass/Fail Criteria
Certain criteria that have been set to determine whether a script has passed or failed any particular step. Changes are made to the script during each failure.
7. Suspension Criteria and Resumption Requirements
The suspension criteria specifies the criteria that is to be used to suspend all or a portion of the testing activities, whereas resumption criteria specifies when testing can resume with the suspended portion.
8. Test Deliverables
This includes a list of documents, reports, and charts that are required to be presented to the stakeholders on a regular basis during the testing process and after its completion.
9. Testing Tasks
This phase lists the testing tasks that need to be performed. This includes conducting the tests, evaluating the results, and documenting them based on the test plan designed. This also helps users and testers to avoid incomplete functions and prevent waste of resources.
10. Environmental Needs
Including the environment involves figuring out all physical (i.e. hardware) aspects of the final location of the software's operation. This includes the server OS, the client OS, and the database server. All hardware must be taken into consideration to satisfy this step in the STLC.
In this phase critical tasks are assigned to those who will then hold responsibility for any risks. In the event of an error, that person usually has to handle it.
12. Staffing and Training Needs
In this phase members that can train others on the application/system and the testing tools to be used, are assigned.
13. Risks and Contingencies
This emphasizes on the probable risks and various events that can occur and what can be done in such situations.
Here we decide who can approve the process as complete and allow the project to proceed to the next level.
Once the test plan documentation is done, the next stage is to analyze what types of software testing should be carried out at the various stages of SDLC.
Test design is done based on the requirements of the project documented in the SRS. This phase decides whether manual or automated testing is to be done.
In automation testing, different paths for testing are to be identified first and writing of scripts has to be done, if required. An end-to-end checklist that covers all the features of the project is necessary in the test design process.
Test Verification and Construction
In this phase, the test plan, test design, and automated test script are completed. Stress and performance testing plans are also completed at this stage. When the development team is done with a unit of code, the testing team is required to help them in testing that unit and reporting any bug in the product, if found. Integration testing and bug reporting is done in this phase of software testing.
Planning and execution of various test cases is done in this phase. Once the unit testing is completed, the functionality of the tests is done in this phase. At first, top-level testing is done to find out the top-level failures, and bugs are reported immediately to the development team to get the required workaround. Test reports have to be documented properly and the bugs have to be reported to the development team.
After the successful execution of the test case, the testing team has to retest it to compare the expected values with the actual values, and declare the result pass/fail.
This is one of the important stages, as the Defect Profile Document (DPD) has to be updated to let developers know about the defect. The Defect Profile Document contains the following:
1. Defect ID
Each bug gets its own unique identification to track it in the future.
2. Test Case ID
Test case identification for a particular defect. It is useful to track progress.
Detailed description of the bug. Tracking tools like Bugzilla or TTPro may be used to create unique descriptions for each bug.
This field contains some keyword information about the bug, which can help in minimizing the number of records to be searched.
5. Defect Submitted By
Name of the tester who detected/reported the bug.
6. Date of Submission
Date at which the bug was detected and reported.
7. Build Number
The build number is the number of test runs required to satisfy a testing criterion.
8. Version Number
The version information of the software application in which the bug was detected and fixed.
9. Assigned To
Name of the developer who is supposed to fix the bug.
It records the degree of severity of the defect, allowing it to gain or lose priority.
Priority of fixing the bug.
This field displays current status of the bug.
Reporting and Rework
Testing is an iterative process. The bug that is reported and fixed by the development team has to undergo the testing process again to ensure that the problem has been solved. Regression testing has to be done.
Once the Quality Analyst assures that the product is ready, the software is released for production. Before release, the software has to undergo one more round of top-level testing. Thus testing is an ongoing process.
Final Testing and Implementation
This phase focuses on the remaining levels of testing, such as acceptance, load, stress, performance, and recovery testing. The application needs to be verified under specified conditions with respect to the SRS. Various documents are updated and different matrices for testing are completed at this stage of software testing.
Once the test results are evaluated, the recording of errors that occurred during the various levels of the testing process is done. Creating plans for improvement and enhancement is an ongoing process. This helps to prevent similar problems from occurring in future projects. In short, planning for improvement of the testing process for future applications is done in this phase.
Software defects are not always caused by coding errors. In fact, requirement gaps can also result in errors in an application. Though software testing can be carried out at any stage in the development phase, the process is mostly implemented after the requirements for an application have been specified and the coding has been completed.