playwright-ruby-client 1.28.1 → 1.29.0

data/lib/playwright_api/playwright.rb

@@ -1,4 +1,5 @@
 module Playwright
+  #
   # Playwright module provides a method to launch a browser instance. The following is a typical example of using Playwright
   # to drive automation:
   #
@@ -18,11 +19,13 @@ module Playwright
   # ```
   class Playwright < PlaywrightApi
 
+    #
     # This object can be used to launch or connect to Chromium, returning instances of `Browser`.
     def chromium # property
       wrap_impl(@impl.chromium)
     end
 
+    #
     # Returns a dictionary of devices to be used with [`method: Browser.newContext`] or [`method: Browser.newPage`].
     #
     # ```python sync
@@ -45,29 +48,33 @@ module Playwright
       wrap_impl(@impl.devices)
     end
 
+    #
     # This object can be used to launch or connect to Firefox, returning instances of `Browser`.
     def firefox # property
       wrap_impl(@impl.firefox)
     end
 
+    #
     # Exposes API that can be used for the Web API testing.
     def request # property
       raise NotImplementedError.new('request is not implemented yet.')
     end
 
-    # Selectors can be used to install custom selector engines. See [Working with selectors](../selectors.md) for more
-    # information.
+    #
+    # Selectors can be used to install custom selector engines. See
+    # [extensibility](../extensibility.md) for more information.
     def selectors # property
       wrap_impl(@impl.selectors)
     end
 
+    #
     # This object can be used to launch or connect to WebKit, returning instances of `Browser`.
     def webkit # property
       wrap_impl(@impl.webkit)
     end
 
-    # Terminates this instance of Playwright in case it was created bypassing the Python context manager. This is useful in
-    # REPL applications.
+    #
+    # Terminates this instance of Playwright in case it was created bypassing the Python context manager. This is useful in REPL applications.
     #
     # ```py
     # >>> from playwright.sync_api import sync_playwright

data/lib/playwright_api/request.rb

@@ -1,4 +1,5 @@
 module Playwright
+  #
   # Whenever the page sends a request for a network resource the following sequence of events are emitted by `Page`:
   # - [`event: Page.request`] emitted when the request is issued by the page.
   # - [`event: Page.response`] emitted when/if the response status and headers are received for the request.
@@ -7,20 +8,24 @@ module Playwright
   # If request fails at some point, then instead of `'requestfinished'` event (and possibly instead of 'response' event),
   # the  [`event: Page.requestFailed`] event is emitted.
   #
-  # > NOTE: HTTP Error responses, such as 404 or 503, are still successful responses from HTTP standpoint, so request will
-  # complete with `'requestfinished'` event.
+  # **NOTE**: HTTP Error responses, such as 404 or 503, are still successful responses from HTTP standpoint, so request will complete
+  # with `'requestfinished'` event.
   #
   # If request gets a 'redirect' response, the request is successfully finished with the `requestfinished` event, and a new
   # request is  issued to a redirected url.
   class Request < PlaywrightApi
 
+    #
     # An object with all the request HTTP headers associated with this request. The header names are lower-cased.
     def all_headers
       wrap_impl(@impl.all_headers)
     end
 
+    #
     # The method returns `null` unless this request has failed, as reported by `requestfailed` event.
     #
+    # **Usage**
+    #
     # Example of logging of all the failed requests:
     #
     # ```py
@@ -30,49 +35,58 @@ module Playwright
       wrap_impl(@impl.failure)
     end
 
+    #
     # Returns the `Frame` that initiated this request.
     def frame
       wrap_impl(@impl.frame)
     end
 
-    # An object with the request HTTP headers. The header names are lower-cased. Note that this method does not return
-    # security-related headers, including cookie-related ones. You can use [`method: Request.allHeaders`] for complete list of
-    # headers that include `cookie` information.
+    #
+    # An object with the request HTTP headers. The header names are lower-cased.
+    # Note that this method does not return security-related headers, including cookie-related ones.
+    # You can use [`method: Request.allHeaders`] for complete list of headers that include `cookie` information.
     def headers
       wrap_impl(@impl.headers)
     end
 
