Class: Playwright::LocatorAssertions

Inherits:
PlaywrightApi show all
Defined in:
lib/playwright_api/locator_assertions.rb,
sig/playwright.rbs

Overview

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")

Instance Method Summary collapse

Methods inherited from PlaywrightApi

#initialize, unwrap, wrap

Constructor Details

This class inherits a constructor from Playwright::PlaywrightApi

Instance Method Details

#not_to_be_attached(attached: nil, timeout: nil) ⇒ void

This method returns an undefined value.

The opposite of [method: LocatorAssertions.toBeAttached].

Parameters:

  • attached: (Boolean) (defaults to: nil)
  • timeout: (Float) (defaults to: nil) 


17
18
19
 
# File 'lib/playwright_api/locator_assertions.rb', line 17

def not_to_be_attached(attached: nil, timeout: nil)
  wrap_impl(@impl.not_to_be_attached(attached: unwrap_impl(attached), timeout: unwrap_impl(timeout)))
end

#not_to_be_checked(timeout: nil) ⇒ void

This method returns an undefined value.

The opposite of [method: LocatorAssertions.toBeChecked].

Parameters:

  • timeout: (Float) (defaults to: nil) 


23
24
25
 
# File 'lib/playwright_api/locator_assertions.rb', line 23

def not_to_be_checked(timeout: nil)
  wrap_impl(@impl.not_to_be_checked(timeout: unwrap_impl(timeout)))
end

#not_to_be_disabled(timeout: nil) ⇒ void

This method returns an undefined value.

The opposite of [method: LocatorAssertions.toBeDisabled].

Parameters:

  • timeout: (Float) (defaults to: nil) 


29
30
31
 
# File 'lib/playwright_api/locator_assertions.rb', line 29

def not_to_be_disabled(timeout: nil)
  wrap_impl(@impl.not_to_be_disabled(timeout: unwrap_impl(timeout)))
end

#not_to_be_editable(editable: nil, timeout: nil) ⇒ void

This method returns an undefined value.

The opposite of [method: LocatorAssertions.toBeEditable].

Parameters:

  • editable: (Boolean) (defaults to: nil)
  • timeout: (Float) (defaults to: nil) 


35
36
37
 
# File 'lib/playwright_api/locator_assertions.rb', line 35

def not_to_be_editable(editable: nil, timeout: nil)
  wrap_impl(@impl.not_to_be_editable(editable: unwrap_impl(editable), timeout: unwrap_impl(timeout)))
end

#not_to_be_empty(timeout: nil) ⇒ void

This method returns an undefined value.

The opposite of [method: LocatorAssertions.toBeEmpty].

Parameters:

  • timeout: (Float) (defaults to: nil) 


41
42
43
 
# File 'lib/playwright_api/locator_assertions.rb', line 41

def not_to_be_empty(timeout: nil)
  wrap_impl(@impl.not_to_be_empty(timeout: unwrap_impl(timeout)))
end

#not_to_be_enabled(enabled: nil, timeout: nil) ⇒ void

This method returns an undefined value.

The opposite of [method: LocatorAssertions.toBeEnabled].

Parameters:

  • enabled: (Boolean) (defaults to: nil)
  • timeout: (Float) (defaults to: nil) 


47
48
49
 
# File 'lib/playwright_api/locator_assertions.rb', line 47

def not_to_be_enabled(enabled: nil, timeout: nil)
  wrap_impl(@impl.not_to_be_enabled(enabled: unwrap_impl(enabled), timeout: unwrap_impl(timeout)))
end

#not_to_be_focused(timeout: nil) ⇒ void

This method returns an undefined value.

The opposite of [method: LocatorAssertions.toBeFocused].

Parameters:

  • timeout: (Float) (defaults to: nil) 


53
54
55
 
# File 'lib/playwright_api/locator_assertions.rb', line 53

def not_to_be_focused(timeout: nil)
  wrap_impl(@impl.not_to_be_focused(timeout: unwrap_impl(timeout)))
end

#not_to_be_hidden(timeout: nil) ⇒ void

This method returns an undefined value.

The opposite of [method: LocatorAssertions.toBeHidden].

Parameters:

  • timeout: (Float) (defaults to: nil) 


