Element not present in the DOM

Oct 13, 2025 by sorusgentrification.com 19 views

[🐛 Bug]: Python - staleness_of is crashing with Node with given id does not belong to the document

In this article, we will be discussing a bug that occurs when using the staleness_of predicate in Selenium Python. The staleness_of predicate is used to check if an element is still present in the DOM after a certain action has been performed. However, occasionally, it crashes with the error "Node with given id does not belong to the document". This error is quite cryptic and can be frustrating to debug.

What happened?

The staleness_of predicate occasionally crashes with the following error:

selenium.common.exceptions.WebDriverException: Message: unknown error: unhandled inspector error: {"code":-32000,"message":"Node with given id does not belong to the document"}

This error occurs in a few percent of test runs, which makes it difficult to reproduce and debug. The error message suggests that the element with the given id does not belong to the document, but this is not the case. The element is indeed present in the DOM, but the staleness_of predicate is unable to verify its staleness.

How can we reproduce the issue?

To reproduce the issue, we can use the following code snippet:

old_page = driver.find_element(By.TAG_NAME, "html")
button = driver.find_element(By.ID, "login-button")
button.click()
WebDriverWait(driver, timeout).until(staleness_of(old_page))

In this code snippet, we first find the html element using driver.find_element(By.TAG_NAME, "html"). We then find the login-button element using driver.find_element(By.ID, "login-button") and click on it. Finally, we use WebDriverWait(driver, timeout).until(staleness_of(old_page)) to wait for the html element to become stale.

Relevant log output

Unfortunately, I do not have the relevant log output to share at this time. However, I have enabled Selenium logging in our tests, so I will be able to provide the logs later.

Operating System

The operating system where this issue occurs is Ubuntu.

Selenium version

The Selenium version used is Python 4.29.0.

Browser(s) and version(s)

The browser where this issue occurs is Chromium 134.0.6998.0.

Browser driver(s) and version(s)

The browser driver used is ChromeDriver 134.0.6998.35.

Are you using Selenium Grid?

Unfortunately, I do not have information on whether Selenium Grid is being used.

Possible causes

There are several possible causes for this issue:

Element not found: The element with the given id may not be found in the DOM, which would cause the staleness_of predicate to crash.
Element not present: The element with the given id may not be present in the DOM, which would cause the staleness_of predicate to crash.
Element not visible: The element with the given id may not be visible in the DOM, which would cause the staleness_of predicate to crash.
Element not enabled: The element with the given id may not be enabled in the DOM, which would cause the staleness_of predicate to crash.
Element not present in the DOM: The element with the given id may not be present in the DOM, which would cause the staleness_of predicate to crash.

Possible solutions

To solve this issue, we can try the following:

Use a different locator strategy: Instead of using the find_element method with the By.ID locator strategy, we can try using a different locator strategy such as By.XPATH or By.CSS_SELECTOR.
Use a different wait strategy: Instead of using the WebDriverWait class with the staleness_of predicate, we can try using a different wait strategy such as WebDriverWait with the presence_of_element_located predicate.
Add a timeout: We can add a timeout to the WebDriverWait class to prevent it from waiting indefinitely for the element to become stale.
Use a try-except block: We can use a try-except block to catch the WebDriverException that is raised when the staleness_of predicate crashes.

In conclusion, the staleness_of predicate in Selenium Python occasionally crashes with the error "Node with given id does not belong to the document". This error is quite cryptic and can be frustrating to debug. However, by using a different locator strategy, a different wait strategy, adding a timeout, or using a try-except block, we can solve this issue and make our tests more robust.

In the future, we can try to reproduce this issue in a more controlled environment and provide more information on the operating system, Selenium version, browser, and browser driver used. We can also try to debug the issue further by using the Selenium logs and the browser's developer tools.

Selenium Python documentation
Selenium WebDriver documentation
ChromeDriver documentation
Chromium documentation
[🐛 Bug]: Python - staleness_of is crashing with Node with given id does not belong to the document

Q: What is the staleness_of predicate in Selenium Python?

A: The staleness_of predicate in Selenium Python is a method that checks if an element is still present in the DOM after a certain action has been performed. It is used to verify that an element has become stale, meaning it is no longer present in the DOM.

Q: What is the error "Node with given id does not belong to the document" in Selenium Python?

A: The error "Node with given id does not belong to the document" in Selenium Python is a cryptic error message that occurs when the staleness_of predicate crashes. It suggests that the element with the given id does not belong to the document, but this is not the case.

Q: How can I reproduce the issue with the staleness_of predicate in Selenium Python?

A: To reproduce the issue with the staleness_of predicate in Selenium Python, you can use the following code snippet:

old_page = driver.find_element(By.TAG_NAME, "html")
button = driver.find_element(By.ID, "login-button")
button.click()
WebDriverWait(driver, timeout).until(staleness_of(old_page))

Q: What are the possible causes of the issue with the staleness_of predicate in Selenium Python?

A: There are several possible causes of the issue with the staleness_of predicate in Selenium Python, including:

Element not found: The element with the given id may not be found in the DOM, which would cause the staleness_of predicate to crash.
Element not present: The element with the given id may not be present in the DOM, which would cause the staleness_of predicate to crash.
Element not visible: The element with the given id may not be visible in the DOM, which would cause the staleness_of predicate to crash.
Element not enabled: The element with the given id may not be enabled in the DOM, which would cause the staleness_of predicate to crash.
Element not present in the DOM: The element with the given id may not be present in the DOM, which would cause the staleness_of predicate to crash.

Q: How can I solve the issue with the staleness_of predicate in Selenium Python?

A: To solve the issue with the staleness_of predicate in Selenium Python, you can try the following:

Use a different locator strategy: Instead of using the find_element method with the By.ID locator strategy, you can try using a different locator strategy such as By.XPATH or By.CSS_SELECTOR.
Use a different wait strategy: Instead of using the WebDriverWait class with the staleness_of predicate, you can try using a different wait strategy such as WebDriverWait with the presence_of_element_located predicate.
Add a timeout: You can add a timeout to the WebDriverWait class to prevent it from waiting indefinitely for the element to become stale.
Use a try-except block: You can use a try-except block to catch the WebDriverException that is raised when the staleness_of predicate crashes.

Q: What are the best practices for using the staleness_of predicate in Selenium Python?

A: The best practices for using the staleness_of predicate in Selenium Python include:

Use a try-except block: Use a try-except block to catch the WebDriverException that is raised when the staleness_of predicate crashes.
Add a timeout: Add a timeout to the WebDriverWait class to prevent it from waiting indefinitely for the element to become stale.
Use a different locator strategy: Use a different locator strategy such as By.XPATH or By.CSS_SELECTOR instead of By.ID.
Use a different wait strategy: Use a different wait strategy such as WebDriverWait with the presence_of_element_located predicate instead of staleness_of.

Q: What are the common mistakes to avoid when using the staleness_of predicate in Selenium Python?

A: The common mistakes to avoid when using the staleness_of predicate in Selenium Python include:

Not using a try-except block: Not using a try-except block to catch the WebDriverException that is raised when the staleness_of predicate crashes.
Not adding a timeout: Not adding a timeout to the WebDriverWait class to prevent it from waiting indefinitely for the element to become stale.
Using the wrong locator strategy: Using the wrong locator strategy such as By.ID instead of By.XPATH or By.CSS_SELECTOR.
Using the wrong wait strategy: Using the wrong wait strategy such as staleness_of instead of presence_of_element_located.