playwright-ruby-client 0.0.3 → 0.0.8

data/lib/playwright.rb

@@ -10,12 +10,20 @@ require 'concurrent'
 require 'playwright/errors'
 require 'playwright/events'
 require 'playwright/event_emitter'
+require 'playwright/javascript'
+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'
 require 'playwright/version'
+require 'playwright/wait_helper'
 
 require 'playwright/playwright_api'
 # load generated files

data/lib/playwright/channel_owner.rb

@@ -6,6 +6,10 @@ module Playwright
       channel.object
     end
 
+    def self.from_nullable(channel)
+      channel&.object
+    end
+
     # @param parent [Playwright::ChannelOwner|Playwright::Connection]
     # @param type [String]
     # @param guid [String]
@@ -35,16 +39,26 @@ 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
 
+    # Suppress long long inspect log and avoid RSpec from hanging up...
+    def inspect
+      to_s
+    end
+
+    def to_s
+      "#<#{@guid}>"
+    end
+
     private
 
     def after_initialize

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,163 @@
+module Playwright
+  define_channel_owner :AndroidDevice do
+    include Utils::PrepareBrowserContextOptions
+
+    def after_initialize
+      @input = InputTypes::AndroidInput.new(@channel)
+    end
+
+    attr_reader :input
+
+    def serial
+      @initializer['serial']
+    end
+
+    def model
+      @initializer['model']
+    end
+
+    private def to_regex(value)
+      case value
+      when nil
+        nil
+      when Regexp
+        value
+      else
+        Regexp.new("^#{value}$")
+      end
+    end
+
+    private def to_selector_channel(selector)
+      {
+        checkable: selector[:checkable],
+        checked: selector[:checked],
+        clazz: to_regex(selector[:clazz]),
+        pkg: to_regex(selector[:pkg]),
+        desc: to_regex(selector[:desc]),
+        res: to_regex(selector[:res]),
+        text: to_regex(selector[:text]),
+        clickable: selector[:clickable],
+        depth: selector[:depth],
+        enabled: selector[:enabled],
+        focusable: selector[:focusable],
+        focused: selector[:focused],
+        hasChild: selector[:hasChild] ? { selector: to_selector_channel(selector[:hasChild][:selector]) } : nil,
+        hasDescendant: selector[:hasDescendant] ? {
+          selector: to_selector_channel(selector[:hasDescendant][:selector]),
+          maxDepth: selector[:hasDescendant][:maxDepth],
+        } : nil,
+        longClickable: selector[:longClickable],
+        scrollable: selector[:scrollable],
+        selected: selector[:selected],
+      }.compact
+    end
+
+    def tap_on(selector, duration: nil, timeout: nil)
+      params = {
+        selector: to_selector_channel(selector),
+        duration: duration,
+        timeout: timeout,
+      }.compact
+      @channel.send_message_to_server('tap', params)
+    end
+
+    def info(selector)
+      @channel.send_message_to_server('info', selector: to_selector_channel(selector))
+    end
+
+    def tree
+      @channel.send_message_to_server('tree')
+    end
+
+    def screenshot(path: nil)
+      encoded_binary = @channel.send_message_to_server('screenshot')
+      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 close
+      @channel.send_message_to_server('close')
+      emit(Events::AndroidDevice::Close)
+    end
+
+    def shell(command)
+      resp = @channel.send_message_to_server('shell', command: command)
+      Base64.strict_decode64(resp)
+    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

@@ -1,9 +1,12 @@
 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
-      @channel.on('close', method(:handle_close))
+      @channel.on('close', method(:on_close))
     end
 
     def contexts
@@ -14,30 +17,29 @@ 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(*args)
-      context = new_context(*args)
+    def new_page(**options)
+      context = new_context(**options)
       page = context.new_page
       page.owned_context = context
       context.owner_page = page
@@ -57,24 +59,15 @@ module Playwright
       @initializer['version']
     end
 
-    private
-
-    def handle_close(_ = {})
+    private def on_close(_ = {})
       @connected = false
       emit(Events::Browser::Disconnected)
       @closed_or_closing = false
     end
 
