Class: Playwright::LocatorAssertions

Inherits:
PlaywrightApi show all
Defined in:
lib/playwright_api/locator_assertions.rb

Overview

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

“‘python sync 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) ⇒ Object

The opposite of [‘method: LocatorAssertions.toBeAttached`].



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) ⇒ Object

The opposite of [‘method: LocatorAssertions.toBeChecked`].



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) ⇒ Object

The opposite of [‘method: LocatorAssertions.toBeDisabled`].



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) ⇒ Object

The opposite of [‘method: LocatorAssertions.toBeEditable`].



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) ⇒ Object

The opposite of [‘method: LocatorAssertions.toBeEmpty`].



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) ⇒ Object

The opposite of [‘method: LocatorAssertions.toBeEnabled`].



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) ⇒ Object

The opposite of [‘method: LocatorAssertions.toBeFocused`].



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) ⇒ Object

The opposite of [‘method: LocatorAssertions.toBeHidden`].



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) ⇒ Object

The opposite of [‘method: LocatorAssertions.toBeInViewport`].



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) ⇒ Object

The opposite of [‘method: LocatorAssertions.toBeVisible`].



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_text(expected, ignoreCase: nil, timeout: nil, useInnerText: nil) ⇒ Object

The opposite of [‘method: LocatorAssertions.toContainText`].



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

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) ⇒ Object

The opposite of [‘method: LocatorAssertions.toHaveAccessibleDescription`].



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

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_name(name, ignoreCase: nil, timeout: nil) ⇒ Object

The opposite of [‘method: LocatorAssertions.toHaveAccessibleName`].



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

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) ⇒ Object

The opposite of [‘method: LocatorAssertions.toHaveAttribute`].



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

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) ⇒ Object

The opposite of [‘method: LocatorAssertions.toHaveClass`].



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

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) ⇒ Object

The opposite of [‘method: LocatorAssertions.toHaveCount`].



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

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) ⇒ Object

The opposite of [‘method: LocatorAssertions.toHaveCSS`].



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

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) ⇒ Object

The opposite of [‘method: LocatorAssertions.toHaveId`].



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

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) ⇒ Object

The opposite of [‘method: LocatorAssertions.toHaveJSProperty`].



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

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) ⇒ Object

The opposite of [‘method: LocatorAssertions.toHaveRole`].



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

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) ⇒ Object

The opposite of [‘method: LocatorAssertions.toHaveText`].



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

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) ⇒ Object

The opposite of [‘method: LocatorAssertions.toHaveValue`].



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

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) ⇒ Object

The opposite of [‘method: LocatorAssertions.toHaveValues`].



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

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

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

Ensures that ‘Locator` points to an element that is [connected](developer.mozilla.org/en-US/docs/Web/API/Node/isConnected) to a Document or a ShadowRoot.

Usage

“‘python sync expect(page.get_by_text(“Hidden text”)).to_be_attached() “`



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

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, timeout: nil) ⇒ Object

Ensures the ‘Locator` points to a checked input.

Usage

“‘python sync from playwright.sync_api import expect

locator = page.get_by_label(“Subscribe to newsletter”) expect(locator).to_be_checked() “‘



176
177
178
 
# File 'lib/playwright_api/locator_assertions.rb', line 176

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

#to_be_disabled(timeout: nil) ⇒ Object

Ensures the ‘Locator` points to a disabled element. Element is disabled if it has “disabled” attribute or is disabled via [’aria-disabled’](developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/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

“‘python sync from playwright.sync_api import expect

locator = page.locator(“button.submit”) expect(locator).to_be_disabled() “‘



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

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

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

Ensures the ‘Locator` points to an editable element.

Usage

“‘python sync from playwright.sync_api import expect

locator = page.get_by_role(“textbox”) expect(locator).to_be_editable() “‘



210
211
212
 
# File 'lib/playwright_api/locator_assertions.rb', line 210

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) ⇒ Object

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

Usage

“‘python sync from playwright.sync_api import expect

locator = page.locator(“div.warning”) expect(locator).to_be_empty() “‘



225
226
227
 
# File 'lib/playwright_api/locator_assertions.rb', line 225

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

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

Ensures the ‘Locator` points to an enabled element.

Usage

“‘python sync from playwright.sync_api import expect

locator = page.locator(“button.submit”) expect(locator).to_be_enabled() “‘



240
241
242
 
# File 'lib/playwright_api/locator_assertions.rb', line 240

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) ⇒ Object

Ensures the ‘Locator` points to a focused DOM node.

Usage

“‘python sync from playwright.sync_api import expect

locator = page.get_by_role(“textbox”) expect(locator).to_be_focused() “‘



255
256
257
 
# File 'lib/playwright_api/locator_assertions.rb', line 255

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

#to_be_hidden(timeout: nil) ⇒ Object

Ensures that ‘Locator` either does not resolve to any DOM node, or resolves to a [non-visible](../actionability.md#visible) one.

Usage

“‘python sync from playwright.sync_api import expect

locator = page.locator(‘.my-element’) expect(locator).to_be_hidden() “‘



270
271
272
 
# File 'lib/playwright_api/locator_assertions.rb', line 270

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) ⇒ Object

Ensures the ‘Locator` points to an element that intersects viewport, according to the [intersection observer API](developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API).

