Bird
Raised Fist0
Testing Fundamentalstesting~10 mins

Exploratory testing in Testing Fundamentals - Test Execution Trace

Choose your learning style10 modes available
Test Overview

This test explores a simple login page without a fixed script. It tries different inputs and checks if the login button behaves correctly, verifying the system handles inputs as expected.

Test Code - Selenium with unittest
Testing Fundamentals
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import unittest

class TestLoginExploratory(unittest.TestCase):
    def setUp(self):
        self.driver = webdriver.Chrome()
        self.driver.get('https://example.com/login')

    def test_login_button_enabled_with_input(self):
        driver = self.driver
        wait = WebDriverWait(driver, 10)

        # Find username and password fields
        username = wait.until(EC.presence_of_element_located((By.ID, 'username')))
        password = driver.find_element(By.ID, 'password')
        login_button = driver.find_element(By.ID, 'login-btn')

        # Initially, login button should be disabled
        self.assertFalse(login_button.is_enabled())

        # Enter username only
        username.send_keys('testuser')
        self.assertFalse(login_button.is_enabled())

        # Enter password
        password.send_keys('password123')

        # Now login button should be enabled
        self.assertTrue(login_button.is_enabled())

        # Clear username to test edge case
        username.clear()
        self.assertFalse(login_button.is_enabled())

    def tearDown(self):
        self.driver.quit()

if __name__ == '__main__':
    unittest.main()
Execution Trace - 7 Steps
StepActionSystem StateAssertionResult
1Test starts and opens Chrome browserBrowser opened at https://example.com/login showing login form with username, password fields and disabled login button—PASS
2Waits for username field to be present and finds password and login button elementsAll elements are visible and interactable—PASS
3Checks that login button is initially disabledLogin button is disabledAssert login_button.is_enabled() is FalsePASS
4Enters 'testuser' in username fieldUsername field contains 'testuser', password empty, login button still disabledAssert login_button.is_enabled() is FalsePASS
5Enters 'password123' in password fieldUsername and password fields filled, login button enabledAssert login_button.is_enabled() is TruePASS
6Clears username fieldUsername empty, password filled, login button disabledAssert login_button.is_enabled() is FalsePASS
7Test ends and browser closesBrowser closed—PASS
Failure Scenario
Failing Condition: Login button remains enabled even when username or password fields are empty
Execution Trace Quiz - 3 Questions
Test your understanding
What does the test check after entering only the username?
ALogin button remains disabled
BLogin button becomes enabled
CPassword field is cleared
DPage reloads
Key Result
Exploratory testing involves trying different inputs and observing system behavior without a fixed script, helping find unexpected issues.

Practice

(1/5)
1. What is the main goal of exploratory testing?
easy
A. To find bugs by freely exploring the software
B. To write detailed test scripts before testing
C. To automate all test cases
D. To test only the user interface

Solution

  1. Step 1: Understand exploratory testing purpose

    Exploratory testing means testing without fixed scripts, exploring freely to find bugs.
  2. Step 2: Compare options with definition

    Only To find bugs by freely exploring the software matches this idea; others describe scripted or automated testing.
  3. Final Answer:

    To find bugs by freely exploring the software -> Option A
  4. Quick Check:

    Exploratory testing = find bugs freely [OK]
Hint: Exploratory means exploring freely to find bugs [OK]
Common Mistakes:
  • Confusing exploratory with scripted testing
  • Thinking exploratory is only automation
  • Believing it tests only UI
2. Which of the following is a correct practice during exploratory testing?
easy
A. Following a strict test script without deviation
B. Avoiding any note-taking during testing
C. Only testing features that have detailed requirements
D. Using creativity to try different actions in the software

Solution

  1. Step 1: Identify exploratory testing practices

    Exploratory testing encourages creativity and trying different actions freely.
  2. Step 2: Evaluate each option

    Using creativity to try different actions in the software fits this; others restrict testing or avoid useful habits like note-taking.
  3. Final Answer:

    Using creativity to try different actions in the software -> Option D
  4. Quick Check:

    Creativity = exploratory testing [OK]
Hint: Creativity and freedom are key in exploratory testing [OK]
Common Mistakes:
  • Thinking exploratory testing requires strict scripts
  • Ignoring features without detailed requirements
  • Not taking notes during testing
3. During exploratory testing, a tester tries to log in with invalid credentials multiple times. What is the expected outcome?
medium
A. The system crashes immediately
B. The system allows login without error
C. The system blocks login and shows an error message
D. The system logs in with default admin access

Solution

  1. Step 1: Understand login behavior with invalid credentials

    Systems usually block login attempts with wrong credentials and show error messages.
  2. Step 2: Match expected behavior with options

    The system blocks login and shows an error message matches expected behavior; others describe incorrect or unsafe outcomes.
  3. Final Answer:

    The system blocks login and shows an error message -> Option C
  4. Quick Check:

    Invalid login = error message [OK]
Hint: Invalid login should show error, not allow access [OK]
Common Mistakes:
  • Assuming system crashes on invalid login
  • Thinking invalid login grants admin access
  • Believing system ignores invalid attempts
4. A tester performing exploratory testing notices the app crashes when clicking a button, but the crash is not reproducible every time. What should the tester do?
medium
A. Report the crash with detailed steps and environment info
B. Assume the crash is caused by user error and do nothing
C. Ignore it since it is not consistent
D. Restart the app and continue testing without reporting

Solution

  1. Step 1: Understand handling intermittent crashes in exploratory testing

    Even if a crash is not consistent, it should be reported with details to help developers.
  2. Step 2: Evaluate options for best practice

    Report the crash with detailed steps and environment info is correct; ignoring or assuming user error is bad practice.
  3. Final Answer:

    Report the crash with detailed steps and environment info -> Option A
  4. Quick Check:

    Report all crashes with details [OK]
Hint: Always report crashes with details, even if intermittent [OK]
Common Mistakes:
  • Ignoring intermittent bugs
  • Assuming user error without evidence
  • Not providing environment info in reports
5. You are doing exploratory testing on a new app with unclear requirements. Which approach best helps you find important bugs quickly?
hard
A. Randomly click everywhere without any plan
B. Use your knowledge to explore critical areas and take notes
C. Focus only on features with written requirements
D. Wait for developers to provide test cases

Solution

  1. Step 1: Identify best exploratory testing approach with unclear requirements

    Exploratory testing works best by using tester's knowledge to explore important areas thoughtfully.
  2. Step 2: Compare options for effectiveness

    Use your knowledge to explore critical areas and take notes uses knowledge and notes, which is best; random clicking or waiting wastes time.
  3. Final Answer:

    Use your knowledge to explore critical areas and take notes -> Option B
  4. Quick Check:

    Knowledge + notes = effective exploratory testing [OK]
Hint: Explore smartly using knowledge and notes, not random clicks [OK]
Common Mistakes:
  • Testing only documented features
  • Clicking randomly without focus
  • Waiting passively for test cases
Recommended

Ready to prove it?

Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.

10 questions~5 mineasy hard