playwright-ruby-client 0.6.0 → 0.6.1

data/documentation/docs/api/playwright.md

@@ -0,0 +1,63 @@
+---
+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 [Working with selectors](https://playwright.dev/python/docs/selectors) 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,188 @@
+---
+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.
+
+## failure
+
+```
+def failure
+```
+
+The method returns `null` unless this request has failed, as reported by `requestfailed` event.
+
+Example of logging of all the failed requests:
+
+```py title=example_5f3f4534ab17f584cfd41ca38448ce7de9490b6588e29e73116ede3cb15a25a5.py
+page.on("requestfailed", lambda request: print(request.url + " " + request.failure))
+
+```
+
+
+
+## frame
+
+```
+def frame
+```
+
+Returns the [Frame](./frame) that initiated this request.
+
+## headers
+
+```
+def headers
+```
+
+An object with HTTP headers associated with the request. All header names are lower-case.
+
+## navigation_request?
+
+```
+def navigation_request?
+```
+
+Whether this request is driving frame's navigation.
+
+## 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
+`redirectedFrom()` and `redirectedTo()` methods. When multiple server redirects has happened, it is possible to
+construct the whole redirect chain by repeatedly calling `redirectedFrom()`.
+
+For example, if the website `http://example.com` redirects to `https://example.com`:
+
+```python sync title=example_89568fc86bf623eef37b68c6659b1a8524647c8365bb32a7a8af63bd86111075.py
+response = page.goto("http://example.com")
+print(response.request.redirected_from.url) # "http://example.com"
+
+```
+
+If the website `https://google.com` has no redirects:
+
+```python sync title=example_6d7b3fbf8d69dbe639b71fedc5a8977777fca29dfb16d38012bb07c496342472.py
+response = page.goto("https://google.com")
+print(response.request.redirected_from) # None
+
+```
+
+
+
+## redirected_to
+
+```
+def redirected_to
+```
+
+New request issued by the browser if the server responded with redirect.
+
+This method is the opposite of [Request#redirected_from](./request#redirected_from):
+
+```py title=example_922623f4033e7ec2158787e54a8554655f7e1e20a024e4bf4f69337f781ab88a.py
+assert request.redirected_from.redirected_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.
+
+## 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).
+
+```python sync title=example_e2a297fe95fd0699b6a856c3be2f28106daa2615c0f4d6084f5012682a619d20.py
+with page.expect_event("requestfinished") as request_info:
+    page.goto("http://example.com")
+request = request_info.value
+print(request.timing)
+
+```
+
+
+
+## url
+
+```
+def url
+```
+
+URL of the request.

data/documentation/docs/api/response.md

@@ -0,0 +1,97 @@
+---
+sidebar_position: 10
+---
+
+# Response
+
+[Response](./response) class represents responses which are received by page.
+
+## body
+
+```
+def body
+```
+
+Returns the buffer with response body.
+
+## finished
+
+```
+def finished
+```
+
+Waits for this response to finish, returns failure error if request failed.
+
+## frame
+
+```
+def frame
+```
+
+Returns the [Frame](./frame) that initiated this response.
+
+## headers
+
+```
+def headers
+```
+
+Returns the object with HTTP headers associated with the response. All header names are lower-case.
+
+## 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.
+
+## 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.

data/documentation/docs/api/route.md

@@ -0,0 +1,80 @@
+---
+sidebar_position: 10
+---
+
+# Route
+
+Whenever a network route is set up with [Page#route](./page#route) or [BrowserContext#route](./browser_context#route), the [Route](./route) object
+allows to handle the route.
+
+## abort
+
+```
+def abort(errorCode: nil)
+```
+
+Aborts the route's request.
+
+## continue
+
+```
+def continue(headers: nil, method: nil, postData: nil, url: nil)
+```
+
+Continues route's request with optional overrides.
+
+```python sync title=example_1960aabd58c9553683368e29429d39c1209d35e6e3625bbef1280a1fa022a9ee.py
+def handle(route, request):
+    # override headers
+    headers = {
+        **request.headers,
+        "foo": "bar" # set "foo" header
+        "origin": None # remove "origin" header
+    }
+    route.continue_(headers=headers)
+}
+page.route("**/*", handle)
+
+```
+
+
+
+## fulfill
+
+```
+def fulfill(
+      body: nil,
+      contentType: nil,
+      headers: nil,
+      path: nil,
+      status: nil)
+```
+
+Fulfills route's request with given response.
+
+An example of fulfilling all requests with 404 responses:
+
+```python sync title=example_6d2dfd4bb5c8360f8d80bb91c563b0bd9b99aa24595063cf85e5a6e1b105f89c.py
+page.route("**/*", lambda route: route.fulfill(
+    status=404,
+    content_type="text/plain",
+    body="not found!"))
+
+```
+
+An example of serving static file:
+
+```python sync title=example_c77fd0986d0b74c905cd9417756c76775e612cc86410f9a5aabc5b46d233d150.py
+page.route("**/xhr_endpoint", lambda route: route.fulfill(path="mock_data.json"))
+
+```
+
+
+
+## request
+
+```
+def request
+```
+
+A request to be routed.

data/documentation/docs/api/selectors.md

@@ -0,0 +1,23 @@
+---
+sidebar_position: 10
+---
+
+# Selectors
+
+Selectors can be used to install custom selector engines. See [Working with selectors](https://playwright.dev/python/docs/selectors) for more
+information.
+
+## register
+
+```
+def register(name, contentScript: nil, path: nil, script: nil)
+```
+
+An example of registering selector engine that queries elements based on a tag name:
+
+```python sync title=example_49f0cb9b5a21d0d5fe2b180c847bdb21068b335b4c2f42d5c05eb1957297899f.py
+# FIXME: add snippet
+
+```
+
+