Ad-Hoc & Exploratory Testing

How those benefited my testing process

Speaking about software development, when features that developed grows in a fast pace, issues need to be found fast the and expanding product feature and design will always create loopholes on prepared test cases. When tester preparing test cases only based on design and task cards, there is a chance to miss out certain test cases. At this point, ad-hoc and exploratory testing plays its part.

(disclaimer: This post is personal opinion, not making a statement. :D)

What are those?

Ad-hoc testing is a test that runs outside test plans, test scenarios, test cases or any documents. It can be said to do anything as you please aiming to break the application. In this case, deep knowledge of the application is essential. Since there are no any documents to direct the testing process, a tester should already understand what required criteria for such feature or function considered as passed. Since the main goal is to find defects, this test usually works on negative scenarios.

Pros:
  • Can be done anytime without test documentation
  • Require less time since no test case report to be completed
  • Since no documentation needed, can be done by developer during product development, not limited to QA.
  • Can find bugs in short period of time.
Cons:
  • No documentation means scenario/bug reproduction will be a challenge.
  • Also, no documentation means tester need to rely on their memory when they need to recollect the scenario.
  • Very dependent to tester skill and product knowledge.

Ad hoc testing mostly done not to complete test cases but to find obvious issues that sometimes quite common so that unnecessary to be included in the test case document. When the bug is very obvious that does not require thorough checking on later testing sequence, for bugs like page redirection, display, texts which usually does not occur again after fixing.

Ad-hoc testing itself can be fully detached from above flow since it can be done on daily testing in line with the development process that still ongoing and QA need to check features need to be reviewed. This way, issues can be found faster.

Meanwhile, exploratory testing is a simultaneous learning, test design, and test execution. This testing is done to complete and develop existing test cases as test documentation and execution is done at the same time since test cases are not written in advance.

Pros:
  • Help to learn application capabilities.
  • Less preparation needed.
  • Not limited to find negative cases. Also resulted on finding positive cases
  • Can find issues or cases in short period of time.
Cons:
  • Tend to need to stick to certain flow in order to find possible cases
  • Time to test is reduced, but more time spent during testing since cases that found need to be write down to complete test case.

After performing test cases that have been prepared before, exploratory testing is done to develop the cases deeper and in the attempt to found more test cases to be listed down. When performing this type of test, test and scenario documentation need to be done in parallel. Simply execute the test and write it down when the scenario is not yet defined on test documentation. Exploratory testing is not limited to find negative cases but also dig more positive cases that not yet described on definition done.

From my personal point of view, it is hard to determine which test that has been performed during testing since tester tend to unconsciously perform both of this test at the same time if he/she does not refer to any test documentation during testing.

Simply said, when the scenario is not written, it is more like ad-hoc, but when the scenario that found deserved to be listed down, exploratory it is. Furthermore, exploratory testing can be more efficient when definition of done of each feature already defined clearly. Tester only need to find cases outside intended behavior. Performing both of this test can save time since tester does not need to follow specific sequence during testing.

For further reading:

https://medium.com/@99tests/basics-of-exploratory-testing-difference-from-adhoc-testing-e1c15473dc3b

http://www.softwaretestingclass.com/why-exploratory-testing-is-important-in-agile-projects/

https://www.tutorialspoint.com/software_testing_dictionary/adhoc_testing.htm

One clap, two clap, three clap, forty?

By clapping more or less, you can signal to us which stories really stand out.