playwright-ruby-client 0.6.3 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 77f49d82e8b6b94210f79ee9e031dcfb73072a11da4c366626ad3bcf3e18bfa9
-  data.tar.gz: '098cbff788ed38a7647de0271d6f3c38a757e3c750ebf8aaa3f96dccbb626921'
+  metadata.gz: d8e3e3982a30add91ed67641a29dcff9778c40788c8434d2ef581cb926951968
+  data.tar.gz: bc7c51236c2d9c2632c53dfe25ae7f9f357c1118a434bb1c41f735a0c67c7625
 SHA512:
-  metadata.gz: 46997fb7eff8b747560a6f8658bc2b50cbeb2a489f75ed716ccfb84fc8dfddea171bbd4812dc897840507c7d9267e1c81e9f79ae05679ccece322dff7c8adc8b
-  data.tar.gz: 134a0003575cbe1501af23dad3a2f706cf9a961a8c067a858ecd25e61fe7a20f018d382d8d38be40c5aaa0c603dd0b1d02bd62b674405bfa5b5e130cf8593196
+  metadata.gz: b438126a715d3c427408fb4d0b13483bb6f96444cb9c359a946da70125f00b0eee488e5753493a5f9e37ff1294209fd58a044721e0c7b0b2e5c06ef2a8611aef
+  data.tar.gz: a13605776cfca08333630a2e18cf53035d71b6b0ea454a27f76bf0562ef1d505844c70b1119bdca2c2cfd400d402d2c62e06fe38d53abf561c005b6127900c83

data/documentation/docs/api/browser.md

@@ -61,6 +61,16 @@ def connected?
 
 Indicates that the browser is connected.
 
+## new_browser_cdp_session
+
+```
+def new_browser_cdp_session
+```
+
+> NOTE: CDP Sessions are only supported on Chromium-based browsers.
+
+Returns the newly created browser session.
+
 ## new_context
 
 ```
@@ -138,7 +148,8 @@ def new_page(
       storageState: nil,
       timezoneId: nil,
       userAgent: nil,
-      viewport: nil)
+      viewport: nil,
+      &block)
 ```
 
 Creates a new page in a new browser context. Closing this page will close the context as well.

data/documentation/docs/api/browser_context.md

@@ -226,10 +226,20 @@ def grant_permissions(permissions, origin: nil)
 Grants specified permissions to the browser context. Only grants corresponding permissions to the given origin if
 specified.
 
+## new_cdp_session
+
+```
+def new_cdp_session(page)
+```
+
+> NOTE: CDP sessions are only supported on Chromium-based browsers.
+
+Returns the newly created session.
+
 ## new_page
 
 ```
-def new_page
+def new_page(&block)
 ```
 
 Creates a new page in the browser context.

data/documentation/docs/api/browser_type.md

@@ -65,7 +65,7 @@ def launch(
       proxy: nil,
       slowMo: nil,
       timeout: nil,
-      traceDir: nil,
+      tracesDir: nil,
       &block)
 ```
 
@@ -96,6 +96,59 @@ differences between Chromium and Chrome.
 [This article](https://chromium.googlesource.com/chromium/src/+/lkgr/docs/chromium_browser_vs_google_chrome.md)
 describes some differences for Linux users.
 
+## launch_persistent_context
+
+```
+def launch_persistent_context(
+      userDataDir,
+      acceptDownloads: nil,
+      args: nil,
+      bypassCSP: nil,
+      channel: nil,
+      chromiumSandbox: nil,
+      colorScheme: nil,
+      deviceScaleFactor: nil,
+      devtools: nil,
+      downloadsPath: nil,
+      env: nil,
+      executablePath: nil,
+      extraHTTPHeaders: nil,
+      geolocation: nil,
+      handleSIGHUP: nil,
+      handleSIGINT: nil,
+      handleSIGTERM: nil,
+      hasTouch: nil,
+      headless: nil,
+      httpCredentials: nil,
+      ignoreDefaultArgs: nil,
+      ignoreHTTPSErrors: nil,
+      isMobile: nil,
+      javaScriptEnabled: nil,
+      locale: nil,
+      noViewport: nil,
+      offline: nil,
+      permissions: nil,
+      proxy: nil,
+      record_har_omit_content: nil,
+      record_har_path: nil,
+      record_video_dir: nil,
+      record_video_size: nil,
+      reducedMotion: nil,
+      screen: nil,
+      slowMo: nil,
+      timeout: nil,
+      timezoneId: nil,
+      tracesDir: nil,
+      userAgent: nil,
+      viewport: nil,
+      &block)
+```
+
+Returns the persistent browser context instance.
+
+Launches browser that uses persistent storage located at `userDataDir` and returns the only context. Closing this
+context will automatically close the browser.
+
 ## name
 
 ```

