playwright-ruby-client 0.9.0 → 1.14.0

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

@@ -0,0 +1,78 @@
+---
+sidebar_position: 6
+---
+
+# Reuse Cookie and LocalStorage
+
+In most cases, authentication state is stored in cookie or local storage. When we just want to keep authenticated, it is a good solution to dump/load 'storage state' (= Cookie + LocalStorage).
+https://playwright.dev/docs/next/auth#reuse-authentication-state
+
+* Dump storage state using [BrowserContext#storage_state](/docs/api/browser_context#storage_state) with `path: /path/to/state.json`
+* Load storage state by specifying the parameter `storageState: /path/to/state.json` into [Browser#new_context](/docs/api/browser#new_context) or [Browser#new_page](/docs/api/browser#new_page)
+
+## Example
+
+Generally in browser automation, it is very difficult to bypass 2FA or reCAPTCHA in login screen. In such cases, we would consider
+
+* Authenticate manually by hand
+* Resume automation with the authentication result
+
+
+```ruby {16,21}
+require 'playwright'
+require 'pry'
+
+force_login = !File.exist?('github_state.json')
+
+Playwright.create(playwright_cli_executable_path: 'npx playwright') do |playwright|
+  if force_login
+    # Use headful mode for manual operation.
+    playwright.chromium.launch(headless: false, channel: 'chrome') do |browser|
+      page = browser.new_page
+      page.goto('https://github.com/login')
+
+      # Login manually.
+      binding.pry
+
+      page.context.storage_state(path: 'github_state.json')
+    end
+  end
+
+  playwright.chromium.launch do |browser|
+    page = browser.new_page(storageState: 'github_state.json')
+    page.goto('https://github.com/notifications')
+    page.screenshot(path: 'github_notification.png')
+  end
+end
+```
+
+When we execute this script at the first time (without github_state.json), login screen is shown:
+
+![login screen is shown](https://user-images.githubusercontent.com/11763113/129394130-7a248f6a-56f0-40b0-a4dd-f0f65d71b3a9.png)
+
+and input credentials manually:
+
+![input credentials manually](https://user-images.githubusercontent.com/11763113/129394155-fccc280e-5e6b-46c7-8a4d-a99d7db02c7f.png)
+
+and hit `exit` in Pry console.
+
+```
+
+     9:
+    10:     # Login manually. Hit `exit` in Pry console after authenticated.
+    11:     require 'pry'
+    12:     binding.pry
+    13:
+ => 14:     page.context.storage_state(path: 'github_state.json')
+    15:   end if force_login
+    16:
+    17:   playwright.chromium.launch do |browser|
+    18:     page = browser.new_page(storageState: 'github_state.json')
+    19:     page.goto('https://github.com/notifications')
+
+[1] pry(main)> exit
+```
+
+then we can enjoy automation with keeping authenticated. Login screen is never shown until github_state.json is deleted :)
+
+![github_notification.png](https://user-images.githubusercontent.com/11763113/129394879-838797eb-135f-41ab-b965-8d6fabde6109.png)

data/documentation/docs/include/api_coverage.md

@@ -65,7 +65,7 @@
 
 ## Touchscreen
 
-* ~~tap_point~~
+* tap_point
 
 ## JSHandle
 
@@ -116,9 +116,9 @@
 * wait_for_element_state
 * wait_for_selector
 
-## ~~Accessibility~~
+## Accessibility
 
-* ~~snapshot~~
+* snapshot
 
 ## FileChooser
 
@@ -178,14 +178,14 @@
 * wait_for_load_state
 * expect_navigation
 * wait_for_selector
-* ~~wait_for_timeout~~
+* wait_for_timeout
 * wait_for_url
 
 ## Worker
 
-* ~~evaluate~~
-* ~~evaluate_handle~~
-* ~~url~~
+* evaluate
+* evaluate_handle
+* url
 
 ## Selectors
 
@@ -296,11 +296,11 @@
 * expect_request_finished
 * expect_response
 * wait_for_selector
-* ~~wait_for_timeout~~
+* wait_for_timeout
 * wait_for_url
 * expect_websocket
-* ~~expect_worker~~
-* ~~workers~~
+* expect_worker
+* workers
 * ~~wait_for_event~~
 * accessibility
 * keyboard
@@ -311,7 +311,7 @@
 
 * add_cookies
 * add_init_script
-* ~~background_pages~~
+* background_pages
 * browser
 * clear_cookies
 * clear_permissions
@@ -324,13 +324,13 @@
 * new_page
 * pages
 * route
-* ~~service_workers~~
+* service_workers
 * set_default_navigation_timeout
 * set_default_timeout
 * set_extra_http_headers
 * set_geolocation
 * set_offline
-* ~~storage_state~~
+* storage_state
 * unroute
 * expect_event
 * expect_page

data/lib/playwright/accessibility_impl.rb

@@ -0,0 +1,50 @@
+module Playwright
+  define_api_implementation :AccessibilityImpl do
+    def initialize(channel)
+      @channel = channel
+    end
+
+    def snapshot(interestingOnly: nil, root: nil)
+      params = {
+        interestingOnly: interestingOnly,
+        root: root&.channel,
+      }.compact
+      result = @channel.send_message_to_server('accessibilitySnapshot', params)
+      format_ax_node_from_protocol(result) if result
+      result
+    end
+
+    # original JS implementation create a new Hash from ax_node,
+    # but this implementation directly modify ax_node and don't return hash.
+    private def format_ax_node_from_protocol(ax_node)
+      value = ax_node.delete('valueNumber') || ax_node.delete('valueString')
+      ax_node['value'] = value unless value.nil?
+
+      checked =
+        case ax_node['checked']
+        when 'checked'
+          true
+        when 'unchecked'
+          false
+        else
+          ax_node['checked']
+        end
+      ax_node['checked'] = checked unless checked.nil?
+
+      pressed =
+        case ax_node['pressed']
+        when 'pressed'
+          true
+        when 'released'
+          false
+        else
+          ax_node['pressed']
+        end
+      ax_node['pressed'] = pressed unless pressed.nil?
+
+      ax_node['children']&.each do |child|
+        format_ax_node_from_protocol(child)
+      end
+    end
+  end
+end

data/lib/playwright/channel_owners/browser_context.rb

@@ -11,6 +11,8 @@ module Playwright
       @routes = []
       @bindings = {}
       @timeout_settings = TimeoutSettings.new
+      @service_workers = Set.new
+      @background_pages = Set.new
 
       @tracing = TracingImpl.new(@channel, self)
       @channel.on('bindingCall', ->(params) { on_binding(ChannelOwners::BindingCall.from(params['binding'])) })
@@ -19,6 +21,12 @@ module Playwright
       @channel.on('route', ->(params) {
         on_route(ChannelOwners::Route.from(params['route']), ChannelOwners::Request.from(params['request']))
       })
+      @channel.on('backgroundPage', ->(params) {
+        on_background_page(ChannelOwners::Page.from(params['page']))
+      })
+      @channel.on('serviceWorker', ->(params) {
+        on_service_worker(ChannelOwners::Worker.from(params['worker']))
+      })
       @channel.on('request', ->(params) {
         on_request(
           ChannelOwners::Request.from(params['request']),
@@ -56,6 +64,11 @@ module Playwright
       page.send(:emit_popup_event_from_browser_context)
     end
 
+    private def on_background_page(page)
+      @background_pages << page
+      emit(Events::BrowserContext::BackgroundPage, page)
+    end
+
     private def on_route(route, request)
       # It is not desired to use PlaywrightApi.wrap directly.
       # However it is a little difficult to define wrapper for `handler` parameter in generate_api.
@@ -98,6 +111,20 @@ module Playwright
       page&.emit(Events::Page::Response, response)
     end
 
+    private def on_service_worker(worker)
+      worker.context = self
+      @service_workers << worker
+      emit(Events::BrowserContext::ServiceWorker, worker)
+    end
+
+    def background_pages
+      @background_pages.to_a
+    end
+
+    def service_workers
+      @service_workers.to_a
+    end
+
     def new_cdp_session(page)
       resp = @channel.send_message_to_server('newCDPSession', page: page.channel)
       ChannelOwners::CDPSession.from(resp)
@@ -279,6 +306,16 @@ module Playwright
       @channel.send_message_to_server('pause')
     end
 
+    def storage_state(path: nil)
+      @channel.send_message_to_server_result('storageState', {}).tap do |result|
+        if path
+          File.open(path, 'w') do |f|
+            f.write(JSON.dump(result))
+          end
+        end
+      end
+    end
+
     def expect_page(predicate: nil, timeout: nil)
       params = {
         predicate: predicate,
@@ -292,6 +329,14 @@ module Playwright
       @pages.delete(page)
     end
 
+    private def remove_background_page(page)
+      @background_pages.delete(page)
+    end
+
+    private def remove_service_worker(worker)
+      @service_workers.delete(worker)
+    end
+
     # called from Page with send(:_timeout_settings), so keep private.
     private def _timeout_settings
       @timeout_settings

data/lib/playwright/channel_owners/frame.rb

@@ -309,15 +309,20 @@ module Playwright
           target,
           force: nil,
           noWaitAfter: nil,
+          sourcePosition: nil,
           strict: nil,
+          targetPosition: nil,
           timeout: nil,
           trial: nil)
+
       params = {
         source: source,
         target: target,
         force: force,
         noWaitAfter: noWaitAfter,
+        sourcePosition: sourcePosition,
         strict: strict,
+        targetPosition: targetPosition,
         timeout: timeout,
         trial: trial,
       }.compact
@@ -579,6 +584,10 @@ module Playwright
       nil
     end
 
+    def wait_for_timeout(timeout)
+      sleep(timeout / 1000.0)
+    end
+
     def wait_for_function(pageFunction, arg: nil, polling: nil, timeout: nil)
       if polling.is_a?(String) && polling != 'raf'
         raise ArgumentError.new("Unknown polling option: #{polling}")

data/lib/playwright/channel_owners/page.rb

@@ -9,7 +9,7 @@ module Playwright
     private def after_initialize
       @browser_context = @parent
       @timeout_settings = TimeoutSettings.new(@browser_context.send(:_timeout_settings))
-      @accessibility = Accessibility.new(@channel)
+      @accessibility = AccessibilityImpl.new(@channel)
       @keyboard = KeyboardImpl.new(@channel)
       @mouse = MouseImpl.new(@channel)
       @touchscreen = TouchscreenImpl.new(@channel)
@@ -21,6 +21,7 @@ module Playwright
         }
       end
       @closed = false
+      @workers = Set.new
       @bindings = {}
       @routes = []
 
@@ -66,7 +67,7 @@ module Playwright
       })
       @channel.on('worker', ->(params) {
         worker = ChannelOwners::Worker.from(params['worker'])
-        # on_worker(worker)
+        on_worker(worker)
       })
     end
 
@@ -110,9 +111,16 @@ module Playwright
       @browser_context.send(:on_binding, binding_call)
     end
 
+    private def on_worker(worker)
+      worker.page = self
+      @workers << worker
+      emit(Events::Page::Worker, worker)
+    end
+
     private def on_close
       @closed = true
       @browser_context.send(:remove_page, self)
+      @browser_context.send(:remove_background_page, self)
       emit(Events::Page::Close)
     end
 
@@ -467,7 +475,9 @@ module Playwright
           target,
           force: nil,
           noWaitAfter: nil,
+          sourcePosition: nil,
           strict: nil,
+          targetPosition: nil,
           timeout: nil,
           trial: nil)
 
@@ -476,7 +486,9 @@ module Playwright
         target,
         force: force,
         noWaitAfter: noWaitAfter,
+        sourcePosition: sourcePosition,
         strict: strict,
+        targetPosition: targetPosition,
         timeout: timeout,
         trial: trial)
     end
@@ -690,10 +702,18 @@ module Playwright
         trial: trial)
     end
 
+    def wait_for_timeout(timeout)
+      @main_frame.wait_for_timeout(timeout)
+    end
+
     def wait_for_function(pageFunction, arg: nil, polling: nil, timeout: nil)
       @main_frame.wait_for_function(pageFunction, arg: arg, polling: polling, timeout: timeout)
     end
 
+    def workers
+      @workers.to_a
+    end
+
     def pause
       @browser_context.send(:pause)
     end
@@ -865,6 +885,10 @@ module Playwright
       expect_event(Events::Page::WebSocket, predicate: predicate, timeout: timeout, &block)
     end
 
+    def expect_worker(predicate: nil, timeout: nil, &block)
+      expect_event(Events::Page::Worker, predicate: predicate, timeout: timeout, &block)
+    end
+
     # called from Frame with send(:timeout_settings)
     private def timeout_settings
       @timeout_settings
@@ -875,6 +899,11 @@ module Playwright
       @bindings.key?(name)
     end
 
+    # called from Worker#on_close
+    private def remove_worker(worker)
+      @workers.delete(worker)
+    end
+
     # Expose guid for library developers.
     # Not intended to be used by users.
     def guid

data/lib/playwright/channel_owners/request.rb

@@ -100,14 +100,14 @@ module Playwright
                   request_start:,
                   response_start:)
 
-      @timing["startTime"] = start_time
-      @timing["domainLookupStart"] = domain_lookup_start
-      @timing["domainLookupEnd"] = domain_lookup_end
-      @timing["connectStart"] = connect_start
-      @timing["secureConnectionStart"] = secure_connection_start
-      @timing["connectEnd"] = connect_end
-      @timing["requestStart"] = request_start
-      @timing["responseStart"] = response_start
+      @timing[:startTime] = start_time
+      @timing[:domainLookupStart] = domain_lookup_start
+      @timing[:domainLookupEnd] = domain_lookup_end
+      @timing[:connectStart] = connect_start
+      @timing[:secureConnectionStart] = secure_connection_start
+      @timing[:connectEnd] = connect_end
+      @timing[:requestStart] = request_start
+      @timing[:responseStart] = response_start
     end
 
     private def update_headers(headers)