Bird
Raised Fist0
Testing Fundamentalstesting~15 mins

Error guessing in Testing Fundamentals - Build an Automation Script

Choose your learning style10 modes available
Error guessing test for login form
Preconditions (1)
Step 1: Enter an invalid email format 'user@@example.com' in the email field
Step 2: Enter a valid password 'Password123!' in the password field
Step 3: Click the Login button
Step 4: Verify that an error message 'Invalid email format' is displayed
Step 5: Enter a valid email 'user@example.com' in the email field
Step 6: Leave the password field empty
Step 7: Click the Login button
Step 8: Verify that an error message 'Password cannot be empty' is displayed
Step 9: Enter a valid email 'user@example.com' in the email field
Step 10: Enter a password with less than 6 characters '123' in the password field
Step 11: Click the Login button
Step 12: Verify that an error message 'Password too short' is displayed
✅ Expected Result: The application shows appropriate error messages for each invalid input scenario.
Automation Requirements - Selenium with Python
Assertions Needed:
Verify error message text matches expected for invalid email
Verify error message text matches expected for empty password
Verify error message text matches expected for short password
Best Practices:
Use explicit waits to wait for error messages to appear
Use descriptive locators like By.ID or By.CSS_SELECTOR
Use Page Object Model to separate page actions and test logic
Avoid hardcoded sleeps
Use clear assertion messages
Automated Solution
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 LoginPage:
    def __init__(self, driver):
        self.driver = driver
        self.email_input = (By.ID, 'email')
        self.password_input = (By.ID, 'password')
        self.login_button = (By.ID, 'login-btn')
        self.error_message = (By.ID, 'error-msg')

    def enter_email(self, email):
        self.driver.find_element(*self.email_input).clear()
        self.driver.find_element(*self.email_input).send_keys(email)

    def enter_password(self, password):
        self.driver.find_element(*self.password_input).clear()
        self.driver.find_element(*self.password_input).send_keys(password)

    def click_login(self):
        self.driver.find_element(*self.login_button).click()

    def get_error_message(self):
        wait = WebDriverWait(self.driver, 10)
        error_element = wait.until(EC.visibility_of_element_located(self.error_message))
        return error_element.text

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

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

    def test_invalid_email_format(self):
        self.login_page.enter_email('user@@example.com')
        self.login_page.enter_password('Password123!')
        self.login_page.click_login()
        error = self.login_page.get_error_message()
        self.assertEqual(error, 'Invalid email format', 'Error message for invalid email is incorrect')

    def test_empty_password(self):
        self.login_page.enter_email('user@example.com')
        self.login_page.enter_password('')
        self.login_page.click_login()
        error = self.login_page.get_error_message()
        self.assertEqual(error, 'Password cannot be empty', 'Error message for empty password is incorrect')

    def test_short_password(self):
        self.login_page.enter_email('user@example.com')
        self.login_page.enter_password('123')
        self.login_page.click_login()
        error = self.login_page.get_error_message()
        self.assertEqual(error, 'Password too short', 'Error message for short password is incorrect')

if __name__ == '__main__':
    unittest.main()

This test script uses Selenium WebDriver with Python's unittest framework.

The LoginPage class follows the Page Object Model. It stores locators and methods to interact with the login page elements. This keeps the test code clean and easy to maintain.

Each test method performs one error guessing scenario by entering invalid inputs and clicking the login button.

Explicit waits are used to wait for the error message to appear before reading its text. This avoids flaky tests.

Assertions check that the error messages shown match the expected text for each invalid input.

The setup and teardown methods open and close the browser for each test, ensuring a fresh start.

This approach follows best practices like using descriptive locators, explicit waits, and clear assertion messages.

Common Mistakes - 4 Pitfalls
Using time.sleep() instead of explicit waits
Using brittle XPath locators that break easily
Not clearing input fields before typing
Combining multiple test scenarios in one test method
Bonus Challenge

Now add data-driven testing with 3 different invalid input sets for email and password

Show Hint

Practice

(1/5)
1. What is the main idea behind Error guessing in software testing?
easy
A. Using formal test cases only
B. Writing automated tests for every function
C. Guessing where errors might occur based on experience
D. Ignoring past bugs and testing randomly

