In the fast-paced world of software development, identifying and reporting defects is the core responsibility of testers. It's common to become familiar with the application you are testing and develop blindspots that hinder your ability to identify and investigate defects. One of the reasons for this to happen is that you rely on scripted testing only. Automated and manual regression testing provides a structured approach and is excellent at saving time and ensuring the minimum defined quality, but it can only uncover deeper defects. That's where exploratory testing comes into play, offering you a push to think outside the box and take an active role in the testing process to adventure yourself into areas untouched by scripted testing.
In this blog, you will discover best practices of exploratory testing that will help you enhance your bug detection and reporting skills.
Understanding exploratory testing
Exploratory testing is an approach to software testing that gives you the freedom and flexibility to adapt your testing process. Unlike scripted testing, where you follow predefined test cases and predetermined steps, exploratory testing allows you to learn, design, and execute tests simultaneously. With exploratory testing, you move from passive to actively exploring the application, making on-the-spot decisions based on your knowledge, experience, and intuition.
By actively exploring and investigating the software, you gain a deeper understanding of its behavior and identify vulnerabilities that scripted testing alone might miss.
Exploratory testing methods to help you identify hidden defects
Defects hide everywhere. While automation and manual testing cover the user's happy path, exploratory testing usually takes you off the beaten path, where scripted testing cannot reach. To find those hidden bugs, you need creativity and diligence.
Let's see some exploratory testing methods to ignite your creativity and inspire you to leave the happy path:
- Exploratory Testing Heuristics
Utilize heuristics and mnemonics to guide your testing. These heuristics provide patterns and guidelines for identifying potential defects. Let's see some examples.
- FEW HICCUPPS (Familiar, Explainability, World, History, Image, Comparable product, Claims, User Expectations, Product, Purpose, Standards, and Statutes). This mnemonic helps you remember keywords for useful oracles when a specification is missing;
- Zero, One, Many (Zero things, one thing, many things): Look out for performance issues as the number of items increases;
- Starve: Limit access to required resources like CPU, memory, network, or space.
- Risk-Based Testing
Prioritize testing efforts by identifying high-risk areas of the application. Focus on critical functionalities, complex components, or areas prone to defects based on historical data or requirements analysis. By targeting these areas, you increase the likelihood of uncovering defects.
- Exploratory Test Tours
Adopt predefined testing tours or charters to guide your exploratory testing. Test tours provide structured exploration paths and focus areas to ensure comprehensive coverage. Some tour examples include the money tour, the supermodel tour, and the intellectual tour.
- Pair Testing
Collaborate with a colleague or developer to perform exploratory testing. Two minds working together can often identify defects more effectively. Share observations, discuss potential issues, and document defects collectively.
Best practices for writing defect reports during exploratory testing
One of the most important outputs of exploratory testing is the discovered bugs. However, how you report the bugs is essential as it impacts the credibility of your testing and the chances of resolving it. A well-written bug report should ease the replication of the situation that created the bug and help your colleagues dig deeper into the root cause of the problem (RCA).
Let’s see the best practices to help you achieve a well-written bug report:
1. Use visual annotations to make explanations clearer
Screenshots are incredibly valuable because they allow you to visually capture information that may be challenging to articulate in words alone. Moreover, if working in a multilingual team, screenshots and videos are helpful to communicate well across the language barrier. There are instances when you need to reference a particular section of the application or website. Drawing around the desired area enhances clarity and makes it easier for others to review and understand the intended message. This simple act of highlighting relevant portions facilitates effective communication and properly conveys critical details.
2. Focus on the problem and not the individual
When you're taking text notes, it's crucial to steer clear of blaming individuals for problems. Instead, center your focus on presenting technical facts and evidence. While it's acceptable to mention past decisions connected to the problem, the primary objective is to highlight their relationship to the issue and any potential impacts they might have had.
3. Help the reader quickly scan your report
Categorize your notes to help the reader quickly scan the report. Use labels for every note to indicate the intent of the information. It can be beneficial for your colleagues to know in advance if your note is a comment, an issue, an idea, or a concern.
4. Sequence matters, so record it
Issues frequently arise due to the target system being in a specific state, which, in turn, stems from a series of steps taken. Remembering the exact sequence of performed actions to reproduce these problems or situations accurately is crucial. By recording evidence in a timeline to accurately retain a clear recollection of the steps taken, you can effectively recreate the circumstances and gain a deeper understanding of the underlying issues.
5. Communicate bugs with fixes
Be bold about offering a possible fix or suggestions. You're not expected to know the exact solution, but sharing your insights can give developers a head start in their investigation and makes the reporting more effective. As fixing the bug yourself is not always possible, this could be an excellent opportunity to work in a pair assembled with a developer.
6. Record the traffic to a .har file
If you are testing in a browser, capturing and uploading the network traffic to your report can be helpful. In Chrome, you can access this feature by navigating to "Developer Tools > Network". Remember to enable the "Preserve Log" option.
7. Record only relevant information
For better focus and minimizing distractions, consider only capturing the browser or the application's UI when recording. However, you should record the entire screen if it aligns better with your specific use case. This can be especially useful when showcasing the interaction of a desktop application with other applications. The key is to choose the recording approach that best serves your needs and effectively communicates the desired information.
8. Mention the importance of the defect
Indicating the severity of the bug is important because it will help your team know how to prioritize it. It would help to ask yourself the following questions to understand the defect's importance:
- How much harm does it cause when it happens? The severity is critical when the bug blocks the project and harms the user;
- How often and how simple is it to occur? You can consider bugs important when they are visible to most users, and they get triggered by popular features;
- Does the bug suggest other possible risks? Assess the risks the bug implies. The risks might signal other problems in the development process or issues with the brand reputation.
9. Include everything in your test management platform
Record and share your findings in your team's test management platform with all stakeholders. It's essential to communicate the impact of the defect clearly and highlight its potential consequences for the product. This way, you create a traceable record of the reported issues, making it easier to refer back to them in the future.
Identify and report hidden defects like a pro with Xray Exploratory App
The most visible outcome of testing is the bug report. Therefore, writing a good bug report during exploratory testing sessions is critical to properly communicating hidden defects. Without clear documentation, bugs may confuse colleagues and risk being overlooked and unresolved. It's essential to use visual annotations, categorize notes, record videos, and organize evidence logically to prevent such issues.
Documenting an exploratory testing session becomes challenging when using scattered tools. This is where the Xray Exploratory App comes in handy. This desktop application consolidates all the necessary tools, making gathering evidence easier and automatically generating session reports that can be easily shared with your team.
