playwright-ruby-client 0.0.6 → 0.2.0

data/lib/playwright/channel_owners/frame.rb

@@ -1,7 +1,7 @@
 module Playwright
   # @ref https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_frame.py
   define_channel_owner :Frame do
-    def after_initialize
+    private def after_initialize
       if @initializer['parentFrame']
         @parent_frame = ChannelOwners::Frame.from(@initializer['parentFrame'])
         @parent_frame.send(:append_child_frame_from_child, self)
@@ -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)
@@ -143,6 +144,55 @@ module Playwright
       end
     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
+
+    def checked?(selector, timeout: nil)
+      params = { selector: selector, timeout: timeout }.compact
+      @channel.send_message_to_server('isChecked', params)
+    end
+
+    def disabled?(selector, timeout: nil)
+      params = { selector: selector, timeout: timeout }.compact
+      @channel.send_message_to_server('isDisabled', params)
+    end
+
+    def editable?(selector, timeout: nil)
+      params = { selector: selector, timeout: timeout }.compact
+      @channel.send_message_to_server('isEditable', params)
+    end
+
+    def enabled?(selector, timeout: nil)
+      params = { selector: selector, timeout: timeout }.compact
+      @channel.send_message_to_server('isEnabled', params)
+    end
+
+    def hidden?(selector, timeout: nil)
+      params = { selector: selector, timeout: timeout }.compact
+      @channel.send_message_to_server('isHidden', params)
+    end
+
+    def visible?(selector, timeout: nil)
+      params = { selector: selector, timeout: timeout }.compact
+      @channel.send_message_to_server('isVisible', params)
+    end
+
+    def dispatch_event(selector, type, eventInit: nil, timeout: nil)
+      params = {
+        selector: selector,
+        type: type,
+        eventInit: JavaScript::ValueSerializer.new(eventInit).serialize,
+        timeout: timeout,
+      }.compact
+      @channel.send_message_to_server('dispatchEvent', params)
+
+      nil
+    end
+
     def eval_on_selector(selector, pageFunction, arg: nil)
       if JavaScript.function?(pageFunction)
         JavaScript::Function.new(pageFunction, arg).eval_on_selector(@channel, selector)
@@ -175,6 +225,47 @@ module Playwright
       nil
     end
 