-    # An array with all the request HTTP headers associated with this request. Unlike [`method: Request.allHeaders`], header
-    # names are NOT lower-cased. Headers with multiple entries, such as `Set-Cookie`, appear in the array multiple times.
+    #
+    # An array with all the request HTTP headers associated with this request. Unlike [`method: Request.allHeaders`], header names are NOT lower-cased.
+    # Headers with multiple entries, such as `Set-Cookie`, appear in the array multiple times.
     def headers_array
       wrap_impl(@impl.headers_array)
     end
 
+    #
     # Returns the value of the header matching the name. The name is case insensitive.
     def header_value(name)
       wrap_impl(@impl.header_value(unwrap_impl(name)))
     end
 
+    #
     # Whether this request is driving frame's navigation.
     def navigation_request?
       wrap_impl(@impl.navigation_request?)
     end
 
+    #
     # Request's method (GET, POST, etc.)
     def method
       wrap_impl(@impl.method)
     end
 
+    #
     # Request's post body, if any.
     def post_data
       wrap_impl(@impl.post_data)
     end
 
+    #
     # Request's post body in a binary form, if any.
     def post_data_buffer
       wrap_impl(@impl.post_data_buffer)
     end
 
+    #
     # Returns parsed request's body for `form-urlencoded` and JSON as a fallback if any.
     #
     # When the response is `application/x-www-form-urlencoded` then a key/value object of the values will be returned.
@@ -81,12 +95,15 @@ module Playwright
       wrap_impl(@impl.post_data_json)
     end
 
+    #
     # Request that was redirected by the server to this one, if any.
     #
     # When the server responds with a redirect, Playwright creates a new `Request` object. The two requests are connected by
     # `redirectedFrom()` and `redirectedTo()` methods. When multiple server redirects has happened, it is possible to
     # construct the whole redirect chain by repeatedly calling `redirectedFrom()`.
     #
+    # **Usage**
+    #
     # For example, if the website `http://example.com` redirects to `https://example.com`:
     #
     # ```python sync
@@ -104,8 +121,11 @@ module Playwright
       wrap_impl(@impl.redirected_from)
     end
 
+    #
     # New request issued by the browser if the server responded with redirect.
     #
+    # **Usage**
+    #
     # This method is the opposite of [`method: Request.redirectedFrom`]:
     #
     # ```py
@@ -115,6 +135,7 @@ module Playwright
       wrap_impl(@impl.redirected_to)
     end
 
+    #
     # Contains the request's resource type as it was perceived by the rendering engine. ResourceType will be one of the
     # following: `document`, `stylesheet`, `image`, `media`, `font`, `script`, `texttrack`, `xhr`, `fetch`, `eventsource`,
     # `websocket`, `manifest`, `other`.
@@ -122,20 +143,25 @@ module Playwright
       wrap_impl(@impl.resource_type)
     end
 
+    #
     # Returns the matching `Response` object, or `null` if the response was not received due to error.
     def response
       wrap_impl(@impl.response)
     end
 
+    #
     # Returns resource size information for given request.
     def sizes
       wrap_impl(@impl.sizes)
     end
 
+    #
     # Returns resource timing information for given request. Most of the timing values become available upon the response,
     # `responseEnd` becomes available when request finishes. Find more information at
     # [Resource Timing API](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming).
     #
+    # **Usage**
+    #
     # ```python sync
     # with page.expect_event("requestfinished") as request_info:
     #     page.goto("http://example.com")
@@ -146,6 +172,7 @@ module Playwright
       wrap_impl(@impl.timing)
     end
 
+    #
     # URL of the request.
     def url
       wrap_impl(@impl.url)

data/lib/playwright_api/response.rb

@@ -1,58 +1,67 @@
 module Playwright
+  #
   # `Response` class represents responses which are received by page.
   class Response < PlaywrightApi
 
+    #
     # An object with all the response HTTP headers associated with this response.
     def all_headers
       wrap_impl(@impl.all_headers)
     end
 
+    #
     # Returns the buffer with response body.
     def body
       wrap_impl(@impl.body)
     end
 
+    #
     # Waits for this response to finish, returns always `null`.
     def finished
       wrap_impl(@impl.finished)
     end
 
+    #
     # Returns the `Frame` that initiated this response.
     def frame
       wrap_impl(@impl.frame)
     end
 
