playwright-ruby-client 1.16.0 → 1.17.1

data/lib/playwright.rb

@@ -135,13 +135,14 @@ module Playwright
 
     transport = WebSocketTransport.new(ws_endpoint: ws_endpoint)
     connection = Connection.new(transport)
+    connection.mark_as_remote
     connection.async_run
 
     execution =
       begin
         playwright = connection.initialize_playwright
         browser = playwright.send(:pre_launched_browser)
-        browser.send(:update_as_remote)
+        browser.should_close_connection_on_close!
         Execution.new(connection, PlaywrightApi.wrap(playwright), PlaywrightApi.wrap(browser))
       rescue
         connection.stop

data/lib/playwright_api/android_device.rb

@@ -165,13 +165,13 @@ module Playwright
     end
 
     # @nodoc
-    def tree
-      wrap_impl(@impl.tree)
+    def tap_on(selector, duration: nil, timeout: nil)
+      wrap_impl(@impl.tap_on(unwrap_impl(selector), duration: unwrap_impl(duration), timeout: unwrap_impl(timeout)))
     end
 
     # @nodoc
-    def tap_on(selector, duration: nil, timeout: nil)
-      wrap_impl(@impl.tap_on(unwrap_impl(selector), duration: unwrap_impl(duration), timeout: unwrap_impl(timeout)))
+    def tree
+      wrap_impl(@impl.tree)
     end
 
     # -- inherited from EventEmitter --

data/lib/playwright_api/api_request.rb

@@ -0,0 +1,18 @@
+module Playwright
+  # Exposes API that can be used for the Web API testing.
+  class APIRequest < PlaywrightApi
+
+    # Creates new instances of `APIRequestContext`.
+    def new_context(
+          baseURL: nil,
+          extraHTTPHeaders: nil,
+          httpCredentials: nil,
+          ignoreHTTPSErrors: nil,
+          proxy: nil,
+          storageState: nil,
+          timeout: nil,
+          userAgent: nil)
+      raise NotImplementedError.new('new_context is not implemented yet.')
+    end
+  end
+end

data/lib/playwright_api/api_request_context.rb

@@ -10,19 +10,22 @@ module Playwright
     # method will automatically follow redirects.
     def delete(
           url,
+          data: nil,
           failOnStatusCode: nil,
+          form: nil,
           headers: nil,
           ignoreHTTPSErrors: nil,
+          multipart: nil,
           params: nil,
           timeout: nil)
-      raise NotImplementedError.new('delete is not implemented yet.')
+      wrap_impl(@impl.delete(unwrap_impl(url), data: unwrap_impl(data), failOnStatusCode: unwrap_impl(failOnStatusCode), form: unwrap_impl(form), headers: unwrap_impl(headers), ignoreHTTPSErrors: unwrap_impl(ignoreHTTPSErrors), multipart: unwrap_impl(multipart), params: unwrap_impl(params), timeout: unwrap_impl(timeout)))
     end
 
     # All responses returned by [`method: APIRequestContext.get`] and similar methods are stored in the memory, so that you
     # can later call [`method: APIResponse.body`]. This method discards all stored responses, and makes
     # [`method: APIResponse.body`] throw "Response disposed" error.
     def dispose
-      raise NotImplementedError.new('dispose is not implemented yet.')
+      wrap_impl(@impl.dispose)
     end
 
     # Sends HTTP(S) request and returns its response. The method will populate request cookies from the context and update
@@ -38,7 +41,7 @@ module Playwright
           multipart: nil,
           params: nil,
           timeout: nil)
-      raise NotImplementedError.new('fetch is not implemented yet.')
+      wrap_impl(@impl.fetch(unwrap_impl(urlOrRequest), data: unwrap_impl(data), failOnStatusCode: unwrap_impl(failOnStatusCode), form: unwrap_impl(form), headers: unwrap_impl(headers), ignoreHTTPSErrors: unwrap_impl(ignoreHTTPSErrors), method: unwrap_impl(method), multipart: unwrap_impl(multipart), params: unwrap_impl(params), timeout: unwrap_impl(timeout)))
     end
 
     # Sends HTTP(S) [GET](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/GET) request and returns its response. The
@@ -51,7 +54,7 @@ module Playwright
           ignoreHTTPSErrors: nil,
           params: nil,
           timeout: nil)
