Why advanced patterns solve real challenges in Selenium Python - Test Execution Impact

Test Overview

This test demonstrates how using advanced Selenium patterns like Page Object Model helps solve real challenges such as code duplication and maintenance issues. It verifies that a login page works correctly using a clean, reusable structure.

Test Code - Selenium

Selenium Python

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.username_input = (By.ID, "username")
        self.password_input = (By.ID, "password")
        self.login_button = (By.ID, "loginBtn")

    def enter_username(self, username):
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located(self.username_input)).send_keys(username)

    def enter_password(self, password):
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located(self.password_input)).send_keys(password)

    def click_login(self):
        WebDriverWait(self.driver, 10).until(EC.element_to_be_clickable(self.login_button)).click()

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

    def test_valid_login(self):
        self.login_page.enter_username("user1")
        self.login_page.enter_password("pass123")
        self.login_page.click_login()
        welcome_message = WebDriverWait(self.driver, 10).until(
            EC.presence_of_element_located((By.ID, "welcomeMsg"))
        ).text
        self.assertEqual(welcome_message, "Welcome user1!")

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

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

Execution Trace - 7 Steps

Step	Action	System State	Assertion	Result
1	Test starts and Chrome browser opens	Browser window is open at https://example.com/login	—	PASS
2	Test navigates to login page and waits for username input	Login page loaded with username, password fields and login button visible	Username input field is present	PASS
3	Test enters username 'user1'	Username input field contains 'user1'	—	PASS
4	Test waits for password input and enters 'pass123'	Password input field contains 'pass123'	—	PASS
5	Test waits for login button to be clickable and clicks it	Login button clicked, page processing login	—	PASS
6	Test waits for welcome message element to appear	Welcome message 'Welcome user1!' displayed on page	Welcome message text equals 'Welcome user1!'	PASS
7	Test ends and browser closes	Browser window closed	—	PASS

Failure Scenario

Failing Condition: Welcome message does not appear or text is incorrect after login

Execution Trace Quiz - 3 Questions

What does the test verify after clicking the login button?

A That the welcome message 'Welcome user1!' appears

B That the login button disappears

C That the username input is cleared

D That the password input is hidden

Key Result

Using advanced patterns like Page Object Model helps keep test code clean and easy to update, solving real challenges like duplicated code and fragile tests.

Practice

1. Why do advanced patterns in Selenium tests help solve real challenges?

easy

A. They remove the need for any locators

B. They slow down test execution significantly

C. They make tests easier to read and maintain

D. They make tests run only on one browser

Solution

1. Step 1: Understand the purpose of advanced patterns

   Advanced patterns are designed to improve test code by making it cleaner and easier to understand.

2. Step 2: Connect patterns to real challenges

   They help handle timing issues and complex user actions, making tests more reliable and maintainable.

3. Final Answer:

   They make tests easier to read and maintain -> Option C

4. Quick Check:

   Advanced patterns improve readability and maintenance [OK]

Hint: Advanced patterns improve readability and reliability [OK]

Common Mistakes:

• Thinking patterns slow tests down
• Believing patterns remove locators
• Assuming patterns limit browser support

2. Which of the following is the correct syntax to wait for an element to be clickable using Selenium's WebDriverWait in Python?

easy

A. WebDriverWait(driver, 10).until(EC.element_to_be_clickable((By.ID, 'submit')))

B. WebDriverWait(driver, 10).wait_for_clickable(By.ID, 'submit')

C. driver.wait(10).until_clickable('submit')

D. WebDriverWait.until(driver, 10, EC.clickable('submit'))

Solution

1. Step 1: Recall correct WebDriverWait syntax

   The correct syntax uses WebDriverWait(driver, timeout).until(condition).

2. Step 2: Check the expected condition usage

   EC.element_to_be_clickable expects a locator tuple like (By.ID, 'submit').

3. Final Answer:

   WebDriverWait(driver, 10).until(EC.element_to_be_clickable((By.ID, 'submit'))) -> Option A

4. Quick Check:

   Correct WebDriverWait syntax = WebDriverWait(driver, 10).until(EC.element_to_be_clickable((By.ID, 'submit'))) [OK]

Hint: Use WebDriverWait(driver, time).until(EC.condition(locator)) [OK]

Common Mistakes:

• Using incorrect method names like wait_for_clickable
• Passing locator as separate arguments instead of tuple
• Misplacing driver or timeout parameters

3. What will be the output of the following Selenium Python code snippet?

from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

wait = WebDriverWait(driver, 5)
element = wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, '.btn-primary')))
print(element.text)

medium

A. Raises TimeoutException immediately

B. Prints the text of the first element with class 'btn-primary' if found within 5 seconds

C. Prints None

D. Prints the number of elements with class 'btn-primary'

Solution

1. Step 1: Understand WebDriverWait with presence_of_element_located

   The wait.until waits up to 5 seconds for the element with CSS class 'btn-primary' to appear in the DOM.

2. Step 2: Check what print(element.text) does

   If found, element.text prints the visible text of that element.

3. Final Answer:

   Prints the text of the first element with class 'btn-primary' if found within 5 seconds -> Option B

4. Quick Check:

   Wait for presence then print text = Prints the text of the first element with class 'btn-primary' if found within 5 seconds [OK]

Hint: Wait returns element; print its text to see content [OK]

Common Mistakes:

• Confusing presence_of_element_located with visibility
• Expecting count instead of element text
• Assuming immediate exception without wait

4. Identify the error in this Selenium Python code snippet and choose the correct fix:

element = driver.find_element(By.ID, 'login')
element.click()

Assume the element appears after some delay.

medium

A. Remove the click() call

B. Change By.ID to By.CLASS_NAME

C. Use driver.find_elements instead of find_element

D. Add WebDriverWait to wait until element is clickable before clicking

Solution

1. Step 1: Recognize timing issue in element interaction

   The element may not be ready immediately, so clicking right away can cause errors.

2. Step 2: Use WebDriverWait to wait for clickability

   Waiting until the element is clickable ensures the element is ready for interaction.

3. Final Answer:

   Add WebDriverWait to wait until element is clickable before clicking -> Option D

4. Quick Check:

   Wait for clickable before click = Add WebDriverWait to wait until element is clickable before clicking [OK]

Hint: Always wait for element to be clickable before clicking [OK]

Common Mistakes:

• Changing locator type without reason
• Removing click call disables test action
• Using find_elements returns list, not single element

5. You want to create a reusable Selenium Python function that waits for an element to be visible and then clicks it. Which advanced pattern best solves this real challenge?

hard

A. Create a custom wrapper method combining WebDriverWait and click action

B. Use time.sleep() before every click to wait fixed time

C. Directly call driver.find_element().click() without waiting

D. Write separate wait and click calls every time in test code

Solution

1. Step 1: Identify need for reusable, reliable click action

   Waiting for visibility and clicking is a common pattern that benefits from reuse.

2. Step 2: Use a wrapper method to combine wait and click

   A custom method hides complexity and improves test code readability and reliability.

3. Final Answer:

   Create a custom wrapper method combining WebDriverWait and click action -> Option A

4. Quick Check:

   Reusable wrapper method solves timing and reuse [OK]

Hint: Wrap wait and click in one function for reuse [OK]

Common Mistakes:

• Using fixed sleep wastes time and is unreliable
• Skipping wait causes flaky tests
• Repeating wait and click code everywhere reduces maintainability