To start with this topic, let’s first understand the two different approaches to software testing, named Scripted and Unscripted Testing.
Scripted Testing:
This is a formal and structured testing approach where test cases are pre-determined and scripted in advance, usually when the feature is under development, before the actual testing starts. Functional Testing falls into this category of testing.
Unscripted Testing:
This is a dynamic and flexible approach where testers explore the application in real-time, designing and executing test cases simultaneously after the feature is developed. Exploratory Testing falls into this category of testing.
Now, let’s dive deep into Functional & Exploratory testing.
Functional testing and Exploratory testing are two distinct approaches to software testing, each with its own characteristics, benefits, and use cases. Let’s explore the key differences between functional testing and exploratory testing.
Functional Testing
- Structured Approach:
Definition: Functional testing is a structured testing approach where test cases are designed based on the specifications, requirements, and functionalities of the software well in advance, before the actual testing starts.
Scripted Test Cases: Testers create test cases in advance, specifying the inputs, expected outputs, and steps to be followed during the test execution. - Requirements-Driven:
Verification of Requirements: The primary goal of functional testing is to ensure that the software functions according to the specified requirements and behaves as expected.
Documentation: It relies heavily on documented requirements, design specifications, and other project documentation. - Repeatability:
Repetitive Execution: Functional tests are typically repeatable and can be executed multiple times to validate that the software consistently meets its functional specifications.
Regression Testing: Functional testing often includes regression testing to ensure that new changes do not break existing functionality. - Test Automation:
Automation Integration: Functional testing can be automated, and automated scripts can be created to speed up the execution of repetitive test cases. - Formal Reporting:
Structured Reporting: Formal test reports are generated based on the results of scripted test cases, making it easier to track the status of testing and identify specific issues.
Exploratory Testing
- Unscripted and Dynamic:
Definition: Exploratory testing is an unscripted and dynamic testing approach where testers design and execute test cases simultaneously based on their domain/product knowledge, experience, and intuition.
Learning While Testing: Testers learn about the application as they test and adjust their testing strategies on the fly. - Tester Independence:
Freedom to Explore: Testers have the freedom to explore the application, identify scenarios, and interact with the software in a way that functional test cases may not cover.
Creative and Intuitive: Exploratory testing encourages creativity, intuition, and critical thinking on the part of the tester. - Adaptability:
Adaptive Approach: Testers can adapt their testing based on the information gathered during testing. This makes exploratory testing particularly suitable for situations where requirements are not very clear or evolving continuously. - Usability Focus:
User Experience: Exploratory testing often focuses on user experience, usability, and areas that might be challenging to address through scripted functional test cases. - Informal Reporting:
Immediate Feedback: Testers provide immediate feedback on issues discovered during exploratory testing, which may not follow a formal reporting structure. This quick feedback loop can lead to faster issue resolution.
Now, since we know the definition, characteristics, benefits and most importantly the differences between both Functional and Exploratory testing, let’s understand the benefits of combining both of these testing approaches.
Combining functional testing and exploratory testing can be a powerful approach to ensure thorough testing coverage and to leverage the strengths of both methodologies.
- Test Planning:
Define Functional Test Cases: Start by designing detailed functional test cases based on the specifications and requirements of the software. These scripted test cases serve as a foundation for ensuring that the core functionality is tested thoroughly.
Identify Areas for Exploration: Identify areas within the application where exploratory testing can be beneficial. This might include scenarios where requirements are unclear, usability aspects, or areas prone to defects.
This will uncover defects in critical or unexplored areas of the software which might be missed in functional test cases. These will also cover corner case scenarios which usually get missed in functional testing. - Execution:
Execute Scripted Functional Tests: Begin by executing the predefined functional test cases to verify that the software behaves as expected according to the specifications. This helps in validating the core functionality and ensuring that the basic requirements are met.
Exploratory Testing Sessions: After completing the Functional testing, allocate time for exploratory testing sessions. Testers can explore the application, focusing on areas not covered or missed by scripted functional tests, identifying usability issues, and trying to uncover defects that may not have been anticipated. - Feedback and Iteration:
Provide Feedback: Report any issues or unexpected behavior discovered during both the functional and exploratory testing phases. Include detailed information about the scenarios, steps to reproduce, and any relevant information to help developers understand and address the issues.
It’s highly recommended to use existing open source tools to record steps performed during exploratory testing simultaneously to avoid double effort and make reporting faster.
Iterate as Needed: Based on the feedback, iterate on the test plan. This may involve refining existing functional test cases, creating new ones, or adjusting the focus of exploratory testing sessions to target specific areas of concern. - Continuous Learning:
Knowledge Sharing: Encourage knowledge sharing among team members. Insights gained during exploratory testing sessions can be valuable for improving scripted functional & automated test cases and overall testing strategies.
Additionally, these insights can help developers to think beyond the box during development and avoid issues like backward compatibility, dependency management, thread starvation etc. - Automation Integration:
Automate Repetitive Functional Tests: Consider automating repetitive functional tests to ensure quick and consistent validation of critical paths. This allows testers to focus more on exploratory testing, which is often better suited for scenarios that require creativity and intuition.
After every exploratory testing session, try to identify exploratory scenarios which can be automated. This will help in removing redundant exploratory tests from being performed manually in further exploratory testing cycles. - Adaptability:
Adapt Testing Approach: Be flexible and adapt the testing approach based on the project’s needs. Depending on the context and project requirements, you may need to allocate more or less time to exploratory testing.
Now, Let’s take a look at examples of both functional and exploratory testing for a Mobile Banking App.
Functional Testing Example:
Scenario: Testing Fund Transfer Functionality
- Scripted Test Case:
Test Case Title: Verify Fund Transfer
Test Steps:
1.1. Open the mobile banking app.
1.2. Navigate to the fund transfer section.
1.3. Enter valid recipient details (account number, name, etc.).
1.4. Enter the transfer amount.
1.5. Select the account from which to transfer funds.
1.6. Submit the fund transfer request.
1.7. Verify that the transaction is successful.
1.8. Check the transaction history to confirm the entry is recorded. - Execution:
The tester follows the predefined steps in the above scripted test case to ensure that the fund transfer functionality operates correctly.
Automated scripts can be created to perform this test with different sets of data. - Regression Testing:
Functional testing includes regression testing to ensure that changes or updates do not negatively impact the fund transfer functionality.
Exploratory Testing Example:
Scenario: Usability and Navigation Exploration
- Unscripted Exploration:
The tester explores the mobile banking app without predefined test cases, focusing on usability and navigation.
The tester navigates through various screens, including account summary, transaction history, and settings. - Adaptation:
While exploring, the tester identifies that the navigation to the fund transfer section is not intuitive.
The tester explores alternative paths and provides feedback on how the navigation can be improved for better user experience. - Error Handling Exploration:
The tester deliberately enters incorrect recipient details during a fund transfer to explore how the app handles errors.
Observations are made on error messages, user prompts, and the overall error recovery process. - Feedback and Reporting:
The tester provides immediate feedback on usability issues and the error-handling process to the development team.
Informal reporting emphasizes the need for improvements in navigation and user feedback during error scenarios.
Combined Approach:
Scenario: Exploring a New Feature — Mobile Check Deposit
- Scripted Test Case:
Test Case Title: Verify Mobile Check Deposit
Steps:
1.1. Open the mobile banking app.
1.2. Navigate to the check deposit section.
1.3. Take a picture of a check using the mobile device’s camera.
1.4. Enter check details (amount, account, etc.).
1.5. Submit the check deposit request.
1.6. Verify that the deposited amount reflects in the account. - Unscripted Exploration:
While exploring the check deposit feature, the tester identifies that the image recognition for checks with specific fonts is causing errors.
The tester explores different scenarios with check images to understand the limitations and challenges. - Feedback and Iteration:
The tester provides feedback on issues related to the image recognition identified during unscripted exploratory testing.
The development team iterates on the image recognition algorithm, addressing the specific font-related challenges identified during exploration. - Automation Integration:
Automated test scripts are created for repetitive tasks, such as regression testing of existing features, while exploratory testing continues to uncover new issues, especially with the introduction of the new check deposit feature.
To conclude the topic, by combining functional and exploratory testing, you can achieve a balance between structured, requirement-based testing and flexible, scenario-driven testing. This approach can uncover a broader range of issues and provide a more comprehensive view of the software’s quality.