playwright-ruby-client 0.0.8 → 1.58.1.alpha1

data/documentation/docs/api/page_assertions.md

@@ -0,0 +1,65 @@
+---
+sidebar_position: 10
+---
+
+# PageAssertions
+
+
+The [PageAssertions](./page_assertions) class provides assertion methods that can be used to make assertions about the [Page](./page) state in the tests.
+
+```ruby
+page.content = <<~HTML
+<a href="https://example.com/user/login">Sign in</a>
+HTML
+
+page.get_by_text("Sign in").click
+expect(page).to have_url(/.*\/login/)
+```
+
+## not_to_have_title
+
+```
+def not_to_have_title(titleOrRegExp, timeout: nil)
+```
+
+
+The opposite of [PageAssertions#to_have_title](./page_assertions#to_have_title).
+
+## not_to_have_url
+
+```
+def not_to_have_url(urlOrRegExp, ignoreCase: nil, timeout: nil)
+```
+
+
+The opposite of [PageAssertions#to_have_url](./page_assertions#to_have_url).
+
+## to_have_title
+
+```
+def to_have_title(titleOrRegExp, timeout: nil)
+```
+
+
+Ensures the page has the given title.
+
+**Usage**
+
+```ruby
+expect(page).to have_title(/.*checkout/)
+```
+
+## to_have_url
+
+```
+def to_have_url(urlOrRegExp, ignoreCase: nil, timeout: nil)
+```
+
+
+Ensures the page is navigated to the given URL.
+
+**Usage**
+
+```ruby
+expect(page).to have_url(/.*checkout/)
+```

data/documentation/docs/api/playwright.md

@@ -0,0 +1,66 @@
+---
+sidebar_position: 10
+---
+
+# Playwright
+
+
+Playwright module provides a method to launch a browser instance. The following is a typical example of using Playwright
+to drive automation:
+
+```ruby
+require 'playwright'
+
+Playwright.create(playwright_cli_executable_path: 'npx playwright') do |playwright|
+  chromium = playwright.chromium # or "firefox" or "webkit".
+  chromium.launch do |browser|
+    page = browser.new_page
+    page.goto('https://example.com/')
+
+    # other actions
+
+  end
+end
+```
+
+## chromium
+
+
+This object can be used to launch or connect to Chromium, returning instances of [Browser](./browser).
+
+## devices
+
+
+Returns a dictionary of devices to be used with [Browser#new_context](./browser#new_context) or [Browser#new_page](./browser#new_page).
+
+```ruby
+require 'playwright'
+
+Playwright.create(playwright_cli_executable_path: 'npx playwright') do |playwright|
+  iphone = playwright.devices["iPhone 6"]
+  playwright.webkit.launch do |browser|
+    context = browser.new_context(**iphone)
+    page = context.new_page
+    page.goto('https://example.com/')
+
+    # other actions
+
+  end
+end
+```
+
+## firefox
+
+
+This object can be used to launch or connect to Firefox, returning instances of [Browser](./browser).
+
+## selectors
+
+
+Selectors can be used to install custom selector engines. See
+[extensibility](https://playwright.dev/python/docs/extensibility) for more information.
+
+## webkit
+
+
+This object can be used to launch or connect to WebKit, returning instances of [Browser](./browser).

data/documentation/docs/api/request.md

@@ -0,0 +1,255 @@
+---
+sidebar_position: 10
+---
+
+# Request
+
+
+Whenever the page sends a request for a network resource the following sequence of events are emitted by [Page](./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.
+- [`event: Page.requestFinished`] emitted when the response body is downloaded and the request is complete.
+
+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.
+
+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.
+
+## all_headers
+
+```
+def all_headers
+```
+
+
+An object with all the request HTTP headers associated with this request. The header names are lower-cased.
+
+## failure
+
+```
+def failure
+```
+
+
+The method returns `null` unless this request has failed, as reported by `requestfailed` event.
+
+**Usage**
+
+Example of logging of all the failed requests:
+
+```ruby
+page.on("requestfailed", ->(request) { puts "#{request.url} #{request.failure}" })
+```
+
+## frame
+
+```
+def frame
+```
+
+
+Returns the [Frame](./frame) that initiated this request.
+
+**Usage**
+
+```ruby
+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 [Request#navigation_request?](./request#navigation_request?) to check that.
+
+Here is an example that handles all the cases:
+
+## headers
+
+```
+def headers
+```
+
+
+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 [Request#all_headers](./request#all_headers) for complete list of headers that include `cookie` information.
+
+## headers_array
+
+```
+def headers_array
+```
+
+
+An array with all the request HTTP headers associated with this request. Unlike [Request#all_headers](./request#all_headers), header names are NOT lower-cased.
+Headers with multiple entries, such as `Set-Cookie`, appear in the array multiple times.
+
+## header_value
+
+```
+def header_value(name)
+```
+
+
+Returns the value of the header matching the name. The name is case-insensitive.
+
+## navigation_request?
+
+```
+def navigation_request?
+```
+
+
+Whether this request is driving frame's navigation.
+
+Some navigation requests are issued before the corresponding frame is created, and therefore
+do not have [Request#frame](./request#frame) available.
+
+## method
+
+```
+def method
+```
+
+
+Request's method (GET, POST, etc.)
+
+## post_data
+
+```
+def post_data
+```
+
+
+Request's post body, if any.
+
+## post_data_buffer
+
+```
+def post_data_buffer
+```
+
+
+Request's post body in a binary form, if any.
+
+## post_data_json
+
+```
+def post_data_json
+```
+
+
+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.
+Otherwise it will be parsed as JSON.
+
+## redirected_from
+
+```
+def redirected_from
+```
+
+
+Request that was redirected by the server to this one, if any.
+
+When the server responds with a redirect, Playwright creates a new [Request](./request) object. The two requests are connected by
+[redirected_from](./request#redirected_from) and [redirected_to](./request#redirected_to) methods. When multiple server redirects has happened, it is possible to
+construct the whole redirect chain by repeatedly calling [redirected_from](./request#redirected_from).
+
+**Usage**
+
+For example, if the website `http://github.com` redirects to `https://github.com`:
+
+```ruby
+response = page.goto("http://github.com")
+puts response.url # => "https://github.com"
+puts response.request.redirected_from&.url # => "http://github.com"
+```
+
+If the website `https://google.com` has no redirects:
+
+```ruby
+response = page.goto("https://google.com")
+puts response.request.redirected_from&.url # => nil
+```
+
+## redirected_to
+
+```
+def redirected_to
+```
+
+
+New request issued by the browser if the server responded with redirect.
+
+**Usage**
+
+This method is the opposite of [Request#redirected_from](./request#redirected_from):
+
+```ruby
+request.redirected_from.redirected_to # equals to request
+```
+
+## resource_type
+
+```
+def resource_type
+```
+
+
+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`.
+
+## response
+
+```
+def response
+```
+
+
+Returns the matching [Response](./response) object, or `null` if the response was not received due to error.
+
+## sizes
+
+```
+def sizes
+```
+
+
+Returns resource size information for given request.
+
+## timing
+
+```
+def timing
+```
+
+
+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**
+
+```ruby
+request = page.expect_event("requestfinished") do
+  page.goto("https://example.com")
+end
+puts request.timing
+```
+
+## url
+
+```
+def url
+```
+
+
+URL of the request.

data/documentation/docs/api/response.md

@@ -0,0 +1,176 @@
+---
+sidebar_position: 10
+---
+
+# Response
+
+
+[Response](./response) class represents responses which are received by page.
+
+## all_headers
+
+```
+def all_headers
+```
+
+
+An object with all the response HTTP headers associated with this response.
+
+## body
+
+```
+def body
+```
+
+
+Returns the buffer with response body.
+
+## finished
+
+```
+def finished
+```
+
+
+Waits for this response to finish, returns always `null`.
+
+## frame
+
+```
+def frame
+```
+
+
+Returns the [Frame](./frame) that initiated this response.
+
+## from_service_worker
+
+```
+def from_service_worker
+```
+
+
+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)).
+
+## headers
+
+```
+def headers
+```
+
+
+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 [Response#all_headers](./response#all_headers) for complete list of headers that include `cookie` information.
+
+## headers_array
+
+```
+def headers_array
+```
+
+
+An array with all the request HTTP headers associated with this response. Unlike [Response#all_headers](./response#all_headers), header names are NOT lower-cased.
+Headers with multiple entries, such as `Set-Cookie`, appear in the array multiple times.
+
+## header_value
+
+```
+def header_value(name)
+```
+
+
+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.
+
+## header_values
+
+```
+def header_values(name)
+```
+
+
+Returns all values of the headers matching the name, for example `set-cookie`. The name is case-insensitive.
+
+## json
+
+```
+def json
+```
+
+
+Returns the JSON representation of response body.
+
+This method will throw if the response body is not parsable via `JSON.parse`.
+
+## ok
+
+```
+def ok
+```
+
+
+Contains a boolean stating whether the response was successful (status in the range 200-299) or not.
+
+## request
+
+```
+def request
+```
+
+
+Returns the matching [Request](./request) object.
+
+## security_details
+
+```
+def security_details
+```
+
+
+Returns SSL and other security information.
+
+## server_addr
+
+```
+def server_addr
+```
+
+
+Returns the IP address and port of the server.
+
+## status
+
+```
+def status
+```
+
+
+Contains the status code of the response (e.g., 200 for a success).
+
+## status_text
+
+```
+def status_text
+```
+
+
+Contains the status text of the response (e.g. usually an "OK" for a success).
+
+## text
+
+```
+def text
+```
+
+
+Returns the text representation of response body.
+
+## url
+
+```
+def url
+```
+
+
+Contains the URL of the response.