-      raise NotImplementedError.new('get is not implemented yet.')
+      wrap_impl(@impl.get(unwrap_impl(url), failOnStatusCode: unwrap_impl(failOnStatusCode), headers: unwrap_impl(headers), ignoreHTTPSErrors: unwrap_impl(ignoreHTTPSErrors), params: unwrap_impl(params), timeout: unwrap_impl(timeout)))
     end
 
     # Sends HTTP(S) [HEAD](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/HEAD) request and returns its response.
@@ -64,7 +67,7 @@ module Playwright
           ignoreHTTPSErrors: nil,
           params: nil,
           timeout: nil)
-      raise NotImplementedError.new('head is not implemented yet.')
+      wrap_impl(@impl.head(unwrap_impl(url), failOnStatusCode: unwrap_impl(failOnStatusCode), headers: unwrap_impl(headers), ignoreHTTPSErrors: unwrap_impl(ignoreHTTPSErrors), params: unwrap_impl(params), timeout: unwrap_impl(timeout)))
     end
 
     # Sends HTTP(S) [PATCH](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PATCH) request and returns its response.
@@ -80,7 +83,7 @@ module Playwright
           multipart: nil,
           params: nil,
           timeout: nil)
-      raise NotImplementedError.new('patch is not implemented yet.')
+      wrap_impl(@impl.patch(unwrap_impl(url), data: unwrap_impl(data), failOnStatusCode: unwrap_impl(failOnStatusCode), form: unwrap_impl(form), headers: unwrap_impl(headers), ignoreHTTPSErrors: unwrap_impl(ignoreHTTPSErrors), multipart: unwrap_impl(multipart), params: unwrap_impl(params), timeout: unwrap_impl(timeout)))
     end
 
     # Sends HTTP(S) [POST](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST) request and returns its response.
@@ -96,7 +99,7 @@ module Playwright
           multipart: nil,
           params: nil,
           timeout: nil)
-      raise NotImplementedError.new('post is not implemented yet.')
+      wrap_impl(@impl.post(unwrap_impl(url), data: unwrap_impl(data), failOnStatusCode: unwrap_impl(failOnStatusCode), form: unwrap_impl(form), headers: unwrap_impl(headers), ignoreHTTPSErrors: unwrap_impl(ignoreHTTPSErrors), multipart: unwrap_impl(multipart), params: unwrap_impl(params), timeout: unwrap_impl(timeout)))
     end
 
     # Sends HTTP(S) [PUT](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT) request and returns its response. The
@@ -112,7 +115,7 @@ module Playwright
           multipart: nil,
           params: nil,
           timeout: nil)
-      raise NotImplementedError.new('put is not implemented yet.')
+      wrap_impl(@impl.put(unwrap_impl(url), data: unwrap_impl(data), failOnStatusCode: unwrap_impl(failOnStatusCode), form: unwrap_impl(form), headers: unwrap_impl(headers), ignoreHTTPSErrors: unwrap_impl(ignoreHTTPSErrors), multipart: unwrap_impl(multipart), params: unwrap_impl(params), timeout: unwrap_impl(timeout)))
     end
 
     # Returns storage state for this request context, contains current cookies and local storage snapshot if it was passed to

data/lib/playwright_api/api_response.rb

@@ -0,0 +1,68 @@
+module Playwright
+  # `APIResponse` class represents responses returned by [`method: APIRequestContext.get`] and similar methods.
+  class APIResponse < PlaywrightApi
+
+    # Returns the buffer with response body.
+    def body
+      wrap_impl(@impl.body)
+    end
+
+    # Disposes the body of this response. If not called then the body will stay in memory until the context closes.
+    def dispose
+      wrap_impl(@impl.dispose)
+    end
+
+    # An object with all the response HTTP headers associated with this response.
+    def headers
+      wrap_impl(@impl.headers)
+    end
+
+    # An array with all the request HTTP headers associated with this response. 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 JSON representation of response body.
+    #
+    # This method will throw if the response body is not parsable via `JSON.parse`.
+    def json
+      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
+
+    # 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)
+    end
+
+    # @nodoc
+    def ok?
+      wrap_impl(@impl.ok?)
+    end
+
+    # @nodoc
+    def to_s
+      wrap_impl(@impl.to_s)
+    end
+  end
+end

