A RetroSearch Logo

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Search Query:

Showing content from https://playwright.dev/python/docs/api/class-locatorassertions below:

LocatorAssertions | Playwright Python

LocatorAssertions

The LocatorAssertions class provides assertion methods that can be used to make assertions about the Locator state in the tests.

from playwright.sync_api import Page, expect

def test_status_becomes_submitted(page: Page) -> None:
    
    page.get_by_role("button").click()
    expect(page.locator(".status")).to_have_text("Submitted")
from playwright.async_api import Page, expect

async def test_status_becomes_submitted(page: Page) -> None:
    
    await page.get_by_role("button").click()
    await expect(page.locator(".status")).to_have_text("Submitted")
Methods​ not_to_be_attached​Added in: v1.33 locatorAssertions.not_to_be_attached

The opposite of expect(locator).to_be_attached().

Usage

expect(locator).not_to_be_attached()
expect(locator).not_to_be_attached(**kwargs)

Arguments

Returns

not_to_be_checked​Added in: v1.20 locatorAssertions.not_to_be_checked

The opposite of expect(locator).to_be_checked().

Usage

expect(locator).not_to_be_checked()
expect(locator).not_to_be_checked(**kwargs)

Arguments

Returns

not_to_be_disabled​Added in: v1.20 locatorAssertions.not_to_be_disabled

The opposite of expect(locator).to_be_disabled().

Usage

expect(locator).not_to_be_disabled()
expect(locator).not_to_be_disabled(**kwargs)

Arguments

Returns

not_to_be_editable​Added in: v1.20 locatorAssertions.not_to_be_editable

The opposite of expect(locator).to_be_editable().

Usage

expect(locator).not_to_be_editable()
expect(locator).not_to_be_editable(**kwargs)

Arguments

Returns

not_to_be_empty​Added in: v1.20 locatorAssertions.not_to_be_empty

The opposite of expect(locator).to_be_empty().

Usage

expect(locator).not_to_be_empty()
expect(locator).not_to_be_empty(**kwargs)

Arguments

Returns

not_to_be_enabled​Added in: v1.20 locatorAssertions.not_to_be_enabled

The opposite of expect(locator).to_be_enabled().

Usage

expect(locator).not_to_be_enabled()
expect(locator).not_to_be_enabled(**kwargs)

Arguments

Returns

not_to_be_focused​Added in: v1.20 locatorAssertions.not_to_be_focused

The opposite of expect(locator).to_be_focused().

Usage

expect(locator).not_to_be_focused()
expect(locator).not_to_be_focused(**kwargs)

Arguments

Returns

not_to_be_hidden​Added in: v1.20 locatorAssertions.not_to_be_hidden

The opposite of expect(locator).to_be_hidden().

Usage

expect(locator).not_to_be_hidden()
expect(locator).not_to_be_hidden(**kwargs)

Arguments

Returns

not_to_be_in_viewport​Added in: v1.31 locatorAssertions.not_to_be_in_viewport

The opposite of expect(locator).to_be_in_viewport().

Usage

expect(locator).not_to_be_in_viewport()
expect(locator).not_to_be_in_viewport(**kwargs)

Arguments

Returns

not_to_be_visible​Added in: v1.20 locatorAssertions.not_to_be_visible

The opposite of expect(locator).to_be_visible().

Usage

expect(locator).not_to_be_visible()
expect(locator).not_to_be_visible(**kwargs)

Arguments

Returns

not_to_contain_class​Added in: v1.52 locatorAssertions.not_to_contain_class

The opposite of expect(locator).to_contain_class().

Usage

expect(locator).not_to_contain_class(expected)
expect(locator).not_to_contain_class(expected, **kwargs)

Arguments

Returns

not_to_contain_text​Added in: v1.20 locatorAssertions.not_to_contain_text

The opposite of expect(locator).to_contain_text().

Usage

expect(locator).not_to_contain_text(expected)
expect(locator).not_to_contain_text(expected, **kwargs)

Arguments

Returns

not_to_have_accessible_description​Added in: v1.44 locatorAssertions.not_to_have_accessible_description

The opposite of expect(locator).to_have_accessible_description().