data/documentation/docs/api/cdp_session.md

@@ -4,4 +4,44 @@ sidebar_position: 10
 
 # CDPSession
 
-Not Implemented
+- extends: [EventEmitter]
+
+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/experimental/android.md

@@ -4,14 +4,15 @@ sidebar_position: 10
 
 # Android
 
-Playwright has **experimental** support for Android automation. You can access android namespace via:
+Playwright has **experimental** support for Android automation. See [here](https://playwright.dev/python/docs/mobile) for more information. You can
+access android namespace via:
 
 An example of the Android automation script would be:
 
 Note that since you don't need Playwright to install web browsers when testing Android, you can omit browser download
 via setting the following environment variable when installing Playwright:
 
-```sh js
+```bash js
 PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD=1 npm i -D playwright
 ```
 

data/documentation/docs/api/page.md

@@ -1328,6 +1328,16 @@ puts request.headers
 
 
 
+## expect_request_finished
+
+```
+def expect_request_finished(predicate: nil, timeout: nil, &block)
+```
+
+Performs action and waits for a [Request](./request) to finish loading. If predicate is provided, it passes [Request](./request) value into
+the `predicate` function and waits for `predicate(request)` to return a truthy value. Will throw an error if the page is
+closed before the [`event: Page.requestFinished`] event is fired.
+
 ## expect_response
 
 ```
@@ -1393,6 +1403,14 @@ page.wait_for_url("**/target.html")
 
 Shortcut for main frame's [Frame#wait_for_url](./frame#wait_for_url).
 
+## expect_websocket
+
+```
+def expect_websocket(predicate: nil, timeout: nil, &block)
+```
+
+Performs action and waits for a new [WebSocket](./web_socket). If predicate is provided, it passes [WebSocket](./web_socket) value into the `predicate` function and waits for `predicate.call(web_socket)` to return a truthy value. Will throw an error if the page is closed before the WebSocket event is fired.
+
 ## accessibility
 
 ## keyboard

data/documentation/docs/api/route.md

@@ -23,18 +23,16 @@ 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)
-
+```ruby
+def handle(route, request)
+  # override headers
+  headers = request.headers
+  headers['foo'] = 'bar' # set "foo" header
+  headers['user-agent'] = 'Unknown Browser' # modify user-agent
+
+  route.continue(headers: headers)
+end
+page.route("**/*", method(:handle))
 ```
 
 
@@ -54,19 +52,20 @@ 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!"))
-
+```ruby
+page.route("**/*", ->(route, request) {
+  route.fulfill(
+    status: 404,
+    contentType: '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"))
-
+```ruby
+page.route("**/xhr_endpoint", ->(route, _) { route.fulfill(path: "mock_data.json") })
 ```
 
 

data/documentation/docs/api/tracing.md

@@ -9,24 +9,16 @@ Playwright script runs.
 
 Start with specifying the folder traces will be stored in:
 
-```python sync title=example_b375e389cd6685ec49d1ef57f3186da60ef682785c646fe8db351b6f39b1a34c.py
-browser = chromium.launch(traceDir='traces')
+```python sync title=example_a767dfb400d98aef50f2767b94171d23474ea1ac1cf9b4d75d412936208e652d.py
+browser = chromium.launch()
 context = browser.new_context()
-context.tracing.start(name="trace", screenshots=True, snapshots=True)
+context.tracing.start(screenshots=True, snapshots=True)
 page.goto("https://playwright.dev")
-context.tracing.stop()
-context.tracing.export("trace.zip")
+context.tracing.stop(path = "trace.zip")
 
 ```
 
 
-## export
-
-```
-def export(path)
-```
-
-Export trace into the file with the given name. Should be called after the tracing has stopped.
 
 ## start
 
@@ -36,19 +28,20 @@ def start(name: nil, screenshots: nil, snapshots: nil)
 
 Start tracing.
 
-```python sync title=example_4c72a858b35ec7bd7aaba231cb93acecb7ee4b7ea8048a534f28f7e16af966b8.py
+```python sync title=example_e611abc8b1066118d0c87eae1bbbb08df655f36d50a94402fc56b8713150997b.py
 context.tracing.start(name="trace", screenshots=True, snapshots=True)
 page.goto("https://playwright.dev")
 context.tracing.stop()