59
60
61
 
# File 'lib/playwright_api/locator_assertions.rb', line 59

def not_to_be_hidden(timeout: nil)
  wrap_impl(@impl.not_to_be_hidden(timeout: unwrap_impl(timeout)))
end

#not_to_be_in_viewport(ratio: nil, timeout: nil) ⇒ void

This method returns an undefined value.

The opposite of [method: LocatorAssertions.toBeInViewport].

Parameters:

  • ratio: (Float) (defaults to: nil)
  • timeout: (Float) (defaults to: nil) 


65
66
67
 
# File 'lib/playwright_api/locator_assertions.rb', line 65

def not_to_be_in_viewport(ratio: nil, timeout: nil)
  wrap_impl(@impl.not_to_be_in_viewport(ratio: unwrap_impl(ratio), timeout: unwrap_impl(timeout)))
end

#not_to_be_visible(timeout: nil, visible: nil) ⇒ void

This method returns an undefined value.

The opposite of [method: LocatorAssertions.toBeVisible].

Parameters:

  • timeout: (Float) (defaults to: nil)
  • visible: (Boolean) (defaults to: nil) 


71
72
73
 
# File 'lib/playwright_api/locator_assertions.rb', line 71

def not_to_be_visible(timeout: nil, visible: nil)
  wrap_impl(@impl.not_to_be_visible(timeout: unwrap_impl(timeout), visible: unwrap_impl(visible)))
end

#not_to_contain_class(expected, timeout: nil) ⇒ void

This method returns an undefined value.

The opposite of [method: LocatorAssertions.toContainClass].

Parameters:

  • expected (String, Array[untyped])
  • timeout: (Float) (defaults to: nil) 


77
78
79
 
# File 'lib/playwright_api/locator_assertions.rb', line 77

def not_to_contain_class(expected, timeout: nil)
  wrap_impl(@impl.not_to_contain_class(unwrap_impl(expected), timeout: unwrap_impl(timeout)))
end

#not_to_contain_text(expected, ignoreCase: nil, timeout: nil, useInnerText: nil) ⇒ void

This method returns an undefined value.

The opposite of [method: LocatorAssertions.toContainText].

Parameters:

  • expected (String, Regexp, Array[untyped], Array[untyped], Array[untyped])
  • ignoreCase: (Boolean) (defaults to: nil)
  • timeout: (Float) (defaults to: nil)
  • useInnerText: (Boolean) (defaults to: nil) 


83
84
85
 
# File 'lib/playwright_api/locator_assertions.rb', line 83

def not_to_contain_text(expected, ignoreCase: nil, timeout: nil, useInnerText: nil)
  wrap_impl(@impl.not_to_contain_text(unwrap_impl(expected), ignoreCase: unwrap_impl(ignoreCase), timeout: unwrap_impl(timeout), useInnerText: unwrap_impl(useInnerText)))
end

#not_to_have_accessible_description(name, ignoreCase: nil, timeout: nil) ⇒ void

This method returns an undefined value.

The opposite of [method: LocatorAssertions.toHaveAccessibleDescription].

Parameters:

  • name (String, Regexp)
  • ignoreCase: (Boolean) (defaults to: nil)
  • timeout: (Float) (defaults to: nil) 


89
90
91
 
# File 'lib/playwright_api/locator_assertions.rb', line 89

def not_to_have_accessible_description(name, ignoreCase: nil, timeout: nil)
  wrap_impl(@impl.not_to_have_accessible_description(unwrap_impl(name), ignoreCase: unwrap_impl(ignoreCase), timeout: unwrap_impl(timeout)))
end

#not_to_have_accessible_error_message(errorMessage, ignoreCase: nil, timeout: nil) ⇒ void

This method returns an undefined value.

The opposite of [method: LocatorAssertions.toHaveAccessibleErrorMessage].

Parameters:

  • errorMessage (String, Regexp)
  • ignoreCase: (Boolean) (defaults to: nil)
  • timeout: (Float) (defaults to: nil) 


95
96
97
 
# File 'lib/playwright_api/locator_assertions.rb', line 95