Usage

“‘python sync 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) “‘



290
291
292
 
# File 'lib/playwright_api/locator_assertions.rb', line 290

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) ⇒ Object

Ensures that ‘Locator` points to an attached and [visible](../actionability.md#visible) DOM node.

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

Usage

“‘python sync # 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() “‘



315
316
317
 
# File 'lib/playwright_api/locator_assertions.rb', line 315

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_text(expected, ignoreCase: nil, timeout: nil, useInnerText: nil) ⇒ Object

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

“‘python sync 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:

“‘html <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:

“‘python sync 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”, “Text 4”])

# ✖ 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”]) “‘



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

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) ⇒ Object

Ensures the ‘Locator` points to an element with a given [accessible description](w3c.github.io/accname/#dfn-accessible-description).

Usage

“‘python sync locator = page.get_by_test_id(“save-button”) expect(locator).to_have_accessible_description(“Save results to disk”) “`



384
385
386
 
# File 'lib/playwright_api/locator_assertions.rb', line 384

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_name(name, ignoreCase: nil, timeout: nil) ⇒ Object

Ensures the ‘Locator` points to an element with a given [accessible name](w3c.github.io/accname/#dfn-accessible-name).

Usage

“‘python sync locator = page.get_by_test_id(“save-button”) expect(locator).to_have_accessible_name(“Save to disk”) “`



397
398
399
 
# File 'lib/playwright_api/locator_assertions.rb', line 397

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) ⇒ Object

Ensures the ‘Locator` points to an element with given attribute.

Usage

“‘python sync from playwright.sync_api import expect

locator = page.locator(“input”) expect(locator).to_have_attribute(“type”, “text”) “‘



412
413
414
 
# File 'lib/playwright_api/locator_assertions.rb', line 412

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) ⇒ Object

Ensures the ‘Locator` points to an element with given CSS classes. This needs to be a full match or using a relaxed regular expression.

Usage

“‘html <div class=’selected row’ id=‘component’></div> “‘

“‘python sync from playwright.sync_api import expect

locator = page.locator(“#component”) expect(locator).to_have_class(re.compile(r“selected”)) expect(locator).to_have_class(“selected row”) “‘

Note that if array is passed as an expected value, entire lists of elements can be asserted:

“‘python sync from playwright.sync_api import expect

locator = page.locator(“list > .component”) expect(locator).to_have_class([“component”, “component selected”, “component”]) “‘



442
443
444
 
# File 'lib/playwright_api/locator_assertions.rb', line 442

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) ⇒ Object

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

Usage

“‘python sync from playwright.sync_api import expect

locator = page.locator(“list > .component”) expect(locator).to_have_count(3) “‘



457
458
459
 
# File 'lib/playwright_api/locator_assertions.rb', line 457

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, timeout: nil) ⇒ Object

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

Usage

“‘python sync from playwright.sync_api import expect

locator = page.get_by_role(“button”) expect(locator).to_have_css(“display”, “flex”) “‘



472
473
474
 
# File 'lib/playwright_api/locator_assertions.rb', line 472

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

#to_have_id(id, timeout: nil) ⇒ Object

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

Usage

“‘python sync from playwright.sync_api import expect

locator = page.get_by_role(“textbox”) expect(locator).to_have_id(“lastname”) “‘



487
488
489
 
# File 'lib/playwright_api/locator_assertions.rb', line 487

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) ⇒ Object

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

“‘python sync from playwright.sync_api import expect

locator = page.locator(“.component”) expect(locator).to_have_js_property(“loaded”, True) “‘



503
504
505
 
# File 'lib/playwright_api/locator_assertions.rb', line 503

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) ⇒ Object

Ensures the ‘Locator` points to an element with a given [ARIA role](www.w3.org/TR/wai-aria-1.2/#roles).

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

“‘python sync locator = page.get_by_test_id(“save-button”) expect(locator).to_have_role(“button”) “`



518
519
520
 
# File 'lib/playwright_api/locator_assertions.rb', line 518

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) ⇒ Object

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

“‘python sync 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:

“‘html <ul>

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

</ul> “‘

Let’s see how we can use the assertion:

“‘python sync 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”]) “‘



573
574
575
 
# File 'lib/playwright_api/locator_assertions.rb', line 573

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) ⇒ Object

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

Usage

“‘python sync import re from playwright.sync_api import expect

locator = page.locator(“input”) expect(locator).to_have_value(re.compile(r“”)) “‘



589
590
591
 
# File 'lib/playwright_api/locator_assertions.rb', line 589

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) ⇒ Object

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:

“‘html <select id=“favorite-colors” multiple>

<option value="R">Red</option>
<option value="G">Green</option>
<option value="B">Blue</option>

</select> “‘

“‘python sync 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”)]) “‘



616
617
618
 
# File 'lib/playwright_api/locator_assertions.rb', line 616

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