+    def name
+      @name || ''
+    end
+
+    def url
+      @url || ''
+    end
+
+    def child_frames
+      @child_frames.to_a
+    end
+
+    def detached?
+      @detached
+    end
+
+    def add_script_tag(content: nil, path: nil, type: nil, url: nil)
+      params = {
+        content: content,
+        type: type,
+        url: url,
+      }.compact
+      if path
+        params[:content] = "#{File.read(path)}\n//# sourceURL=#{path}"
+      end
+      resp = @channel.send_message_to_server('addScriptTag', params)
+      ChannelOwners::ElementHandle.from(resp)
+    end
+
+    def add_style_tag(content: nil, path: nil, url: nil)
+      params = {
+        content: content,
+        url: url,
+      }.compact
+      if path
+        params[:content] = "#{File.read(path)}\n/*# sourceURL=#{path}*/"
+      end
+      resp = @channel.send_message_to_server('addStyleTag', params)
+      ChannelOwners::ElementHandle.from(resp)
+    end
+
     def click(
           selector,
           button: nil,
@@ -202,18 +293,145 @@ 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 tap_point(
+          selector,
+          force: nil,
+          modifiers: nil,
+          noWaitAfter: nil,
+          position: nil,
+          timeout: nil)
+      params = {
+        selector: selector,
+        force: force,
+        modifiers: modifiers,
+        noWaitAfter: noWaitAfter,
+        position: position,
+        timeout: timeout,
+      }.compact
+      @channel.send_message_to_server('tap', 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(
-      selector,
-      text,
-      delay: nil,
-      noWaitAfter: nil,
-      timeout: nil)
+    def text_content(selector, timeout: nil)
+      params = { selector: selector, timeout: timeout }.compact
+      @channel.send_message_to_server('textContent', params)
+    end
+
+    def inner_text(selector, timeout: nil)
+      params = { selector: selector, timeout: timeout }.compact
+      @channel.send_message_to_server('innerText', params)
+    end
+
+    def inner_html(selector, timeout: nil)
+      params = { selector: selector, timeout: timeout }.compact
+      @channel.send_message_to_server('innerHTML', params)
+    end
+
+    def get_attribute(selector, name, timeout: nil)
+      params = {
+        selector: selector,
+        name: name,
+        timeout: timeout,
+      }.compact
+      @channel.send_message_to_server('getAttribute', params)
+    end
+
+    def hover(
+          selector,
+          force: nil,
+          modifiers: nil,
+          position: nil,
+          timeout: nil)
+      params = {
+        selector: selector,
+        force: force,
+        modifiers: modifiers,
+        position: position,
+        timeout: timeout,
+      }.compact
+      @channel.send_message_to_server('hover', params)
+
+      nil
+    end
+
+    def select_option(
+          selector,
+          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 + { 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)
+      file_payloads = InputFiles.new(files).as_params
+      params = { files: file_payloads, selector: selector, noWaitAfter: noWaitAfter, timeout: timeout }.compact
+      @channel.send_message_to_server('setInputFiles', params)
+
+      nil
+    end
+
+    def type(
+          selector,
+          text,
+          delay: nil,
+          noWaitAfter: nil,
+          timeout: nil)
 
       params = {
         selector: selector,
@@ -222,16 +440,17 @@ module Playwright
         noWaitAfter: noWaitAfter,
         timeout: timeout,
       }.compact
-
       @channel.send_message_to_server('type', params)
+
+      nil
     end
 
     def press(
-      selector,
-      key,
-      delay: nil,
-      noWaitAfter: nil,
-      timeout: nil)
+          selector,
+          key,
+          delay: nil,
+          noWaitAfter: nil,
+          timeout: nil)
 
       params = {
         selector: selector,
@@ -240,20 +459,48 @@ module Playwright
         noWaitAfter: noWaitAfter,
         timeout: timeout,
       }.compact
-
       @channel.send_message_to_server('press', params)
+
+      nil
     end
 
-    def name
-      @name || ''
+    def check(selector, force: nil, noWaitAfter: nil, timeout: nil)
+      params = {
+        selector: selector,
+        force: force,
+        noWaitAfter:  noWaitAfter,
+        timeout: timeout,
+      }.compact
+      @channel.send_message_to_server('check', params)
+
+      nil
     end
 
-    def url
-      @url || ''
+    def uncheck(selector, force: nil, noWaitAfter: nil, timeout: nil)
+      params = {
+        selector: selector,
+        force: force,
+        noWaitAfter:  noWaitAfter,
+        timeout: timeout,
+      }.compact
+      @channel.send_message_to_server('uncheck', params)
+
+      nil
     end
 
-    def child_frames
-      @child_frames.to_a
+    def wait_for_function(pageFunction, arg: nil, polling: nil, timeout: nil)
+      if polling.is_a?(String) && polling != 'raf'
+        raise ArgumentError.new("Unknown polling option: #{polling}")
+      end
+
+      function_or_expression =
+        if JavaScript.function?(pageFunction)
+          JavaScript::Function.new(pageFunction, arg)
+        else
+          JavaScript::Expression.new(pageFunction)
+        end
+
+      function_or_expression.wait_for_function(@channel, polling: polling, timeout: timeout)
     end
 
     def title

data/lib/playwright/channel_owners/js_handle.rb

@@ -1,4 +1,55 @@
 module Playwright
   define_channel_owner :JSHandle do
+    private def after_initialize
+      @preview = @initializer['preview']
+      @channel.on('previewUpdated', method(:on_preview_updated))
+    end
+
+    def to_s
+      @preview
+    end
+
+    private def on_preview_updated(preview)
+      @preview = preview
+    end
+
+    def evaluate(pageFunction, arg: nil)
+      if JavaScript.function?(pageFunction)
+        JavaScript::Function.new(pageFunction, arg).evaluate(@channel)
+      else
+        JavaScript::Expression.new(pageFunction).evaluate(@channel)
+      end
+    end
+
+    def evaluate_handle(pageFunction, arg: nil)
+      if JavaScript.function?(pageFunction)
+        JavaScript::Function.new(pageFunction, arg).evaluate_handle(@channel)
+      else
+        JavaScript::Expression.new(pageFunction).evaluate_handle(@channel)
+      end
+    end
+
+    def get_properties
+      resp = @channel.send_message_to_server('getPropertyList')
+      resp.map { |prop| [prop['name'], ChannelOwner.from(prop['value'])] }.to_h
+    end
+
+    def get_property(name)
+      resp = @channel.send_message_to_server('getProperty', name: name)
+      ChannelOwner.from(resp)
+    end
+
+    def as_element
+      nil
+    end
+
+    def dispose
+      @channel.send_message_to_server('dispose')
+    end
+
+    def json_value
+      value = @channel.send_message_to_server('jsonValue')
+      JavaScript::ValueParser.new(value).parse
+    end
   end
 end

data/lib/playwright/channel_owners/page.rb

@@ -6,13 +6,13 @@ module Playwright
     include Utils::Errors::SafeCloseError
     attr_writer :owned_context
 
-    def after_initialize
+    private def after_initialize
       @browser_context = @parent
       @timeout_settings = TimeoutSettings.new(@browser_context.send(:_timeout_settings))
       @accessibility = Accessibility.new(@channel)
-      @keyboard = InputTypes::Keyboard.new(@channel)
-      @mouse = InputTypes::Mouse.new(@channel)
-      @touchscreen = InputTypes::Touchscreen.new(@channel)
+      @keyboard = KeyboardImpl.new(@channel)
+      @mouse = MouseImpl.new(@channel)
+      @touchscreen = TouchscreenImpl.new(@channel)
 
       @viewport_size = @initializer['viewportSize']
       @closed = false
@@ -26,7 +26,19 @@ module Playwright
         console_message = ChannelOwners::ConsoleMessage.from(params['message'])
         emit(Events::Page::Console, console_message)
       })