def not_to_have_accessible_error_message(errorMessage, ignoreCase: nil, timeout: nil)
  wrap_impl(@impl.not_to_have_accessible_error_message(unwrap_impl(errorMessage), ignoreCase: unwrap_impl(ignoreCase), timeout: unwrap_impl(timeout)))
end

#not_to_have_accessible_name(name, ignoreCase: nil, timeout: nil) ⇒ void

This method returns an undefined value.

The opposite of [method: LocatorAssertions.toHaveAccessibleName].

Parameters:

  • name (String, Regexp)
  • ignoreCase: (Boolean) (defaults to: nil)
  • timeout: (Float) (defaults to: nil) 


101
102
103
 
# File 'lib/playwright_api/locator_assertions.rb', line 101

def not_to_have_accessible_name(name, ignoreCase: nil, timeout: nil)
  wrap_impl(@impl.not_to_have_accessible_name(unwrap_impl(name), ignoreCase: unwrap_impl(ignoreCase), timeout: unwrap_impl(timeout)))
end

#not_to_have_attribute(name, value, ignoreCase: nil, timeout: nil) ⇒ void

This method returns an undefined value.

The opposite of [method: LocatorAssertions.toHaveAttribute].

Parameters:

  • name (String)
  • value (String, Regexp)
  • ignoreCase: (Boolean) (defaults to: nil)
  • timeout: (Float) (defaults to: nil) 


107
108
109
 
# File 'lib/playwright_api/locator_assertions.rb', line 107

def not_to_have_attribute(name, value, ignoreCase: nil, timeout: nil)
  wrap_impl(@impl.not_to_have_attribute(unwrap_impl(name), unwrap_impl(value), ignoreCase: unwrap_impl(ignoreCase), timeout: unwrap_impl(timeout)))
end

#not_to_have_class(expected, timeout: nil) ⇒ void

This method returns an undefined value.

The opposite of [method: LocatorAssertions.toHaveClass].

Parameters:

  • expected (String, Regexp, Array[untyped], Array[untyped], Array[untyped])
  • timeout: (Float) (defaults to: nil) 


113
114
115
 
# File 'lib/playwright_api/locator_assertions.rb', line 113

def not_to_have_class(expected, timeout: nil)
  wrap_impl(@impl.not_to_have_class(unwrap_impl(expected), timeout: unwrap_impl(timeout)))
end

#not_to_have_count(count, timeout: nil) ⇒ void

This method returns an undefined value.

The opposite of [method: LocatorAssertions.toHaveCount].

Parameters:

  • count (Integer)
  • timeout: (Float) (defaults to: nil) 


119
120
121
 
# File 'lib/playwright_api/locator_assertions.rb', line 119

def not_to_have_count(count, timeout: nil)
  wrap_impl(@impl.not_to_have_count(unwrap_impl(count), timeout: unwrap_impl(timeout)))
end

#not_to_have_css(name, value, timeout: nil) ⇒ void

This method returns an undefined value.

The opposite of [method: LocatorAssertions.toHaveCSS].

Parameters:

  • name (String)
  • value (String, Regexp)
  • timeout: (Float) (defaults to: nil) 


125
126
127
 
# File 'lib/playwright_api/locator_assertions.rb', line 125

def not_to_have_css(name, value, timeout: nil)
  wrap_impl(@impl.not_to_have_css(unwrap_impl(name), unwrap_impl(value), timeout: unwrap_impl(timeout)))
end

#not_to_have_id(id, timeout: nil) ⇒ void

This method returns an undefined value.

The opposite of [method: LocatorAssertions.toHaveId].

Parameters:

  • id (String, Regexp)
  • timeout: (Float) (defaults to: nil) 


131
132
133
 
# File 'lib/playwright_api/locator_assertions.rb', line 131

def not_to_have_id(id, timeout: nil)
  wrap_impl(@impl.not_to_have_id(unwrap_impl(id), timeout: unwrap_impl(timeout)))
end

#not_to_have_js_property(name, value, timeout: nil) ⇒ void

This method returns an undefined value.

The opposite of [method: LocatorAssertions.toHaveJSProperty].

Parameters:

  • name (String)
  • value (Object)
  • timeout: (Float) (defaults to: nil) 


137
138
139
 