Solution

  1. Step 1: Understand the concept of error guessing

    Error guessing is a technique where testers use their experience to predict where bugs might be.
  2. Step 2: Compare options with the concept

    Only Guessing where errors might occur based on experience matches the idea of using experience to guess errors, others describe different testing methods.
  3. Final Answer:

    Guessing where errors might occur based on experience -> Option C
  4. Quick Check:

    Error guessing = Experience-based bug prediction [OK]
Hint: Error guessing is about experience, not formal rules [OK]
Common Mistakes:
  • Confusing error guessing with automated testing
  • Thinking error guessing ignores tester knowledge
  • Believing error guessing is random testing
2. Which of the following is a correct example of an error guessing test case?
easy
A. Test all buttons for correct color
B. Test the software without any plan
C. Test only the homepage layout
D. Test input with empty fields to check validation

Solution

  1. Step 1: Identify error guessing test case traits

    Error guessing focuses on inputs or actions likely to cause errors, like empty fields.
  2. Step 2: Evaluate each option

    Test input with empty fields to check validation tests empty input, a common error source. Others are unrelated or random.
  3. Final Answer:

    Test input with empty fields to check validation -> Option D
  4. Quick Check:

    Empty input tests = Error guessing [OK]
Hint: Look for tests targeting likely error spots [OK]
Common Mistakes:
  • Choosing tests unrelated to error conditions
  • Confusing UI checks with error guessing
  • Selecting random or unplanned tests
3. Given this scenario: A login form accepts username and password. Which input is best for error guessing?
medium
A. Username: 'admin', Password: '1234'
B. Username: '', Password: ''
C. Username: 'user1', Password: 'password'
D. Username: 'test', Password: 'test123'

Solution

  1. Step 1: Identify inputs likely to cause errors

    Empty username and password fields often cause validation errors.
  2. Step 2: Compare options for error likelihood

    Username: '', Password: '' uses empty inputs, which is a common error guess. Others are normal inputs.
  3. Final Answer:

    Username: '', Password: '' -> Option B
  4. Quick Check:

    Empty inputs = Common error guess [OK]
Hint: Empty or invalid inputs are classic error guesses [OK]
Common Mistakes:
  • Choosing normal valid inputs
  • Ignoring empty or boundary inputs
  • Assuming random inputs are best
4. You wrote an error guessing test for a form but it never finds bugs. What is the most likely problem?
medium
A. You guessed errors in unlikely places
B. You wrote too many test cases
C. You automated all tests
D. You tested only the UI colors

Solution

  1. Step 1: Understand error guessing effectiveness

    Error guessing works best when testers guess likely error spots based on experience.
  2. Step 2: Analyze why tests fail to find bugs

    If guesses are in unlikely places, bugs won't be found. Other options don't explain this well.
  3. Final Answer:

    You guessed errors in unlikely places -> Option A
  4. Quick Check:

    Wrong guess spots = No bugs found [OK]
Hint: Guess where errors usually happen, not random places [OK]
Common Mistakes:
  • Thinking more tests always find more bugs
  • Believing automation replaces error guessing
  • Focusing on UI style instead of error sources
5. You want to use error guessing to test a calculator app. Which combination of inputs is best to find errors?
hard
A. Very large numbers, zero, and dividing by zero
B. Random letters instead of numbers
C. Only positive integers
D. Normal numbers like 5 + 3, 10 - 2

Solution

  1. Step 1: Identify error-prone inputs for calculator

    Calculators often fail with large numbers, zero, or division by zero.
  2. Step 2: Evaluate options for error guessing effectiveness

    Very large numbers, zero, and dividing by zero targets these error-prone inputs, while others do not or are invalid inputs.
  3. Final Answer:

    Very large numbers, zero, and dividing by zero -> Option A
  4. Quick Check:

    Edge and invalid inputs = Best error guesses [OK]
Hint: Test edge cases and invalid inputs for errors [OK]
Common Mistakes:
  • Testing only normal inputs
  • Ignoring division by zero errors
  • Using completely invalid inputs without context
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