playwright-ruby-client 1.37.1 → 1.38.1

data/lib/playwright_api/locator_assertions.rb

@@ -0,0 +1,538 @@
+module Playwright
+  #
+  # 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")
+  # ```
+  class LocatorAssertions < PlaywrightApi
+
+    #
+    # The opposite of [`method: LocatorAssertions.toBeAttached`].
+    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
+
+    #
+    # The opposite of [`method: LocatorAssertions.toBeChecked`].
+    def not_to_be_checked(timeout: nil)
+      wrap_impl(@impl.not_to_be_checked(timeout: unwrap_impl(timeout)))
+    end
+
+    #
+    # The opposite of [`method: LocatorAssertions.toBeDisabled`].
+    def not_to_be_disabled(timeout: nil)
+      wrap_impl(@impl.not_to_be_disabled(timeout: unwrap_impl(timeout)))
+    end
+
+    #
+    # The opposite of [`method: LocatorAssertions.toBeEditable`].
+    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
+
+    #
+    # The opposite of [`method: LocatorAssertions.toBeEmpty`].
+    def not_to_be_empty(timeout: nil)
+      wrap_impl(@impl.not_to_be_empty(timeout: unwrap_impl(timeout)))
+    end
+
+    #
+    # The opposite of [`method: LocatorAssertions.toBeEnabled`].
+    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
+
+    #
+    # The opposite of [`method: LocatorAssertions.toBeFocused`].
+    def not_to_be_focused(timeout: nil)
+      wrap_impl(@impl.not_to_be_focused(timeout: unwrap_impl(timeout)))
+    end
+
+    #
+    # The opposite of [`method: LocatorAssertions.toBeHidden`].
+    def not_to_be_hidden(timeout: nil)
+      wrap_impl(@impl.not_to_be_hidden(timeout: unwrap_impl(timeout)))
+    end
+
+    #
+    # The opposite of [`method: LocatorAssertions.toBeInViewport`].
+    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
+
+    #
+    # The opposite of [`method: LocatorAssertions.toBeVisible`].
+    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
+
+    #
+    # The opposite of [`method: LocatorAssertions.toContainText`].
+    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
+
+    #
+    # The opposite of [`method: LocatorAssertions.toHaveAttribute`].
+    def not_to_have_attribute(name, value, timeout: nil)
+      wrap_impl(@impl.not_to_have_attribute(unwrap_impl(name), unwrap_impl(value), timeout: unwrap_impl(timeout)))
+    end
+
+    #
+    # The opposite of [`method: LocatorAssertions.toHaveClass`].
+    def not_to_have_class(expected, timeout: nil)
+      wrap_impl(@impl.not_to_have_class(unwrap_impl(expected), timeout: unwrap_impl(timeout)))
+    end
+
+    #
+    # The opposite of [`method: LocatorAssertions.toHaveCount`].
+    def not_to_have_count(count, timeout: nil)
+      wrap_impl(@impl.not_to_have_count(unwrap_impl(count), timeout: unwrap_impl(timeout)))
+    end
+
+    #
+    # The opposite of [`method: LocatorAssertions.toHaveCSS`].
+    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
+
+    #
+    # The opposite of [`method: LocatorAssertions.toHaveId`].
+    def not_to_have_id(id, timeout: nil)
+      wrap_impl(@impl.not_to_have_id(unwrap_impl(id), timeout: unwrap_impl(timeout)))
+    end
+
+    #
+    # The opposite of [`method: LocatorAssertions.toHaveJSProperty`].
+    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
+
+    #
+    # The opposite of [`method: LocatorAssertions.toHaveText`].
+    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
+
+    #
+    # The opposite of [`method: LocatorAssertions.toHaveValue`].
+    def not_to_have_value(value, timeout: nil)
+      wrap_impl(@impl.not_to_have_value(unwrap_impl(value), timeout: unwrap_impl(timeout)))
+    end
+
+    #
+    # The opposite of [`method: LocatorAssertions.toHaveValues`].
+    def not_to_have_values(values, timeout: nil)
+      wrap_impl(@impl.not_to_have_values(unwrap_impl(values), timeout: unwrap_impl(timeout)))
+    end
+
+    #
+    # Ensures that `Locator` points to an [attached](../actionability.md#attached) DOM node.
+    #
+    # **Usage**
+    #
+    # ```python sync
+    # expect(page.get_by_text("Hidden text")).to_be_attached()
+    # ```
+    def to_be_attached(attached: nil, timeout: nil)
+      wrap_impl(@impl.to_be_attached(attached: unwrap_impl(attached), timeout: unwrap_impl(timeout)))
+    end
+
+    #
+    # 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()
+    # ```
+    def to_be_checked(checked: nil, timeout: nil)
+      wrap_impl(@impl.to_be_checked(checked: unwrap_impl(checked), timeout: unwrap_impl(timeout)))
+    end
+
+    #
+    # Ensures the `Locator` points to a disabled element. Element is disabled if it has "disabled" attribute
+    # or is disabled via ['aria-disabled'](https://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()
+    # ```
+    def to_be_disabled(timeout: nil)
+      wrap_impl(@impl.to_be_disabled(timeout: unwrap_impl(timeout)))
+    end
+
+    #
+    # 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()
+    # ```
+    def to_be_editable(editable: nil, timeout: nil)
+      wrap_impl(@impl.to_be_editable(editable: unwrap_impl(editable), timeout: unwrap_impl(timeout)))
+    end
+
+    #
+    # 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()
+    # ```
+    def to_be_empty(timeout: nil)
+      wrap_impl(@impl.to_be_empty(timeout: unwrap_impl(timeout)))
+    end
+
+    #
+    # 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()
+    # ```
+    def to_be_enabled(enabled: nil, timeout: nil)
+      wrap_impl(@impl.to_be_enabled(enabled: unwrap_impl(enabled), timeout: unwrap_impl(timeout)))
+    end
+
+    #
+    # 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()
+    # ```
+    def to_be_focused(timeout: nil)
+      wrap_impl(@impl.to_be_focused(timeout: unwrap_impl(timeout)))
+    end
+
+    #
+    # 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()
+    # ```
+    def to_be_hidden(timeout: nil)
+      wrap_impl(@impl.to_be_hidden(timeout: unwrap_impl(timeout)))
+    end
+
+    #
+    # Ensures the `Locator` points to an element that intersects viewport, according to the [intersection observer API](https://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)
+    # ```
+    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
+
+    #
+    # Ensures that `Locator` points to an [attached](../actionability.md#attached) and [visible](../actionability.md#visible) DOM node.
+    #
+    # **Usage**
+    #
+    # ```python sync
+    # expect(page.get_by_text("Welcome")).to_be_visible()
+    # ```
+    def to_be_visible(timeout: nil, visible: nil)
+      wrap_impl(@impl.to_be_visible(timeout: unwrap_impl(timeout), visible: unwrap_impl(visible)))
+    end
+
+    #
+    # Ensures the `Locator` points to an element that contains the given text. You can use regular expressions for the value as well.
+    #
+    # **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.
+    # 1. Elements from a **subset** of this list contain text from the expected array, respectively.
+    # 1. The matching subset of elements has the same order as the expected array.
+    # 1. 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"])
+    # ```
+    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
+
+    #
+    # 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")
+    # ```
+    def to_have_attribute(name, value, timeout: nil)
+      wrap_impl(@impl.to_have_attribute(unwrap_impl(name), unwrap_impl(value), timeout: unwrap_impl(timeout)))
+    end
+
+    #
+    # 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"])
+    # ```
+    def to_have_class(expected, timeout: nil)
+      wrap_impl(@impl.to_have_class(unwrap_impl(expected), timeout: unwrap_impl(timeout)))
+    end
+
+    #
+    # 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)
+    # ```
+    def to_have_count(count, timeout: nil)
+      wrap_impl(@impl.to_have_count(unwrap_impl(count), timeout: unwrap_impl(timeout)))
+    end
+
+    #
+    # 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")
+    # ```
+    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
+
+    #
+    # 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")
+    # ```
+    def to_have_id(id, timeout: nil)
+      wrap_impl(@impl.to_have_id(unwrap_impl(id), timeout: unwrap_impl(timeout)))
+    end
+
+    #
+    # 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)
+    # ```
+    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
+
+    #
+    # Ensures the `Locator` points to an element with the given text. You can use regular expressions for the value as well.
+    #
+    # **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.
+    # 1. The number of elements equals the number of expected values in the array.
+    # 1. 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"])
+    # ```
+    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
+
+    #
+    # 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[type=number]")
+    # expect(locator).to_have_value(re.compile(r"[0-9]"))
+    # ```
+    def to_have_value(value, timeout: nil)
+      wrap_impl(@impl.to_have_value(unwrap_impl(value), timeout: unwrap_impl(timeout)))
+    end
+
+    #
+    # 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")])
+    # ```
+    def to_have_values(values, timeout: nil)
+      wrap_impl(@impl.to_have_values(unwrap_impl(values), timeout: unwrap_impl(timeout)))
+    end
+  end
+end