# File 'lib/playwright_api/locator_assertions.rb', line 137

def not_to_have_js_property(name, value, timeout: nil)
  wrap_impl(@impl.not_to_have_js_property(unwrap_impl(name), unwrap_impl(value), timeout: unwrap_impl(timeout)))
end

#not_to_have_role(role, timeout: nil) ⇒ void

This method returns an undefined value.

The opposite of [method: LocatorAssertions.toHaveRole].

Parameters:

  • role ("alert", "alertdialog", "application", "article", "banner", "blockquote", "button", "caption", "cell", "checkbox", "code", "columnheader", "combobox", "complementary", "contentinfo", "definition", "deletion", "dialog", "directory", "document", "emphasis", "feed", "figure", "form", "generic", "grid", "gridcell", "group", "heading", "img", "insertion", "link", "list", "listbox", "listitem", "log", "main", "marquee", "math", "meter", "menu", "menubar", "menuitem", "menuitemcheckbox", "menuitemradio", "navigation", "none", "note", "option", "paragraph", "presentation", "progressbar", "radio", "radiogroup", "region", "row", "rowgroup", "rowheader", "scrollbar", "search", "searchbox", "separator", "slider", "spinbutton", "status", "strong", "subscript", "superscript", "switch", "tab", "table", "tablist", "tabpanel", "term", "textbox", "time", "timer", "toolbar", "tooltip", "tree", "treegrid", "treeitem")
  • timeout: (Float) (defaults to: nil) 


143
144
145
 
# File 'lib/playwright_api/locator_assertions.rb', line 143

def not_to_have_role(role, timeout: nil)
  wrap_impl(@impl.not_to_have_role(unwrap_impl(role), timeout: unwrap_impl(timeout)))
end

#not_to_have_text(expected, ignoreCase: nil, timeout: nil, useInnerText: nil) ⇒ void

This method returns an undefined value.

The opposite of [method: LocatorAssertions.toHaveText].

Parameters:

  • expected (String, Regexp, Array[untyped], Array[untyped], Array[untyped])
  • ignoreCase: (Boolean) (defaults to: nil)
  • timeout: (Float) (defaults to: nil)
  • useInnerText: (Boolean) (defaults to: nil) 


149
150
151
 
# File 'lib/playwright_api/locator_assertions.rb', line 149

def not_to_have_text(expected, ignoreCase: nil, timeout: nil, useInnerText: nil)
  wrap_impl(@impl.not_to_have_text(unwrap_impl(expected), ignoreCase: unwrap_impl(ignoreCase), timeout: unwrap_impl(timeout), useInnerText: unwrap_impl(useInnerText)))
end

#not_to_have_value(value, timeout: nil) ⇒ void

This method returns an undefined value.

The opposite of [method: LocatorAssertions.toHaveValue].

Parameters:

  • value (String, Regexp)
  • timeout: (Float) (defaults to: nil) 


155
156
157
 
# File 'lib/playwright_api/locator_assertions.rb', line 155

def not_to_have_value(value, timeout: nil)
  wrap_impl(@impl.not_to_have_value(unwrap_impl(value), timeout: unwrap_impl(timeout)))
end

#not_to_have_values(values, timeout: nil) ⇒ void

This method returns an undefined value.

The opposite of [method: LocatorAssertions.toHaveValues].

Parameters:

  • values (Array[untyped], Array[untyped], Array[untyped])
  • timeout: (Float) (defaults to: nil) 


161
162
163
 
# File 'lib/playwright_api/locator_assertions.rb', line 161

def not_to_have_values(values, timeout: nil)
  wrap_impl(@impl.not_to_have_values(unwrap_impl(values), timeout: unwrap_impl(timeout)))
end

#not_to_match_aria_snapshot(expected, timeout: nil) ⇒ void

This method returns an undefined value.

The opposite of [method: LocatorAssertions.toMatchAriaSnapshot].

Parameters:

  • expected (String)
  • timeout: (Float) (defaults to: nil) 


167
168
169
 
# File 'lib/playwright_api/locator_assertions.rb', line 167

def not_to_match_aria_snapshot(expected, timeout: nil)
  wrap_impl(@impl.not_to_match_aria_snapshot(unwrap_impl(expected), timeout: unwrap_impl(timeout)))