+      @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('fileChooser', ->(params) {
+        chooser = FileChooserImpl.new(
+                    page: self,
+                    element_handle: ChannelOwners::ElementHandle.from(params['element']),
+                    is_multiple: params['isMultiple'])
+        emit(Events::Page::FileChooser, chooser)
+      })
       @channel.on('frameAttached', ->(params) {
         on_frame_attached(ChannelOwners::Frame.from(params['frame']))
       })
@@ -34,9 +46,43 @@ module Playwright
         on_frame_detached(ChannelOwners::Frame.from(params['frame']))
       })
       @channel.on('load', ->(_) { emit(Events::Page::Load) })
+      @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']))
+      })
+      @channel.on('requestFailed', ->(params) {
+        on_request_failed(
+          ChannelOwners::Request.from(params['request']),
+          params['responseEndTiming'],
+          params['failureText'],
+        )
+      })
+      @channel.on('requestFinished', ->(params) {
+        on_request_finished(
+          ChannelOwners::Request.from(params['request']),
+          params['responseEndTiming'],
+        )
+      })
+      @channel.on('response', ->(params) {
+        emit(Events::Page::Response, ChannelOwners::Response.from(params['response']))
+      })
+      @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('webSocket', ->(params) {
+        emit(Events::Page::WebSocket, ChannelOwners::WebSocket.from(params['webSocket']))
+      })
+      @channel.on('worker', ->(params) {
+        on_worker(ChannelOwners::Worker.from(params['worker']))
+      })
     end
 
     attr_reader \
@@ -47,6 +93,17 @@ module Playwright
       :viewport_size,
       :main_frame
 
+    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)
+    end
+
+    private def on_request_finished(request, response_end_timing)
+      request.send(:update_response_end_timing, response_end_timing)
+      emit(Events::Page::RequestFinished)
+    end
+
     private def on_frame_attached(frame)
       frame.send(:update_page_from_page, self)
       @frames << frame
@@ -59,12 +116,48 @@ module Playwright
       emit(Events::Page::FrameDetached, frame)
     end
 
+    private def on_route(route, request)
+      # @routes.each ...
+      @browser_context.send(:on_route, route, request)
+    end
+
     private def on_close
       @closed = true
       @browser_context.send(:remove_page, self)
       emit(Events::Page::Close)
     end
 
