8.5.2. Why it’s valuable in Agile

Exploratory testing is simultaneous learning, test design, and execution, where testers explore the application without predefined scripts.

Exploratory testing is a unique approach in which testers engage with the application actively rather than following a strict set of predefined testing scripts. This means they are learning about the application and testing it simultaneously. This kind of testing is valuable because it allows testers to use their creativity and intuition to find unexpected issues that might not be covered by traditional scripted tests.

Think of exploratory testing like a child exploring a new playground. Instead of sticking to a specific route, the child runs around, tries all the slides, swings, and sees what works and what doesn’t. Similarly, testers can discover how users might interact with an application in ways that the original creators didn’t anticipate.

Ideal for early-stage builds and UI-rich applications.

Exploratory testing shines particularly in early-stage applications where many features are still being developed, and in applications with rich user interfaces (UIs). In early builds, not all features are fully implemented; therefore, exploratory testing allows testers to evaluate the existing components to ensure they work together effectively. Moreover, for applications with complex UIs, exploratory testing helps in identifying usability issues that scripted tests might miss, such as confusing layouts or unexpected navigation paths.

Imagine updating a recipe for a favorite dish. Initially, you might just follow the recipe closely, but as you become familiar with the dish, you might start experimenting with ingredients and cooking times to see how the flavors change. Similar to this, exploratory testing allows testers to experiment with the application to understand its strengths and weaknesses before the final version is ready.

Helps find usability issues, confusing workflows, and minor glitches.

Usability issues often arise when users find it difficult to navigate or interact with an application as intended. Exploratory testing empowers testers to interact with an application as end-users would, which can reveal small glitches—like buttons not responding or features being difficult to access—that might not show up in automated tests. Addressing these issues during the testing phase ensures a smoother user experience once the application is launched.

Consider a new phone app designed for ordering food. If a tester simply follows steps in a strict script, they might not notice that the 'order' button is hard to find or that the checkout process seems complicated. However, by using the app like a real customer, they can identify these usability glitches and provide feedback on how to improve the user interface.

Use charter-based sessions (e.g., 'Explore cart checkout flow for invalid inputs')

Charter-based exploratory testing involves setting specific goals or 'charters' for a testing session. For instance, a charter might be to explore how the application behaves when users enter invalid data during checkout. This approach helps testers focus their efforts while still allowing for creative exploration of the application. It combines the benefits of structure and spontaneity, making exploratory testing both efficient and effective.

Imagine you're on a treasure hunt with a map that points to certain areas where you might find clues. Instead of aimlessly searching everywhere, you focus on those areas, but once you get there, you can still look around broadly for other hidden treasures. In the same way, charter-based exploratory testing leads testers to specific functionalities while encouraging them to explore the surrounding context.

Combine with automated and scripted testing.

Exploratory testing should not be seen as a replacement for automated or scripted tests but rather as a valuable complement to them. Automated tests handle repetitive and straightforward scenarios efficiently, while exploratory testing can find unique bugs that automated scripts might overlook. By integrating both approaches, teams can achieve comprehensive test coverage and enhance overall product quality.

Think of it like cooking: you might use a slow cooker for consistent results with certain dishes but also decide to grill some vegetables for a unique flavor. Similarly, you use automated tests for regular checks and add exploratory testing to enhance the richness of the testing suite, improving your application's quality.

--