end

#to_be_attached(attached: nil, timeout: nil) ⇒ void

This method returns an undefined value.

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()

Parameters:

  • attached: (Boolean) (defaults to: nil)
  • timeout: (Float) (defaults to: nil) 


179
180
181
 
# File 'lib/playwright_api/locator_assertions.rb', line 179

def to_be_attached(attached: nil, timeout: nil)
  wrap_impl(@impl.to_be_attached(attached: unwrap_impl(attached), timeout: unwrap_impl(timeout)))
end

#to_be_checked(checked: nil, indeterminate: nil, timeout: nil) ⇒ void

This method returns an undefined value.

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()

Parameters:

  • checked: (Boolean) (defaults to: nil)
  • indeterminate: (Boolean) (defaults to: nil)
  • timeout: (Float) (defaults to: nil) 


194
195
196
 
# File 'lib/playwright_api/locator_assertions.rb', line 194

def to_be_checked(checked: nil, indeterminate: nil, timeout: nil)
  wrap_impl(@impl.to_be_checked(checked: unwrap_impl(checked), indeterminate: unwrap_impl(indeterminate), timeout: unwrap_impl(timeout)))
end

#to_be_disabled(timeout: nil) ⇒ void

This method returns an undefined value.

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()

Parameters:

  • timeout: (Float) (defaults to: nil) 


213
214
215
 
# File 'lib/playwright_api/locator_assertions.rb', line 213

def to_be_disabled(timeout: nil)
  wrap_impl(@impl.to_be_disabled(timeout: unwrap_impl(timeout)))
end

#to_be_editable(editable: nil, timeout: nil) ⇒ void

This method returns an undefined value.

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()

Parameters:

  • editable: (Boolean) (defaults to: nil)
  • timeout: (Float) (defaults to: nil) 


228
229
230
 
# File 'lib/playwright_api/locator_assertions.rb', line 228

def to_be_editable(editable: nil, timeout: nil)
  wrap_impl(@impl.to_be_editable(editable: unwrap_impl(editable), timeout: unwrap_impl(timeout)))
end

#to_be_empty(timeout: nil) ⇒ void

This method returns an undefined value.

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()

Parameters:

  • timeout: (Float) (defaults to: nil) 


243
244
245
 
# File 'lib/playwright_api/locator_assertions.rb', line 243

def to_be_empty(timeout: nil)
  wrap_impl(@impl.to_be_empty(timeout: unwrap_impl(timeout)))
end

#to_be_enabled(enabled: nil, timeout: nil) ⇒ void

This method returns an undefined value.

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()

Parameters:

  • enabled: (Boolean) (defaults to: nil)
  • timeout: (Float) (defaults to: nil) 


258
259
260
 
# File 'lib/playwright_api/locator_assertions.rb', line 258

def to_be_enabled(enabled: nil, timeout: nil)
  wrap_impl(@impl.to_be_enabled(enabled: unwrap_impl(enabled), timeout: unwrap_impl(timeout)))
end

#to_be_focused(timeout: nil) ⇒ void

This method returns an undefined value.

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()

Parameters:

  • timeout: (Float) (defaults to: nil) 


273
274
275
 
# File 'lib/playwright_api/locator_assertions.rb', line 273

def to_be_focused(timeout: nil)
  wrap_impl(@impl.to_be_focused(timeout: unwrap_impl(timeout)))
end

#to_be_hidden(timeout: nil) ⇒ void

This method returns an undefined value.

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()

Parameters:

  • timeout: (Float) (defaults to: nil) 


288
289
290
 
# File 'lib/playwright_api/locator_assertions.rb', line 288

def to_be_hidden(timeout: nil)
  wrap_impl(@impl.to_be_hidden(timeout: unwrap_impl(timeout)))
end

#to_be_in_viewport(ratio: nil, timeout: nil) ⇒ void

This method returns an undefined value.

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")
# Make sure at least some part of element intersects viewport.
expect(locator).to_be_in_viewport()
# Make sure element is fully outside of viewport.
expect(locator).not_to_be_in_viewport()
# Make sure that at least half of the element intersects viewport.
expect(locator).to_be_in_viewport(ratio=0.5)