-    # Indicates whether this Response was fulfilled by a Service Worker's Fetch Handler (i.e. via
-    # [FetchEvent.respondWith](https://developer.mozilla.org/en-US/docs/Web/API/FetchEvent/respondWith)).
+    #
+    # Indicates whether this Response was fulfilled by a Service Worker's Fetch Handler (i.e. via [FetchEvent.respondWith](https://developer.mozilla.org/en-US/docs/Web/API/FetchEvent/respondWith)).
     def from_service_worker
       wrap_impl(@impl.from_service_worker)
     end
 
-    # An object with the response HTTP headers. The header names are lower-cased. Note that this method does not return
-    # security-related headers, including cookie-related ones. You can use [`method: Response.allHeaders`] for complete list
-    # of headers that include `cookie` information.
+    #
+    # An object with the response HTTP headers. The header names are lower-cased.
+    # Note that this method does not return security-related headers, including cookie-related ones.
+    # You can use [`method: Response.allHeaders`] for complete list of headers that include `cookie` information.
     def headers
       wrap_impl(@impl.headers)
     end
 
-    # An array with all the request HTTP headers associated with this response. Unlike [`method: Response.allHeaders`], header
-    # names are NOT lower-cased. Headers with multiple entries, such as `Set-Cookie`, appear in the array multiple times.
+    #
+    # An array with all the request HTTP headers associated with this response. Unlike [`method: Response.allHeaders`], header names are NOT lower-cased.
+    # Headers with multiple entries, such as `Set-Cookie`, appear in the array multiple times.
     def headers_array
       wrap_impl(@impl.headers_array)
     end
 
-    # Returns the value of the header matching the name. The name is case insensitive. If multiple headers have the same name
-    # (except `set-cookie`), they are returned as a list separated by `, `. For `set-cookie`, the `\n` separator is used. If
-    # no headers are found, `null` is returned.
+    #
+    # Returns the value of the header matching the name. The name is case insensitive. If multiple headers have
+    # the same name (except `set-cookie`), they are returned as a list separated by `, `. For `set-cookie`, the `\n` separator is used. If no headers are found, `null` is returned.
     def header_value(name)
       wrap_impl(@impl.header_value(unwrap_impl(name)))
     end
 
+    #
     # Returns all values of the headers matching the name, for example `set-cookie`. The name is case insensitive.
     def header_values(name)
       wrap_impl(@impl.header_values(unwrap_impl(name)))
     end
 
+    #
     # Returns the JSON representation of response body.
     #
     # This method will throw if the response body is not parsable via `JSON.parse`.
@@ -60,41 +69,49 @@ module Playwright
       wrap_impl(@impl.json)
     end
 
+    #
     # Contains a boolean stating whether the response was successful (status in the range 200-299) or not.
     def ok
       wrap_impl(@impl.ok)
     end
 
+    #
     # Returns the matching `Request` object.
     def request
       wrap_impl(@impl.request)
     end
 
+    #
     # Returns SSL and other security information.
     def security_details
       wrap_impl(@impl.security_details)
     end
 
+    #
     # Returns the IP address and port of the server.
     def server_addr
       wrap_impl(@impl.server_addr)
     end
 
+    #
     # Contains the status code of the response (e.g., 200 for a success).
     def status
       wrap_impl(@impl.status)
     end
 
+    #
     # Contains the status text of the response (e.g. usually an "OK" for a success).
     def status_text
       wrap_impl(@impl.status_text)
     end
 
+    #
     # Returns the text representation of response body.
     def text
       wrap_impl(@impl.text)
     end
 
+    #
     # Contains the URL of the response.
     def url
       wrap_impl(@impl.url)

data/lib/playwright_api/route.rb

@@ -1,17 +1,22 @@
 module Playwright
+  #
   # Whenever a network route is set up with [`method: Page.route`] or [`method: BrowserContext.route`], the `Route` object
   # allows to handle the route.
   #
   # Learn more about [networking](../network.md).
   class Route < PlaywrightApi
 
+    #
     # Aborts the route's request.
     def abort(errorCode: nil)
       wrap_impl(@impl.abort(errorCode: unwrap_impl(errorCode)))
     end
 
+    #
     # Continues route's request with optional overrides.
     #
+    # **Usage**
+    #
     # ```python sync
     # def handle(route, request):
     #     # override headers
@@ -21,17 +26,20 @@ module Playwright
     #         "bar": None # remove "bar" header
     #     }
     #     route.continue_(headers=headers)
