playwright-ruby-client 0.0.8 → 0.3.0

data/lib/playwright/{input_types/android_input.rb → android_input_impl.rb}

@@ -1,5 +1,9 @@
 module Playwright
-  define_input_type :AndroidInput do
+  define_api_implementation :AndroidInputImpl do
+    def initialize(channel)
+      @channel = channel
+    end
+
     def type(text)
       @channel.send_message_to_server('inputType', text: text)
     end

data/lib/playwright/api_implementation.rb

@@ -0,0 +1,18 @@
+module Playwright
+  # Each Impl class include this module.
+  # Used for detecting whether the object is a XXXXImpl or not.
+  module ApiImplementation ; end
+
+  def self.define_api_implementation(class_name, &block)
+    klass = Class.new
+    klass.include(ApiImplementation)
+    klass.class_eval(&block) if block
+    if ::Playwright.const_defined?(class_name)
+      raise ArgumentError.new("Playwright::#{class_name} already exist. Choose another class name.")
+    end
+    ::Playwright.const_set(class_name, klass)
+  end
+end
+
+# load subclasses
+Dir[File.join(__dir__, '*_impl.rb')].each { |f| require f }

data/lib/playwright/channel.rb

@@ -16,12 +16,19 @@ module Playwright
     # @param method [String]
     # @param params [Hash]
     def send_message_to_server(method, params = {})
-      result = @connection.send_message_to_server(@guid, method, params)
-      if result.is_a?(Hash)
-        _type, channel_owner = result.first
-        channel_owner
-      else
-        nil
+      async_send_message_to_server(method, params).value!
+    end
+
+    # @param method [String]
+    # @param params [Hash]
+    def async_send_message_to_server(method, params = {})
+      @connection.async_send_message_to_server(@guid, method, params).then do |result|
+        if result.is_a?(Hash)
+          _type, channel_owner = result.first
+          channel_owner
+        else
+          nil
+        end
       end
     end
   end

data/lib/playwright/channel_owner.rb

@@ -59,16 +59,14 @@ module Playwright
       "#<#{@guid}>"
     end
 
-    private
-
-    def after_initialize
+    private def after_initialize
     end
 
-    def update_object_from_child(guid, child)
+    private def update_object_from_child(guid, child)
       @objects[guid] = child
     end
 
-    def delete_object_from_child(guid)
+    private def delete_object_from_child(guid)
       @objects.delete(guid)
     end
   end

data/lib/playwright/channel_owners/android.rb

@@ -1,6 +1,6 @@
 module Playwright
   define_channel_owner :Android do
-    def after_initialize
+    private def after_initialize
       @timeout_settings = TimeoutSettings.new
     end
 

data/lib/playwright/channel_owners/android_device.rb

@@ -2,8 +2,8 @@ module Playwright
   define_channel_owner :AndroidDevice do
     include Utils::PrepareBrowserContextOptions
 
-    def after_initialize
-      @input = InputTypes::AndroidInput.new(@channel)
+    private def after_initialize
+      @input = AndroidInputImpl.new(@channel)
     end
 
     attr_reader :input
@@ -104,17 +104,17 @@ module Playwright
           isMobile: nil,
           javaScriptEnabled: nil,
           locale: nil,
-          logger: nil,
+          noViewport: nil,
           offline: nil,
           permissions: nil,
           proxy: nil,
-          recordHar: nil,
-          recordVideo: nil,
+          record_har_omit_content: nil,
+          record_har_path: nil,
+          record_video_dir: nil,
+          record_video_size: nil,
           storageState: nil,
           timezoneId: nil,
           userAgent: nil,
-          videoSize: nil,
-          videosPath: nil,
           viewport: nil,
           &block)
       params = {
@@ -131,17 +131,17 @@ module Playwright
         isMobile: isMobile,
         javaScriptEnabled: javaScriptEnabled,
         locale: locale,
-        logger: logger,
+        noViewport: noViewport,
         offline: offline,
         permissions: permissions,
         proxy: proxy,
-        recordHar: recordHar,
-        recordVideo: recordVideo,
+        record_har_omit_content: record_har_omit_content,
+        record_har_path: record_har_path,
+        record_video_dir: record_video_dir,
+        record_video_size: record_video_size,
         storageState: storageState,
         timezoneId: timezoneId,
         userAgent: userAgent,
-        videoSize: videoSize,
-        videosPath: videosPath,
         viewport: viewport,
       }.compact
       prepare_browser_context_options(params)

data/lib/playwright/channel_owners/binding_call.rb

@@ -1,4 +1,7 @@
 module Playwright
   define_channel_owner :BindingCall do
+    def name
+      @initializer['name']
+    end
   end
 end

data/lib/playwright/channel_owners/browser.rb

@@ -4,7 +4,7 @@ module Playwright
     include Utils::Errors::SafeCloseError
     include Utils::PrepareBrowserContextOptions
 
-    def after_initialize
+    private def after_initialize
       @contexts = Set.new
       @channel.on('close', method(:on_close))
     end

data/lib/playwright/channel_owners/browser_context.rb

@@ -2,13 +2,21 @@ module Playwright
   # @ref https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_browser_context.py
   define_channel_owner :BrowserContext do
     include Utils::Errors::SafeCloseError
-    attr_writer :browser, :owner_page, :options
+    attr_accessor :browser
+    attr_writer :owner_page, :options
 
-    def after_initialize
+    private def after_initialize
       @pages = Set.new
+      @routes = Set.new
+      @bindings = {}
+      @timeout_settings = TimeoutSettings.new
 
+      @channel.on('bindingCall', ->(params) { on_binding(ChannelOwners::BindingCall.from(params['binding'])) })
       @channel.once('close', ->(_) { on_close })
-      @channel.on('page', ->(hash) { on_page(ChannelOwners::Page.from(hash['page']) )})
+      @channel.on('page', ->(params) { on_page(ChannelOwners::Page.from(params['page']) )})
+      @channel.on('route', ->(params) {
+        on_route(ChannelOwners::Route.from(params['route']), ChannelOwners::Request.from(params['request']))
+      })
     end
 
     private def on_page(page)
