playwright-ruby-client 0.0.8 → 1.58.1.alpha1

data/documentation/docs/api/cdp_session.md

@@ -0,0 +1,44 @@
+---
+sidebar_position: 10
+---
+
+# CDPSession
+
+
+The [CDPSession](./cdp_session) instances are used to talk raw Chrome Devtools Protocol:
+- protocol methods can be called with `session.send_message` method.
+- protocol events can be subscribed to with `session.on` method.
+
+Useful links:
+- Documentation on DevTools Protocol can be found here: [DevTools Protocol Viewer](https://chromedevtools.github.io/devtools-protocol/).
+- Getting Started with DevTools Protocol: https://github.com/aslushnikov/getting-started-with-cdp/blob/master/README.md
+
+```ruby
+client = page.context.new_cdp_session(page)
+client.send_message('Animation.enable')
+client.on('Animation.animationCreated', -> (_) { puts 'Animation Created' })
+response = client.send_message('Animation.getPlaybackRate')
+puts "Playback rate is #{response['playbackRate']}"
+client.send_message(
+  'Animation.setPlaybackRate',
+  params: { playbackRate: response['playbackRate'] / 2.0 },
+)
+```
+
+## detach
+
+```
+def detach
+```
+
+
+Detaches the CDPSession from the target. Once detached, the CDPSession object won't emit any events and can't be used to
+send messages.
+
+## send_message
+
+```
+def send_message(method, params: nil)
+```
+
+

data/documentation/docs/api/clock.md

@@ -0,0 +1,154 @@
+---
+sidebar_position: 10
+---
+
+# Clock
+
+
+Accurately simulating time-dependent behavior is essential for verifying the correctness of applications. Learn more about [clock emulation](https://playwright.dev/python/docs/clock).
+
+Note that clock is installed for the entire [BrowserContext](./browser_context), so the time
+in all the pages and iframes is controlled by the same clock.
+
+## fast_forward
+
+```
+def fast_forward(ticks)
+```
+
+
+Advance the clock by jumping forward in time. Only fires due timers at most once. This is equivalent to user closing the laptop lid for a while and
+reopening it later, after given time.
+
+**Usage**
+
+```ruby
+page.clock.fast_forward(1000)
+page.clock.fast_forward("30:00")
+```
+
+## install
+
+```
+def install(time: nil)
+```
+
+
+Install fake implementations for the following time-related functions:
+- `Date`
+- `setTimeout`
+- `clearTimeout`
+- `setInterval`
+- `clearInterval`
+- `requestAnimationFrame`
+- `cancelAnimationFrame`
+- `requestIdleCallback`
+- `cancelIdleCallback`
+- `performance`
+
+Fake timers are used to manually control the flow of time in tests. They allow you to advance time, fire timers, and control the behavior of time-dependent functions. See [Clock#run_for](./clock#run_for) and [Clock#fast_forward](./clock#fast_forward) for more information.
+
+## run_for
+
+```
+def run_for(ticks)
+```
+
+
+Advance the clock, firing all the time-related callbacks.
+
+**Usage**
+
+```ruby
+page.clock.run_for(1000)
+page.clock.run_for("30:00")
+```
+
+## pause_at
+
+```
+def pause_at(time)
+```
+
+
+Advance the clock by jumping forward in time and pause the time. Once this method is called, no timers
+are fired unless [Clock#run_for](./clock#run_for), [Clock#fast_forward](./clock#fast_forward), [Clock#pause_at](./clock#pause_at) or [Clock#resume](./clock#resume) is called.
+
+Only fires due timers at most once.
+This is equivalent to user closing the laptop lid for a while and reopening it at the specified time and
+pausing.
+
+**Usage**
+
+```ruby
+page.clock.pause_at(Time.parse("2020-02-02"))
+page.clock.pause_at("2020-02-02")
+```
+
+For best results, install the clock before navigating the page and set it to a time slightly before the intended test time. This ensures that all timers run normally during page loading, preventing the page from getting stuck. Once the page has fully loaded, you can safely use [Clock#pause_at](./clock#pause_at) to pause the clock.
+
+```ruby
+# Initialize clock with some time before the test time and let the page load
+# naturally. `Date.now` will progress as the timers fire.
+page.clock.install(Time.parse("2024-12-10T08:00:00Z"))
+page.goto("http://localhost:3333")
+page.clock.pause_at(Time.parse("2024-12-10T10:00:00Z"))
+```
+
+## resume
+
+```
+def resume
+```
+
+
+Resumes timers. Once this method is called, time resumes flowing, timers are fired as usual.
+
+## set_fixed_time
+
+```
+def set_fixed_time(time)
+```
+alias: `fixed_time=`
+
+
+Makes `Date.now` and `new Date()` return fixed fake time at all times,
+keeps all the timers running.
+
+Use this method for simple scenarios where you only need to test with a predefined time. For more advanced scenarios, use [Clock#install](./clock#install) instead. Read docs on [clock emulation](https://playwright.dev/python/docs/clock) to learn more.
+
+**Usage**
+
+```ruby
+page.clock.set_fixed_time(Time.now)
+page.clock.set_fixed_time(Time.parse("2020-02-02"))
+page.clock.set_fixed_time("2020-02-02")
+
+# or we can use the alias
+page.clock.fixed_time = Time.now
+page.clock.fixed_time = Time.parse("2020-02-02")
+page.clock.fixed_time = "2020-02-02"
+```
+
+## set_system_time
+
+```
+def set_system_time(time)
+```
+alias: `system_time=`
+
+
+Sets system time, but does not trigger any timers. Use this to test how the web page reacts to a time shift, for example switching from summer to winter time, or changing time zones.
+
+**Usage**
+
+```ruby
+page.clock.set_system_time(Time.now)
+page.clock.set_system_time(Time.parse("2020-02-02"))
+page.clock.set_system_time("2020-02-02")
+
+# or we can use the alias
+page.clock.system_time = Time.now
+page.clock.system_time = Time.parse("2020-02-02")
+page.clock.system_time = "2020-02-02"
+```

data/documentation/docs/api/console_message.md

@@ -0,0 +1,85 @@
+---
+sidebar_position: 10
+---
+
+# ConsoleMessage
+
+
+[ConsoleMessage](./console_message) objects are dispatched by page via the [`event: Page.console`] event.
+For each console message logged in the page there will be corresponding event in the Playwright
+context.
+
+```ruby
+# Listen for all console logs
+page.on("console", ->(msg) { puts msg.text })
+
+# Listen for all console events and handle errors
+page.on("console", ->(msg) {
+  if msg.type == 'error'
+    puts "error: #{msg.text}"
+  end
+})
+
+# Get the next console log
+msg = page.expect_console_message do
+  # Issue console.log inside the page
+  page.evaluate("console.error('hello', 42, { foo: 'bar' })")
+end
+
+# Deconstruct print arguments
+msg.args[0].json_value # => 'hello'
+msg.args[1].json_value # => 42
+msg.args[2].json_value # => { 'foo' => 'bar' }
+```
+
+## args
+
+```
+def args
+```
+
+
+List of arguments passed to a `console` function call. See also [`event: Page.console`].
+
+## location
+
+```
+def location
+```
+
+
+
+## page
+
+```
+def page
+```
+
+
+The page that produced this console message, if any.
+
+## text
+
+```
+def text
+```
+
+
+The text of the console message.
+
+## type
+
+```
+def type
+```
+
+
+
+## worker
+
+```
+def worker
+```
+
+
+The web worker or service worker that produced this console message, if any. Note that console messages from web workers also have non-null [ConsoleMessage#page](./console_message#page).

data/documentation/docs/api/dialog.md

@@ -0,0 +1,84 @@
+---
+sidebar_position: 10
+---
+
+# Dialog
+
+
+[Dialog](./dialog) objects are dispatched by page via the [`event: Page.dialog`] event.
+
+An example of using [Dialog](./dialog) class:
+
+```ruby
+def handle_dialog(dialog)
+  puts "[#{dialog.type}] #{dialog.message}"
+  if dialog.message =~ /foo/
+    dialog.accept
+  else
+    dialog.dismiss
+  end
+end
+
+page.on("dialog", method(:handle_dialog))
+page.evaluate("confirm('foo')") # will be accepted
+# => [confirm] foo
+page.evaluate("alert('bar')") # will be dismissed
+# => [alert] bar
+```
+
+**NOTE**: Dialogs are dismissed automatically, unless there is a [`event: Page.dialog`] listener.
+When listener is present, it **must** either [Dialog#accept](./dialog#accept) or [Dialog#dismiss](./dialog#dismiss) the dialog - otherwise the page will [freeze](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop#never_blocking) waiting for the dialog, and actions like click will never finish.
+
+## accept
+
+```
+def accept(promptText: nil)
+```
+
+
+Returns when the dialog has been accepted.
+
+## default_value
+
+```
+def default_value
+```
+
+
+If dialog is prompt, returns default prompt value. Otherwise, returns empty string.
+
+## dismiss
+
+```
+def dismiss
+```
+
+
+Returns when the dialog has been dismissed.
+
+## message
+
+```
+def message
+```
+
+
+A message displayed in the dialog.
+
+## page
+
+```
+def page
+```
+
+
+The page that initiated this dialog, if available.
+
+## type
+
+```
+def type
+```
+
+
+Returns dialog's type, can be one of `alert`, `beforeunload`, `confirm` or `prompt`.

data/documentation/docs/api/download.md

@@ -0,0 +1,111 @@
+---
+sidebar_position: 10
+---
+
+# Download
+
+
+[Download](./download) objects are dispatched by page via the [`event: Page.download`] event.
+
+All the downloaded files belonging to the browser context are deleted when the
+browser context is closed.
+
+Download event is emitted once the download starts. Download path becomes available once download completes.
+
+```ruby
+download = page.expect_download do
+  page.get_by_text("Download file").click
+end
+
+# Wait for the download process to complete and save the downloaded file somewhere
+path = File.join(download_dir, download.suggested_filename)
+download.save_as(path)
+
+path
+```
+
+## cancel
+
+```
+def cancel
+```
+
+
+Cancels a download. Will not fail if the download is already finished or canceled.
+Upon successful cancellations, `download.failure()` would resolve to `'canceled'`.
+
+## delete
+
+```
+def delete
+```
+
+
+Deletes the downloaded file. Will wait for the download to finish if necessary.
+
+## failure
+
+```
+def failure
+```
+
+
+Returns download error if any. Will wait for the download to finish if necessary.
+
+## page
+
+```
+def page
+```
+
+
+Get the page that the download belongs to.
+
+## path
+
+```
+def path
+```
+
+
+Returns path to the downloaded file for a successful download, or throws for a failed/canceled download. The method will wait for the download to finish if necessary. The method throws when connected remotely.
+
+Note that the download's file name is a random GUID, use [Download#suggested_filename](./download#suggested_filename)
+to get suggested file name.
+
+## save_as
+
+```
+def save_as(path)
+```
+
+
+Copy the download to a user-specified path. It is safe to call this method while the download
+is still in progress. Will wait for the download to finish if necessary.
+
+**Usage**
+
+```ruby
+download.save_as(File.join(download_dir, download.suggested_filename))
+```
+
+## suggested_filename
+
+```
+def suggested_filename
+```
+
+
+Returns suggested filename for this download. It is typically computed by the browser from the
+[`Content-Disposition`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Disposition) response header
+or the `download` attribute. See the spec on [whatwg](https://html.spec.whatwg.org/#downloading-resources). Different
+browsers can use different logic for computing it.
+
+## url
+
+```
+def url
+```
+
+
+Returns downloaded url.