Usage

expect(locator).not_to_have_accessible_description(name)
expect(locator).not_to_have_accessible_description(name, **kwargs)

Arguments

Returns

not_to_have_accessible_error_message​Added in: v1.50 locatorAssertions.not_to_have_accessible_error_message

The opposite of expect(locator).to_have_accessible_error_message().

Usage

expect(locator).not_to_have_accessible_error_message(error_message)
expect(locator).not_to_have_accessible_error_message(error_message, **kwargs)

Arguments

Returns

not_to_have_accessible_name​Added in: v1.44 locatorAssertions.not_to_have_accessible_name

The opposite of expect(locator).to_have_accessible_name().

Usage

expect(locator).not_to_have_accessible_name(name)
expect(locator).not_to_have_accessible_name(name, **kwargs)

Arguments

Returns

not_to_have_attribute​Added in: v1.20 locatorAssertions.not_to_have_attribute

The opposite of expect(locator).to_have_attribute().

Usage

expect(locator).not_to_have_attribute(name, value)
expect(locator).not_to_have_attribute(name, value, **kwargs)

Arguments

Returns

not_to_have_class​Added in: v1.20 locatorAssertions.not_to_have_class

The opposite of expect(locator).to_have_class().

Usage

expect(locator).not_to_have_class(expected)
expect(locator).not_to_have_class(expected, **kwargs)

Arguments

Returns

not_to_have_count​Added in: v1.20 locatorAssertions.not_to_have_count

The opposite of expect(locator).to_have_count().

Usage

expect(locator).not_to_have_count(count)
expect(locator).not_to_have_count(count, **kwargs)

Arguments

Returns

not_to_have_css​Added in: v1.20 locatorAssertions.not_to_have_css

The opposite of expect(locator).to_have_css().

Usage

expect(locator).not_to_have_css(name, value)
expect(locator).not_to_have_css(name, value, **kwargs)

Arguments

Returns

not_to_have_id​Added in: v1.20 locatorAssertions.not_to_have_id

The opposite of expect(locator).to_have_id().

Usage

expect(locator).not_to_have_id(id)
expect(locator).not_to_have_id(id, **kwargs)

Arguments

Returns

not_to_have_js_property​Added in: v1.20 locatorAssertions.not_to_have_js_property

The opposite of expect(locator).to_have_js_property().

Usage

expect(locator).not_to_have_js_property(name, value)
expect(locator).not_to_have_js_property(name, value, **kwargs)

Arguments

Returns

not_to_have_role​Added in: v1.44 locatorAssertions.not_to_have_role

The opposite of expect(locator).to_have_role().

Usage

expect(locator).not_to_have_role(role)
expect(locator).not_to_have_role(role, **kwargs)

Arguments

Returns

not_to_have_text​Added in: v1.20 locatorAssertions.not_to_have_text

The opposite of expect(locator).to_have_text().

Usage

expect(locator).not_to_have_text(expected)
expect(locator).not_to_have_text(expected, **kwargs)

Arguments

Returns

not_to_have_value​Added in: v1.20 locatorAssertions.not_to_have_value

The opposite of expect(locator).to_have_value().

Usage

expect(locator).not_to_have_value(value)
expect(locator).not_to_have_value(value, **kwargs)

Arguments

Returns

not_to_have_values​Added in: v1.23 locatorAssertions.not_to_have_values

The opposite of expect(locator).to_have_values().

Usage

expect(locator).not_to_have_values(values)
expect(locator).not_to_have_values(values, **kwargs)

Arguments

Returns

not_to_match_aria_snapshot​Added in: v1.49 locatorAssertions.not_to_match_aria_snapshot

The opposite of expect(locator).to_match_aria_snapshot().

Usage

expect(locator).not_to_match_aria_snapshot(expected)
expect(locator).not_to_match_aria_snapshot(expected, **kwargs)

Arguments

Returns

to_be_attached​Added in: v1.33 locatorAssertions.to_be_attached

Ensures that Locator points to an element that is connected to a Document or a ShadowRoot.

Usage

expect(page.get_by_text("Hidden text")).to_be_attached()
await expect(page.get_by_text("Hidden text")).to_be_attached()