data/lib/playwright_api/browser_context.rb

@@ -20,6 +20,11 @@ module Playwright
   # ```
   class BrowserContext < PlaywrightApi
 
+    # API testing helper associated with this context. Requests made with this API will use context cookies.
+    def request # property
+      wrap_impl(@impl.request)
+    end
+
     def tracing # property
       wrap_impl(@impl.tracing)
     end
@@ -366,6 +371,11 @@ module Playwright
       raise NotImplementedError.new('wait_for_event is not implemented yet.')
     end
 
+    # @nodoc
+    def pause
+      wrap_impl(@impl.pause)
+    end
+
     # @nodoc
     def enable_debug_console!
       wrap_impl(@impl.enable_debug_console!)
@@ -381,11 +391,6 @@ module Playwright
       wrap_impl(@impl.owner_page=(unwrap_impl(req)))
     end
 
-    # @nodoc
-    def pause
-      wrap_impl(@impl.pause)
-    end
-
     # @nodoc
     def options=(req)
       wrap_impl(@impl.options=(unwrap_impl(req)))

data/lib/playwright_api/element_handle.rb

@@ -6,6 +6,8 @@ module Playwright
   # ElementHandle represents an in-page DOM element. ElementHandles can be created with the [`method: Page.querySelector`]
   # method.
   #
+  # > NOTE: The use of ElementHandle is discouraged, use `Locator` objects and web-first assertions instead.
+  #
   # ```python sync
   # href_element = page.query_selector("a")
   # href_element.click()
@@ -17,9 +19,6 @@ module Playwright
   # ElementHandle instances can be used as an argument in [`method: Page.evalOnSelector`] and [`method: Page.evaluate`]
   # methods.
   #
-  # > NOTE: In most cases, you would want to use the `Locator` object instead. You should only use `ElementHandle` if you
-  # want to retain a handle to a particular DOM Node that you intend to pass into [`method: Page.evaluate`] as an argument.
-  #
   # The difference between the `Locator` and ElementHandle is that the ElementHandle points to a particular element, while
   # `Locator` captures the logic of how to retrieve an element.
   #

data/lib/playwright_api/frame.rb

@@ -183,6 +183,9 @@ module Playwright
 
     # Returns the return value of `expression`.
     #
+    # > NOTE: This method does not wait for the element to pass actionability checks and therefore can lead to the flaky
+    # tests. Use [`method: Locator.evaluate`], other `Locator` helper methods or web-first assertions instead.
+    #
     # The method finds an element matching the specified selector within the frame and passes it as a first argument to
     # `expression`. See [Working with selectors](./selectors.md) for more details. If no elements match the selector, the
     # method throws an error.
@@ -203,6 +206,9 @@ module Playwright
 
     # Returns the return value of `expression`.
     #
+    # > NOTE: In most cases, [`method: Locator.evaluateAll`], other `Locator` helper methods and web-first assertions do a
+    # better job.
+    #
     # The method finds all elements matching the specified selector within the frame and passes an array of matched elements
     # as a first argument to `expression`. See [Working with selectors](./selectors.md) for more details.
     #
@@ -243,7 +249,7 @@ module Playwright
     # `ElementHandle` instances can be passed as an argument to the [`method: Frame.evaluate`]:
     #
     # ```python sync
-    # body_handle = frame.query_selector("body")
+    # body_handle = frame.evaluate("document.body")
     # html = frame.evaluate("([body, suffix]) => body.innerHTML + suffix", [body_handle, "hello"])
     # body_handle.dispose()
     # ```
@@ -324,6 +330,18 @@ module Playwright
       wrap_impl(@impl.frame_element)
     end
 
+    # When working with iframes, you can create a frame locator that will enter the iframe and allow selecting elements in
+    # that iframe. Following snippet locates element with text "Submit" in the iframe with id `my-frame`, like `<iframe
+    # id="my-frame">`:
+    #
+    # ```python sync
+    # locator = frame.frame_locator("#my-iframe").locator("text=Submit")
+    # locator.click()
+    # ```
+    def frame_locator(selector)
+      wrap_impl(@impl.frame_locator(unwrap_impl(selector)))
+    end
+
     # Returns element attribute value.
     def get_attribute(selector, name, strict: nil, timeout: nil)
       wrap_impl(@impl.get_attribute(unwrap_impl(selector), unwrap_impl(name), strict: unwrap_impl(strict), timeout: unwrap_impl(timeout)))