-    # }
+    #
     # page.route("**/*", handle)
     # ```
     def continue(headers: nil, method: nil, postData: nil, url: nil)
       wrap_impl(@impl.continue(headers: unwrap_impl(headers), method: unwrap_impl(method), postData: unwrap_impl(postData), url: unwrap_impl(url)))
     end
 
-    # When several routes match the given pattern, they run in the order opposite to their registration. That way the last
-    # registered route can always override all the previous ones. In the example below, request will be handled by the
-    # bottom-most handler first, then it'll fall back to the previous one and in the end will be aborted by the first
-    # registered route.
+    #
+    # When several routes match the given pattern, they run in the order opposite to their registration.
+    # That way the last registered route can always override all the previous ones. In the example below,
+    # request will be handled by the bottom-most handler first, then it'll fall back to the previous one and
+    # in the end will be aborted by the first registered route.
+    #
+    # **Usage**
     #
     # ```python sync
     # page.route("**/*", lambda route: route.abort())  # Runs last.
@@ -39,8 +47,9 @@ module Playwright
     # page.route("**/*", lambda route: route.fallback())  # Runs first.
     # ```
     #
-    # Registering multiple routes is useful when you want separate handlers to handle different kinds of requests, for example
-    # API calls vs page resources or GET requests vs POST requests as in the example below.
+    # Registering multiple routes is useful when you want separate handlers to
+    # handle different kinds of requests, for example API calls vs page resources or
+    # GET requests vs POST requests as in the example below.
     #
     # ```python sync
     # # Handle GET requests.
@@ -63,8 +72,8 @@ module Playwright
     # page.route("**/*", handle_post)
     # ```
     #
-    # One can also modify request while falling back to the subsequent handler, that way intermediate route handler can modify
-    # url, method, headers and postData of the request.
+    # One can also modify request while falling back to the subsequent handler, that way intermediate
+    # route handler can modify url, method, headers and postData of the request.
     #
     # ```python sync
     # def handle(route, request):
@@ -75,15 +84,37 @@ module Playwright
     #         "bar": None # remove "bar" header
     #     }
     #     route.fallback(headers=headers)
-    # }
+    #
     # page.route("**/*", handle)
     # ```
     def fallback(headers: nil, method: nil, postData: nil, url: nil)
       wrap_impl(@impl.fallback(headers: unwrap_impl(headers), method: unwrap_impl(method), postData: unwrap_impl(postData), url: unwrap_impl(url)))
     end
 
+    #
+    # Performs the request and fetches result without fulfilling it, so that the response
+    # could be modified and then fulfilled.
+    #
+    # **Usage**
+    #
+    # ```python sync
+    # def handle(route):
+    #     response = route.fulfill()
+    #     json = response.json()
+    #     json["message"]["big_red_dog"] = []
+    #     route.fulfill(response=response, json=json)
+    #
+    # page.route("https://dog.ceo/api/breeds/list/all", handle)
+    # ```
+    def fetch(headers: nil, method: nil, postData: nil, url: nil)
+      wrap_impl(@impl.fetch(headers: unwrap_impl(headers), method: unwrap_impl(method), postData: unwrap_impl(postData), url: unwrap_impl(url)))
+    end
+
+    #
     # Fulfills route's request with given response.
     #
+    # **Usage**
+    #
     # An example of fulfilling all requests with 404 responses:
     #
     # ```python sync
@@ -102,12 +133,14 @@ module Playwright
           body: nil,
           contentType: nil,
           headers: nil,
+          json: nil,
           path: nil,
           response: nil,
           status: nil)
-      wrap_impl(@impl.fulfill(body: unwrap_impl(body), contentType: unwrap_impl(contentType), headers: unwrap_impl(headers), path: unwrap_impl(path), response: unwrap_impl(response), status: unwrap_impl(status)))
+      wrap_impl(@impl.fulfill(body: unwrap_impl(body), contentType: unwrap_impl(contentType), headers: unwrap_impl(headers), json: unwrap_impl(json), path: unwrap_impl(path), response: unwrap_impl(response), status: unwrap_impl(status)))
     end
 
+    #
     # A request to be routed.
     def request
       wrap_impl(@impl.request)

data/lib/playwright_api/selectors.rb

@@ -1,8 +1,12 @@
 module Playwright
