Exploratory Testing
The term Exploratory Testing was invented by Cem Kaner in 1984. He defines Exploratory Testing as, a style of software testing that emphasizes the personal freedom and responsibility of the individual tester to continually optimize the quality of his/her work by treating test-related learning, test design, test execution, and test result interpretation as mutually supportive activities that run in parallel throughout the project.[Wikipedia]
From the definition provided by Cem Kaner, it can be understood that Exploratory testing is a technique for simultaneous learning, test design and execution. It is a technique for designing and executing the tests in a free form.
Exploratory testing does not specify about the planning, managing and tracking of test activities. It does not involve in how the test environment should be set up and which tools should be used. It is a free form testing which the tester according to his experience and creative skills tests the application and checks the various parts of the software.
Why should Exploratory Testing be performed?
As we learnt that Exploratory Testing is a free form testing that is performed as per the experience and creative skills of the tester. There are multiple reasons for which Exploratory tests should be performed, some of which are listed below:
- When you need to learn the software application quickly and provide rapid feedback.
- When the software application needs to be verified from the end users perspective.
- To check the stability of the application.
- When the there is no clear idea about what next tests should be performed.
- When you don’t have time for writing tests and scenarios however you need to test the application for the hidden issues.
- Exploratory testing can also be used to discover new test scenarios and enhance the test coverage.
As per my experience, performing Exploratory Testing in the end after all Unit, Integration and End to End tests have been performed using the automated pipeline, can help uncover the hidden defects. Since all the basic validations and major functionalities are covered in the automated tests, testers can utilise their saved time to perform Exploratory testing to check other areas of the application like User-Friendliness, GUI, Usability, checking complex scenarios, etc and enhance its quality.
Exploratory tests can be done by an individual tester or it can also be performed by a team of testers checking different sections of the software. Let me share you my experience about performing Pair based Exploratory Testing.
Pair based Exploratory Testing
You might have heard the term “Pair Programming” where two developers pair and write code for a feature. Similarly, Pair based Exploratory testing can also be performed that could help the pairing testers to quickly learn the software and test it more efficiently.
Two testers can pair and perform Exploratory Testing on the application to learn the application quickly and provide faster feedback. There is no hard and fast rule for pairing. It can be a pair of an experienced tester and a new joiner in the team, a pair of two new joiners or a pair of two experienced testers.
While working on my previous previous project which was an e-commerce mobile application developed for iOS and Android platforms, we used to follow this pair based strategy for performing Exploratory Testing.
I, being an experienced tester used to pair with a fresher in the team and perform Exploratory tests. By doing this, there were two benefits, one, product knowledge was transferred to the fresher in the process of performing tests, two, as the fresher in the team being new to application would keep on asking curious questions about the product and out of curiosity we performed some additional scenarios and uncovered hidden issues. However, as mentioned earlier, there is no rule for pairing it can be all up to the members deciding whom should they pair with. The main goal is to perform the testing efficiently to deliver a quality product.
Another benefit we got by performing pair based Exploratory testing was covering tests on 2 different mobile platforms in parallel. As mentioned earlier, the mobile application was built for iOS and Android platforms and hence needed to be tested on both.
As two persons paired, one would take an Android real device and other would take an iOS real device and perform the same steps on two different devices considering that the functionality on both the platforms should provide the same output. This made testing easier and we were able to cover multiple scenarios on two devices in quick time.
Since Exploratory testing is a free form testing and does not involve and test cases/scenarios documents, there are some points that needs to be taken care of, so we don’t face any blocker.
Points to be taken care while performing Exploratory Testing
Testers should learn and know the product well, in case of a new testers, they should check out the business requirement specifications to understand granular details of software under test. This will help them to understand what exactly they are looking for while testing and will test the software more efficiently to uncover hidden issues.
The testers should have access to all the required resources before starting Exploratory testing -
Access to Admin and related sub applications
In case of an app suite to test, make sure to have access to Admin application as well as the related Sub applications.
Test Cases/Business Specifications documents
Though there are no test cases scenarios needed to perform Exploratory tests, however, the tester should have the access to test cases, scenarios and business specification documents. This will help them learn about the software and perform the relevant verification easily.
Access to Logs
Logs actually help in better understanding of the failures and investigate them. It also serves as a proof while creating defect report. Exploratory testers should be provided with the access to logs so they can understand the exact cause of the issue occurred and also mention it in the bug report which eventually will help the developers while fixing the bug.
Access to relevant Testing tools/Test Data
Exploratory Testers should be given access to relevant testing tools as well. This will help in performing the testing more comfortably.
By re-using the existing test data, test data creation time could be saved and used in verifying other test scenarios.
Once you have the access for all the related resources required for performing Exploratory testing, you can start performing the tests considering the following points —
Analyse the Software
As you explore the software, learn about its different features and understand why was the software built.
The following checklist can help in understanding the software -
- What are the needs of the users?
- What will it be used for?
- Who will be using the software?
- What are the dependencies of the software?
Once go through the checklist, list down all the questions that you come across while analysing the software. An important point to note while analysing the software is that testers should be given sufficient time for performing the Exploratory tests as it involves walking through and understanding the software and not just Monkey Testing.
By sufficient time, it means a time boxed time duration like 60 mins, 90 mins, etc.
Document all the Observations found
Document all the relevant observations found while performing Exploratory tests. These observations can be converted to defects and respective tickets could be raised after discussion with the team by assigning severity and priority to it.
Another angle for looking at it is that this documentation can help in updating the existing test scenarios and cases. It can also be used for adding more tests at Unit/Integration and End to End tests.
Apply your past experience while testing
Experienced testers can apply their past experiences while performing Exploratory tests. For example, if you have earlier tested a login functionality of a web application, you can directly check for by-passing the login functionality by updating the URL to Home page of the web application and check if it loads the Home page without login.
Tips for Exploratory Testing
The following tips can come handy while performing Exploratory Testing -
- Perform field level validations on all the input fields.
- Check functional validation messages on successful saving/submitting of the forms.
- Check the that the UI is uniform across all the screens in the software application.
- Check font and font size are uniform across the software application.
- Verify the integration between different screens of the application.
- Check the End to End test journey of the software.
- Perform negative testing and check the messages displayed for negative input.
- If the application can be integrated with external applications, check the integration between the external application and the software.
- Verify the complex business logic by performing positive and negative validations.
- Check if the application is vulnerable to security issues by performing ethical hacking of the application.
- Check for all the possible error messages.
- Check if the application allows by-passing the authorisation and login.
- Check if any sensitive data like PII(Personal Identifiable Information), is displayed in the logs of the application.
- Check that the APIs used in the application does not expose any sensitive data in the response.
- Check that the token/secured content are encrypted.
If the Exploratory testing is performed on mobile application
- Check that the application can be installed on minimum versions of mobile platforms as specified in the documentation and provide proper logs in case of crashes.
- Check in case of mobile application getting updated either manually or using App Store/Play Store, the app data and app state remains intact.
- Check that the application’s screen is displayed correctly without being truncated in big/small screen devices.
Final Thoughts
Exploratory Testing is been performed by almost all the Software Testing departments around the globe to get better understanding of the software and provide a quick feedback on the builds. It is a free form of testing where no formal documentation is required to be created for performing it. It helps in evaluating the product and discovering the hidden issues in quick time.
By performing Pair based Exploratory Testing, we can unleash its power by learning the product together with other team members. It can also help in delivering knowledge to the other team member and vice versa. It also facilitates to test multiple test scenarios of the software on different platforms in short span of time.
Exploratory Testing is very useful in cases where you need to perform a quick check about the stability of the software and also verify that the major functionalities of the application works as expected. I
Happy Testing!!
Freelance Work / Paid Trainings/Mentoring
Contact me for Paid trainings/Mentoring related to Test Automation and Software Testing, ping me using any of the social media site listed on LinkTree or email me @mohammadfaisalkhatri@gmail.com.