+    private def on_dialog(params)
+      dialog = ChannelOwners::Dialog.from(params['dialog'])
+      unless emit(Events::Page::Dialog, dialog)
+        dialog.dismiss # FIXME: this should be asynchronous
+      end
+    end
+
+    # @override
+    def on(event, callback)
+      if event == Events::Page::FileChooser && listener_count(event) == 0
+        @channel.send_no_reply('setFileChooserInterceptedNoReply', intercepted: true)
+      end
+      super
+    end
+
+    # @override
+    def once(event, callback)
+      if event == Events::Page::FileChooser && listener_count(event) == 0
+        @channel.send_no_reply('setFileChooserInterceptedNoReply', intercepted: true)
+      end
+      super
+    end
+
+    # @override
+    def off(event, callback)
+      super
+      if event == Events::Page::FileChooser && listener_count(event) == 0
+        @channel.send_no_reply('setFileChooserInterceptedNoReply', intercepted: false)
+      end
+    end
+
     def context
       @browser_context
     end
@@ -74,14 +167,7 @@ module Playwright
       ChannelOwners::Page.from(resp)
     end
 
-    def frame(frameSelector)
-      name, url =
-        if frameSelector.is_a?(Hash)
-          [frameSelector[:name], frameSelector[:url]]
-        else
-          [frameSelector, nil]
-        end
-
+    def frame(name: nil, url: nil)
       if name
         @frames.find { |f| f.name == name }
       elsif url
@@ -103,6 +189,16 @@ module Playwright
       @frames.to_a
     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 query_selector(selector)
       @main_frame.query_selector(selector)
     end
@@ -111,6 +207,38 @@ module Playwright
       @main_frame.query_selector_all(selector)
     end
 
+    def wait_for_selector(selector, state: nil, timeout: nil)
+      @main_frame.wait_for_selector(selector, state: state, timeout: timeout)
+    end
+
+    def checked?(selector, timeout: nil)
+      @main_frame.checked?(selector, timeout: timeout)
+    end
+
+    def disabled?(selector, timeout: nil)
+      @main_frame.disabled?(selector, timeout: timeout)
+    end
+
+    def editable?(selector, timeout: nil)
+      @main_frame.editable?(selector, timeout: timeout)
+    end
+
+    def enabled?(selector, timeout: nil)
+      @main_frame.enabled?(selector, timeout: timeout)
+    end
+
+    def hidden?(selector, timeout: nil)
+      @main_frame.hidden?(selector, timeout: timeout)
+    end
+
+    def visible?(selector, timeout: nil)
+      @main_frame.visible?(selector, timeout: timeout)
+    end
+
+    def dispatch_event(selector, type, eventInit: nil, timeout: nil)
+      @main_frame.dispatch_event(selector, type, eventInit: eventInit, timeout: timeout)
+    end
+
     def evaluate(pageFunction, arg: nil)
       @main_frame.evaluate(pageFunction, arg: arg)
     end
@@ -127,6 +255,33 @@ module Playwright
       @main_frame.eval_on_selector_all(selector, pageFunction, arg: arg)
     end
 
+    def add_script_tag(content: nil, path: nil, type: nil, url: nil)
+      @main_frame.add_script_tag(content: content, path: path, type: type, url: url)
+    end
+
+    def add_style_tag(content: nil, path: nil, url: nil)
+      @main_frame.add_style_tag(content: content, path: path, url: url)
+    end
+
+    def expose_function(name, callback)
+      @channel.send_message_to_server('exposeBinding', name: name)
+      @bindings[name] = ->(_source, *args) { callback.call(*args) }
+    end
+
+    def expose_binding(name, callback, handle: nil)
+      params = {
+        name: name,
+        needsHandle: handle,
+      }.compact
+      @channel.send_message_to_server('exposeBinding', params)
+      @bindings[name] = callback
+    end
+
+    def set_extra_http_headers(headers)
+      serialized_headers = HttpHeaders.new(headers).as_serialized
+      @channel.send_message_to_server('setExtraHTTPHeaders', headers: serialized_headers)
+    end
+
     def url
       @main_frame.url
     end
@@ -143,12 +298,66 @@ module Playwright
       @main_frame.goto(url, timeout: timeout,  waitUntil: waitUntil, referer: referer)
     end
 