Parameters:

  • ratio: (Float) (defaults to: nil)
  • timeout: (Float) (defaults to: nil) 


308
309
310
 
# File 'lib/playwright_api/locator_assertions.rb', line 308

def to_be_in_viewport(ratio: nil, timeout: nil)
  wrap_impl(@impl.to_be_in_viewport(ratio: unwrap_impl(ratio), timeout: unwrap_impl(timeout)))
end

#to_be_visible(timeout: nil, visible: nil) ⇒ void

This method returns an undefined value.

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

To check that at least one element from the list is visible, use [method: Locator.first].

Usage

# A specific element is visible.
expect(page.get_by_text("Welcome")).to_be_visible()

# At least one item in the list is visible.
expect(page.get_by_test_id("todo-item").first).to_be_visible()

# At least one of the two elements is visible, possibly both.
expect(
    page.get_by_role("button", name="Sign in")
    .or_(page.get_by_role("button", name="Sign up"))
    .first
).to_be_visible()

Parameters:

  • timeout: (Float) (defaults to: nil)
  • visible: (Boolean) (defaults to: nil) 


333
334
335
 
# File 'lib/playwright_api/locator_assertions.rb', line 333

def to_be_visible(timeout: nil, visible: nil)
  wrap_impl(@impl.to_be_visible(timeout: unwrap_impl(timeout), visible: unwrap_impl(visible)))
end

#to_contain_class(expected, timeout: nil) ⇒ void

This method returns an undefined value.

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")

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"])

Parameters:

  • expected (String, Array[untyped])
  • timeout: (Float) (defaults to: nil) 


371
372
373
 
# File 'lib/playwright_api/locator_assertions.rb', line 371

def to_contain_class(expected, timeout: nil)
  wrap_impl(@impl.to_contain_class(unwrap_impl(expected), timeout: unwrap_impl(timeout)))
end

#to_contain_text(expected, ignoreCase: nil, timeout: nil, useInnerText: nil) ⇒ void

This method returns an undefined value.

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.

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.

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"))

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

# ✓ Contains the right items in the right order
expect(page.locator("ul > li")).to_contain_text(["Text 1", "Text 3"])

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

# ✖ No item contains this text
expect(page.locator("ul > li")).to_contain_text(["Some 33"])

# ✖ Locator points to the outer list element, not to the list items
expect(page.locator("ul")).to_contain_text(["Text 3"])

Parameters:

  • expected (String, Regexp, Array[untyped], Array[untyped], Array[untyped])
  • ignoreCase: (Boolean) (defaults to: nil)
  • timeout: (Float) (defaults to: nil)
  • useInnerText: (Boolean) (defaults to: nil) 


427
428
429
 
# File 'lib/playwright_api/locator_assertions.rb', line 427

def to_contain_text(expected, ignoreCase: nil, timeout: nil, useInnerText: nil)
  wrap_impl(@impl.to_contain_text(unwrap_impl(expected), ignoreCase: unwrap_impl(ignoreCase), timeout: unwrap_impl(timeout), useInnerText: unwrap_impl(useInnerText)))
end

#to_have_accessible_description(description, ignoreCase: nil, timeout: nil) ⇒ void

This method returns an undefined value.

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")

Parameters:

  • description (String, Regexp)
  • ignoreCase: (Boolean) (defaults to: nil)
  • timeout: (Float) (defaults to: nil) 


440
441
442
 
# File 'lib/playwright_api/locator_assertions.rb', line 440

def to_have_accessible_description(description, ignoreCase: nil, timeout: nil)
  wrap_impl(@impl.to_have_accessible_description(unwrap_impl(description), ignoreCase: unwrap_impl(ignoreCase), timeout: unwrap_impl(timeout)))
end

#to_have_accessible_error_message(errorMessage, ignoreCase: nil, timeout: nil) ⇒ void

This method returns an undefined value.

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.")

Parameters:

  • errorMessage (String, Regexp)
  • ignoreCase: (Boolean) (defaults to: nil)
  • timeout: (Float) (defaults to: nil) 


453
454
455
 