Arguments

Returns

to_be_checked​Added in: v1.20 locatorAssertions.to_be_checked

Ensures the Locator points to a checked input.

Usage

from playwright.sync_api import expect

locator = page.get_by_label("Subscribe to newsletter")
expect(locator).to_be_checked()
from playwright.async_api import expect

locator = page.get_by_label("Subscribe to newsletter")
await expect(locator).to_be_checked()

Arguments

Returns

to_be_disabled​Added in: v1.20 locatorAssertions.to_be_disabled

Ensures the Locator points to a disabled element. Element is disabled if it has "disabled" attribute or is disabled via 'aria-disabled'. Note that only native control elements such as HTML button, input, select, textarea, option, optgroup can be disabled by setting "disabled" attribute. "disabled" attribute on other elements is ignored by the browser.

Usage

from playwright.sync_api import expect

locator = page.locator("button.submit")
expect(locator).to_be_disabled()
from playwright.async_api import expect

locator = page.locator("button.submit")
await expect(locator).to_be_disabled()

Arguments

Returns

to_be_editable​Added in: v1.20 locatorAssertions.to_be_editable

Ensures the Locator points to an editable element.

Usage

from playwright.sync_api import expect

locator = page.get_by_role("textbox")
expect(locator).to_be_editable()
from playwright.async_api import expect

locator = page.get_by_role("textbox")
await expect(locator).to_be_editable()

Arguments

Returns

to_be_empty​Added in: v1.20 locatorAssertions.to_be_empty

Ensures the Locator points to an empty editable element or to a DOM node that has no text.

Usage

from playwright.sync_api import expect

locator = page.locator("div.warning")
expect(locator).to_be_empty()
from playwright.async_api import expect

locator = page.locator("div.warning")
await expect(locator).to_be_empty()

Arguments

Returns

to_be_enabled​Added in: v1.20 locatorAssertions.to_be_enabled

Ensures the Locator points to an enabled element.

Usage

from playwright.sync_api import expect

locator = page.locator("button.submit")
expect(locator).to_be_enabled()
from playwright.async_api import expect

locator = page.locator("button.submit")
await expect(locator).to_be_enabled()

Arguments

Returns

to_be_focused​Added in: v1.20 locatorAssertions.to_be_focused

Ensures the Locator points to a focused DOM node.

Usage

from playwright.sync_api import expect

locator = page.get_by_role("textbox")
expect(locator).to_be_focused()
from playwright.async_api import expect

locator = page.get_by_role("textbox")
await expect(locator).to_be_focused()

Arguments

Returns

to_be_hidden​Added in: v1.20 locatorAssertions.to_be_hidden

Ensures that Locator either does not resolve to any DOM node, or resolves to a non-visible one.

Usage

from playwright.sync_api import expect

locator = page.locator('.my-element')
expect(locator).to_be_hidden()
from playwright.async_api import expect

locator = page.locator('.my-element')
await expect(locator).to_be_hidden()

Arguments

Returns

to_be_in_viewport​Added in: v1.31 locatorAssertions.to_be_in_viewport

Ensures the Locator points to an element that intersects viewport, according to the intersection observer API.

Usage

from playwright.sync_api import expect

locator = page.get_by_role("button")

expect(locator).to_be_in_viewport()

expect(locator).not_to_be_in_viewport()

expect(locator).to_be_in_viewport(ratio=0.5)
from playwright.async_api import expect

locator = page.get_by_role("button")

await expect(locator).to_be_in_viewport()

await expect(locator).not_to_be_in_viewport()

await expect(locator).to_be_in_viewport(ratio=0.5)

Arguments

Returns

to_be_visible​Added in: v1.20 locatorAssertions.to_be_visible

Ensures that Locator points to an attached and visible DOM node.

To check that at least one element from the list is visible, use locator.first.

Usage


expect(page.get_by_text("Welcome")).to_be_visible()


expect(page.get_by_test_id("todo-item").first).to_be_visible()


expect(
    page.get_by_role("button", name="Sign in")
    .or_(page.get_by_role("button", name="Sign up"))
    .first
).to_be_visible()