@@ -478,6 +496,8 @@ module Playwright
 
     # Returns the ElementHandle pointing to the frame element.
     #
+    # > NOTE: The use of `ElementHandle` is discouraged, use `Locator` objects and web-first assertions instead.
+    #
     # The method finds an element matching the specified selector within the frame. See
     # [Working with selectors](./selectors.md) for more details. If no elements match the selector, returns `null`.
     def query_selector(selector, strict: nil)
@@ -486,6 +506,8 @@ module Playwright
 
     # Returns the ElementHandles pointing to the frame elements.
     #
+    # > NOTE: The use of `ElementHandle` is discouraged, use `Locator` objects instead.
+    #
     # The method finds all elements matching the specified selector within the frame. See
     # [Working with selectors](./selectors.md) for more details. If no elements match the selector, returns empty array.
     def query_selector_all(selector)
@@ -714,6 +736,9 @@ module Playwright
     # Returns when element specified by selector satisfies `state` option. Returns `null` if waiting for `hidden` or
     # `detached`.
     #
+    # > NOTE: Playwright automatically waits for element to be ready before performing an action. Using `Locator` objects and
+    # web-first assertions make the code wait-for-selector-free.
+    #
     # Wait for the `selector` to satisfy `state` option (either appear/disappear from dom, or become visible/hidden). If at
     # the moment of calling the method `selector` already satisfies the condition, the method will return immediately. If the
     # selector doesn't satisfy the condition for the `timeout` milliseconds, the function will throw.

data/lib/playwright_api/frame_locator.rb

@@ -0,0 +1,51 @@
+module Playwright
+  # FrameLocator represents a view to the `iframe` on the page. It captures the logic sufficient to retrieve the `iframe`
+  # and locate elements in that iframe. FrameLocator can be created with either [`method: Page.frameLocator`] or
+  # [`method: Locator.frameLocator`] method.
+  #
+  # ```python sync
+  # locator = page.frame_locator("my-frame").locator("text=Submit")
+  # locator.click()
+  # ```
+  #
+  # **Strictness**
+  #
+  # Frame locators are strict. This means that all operations on frame locators will throw if more than one element matches
+  # given selector.
+  #
+  # ```python sync
+  # # Throws if there are several frames in DOM:
+  # page.frame_locator('.result-frame').locator('button').click()
+  #
+  # # Works because we explicitly tell locator to pick the first frame:
+  # page.frame_locator('.result-frame').first.locator('button').click()
+  # ```
+  class FrameLocator < PlaywrightApi
+
+    # Returns locator to the first matching frame.
+    def first
+      wrap_impl(@impl.first)
+    end
+
+    # When working with iframes, you can create a frame locator that will enter the iframe and allow selecting elements in
+    # that iframe.
+    def frame_locator(selector)
+      wrap_impl(@impl.frame_locator(unwrap_impl(selector)))
+    end
+
+    # Returns locator to the last matching frame.
+    def last
+      wrap_impl(@impl.last)
+    end
+
+    # The method finds an element matching the specified selector in the FrameLocator's subtree.
+    def locator(selector)
+      wrap_impl(@impl.locator(unwrap_impl(selector)))
+    end
+
+    # Returns locator to the n-th matching frame.
+    def nth(index)
+      wrap_impl(@impl.nth(unwrap_impl(index)))
+    end
+  end
+end

data/lib/playwright_api/locator.rb

@@ -264,6 +264,17 @@ module Playwright
       wrap_impl(@impl.focus(timeout: unwrap_impl(timeout)))
     end
 
+    # When working with iframes, you can create a frame locator that will enter the iframe and allow selecting elements in
+    # that iframe:
+    #
+    # ```python sync
+    # locator = page.frame_locator("text=Submit").locator("text=Submit")
+    # locator.click()
+    # ```
+    def frame_locator(selector)
+      wrap_impl(@impl.frame_locator(unwrap_impl(selector)))
+    end
+
     # Returns element attribute value.
     def get_attribute(name, timeout: nil)
       wrap_impl(@impl.get_attribute(unwrap_impl(name), timeout: unwrap_impl(timeout)))