# File 'lib/playwright_api/locator_assertions.rb', line 453

def to_have_accessible_error_message(errorMessage, ignoreCase: nil, timeout: nil)
  wrap_impl(@impl.to_have_accessible_error_message(unwrap_impl(errorMessage), ignoreCase: unwrap_impl(ignoreCase), timeout: unwrap_impl(timeout)))
end

#to_have_accessible_name(name, ignoreCase: nil, timeout: nil) ⇒ void

This method returns an undefined value.

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")

Parameters:

  • name (String, Regexp)
  • ignoreCase: (Boolean) (defaults to: nil)
  • timeout: (Float) (defaults to: nil) 


466
467
468
 
# File 'lib/playwright_api/locator_assertions.rb', line 466

def to_have_accessible_name(name, ignoreCase: nil, timeout: nil)
  wrap_impl(@impl.to_have_accessible_name(unwrap_impl(name), ignoreCase: unwrap_impl(ignoreCase), timeout: unwrap_impl(timeout)))
end

#to_have_attribute(name, value, ignoreCase: nil, timeout: nil) ⇒ void

This method returns an undefined value.

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")

Parameters:

  • name (String)
  • value (String, Regexp)
  • ignoreCase: (Boolean) (defaults to: nil)
  • timeout: (Float) (defaults to: nil) 


481
482
483
 
# File 'lib/playwright_api/locator_assertions.rb', line 481

def to_have_attribute(name, value, ignoreCase: nil, timeout: nil)
  wrap_impl(@impl.to_have_attribute(unwrap_impl(name), unwrap_impl(value), ignoreCase: unwrap_impl(ignoreCase), timeout: unwrap_impl(timeout)))
end

#to_have_class(expected, timeout: nil) ⇒ void

This method returns an undefined value.

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 [method: LocatorAssertions.toContainClass].

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|$)"))

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"])

Parameters:

  • expected (String, Regexp, Array[untyped], Array[untyped], Array[untyped])
  • timeout: (Float) (defaults to: nil) 


510
511
512
 
# File 'lib/playwright_api/locator_assertions.rb', line 510

def to_have_class(expected, timeout: nil)
  wrap_impl(@impl.to_have_class(unwrap_impl(expected), timeout: unwrap_impl(timeout)))
end

#to_have_count(count, timeout: nil) ⇒ void

This method returns an undefined value.

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)

Parameters:

  • count (Integer)
  • timeout: (Float) (defaults to: nil) 


525
526
527
 
# File 'lib/playwright_api/locator_assertions.rb', line 525

def to_have_count(count, timeout: nil)
  wrap_impl(@impl.to_have_count(unwrap_impl(count), timeout: unwrap_impl(timeout)))
end

#to_have_css(name, value, pseudo: nil, timeout: nil) ⇒ void

This method returns an undefined value.

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")

Parameters:

  • name (String)
  • value (String, Regexp)
  • pseudo: ("before", "after") (defaults to: nil)
  • timeout: (Float) (defaults to: nil) 


540
541
542
 
# File 'lib/playwright_api/locator_assertions.rb', line 540

def to_have_css(name, value, pseudo: nil, timeout: nil)
  wrap_impl(@impl.to_have_css(unwrap_impl(name), unwrap_impl(value), pseudo: unwrap_impl(pseudo), timeout: unwrap_impl(timeout)))
end

#to_have_id(id, timeout: nil) ⇒ void

This method returns an undefined value.

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")

Parameters:

  • id (String, Regexp)
  • timeout: (Float) (defaults to: nil) 


555
556
557
 
# File 'lib/playwright_api/locator_assertions.rb', line 555

def to_have_id(id, timeout: nil)
  wrap_impl(@impl.to_have_id(unwrap_impl(id), timeout: unwrap_impl(timeout)))
end

#to_have_js_property(name, value, timeout: nil) ⇒ void

This method returns an undefined value.

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)

Parameters:

  • name (String)
  • value (Object)
  • timeout: (Float) (defaults to: nil) 


571
572
573
 
# File 'lib/playwright_api/locator_assertions.rb', line 571

def to_have_js_property(name, value, timeout: nil)
  wrap_impl(@impl.to_have_js_property(unwrap_impl(name), unwrap_impl(value), timeout: unwrap_impl(timeout)))
