The quality of a software product impacts directly the brand reputation and influences client retention. Just a single faulty product can have disastrous consequences for both the business using the product and the company that has developed it. That’s why ensuring the top quality of every developed product is our main goal.
That’s why we test our software. Software testing reduces the possibility of errors and bugs.
Software testing life cycle
Contrary to common belief, software testing is not a single action. It is not even a single step or stage in the product development cycle.
What is the software testing life cycle?
Software testing life cycle (STLC) is a sequence of specific actions performed during the testing process to ensure that the software quality objectives are met.
Software testing is performed in stages, along with the software development. Here, we shall distinguish clearly the software development life cycle and software testing life cycle.
Software development life cycle is about collecting requirements and developing features based on the collected requirements.
Software testing life cycle is about creating tests to ensure that the developed features meet specific requirements.
STLC in agile environment
While the STLC looks pretty robust, it is successfully applied in agile teams like ours. We load clean builds of software several times a day using automated compilation and unit test execution. This approach is known as continuous integration.
Another benefit of our agile team is our ability to release product features at the end of each iteration. So, we can provide the client and the users with a stream of continuous value through constant product releases. It is known as continuous delivery.
Software testing life cycle phases
We perform testing and programming concurrently. Even though we adapt our testing methodologies to every specific project, the core phases are the same. They are carried out in a specific order to ensure the viability of your software product.
The main stages of the software testing life cycle are the following:
- Requirement analysis
- Test planning
- Test case development
- Test environment setup
- Test execution
- Test cycle closure
At this stage, we collect requirements from the testing point of view. These requirements can be functional (determine what a specific feature can do) or non-functional (characteristics of a feature).
Then, we assess the possibility of automating testing processes, learn about testing priorities, and identify the testing environment.
Once the requirement collection stage is over, we move to the planning stage.
At this stage, a senior QA manager determines the testing strategy along with the testing environment, resources, schedule, and budget. Roles and responsibilities are also determined and documented during this phase.
When this stage is completed, we have a plan for testing. The plan addresses the critical areas of the project deliverables.
One of the main challenges of the planning stage is that the time needed for testing is frequently underestimated. Our experience shows that testing takes from 30 to 50% of the time needed for development. Here, it is important to find the right balance between not sufficient testing and over-testing. The first one leads to increased project risks and failures in the product after its release. The latter means more resources wasted, deadlines delayed, and frustration of other team members.
Test case development
When the test planning is completed, we move to the test case development stage. At this stage, we create test cases.
A test case is created to determine the flow of activities needed to test a specific set of requirements. A test case determines the action consequence needed to perform a specific testing scenario.
We store test cases in either Google Docs or Jira. For each case, we define the following components:
- Testing environment
- Testing procedures
- Execution conditions
- The expected results
Each test case is based on a specific real-life business process addressed in the product.
At the end of the test case development stage, we have test cases that cover all the main requirements of a project.
Test environment setup
At this stage, we configure and deploy testing environments. For this, we use a number of tools such as Appium, Selenium, PyTest, Cucumber, Selenoid, and Jasmin. Test servers are also set up at this stage.
The QA team might be not involved in this stage if the development team provides the testing environment. In such a case, the test team just checks the readiness of testing environments.
The goal of this phase is to identify the defects in a software release. Test execution is carried out based on the test plans and in the predetermined and prepared testing environment. The process can be divided into the following main phases:
- Test script execution
- Test script maintenance
- Bug reporting
If bugs are detected, the development team works on their fixes. After the bugs are fixed, retesting is conducted.
Test cycle closure
With the test cycle closure stage, the testing procedures are completed. During this phase, the team prepares the following documents:
- Test completion reporting
- Test metrics
The team members meet to discuss the testing activities and artifacts. We check the results, discuss the difficulties, and determine the bottlenecks to adjust the testing strategies for future projects.
Quality control vs quality assurance
Now, we move from QA (Quality Assurance) to QC (Quality Control). These two terms are still used interchangeably even though it is not correct.
Quality assurance comprises administrative and procedural activities implemented in a quality system so that requirements and goals for a product, service or activity will be fulfilled.
Quality Control is a set of processes to ensure that the quality of the product is appropriate. The main aim of QC is to ensure that the product meets the requirements (both functional and non-functional).
The key differences between QA and QC can be clearly seen in the table below.
Key differences between QA and QC
- Its main aim is to avoid defects in the product
- It is performed during the software development life cycle
- It is a proactive measure
- All team members are involved
- Is performed before the Quality Control Stage
- Its main aim is to identify and fix the defects
- It is performed during the software testing life cycle
- It is a reactive measure
- Only the testing team is involved
- Is performed after the Quality Assurance Stage
Some teams skip the QA and QC stages to save time and reduce costs. However, this approach has proven itself faulty. Software testing might look pretty challenging but it helps to ensure the quality and reliability of a product.
QA ensures that all the processes for creating and managing deliverables are followed and helps to detect faults in the process. QC ensures that the project deliverables meet the defined quality standards. Therefore, QA and QC not only help to save time and money but to guarantee that the project complies with the client’s expectations and quality standards.