data/lib/playwright_api/page.rb

@@ -532,7 +532,7 @@ module Playwright
     #
     # If the target element is not an `<input>`, `<textarea>` or `[contenteditable]` element, this method throws an error. However, if the element is inside the `<label>` element that has an associated [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be filled instead.
     #
-    # To send fine-grained keyboard events, use [`method: Page.type`].
+    # To send fine-grained keyboard events, use [`method: Locator.pressSequentially`].
     def fill(
           selector,
           value,
@@ -1340,11 +1340,6 @@ module Playwright
     # To press a special key, like `Control` or `ArrowDown`, use [`method: Keyboard.press`].
     #
     # **Usage**
-    #
-    # ```python sync
-    # page.type("#mytextarea", "hello") # types instantly
-    # page.type("#mytextarea", "world", delay=100) # types slower, like a user
-    # ```
     def type(
           selector,
           text,

data/lib/playwright_api/request.rb

@@ -37,6 +37,20 @@ module Playwright
 
     #
     # Returns the `Frame` that initiated this request.
+    #
+    # **Usage**
+    #
+    # ```py
+    # frame_url = request.frame.url
+    # ```
+    #
+    # **Details**
+    #
+    # Note that in some cases the frame is not available, and this method will throw.
+    # - When request originates in the Service Worker. You can use `request.serviceWorker()` to check that.
+    # - When navigation request is issued before the corresponding frame is created. You can use [`method: Request.isNavigationRequest`] to check that.
+    #
+    # Here is an example that handles all the cases:
     def frame
       wrap_impl(@impl.frame)
     end
@@ -64,6 +78,9 @@ module Playwright
 
     #
     # Whether this request is driving frame's navigation.
+    #
+    # Some navigation requests are issued before the corresponding frame is created, and therefore
+    # do not have [`method: Request.frame`] available.
     def navigation_request?
       wrap_impl(@impl.navigation_request?)
     end

data/lib/playwright_api/worker.rb

@@ -47,13 +47,13 @@ module Playwright
     end
 
     # @nodoc
-    def page=(req)
-      wrap_impl(@impl.page=(unwrap_impl(req)))
+    def context=(req)
+      wrap_impl(@impl.context=(unwrap_impl(req)))
     end
 
     # @nodoc
-    def context=(req)
-      wrap_impl(@impl.context=(unwrap_impl(req)))
+    def page=(req)
+      wrap_impl(@impl.page=(unwrap_impl(req)))
     end
 
     # -- inherited from EventEmitter --

data/sig/playwright.rbs

@@ -483,6 +483,7 @@ module Playwright
     def or: (Locator locator) -> Locator
     def page: -> Page
     def press: (String key, ?delay: Float, ?noWaitAfter: bool, ?timeout: Float) -> void
+    def press_sequentially: (String text, ?delay: Float, ?noWaitAfter: bool, ?timeout: Float) -> void
     def screenshot: (?animations: ("disabled" | "allow"), ?caret: ("hide" | "initial"), ?mask: Array[untyped], ?maskColor: String, ?omitBackground: bool, ?path: (String | File), ?quality: Integer, ?scale: ("css" | "device"), ?timeout: Float, ?type: ("png" | "jpeg")) -> String
     def scroll_into_view_if_needed: (?timeout: Float) -> void
     def select_option: (?element: (ElementHandle | Array[untyped]), ?index: (Integer | Array[untyped]), ?value: (String | Array[untyped]), ?label: (String | Array[untyped]), ?force: bool, ?noWaitAfter: bool, ?timeout: Float) -> Array[untyped]
@@ -537,6 +538,49 @@ module Playwright
     def put: (String url, ?data: (String | String | untyped), ?failOnStatusCode: bool, ?form: Hash[untyped, untyped], ?headers: Hash[untyped, untyped], ?ignoreHTTPSErrors: bool, ?maxRedirects: Integer, ?multipart: Hash[untyped, untyped], ?params: Hash[untyped, untyped], ?timeout: Float) -> APIResponse
   end
 
+  class LocatorAssertions
+    def not_to_be_attached: (?attached: bool, ?timeout: Float) -> void
+    def not_to_be_checked: (?timeout: Float) -> void
+    def not_to_be_disabled: (?timeout: Float) -> void
+    def not_to_be_editable: (?editable: bool, ?timeout: Float) -> void
+    def not_to_be_empty: (?timeout: Float) -> void
+    def not_to_be_enabled: (?enabled: bool, ?timeout: Float) -> void
+    def not_to_be_focused: (?timeout: Float) -> void
+    def not_to_be_hidden: (?timeout: Float) -> void
+    def not_to_be_in_viewport: (?ratio: Float, ?timeout: Float) -> void
+    def not_to_be_visible: (?timeout: Float, ?visible: bool) -> void
+    def not_to_contain_text: ((String | Regexp | Array[untyped] | Array[untyped] | Array[untyped]) expected, ?ignoreCase: bool, ?timeout: Float, ?useInnerText: bool) -> void
+    def not_to_have_attribute: (String name, (String | Regexp) value, ?timeout: Float) -> void
+    def not_to_have_class: ((String | Regexp | Array[untyped] | Array[untyped] | Array[untyped]) expected, ?timeout: Float) -> void
+    def not_to_have_count: (Integer count, ?timeout: Float) -> void
+    def not_to_have_css: (String name, (String | Regexp) value, ?timeout: Float) -> void
+    def not_to_have_id: ((String | Regexp) id, ?timeout: Float) -> void
+    def not_to_have_js_property: (String name, untyped value, ?timeout: Float) -> void
+    def not_to_have_text: ((String | Regexp | Array[untyped] | Array[untyped] | Array[untyped]) expected, ?ignoreCase: bool, ?timeout: Float, ?useInnerText: bool) -> void
+    def not_to_have_value: ((String | Regexp) value, ?timeout: Float) -> void
+    def not_to_have_values: ((Array[untyped] | Array[untyped] | Array[untyped]) values, ?timeout: Float) -> void
+    def to_be_attached: (?attached: bool, ?timeout: Float) -> void
+    def to_be_checked: (?checked: bool, ?timeout: Float) -> void
+    def to_be_disabled: (?timeout: Float) -> void
+    def to_be_editable: (?editable: bool, ?timeout: Float) -> void
+    def to_be_empty: (?timeout: Float) -> void
+    def to_be_enabled: (?enabled: bool, ?timeout: Float) -> void
+    def to_be_focused: (?timeout: Float) -> void
+    def to_be_hidden: (?timeout: Float) -> void
+    def to_be_in_viewport: (?ratio: Float, ?timeout: Float) -> void
+    def to_be_visible: (?timeout: Float, ?visible: bool) -> void
+    def to_contain_text: ((String | Regexp | Array[untyped] | Array[untyped] | Array[untyped]) expected, ?ignoreCase: bool, ?timeout: Float, ?useInnerText: bool) -> void
+    def to_have_attribute: (String name, (String | Regexp) value, ?timeout: Float) -> void
+    def to_have_class: ((String | Regexp | Array[untyped] | Array[untyped] | Array[untyped]) expected, ?timeout: Float) -> void
+    def to_have_count: (Integer count, ?timeout: Float) -> void
+    def to_have_css: (String name, (String | Regexp) value, ?timeout: Float) -> void
+    def to_have_id: ((String | Regexp) id, ?timeout: Float) -> void
+    def to_have_js_property: (String name, untyped value, ?timeout: Float) -> void
+    def to_have_text: ((String | Regexp | Array[untyped] | Array[untyped] | Array[untyped]) expected, ?ignoreCase: bool, ?timeout: Float, ?useInnerText: bool) -> void
+    def to_have_value: ((String | Regexp) value, ?timeout: Float) -> void
+    def to_have_values: ((Array[untyped] | Array[untyped] | Array[untyped]) values, ?timeout: Float) -> void
+  end
+
   class Android
     def devices: (?host: String, ?omitDriverInstall: bool, ?port: Integer) -> Array[untyped]
   end