@@ -338,8 +349,7 @@ module Playwright
       wrap_impl(@impl.last)
     end
 
-    # The method finds an element matching the specified selector in the `Locator`'s subtree. See
-    # [Working with selectors](./selectors.md) for more details.
+    # The method finds an element matching the specified selector in the `Locator`'s subtree.
     def locator(selector)
       wrap_impl(@impl.locator(unwrap_impl(selector)))
     end

data/lib/playwright_api/page.rb

@@ -288,6 +288,9 @@ module Playwright
       wrap_impl(@impl.emulate_media(colorScheme: unwrap_impl(colorScheme), forcedColors: unwrap_impl(forcedColors), media: unwrap_impl(media), reducedMotion: unwrap_impl(reducedMotion)))
     end
 
+    # > NOTE: This method does not wait for the element to pass actionability checks and therefore can lead to the flaky
+    # tests. Use [`method: Locator.evaluate`], other `Locator` helper methods or web-first assertions instead.
+    #
     # The method finds an element matching the specified selector within the page and passes it as a first argument to
     # `expression`. If no elements match the selector, the method throws an error. Returns the value of `expression`.
     #
@@ -307,6 +310,9 @@ module Playwright
       wrap_impl(@impl.eval_on_selector(unwrap_impl(selector), unwrap_impl(expression), arg: unwrap_impl(arg), strict: unwrap_impl(strict)))
     end
 
+    # > NOTE: In most cases, [`method: Locator.evaluateAll`], other `Locator` helper methods and web-first assertions do a
+    # better job.
+    #
     # The method finds all elements matching the specified selector within the page and passes an array of matched elements as
     # a first argument to `expression`. Returns the result of `expression` invocation.
     #
@@ -349,7 +355,7 @@ module Playwright
     # `ElementHandle` instances can be passed as an argument to the [`method: Page.evaluate`]:
     #
     # ```python sync
-    # body_handle = page.query_selector("body")
+    # body_handle = page.evaluate("document.body")
     # html = page.evaluate("([body, suffix]) => body.innerHTML + suffix", [body_handle, "hello"])
     # body_handle.dispose()
     # ```
@@ -533,6 +539,18 @@ module Playwright
       wrap_impl(@impl.frame(name: unwrap_impl(name), url: unwrap_impl(url)))
     end
 
+    # When working with iframes, you can create a frame locator that will enter the iframe and allow selecting elements in
+    # that iframe. Following snippet locates element with text "Submit" in the iframe with id `my-frame`, like `<iframe
+    # id="my-frame">`:
+    #
+    # ```python sync
+    # locator = page.frame_locator("#my-iframe").locator("text=Submit")
+    # locator.click()
+    # ```
+    def frame_locator(selector)
+      wrap_impl(@impl.frame_locator(unwrap_impl(selector)))
+    end
+
     # An array of all frames attached to the page.
     def frames
       wrap_impl(@impl.frames)
@@ -791,14 +809,18 @@ module Playwright
       wrap_impl(@impl.press(unwrap_impl(selector), unwrap_impl(key), delay: unwrap_impl(delay), noWaitAfter: unwrap_impl(noWaitAfter), strict: unwrap_impl(strict), timeout: unwrap_impl(timeout)))
     end
 
+    # > NOTE: The use of `ElementHandle` is discouraged, use `Locator` objects and web-first assertions instead.
+    #
     # The method finds an element matching the specified selector within the page. If no elements match the selector, the
-    # return value resolves to `null`. To wait for an element on the page, use [`method: Page.waitForSelector`].
+    # return value resolves to `null`. To wait for an element on the page, use [`method: Locator.waitFor`].
     #
     # Shortcut for main frame's [`method: Frame.querySelector`].
     def query_selector(selector, strict: nil)
       wrap_impl(@impl.query_selector(unwrap_impl(selector), strict: unwrap_impl(strict)))
     end
 
+    # > NOTE: The use of `ElementHandle` is discouraged, use `Locator` objects and web-first assertions instead.
+    #
     # The method finds all elements matching the specified selector within the page. If no elements match the selector, the
     # return value resolves to `[]`.
     #
@@ -807,8 +829,8 @@ module Playwright
       wrap_impl(@impl.query_selector_all(unwrap_impl(selector)))
     end
 