await expect(page.get_by_text("Welcome")).to_be_visible()


await expect(page.get_by_test_id("todo-item").first).to_be_visible()


await expect(
    page.get_by_role("button", name="Sign in")
    .or_(page.get_by_role("button", name="Sign up"))
    .first
).to_be_visible()

Arguments

Returns

to_contain_class​Added in: v1.52 locatorAssertions.to_contain_class

Ensures the Locator points to an element with given CSS classes. All classes from the asserted value, separated by spaces, must be present in the Element.classList in any order.

Usage

<div class='middle selected row' id='component'></div>
from playwright.sync_api import expect

locator = page.locator("#component")
expect(locator).to_contain_class("middle selected row")
expect(locator).to_contain_class("selected")
expect(locator).to_contain_class("row middle")
from playwright.async_api import expect

locator = page.locator("#component")
await expect(locator).to_contain_class("middle selected row")
await expect(locator).to_contain_class("selected")
await expect(locator).to_contain_class("row middle")

When an array is passed, the method asserts that the list of elements located matches the corresponding list of expected class lists. Each element's class attribute is matched against the corresponding class in the array:

<div class='list'>
  <div class='component inactive'></div>
  <div class='component active'></div>
  <div class='component inactive'></div>
</div>
from playwright.sync_api import expect

locator = page.locator(".list > .component")
await expect(locator).to_contain_class(["inactive", "active", "inactive"])
from playwright.async_api import expect

locator = page.locator(".list > .component")
await expect(locator).to_contain_class(["inactive", "active", "inactive"])

Arguments

Returns

to_contain_text​Added in: v1.20 locatorAssertions.to_contain_text

Ensures the Locator points to an element that contains the given text. All nested elements will be considered when computing the text content of the element. You can use regular expressions for the value as well.

Usage

import re
from playwright.sync_api import expect

locator = page.locator('.title')
expect(locator).to_contain_text("substring")
expect(locator).to_contain_text(re.compile(r"\d messages"))
import re
from playwright.async_api import expect

locator = page.locator('.title')
await expect(locator).to_contain_text("substring")
await expect(locator).to_contain_text(re.compile(r"\d messages"))

If you pass an array as an expected value, the expectations are:

  1. Locator resolves to a list of elements.
  2. Elements from a subset of this list contain text from the expected array, respectively.
  3. The matching subset of elements has the same order as the expected array.
  4. Each text value from the expected array is matched by some element from the list.

For example, consider the following list:

<ul>
  <li>Item Text 1</li>
  <li>Item Text 2</li>
  <li>Item Text 3</li>
</ul>

Let's see how we can use the assertion:

from playwright.sync_api import expect


expect(page.locator("ul > li")).to_contain_text(["Text 1", "Text 3", "Text 4"])


expect(page.locator("ul > li")).to_contain_text(["Text 3", "Text 2"])


expect(page.locator("ul > li")).to_contain_text(["Some 33"])


expect(page.locator("ul")).to_contain_text(["Text 3"])
from playwright.async_api import expect


await expect(page.locator("ul > li")).to_contain_text(["Text 1", "Text 3", "Text 4"])


await expect(page.locator("ul > li")).to_contain_text(["Text 3", "Text 2"])


await expect(page.locator("ul > li")).to_contain_text(["Some 33"])


await expect(page.locator("ul")).to_contain_text(["Text 3"])

Arguments

Returns

Details

When expected parameter is a string, Playwright will normalize whitespaces and line breaks both in the actual text and in the expected string before matching. When regular expression is used, the actual text is matched as is.

to_have_accessible_description​Added in: v1.44 locatorAssertions.to_have_accessible_description

Ensures the Locator points to an element with a given accessible description.

Usage

locator = page.get_by_test_id("save-button")
expect(locator).to_have_accessible_description("Save results to disk")
locator = page.get_by_test_id("save-button")
await expect(locator).to_have_accessible_description("Save results to disk")

Arguments

Returns

to_have_accessible_error_message​Added in: v1.50 locatorAssertions.to_have_accessible_error_message

Ensures the Locator points to an element with a given aria errormessage.

Usage

