Automation maintenance challenges in Testing Fundamentals - Build an Automation Script

Verify login functionality with stable automation despite UI changes

Preconditions (2)

Step 1: Open the login page URL

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

Step 3: Enter 'Password123' in the password input field

Step 4: Click the login button

Step 5: Verify that the user is redirected to the dashboard page

✅ Expected Result: User successfully logs in and dashboard page is displayed

Automation Requirements - Selenium WebDriver with Python

Assertions Needed:

Verify the current URL is the dashboard URL after login

Verify the presence of a dashboard welcome message element

Best Practices:

Use explicit waits to handle dynamic page loading

Use Page Object Model to separate locators and actions

Use stable locators like IDs or data-test attributes instead of brittle XPaths

Handle UI changes by updating locators in one place (page objects)

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

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 enter_email(self, email):
        WebDriverWait(self.driver, 10).until(
            EC.visibility_of_element_located(self.email_input)
        ).send_keys(email)

    def enter_password(self, password):
        WebDriverWait(self.driver, 10).until(
            EC.visibility_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 DashboardPage:
    def __init__(self, driver):
        self.driver = driver
        self.welcome_message = (By.ID, 'welcomeMsg')

    def is_welcome_message_displayed(self):
        return WebDriverWait(self.driver, 10).until(
            EC.visibility_of_element_located(self.welcome_message)
        ) is not None


def test_login():
    driver = webdriver.Chrome()
    driver.get('https://example.com/login')

    login_page = LoginPage(driver)
    login_page.enter_email('[e-mail]')
    login_page.enter_password('Password123')
    login_page.click_login()

    WebDriverWait(driver, 10).until(
        EC.url_contains('/dashboard')
    )

    dashboard_page = DashboardPage(driver)
    assert dashboard_page.is_welcome_message_displayed(), 'Welcome message not displayed on dashboard'

    driver.quit()

This test script uses Selenium WebDriver with Python to automate the login functionality.

We use the Page Object Model to keep locators and actions organized in LoginPage and DashboardPage classes. This makes maintenance easier if UI changes.

Explicit waits ensure elements are ready before interacting, avoiding flaky tests.

Locators use stable IDs instead of brittle XPaths to reduce breakage when UI changes.

The test opens the login page, enters credentials, clicks login, waits for the dashboard URL, and asserts the welcome message is visible.

This structure helps handle automation maintenance challenges by isolating UI changes to page objects and using robust waits and locators.

Common Mistakes - 3 Pitfalls

Using hardcoded XPath locators that break easily when UI changes

Using implicit waits or no waits, causing flaky tests due to timing issues

Mixing test logic and locators directly in test scripts

Bonus Challenge

Now add data-driven testing with 3 different sets of login credentials (valid and invalid).

Show Hint

Practice

1. Why is it important to update automated tests when the software changes?

easy

A. Because updating tests slows down the development process

B. Because tests never need updates once created

C. Because outdated tests may fail even if the software works correctly

D. Because automated tests do not depend on software changes

Solution

1. Step 1: Understand the relationship between software and tests

   Automated tests check software behavior, so if software changes, tests must reflect those changes.

2. Step 2: Identify the effect of not updating tests

   If tests are not updated, they may fail incorrectly, causing confusion and wasted effort.

3. Final Answer:

   Because outdated tests may fail even if the software works correctly -> Option C

4. Quick Check:

   Update tests when software changes = Avoid false failures [OK]

Hint: Tests must match software changes to avoid false failures [OK]

Common Mistakes:

• Thinking tests never need updates
• Believing tests run independently of software
• Assuming updates slow development unnecessarily

2. Which of the following is the correct way to write a locator for a button with id 'submitBtn' in Selenium WebDriver?

easy

A. driver.find_element(By.ID, 'submitBtn')

B. driver.find_element_by_id('submitBtn')

C. driver.find_element('id', 'submitBtn')

D. driver.find_element_by_name('submitBtn')

Solution

1. Step 1: Recall the modern Selenium locator syntax

   In recent Selenium versions, locators use By class with find_element(By.ID, 'value').

2. Step 2: Identify the correct syntax among options

   driver.find_element(By.ID, 'submitBtn'): driver.find_element(By.ID, 'submitBtn'), which is correct syntax in Python Selenium.

3. Final Answer:

   driver.find_element(By.ID, 'submitBtn') -> Option A

4. Quick Check:

   Use By.ID with find_element = Correct locator syntax [OK]

Hint: Use By.ID with find_element for correct Selenium locator [OK]

Common Mistakes:

• Using deprecated find_element_by_id method
• Passing locator type as string instead of By class
• Confusing id with name locator

3. Consider this Python test snippet using pytest:

def test_sum():
    a = 2
    b = 3
    assert a + b == 6

What will be the test result when this runs?

medium

A. Test is skipped automatically

B. Test passes successfully

C. Syntax error stops the test

D. Test fails due to wrong assertion

Solution

1. Step 1: Evaluate the assertion logic

   The assertion checks if 2 + 3 equals 6, but 2 + 3 equals 5, so the assertion is false.

2. Step 2: Determine test outcome based on assertion

   Since the assertion is false, pytest will mark the test as failed.

3. Final Answer:

   Test fails due to wrong assertion -> Option D

4. Quick Check:

   2 + 3 != 6 means assertion fails [OK]

Hint: Check assertion math carefully to predict test pass/fail [OK]

Common Mistakes:

• Assuming assertion is true without calculation
• Confusing syntax error with assertion failure
• Thinking test skips without skip decorator

4. You have this Selenium test code snippet:

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

But the test fails with NoSuchElementException. What is the most likely cause?

medium

A. The driver object is not initialized

B. The element with id 'login' does not exist on the page

C. The click() method is not supported on elements

D. The syntax of find_element is incorrect

Solution

1. Step 1: Understand NoSuchElementException meaning

   This exception means Selenium could not find the element with the given locator on the page.

2. Step 2: Analyze possible causes

   If the element does not exist or is not loaded yet, this error occurs. The syntax and click() method are correct, and driver is assumed initialized.

3. Final Answer:

   The element with id 'login' does not exist on the page -> Option B

4. Quick Check:

   NoSuchElementException = Missing element on page [OK]

Hint: NoSuchElementException means locator found no matching element [OK]

Common Mistakes:

• Blaming click() method for element not found
• Assuming driver is uninitialized without evidence
• Ignoring page load or locator correctness

5. A test automation suite has many flaky tests that fail randomly due to timing issues. Which approach best reduces maintenance effort and improves reliability?

hard

A. Use explicit waits to wait for specific conditions before actions

B. Rewrite all tests in a different programming language

C. Ignore flaky tests and run only stable ones

D. Add fixed long waits (sleep) before every action

Solution

1. Step 1: Understand flaky tests caused by timing

   Flaky tests often fail because the test tries to interact before the page or element is ready.

2. Step 2: Evaluate maintenance-friendly solutions

   Using explicit waits waits only as long as needed for conditions, improving reliability without slowing tests unnecessarily.

3. Step 3: Compare other options

   Fixed long waits slow tests and increase maintenance. Ignoring flaky tests risks missing bugs. Rewriting tests is costly and unrelated to timing issues.

4. Final Answer:

   Use explicit waits to wait for specific conditions before actions -> Option A

5. Quick Check:

   Explicit waits = Reliable, maintainable tests [OK]

Hint: Use explicit waits, not fixed sleeps, to fix flaky tests [OK]

Common Mistakes:

• Using fixed sleeps causing slow, brittle tests
• Ignoring flaky tests instead of fixing
• Thinking rewriting tests solves timing issues