February 28, 2020
Exploratory Testing (And How To Actually Do It)
Software testing is done throughout the various phases of building an application or program to measure different responses and functionality of the code. Exploratory testing is a valuable testing method that encourages the testers to use their knowledge and skills to produce a high-quality product that delivers a seamless user experience. It is the simultaneous execution of test and design to uncover any critical bugs in the code that other testing methods may overlook.
The method is closely tied to creative thinking, discovery, and learning. In this article, we will walk you through this testing approach and how to perform it. We will also cover when exploratory testing should be used, as well as some of the challenges you might face.
What Is Exploratory Testing?
Exploratory testing is a form of software testing that is performed to establish the feasibility of a product. In other testing methods, which we’ll get to below, test cases are created in advance and then executed at a later stage. Whereas exploratory testing involves simultaneously designing and executing the test. Exploratory testers need to be able to think and take action quickly rather than follow laid out steps.
This doesn’t mean that the process is random as testers should jot down ideas and go in with an idea of what to test before the actual test execution. The premise is that more weight is placed on the freedom of the testers to explore without a set plan.
As exploratory testing is widely used in Agile models, let’s expand on the methodology for context. The agile methodology encourages continuous testing and development throughout the development process of software projects. Exploratory testing is often used in Agile models because it links up with the concepts of discovering, investigating, and acquiring a greater understanding of the code undergoing testing.
The freedom of the tester in exploratory testing is greater than with other types of testing – but with great freedom, comes great responsibility. Exploratory testing can be fairly rigorous, and cognitively taxing. Some issues will be easy to spot, but some will really require an experienced tester to navigate.
Exploratory testing is more of an approach than a technique. It is also best performed by experienced developers who can think creatively and outside the box during the process. The approach is important because it can pick up errors that wouldn’t necessarily be found while using other testing methods. The tester needs to continually decide where to spend their energy, and what to test next.
Exploratory Testing Versus Scripted Testing
In scripted testing, the test case design and the test execution are separate processes. With exploratory testing, these processes occur simultaneously so the test is not completely planned in advance.
Software functionalities are also checked in a very structured manner during scripted testing, as opposed to the random style of exploratory testing. Note that ad-hoc testing is not exploratory testing – exploratory testing has a purpose in mind, but there is minimal planning involved.
There is a misconception that scripted testing is automated, but this is not always the case. Simply put, it is a method of testing that follows step-by-step instructions, where the results of the test are then compared to what was expected to happen. This can also be done manually.
Scripted tests that are automated are not used to find bugs – instead, they ensure that the functions that worked previously, still work. Unlike exploratory testing, this is not so much a cognitive process as it is a procedural one. In other words, it doesn’t require much thinking as all of the steps are already laid out.
Exploratory testing emphasises the concepts of learning and adapting, while scripted testing emphasises the concepts of prediction and decision making. Scripted testing is essentially testing from a draft – the tester follows the instructions, and there is no need to deviate from the draft. Exploratory testing activates thinking and problem-solving in testers and is more spontaneous.
Performing Exploratory Testing
Exploratory testing can also be called Session-Based Test Management (SBTM) and is performed in five stages.
1. Break It Down – Taxonomise Bugs
- Be categorical when jotting down some common issues that have come up in previous projects
- Identify the root cause of the issues
- Find risky areas and formulate a plan to test the code
2. Create A Test Charter To Guide The Testing Process
A charter is one sentence that carries a lot of power. It needs to describe what is being explored, how it’s going to be explored, and what the expected outcome is. It should go something like this:
‘Explore (aim of exploration) with (insert what resources you have) to discover (information)’.
Essentially, the charter will help in solidifying the end-user experience and is the responsibility of the tester to write up. Here are some points on how to find ideas for test charter construction below. This is a very important step.
- Consider stakeholders questions
- Address implicit expectations that deal with reliability, company standards, industry standards and performance
- Examine the requirements (this is especially important with vague areas that have seemingly no requirements)
- Explore new discoveries or software knowledge recently acquired
3. Timebox Tasks To Stay Efficient
Time-boxing involves setting fixed time periods for activities to be completed in. The time frame is relative – suggested periods range from 20 minutes to 90 minutes.
- With software development, it is recommended that two people (an observer and a tester) team up for a time-boxed period to check the reactions of the system
- No matter how long the time period is, the testers should not be interrupted during the session
4. Review The Results
This step is where the software faults and issues get analysed.
- Since this is exploratory testing, a big part of this process is to learn
- There needs to be an analysis of the areas covered during testing
5. Debrief Session
Lastly, the results from testing need to be compiled into a report. These need to be compared with the results from the test charter that was drawn up in the second phase. If it matches, the user experience is what it was expected to be. If not, the testers should consider an additional round of testing to make sure that nothing was omitted.
When To Use Exploratory Testing
As this testing method is most successful when testers approach it creatively, it is best performed by a team of highly experienced testers who have a wide knowledge base. It is often a valuable method to use if there are iterations required early on in the game as it sets the precedent for bug-free code going forward.
Exploratory testing is valuable to perform at the point when new testers join the team, as they bring their knowledge and expertise as well as a fresh perspective to use as a lens for viewing the process.
It is also useful when there is limited time to learn about the product or software and stakeholders require rapid feedback. Furthermore, it is one of the best methods to use in an Agile environment as it is more context-driven rather than following a set of laid out steps.
Implementing exploratory testing after scripted testing helps to identify bugs that other testing methods fail to pick up. The developers can then fix issues that would have otherwise been missed.
Pairing scripted and exploratory testing together provides a more holistic approach to software testing, as it diversifies the process and allows for a more complete analysis of the software.
Perks And Challenges
If the requirements of the software are unclear in any way, then exploratory testing is a good approach to harness. The way the tests are executed in iterations also ensures the expansion of the knowledge and imagination of the testers, which can lead to more productivity.
These iterations also help the testers get into the nitty-gritty of the software to make sure that the requirements are covered from all corners.
One big thing to consider about exploratory testing is that the test design happens at the same time as the execution. This means that the actions the tester takes are the direct results of the activities they are currently engaging with. The actions they take can be informed by previous experience with the software they are testing, which makes things easier as they have a better idea of where to begin.
Some challenging parts of exploratory testing need to be noted. It can be hard to learn to use the software system, replicate the failures encountered during the process, and to document everything that occurs in the test period. It can also be hard to know when to stop testing, as there aren’t defined test scripts to follow.
As the purpose of exploratory testing is to expose faults that other methodologies may miss, it is a valuable tool in establishing the quality of a product. The efficacy of the method is based on the creative thinking abilities of the testers performing it. Therefore, those who are experienced and can bring their knowledge from past projects into the environment are crucial to its success.