-    # @param err [Exception]
-    def safe_close_error?(err)
-      return true if err.is_a?(Transport::AlreadyDisconnectedError)
-
-      [
-        'Browser has been closed',
-        'Target page, context or browser has been closed',
-      ].any? do |closed_message|
-        err.message.end_with?(closed_message)
-      end
+    # called from BrowserContext#on_close with send(:remove_context), so keep private.
+    private def remove_context(context)
+      @contexts.delete(context)
     end
   end
 end

data/lib/playwright/channel_owners/browser_context.rb

@@ -1,13 +1,56 @@
 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
 
+    def after_initialize
+      @pages = Set.new
+
+      @channel.once('close', ->(_) { on_close })
+      @channel.on('page', ->(hash) { on_page(ChannelOwners::Page.from(hash['page']) )})
+    end
+
+    private def on_page(page)
+      page.send(:update_browser_context, self)
+      @pages << page
+      emit(Events::BrowserContext::Page, page)
+    end
+
+    def pages
+      @pages.to_a
+    end
+
     # @returns [Playwright::Page]
     def new_page
       raise 'Please use browser.new_context' if @owner_page
       resp = @channel.send_message_to_server('newPage')
       ChannelOwners::Page.from(resp)
     end
+
+    private def on_close
+      @closed_or_closing = true
+      @browser&.send(:remove_context, self)
+      emit(Events::BrowserContext::Close)
+    end
+
+    def close
+      return if @closed_or_closing
+      @closed_or_closing = true
+      @channel.send_message_to_server('close')
+      nil
+    rescue => err
+      raise unless safe_close_error?(err)
+    end
+
+    # called from Page#on_close with send(:remove_page, page), so keep private
+    private def remove_page(page)
+      @pages.delete(page)
+    end
+
+    # called from Page with send(:_timeout_settings), so keep private.
+    private def _timeout_settings
+      @timeout_settings
+    end
   end
 end

data/lib/playwright/channel_owners/console_message.rb

@@ -0,0 +1,21 @@
+module Playwright
+  define_channel_owner :ConsoleMessage do
+    def type
+      @initializer['type']
+    end
+
+    def text
+      @initializer['text']
+    end
+
+    def args
+      @initializer['args']&.map do |arg|
+        ChannelOwner.from(arg)
+      end
+    end
+
+    def location
+      @initialize['location']
+    end
+  end
+end

data/lib/playwright/channel_owners/element_handle.rb

@@ -0,0 +1,314 @@
+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,
+            delay: nil,
+            force: nil,
+            modifiers: nil,
+            noWaitAfter: nil,
+            position: nil,
+            timeout: nil)
+
+        params = {
+          button: button,
+          clickCount: clickCount,
+          delay: delay,
+          force: force,
+          modifiers: modifiers,
+          noWaitAfter: noWaitAfter,
+          position: position,
+          timeout: timeout,
+        }.compact
+        @channel.send_message_to_server('click', params)
+
+        nil
+      end
+
+      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,
+          noWaitAfter: noWaitAfter,
+          timeout: timeout,
+        }.compact
+        @channel.send_message_to_server('type', params)
+
+        nil
+      end
+
+      def press(key, delay: nil, noWaitAfter: nil, timeout: nil)
+        params = {
+          key: key,
+          delay: delay,
+          noWaitAfter: noWaitAfter,
+          timeout: timeout,
+        }.compact
+        @channel.send_message_to_server('press', params)
+
+        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)
+      end
+
+      def query_selector_all(selector)
+        @channel.send_message_to_server('querySelectorAll', selector: selector).map do |el|
+          ChannelOwners::ElementHandle.from(el)
+        end
+      end
+
+      def eval_on_selector(selector, pageFunction, arg: nil)
+        if JavaScript.function?(pageFunction)
+          JavaScript::Function.new(pageFunction, arg).eval_on_selector(@channel, selector)
+        else
+          JavaScript::Expression.new(pageFunction).eval_on_selector(@channel, selector)
+        end
+      end
+
+      def eval_on_selector_all(selector, pageFunction, arg: nil)
+        if JavaScript.function?(pageFunction)
+          JavaScript::Function.new(pageFunction, arg).eval_on_selector_all(@channel, selector)
+        else
+          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