7 Awesome Exploratory Testing Tools

Exploratory testing is defined as simultaneous learning, test design, and test execution and the heart of manual testing. Exploratory testing values the tester as an integral part of the test process, like the Agile Manifesto states: “Individuals and interactions over tools and processes.”

In a previous post, we discussed how a tester can express their inner creative while ‘bug-hunting’, but we didn’t cover the many handy (read: awesome) tools that facilitate organizing, recording, and documenting during the hunt. Let’s do that now.

Exploratory Testing – a Recap

First, a recap of exploratory testing. Exploratory tests are a manual method of exploring an app without test scripts or predetermined input definitions. Instead of following the user ‘happy path’ typically covered in scripted testing, the tester imagines alternate paths where users do unexpected things. This could be repeated button-clicking, following a non-standard flow, or inputting non-spec data. The unexpected could also be less obvious error-inducing concerns, such as configuration requirements or structural module deficiencies.

During an exploratory test a tester needs to remember what they did to cause an error, and what the results of the error are. This remembering happens through detailed note taking. With proper documentation, exploratory test notes can become future test cases — a double win for both the tester’s personal experience and future iterations of the software. Also, testers need to think of ways to design tests to return actionable data, and to explore issues deeper. These two areas, documenting actions and devising tests, are where the awesome tools come in!

Awesome Tools for Exploratory Testing

Unfortunately, no one tool can be everything for the exploratory tester. But, given each testers’ individual workflow preferences, there are tools in several categories to consider. First, let’s look at three tools for devising tests. They are heuristics, personas, and mind maps:

1. Heuristics:

During exploratory, the tester designs and executes tests in real time. To do so, a tester must organize their inquiry to devise worthwhile tests. One way to devise tests is with heuristics and mnemonics.

A heuristic is a mental shortcut — a cognitive-load reducer — based on past experience and deriving from the Greek word that means ‘to find’. Heuristics are unconscious ways to quickly process information, also known as a ‘rule-of-thumb’. For example, the idea of looking under a welcome mat to find a key is a heuristic. This is an example of a ‘representative heuristic’.

In contrast, a mnemonic is a word, rhyme, or other memory aid used to associate complex information with something that is easy to remember. For example, I might remember Rob by linking his name to Rob’s red hair. Then, I remember ‘Red Rob’ without a struggle, and can greet him by his name when I see his hair. Heuristics and mnemonics help us solve problems and find answers efficiently under cognitive load.

Designed by James Branch of www.satisfice.com as both a mnemonic and a heuristic for exploratory tests is SFDPO. This translates verbally to ‘San Francisco Depot’, or Structure, Function, Data, Platform, and Operations. Each word represents a different aspect of the software to explore during testing. By thinking of software from these POV’s, we can devise interesting and profitable tests.

Here’s a breakdown of SFDPO:

• Structure (what the software is): What are its components?
• Function (what the software does): What are its functions from both the business and user perspective?
• Data (what the software processes): What input does it accept and what is the expected output? Is input sequence sensitive? Are there multiple modes-of-being?
• Platform (what the software depends on): What operating systems does it run on? Does the environment specify a configuration to work? Does it depend on third-party components?
• Operations (how the software will be used): Who will use it? Where and how will they use it? What will they use it for?

2. Personas:

Personas are a tool that helps the tester adopt the habits (and feelings) of different types of users. During exploratory testing, personas help us to discover different types of problems resulting from different types of user behavior. For a great overview of personas, and how they inform exploratory testing, check out this blog post by Katrina Clokie.

3. Mind Mapping:

Each tester will have their personal process for setting up an exploratory testing session. It can be helpful to start with a plan of what they’d like to achieve in the session or the most important areas or requisites to review and explore. A mind map can help visualize the potential starting points, especially when combined with the SFDPO heuristic. Mind maps also help a tester circle around after following a deviation. Two favorite mind mapping tools are Xmind and MindMup.

Tools for Documenting the Exploratory Processes

Now let’s look at ways to document exploratory processes.

4. Screen Recorders:

An exploratory tester tends to be passionate about testing. As such, it’s easy to become wrapped up in the excitement of creating an error. Remembering the steps taken to produce an error, while overwhelmed with the excitement of finding a bug, is vital to comprehensive test documentation. One of the best, and simplest, tools to facilitate documentation after the test is a screen recorder. By simply recording the test session, a tester has a complete history of every action taken. There are many screen recorders available, but if you’re a Chrome devotee like me Screencastify is a free browser extension that offers an elegant UI and auto-saves to Drive. Awesome!

5. Sticky Notes:

Whether you prefer the stickies on your PC, or old-fashioned Post-Its, sticky notes are a great way to jot down ideas while testing. During exploratory testing it’s common for other ideas to pop up, like other test variations or different software aspects that need checked for similar issues. With an awesome note-taking setup, a tester can jot down these ideas to use later without interrupting their process.

6. Browser Dev Tools:

For web applications, the built-in browser tools are helpful. The moment something looks a bit odd, pop open the dev console to inspect an element, investigate a script flow, and so on. There’s other browser tools like Bug Magnet or Fiddler. Bug Magnet is an exploratory testing assistant for Chrome and Firefox that adds problematic values and edge cases to the context menu for editable elements, allowing easy access during exploratory testing sessions. Fiddler is another web session manipulator. Both are highly rated, but it’s up to the tester to decide which of the many browser tools available is the most useful.

7. Service Virtualization Tools:

Finally, the need to test early in the development cycle is a reality of the Agile process. So, how can a tester mock a service if the API isn’t complete yet? Virtualization tools allow service virtualization, a practice common in software testing for simulating backend and third-party systems. Here’s a list of 10 recommended service virtualization tools from Guru99.

Tools Help Optimize Exploratory Testing Time

We can see there are as many awesome tools to use during exploratory testing as there are ways for a tester to develop their personal exploratory test process. The takeaway here is that creating profitable exploratory tests requires more than random button- clicking (although that happens sometimes). Exploratory testing is a creative process, yes, but a directed and informed one.

Exploratory testing asks the tester to use an underlying framework of organized inquiry to explore the software. To make the tests profitable they must be documented. These two concepts, mapping and recording, are the backbone of exploratory testing. Combine the backbone with the creative heart, and you’ll find exploratory testing a task to look forward to.

Contact Us