+    def reload(timeout: nil, waitUntil: nil)
+      params = {
+        timeout: timeout,
+        waitUntil: waitUntil,
+      }.compact
+      resp = @channel.send_message_to_server('reoad', params)
+      ChannelOwners::Response.from_nullable(resp)
+    end
+
+    def wait_for_load_state(state: nil, timeout: nil)
+      @main_frame.wait_for_load_state(state: state, timeout: timeout)
+    end
+
+    def go_back(timeout: nil, waitUntil: nil)
+      params = { timeout: timeout, waitUntil: waitUntil }.compact
+      resp = @channel.send_message_to_server('goBack', params)
+      ChannelOwners::Response.from_nullable(resp)
+    end
+
+    def go_forward(timeout: nil, waitUntil: nil)
+      params = { timeout: timeout, waitUntil: waitUntil }.compact
+      resp = @channel.send_message_to_server('goForward', params)
+      ChannelOwners::Response.from_nullable(resp)
+    end
+
+    def emulate_media(colorScheme: nil, media: nil)
+      params = {
+        colorScheme: colorScheme,
+        media: media,
+      }.compact
+      @channel.send_message_to_server('emulateMedia', params)
+
+      nil
+    end
+
     def set_viewport_size(viewportSize)
       @viewport_size = viewportSize
       @channel.send_message_to_server('setViewportSize', { viewportSize: viewportSize })
       nil
     end
 
+    def bring_to_front
+      @channel.send_message_to_server('bringToFront')
+      nil
+    end
+
+    def add_init_script(path: nil, script: nil)
+      source =
+        if path
+          File.read(path, 'r')
+        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 screenshot(
       path: nil,
       type: nil,
@@ -167,7 +376,7 @@ module Playwright
         timeout: timeout,
       }.compact
       encoded_binary = @channel.send_message_to_server('screenshot', params)
-      decoded_binary = Base64.decode64(encoded_binary)
+      decoded_binary = Base64.strict_decode64(encoded_binary)
       if path
         File.open(path, 'wb') do |f|
           f.write(decoded_binary)
@@ -217,18 +426,114 @@ module Playwright
       )
     end
 
+    def dblclick(
+          selector,
+          button: nil,
+          delay: nil,
+          force: nil,
+          modifiers: nil,
+          noWaitAfter: nil,
+          position: nil,
+          timeout: nil)
+      @main_frame.dblclick(
+        selector,
+        button: button,
+        delay: delay,
+        force: force,
+        modifiers: modifiers,
+        noWaitAfter: noWaitAfter,
+        position: position,
+        timeout: timeout,
+      )
+    end
+
+    def tap_point(
+          selector,
+          force: nil,
+          modifiers: nil,
+          noWaitAfter: nil,
+          position: nil,
+          timeout: nil)
+      @main_frame.tap_point(
+        selector,
+        force: force,
+        modifiers: modifiers,
+        noWaitAfter: noWaitAfter,
+        position: position,
+        timeout: timeout,
+      )
+    end
+
+    def fill(selector, value, noWaitAfter: nil, timeout: nil)
+      @main_frame.fill(selector, value, noWaitAfter: noWaitAfter, timeout: timeout)
+    end
+
     def focus(selector, timeout: nil)
       @main_frame.focus(selector, timeout: timeout)
     end
 
