playwright-ruby-client 1.39.0 → 1.40.0

data/lib/playwright_api/locator_assertions.rb

@@ -0,0 +1,561 @@
+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.
+    #
+    # 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()
+    # ```
+    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.
+    #
+    # **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.
+    # 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, 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
+
+    #
+    # 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.
+    #
+    # **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.
+    # 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

@@ -166,8 +166,8 @@ module Playwright
     #
     # **NOTE**: if `runBeforeUnload` is passed as true, a `beforeunload` dialog might be summoned and should be handled
     # manually via [`event: Page.dialog`] event.
-    def close(runBeforeUnload: nil)
-      wrap_impl(@impl.close(runBeforeUnload: unwrap_impl(runBeforeUnload)))
+    def close(reason: nil, runBeforeUnload: nil)
+      wrap_impl(@impl.close(reason: unwrap_impl(reason), runBeforeUnload: unwrap_impl(runBeforeUnload)))
     end
 
     #
@@ -225,13 +225,16 @@ module Playwright
     #
     # Since `eventInit` is event-specific, please refer to the events documentation for the lists of initial
     # properties:
+    # - [DeviceMotionEvent](https://developer.mozilla.org/en-US/docs/Web/API/DeviceMotionEvent/DeviceMotionEvent)
+    # - [DeviceOrientationEvent](https://developer.mozilla.org/en-US/docs/Web/API/DeviceOrientationEvent/DeviceOrientationEvent)
     # - [DragEvent](https://developer.mozilla.org/en-US/docs/Web/API/DragEvent/DragEvent)
+    # - [Event](https://developer.mozilla.org/en-US/docs/Web/API/Event/Event)
     # - [FocusEvent](https://developer.mozilla.org/en-US/docs/Web/API/FocusEvent/FocusEvent)
     # - [KeyboardEvent](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/KeyboardEvent)
     # - [MouseEvent](https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/MouseEvent)
     # - [PointerEvent](https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/PointerEvent)
     # - [TouchEvent](https://developer.mozilla.org/en-US/docs/Web/API/TouchEvent/TouchEvent)
-    # - [Event](https://developer.mozilla.org/en-US/docs/Web/API/Event/Event)
+    # - [WheelEvent](https://developer.mozilla.org/en-US/docs/Web/API/WheelEvent/WheelEvent)
     #
     # You can also specify `JSHandle` as the property value if you want live objects to be passed into the event:
     #
@@ -442,7 +445,7 @@ module Playwright
     #
     # def run(playwright: Playwright):
     #     webkit = playwright.webkit
-    #     browser = webkit.launch(headless=false)
+    #     browser = webkit.launch(headless=False)
     #     context = browser.new_context()
     #     page = context.new_page()
     #     page.expose_binding("pageURL", lambda source: source["page"].url)
@@ -1671,13 +1674,13 @@ module Playwright
     end
 
     # @nodoc
-    def stop_css_coverage
-      wrap_impl(@impl.stop_css_coverage)
+    def stop_js_coverage
+      wrap_impl(@impl.stop_js_coverage)
     end
 
     # @nodoc
-    def stop_js_coverage
-      wrap_impl(@impl.stop_js_coverage)
+    def start_js_coverage(resetOnNavigation: nil, reportAnonymousScripts: nil)
+      wrap_impl(@impl.start_js_coverage(resetOnNavigation: unwrap_impl(resetOnNavigation), reportAnonymousScripts: unwrap_impl(reportAnonymousScripts)))
     end
 
     # @nodoc
@@ -1685,6 +1688,11 @@ module Playwright
       wrap_impl(@impl.start_css_coverage(resetOnNavigation: unwrap_impl(resetOnNavigation), reportAnonymousScripts: unwrap_impl(reportAnonymousScripts)))
     end
 
+    # @nodoc
+    def stop_css_coverage
+      wrap_impl(@impl.stop_css_coverage)
+    end
+
     # @nodoc
     def owned_context=(req)
       wrap_impl(@impl.owned_context=(unwrap_impl(req)))
@@ -1695,11 +1703,6 @@ module Playwright
       wrap_impl(@impl.guid)
     end
 
-    # @nodoc
-    def start_js_coverage(resetOnNavigation: nil, reportAnonymousScripts: nil)
-      wrap_impl(@impl.start_js_coverage(resetOnNavigation: unwrap_impl(resetOnNavigation), reportAnonymousScripts: unwrap_impl(reportAnonymousScripts)))
-    end
-
     # -- inherited from EventEmitter --
     # @nodoc
     def off(event, callback)

data/lib/playwright_api/request.rb

@@ -196,13 +196,13 @@ module Playwright
     end
 
     # @nodoc
-    def apply_fallback_overrides(overrides)
-      wrap_impl(@impl.apply_fallback_overrides(unwrap_impl(overrides)))
+    def header_values(name)
+      wrap_impl(@impl.header_values(unwrap_impl(name)))
     end
 
     # @nodoc
-    def header_values(name)
-      wrap_impl(@impl.header_values(unwrap_impl(name)))
+    def apply_fallback_overrides(overrides)
+      wrap_impl(@impl.apply_fallback_overrides(unwrap_impl(overrides)))
     end
 
     # -- inherited from EventEmitter --

data/lib/playwright_api/worker.rb

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