Debugging Selenium Tests with Pytest: Common Pitfalls and Solutions

When automating browser tests with Selenium and Pytest, it’s common to run into challenges. Selenium is a powerful tool, but it can be tricky to troubleshoot and debug. Whether you’re encountering timeouts, stale elements, or incorrect results, understanding how to identify and resolve common issues is essential.

In this blog, we’ll walk through some common pitfalls when using Selenium with Pytest and share practical solutions to help you debug your tests effectively.

Element Not Found / NoSuchElementException:
One of the most frequent errors when using Selenium is the NoSuchElementException, which occurs when Selenium cannot locate an element on the page. This usually happens if:
- - The element is not present yet (e.g., it loads dynamically).
  - The selector is incorrect or out-of-date.
- - The element is in a different frame or window.
Solution:
To resolve this, you can use Explicit Waits to ensure the element is present before interacting with it. Selenium provides the WebDriverWait method, which waits for a specific condition to be met (e.g., an element to become visible or clickable).

Example:

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

# Wait for the element to be visible
wait = WebDriverWait(driver, 10)  # Wait for up to 10 seconds
element = wait.until(EC.visibility_of_element_located((By.ID, "myElement")))
element.click()

This will wait for the element to appear within 10 seconds before trying to interact with it.

StaleElementReferenceException: The StaleElementReferenceException occurs when you try to interact with an element that is no longer part of the DOM. This can happen if the page is reloaded, or the element gets removed and recreated.
Solution: To solve this issue, simply re-locate the element before interacting with it again. Using an explicit wait before interacting with the element is also a good practice.

Example:

# First locate the element 
element = driver.find_element(By.ID, "myElement") 

# Perform an action 
element.click() 

# If the page is updated, re-locate the element 
element = driver.find_element(By.ID, "myElement") 
element.click()

Timeouts (Element Not Interactable): Timeout errors often occur when Selenium takes longer than expected to find or interact with an element. For example, trying to click an element before it’s fully loaded, or interacting with an element that’s hidden
Solution: Using explicit waits as shown in the first example will help here. But you should also ensure that the element is interactable (visible and enabled) before performing any action on it
.
Example:
```
wait = WebDriverWait(driver, 10)
element = wait.until(EC.element_to_be_clickable((By.ID, "submitButton")))
element.click()
```
In this case, element_to_be_clickable ensures that the button is not only present but also interactable (i.e., visible and enabled).

Wrong Browser Version or Compatibility Issues: Sometimes tests may pass on one browser but fail on another. This is especially common with cross-browser testing.
Solution: Make sure you’re using the correct browser drivers (e.g., ChromeDriver for Chrome, GeckoDriver for Firefox) that are compatible with the version of the browser you are testing. Also, check if the issue is specific to the browser’s rendering engine.If you’re running tests across multiple browsers, using a cloud testing service like BrowserStack or Sauce Labs is a good way to avoid browser setup issues and test on real environments.

Logging and Capturing Errors Another issue is tracking and logging errors effectively during the test execution. If you don’t capture logs, it can be hard to identify what went wrong in case of test failure.
Solution: Incorporating logging within your test can help you keep track of actions and errors, making it easier to identify issues.

Example:

import logging

# Set up logging
logging.basicConfig(level=logging.INFO)

def test_login(driver):
    logging.info("Opening login page")
    driver.get("https://example.com/login")

    logging.info("Filling in login credentials")
    driver.find_element(By.ID, "username").send_keys("user")
    driver.find_element(By.ID, "password").send_keys("pass")

    logging.info("Submitting the form")
    driver.find_element(By.ID, "submit").click()

    logging.info("Verifying login success")
    assert "Welcome" in driver.page_source

You can view the log output to trace the sequence of events in case a failure occurs.

Pytest Assertion Errors: Another common issue is assertion errors when the expected value does not match the actual value returned by the test.
Solution: When you’re running tests with Pytest, ensure that your assertions are meaningful and validate what you really care about. Sometimes, comparing strings or numbers directly may lead to errors if the values have different formats.

Example:

def test_title(driver):
    driver.get("https://example.com")
    assert driver.title == "Expected Title", f"Expected 'Expected Title' but got {driver.title}"

This assertion helps ensure that the test fails gracefully, providing helpful error messages to debug.

Pytest Markers and Test CategorizationWhen you have a large test suite, running all tests every time can slow down development. Using Pytest markers to categorize tests (e.g., @pytest.mark.smoke) can help you run only relevant tests, making debugging easier..
Solution: Use markers to tag tests for different categories, such as smoke tests, regression tests, etc.

Example:

import pytest

@pytest.mark.smoke
def test_login(driver):
    driver.get("https://example.com/login")
    assert "Login" in driver.title

@pytest.mark.regression
def test_logout(driver):
    driver.get("https://example.com/logout")
    assert "Logout Successful" in driver.page_source

Then run only smoke tests or regression tests by specifying the marker:
pytest -m smoke

Conclusion

Debugging Selenium tests with Pytest can be tricky, but by understanding common pitfalls and applying simple solutions, you can save time and improve test reliability. Here’s a quick recap of what we covered: