playwright-ruby-client 0.2.1 → 0.5.5

data/lib/playwright/channel_owners/js_handle.rb

@@ -9,8 +9,8 @@ module Playwright
       @preview
     end
 
-    private def on_preview_updated(preview)
-      @preview = preview
+    private def on_preview_updated(params)
+      @preview = params['preview']
     end
 
     def evaluate(pageFunction, arg: nil)

data/lib/playwright/channel_owners/page.rb

@@ -14,12 +14,21 @@ module Playwright
       @mouse = MouseImpl.new(@channel)
       @touchscreen = TouchscreenImpl.new(@channel)
 
-      @viewport_size = @initializer['viewportSize']
+      if @initializer['viewportSize']
+        @viewport_size = {
+          width: @initializer['viewportSize']['width'],
+          height: @initializer['viewportSize']['height'],
+        }
+      end
       @closed = false
+      @bindings = {}
+      @routes = Set.new
+
       @main_frame = ChannelOwners::Frame.from(@initializer['mainFrame'])
       @main_frame.send(:update_page_from_page, self)
       @frames = Set.new
       @frames << @main_frame
+      @opener = ChannelOwners::Page.from_nullable(@initializer['opener'])
 
       @channel.once('close', ->(_) { on_close })
       @channel.on('console', ->(params) {
@@ -29,9 +38,7 @@ module Playwright
       @channel.on('crash', ->(_) { emit(Events::Page::Crash) })
       @channel.on('dialog', method(:on_dialog))
       @channel.on('domcontentloaded', ->(_) { emit(Events::Page::DOMContentLoaded) })
-      @channel.on('download', ->(params) {
-        emit(Events::Page::Download, ChannelOwners::Download.from(params['download']))
-      })
+      @channel.on('download', method(:on_download))
       @channel.on('fileChooser', ->(params) {
         chooser = FileChooserImpl.new(
                     page: self,
@@ -49,9 +56,6 @@ module Playwright
       @channel.on('pageError', ->(params) {
         emit(Events::Page::PageError, Error.parse(params['error']['error']))
       })
-      @channel.on('popup', ->(params) {
-        emit(Events::Page::Popup, ChannelOwners::Page.from(params['page']))
-      })
       @channel.on('request', ->(params) {
         emit(Events::Page::Request, ChannelOwners::Request.from(params['request']))
       })
@@ -74,9 +78,7 @@ module Playwright
       @channel.on('route', ->(params) {
         on_route(ChannelOwners::Route.from(params['route']), ChannelOwners::Request.from(params['request']))
       })
-      @channel.on('video', ->(params) {
-        video.send(:update_relative_path, params['relativePath'])
-      })
+      @channel.on('video', method(:on_video))
       @channel.on('webSocket', ->(params) {
         emit(Events::Page::WebSocket, ChannelOwners::WebSocket.from(params['webSocket']))
       })
@@ -96,12 +98,12 @@ module Playwright
     private def on_request_failed(request, response_end_timing, failure_text)
       request.send(:update_failure_text, failure_text)
       request.send(:update_response_end_timing, response_end_timing)
-      emit(Events::Page::RequestFailed)
+      emit(Events::Page::RequestFailed, request)
     end
 
     private def on_request_finished(request, response_end_timing)
       request.send(:update_response_end_timing, response_end_timing)
-      emit(Events::Page::RequestFinished)
+      emit(Events::Page::RequestFinished, request)
     end
 
     private def on_frame_attached(frame)
@@ -117,8 +119,15 @@ module Playwright
     end
 
     private def on_route(route, request)
-      # @routes.each ...
-      @browser_context.send(: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.
+      # Just a workaround...
+      wrapped_route = PlaywrightApi.wrap(route)
+      wrapped_request = PlaywrightApi.wrap(request)
+
+      if @routes.none? { |handler_entry| handler_entry.handle(wrapped_route, wrapped_request) }
+        @browser_context.send(:on_route, route, request)
+      end
     end
 
     private def on_close
@@ -130,14 +139,28 @@ module Playwright
     private def on_dialog(params)
       dialog = ChannelOwners::Dialog.from(params['dialog'])
       unless emit(Events::Page::Dialog, dialog)
-        dialog.dismiss # FIXME: this should be asynchronous
+        dialog.dismiss
       end
     end
 
+    private def on_download(params)
+      download = Download.new(
+        url: params['url'],
+        suggested_filename: params['suggestedFilename'],
+        artifact: ChannelOwners::Artifact.from(params['artifact']),
+      )
+      emit(Events::Page::Download, download)
+    end
+
+    private def on_video(params)
+      artifact = ChannelOwners::Artifact.from(params['artifact'])
+      video.send(:set_artifact, artifact)
+    end
+
     # @override
     def on(event, callback)
       if event == Events::Page::FileChooser && listener_count(event) == 0
-        @channel.send_no_reply('setFileChooserInterceptedNoReply', intercepted: true)
+        @channel.async_send_message_to_server('setFileChooserInterceptedNoReply', intercepted: true)
       end
       super
     end
@@ -145,7 +168,7 @@ module Playwright
     # @override
     def once(event, callback)
       if event == Events::Page::FileChooser && listener_count(event) == 0
-        @channel.send_no_reply('setFileChooserInterceptedNoReply', intercepted: true)
+        @channel.async_send_message_to_server('setFileChooserInterceptedNoReply', intercepted: true)
       end
       super
     end
@@ -154,7 +177,7 @@ module Playwright
     def off(event, callback)
       super
       if event == Events::Page::FileChooser && listener_count(event) == 0
-        @channel.send_no_reply('setFileChooserInterceptedNoReply', intercepted: false)
+        @channel.async_send_message_to_server('setFileChooserInterceptedNoReply', intercepted: false)
       end
     end
 
@@ -163,8 +186,17 @@ module Playwright
     end
 
     def opener
-      resp = @channel.send_message_to_server('opener')
-      ChannelOwners::Page.from(resp)
+      if @opener&.closed?
+        nil
+      else
+        @opener
+      end
+    end
+
+    private def emit_popup_event_from_browser_context
+      if @opener && !@opener.closed?
+        @opener.emit(Events::Page::Popup, self)
+      end
     end
 
     def frame(name: nil, url: nil)
@@ -311,6 +343,10 @@ module Playwright
       @main_frame.wait_for_load_state(state: state, timeout: timeout)
     end
 
+    def wait_for_url(url, timeout: nil, waitUntil: nil)
+      @main_frame.wait_for_url(url, timeout: timeout,  waitUntil: waitUntil)
+    end
+
     def go_back(timeout: nil, waitUntil: nil)
       params = { timeout: timeout, waitUntil: waitUntil }.compact
       resp = @channel.send_message_to_server('goBack', params)
@@ -347,7 +383,7 @@ module Playwright
     def add_init_script(path: nil, script: nil)
       source =
         if path
-          File.read(path, 'r')
+          File.read(path)
         elsif script
           script
         else
@@ -358,6 +394,23 @@ module Playwright
       nil
     end
 
+    def route(url, handler)
+      entry = RouteHandlerEntry.new(url, handler)
+      @routes << entry
+      if @routes.count >= 1
+        @channel.send_message_to_server('setNetworkInterceptionEnabled', enabled: true)
+      end
+    end
+
+    def unroute(url, handler: nil)
+      @routes.reject! do |handler_entry|
+        handler_entry.same_value?(url: url, handler: handler)
+      end
+      if @routes.count == 0
+        @channel.send_message_to_server('setNetworkInterceptionEnabled', enabled: false)
+      end
+    end
+
     def screenshot(
       path: nil,
       type: nil,
@@ -546,12 +599,24 @@ module Playwright
       @main_frame.press(selector, key, delay: delay, noWaitAfter: noWaitAfter, timeout: timeout)
     end
 
-    def check(selector, force: nil, noWaitAfter: nil, timeout: nil)
-      @main_frame.check(selector, force: force, noWaitAfter: noWaitAfter, timeout: timeout)
+    def check(
+      selector,
+      force: nil,
+      noWaitAfter: nil,
+      position: nil,
+      timeout: nil)
+
+      @main_frame.check(selector, force: force, noWaitAfter: noWaitAfter, position: position, timeout: timeout)
     end
 
-    def uncheck(selector, force: nil, noWaitAfter: nil, timeout: nil)
-      @main_frame.uncheck(selector, force: force, noWaitAfter: noWaitAfter, timeout: timeout)
+    def uncheck(
+      selector,
+      force: nil,
+      noWaitAfter: nil,
+      position: nil,
+      timeout: nil)
+
+      @main_frame.uncheck(selector, force: force, noWaitAfter: noWaitAfter, position: position, timeout: timeout)
     end
 
     def wait_for_function(pageFunction, arg: nil, polling: nil, timeout: nil)
@@ -597,6 +662,36 @@ module Playwright
       decoded_binary
     end
 
+    def video
+      return nil unless @browser_context.send(:has_record_video_option?)
+      @video ||= Video.new(self)
+    end
+
+    def start_js_coverage(resetOnNavigation: nil, reportAnonymousScripts: nil)
+      params = {
+        resetOnNavigation: resetOnNavigation,
+        reportAnonymousScripts: reportAnonymousScripts,
+      }.compact
+
+      @channel.send_message_to_server('startJSCoverage', params)
+    end
+
+    def stop_js_coverage
+      @channel.send_message_to_server('stopJSCoverage')
+    end
+
+    def start_css_coverage(resetOnNavigation: nil, reportAnonymousScripts: nil)
+      params = {
+        resetOnNavigation: resetOnNavigation,
+      }.compact
+
+      @channel.send_message_to_server('startCSSCoverage', params)
+    end
+
+    def stop_css_coverage
+      @channel.send_message_to_server('stopCSSCoverage')
+    end
+
     class CrashedError < StandardError
       def initialize
         super('Page crashed')
@@ -698,5 +793,10 @@ module Playwright
     private def timeout_settings
       @timeout_settings
     end
+
+    # called from BrowserContext#expose_binding
+    private def has_bindings?(name)
+      @bindings.key?(name)
+    end
   end
 end

data/lib/playwright/channel_owners/playwright.rb

@@ -20,38 +20,35 @@ module Playwright
       @electron ||= ::Playwright::ChannelOwners::Electron.from(@initializer['electron'])
     end
 
-    class DeviceDescriptor
-      class Viewport
-        def initialize(hash)
-          @width = hash['width']
-          @heirhgt = hash['height']
-        end
-        attr_reader :width, :height
-      end
-
-      def initialize(hash)
-        @user_agent = hash["userAgent"]
-        @viewport = Viewport.new(hash["viewport"])
-        @device_scale_factor = hash["deviceScaleFactor"]
-        @is_mobile = hash["isMobile"]
-        @has_touch = hash["hasTouch"]
-      end
-
-      attr_reader :user_agent, :viewport, :device_scale_factor
-
-      def mobile?
-        @is_mobile
-      end
-
-      def has_touch?
-        @has_touch
-      end
+    def selectors
+      @selectors ||= ::Playwright::ChannelOwners::Selectors.from(@initializer['selectors'])
     end
 
     def devices
       @devices ||= @initializer['deviceDescriptors'].map do |item|
-        [item['name'], DeviceDescriptor.new(item['descriptor'])]
+        [item['name'], parse_device_descriptor(item['descriptor'])]
       end.to_h
     end
+
+    private def parse_device_descriptor(descriptor)
+      # This return value can be passed into Browser#new_context as it is.
+      # ex:
+      # ```
+      #   iPhone = playwright.devices['iPhone 6']
+      #   context = browser.new_context(**iPhone)
+      #   page = context.new_page
+      #
+      # ```
+      {
+        userAgent: descriptor['userAgent'],
+        viewport: {
+          width: descriptor['viewport']['width'],
+          height: descriptor['viewport']['height'],
+        },
+        deviceScaleFactor: descriptor['deviceScaleFactor'],
+        isMobile: descriptor['isMobile'],
+        hasTouch: descriptor['hasTouch'],
+      }
+    end
   end
 end

data/lib/playwright/channel_owners/request.rb

@@ -29,7 +29,7 @@ module Playwright
     end
 
     def method
-      @initialize['method']
+      @initializer['method']
     end
 
     def post_data
@@ -69,7 +69,7 @@ module Playwright
     end
 
     def frame
-      @initializer['frame']
+      ChannelOwners::Frame.from(@initializer['frame'])
     end
 
     def navigation_request?
@@ -90,6 +90,30 @@ module Playwright
       @failure_text = failure_text
     end
 
+    private def update_timings(
+                  start_time:,
+                  domain_lookup_start:,
+                  domain_lookup_end:,
+                  connect_start:,
+                  secure_connection_start:,
+                  connect_end:,
+                  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
+    end
+
+    private def update_headers(headers)
+      @headers = parse_headers(headers)
+    end
+
     private def update_response_end_timing(response_end_timing)
       @timing[:responseEnd] = response_end_timing
     end

data/lib/playwright/channel_owners/response.rb

@@ -1,5 +1,65 @@
+require 'base64'
+require 'json'
+
 module Playwright
   # @ref https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_network.py
   define_channel_owner :Response do
+    def after_initialize
+      @request = ChannelOwners::Request.from(@initializer['request'])
+      timing = @initializer['timing']
+      @request.send(:update_timings,
+        start_time: timing["startTime"],
+        domain_lookup_start: timing["domainLookupStart"],
+        domain_lookup_end: timing["domainLookupEnd"],
+        connect_start: timing["connectStart"],
+        secure_connection_start: timing["secureConnectionStart"],
+        connect_end: timing["connectEnd"],
+        request_start: timing["requestStart"],
+        response_start: timing["responseStart"],
+      )
+      @request.send(:update_headers, @initializer['requestHeaders'])
+    end
+    attr_reader :request
+
+    def url
+      @initializer['url']
+    end
+
+    def ok
+      status == 0 || (200...300).include?(status)
+    end
+    alias_method :ok?, :ok
+
+    def status
+      @initializer['status']
+    end
+
+    def status_text
+      @initializer['statusText']
+    end
+
+    def headers
+      @initializer['headers'].map do |header|
+        [header['name'].downcase, header['value']]
+      end.to_h
+    end
+
+    def finished
+      @channel.send_message_to_server('finished')
+    end
+
+    def body
+      binary = @channel.send_message_to_server("body")
+      Base64.strict_decode64(binary)
+    end
+    alias_method :text, :body
+
+    def json
+      JSON.parse(text)
+    end
+
+    def frame
+      @request.frame
+    end
   end
 end