@@ -17,6 +25,35 @@ module Playwright
       emit(Events::BrowserContext::Page, 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.
+      # 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) }
+        route.continue
+      end
+    end
+
+    private def on_binding(binding_call)
+      func = @binding[binding_call.name]
+      if func
+        binding_call.call(func)
+      end
+    end
+
+    def set_default_navigation_timeout(timeout)
+      @timeout_settings.default_navigation_timeout = timeout
+      @channel.send_message_to_server('setDefaultNavigationTimeoutNoReply', timeout: timeout)
+    end
+
+    def set_default_timeout(timeout)
+      @timeout_settings.default_timeout = timeout
+      @channel.send_message_to_server('setDefaultTimeoutNoReply', timeout: timeout)
+    end
+
     def pages
       @pages.to_a
     end
@@ -28,6 +65,111 @@ module Playwright
       ChannelOwners::Page.from(resp)
     end
 
+    def cookies(urls: nil)
+      target_urls =
+        if urls.nil?
+          []
+        elsif urls.is_a?(Enumerable)
+          urls
+        else
+          [urls]
+        end
+      @channel.send_message_to_server('cookies', urls: urls)
+    end
+
+    def add_cookies(cookies)
+      @channel.send_message_to_server('addCookies', cookies: cookies)
+    end
+
+    def clear_cookies
+      @channel.send_message_to_server('clearCookies')
+    end
+
+    def grant_permissions(permissions, origin: nil)
+      params = {
+        permissions: permissions,
+        origin: origin,
+      }.compact
+      @channel.send_message_to_server('grantPermissions', params)
+    end
+
+    def clear_permissions
+      @channel.send_message_to_server('clearPermissions')
+    end
+
+    def set_geolocation(geolocation)
+      @channel.send_message_to_server('setGeolocation', geolocation: geolocation)
+    end
+
+    def set_extra_http_headers(headers)
+      @channel.send_message_to_server('setExtraHTTPHeaders',
+        headers: HttpHeaders.new(headers).as_serialized)
+    end
+
+    def set_offline(offline)
+      @channel.send_message_to_server('setOffline', offline: offline)
+    end
+
+    def add_init_script(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
+
+      @channel.send_message_to_server('addInitScript', source: script)
+      nil
+    end
+
+    def expose_binding(name, callback, handle: nil)
+      if @pages.any? { |page| page.send(:has_bindings?, name) }
+        raise ArgumentError.new("Function \"#{name}\" has been already registered in one of the pages")
+      end
+      if @bindings.key?(name)
+        raise ArgumentError.new("Function \"#{name}\" has been already registered")
+      end
+      params = {
+        name: name,
+        needsHandle: handle,
+      }.compact
+      @bindings[name] = callback
+      @channel.send_message_to_server('exposeBinding', params)
+    end
+
+    def expose_function(name, callback)
+      expose_binding(name, ->(_source, *args) { callback.call(*args) }, )
+    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 expect_event(event, predicate: nil, timeout: nil, &block)
+      wait_helper = WaitHelper.new
+      wait_helper.reject_on_timeout(timeout || @timeout_settings.timeout, "Timeout while waiting for event \"#{event}\"")
+      wait_helper.wait_for_event(self, event, predicate: predicate)
+
+      block&.call
+
+      wait_helper.promise.value!
+    end
+
     private def on_close
       @closed_or_closing = true
       @browser&.send(:remove_context, self)
@@ -43,6 +185,18 @@ module Playwright
       raise unless safe_close_error?(err)
     end
 
+    def pause
+      @channel.send_message_to_server('pause')
+    end
+
+    def expect_page(predicate: nil, timeout: nil)
+      params = {
+        predicate: predicate,
+        timeout: timeout,
+      }.compact
+      expect_event(Events::BrowserContext::Page, params)
+    end
+
     # called from Page#on_close with send(:remove_page, page), so keep private
     private def remove_page(page)
       @pages.delete(page)

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/download.rb

@@ -0,0 +1,27 @@
+module Playwright
+  define_channel_owner :Download do
+    def url
+      @initializer['url']
+    end
+
+    def suggested_filename
+      @initializer['suggestedFilename']
+    end
+
+    def delete
+      @channel.send_message_to_server('delete')
+    end
+
+    def failure
+      @channel.send_message_to_server('failure')
+    end
+
+    def path
+      @channel.send_message_to_server('path')
+    end
+
+    def save_as(path)
+      @channel.send_message_to_server('saveAs', path: path)
+    end
+  end
+end

data/lib/playwright/channel_owners/element_handle.rb

@@ -136,8 +136,19 @@ module Playwright
         nil
       end
 
-      def select_option(values, noWaitAfter: nil, timeout: nil)
-        base_params = SelectOptionValues.new(values).as_params
+      def select_option(
+            element: nil,
+            index: nil,
+            value: nil,
+            label: nil,
+            noWaitAfter: nil,
+            timeout: nil)
+        base_params = SelectOptionValues.new(
+          element: element,
+          index: index,
+          value: value,
+          label: label,
+        ).as_params
         params = base_params + { noWaitAfter: noWaitAfter, timeout: timeout }.compact
         @channel.send_message_to_server('selectOption', params)
 
@@ -182,8 +193,8 @@ module Playwright
       end
 
       def set_input_files(files, noWaitAfter: nil, timeout: nil)
-        base_params = InputFiles.new(values).as_params
-        params = base_params + { noWaitAfter: noWaitAfter, timeout: timeout }.compact
+        file_payloads = InputFiles.new(files).as_params
+        params = { files: file_payloads, noWaitAfter: noWaitAfter, timeout: timeout }.compact
         @channel.send_message_to_server('setInputFiles', params)
 
         nil