Tools are relevant and used by testers in agile teams. Not all tools are used in the same way, and some tools are more relevant to agile projects than to traditional projects. For example, although test management tools, requirements management tools, and incident management tools (defect tools) can be used by agile teams, some agile teams opt for a comprehensive tool (e.g., application lifecycle management or task management) that provides features relevant to agile development, such as task boards, burndown diagrams, and user stories. Configuration management tools are important for testers in agile teams because of the high number of automated tests at all levels and the need to store and manage the associated automated test artifacts.
Testers in agile projects may also use the tools described in the following subsections. These tools are used by the entire team to ensure team collaboration and information sharing, which are central to agile practices.
Task Management and Tracking Tools
In some cases, agile teams use physical story/task boards (e.g., whiteboards, corkboards) to manage and track user stories, tests, and other tasks during each sprint. Other teams use application lifecycle management and task management software, including electronic boards. These tools serve the following purposes:
- Recording stories and associated development and testing tasks to ensure that nothing is lost during a sprint
- Capturing team members’ estimates of their tasks and automatically calculating the effort required to implement a story to support efficient iteration planning sessions
- Link development and testing tasks to the same story to get a complete picture of the team’s effort to implement the story
- Aggregate task status updates from developers and testers as they complete their work to automatically provide an up-to-date snapshot of the status of each story, the iteration, and the entire release
- A visual representation (via metrics, charts, and dashboards) of the current status of each user story, iteration, and release so that all stakeholders, including those on geographically dispersed teams, can quickly review the status
- Integration with configuration management tools that can enable automatic recording of code check-ins and builds against tasks and, in some cases, automatic status updates for tasks
Communication and Information Sharing Tools
In addition to email, documents, and verbal communication, agile teams often use three other types of tools to support communication and information sharing: wikis, instant messaging, and desktop sharing.
Wikis allow teams to build and share an online knowledge base on various aspects of the project, such as:
- Diagrams of product features, discussions of features, diagrams of prototypes, photos of whiteboard discussions, and other information.
- Tools and/or techniques for development and testing that other team members find useful
- Metrics, charts, and dashboards on product status, which is especially useful when the wiki is integrated with other tools such as the build server and task management system, as the tool can update product status automatically
- Conversations between team members, similar to instant messaging and email, but in a form that is accessible to all other team members
Instant messaging, audio teleconferencing, and video chat tools provide the following benefits:
- Direct, real-time communication between team members, especially for distributed teams
- Engage distributed teams in standup meetings
- Reduce telephone costs by leveraging voice-over-IP technology and eliminating cost constraints that could impact communication between team members in distributed environments
Desktop sharing and capturing tools provide the following benefits:
- Product demonstrations, code reviews, and even pairing can take place in distributed teams
- Recording of product demonstrations at the end of each iteration that can be published to the team’s wiki
These tools should be used as a complement and extension, not a replacement for face-to-face communication in agile teams.
Software Build and Distribution Tools
Building and deploying software on a daily basis is an important practice in agile teams. This requires the use of continuous integration and build distribution tools.
Configuration Management Tools
In agile teams, configuration management tools can be used not only to store source code and automated tests, but manual tests and other test work products are often stored in the same repository as the product source code. In this way, it is possible to track which versions of the software were tested with which test versions and to make quick changes without losing historical information. The main types of version control systems include centralized version control systems and distributed version control systems. The size of the team, structure, location and integration requirements with other tools will determine which version control system is appropriate for a particular agile project.
Test Design, Implementation, and Execution Tools
Some tools are useful for Agile testers at specific points in the software testing process. While most of these tools are not new or specific to Agile, they provide important functionality given the rapid pace of change in Agile projects.
- Test design tools: the use of tools such as mind maps have become increasingly popular to quickly design and define tests for a new feature.
- Test case management tools: The type of test case management tools used in Agile can be part of the application lifecycle management or task management tools used by the entire team.
- Test data preparation and generation tools: Tools for generating data for an application’s database are very useful when a lot of data and data combinations are required to test the application. These tools can also help redefine the database structure when the product changes during an agile project and refactor the data generation scripts. This allows test data to be updated quickly as changes occur. Some test data preparation tools use production data sources as raw material and use scripts to remove or anonymize sensitive data. Other test data preparation tools can help validate large data inputs or outputs.
- Test data loading tools: After data is generated for testing, it must be loaded into the application. Manual data entry is often time-consuming and error-prone, but there are data loading tools that make this process reliable and efficient. Many of the data generator tools even include a built-in data loading component. In other cases, bulk loading via database management systems is also possible.
- Automated test execution tools: there are test execution tools that are more focused on agile testing. Specific tools are available, both commercial and open-source, that support early testing approaches such as behavior-driven development, test-driven development, and acceptance test-driven development. These tools allow testers and business personnel to express expected system behavior in tables or in natural language using keywords.
- Exploratory testing tools: Tools that capture and log the activities performed in an application during an exploratory testing session are beneficial to testers and developers because they record the actions performed. This is useful when a bug is found, as the actions are taken before the bug occurred are recorded and can be used to report the bug to developers. Logging the steps taken in an exploratory test session can prove beneficial when the test is eventually included in the automated regression test suite.
Cloud Computing and Virtualization Tools
Virtualization allows a single physical resource (server) to operate as many separate, smaller resources. When virtual machines or cloud instances are used, teams have a larger number of servers available for development and testing. This can help avoid delays associated with waiting for physical servers. Provisioning a new server or restoring a server becomes more efficient with snapshot capabilities built into most virtualization tools. Some test management tools now use virtualization technologies to take a snapshot of servers when a bug is discovered so that testers can share the snapshot with developers investigating the bug.