According to the Capgemini World Quality Report, 42% of survey respondents have identified a lack of professional test experience as a hindrance in the implementation of testing techniques for Agile development. While Agile has enabled a faster workflow for software development endeavours, quality has been known to suffer as a result in certain cases.
Teams are facing immense pressure to continually provide new product updates, however this comes with a cost. It has been noted that there is a decrease in the amount of attention paid to testing as a result of this. Rob Mason has even gone so far as to allege that Agile development is causing software testing to suffer. To counterbalance this, Facebook has recently modified its slogan from “move quickly and break stuff” to “move fast with reliable infrastructure”, in order to resist the urge to sacrifice quality.
How does testing into the new world of Agile software development? Testing that is agile.
Traditional testing typically requires a significant investment of time and resources, and is heavily reliant on detailed documentation. In contrast, Agile testing is an approach to testing that follows the principles of Agile software development, which emphasises collaboration, flexibility, and fast delivery of working software. Agile testing is designed to be an iterative process, with testing being completed in a continuous cycle of development and refinement. This approach allows for more rapid feedback and more efficient use of resources, resulting in more reliable software.
- Tests are performed on a much more frequent basis
- Documentation is less important than team member involvement in testing, and
- developers sometimes perform certain testing tasks.
Over the last seven years, I have had the privilege of assisting multiple organisations in transitioning to Agile testing practices and collaborating with testers to update their processes to suit the new approach. This blog post aims to provide some of the most effective insights I have gained from my journey to enhance Agile testing. It is inevitable that there will always be a presence of friction between speed and quality when utilising Agile techniques, however, this article will cover a handful of techniques that can be implemented to raise testing quality levels without compromising the agility of the system. In order to successfully implement the advice outlined in this post, it is recommended that both developers and testers partake in the preparation process in order to achieve the best results possible.
Create a process that defines a Release Test Cycle
The absence of a structured release testing cycle, a predetermined release schedule, or unpredictable testing requests can make testing difficult to manage. Unanticipated requests for testing can complicate the quality assurance process, especially when testers are juggling multiple projects.
Many Agile teams limit themselves to only one build after each sprint, which is not the most effective way to manage projects. It may be beneficial to shift to weekly releases, which can then be incrementally increased to multiple builds per week. To ensure successful builds, it is recommended that development builds and tests be conducted on a regular basis, with developers uploading their work to the repository each day and scheduled builds occurring at a pre-determined time. Taking this concept one step further, teams can opt to use a Continuous Integration/Continuous Deployment (CI/CD) approach, which significantly reduces the risk of a failed build when a major release is due.
When Continuous Integration/Continuous Delivery (CI/CD) and test automation are combined, it enables developers to detect critical defects early on, allowing them to address any serious bugs before the scheduled client release. According to one of the Agile principles, working software is the primary indicator of progress. Establishing a clear release cycle also helps to make the testing process more agile in this type of environment.
Testers should have access to deployment tools
Testing personnel often encounter difficulty when it comes to pushing code to a staging environment. Despite the fact that the technological infrastructure involved in this process may be beyond the control of your team, you may have some room to manoeuvre. It is possible to create solutions that allow non-technical personnel such as testers and project managers to independently distribute the updated codebase for testing purposes.
On one of my teams, we leveraged both Git for version control and Slack for communication. The developers created a Slackbot with Git, deployment scripts, and a single virtual machine. This allowed the testers to contact the bot using either a GitHub or Jira branch name and have it be deployed in a staging environment.
This solution proved to be extremely beneficial for developers, as it allowed them to save a considerable amount of time by eliminating the need to communicate and coordinate with testers when they needed to deploy a branch for testing. This prevented unnecessary delays and interruptions which would have otherwise been caused by the communication process.
Test around with TDD and ATDD
Test-driven development (TDD) is a software development approach that emphasises the importance of quality. Rather than the traditional process of a developer writing code and then being tested by someone else, TDD requires unit tests to be undertaken before any code is written in order to fulfil a user’s narrative. Once these tests have been completed, the code is written to the minimum necessary to pass the tests and is then refactored to meet the team’s quality standards.
Acceptance Test-Driven Development (ATDD) is a process that follows a similar approach to Test-Driven Development (TDD) but with a particular focus on acceptance testing. In this approach, acceptance tests are created and agreed upon by developers, testers and the requester (such as the client, product owner, or business analyst) before any code is written. This helps to ensure that the team has a clear understanding of the client’s requirements before any development takes place.
Test-driven development (TDD) and acceptance test-driven development (ATDD) techniques help to make the testing process more agile by bringing it into the early stages of the development lifecycle. In order to ensure that this is done effectively, it is essential that developers fully understand the requirements before creating test cases. This minimises the need for additional coding and helps to identify any potential uncertainties with the product before the development phase begins. Failing to do this can result in issues or disagreements arising further along the development process, resulting in an increase in both the time and cost of the project.
If You Want To Find Inefficiencies, Look At The Task Card Movement
Our team had a developer who was incredibly efficient at completing smaller tasks. Despite the numerous comments they received during code reviews, our Scrum Master and I attributed this to their inexperience. However, when they began working on more complex projects, the problems became more apparent. They had developed a tendency of sending code to testing before it was fully ready to go. This is often a sign of a lack of communication within the development process, such as when it is not clear how much time employees are spending on a given task.
Developers may be tempted to focus on releasing features as quickly as possible, while delegating the responsibility of quality assurance to the testing team. However, this approach simply delays the problem and does not address the underlying issue. Quality Assurance (QA) is essential to the development process and provides a critical safety net. Without proper QA, developers can become complacent about quality issues and may not take the necessary steps to ensure their code is of the highest quality.
By utilising Jira project management software, we were able to track the movement of task cards on a Scrum or Kanban board, in order to gain an understanding of what occurred with the developer’s tasks and compare them to other developers on the team. Through this investigation, we discovered that:
- His time on our board was almost twice spent in our testing column;
- He experienced a great deal more QA rejections for fixing rounds two or three.
As a result of the extra time spent and the frequent repetition of tasks, testers experienced a great deal of repetition and inefficiency. Our opaque method of working gave the impression of developers being incredibly quick, yet this was not the case when the testing time was taken into account. It is evident that the continual passing of user stories is not an effective strategy in terms of achieving the highest levels of efficiency.
In order to address the problem, we held an open discussion with the developer. He was unaware of the negative impact of his methods, as he had been using them at his previous job, where the standards for quality were lower and there was a larger team of testers. After our conversation and a few joint programming sessions with our Scrum master, he changed his approach to development, leading to a higher level of quality. Despite his quick coding skills, the removal of unnecessary steps in the quality assurance process significantly improved the speed and efficiency of the testing process.
The QA team should be trained in test automation
In traditional, non-Agile projects, testing involves a sequence of tasks such as test analysis, test design, and test execution that require substantial documentation. When an organisation transitions to Agile, the focus tends to be on the developers rather than the testers. This shift often involves discontinuing the production of comprehensive documentation, an integral part of conventional testing, while continuing to do manual testing. However, manual testing tends to be slow and may not be able to keep up with the fast feedback loops that are so crucial to Agile.
A successful strategy to address this problem is to employ test automation. This approach enables developers and testers to focus on other tasks while the testing scripts are running in the background. Additionally, automated testing allows for a broader testing coverage as compared to manual testing, as the tests are executed mechanically. Consequently, it is much easier to test small modifications and new products.
Automated tests are pieces of software code that are analogous to the codebase being tested. Consequently, those responsible for authoring automated tests must possess technical expertise in order to be successful. Depending on the team, there are various approaches to automated testing. For each new feature, developers might take on the role of testers and increase the testing codebase. Alternatively, manual testers may be trained to use test automation technologies in other teams, or an experienced technical tester may be enlisted to automate the testing process. No matter which option the team chooses, automation leads to much more agile testing.
Manage Testing Priorities
In non-Agile software development, testers are typically assigned on a per-project basis. However, with the introduction of Agile and Scrum, it has become common for Quality Assurance (QA) personnel to work on multiple projects. When a tester gives preference to one team’s release testing over another’s sprint planning session, this can create scheduling conflicts and lead to testers missing important meetings.
Given the lack of a consistent flow of jobs in the testing field, it can be difficult to convince stakeholders to commit to a dedicated testing resource for a team. However, there are certain tasks that a tester can carry out when not actively engaged in testing activities. This means that testers are often required to work on multiple projects, as there is not always enough work available to keep them occupied on a full-time basis.
SUPPORT FOR CLIENTS
It is possible to create a scenario in which the tester uses their time outside of sprints to help the client support team. This experience of being exposed to customer issues allows the tester to gain a better understanding of the user experience and how it can be improved. Furthermore, the tester can be invited to participate in planning meetings, providing valuable input to the discussions. Through this, the tester can become more familiar with how their customers use the product, and this knowledge can be used to inform their testing activities.
MANAGEMENT OF PRODUCTS
Another method for managing tester priorities is to assign them as junior product managers who carry out manual testing. This is advantageous as junior product managers have a great deal of understanding of various tasks due to the amount of time they spend developing user stories. Additionally, it may serve as a way to occupy a tester’s free time.
Previously, it has been noted that manual testing is generally less efficient than automated testing. To promote the use of automation, it may be beneficial to have a tester focus solely on the team’s projects and utilise their extra time to become proficient in automation technologies, such as Selenium.
In summary, quality agile testing
It is essential for many software development teams to become more agile in their testing practices. However, this transition should not come at the cost of quality. A successful Agile transition necessitates a shift to Agile testing, and there are a variety of ways to achieve this goal.
- Create a formal release testing procedure.
- Give testers deployment tools.
- It can be beneficial to consider test-driven development and acceptability test-driven development.
- Identifying inefficiencies via task card movement is possible.
- The QA team should include test automation in their skill set.
- Determine the priorities of testers.
As the software industry continues to progress, user expectations and demands for higher quality goods increase. This is due in part to the success of respected software giants such as Google, Apple, and Facebook, who have set a high standard for quality. Consequently, quality assurance and software testing are becoming increasingly essential for software companies in order to meet the ever-growing expectations of their customers. In the coming years, it is likely that the testing process will need to evolve to become more agile and efficient, while still guaranteeing the highest level of product quality.