-    # Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of the
-    # last redirect.
+    # This method reloads the current page, in the same way as if the user had triggered a browser refresh. Returns the main
+    # resource response. In case of multiple redirects, the navigation will resolve with the response of the last redirect.
     def reload(timeout: nil, waitUntil: nil)
       wrap_impl(@impl.reload(timeout: unwrap_impl(timeout), waitUntil: unwrap_impl(waitUntil)))
     end
@@ -1267,6 +1289,9 @@ module Playwright
     # Returns when element specified by selector satisfies `state` option. Returns `null` if waiting for `hidden` or
     # `detached`.
     #
+    # > NOTE: Playwright automatically waits for element to be ready before performing an action. Using `Locator` objects and
+    # web-first assertions make the code wait-for-selector-free.
+    #
     # Wait for the `selector` to satisfy `state` option (either appear/disappear from dom, or become visible/hidden). If at
     # the moment of calling the method `selector` already satisfies the condition, the method will return immediately. If the
     # selector doesn't satisfy the condition for the `timeout` milliseconds, the function will throw.
@@ -1356,6 +1381,11 @@ module Playwright
       wrap_impl(@impl.owned_context=(unwrap_impl(req)))
     end
 
+    # @nodoc
+    def request
+      wrap_impl(@impl.request)
+    end
+
     # @nodoc
     def start_js_coverage(resetOnNavigation: nil, reportAnonymousScripts: nil)
       wrap_impl(@impl.start_js_coverage(resetOnNavigation: unwrap_impl(resetOnNavigation), reportAnonymousScripts: unwrap_impl(reportAnonymousScripts)))

data/lib/playwright_api/playwright.rb

@@ -50,6 +50,11 @@ module Playwright
       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.
     def selectors # property
@@ -82,13 +87,13 @@ module Playwright
     end
 
     # @nodoc
-    def electron
-      wrap_impl(@impl.electron)
+    def android
+      wrap_impl(@impl.android)
     end
 
     # @nodoc
-    def android
-      wrap_impl(@impl.android)
+    def electron
+      wrap_impl(@impl.electron)
     end
 
     # -- inherited from EventEmitter --

data/lib/playwright_api/selectors.rb

@@ -28,11 +28,11 @@ module Playwright
     #     page.set_content('<div><button>Click me</button></div>')
     #
     #     # Use the selector prefixed with its name.
-    #     button = page.query_selector('tag=button')
+    #     button = page.locator('tag=button')
     #     # Combine it with other selector engines.
     #     page.click('tag=div >> text="Click me"')
     #     # Can use it in any methods supporting selectors.
-    #     button_count = page.eval_on_selector_all('tag=button', 'buttons => buttons.length')
+    #     button_count = page.locator('tag=button').count()
     #     print(button_count)
     #     browser.close()
     #

data/lib/playwright_api/tracing.rb

@@ -22,8 +22,8 @@ module Playwright
     # page.goto("https://playwright.dev")
     # context.tracing.stop(path = "trace.zip")
     # ```
-    def start(name: nil, screenshots: nil, snapshots: nil)
-      wrap_impl(@impl.start(name: unwrap_impl(name), screenshots: unwrap_impl(screenshots), snapshots: unwrap_impl(snapshots)))
+    def start(name: nil, screenshots: nil, snapshots: nil, title: nil)
+      wrap_impl(@impl.start(name: unwrap_impl(name), screenshots: unwrap_impl(screenshots), snapshots: unwrap_impl(snapshots), title: unwrap_impl(title)))
     end
 
     # Start a new trace chunk. If you'd like to record multiple traces on the same `BrowserContext`, use
@@ -45,8 +45,8 @@ module Playwright
     # # Save a second trace file with different actions.
     # context.tracing.stop_chunk(path = "trace2.zip")
     # ```
-    def start_chunk
-      wrap_impl(@impl.start_chunk)
+    def start_chunk(title: nil)
+      wrap_impl(@impl.start_chunk(title: unwrap_impl(title)))
     end
 
     # Stop tracing.

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.2.3'
+  spec.add_development_dependency 'bundler', '~> 2.3.0'
   spec.add_development_dependency 'chunky_png'
   spec.add_development_dependency 'dry-inflector'
   spec.add_development_dependency 'faye-websocket'