playwright-ruby-client 0.0.6 → 0.0.7

data/lib/playwright.rb

@@ -15,8 +15,10 @@ require 'playwright/utils'
 
 require 'playwright/channel'
 require 'playwright/channel_owner'
+require 'playwright/input_files'
 require 'playwright/input_type'
 require 'playwright/connection'
+require 'playwright/select_option_values'
 require 'playwright/timeout_settings'
 require 'playwright/transport'
 require 'playwright/url_matcher'

data/lib/playwright/channel_owner.rb

@@ -39,13 +39,14 @@ module Playwright
 
     attr_reader :channel
 
-    def dispose
+    # used only from Connection. Not intended for public use. So keep private.
+    private def dispose!
       # Clean up from parent and connection.
       @parent&.send(:delete_object_from_child, @guid)
       @connection.send(:delete_object_from_channel_owner, @guid)
 
       # Dispose all children.
-      @objects.each_value(&:dispose)
+      @objects.each_value { |object| object.send(:dispose!) }
       @objects.clear
     end
 

data/lib/playwright/channel_owners/android.rb

@@ -1,3 +1,12 @@
 module Playwright
-  define_channel_owner :Android
+  define_channel_owner :Android do
+    def after_initialize
+      @timeout_settings = TimeoutSettings.new
+    end
+
+    def devices
+      resp = @channel.send_message_to_server('devices')
+      resp.map { |device| ChannelOwners::AndroidDevice.from(device) }
+    end
+  end
 end

data/lib/playwright/channel_owners/android_device.rb

@@ -0,0 +1,93 @@
+module Playwright
+  define_channel_owner :AndroidDevice do
+    include Utils::PrepareBrowserContextOptions
+
+    def serial
+      @initializer['serial']
+    end
+
+    def model
+      @initializer['model']
+    end
+
+    def shell(command)
+      resp = @channel.send_message_to_server('shell', command: command)
+      Base64.strict_decode64(resp)
+    end
+
+    def close
+      @channel.send_message_to_server('close')
+      emit(Events::AndroidDevice::Close)
+    end
+
+    def launch_browser(
+          pkg: nil,
+          acceptDownloads: nil,
+          bypassCSP: nil,
+          colorScheme: nil,
+          deviceScaleFactor: nil,
+          extraHTTPHeaders: nil,
+          geolocation: nil,
+          hasTouch: nil,
+          httpCredentials: nil,
+          ignoreHTTPSErrors: nil,
+          isMobile: nil,
+          javaScriptEnabled: nil,
+          locale: nil,
+          logger: nil,
+          offline: nil,
+          permissions: nil,
+          proxy: nil,
+          recordHar: nil,
+          recordVideo: nil,
+          storageState: nil,
+          timezoneId: nil,
+          userAgent: nil,
+          videoSize: nil,
+          videosPath: nil,
+          viewport: nil,
+          &block)
+      params = {
+        pkg: pkg,
+        acceptDownloads: acceptDownloads,
+        bypassCSP: bypassCSP,
+        colorScheme: colorScheme,
+        deviceScaleFactor: deviceScaleFactor,
+        extraHTTPHeaders: extraHTTPHeaders,
+        geolocation: geolocation,
+        hasTouch: hasTouch,
+        httpCredentials: httpCredentials,
+        ignoreHTTPSErrors: ignoreHTTPSErrors,
+        isMobile: isMobile,
+        javaScriptEnabled: javaScriptEnabled,
+        locale: locale,
+        logger: logger,
+        offline: offline,
+        permissions: permissions,
+        proxy: proxy,
+        recordHar: recordHar,
+        recordVideo: recordVideo,
+        storageState: storageState,
+        timezoneId: timezoneId,
+        userAgent: userAgent,
+        videoSize: videoSize,
+        videosPath: videosPath,
+        viewport: viewport,
+      }.compact
+      prepare_browser_context_options(params)
+
+      resp = @channel.send_message_to_server('launchBrowser', params)
+      context = ChannelOwners::BrowserContext.from(resp)
+
+      if block
+        begin
+          block.call(context)
+        ensure
+          context.close
+        end
+      else
+        context
+      end
+    end
+  end
+end

data/lib/playwright/channel_owners/browser.rb

@@ -2,6 +2,7 @@ module Playwright
   # @ref https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_browser.py
   define_channel_owner :Browser do
     include Utils::Errors::SafeCloseError
+    include Utils::PrepareBrowserContextOptions
 
     def after_initialize
       @contexts = Set.new
@@ -16,26 +17,25 @@ module Playwright
       @connected
     end
 
-    def new_context(**options)
+    def new_context(**options, &block)
       params = options.dup