-  # Selectors can be used to install custom selector engines. See [Working with selectors](../selectors.md) for more
+  #
+  # Selectors can be used to install custom selector engines. See [extensibility](../extensibility.md) for more
   # information.
   class Selectors < PlaywrightApi
 
+    #
+    # **Usage**
+    #
     # An example of registering selector engine that queries elements based on a tag name:
     #
     # ```python sync
@@ -43,6 +47,7 @@ module Playwright
       wrap_impl(@impl.register(unwrap_impl(name), contentScript: unwrap_impl(contentScript), path: unwrap_impl(path), script: unwrap_impl(script)))
     end
 
+    #
     # Defines custom attribute name to be used in [`method: Page.getByTestId`]. `data-testid` is used by default.
     def set_test_id_attribute(attributeName)
       raise NotImplementedError.new('set_test_id_attribute is not implemented yet.')

data/lib/playwright_api/touchscreen.rb

@@ -1,8 +1,10 @@
 module Playwright
+  #
   # The Touchscreen class operates in main-frame CSS pixels relative to the top-left corner of the viewport. Methods on the
   # touchscreen can only be used in browser contexts that have been initialized with `hasTouch` set to true.
   class Touchscreen < PlaywrightApi
 
+    #
     # Dispatches a `touchstart` and `touchend` event with a single touch at the position (`x`,`y`).
     def tap_point(x, y)
       wrap_impl(@impl.tap_point(unwrap_impl(x), unwrap_impl(y)))

data/lib/playwright_api/tracing.rb

@@ -1,6 +1,6 @@
 module Playwright
-  # API for collecting and saving Playwright traces. Playwright traces can be opened in [Trace Viewer](../trace-viewer.md)
-  # after Playwright script runs.
+  #
+  # API for collecting and saving Playwright traces. Playwright traces can be opened in [Trace Viewer](../trace-viewer.md) after Playwright script runs.
   #
   # Start recording a trace before performing actions. At the end, stop tracing and save it to a file.
   #
@@ -14,8 +14,11 @@ module Playwright
   # ```
   class Tracing < PlaywrightApi
 
+    #
     # Start tracing.
     #
+    # **Usage**
+    #
     # ```python sync
     # context.tracing.start(name="trace", screenshots=True, snapshots=True)
     # page = context.new_page()
@@ -31,9 +34,10 @@ module Playwright
       wrap_impl(@impl.start(name: unwrap_impl(name), screenshots: unwrap_impl(screenshots), snapshots: unwrap_impl(snapshots), sources: unwrap_impl(sources), title: unwrap_impl(title)))
     end
 
-    # Start a new trace chunk. If you'd like to record multiple traces on the same `BrowserContext`, use
-    # [`method: Tracing.start`] once, and then create multiple trace chunks with [`method: Tracing.startChunk`] and
-    # [`method: Tracing.stopChunk`].
+    #
+    # Start a new trace chunk. If you'd like to record multiple traces on the same `BrowserContext`, use [`method: Tracing.start`] once, and then create multiple trace chunks with [`method: Tracing.startChunk`] and [`method: Tracing.stopChunk`].
+    #
+    # **Usage**
     #
     # ```python sync
     # context.tracing.start(name="trace", screenshots=True, snapshots=True)
@@ -54,11 +58,13 @@ module Playwright
       wrap_impl(@impl.start_chunk(title: unwrap_impl(title)))
     end
 
+    #
     # Stop tracing.
     def stop(path: nil)
       wrap_impl(@impl.stop(path: unwrap_impl(path)))
     end
 
+    #
     # Stop the trace chunk. See [`method: Tracing.startChunk`] for more details about multiple trace chunks.
     def stop_chunk(path: nil)
       wrap_impl(@impl.stop_chunk(path: unwrap_impl(path)))

data/lib/playwright_api/web_socket.rb

@@ -1,28 +1,33 @@
 module Playwright
+  #
   # The `WebSocket` class represents websocket connections in the page.
   class WebSocket < PlaywrightApi
 
+    #
     # Indicates that the web socket has been closed.
     def closed?
       wrap_impl(@impl.closed?)
     end
 
+    #
     # Contains the URL of the WebSocket.
     def url
       wrap_impl(@impl.url)
     end
 
