playwright-ruby-client 0.2.1 → 0.3.0

data/lib/playwright/channel_owners/dialog.rb

@@ -0,0 +1,28 @@
+module Playwright
+  define_channel_owner :Dialog do
+    def type
+      @initializer['type']
+    end
+
+    def message
+      @initializer['message']
+    end
+
+    def default_value
+      @initializer['defaultValue']
+    end
+
+    def accept(promptText: nil)
+      accept_async(prompt_text: promptText).value!
+    end
+
+    def accept_async(promptText: nil)
+      params = { promptText: promptText }.compact
+      @channel.async_send_message_to_server('accept', params)
+    end
+
+    def dismiss
+      @channel.async_send_message_to_server('dismiss')
+    end
+  end
+end

data/lib/playwright/channel_owners/page.rb

@@ -14,8 +14,16 @@ 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
@@ -96,12 +104,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 +125,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 +145,14 @@ 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
 
     # @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 +160,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 +169,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
 
@@ -347,7 +362,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 +373,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,
@@ -698,5 +730,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,6 +20,10 @@ module Playwright
       @electron ||= ::Playwright::ChannelOwners::Electron.from(@initializer['electron'])
     end
 
+    def selectors
+      @selectors ||= ::Playwright::ChannelOwners::Selectors.from(@initializer['selectors'])
+    end
+
     class DeviceDescriptor
       class Viewport
         def initialize(hash)

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

data/lib/playwright/channel_owners/route.rb

@@ -0,0 +1,78 @@
+require 'base64'
+require 'mime/types'
+
+module Playwright
+  define_channel_owner :Route do
+    def request
+      ChannelOwners::Request.from(@initializer['request'])
+    end
+
+    def abort(errorCode: nil)
+      params = { errorCode: errorCode }.compact
+      @channel.async_send_message_to_server('abort', params)
+    end
+
+    def fulfill(
+          body: nil,
+          contentType: nil,
+          headers: nil,
+          path: nil,
+          status: nil)
+      params = {
+        contentType: contentType,
+        status: status,
+      }.compact
+
+      length = 0
+      content =
+        if body
+          body
+        elsif path
+          File.read(path)
+        else
+          nil
+        end
+
+      param_headers = headers || {}
+      if contentType
+        param_headers['content-type'] = contentType
+      elsif path
+        param_headers['content-type'] = mime_type_for(path)
+      end
+
+      if content
+        if content.is_a?(String)
+          params[:body] = content
+          params[:isBase64] = false
+        else
+          params[:body] = Base64.strict_encode64(content)
+          params[:isBase64] = true
+        end
+        param_headers['content-length'] ||= content.length.to_s
+      end
+
+      params[:headers] = HttpHeaders.new(param_headers).as_serialized
+
+      @channel.async_send_message_to_server('fulfill', params)
+    end
+
+    def continue(headers: nil, method: nil, postData: nil, url: nil)
+      overrides = { url: url, method: method }.compact
+
+      if headers
+        overrides[:headers] = HttpHeaders.new(headers).as_serialized
+      end
+
+      if postData
+        overrides[:postData] = Base64.strict_encode64(postData)
+      end
+
+      @channel.async_send_message_to_server('continue', overrides)
+    end
+
+    private def mime_type_for(filepath)
+      mime_types = MIME::Types.type_for(filepath)
+      mime_types.first.to_s || 'application/octet-stream'
+    end
+  end
+end

data/lib/playwright/channel_owners/selectors.rb

@@ -1,4 +1,22 @@
 module Playwright
   # https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_selectors.py
-  define_channel_owner :Selectors
+  define_channel_owner :Selectors do
+    def register(name, contentScript: nil, path: nil, script: nil)
+      source =
+        if path
+          File.read(path)
+        elsif script
+          script
+        else
+          raise ArgumentError.new('Either path or script parameter must be specified')
+        end
+      params = { name: name, source: source }
+      if contentScript
+        params[:contentScript] = true
+      end
+      @channel.send_message_to_server('register', params)
+
+      nil
+    end
+  end
 end

data/lib/playwright/route_handler_entry.rb

