AGILE methodology is a continuous iteration of development and testing. This methodology follows the software development lifecycle of the project. As in the waterfall model, to develop software, you have to first complete the first phase. Then, and only then, you can move to another phase. But in Agile methodology, development and testing activities are concurrent.
Now, I hope we got an idea of what Agile is.
So, we can step on to Agile Testing.
Agile Testing in a Nutshell
A software testing technique that follows the principles of Agile software development is called Agile Testing. It is an iterative development methodology.
Agile testing starts at the beginning of the project with the continuous integration between the development process and testing. It is not sequential but continuous.
The agile team works as a single team to achieve a common goal. The goal, of course, is the quality of the product. This testing has lesser time frames called iterations. Each iteration can be from 1 to 4 weeks.
Agile methodology calls the action of completing an iteration a release. This makes Agile Testing a delivery driven approach. It gives a better prediction of the workable products faster.
Here, we deliver a product with minimal functionalities to the client at the earliest possible time. With every next delivery, new features and functionalities are added to the product. This development and testing provide a higher level of customer satisfaction.
The Principles of Agile Testing
- Testing is NOT a Phase: It is a continuous process.
- Testing Moves the project: Agile testing provides feedback on an ongoing basis and the product meets the business demands.
- Everyone Tests: This includes developers and BAs to test the application as an addition to the testing team.
- Shortening Feedback Response Time: In agile, for each and every iteration, BA’s are involved. So in this way, continuous feedback shortens the feedback response time and costs involved in fixing.
- Clean Code: Defects are fixed within the iteration that they are found.
- Test Driven: In agile testing, testing is done while implementation.
Before moving forward let’s have an introductory discussion about the Agile methodology.
So let’s go ahead…
Agile Testing Methodology
There are so many methods presents in Agile Testing and those are listed below:
- Crystal Methodologies
- Dynamic Software Development Process
- Feature Driven Development
- Lean Software Development
- Xtream Programming
SCRUM is an agile development method. It mainly focuses on how to manage tasks within a team-based development environment. Basically, Scrum is derived from the activity that occurs during a rugby match. Scrum believes in empowering the development team.
This team consists of 7 to 9 members only. It consists of three roles, and each role has its job responsibility. These three roles are as follows:
- Scrum Master,
- Product Owner,
- Scrum Team.
This methodology is based on three concepts. They are as follows:
Chartering: In this phase, activities like creating teams, preliminary feasibility analysis, developing an initial plan, and fine-tuning takes place.
Cyclic delivery: This development phase consist of two or more delivery cycles. During these delivery cycles, some action takes place like
- Team update,
- Refine the release plan,
- Implements a subset of requirements,
- Program tests integrate iterations,
- The product is delivered to actual users.
Wrap Up: Post-deployment reviews and reflections are performed in this phase.
Dynamic Software Development Process
Basically, dynamic software development is a Rapid Application Development approach and it provides an agile delivery framework. The users are required to be involved actively, and the teams are given the power to make decisions in this Development process. DSDM uses different techniques that are as follows:
- Time Boxing,
- MoSCoW Rules,
DSDM project consists of 7 phases
- Feasibility Study,
- Business Study,
- Functional Model Iteration,
- Design and build Iteration,
Feature Driven Development
FDD basically focuses on “Designing & Building” features. It describes the short and very specific phase of work. It includes domain walkthrough, design inspection, code inspection, and design. FDD develop products to keep some things in the target that are as follows:
- Domain object Modeling,
- Development by feature,
- Component/ Class Ownership,
- Feature Teams,
- Configuration Management,
- Regular Builds,
- Visibility of progress and results.
Lean Software Development
It follows a principle that is “Just in time production“. The main aim of this method is to increase the speed and reduce the cost. It has 7 steps that are as follows:
- Eliminating Waste,
- Amplifying learning,
- Defer commitment (deciding as late as possible),
- Early delivery,
- Empowering the team,
- Building Integrity,
- Optimize the whole.
This method is very useful when the requirements changing frequently from the customer. It provides a frequent release of the product with the checkpoints where user requirement can change or implement easily.
There are six phases of XP, are as follows:
Agile Testing Strategies
Top Ten Tips For Agile Testing
So, let’s come to the main point of this blog i.e the tips that make agile testing easy.
1. Integrate the testers in the development teams
Teams (Development and Testing teams) are responsible for delivering software that meets the requirements or expected requirements and quality of the client. Giving the knowledge training to the teams to do it right is a must.
Testers have that knowledge. By integrating testers into the development teams, teams obtain the skills which they need to test their software. When you try this, make sure you choose the right mix of team. This means that one tester for three programmers is a fair but minimal number.
2. Use risk-based testing
You can never test everything with extensive depth, even in a waterfall project.
In an Agile project, all the activities are time-boxed. In other words, there is a time limit on the project. So, you have to make choices on how extensively you want to test each feature.
You should use a risk-based approach to determine which test activities should be carried out for a feature during the iteration. The risk level of every feature is determined by the teams and customers.
Risk-based testing is a very transparent process. The customer knows exactly which test activities are executed for every feature.
3. Have testers review unit tests
The developers are responsible for creating and maintaining the unit tests in most of the company/organization. Unit tests are a very important part of our test harness. Developers often have a different way of thinking:
For example, Developers tends to test only the success scenario.
Testers review the unit tests for all high-risk items and create unit tests that are the best possible. This review has two advantages:
Firstly, it improves the tests or unit tests because testers and developers supplement each other. The developers know about the weaknesses of the source, and the tester can use his knowledge of testing to give tips to improve the unit tests.
Secondly, the testers know exactly which test cases are executed in the unit tests and can concentrate on executing other test cases (on high-level).
4. Create a test automation framework
There are some issues which are difficult to find. Automation testing plays a major role here.
Automated testing has a feature like refactoring that helps to introduce problems that can be difficult to find. During the iteration, you can maintain quality levels by using an automated test framework. Testers are able to create new tests easily and quickly within the framework.
You can appoint a particular person named as toolsmith that maintains and optimizes the test automation framework. This person will review the new automated tests of the testers and analyze the daily test results.
5. Display quality metrics in a public location
Almost every software project has a problem with automated test results, registration system, and in some cases, continuous build results. But how often do team members look at the results or count the open problems?
You can install a system in a room and this will show the actual metrics of the currently open problems, % of successful unit tests, % of successful builds, and the current state of the continuous build.
The teams are confronted with the information by displaying the metrics in public. This way, the information is no longer just a number in a system or a record with some other information in a metrics database.
6. Add a test scrum
One of the advantages of having a separate test team is that there is communication improvement between the testers.
When you have a project where the testers are distributed across several teams, communication becomes more difficult. To solve this problem, use a test scrum to align the test activities in a proper manner. Test scrum should be held twice a week and every team represented by one tester.
The test scrum is a scrum like the daily team scrum but focused on test activities. The test manager is the Scrum Master of the test scrum.
7. Implement test retrospectives
Every team in a project holds a retrospective meeting that is held at the end of the iteration. The team discusses the process and checks that process to find what went well and what went wrong in this retrospective.
Testers in the team learn and discover new ways to improve tests. The sharing of knowledge with testers from the other teams helps everyone.
This way, testers can exchange knowledge and experience. They discuss problems that they have with the retrospective. It is important that the retrospective is only related to testing issues. Therefore, you should not discuss team issues.
As with the test scrum, the test manager is the Scrum Master of the test retrospective.
8. Plan for open problems
You should try to fix the problems that you find during the iteration in that same iteration. Sometimes, you have to end up the iteration with open problems.
To add open problems into the sprint backlog for the next iteration is the best way to handle this type of problem. Through explicitly planning the management of this open problem that they are “forgotten” and pile up is very small.
9. Remember: Testing is still testing
When you are going to test an Agile software project, you can still use the ‘Traditional’ test techniques.
You should use exploratory testing, but you need to also apply test techniques such as boundary value analysis, equivalence partitioning, cause/effect diagram, and pair-wise testing.
Which test technique you choose for a feature purely depends on its risk category. Exploratory testing is used in every category, but if the risk is higher, then you should also apply more formal test techniques. Here, a challenge for the tester arises to use a formal test technique without delivering extensive test documentation.
10. Start doing it!
The last, but the most important tip is to start doing it. There is no need to talk too much about how you are going to introduce testers, or which test approach is perfect for your company/ organization. You are going to make mistakes. You are also going to discover that the chosen approach does not fit your company/organization.
The sooner you will start, the sooner you can begin learning and improving your test approaches. With the retrospective meetings, you have an opportunity to adapt your test approach every month.
Now, you have some basic idea of how testing works with agile methodologies.
Basically, Agile testing involves testing as early as possible in the software development life cycle. With it, customer involvement is very important.
The code should be stable to do system testing. An extensive regression testing can be done to make sure that the bugs are tested and fixed.
Communication between the teams makes an agile testing success.
- COVID-19: How We Are Dealing With It as a Company - March 23, 2020
- Agile Testing – The Only Way to Develop Quality Software - February 8, 2019
- How to Perform System Testing Using Various Types Techniques - May 16, 2018