Why advanced patterns solve real challenges in Selenium Python - Automation Benefits in Action

Automate login and verify user dashboard using Page Object Model

Preconditions (2)

Step 1: Open the browser and navigate to https://example.com/login

Step 2: Enter '[e-mail]' in the email input field with id 'email'

Step 3: Enter 'TestPass123!' in the password input field with id 'password'

Step 4: Click the login button with id 'loginBtn'

Step 5: Wait until the dashboard page loads and URL contains '/dashboard'

Step 6: Verify that the welcome message with id 'welcomeMsg' contains the text 'Welcome, Test User'

✅ Expected Result: User is successfully logged in and redirected to the dashboard page showing the welcome message

Automation Requirements - Selenium with Python

Assertions Needed:

Verify current URL contains '/dashboard'

Verify welcome message text is 'Welcome, Test User'

Best Practices:

Use Page Object Model to separate page structure and test logic

Use explicit waits to wait for elements or conditions

Use meaningful locators like IDs

Keep test code clean and readable

Automated Solution

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

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, 'loginBtn')

    def open(self):
        self.driver.get('https://example.com/login')

    def login(self, email, password):
        WebDriverWait(self.driver, 10).until(
            EC.visibility_of_element_located(self.email_input)
        ).send_keys(email)
        self.driver.find_element(*self.password_input).send_keys(password)
        self.driver.find_element(*self.login_button).click()

class DashboardPage:
    def __init__(self, driver):
        self.driver = driver
        self.welcome_message = (By.ID, 'welcomeMsg')

    def wait_for_dashboard(self):
        WebDriverWait(self.driver, 10).until(
            EC.url_contains('/dashboard')
        )

    def get_welcome_text(self):
        return WebDriverWait(self.driver, 10).until(
            EC.visibility_of_element_located(self.welcome_message)
        ).text


def test_login():
    driver = webdriver.Chrome()
    try:
        login_page = LoginPage(driver)
        dashboard_page = DashboardPage(driver)

        login_page.open()
        login_page.login('[e-mail]', 'TestPass123!')

        dashboard_page.wait_for_dashboard()

        assert '/dashboard' in driver.current_url, 'URL does not contain /dashboard'

        welcome_text = dashboard_page.get_welcome_text()
        assert welcome_text == 'Welcome, Test User', f'Unexpected welcome message: {welcome_text}'

    finally:
        driver.quit()

if __name__ == '__main__':
    test_login()

This test uses the Page Object Model (POM) pattern to organize code. The LoginPage class handles all actions on the login page, like opening the page and entering credentials. The DashboardPage class handles actions on the dashboard page, like waiting for the page to load and getting the welcome message.

Explicit waits are used to wait for elements to appear or for the URL to change. This avoids timing issues where the test tries to interact with elements before they are ready.

Assertions check that the URL contains '/dashboard' and that the welcome message text is exactly as expected. This confirms the login succeeded and the user sees the correct page.

Using POM keeps the test code clean and easy to maintain. If the page changes, only the page classes need updating, not the test logic. This pattern solves real challenges like code duplication, brittle tests, and hard-to-read scripts.

Common Mistakes - 3 Pitfalls

Using hardcoded sleeps instead of explicit waits

Locating elements inside the test function instead of page objects

Using brittle locators like absolute XPath

Bonus Challenge

Now add data-driven testing with 3 different sets of login credentials (valid and invalid) to verify login success and failure scenarios.

Show Hint

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