How do you perform exploratory testing and what are the benefits and limitations of this approach?

Les tests exploratoires sont un pilier central de notre approche d'assurance qualité, exploitant l'expertise créative de nos ingénieurs de test. Dans cette pratique, nos testeurs sont encouragés à explorer le logiciel de manière non linéaire, permettant la découverte proactive de scénarios inattendus et facilitant l'adaptation aux changements. Les avantages de cette approche incluent une couverture exhaustive, une détection précoce des anomalies et une agilité accrue face aux évolutions des exigences. Toutefois, des limites peuvent émerger en termes de reproductibilité, de documentation formelle et de mesure précise de la couverture des tests.

🔎 Exploratory testing is a dynamic learning process emphasizing continuous observation, analysis, and feedback. It involves adapting actions and goals based on ongoing findings. Tools like checklists, mind maps, personas, scenarios, oracles, and test design patterns guide exploration. Documenting findings, insights, and questions with notes, screenshots, videos, or bug reports is crucial for effective exploratory testing.

Exploratory testing involves simultaneous learning, test design, and execution. Testers explore the application to understand its behavior, find defects, and gather information. Benefits include flexibility, adaptability, creativity, and efficiency in finding bugs. However, it lacks structure, documentation, and repeatability, making it difficult to reproduce bugs and track progress.

Uncovering Hidden Gems: - Exploratory testing allows us to unearth unexpected issues that scripted tests might overlook. It’s like exploring a dense forest you stumble upon rare flora and fauna that scripted paths wouldn’t reveal. For instance, during a recent mobile app test, I discovered a quirky bug when swiping left with three fingers while listening to a podcast. Nurturing Creativity: - Creativity is our secret weapon. When exploring, I encourage my team to think like curious users. We simulate real-world scenarios, like a user multitasking while ordering groceries online. Once, while testing a financial app, a tester noticed that the currency converter widget misbehaved when the phone was in landscape mode.

Exploratory tests are the ones that simultaneous learning, test design, and test execution are made. We don't need to rely on test cases and scenarios, instead we need to explore the App/Software/Webpage as a common user and most important, thinking as a user! Because if you go with the tester mindset, you will probably be stick to common routes, doing processes as it should be. But when you act like an user where you misclick, fill forms in wrong order, mistype and this kind of stuff, you will find keys to improve some points.

🌟 Exploratory testing excels in agile, complex, or dynamic software environments. It assesses software from a user's perspective, revealing usability, functionality, or performance issues missed by scripted tests. This approach uncovers new software aspects like hidden features and edge cases. It enhances testing skills and domain knowledge, fosters collaboration among testers, developers, and stakeholders through shared findings, and saves time and resources by reducing the need for detailed test cases or scripts.

Adaptability in Agile Environments: - In fast-paced Agile projects, scripted tests can lag behind. Exploratory testing adapts swiftly to evolving requirements, catching regressions early. Collaboration and Learning: - During a complex integration project, our team collaborated on exploratory sessions. We learned from each other’s approaches and shared domain knowledge, enriching our testing skills. Risk Mitigation: - Exploratory testing helps identify edge cases and dependencies. For instance, in a healthcare system, we discovered a rare data synchronization issue that could impact patient safety. Resource Efficiency: - Instead of maintaining exhaustive test scripts, we allocate time for exploratory sessions.

Exploratory testing of mechanical designs or of performance metrics is very useful in identifying areas for which more strict testing (e.g. using validated test methods) is necessary. Exploratory testing can also provide a solid basis of knowledge of the design, which is helpful when having to be able to defend the choice of quality controls later in the productisation process.

Exploratory testing is beneficial in agile, complex, or dynamic environments because it evaluates software from the user's perspective, uncovering usability, functionality, and performance issues that scripted tests might miss. It helps identify hidden features, edge cases, and dependencies, enhances testers' skills and knowledge, encourages collaboration and communication among team members, and saves time and resources by eliminating the need for detailed test cases and scripts.

I used exploratory testing in manual functional testing along SDLC for modules of an enterprise application being in maintenance team. Exploratory testing is a must in phases like: - Verifying the new installed build on the env/device you will run your tests (build checkout), before starting testing to see if the component you test is usable, testable and well installed; in this case you verify basic functionality paths, integration and system availability. - Random testing post running planned tests, spots hidden defects, inconsistencies and malfunctioning, a free style testing up; depends a lot on how well you know&understand app design and functionality. Found tons of bugs using ET, record the session to provide useful reproducing steps.

Eu costumo dizer que os testes exploratórios são negligenciados pela maioria dos profissionais da área de qualidade e testes de software. As pessoas estão perdendo a essência técnica e estratégica e isso tem consequências intensas no dia a dia. Quando fazer testes exploratórios? Com é o objetivo? Qual estratégia será adotada? Quem são os principais stakeholders que podem estar envolvidos nas descobertas capturadas durante e pós testes exploratórios? Quais KPI queremos capturar? Como esse tipo de teste pode ajudar a diretoria a tomar melhores decisões de negócio? Quais são os outputs em diferentes frente (Técnica, Produto, Qualidade e de Agilidade). Essas perguntas servem para diferentes tipos de testes, ja chega de monkey tests!