@@ -0,0 +1,36 @@
+module Playwright
+  class RouteHandlerEntry
+    # @param url [String]
+    # @param handler [Proc]
+    def initialize(url, handler)
+      @url_value = url
+      @url_matcher = UrlMatcher.new(url)
+      @handler = handler
+    end
+
+    def handle(route, request)
+      if url_match?(request.url)
+        @handler.call(route, request)
+        true
+      else
+        false
+      end
+    end
+
+    def same_value?(url:, handler: nil)
+      if handler
+        @url_value == url && @handler == handler
+      else
+        @url_value == url
+      end
+    end
+
+    private def url_match?(request_url)
+      if @url_value.is_a?(Regexp)
+        @url_matcher.match?(request_url)
+      else
+        @url_matcher.match?(request_url) || File.fnmatch?(@url_value, request_url)
+      end
+    end
+  end
+end

data/lib/playwright/utils.rb

@@ -3,6 +3,7 @@ module Playwright
     module PrepareBrowserContextOptions
       # @see https://github.com/microsoft/playwright/blob/5a2cfdbd47ed3c3deff77bb73e5fac34241f649d/src/client/browserContext.ts#L265
       private def prepare_browser_context_options(params)
+        params[:sdkLanguage] = 'ruby'
         if params[:noViewport] == 0
           params.delete(:noViewport)
           params[:noDefaultViewport] = true

data/lib/playwright/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Playwright
-  VERSION = '0.2.1'
+  VERSION = '0.3.0'
 end

data/lib/playwright_api/android.rb

@@ -1,28 +1,100 @@
 module Playwright
-  # @nodoc
+  # Playwright has **experimental** support for Android automation. You can access android namespace via:
+  # 
+  #
+  # ```js
+  # const { _android } = require('playwright');
+  # ```
+  # 
+  # An example of the Android automation script would be:
+  # 
+  #
+  # ```js
+  # const { _android } = require('playwright');
+  # 
+  # (async () => {
+  #   // Connect to the device.
+  #   const [device] = await playwright._android.devices();
+  #   console.log(`Model: ${device.model()}`);
+  #   console.log(`Serial: ${device.serial()}`);
+  #   // Take screenshot of the whole device.
+  #   await device.screenshot({ path: 'device.png' });
+  # 
+  #   {
+  #     // --------------------- WebView -----------------------
+  # 
+  #     // Launch an application with WebView.
+  #     await device.shell('am force-stop org.chromium.webview_shell');
+  #     await device.shell('am start org.chromium.webview_shell/.WebViewBrowserActivity');
+  #     // Get the WebView.
+  #     const webview = await device.webView({ pkg: 'org.chromium.webview_shell' });
+  # 
+  #     // Fill the input box.
+  #     await device.fill({ res: 'org.chromium.webview_shell:id/url_field' }, 'github.com/microsoft/playwright');
+  #     await device.press({ res: 'org.chromium.webview_shell:id/url_field' }, 'Enter');
+  # 
+  #     // Work with WebView's page as usual.
+  #     const page = await webview.page();
+  #     await page.page.waitForNavigation({ url: /.*microsoft\/playwright.*/ });
+  #     console.log(await page.title());
+  #   }
+  # 
+  #   {
+  #     // --------------------- Browser -----------------------
+  # 
+  #     // Launch Chrome browser.
+  #     await device.shell('am force-stop com.android.chrome');
+  #     const context = await device.launchBrowser();
+  # 
+  #     // Use BrowserContext as usual.
+  #     const page = await context.newPage();
+  #     await page.goto('https://webkit.org/');
+  #     console.log(await page.evaluate(() => window.location.href));
+  #     await page.screenshot({ path: 'page.png' });
+  # 
+  #     await context.close();
+  #   }
+  # 
+  #   // Close the device.
+  #   await device.close();
+  # })();
+  # ```
+  # 
+  # 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
+  # $ PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD=1 npm i -D playwright
+  # ```
   class Android < PlaywrightApi
 
-    # @nodoc
+    # Returns the list of detected Android devices.
     def devices
       wrap_impl(@impl.devices)
     end
 
+    # This setting will change the default maximum time for all the methods accepting `timeout` option.
+    def set_default_timeout(timeout)
+      raise NotImplementedError.new('set_default_timeout is not implemented yet.')
+    end
+    alias_method :default_timeout=, :set_default_timeout
+
     # -- inherited from EventEmitter --
     # @nodoc
-    def once(event, callback)
-      event_emitter_proxy.once(event, callback)
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def on(event, callback)
-      event_emitter_proxy.on(event, callback)
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def off(event, callback)
-      event_emitter_proxy.off(event, callback)
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
     end
 
     private def event_emitter_proxy