+    #
     # Waits for event to fire and passes its value into the predicate function. Returns when the predicate returns truthy
     # value. Will throw an error if the webSocket is closed before the event is fired. Returns the event data value.
     def expect_event(event, predicate: nil, timeout: nil, &block)
       wrap_impl(@impl.expect_event(unwrap_impl(event), predicate: unwrap_impl(predicate), timeout: unwrap_impl(timeout), &wrap_block_call(block)))
     end
 
-    # > NOTE: In most cases, you should use [`method: WebSocket.waitForEvent`].
     #
-    # Waits for given `event` to fire. If predicate is provided, it passes event's value into the `predicate` function and
-    # waits for `predicate(event)` to return a truthy value. Will throw an error if the socket is closed before the `event` is
-    # fired.
+    # **NOTE**: In most cases, you should use [`method: WebSocket.waitForEvent`].
+    #
+    # Waits for given `event` to fire. If predicate is provided, it passes
+    # event's value into the `predicate` function and waits for `predicate(event)` to return a truthy value.
+    # Will throw an error if the socket is closed before the `event` is fired.
     def wait_for_event(event, predicate: nil, timeout: nil, &block)
       wrap_impl(@impl.wait_for_event(unwrap_impl(event), predicate: unwrap_impl(predicate), timeout: unwrap_impl(timeout), &wrap_block_call(block)))
     end

data/lib/playwright_api/worker.rb

@@ -1,4 +1,5 @@
 module Playwright
+  #
   # The Worker class represents a [WebWorker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API). `worker`
   # event is emitted on the page object to signal a worker creation. `close` event is emitted on the worker object when the
   # worker is gone.
@@ -16,25 +17,27 @@ module Playwright
   # ```
   class Worker < PlaywrightApi
 
+    #
     # Returns the return value of `expression`.
     #
-    # If the function passed to the [`method: Worker.evaluate`] returns a [Promise], then [`method: Worker.evaluate`] would
-    # wait for the promise to resolve and return its value.
+    # If the function passed to the [`method: Worker.evaluate`] returns a [Promise], then [`method: Worker.evaluate`] would wait for the promise
+    # to resolve and return its value.
     #
-    # If the function passed to the [`method: Worker.evaluate`] returns a non-[Serializable] value, then
-    # [`method: Worker.evaluate`] returns `undefined`. Playwright also supports transferring some additional values that are
-    # not serializable by `JSON`: `-0`, `NaN`, `Infinity`, `-Infinity`.
+    # If the function passed to the [`method: Worker.evaluate`] returns a non-[Serializable] value, then [`method: Worker.evaluate`] returns `undefined`. Playwright also supports transferring some
+    # additional values that are not serializable by `JSON`: `-0`, `NaN`, `Infinity`, `-Infinity`.
     def evaluate(expression, arg: nil)
       wrap_impl(@impl.evaluate(unwrap_impl(expression), arg: unwrap_impl(arg)))
     end
 
+    #
     # Returns the return value of `expression` as a `JSHandle`.
     #
-    # The only difference between [`method: Worker.evaluate`] and [`method: Worker.evaluateHandle`] is that
-    # [`method: Worker.evaluateHandle`] returns `JSHandle`.
+    # The only difference between [`method: Worker.evaluate`] and
+    # [`method: Worker.evaluateHandle`] is that [`method: Worker.evaluateHandle`]
+    # returns `JSHandle`.
     #
-    # If the function passed to the [`method: Worker.evaluateHandle`] returns a [Promise], then
-    # [`method: Worker.evaluateHandle`] would wait for the promise to resolve and return its value.
+    # If the function passed to the [`method: Worker.evaluateHandle`] returns a [Promise], then [`method: Worker.evaluateHandle`] would wait for
+    # the promise to resolve and return its value.
     def evaluate_handle(expression, arg: nil)
       wrap_impl(@impl.evaluate_handle(unwrap_impl(expression), arg: unwrap_impl(arg)))
     end
@@ -44,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 --

data/playwright.gemspec

@@ -27,7 +27,7 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = '>= 2.4'
   spec.add_dependency 'concurrent-ruby', '>= 1.1.6'
   spec.add_dependency 'mime-types', '>= 3.0'
-  spec.add_development_dependency 'bundler', '~> 2.3.0'
+  spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'chunky_png'
   spec.add_development_dependency 'dry-inflector'
   spec.add_development_dependency 'faye-websocket'