end

#to_have_role(role, timeout: nil) ⇒ void

This method returns an undefined value.

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")

Parameters:

  • role ("alert", "alertdialog", "application", "article", "banner", "blockquote", "button", "caption", "cell", "checkbox", "code", "columnheader", "combobox", "complementary", "contentinfo", "definition", "deletion", "dialog", "directory", "document", "emphasis", "feed", "figure", "form", "generic", "grid", "gridcell", "group", "heading", "img", "insertion", "link", "list", "listbox", "listitem", "log", "main", "marquee", "math", "meter", "menu", "menubar", "menuitem", "menuitemcheckbox", "menuitemradio", "navigation", "none", "note", "option", "paragraph", "presentation", "progressbar", "radio", "radiogroup", "region", "row", "rowgroup", "rowheader", "scrollbar", "search", "searchbox", "separator", "slider", "spinbutton", "status", "strong", "subscript", "superscript", "switch", "tab", "table", "tablist", "tabpanel", "term", "textbox", "time", "timer", "toolbar", "tooltip", "tree", "treegrid", "treeitem")
  • timeout: (Float) (defaults to: nil) 


586
587
588
 
# File 'lib/playwright_api/locator_assertions.rb', line 586

def to_have_role(role, timeout: nil)
  wrap_impl(@impl.to_have_role(unwrap_impl(role), timeout: unwrap_impl(timeout)))
end

#to_have_text(expected, ignoreCase: nil, timeout: nil, useInnerText: nil) ⇒ void

This method returns an undefined value.

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.

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.

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, .*"))

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

# ✓ Has the right items in the right order
expect(page.locator("ul > li")).to_have_text(["Text 1", "Text 2", "Text 3"])

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

# ✖ Last item does not match
expect(page.locator("ul > li")).to_have_text(["Text 1", "Text 2", "Text"])

# ✖ Locator points to the outer list element, not to the list items
expect(page.locator("ul")).to_have_text(["Text 1", "Text 2", "Text 3"])

Parameters:

  • expected (String, Regexp, Array[untyped], Array[untyped], Array[untyped])
  • ignoreCase: (Boolean) (defaults to: nil)
  • timeout: (Float) (defaults to: nil)
  • useInnerText: (Boolean) (defaults to: nil) 


641
642
643
 
# File 'lib/playwright_api/locator_assertions.rb', line 641

def to_have_text(expected, ignoreCase: nil, timeout: nil, useInnerText: nil)
  wrap_impl(@impl.to_have_text(unwrap_impl(expected), ignoreCase: unwrap_impl(ignoreCase), timeout: unwrap_impl(timeout), useInnerText: unwrap_impl(useInnerText)))
end

#to_have_value(value, timeout: nil) ⇒ void

This method returns an undefined 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]"))

Parameters:

  • value (String, Regexp)
  • timeout: (Float) (defaults to: nil) 


657
658
659
 
# File 'lib/playwright_api/locator_assertions.rb', line 657

def to_have_value(value, timeout: nil)
  wrap_impl(@impl.to_have_value(unwrap_impl(value), timeout: unwrap_impl(timeout)))
end

#to_have_values(values, timeout: nil) ⇒ void

This method returns an undefined value.

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")])

Parameters:

  • values (Array[untyped], Array[untyped], Array[untyped])
  • timeout: (Float) (defaults to: nil) 


684
685
686
 
# File 'lib/playwright_api/locator_assertions.rb', line 684

def to_have_values(values, timeout: nil)
  wrap_impl(@impl.to_have_values(unwrap_impl(values), timeout: unwrap_impl(timeout)))
end

#to_match_aria_snapshot(expected, timeout: nil) ⇒ void

This method returns an undefined value.

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?"
''')

Parameters:

  • expected (String)
  • timeout: (Float) (defaults to: nil) 


700
701
702
 
# File 'lib/playwright_api/locator_assertions.rb', line 700

def to_match_aria_snapshot(expected, timeout: nil)
  wrap_impl(@impl.to_match_aria_snapshot(unwrap_impl(expected), timeout: unwrap_impl(timeout)))
end