playwright-ruby-client 0.3.0 → 0.5.6

data/lib/playwright/channel_owners/frame.rb

@@ -98,6 +98,15 @@ module Playwright
       request&.response
     end
 
+    def wait_for_url(url, timeout: nil, waitUntil: nil)
+      matcher = UrlMatcher.new(url)
+      if matcher.match?(@url)
+        wait_for_load_state(state: waitUntil, timeout: timeout)
+      else
+        expect_navigation(timeout: timeout, url: url, waitUntil: waitUntil)
+      end
+    end
+
     def wait_for_load_state(state: nil, timeout: nil)
       option_state = state || 'load'
       option_timeout = timeout || @page.send(:timeout_settings).navigation_timeout
@@ -412,10 +421,8 @@ module Playwright
         value: value,
         label: label,
       ).as_params
-      params = base_params + { selector: selector, noWaitAfter: noWaitAfter, timeout: timeout }.compact
+      params = base_params.merge({ selector: selector, noWaitAfter: noWaitAfter, timeout: timeout }.compact)
       @channel.send_message_to_server('selectOption', params)
-
-      nil
     end
 
     def set_input_files(selector, files, noWaitAfter: nil, timeout: nil)
@@ -464,11 +471,18 @@ module Playwright
       nil
     end
 
-    def check(selector, force: nil, noWaitAfter: nil, timeout: nil)
+    def check(
+      selector,
+      force: nil,
+      noWaitAfter: nil,
+      position: nil,
+      timeout: nil)
+
       params = {
         selector: selector,
         force: force,
         noWaitAfter:  noWaitAfter,
+        position: position,
         timeout: timeout,
       }.compact
       @channel.send_message_to_server('check', params)
@@ -476,11 +490,18 @@ module Playwright
       nil
     end
 
-    def uncheck(selector, force: nil, noWaitAfter: nil, timeout: nil)
+    def uncheck(
+      selector,
+      force: nil,
+      noWaitAfter: nil,
+      position: nil,
+      timeout: nil)
+
       params = {
         selector: selector,
         force: force,
         noWaitAfter:  noWaitAfter,
+        position: position,
         timeout: timeout,
       }.compact
       @channel.send_message_to_server('uncheck', params)

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

@@ -28,6 +28,7 @@ module Playwright
       @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) {
@@ -37,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,
@@ -57,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']))
       })
@@ -82,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']))
       })
@@ -149,6 +143,20 @@ module Playwright
       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
@@ -178,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)
@@ -326,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)
@@ -578,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)
@@ -629,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')

data/lib/playwright/channel_owners/playwright.rb

@@ -24,38 +24,31 @@ module Playwright
       @selectors ||= ::Playwright::ChannelOwners::Selectors.from(@initializer['selectors'])
     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
-    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/stream.rb

@@ -0,0 +1,15 @@
+require 'base64'
+
+module Playwright
+  define_channel_owner :Stream do
+    def save_as(path)
+      File.open(path, 'wb') do |f|
+        loop do
+          binary = @channel.send_message_to_server('read')
+          break if !binary || binary.length == 0
+          f.write(Base64.strict_decode64(binary))
+        end
+      end
+    end
+  end
+end

data/lib/playwright/connection.rb

@@ -12,6 +12,12 @@ module Playwright
       @transport.on_message_received do |message|
         dispatch(message)
       end
+      @transport.on_driver_crashed do
+        @callbacks.each_value do |callback|
+          callback.reject(::Playwright::DriverCrashedError.new)
+        end
+        raise ::Playwright::DriverCrashedError.new
+      end
 
       @objects = {} # Hash[ guid => ChannelOwner ]
       @waiting_for_object = {} # Hash[ guid => Promise<ChannelOwner> ]
@@ -19,26 +25,22 @@ module Playwright
       @root_object = RootChannelOwner.new(self)
     end
 
-    def run
-      @transport.run
+    def async_run
+      @transport.async_run
     end
 
     def stop
       @transport.stop
     end
 
-    def async_wait_for_object_with_known_name(guid)
+    def wait_for_object_with_known_name(guid)
       if @objects[guid]
         return @objects[guid]
       end
 
       callback = Concurrent::Promises.resolvable_future
       @waiting_for_object[guid] = callback
-      callback
-    end
-
-    def wait_for_object_with_known_name(guid)
-      async_wait_for_object_with_known_name.value!
+      callback.value!
     end
 
     def async_send_message_to_server(guid, method, params)
@@ -195,32 +197,9 @@ module Playwright
       end
       initializer = replace_guids_with_channels(initializer)
 
-      class_name = case type
-      when 'Browser'
-        case initializer['name']
-        when 'chromium'
-          'ChromiumBrowser'
-        when 'webkit'
-          'WebKitBrowser'
-        when 'firefox'
-          'FirefoxBrowser'
-        else
-          'Browser'
-        end
-      when 'BrowserContext'
-        browser_name = initializer['browserName']
-        if browser_name == 'chromium'
-          'ChromiumBrowserContext'
-        else
-          'BrowserContext'
-        end
-      else
-        type
-      end
-
       result =
         begin
-          ChannelOwners.const_get(class_name).new(
+          ChannelOwners.const_get(type).new(
             parent,
             type,
             guid,

data/lib/playwright/download.rb

@@ -0,0 +1,27 @@
+module Playwright
+  class Download
+    def initialize(url:, suggested_filename:, artifact:)
+      @url = url
+      @suggested_filename = suggested_filename
+      @artifact = artifact
+    end
+
+    attr_reader :url, :suggested_filename
+
+    def delete
+      @artifact.delete
+    end
+
+    def failure
+      @artifact.failure
+    end
+
+    def path
+      @artifact.path_after_finished
+    end
+
+    def save_as(path)
+      @artifact.save_as(path)
+    end
+  end
+end

data/lib/playwright/errors.rb

@@ -27,6 +27,12 @@ module Playwright
     end
   end
 
+  class DriverCrashedError < StandardError
+    def initialize
+      super("[BUG] Playwright driver is crashed!")
+    end
+  end
+
   class TimeoutError < Error
     def initialize(message:, stack: [])
       super(name: 'TimeoutError', message: message, stack: stack)

data/lib/playwright/events.rb

@@ -24,8 +24,10 @@ end
   },
 
   BrowserContext: {
+    BackgroundPage: 'backgroundpage',
     Close: 'close',
     Page: 'page',
+    ServiceWorker: 'serviceworker',
   },
 
   BrowserServer: {
@@ -67,11 +69,6 @@ end
     Close: 'close',
   },
 
-  ChromiumBrowserContext: {
-    BackgroundPage: 'backgroundpage',
-    ServiceWorker: 'serviceworker',
-  },
-
   ElectronApplication: {
     Close: 'close',
     Window: 'window',