Testesexploratórios vêm sendo negligenciados ao longo dos tempos, precisamos deles assim como numa analogia com a medicina, seriam a importante etapa de clínica geral ... Se formos cegamente focados nos sintomas de um "pé" doendo , podemos não associar a uma "dor de cabeça" advinda de um desvio de coluna ... Lembremos, é o mesmo corpo e com o acompanhamento de casos de testes e cenários , poderíamos ficar limitados , nos testes.

Subjectivity and Bias: - Testers bring their unique lenses. In one instance, two testers explored a mobile app. Their findings diverged due to personal biases. We addressed this by rotating testers across features, ensuring fresh perspectives. Reporting Challenges: - Formal reports struggle to encapsulate exploratory insights. Instead, we adopted lightweight documentation: concise notes, annotated screenshots, and video clips. These captured nuances better than rigid templates. Context Dependency: - Exploratory testing thrives in dynamic contexts. Yet, it falters in compliance or security assessments. For critical systems, we blend exploratory sessions with structured checks to strike a balance.

Exploratory testing is less structured and often lacks detailed documentation. This can make it difficult to reproduce issues, track testing coverage, and demonstrate what has been tested to stakeholders. Because exploratory testing relies on the tester's intuition and experience, there's a risk of missing critical paths or edge cases that might have been caught with more structured testing approaches.

In a highly regulated industry, the formal verification of a design, or release of a product, typically cannot rely on exploratory testing, as these purposes will require test methods that have been validated prior to use. In such an environment, exploratory testing is used for other purposes.

Mindful Observation: - I immerse myself in the software. I watch for subtle cues: a flicker, a lag, or an unexpected response. These often lead to valuable insights. Session Documentation: - I maintain a log. Not just defects, but also “aha” moments. These logs become treasure troves for future sessions. Post-Session Reflection: - After the session, I reflect. What did I learn? What did I miss? Did I uncover hidden risks? This self-review fuels continuous improvement. Heuristic Exploration: - I blend techniques. Sometimes I’m a detective, following hunches (“Why does this input field hiccup?”). Other times, I’m a scientist, experimenting with boundary values or edge cases.

Exploratory Testing: A Must-Have Exploratory testing doesn’t need detailed planning—what needs to be planned is when to allocate time for it. This essential activity should follow the execution of planned test cases and involve everyone: developers, testers, and product managers. It’s a powerful testing approach that demands an ownership mindset. As a exploratory tester, ask yourself: Would I buy this product? If the answer is no and you’d prefer a competitor’s (for technical reasons), that’s the first bug to address. Exploratory testing goes beyond requirements, ensuring the product isn’t just functional but something we’re truly proud to deliver.

To perform exploratory testing, first define the scope by deciding what aspects to test and what questions to answer. Plan the session by choosing tools, techniques, and heuristics. During execution, observe the software's behavior, analyze results, adjust actions, and document findings. Finally, review the session to evaluate what was learned, missed, and achieved, and report the findings to relevant stakeholders.

You must perform exploratory testing when your test manager is asking you to do it, or when you consider it is appropriate. - In determined situations plan your exploratory attach as plan a decision matrix doc containing values you verify or any other doc custom on your needs. -If you verify a build newly installed, an installation on a new device or with a new OS or browser version your plan is to verify the critical path and other must haves that allow you to perform testing. Many blockers are due to env configs. - If you are system testing, include a random ET after you finish running all planned tests, to find more bugs in unexpected scenarios that cross your mind. Record the session, you will not remember what you did to crash it.

In explore it book, the author defined some variables for that as: Look for things you can count: Test scenarios with zero, too many, or specific numbers of items. Explore relative positions: See how software handles items based on their location in lists or hierarchies. Consider file storage and location: Test how the software interacts with files in different locations and formats. Vary geographic locations: Use random locations to test software behavior outside the typical range. Explore different formats Test with abnormally large or small files and data. Test depth: Explore software with deeply nested elements. Vary timing Consider input and navigation

To improve your exploratory testing is no less important to create and use checklists or mind maps to ensure thorough coverage and organization of your testing sessions. Also, we can learn as much as possible about the application under test, including its business logic and workflows. Constantly ask questions about the application’s functionality, edge cases, and user interactions.

Testers need to be like detectives, paying close attention to details and looking for unexpected behavior. It's easy to miss things if you're not actively looking, so: Change your perspective: Focus on different parts of the software Asking Deeper Questions is a key for better understanding

To improve your exploratory testing skills, read books, blogs, and articles, and listen to podcasts on the topic. Watch videos or demos of testing sessions and join communities or events. Pair up with other testers to learn from each other's perspectives and practice together.

Estudar, praticar e documentar. Tudo aquilo que você explora de alguma maneira, pela primeira vez, é desconhecido, fazendo necessário o bom uso de criatividade, discernimento e curiosidade. Porém toda exploração de teste deve gerar informações, métricas, documentação de regras de negócio, para que os próximos testes sejam ainda mais eficazes.