-      # @see https://github.com/microsoft/playwright/blob/5a2cfdbd47ed3c3deff77bb73e5fac34241f649d/src/client/browserContext.ts#L265
-      if params[:viewport] == 0
-        params.delete(:viewport)
-        params[:noDefaultViewport] = true
-      end
-      if params[:extraHTTPHeaders]
-        # TODO
-      end
-      if params[:storageState].is_a?(String)
-        params[:storageState] = JSON.parse(File.read(params[:storageState]))
-      end
+      prepare_browser_context_options(params)
 
       resp = @channel.send_message_to_server('newContext', params.compact)
       context = ChannelOwners::BrowserContext.from(resp)
       @contexts << context
       context.browser = self
       context.options = params
-      context
+
+      if block
+        begin
+          block.call(context)
+        ensure
+          context.close
+        end
+      else
+        context
+      end
     end
 
     def new_page(**options)

data/lib/playwright/channel_owners/element_handle.rb

@@ -3,6 +3,91 @@ require_relative './js_handle'
 module Playwright
   module ChannelOwners
     class ElementHandle < JSHandle
+      def as_element
+        self
+      end
+
+      def owner_frame
+        resp = @channel.send_message_to_server('ownerFrame')
+        ChannelOwners::Frame.from_nullable(resp)
+      end
+
+      def content_frame
+        resp = @channel.send_message_to_server('contentFrame')
+        ChannelOwners::Frame.from_nullable(resp)
+      end
+
+      def get_attribute(name)
+        @channel.send_message_to_server('getAttribute', name: name)
+      end
+
+      def text_content
+        @channel.send_message_to_server('textContent')
+      end
+
+      def inner_text
+        @channel.send_message_to_server('innerText')
+      end
+
+      def inner_html
+        @channel.send_message_to_server('innerHTML')
+      end
+
+      def checked?
+        @channel.send_message_to_server('isChecked')
+      end
+
+      def disabled?
+        @channel.send_message_to_server('isDisabled')
+      end
+
+      def editable?
+        @channel.send_message_to_server('isEditable')
+      end
+
+      def enabled?
+        @channel.send_message_to_server('isEnabled')
+      end
+
+      def hidden?
+        @channel.send_message_to_server('isHidden')
+      end
+
+      def visible?
+        @channel.send_message_to_server('isVisible')
+      end
+
+      def dispatch_event(type, eventInit: nil)
+        params = {
+          type: type,
+          eventInit: JavaScript::ValueSerializer.new(eventInit).serialize,
+        }.compact
+        @channel.send_message_to_server('dispatchEvent', params)
+
+        nil
+      end
+
+      def scroll_into_view_if_needed(timeout: nil)
+        params = {
+          timeout: timeout,
+        }.compact
+        @channel.send_message_to_server('scrollIntoViewIfNeeded', params)
+
+        nil
+      end
+
+      def hover(force: nil, modifiers: nil, position: nil, timeout: nil)
+        params = {
+          force: force,
+          modifiers: modifiers,
+          position: position,
+          timeout: timeout,
+        }
+        @channel.send_message_to_server('hover', params)
+
+        nil
+      end
+
       def click(
             button: nil,
             clickCount: nil,
@@ -28,7 +113,89 @@ module Playwright
         nil
       end
 
-      def type_text(text, delay: nil, noWaitAfter: nil, timeout: nil)
+      def dblclick(
+            button: nil,
+            delay: nil,
+            force: nil,
+            modifiers: nil,
+            noWaitAfter: nil,
+            position: nil,
+            timeout: nil)
+
+        params = {
+          button: button,
+          delay: delay,
+          force: force,
+          modifiers: modifiers,
+          noWaitAfter: noWaitAfter,
+          position: position,
+          timeout: timeout,
+        }.compact
+        @channel.send_message_to_server('dblclick', params)
+
+        nil
+      end
+
+      def select_option(values, noWaitAfter: nil, timeout: nil)
+        base_params = SelectOptionValues.new(values).as_params
+        params = base_params + { noWaitAfter: noWaitAfter, timeout: timeout }.compact
+        @channel.send_message_to_server('selectOption', params)
+
+        nil
+      end
+
+      def tap_point(
+            force: nil,
+            modifiers: nil,
+            noWaitAfter: nil,
+            position: nil,
+            timeout: nil)
+
+        params = {
+          force: force,
+          modifiers: modifiers,
+          noWaitAfter: noWaitAfter,
+          position: position,
+          timeout: timeout,
+        }.compact
+        @channel.send_message_to_server('tap', params)
+
+        nil
+      end
+
+      def fill(value, noWaitAfter: nil, timeout: nil)
+        params = {
+          value: value,
+          noWaitAfter: noWaitAfter,
+          timeout: timeout,
+        }
+        @channel.send_message_to_server('fill', params)
+
+        nil
+      end
+
+      def select_text(timeout: nil)
+        params = { timeout: timeout }.compact
+        @channel.send_message_to_server('selectText', params)
+
+        nil
+      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
+        @channel.send_message_to_server('setInputFiles', params)
+
+        nil
+      end
+
+      def focus
+        @channel.send_message_to_server('focus')
+
+        nil
+      end
+
+      def type(text, delay: nil, noWaitAfter: nil, timeout: nil)
         params = {
           text: text,
           delay: delay,
@@ -52,6 +219,56 @@ module Playwright
         nil
       end
 
+      def check(force: nil, noWaitAfter: nil, timeout: nil)
+        params = {
+          force: force,
+          noWaitAfter:  noWaitAfter,
+          timeout: timeout,
+        }.compact
+        @channel.send_message_to_server('check', params)
+
+        nil
+      end
+
+      def uncheck(force: nil, noWaitAfter: nil, timeout: nil)
+        params = {
+          force: force,
+          noWaitAfter:  noWaitAfter,
+          timeout: timeout,
+        }.compact
+        @channel.send_message_to_server('uncheck', params)
+
+        nil
+      end
+
+      def bounding_box
+        @channel.send_message_to_server('boundingBox')
+      end
+
+      def screenshot(
+        omitBackground: nil,
+        path: nil,
+        quality: nil,
+        timeout: nil,
+        type: nil)
+
+        params = {
+          omitBackground: omitBackground,
+          path: path,
+          quality: quality,
+          timeout: timeout,
+          type: type,
+        }.compact
+        encoded_binary = @channel.send_message_to_server('screenshot', params)
+        decoded_binary = Base64.strict_decode64(encoded_binary)
+        if path
+          File.open(path, 'wb') do |f|
+            f.write(decoded_binary)
+          end
+        end
+        decoded_binary
+      end
+
       def query_selector(selector)
         resp = @channel.send_message_to_server('querySelector', selector: selector)
         ChannelOwners::ElementHandle.from_nullable(resp)
@@ -78,6 +295,20 @@ module Playwright
           JavaScript::Expression.new(pageFunction).eval_on_selector_all(@channel, selector)
         end
       end
+
+      def wait_for_element_state(state, timeout: nil)
+        params = { state: state, timeout: timeout }.compact
+        @channel.send_message_to_server('waitForElementState', params)
+
+        nil
+      end
+
+      def wait_for_selector(selector, state: nil, timeout: nil)
+        params = { selector: selector, state: state, timeout: timeout }.compact
+        resp = @channel.send_message_to_server('waitForSelector', params)
+
+        ChannelOwners::ElementHandle.from_nullable(resp)
+      end
     end
   end
 end

data/lib/playwright/channel_owners/frame.rb

@@ -62,7 +62,7 @@ module Playwright
       end
     end
 
-    def wait_for_navigation(timeout: nil, url: nil, waitUntil: nil, &block)
+    def expect_navigation(timeout: nil, url: nil, waitUntil: nil, &block)
       option_wait_until = waitUntil || 'load'
       option_timeout = timeout || @page.send(:timeout_settings).navigation_timeout
       time_start = Time.now
@@ -100,6 +100,7 @@ module Playwright
 
     def wait_for_load_state(state: nil, timeout: nil)
       option_state = state || 'load'
+      option_timeout = timeout || @page.send(:timeout_settings).navigation_timeout
       unless %w(load domcontentloaded networkidle).include?(option_state)
         raise ArgumentError.new('state: expected one of (load|domcontentloaded|networkidle)')
       end
@@ -107,7 +108,7 @@ module Playwright
         return
       end
 
-      wait_helper = setup_navigation_wait_helper(timeout: timeout)
+      wait_helper = setup_navigation_wait_helper(timeout: option_timeout)
 
       predicate = ->(state) { state == option_state }
       wait_helper.wait_for_event(@event_emitter, 'loadstate', predicate: predicate)
@@ -202,13 +203,50 @@ module Playwright
       nil
     end
 
+    def dblclick(
+          selector,
+          button: nil,
+          delay: nil,
+          force: nil,
+          modifiers: nil,
+          noWaitAfter: nil,
+          position: nil,
+          timeout: nil)
+
+      params = {
+        selector: selector,
+        button: button,
+        delay: delay,
+        force: force,
+        modifiers: modifiers,
+        noWaitAfter: noWaitAfter,
+        position: position,
+        timeout: timeout,
+      }.compact
+      @channel.send_message_to_server('dblclick', params)
+
+      nil
+    end
+
+    def fill(selector, value, noWaitAfter: nil, timeout: nil)
+      params = {
+        selector: selector,
+        value: value,
+        noWaitAfter: noWaitAfter,
+        timeout: timeout,
+      }.compact
+      @channel.send_message_to_server('fill', params)
+
+      nil
+    end
+
     def focus(selector, timeout: nil)
       params = { selector: selector, timeout: timeout }.compact
       @channel.send_message_to_server('focus', params)
       nil
     end
 
-    def type_text(
+    def type(
       selector,
       text,
       delay: nil,