locator = page.get_by_test_id("username-input")
expect(locator).to_have_accessible_error_message("Username is required.")
locator = page.get_by_test_id("username-input")
await expect(locator).to_have_accessible_error_message("Username is required.")

Arguments

Returns

to_have_accessible_name​Added in: v1.44 locatorAssertions.to_have_accessible_name

Ensures the Locator points to an element with a given accessible name.

Usage

locator = page.get_by_test_id("save-button")
expect(locator).to_have_accessible_name("Save to disk")
locator = page.get_by_test_id("save-button")
await expect(locator).to_have_accessible_name("Save to disk")

Arguments

Returns

to_have_attribute​Added in: v1.20 locatorAssertions.to_have_attribute

Ensures the Locator points to an element with given attribute.

Usage

from playwright.sync_api import expect

locator = page.locator("input")
expect(locator).to_have_attribute("type", "text")
from playwright.async_api import expect

locator = page.locator("input")
await expect(locator).to_have_attribute("type", "text")

Arguments

Returns

to_have_class​Added in: v1.20 locatorAssertions.to_have_class

Ensures the Locator points to an element with given CSS classes. When a string is provided, it must fully match the element's class attribute. To match individual classes use expect(locator).to_contain_class().

Usage

<div class='middle selected row' id='component'></div>
from playwright.sync_api import expect

locator = page.locator("#component")
expect(locator).to_have_class("middle selected row")
expect(locator).to_have_class(re.compile(r"(^|\\s)selected(\\s|$)"))
from playwright.async_api import expect

locator = page.locator("#component")
await expect(locator).to_have_class("middle selected row")
await expect(locator).to_have_class(re.compile(r"(^|\\s)selected(\\s|$)"))

When an array is passed, the method asserts that the list of elements located matches the corresponding list of expected class values. Each element's class attribute is matched against the corresponding string or regular expression in the array:

from playwright.sync_api import expect

locator = page.locator(".list > .component")
expect(locator).to_have_class(["component", "component selected", "component"])
from playwright.async_api import expect

locator = page.locator(".list > .component")
await expect(locator).to_have_class(["component", "component selected", "component"])

Arguments

Returns

to_have_count​Added in: v1.20 locatorAssertions.to_have_count

Ensures the Locator resolves to an exact number of DOM nodes.

Usage

from playwright.sync_api import expect

locator = page.locator("list > .component")
expect(locator).to_have_count(3)
from playwright.async_api import expect

locator = page.locator("list > .component")
await expect(locator).to_have_count(3)

Arguments

Returns

to_have_css​Added in: v1.20 locatorAssertions.to_have_css

Ensures the Locator resolves to an element with the given computed CSS style.

Usage

from playwright.sync_api import expect

locator = page.get_by_role("button")
expect(locator).to_have_css("display", "flex")
from playwright.async_api import expect

locator = page.get_by_role("button")
await expect(locator).to_have_css("display", "flex")

Arguments

Returns

to_have_id​Added in: v1.20 locatorAssertions.to_have_id

Ensures the Locator points to an element with the given DOM Node ID.

Usage

from playwright.sync_api import expect

locator = page.get_by_role("textbox")
expect(locator).to_have_id("lastname")
from playwright.async_api import expect

locator = page.get_by_role("textbox")
await expect(locator).to_have_id("lastname")

Arguments

Returns

to_have_js_property​Added in: v1.20 locatorAssertions.to_have_js_property

Ensures the Locator points to an element with given JavaScript property. Note that this property can be of a primitive type as well as a plain serializable JavaScript object.

Usage

from playwright.sync_api import expect

locator = page.locator(".component")
expect(locator).to_have_js_property("loaded", True)
from playwright.async_api import expect

locator = page.locator(".component")
await expect(locator).to_have_js_property("loaded", True)

Arguments

Returns

to_have_role​Added in: v1.44 locatorAssertions.to_have_role

Ensures the Locator points to an element with a given ARIA role.

Note that role is matched as a string, disregarding the ARIA role hierarchy. For example, asserting a superclass role "checkbox" on an element with a subclass role "switch" will fail.

Usage