-    def type_text(
+    def text_content(selector, timeout: nil)
+      @main_frame.text_content(selector, timeout: timeout)
+    end
+
+    def inner_text(selector, timeout: nil)
+      @main_frame.inner_text(selector, timeout: timeout)
+    end
+
+    def inner_html(selector, timeout: nil)
+      @main_frame.inner_html(selector, timeout: timeout)
+    end
+
+    def get_attribute(selector, name, timeout: nil)
+      @main_frame.get_attribute(selector, name, timeout: timeout)
+    end
+
+    def hover(
+          selector,
+          force: nil,
+          modifiers: nil,
+          position: nil,
+          timeout: nil)
+      @main_frame.hover(
+        selector,
+        force: force,
+        modifiers: modifiers,
+        position: position,
+        timeout: timeout,
+      )
+    end
+
+    def select_option(
+          selector,
+          element: nil,
+          index: nil,
+          value: nil,
+          label: nil,
+          noWaitAfter: nil,
+          timeout: nil)
+      @main_frame.select_option(
+        selector,
+        element: element,
+        index: index,
+        value: value,
+        label: label,
+        noWaitAfter: noWaitAfter,
+        timeout: timeout,
+      )
+    end
+
+    def set_input_files(selector, files, noWaitAfter: nil, timeout: nil)
+      @main_frame.set_input_files(selector, files, noWaitAfter: noWaitAfter, timeout: timeout)
+    end
+
+    def type(
       selector,
       text,
       delay: nil,
       noWaitAfter: nil,
       timeout: nil)
 
-      @main_frame.type_text(selector, text, delay: delay, noWaitAfter: noWaitAfter, timeout: timeout)
+      @main_frame.type(selector, text, delay: delay, noWaitAfter: noWaitAfter, timeout: timeout)
     end
 
     def press(
@@ -241,6 +546,57 @@ 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)
+    end
+
+    def uncheck(selector, force: nil, noWaitAfter: nil, timeout: nil)
+      @main_frame.uncheck(selector, force: force, noWaitAfter: noWaitAfter, timeout: timeout)
+    end
+
+    def wait_for_function(pageFunction, arg: nil, polling: nil, timeout: nil)
+      @main_frame.wait_for_function(pageFunction, arg: arg, polling: polling, timeout: timeout)
+    end
+
+    def pdf(
+          displayHeaderFooter: nil,
+          footerTemplate: nil,
+          format: nil,
+          headerTemplate: nil,
+          height: nil,
+          landscape: nil,
+          margin: nil,
+          pageRanges: nil,
+          path: nil,
+          preferCSSPageSize: nil,
+          printBackground: nil,
+          scale: nil,
+          width: nil)
+
+      params = {
+        displayHeaderFooter: displayHeaderFooter,
+        footerTemplate: footerTemplate,
+        format: format,
+        headerTemplate: headerTemplate,
+        height: height,
+        landscape: landscape,
+        margin: margin,
+        pageRanges: pageRanges,
+        preferCSSPageSize: preferCSSPageSize,
+        printBackground: printBackground,
+        scale: scale,
+        width: width,
+      }.compact
+      encoded_binary = @channel.send_message_to_server('pdf', 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
+
     class CrashedError < StandardError
       def initialize
         super('Page crashed')
@@ -259,20 +615,9 @@ module Playwright
       end
     end
 
-    def wait_for_event(event, optionsOrPredicate: nil, &block)
-      predicate, timeout =
-        case optionsOrPredicate
-        when Proc
-          [optionsOrPredicate, nil]
-        when Hash
-          [optionsOrPredicate[:predicate], optionsOrPredicate[:timeout]]
-        else
-          [nil, nil]
-        end
-      timeout ||= @timeout_settings.timeout
-
+    def expect_event(event, predicate: nil, timeout: nil, &block)
       wait_helper = WaitHelper.new
-      wait_helper.reject_on_timeout(timeout, "Timeout while waiting for event \"#{event}\"")
+      wait_helper.reject_on_timeout(timeout || @timeout_settings.timeout, "Timeout while waiting for event \"#{event}\"")
 
       unless event == Events::Page::Crash
         wait_helper.reject_on_event(self, Events::Page::Crash, CrashedError.new)
@@ -289,15 +634,15 @@ module Playwright
       wait_helper.promise.value!
     end
 
-    def wait_for_navigation(timeout: nil, url: nil, waitUntil: nil, &block)
-      @main_frame.wait_for_navigation(
+    def expect_navigation(timeout: nil, url: nil, waitUntil: nil, &block)
+      @main_frame.expect_navigation(
         timeout: timeout,
         url: url,
         waitUntil: waitUntil,
         &block)
     end
 
-    def wait_for_request(urlOrPredicate, timeout: nil)
+    def expect_request(urlOrPredicate, timeout: nil)
       predicate =
         case urlOrPredicate
         when String, Regexp
@@ -309,10 +654,10 @@ module Playwright
           -> (_) { true }
         end
 
-      wait_for_event(Events::Page::Request, optionsOrPredicate: { predicate: predicate, timeout: timeout})
+      expect_event(Events::Page::Request, predicate: predicate, timeout: timeout)
     end
 
-    def wait_for_response(urlOrPredicate, timeout: nil)
+    def expect_response(urlOrPredicate, timeout: nil)
       predicate =
         case urlOrPredicate
         when String, Regexp
@@ -324,7 +669,7 @@ module Playwright
           -> (_) { true }
         end
 
-      wait_for_event(Events::Page::Response, optionsOrPredicate: { predicate: predicate, timeout: timeout})
+      expect_event(Events::Page::Response, predicate: predicate, timeout: timeout)
     end
 
     # called from BrowserContext#on_page with send(:update_browser_context, page), so keep private.