-context.tracing.export("trace.zip")
+context.tracing.stop(path = "trace.zip")
 
 ```
 
 
+
 ## stop
 
 ```
-def stop
+def stop(path: nil)
 ```
 
 Stop tracing.

data/documentation/docs/api/web_socket.md

@@ -4,4 +4,41 @@ sidebar_position: 10
 
 # WebSocket
 
-Not Implemented
+The [WebSocket](./web_socket) class represents websocket connections in the page.
+
+## closed?
+
+```
+def closed?
+```
+
+Indicates that the web socket has been closed.
+
+## url
+
+```
+def url
+```
+
+Contains the URL of the WebSocket.
+
+## expect_event
+
+```
+def expect_event(event, predicate: nil, timeout: nil, &block)
+```
+
+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.
+
+## wait_for_event
+
+```
+def wait_for_event(event, predicate: nil, timeout: nil, &block)
+```
+
+> NOTE: In most cases, you should use [WebSocket#wait_for_event](./web_socket#wait_for_event).
+
+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.

data/documentation/docs/article/guides/launch_browser.md

@@ -117,3 +117,5 @@ Playwright.create(playwright_cli_executable_path: 'npx playwright') do |playwrig
   end
 end
 ```
+
+Note that each browser context is isolated and not persisted by default. When persistent browser context is needed, we can use [BrowserType#launch_persistent_context](/docs/api/browser_type#launch_persistent_context).

data/documentation/docs/article/guides/rails_integration.md

@@ -41,7 +41,7 @@ Capybara.default_max_wait_time = 15
 
 ### (Optional) Update default driver
 
-By default, Capybara driver is set to `:rack_test`, which works only with non-JS contents. If your Rails application has many JavaScript contents, it is recommended to change the default driver to `:playwrite`.
+By default, Capybara driver is set to `:rack_test`, which works only with non-JS contents. If your Rails application has many JavaScript contents, it is recommended to change the default driver to `:playwright`.
 
 ```rb
 Capybara.default_driver = :playwright
@@ -155,8 +155,51 @@ end
 
 Generally, Capybara DSL seems simple, but Playwright-native scripting are more precise and efficient. Also `waitForNavigation`, `waitForSelector`, and many other Playwright functions are available with Playwright-native scripting.
 
+### Screen recording
+
+NO NEED to keep sitting in front of screen during test. Just record what happened with video.
+
+For example, we can store the video for [Allure report](https://github.com/allure-framework/allure-ruby) as below:
+
+```ruby
+before do |example|
+  Capybara.current_session.driver.on_save_screenrecord do |video_path|
+    Allure.add_attachment(
+      name: "screenrecord - #{example.description}",
+      source: File.read(video_path),
+      type: Allure::ContentType::WEBM,
+      test_case: true,
+    )
+  end
+end
+```
+
+![sceenrecord](https://user-images.githubusercontent.com/11763113/121126629-71b5f600-c863-11eb-8f88-7924ab669946.gif)
+
+For more details, refer [Recording video](./recording_video.md#using-screen-recording-from-capybara-driver)
+
+
+### Screenshot just before teardown
+
+In addition to `Capybara::Session#save_screenshot`, capybara-playwright-driver have another method for storing last screen state just before teardown.
+
+For example, we can attach the screenshot for [Allure report](https://github.com/allure-framework/allure-ruby) as below:
+
+```ruby
+before do |example|
+  Capybara.current_session.driver.on_save_raw_screenshot_before_reset do |raw_screenshot|
+    Allure.add_attachment(
+      name: "screenshot - #{example.description}",
+      source: raw_screenshot,
+      type: Allure::ContentType::PNG,
+      test_case: true,
+    )
+  end
+end
+```
+
 ### Limitations
 
 * Playwright doesn't allow clicking invisible DOM elements or moving elements. `click` sometimes doesn't work as Selenium does. See the detail in https://playwright.dev/docs/actionability/
 * `current_window.maximize` and `current_window.fullscreen` work only on headful (non-headless) mode, as selenium driver does.
-* `Capybara::Node::Element#drag_to` does not accept `html5` parameter, since [Playwright doesn't implement the feature yet](https://github.com/microsoft/playwright/pull/6207).
+* `Capybara::Node::Element#drag_to` does not accept `html5` parameter. HTML5 drag and drop is not fully supported in Playwright.