locator = page.get_by_test_id("save-button")
expect(locator).to_have_role("button")
locator = page.get_by_test_id("save-button")
await expect(locator).to_have_role("button")

Arguments

Returns

to_have_text​Added in: v1.20 locatorAssertions.to_have_text

Ensures the Locator points to an element with the given text. All nested elements will be considered when computing the text content of the element. You can use regular expressions for the value as well.

Usage

import re
from playwright.sync_api import expect

locator = page.locator(".title")
expect(locator).to_have_text(re.compile(r"Welcome, Test User"))
expect(locator).to_have_text(re.compile(r"Welcome, .*"))
import re
from playwright.async_api import expect

locator = page.locator(".title")
await expect(locator).to_have_text(re.compile(r"Welcome, Test User"))
await expect(locator).to_have_text(re.compile(r"Welcome, .*"))

If you pass an array as an expected value, the expectations are:

  1. Locator resolves to a list of elements.
  2. The number of elements equals the number of expected values in the array.
  3. Elements from the list have text matching expected array values, one by one, in order.

For example, consider the following list:

<ul>
  <li>Text 1</li>
  <li>Text 2</li>
  <li>Text 3</li>
</ul>

Let's see how we can use the assertion:

from playwright.sync_api import expect


expect(page.locator("ul > li")).to_have_text(["Text 1", "Text 2", "Text 3"])


expect(page.locator("ul > li")).to_have_text(["Text 3", "Text 2", "Text 1"])


expect(page.locator("ul > li")).to_have_text(["Text 1", "Text 2", "Text"])


expect(page.locator("ul")).to_have_text(["Text 1", "Text 2", "Text 3"])
from playwright.async_api import expect


await expect(page.locator("ul > li")).to_have_text(["Text 1", "Text 2", "Text 3"])


await expect(page.locator("ul > li")).to_have_text(["Text 3", "Text 2", "Text 1"])


await expect(page.locator("ul > li")).to_have_text(["Text 1", "Text 2", "Text"])


await expect(page.locator("ul")).to_have_text(["Text 1", "Text 2", "Text 3"])

Arguments

Returns

Details

When expected parameter is a string, Playwright will normalize whitespaces and line breaks both in the actual text and in the expected string before matching. When regular expression is used, the actual text is matched as is.

to_have_value​Added in: v1.20 locatorAssertions.to_have_value

Ensures the Locator points to an element with the given input value. You can use regular expressions for the value as well.

Usage

import re
from playwright.sync_api import expect

locator = page.locator("input[type=number]")
expect(locator).to_have_value(re.compile(r"[0-9]"))
import re
from playwright.async_api import expect

locator = page.locator("input[type=number]")
await expect(locator).to_have_value(re.compile(r"[0-9]"))

Arguments

Returns

to_have_values​Added in: v1.23 locatorAssertions.to_have_values

Ensures the Locator points to multi-select/combobox (i.e. a select with the multiple attribute) and the specified values are selected.

Usage

For example, given the following element:

<select id="favorite-colors" multiple>
  <option value="R">Red</option>
  <option value="G">Green</option>
  <option value="B">Blue</option>
</select>
import re
from playwright.sync_api import expect

locator = page.locator("id=favorite-colors")
locator.select_option(["R", "G"])
expect(locator).to_have_values([re.compile(r"R"), re.compile(r"G")])
import re
from playwright.async_api import expect

locator = page.locator("id=favorite-colors")
await locator.select_option(["R", "G"])
await expect(locator).to_have_values([re.compile(r"R"), re.compile(r"G")])

Arguments

Returns

to_match_aria_snapshot​Added in: v1.49 locatorAssertions.to_match_aria_snapshot

Asserts that the target element matches the given accessibility snapshot.

Usage

page.goto("https://demo.playwright.dev/todomvc/")
expect(page.locator('body')).to_match_aria_snapshot('''
  - heading "todos"
  - textbox "What needs to be done?"
''')
await page.goto("https://demo.playwright.dev/todomvc/")
await expect(page.locator('body')).to_match_aria_snapshot('''
  - heading "todos"
  - textbox "What needs to be done?"
''')

Arguments

Returns

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4