playwright-ruby-client 1.15.beta1 → 1.16.beta1

data/lib/playwright/channel.rb

@@ -30,16 +30,50 @@ module Playwright
     # @param params [Hash]
     # @return [Hash]
     def send_message_to_server_result(method, params)
-      @connection.send_message_to_server(@guid, method, params)
+      with_logging do |metadata|
+        @connection.send_message_to_server(@guid, method, params, metadata: metadata)
+      end
     end
 
     # @param method [String]
     # @param params [Hash]
     # @returns nil
     def async_send_message_to_server(method, params = {})
-      @connection.async_send_message_to_server(@guid, method, params)
+      with_logging do |metadata|
+        @connection.async_send_message_to_server(@guid, method, params, metadata: metadata)
+      end
 
       nil
     end
+
+    private def with_logging(&block)
+      locations = caller_locations
+      first_api_call_location_idx = locations.index { |loc| loc.absolute_path.include?('playwright_api') }
+      unless first_api_call_location_idx
+        return block.call(nil)
+      end
+
+      locations = locations.slice(first_api_call_location_idx..-1)
+
+      api_call_location = locations.shift
+
+      api_class = File.basename(api_call_location.absolute_path, '.rb')
+      api_method = api_call_location.label
+      api_name = "#{api_class}##{api_method}"
+
+      stacks = locations
+
+      metadata = build_metadata_payload_from(api_name, stacks)
+      block.call(metadata)
+    end
+
+    private def build_metadata_payload_from(api_name, stacks)
+      {
+        apiName: api_name,
+        stack: stacks.map do |loc|
+          { file: loc.absolute_path, line: loc.lineno, function: loc.label }
+        end,
+      }
+    end
   end
 end

data/lib/playwright/channel_owners/artifact.rb

@@ -1,14 +1,14 @@
 module Playwright
   define_channel_owner :Artifact do
     private def after_initialize
-      @is_remote = false
+      @remote = false
       @absolute_path = @initializer['absolutePath']
     end
 
     attr_reader :absolute_path
 
     def path_after_finished
-      if @is_remote
+      if @remote
         raise "Path is not available when using browser_type.connect(). Use save_as() to save a local copy."
       end
       @channel.send_message_to_server('pathAfterFinished')
@@ -30,5 +30,9 @@ module Playwright
     def cancel
       @channel.send_message_to_server('cancel')
     end
+
+    private def update_as_remote
+      @remote = true
+    end
   end
 end

data/lib/playwright/channel_owners/browser.rb

@@ -104,6 +104,10 @@ module Playwright
       @remote = true
     end
 
+    private def remote?
+      @remote
+    end
+
     # called from BrowserContext#on_close with send(:remove_context), so keep private.
     private def remove_context(context)
       @contexts.delete(context)

data/lib/playwright/channel_owners/browser_context.rb

@@ -30,7 +30,7 @@ module Playwright
       @channel.on('request', ->(params) {
         on_request(
           ChannelOwners::Request.from(params['request']),
-          ChannelOwners::Request.from_nullable(params['page']),
+          ChannelOwners::Page.from_nullable(params['page']),
         )
       })
       @channel.on('requestFailed', ->(params) {
@@ -38,20 +38,14 @@ module Playwright
           ChannelOwners::Request.from(params['request']),
           params['responseEndTiming'],
           params['failureText'],
-          ChannelOwners::Request.from_nullable(params['page']),
-        )
-      })
-      @channel.on('requestFinished', ->(params) {
-        on_request_finished(
-          ChannelOwners::Request.from(params['request']),
-          params['responseEndTiming'],
-          ChannelOwners::Request.from_nullable(params['page']),
+          ChannelOwners::Page.from_nullable(params['page']),
         )
       })
+      @channel.on('requestFinished', method(:on_request_finished))
       @channel.on('response', ->(params) {
         on_response(
           ChannelOwners::Response.from(params['response']),
-          ChannelOwners::Request.from_nullable(params['page']),
+          ChannelOwners::Page.from_nullable(params['page']),
         )
       })
 
@@ -95,10 +89,15 @@ module Playwright
       page&.emit(Events::Page::RequestFailed, request)
     end
 
-    private def on_request_finished(request, response_end_timing, page)
-      request.send(:update_response_end_timing, response_end_timing)
+    private def on_request_finished(params)
+      request = ChannelOwners::Request.from(params['request'])
+      response = ChannelOwners::Response.from_nullable(params['response'])
+      page = ChannelOwners::Page.from_nullable(params['page'])
+
+      request.send(:update_response_end_timing, params['responseEndTiming'])
       emit(Events::BrowserContext::RequestFinished, request)
       page&.emit(Events::Page::RequestFinished, request)
+      response&.send(:mark_as_finished)
     end
 
     private def on_request(request, page)
@@ -236,8 +235,8 @@ module Playwright
       expose_binding(name, ->(_source, *args) { callback.call(*args) }, )
     end
 
-    def route(url, handler)
-      entry = RouteHandlerEntry.new(url, base_url, handler)
+    def route(url, handler, times: nil)
+      entry = RouteHandler.new(url, base_url, handler, times)
       @routes.unshift(entry)
       if @routes.count >= 1
         @channel.send_message_to_server('setNetworkInterceptionEnabled', enabled: true)
@@ -270,6 +269,14 @@ module Playwright
     end
 
     def close
+      if @options && @options.key?(:recordHar)
+        har = ChannelOwners::Artifact.from(@channel.send_message_to_server('harExport'))
+        if @browser.send(:remote?)
+          har.update_as_remote
+        end
+        har.save_as(@options[:recordHar][:path])
+        har.delete
+      end
       @channel.send_message_to_server('close')
       @closed_promise.value!
       nil

data/lib/playwright/channel_owners/element_handle.rb

@@ -268,6 +268,14 @@ module Playwright
         nil
       end
 
+      def set_checked(checked, **options)
+        if checked
+          check(**options)
+        else
+          uncheck(**options)
+        end
+      end
+
       def bounding_box
         @channel.send_message_to_server('boundingBox')
       end
@@ -322,8 +330,8 @@ module Playwright
         nil
       end
 
-      def wait_for_selector(selector, state: nil, timeout: nil)
-        params = { selector: selector, state: state, timeout: timeout }.compact
+      def wait_for_selector(selector, state: nil, strict: nil, timeout: nil)
+        params = { selector: selector, state: state, strict: strict, timeout: timeout }.compact
         resp = @channel.send_message_to_server('waitForSelector', params)
 
         ChannelOwners::ElementHandle.from_nullable(resp)

data/lib/playwright/channel_owners/fetch_request.rb

@@ -0,0 +1,4 @@
+module Playwright
+  define_channel_owner :FetchRequest do
+  end
+end

data/lib/playwright/channel_owners/frame.rb

@@ -584,8 +584,18 @@ module Playwright
       nil
     end
 
+    def set_checked(selector, checked, **options)
+      if checked
+        check(selector, **options)
+      else
+        uncheck(selector, **options)
+      end
+    end
+
     def wait_for_timeout(timeout)
-      sleep(timeout / 1000.0)
+      @channel.send_message_to_server('waitForTimeout', timeout: timeout)
+
+      nil
     end
 
     def wait_for_function(pageFunction, arg: nil, polling: nil, timeout: nil)

data/lib/playwright/channel_owners/page.rb

@@ -132,17 +132,24 @@ module Playwright
     end
 
     private def on_download(params)
+      artifact = ChannelOwners::Artifact.from(params['artifact'])
+      if @browser_context.browser.send(:remote?)
+        artifact.update_as_remote
+      end
       download = DownloadImpl.new(
         page: self,
         url: params['url'],
         suggested_filename: params['suggestedFilename'],
-        artifact: ChannelOwners::Artifact.from(params['artifact']),
+        artifact: artifact,
       )
       emit(Events::Page::Download, download)
     end
 
     private def on_video(params)
       artifact = ChannelOwners::Artifact.from(params['artifact'])
+      if @browser_context.browser.send(:remote?)
+        artifact.update_as_remote
+      end
       video.send(:set_artifact, artifact)
     end
 
@@ -345,9 +352,10 @@ module Playwright
       ChannelOwners::Response.from_nullable(resp)
     end
 
-    def emulate_media(colorScheme: nil, media: nil, reducedMotion: nil)
+    def emulate_media(colorScheme: nil, forcedColors: nil, media: nil, reducedMotion: nil)
       params = {
         colorScheme: colorScheme,
+        forcedColors: forcedColors,
         media: media,
         reducedMotion: reducedMotion,
       }.compact
@@ -381,8 +389,8 @@ module Playwright
       nil
     end
 
-    def route(url, handler)
-      entry = RouteHandlerEntry.new(url, @browser_context.send(:base_url), handler)
+    def route(url, handler, times: nil)
+      entry = RouteHandler.new(url, @browser_context.send(:base_url), handler, times)
       @routes.unshift(entry)
       if @routes.count >= 1
         @channel.send_message_to_server('setNetworkInterceptionEnabled', enabled: true)
@@ -702,6 +710,14 @@ module Playwright
         trial: trial)
     end
 
+    def set_checked(selector, checked, **options)
+      if checked
+        check(selector, **options)
+      else
+        uncheck(selector, **options)
+      end
+    end
+
     def wait_for_timeout(timeout)
       @main_frame.wait_for_timeout(timeout)
     end

data/lib/playwright/channel_owners/request.rb

@@ -6,6 +6,7 @@ module Playwright
     private def after_initialize
       @redirected_from = ChannelOwners::Request.from_nullable(@initializer['redirectedFrom'])
       @redirected_from&.send(:update_redirected_to, self)
+      @provisional_headers = RawHeaders.new(@initializer['headers'])
       @timing = {
         startTime: 0,
         domainLookupStart: -1,
@@ -17,7 +18,6 @@ module Playwright
         responseStart: -1,
         responseEnd: -1,
       }
-      @headers = parse_headers(@initializer['headers'])
     end
 
     def url
@@ -40,7 +40,7 @@ module Playwright
       data = post_data
       return unless data
 
-      content_type = @headers['content-type']
+      content_type = headers['content-type']
       return unless content_type
 
       if content_type == "application/x-www-form-urlencoded"
@@ -59,10 +59,6 @@ module Playwright
       end
     end
 
-    def headers
-      @headers
-    end
-
     def response
       resp = @channel.send_message_to_server('response')
       ChannelOwners::Response.from_nullable(resp)
@@ -80,7 +76,57 @@ module Playwright
       @failure_text
     end
 
-    attr_reader :headers, :redirected_from, :redirected_to, :timing
+    attr_reader :redirected_from, :redirected_to, :timing
+
+    def headers
+      @provisional_headers.headers
+    end
+
+    # @return [RawHeaders|nil]
+    private def actual_headers
+      @actual_headers ||= response&.send(:raw_request_headers)
+    end
+
+    def all_headers
+      if actual_headers
+        actual_headers.headers
+      else
+        @provisional_headers.headers
+      end
+    end
+
+    def headers_array
+      if actual_headers
+        actual_headers.headers_array
+      else
+        @provisional_headers.headers_array
+      end
+    end
+
+    def header_value(name)
+      if actual_headers
+        actual_headers.get(name)
+      else
+        @provisional_headers.get(name)
+      end
+    end
+
+    def header_values(name)
+      if actual_headers
+        actual_headers.get_all(name)
+      else
+        @provisional_headers.get_all(name)
+      end
+    end
+
+    def sizes
+      res = response
+      unless res
+        raise 'Unable to fetch sizes for failed request'
+      end
+
+      res.send(:sizes)
+    end
 
     private def update_redirected_to(request)
       @redirected_to = request
@@ -110,18 +156,8 @@ module Playwright
       @timing[:responseStart] = response_start
     end
 
-    private def update_headers(headers)
-      @headers = parse_headers(headers)
-    end
-
     private def update_response_end_timing(response_end_timing)
       @timing[:responseEnd] = response_end_timing
     end
-
-    private def parse_headers(headers)
-      headers.map do |header|
-        [header['name'].downcase, header['value']]
-      end.to_h
-    end
   end
 end

data/lib/playwright/channel_owners/response.rb

@@ -5,6 +5,7 @@ module Playwright
   # @ref https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_network.py
   define_channel_owner :Response do
     private def after_initialize
+      @provisional_headers = RawHeaders.new(@initializer['headers'])
       @request = ChannelOwners::Request.from(@initializer['request'])
       timing = @initializer['timing']
       @request.send(:update_timings,
@@ -17,7 +18,7 @@ module Playwright
         request_start: timing["requestStart"],
         response_start: timing["responseStart"],
       )
-      @request.send(:update_headers, @initializer['requestHeaders'])
+      @finished_promise = Concurrent::Promises.resolvable_future
     end
     attr_reader :request
 
@@ -39,9 +40,36 @@ module Playwright
     end
 
     def headers
-      @initializer['headers'].map do |header|
-        [header['name'].downcase, header['value']]
-      end.to_h
+      @provisional_headers.headers
+    end
+
+    # @return [RawHeaders]
+    private def actual_headers
+      @actual_headers ||= raw_response_headers
+    end
+
+    private def raw_request_headers
+      RawHeaders.new(@channel.send_message_to_server('rawRequestHeaders'))
+    end
+
+    private def raw_response_headers
+      RawHeaders.new(@channel.send_message_to_server('rawResponseHeaders'))
+    end
+
+    def all_headers
+      actual_headers.headers
+    end
+
+    def headers_array
+      actual_headers.headers_array
+    end
+
+    def header_value(name)
+      actual_headers.get(name)
+    end
+
+    def header_values(name)
+      actual_headers.get_all(name)
     end
 
     def server_addr
@@ -53,7 +81,7 @@ module Playwright
     end
 
     def finished
-      @channel.send_message_to_server('finished')
+      @finished_promise.value!
     end
 
     def body
@@ -69,5 +97,20 @@ module Playwright
     def frame
       @request.frame
     end
+
+    private def sizes
+      resp = @channel.send_message_to_server('sizes')
+
+      {
+        requestBodySize: resp['requestBodySize'],
+        requestHeadersSize: resp['requestHeadersSize'],
+        responseBodySize: resp['responseBodySize'],
+        responseHeadersSize: resp['responseHeadersSize'],
+      }
+    end
+
+    private def mark_as_finished
+      @finished_promise.fulfill(nil)
+    end
   end
 end

data/lib/playwright/connection.rb

@@ -36,7 +36,7 @@ module Playwright
       ChannelOwners::Playwright.from(result['playwright'])
     end
 
-    def async_send_message_to_server(guid, method, params)
+    def async_send_message_to_server(guid, method, params, metadata: nil)
       callback = Concurrent::Promises.resolvable_future
 
       with_generated_id do |id|
@@ -49,7 +49,9 @@ module Playwright
           guid: guid,
           method: method,
           params: replace_channels_with_guids(params),
+          metadata: metadata || {},
         }
+
         begin
           @transport.send_message(message)
         rescue => err
@@ -62,8 +64,8 @@ module Playwright
       callback
     end
 
-    def send_message_to_server(guid, method, params)
-      async_send_message_to_server(guid, method, params).value!
+    def send_message_to_server(guid, method, params, metadata: nil)
+      async_send_message_to_server(guid, method, params, metadata: metadata).value!
     end
 
     private

data/lib/playwright/http_headers.rb

@@ -10,11 +10,5 @@ module Playwright
         { name: key, value: value }
       end
     end
-
-    def self.parse_serialized(serialized_headers)
-      new(serialized_headers.map do |header|
-        [header['name'].downcase, header['value']]
-      end.to_h)
-    end
   end
 end

data/lib/playwright/locator_impl.rb

@@ -303,6 +303,18 @@ module Playwright
         trial: trial)
     end
 
+    def wait_for(state: nil, timeout: nil)
+      @frame.wait_for_selector(@selector, strict: true, state: state, timeout: timeout)
+    end
+
+    def set_checked(checked, **options)
+      if checked
+        check(**options)
+      else
+        uncheck(**options)
+      end
+    end
+
     def all_inner_texts
       @frame.eval_on_selector_all(@selector, 'ee => ee.map(e => e.innerText)')
     end

data/lib/playwright/mouse_impl.rb

@@ -44,5 +44,14 @@ module Playwright
     def dblclick(x, y, button: nil, delay: nil)
       click(x, y, button: button, clickCount: 2, delay: delay)
     end
+
+    def wheel(deltaX, deltaY)
+      params = {
+        deltaX: deltaX,
+        deltaY: deltaY,
+      }
+      @channel.send_message_to_server('mouseWheel', params)
+      nil
+    end
   end
 end

data/lib/playwright/raw_headers.rb

@@ -0,0 +1,61 @@
+module Playwright
+  class RawHeaders
+    def initialize(headers_array)
+      h_array = []
+      h_map = {}
+      headers_array.each do |header|
+        name = header['name']
+        key = name.downcase
+        value = header['value']
+
+        h_array << [name, value]
+        h_map[key] ||= []
+        h_map[key] << value
+      end
+
+      @headers_array = h_array
+      @headers_map = h_map
+    end
+
+    # @return [String|nil]
+    def get(name)
+      key = name.downcase
+      values = @headers_map[key]
+      if values
+        join(key, values)
+      else
+        nil
+      end
+    end
+
+    # @return [Array<String>]
+    def get_all(name)
+      values = @headers_map[name.downcase]
+      if values
+        values.dup
+      else
+        []
+      end
+    end
+
+    def headers
+      @headers_map.map do |key, values|
+        [key, join(key, values)]
+      end.to_h
+    end
+
+    def headers_array
+      @headers_array.map do |name, value|
+        { name: name, value: value }
+      end
+    end
+
+    private def join(key, values)
+      if key == 'set-cookie'
+        values.join("\n")
+      else
+        values.join(", ")
+      end
+    end
+  end
+end

data/lib/playwright/{route_handler_entry.rb → route_handler.rb}

@@ -1,15 +1,43 @@
 module Playwright
-  class RouteHandlerEntry
+  class RouteHandler
+    class CountDown
+      def initialize(count)
+        @count = count
+      end
+
+      def handle
+        return false if @count <= 0
+
+        @count = @count - 1
+        true
+      end
+    end
+
+    class StubCounter
+      def handle
+        true
+      end
+    end
+
     # @param url [String]
     # @param base_url [String|nil]
     # @param handler [Proc]
-    def initialize(url, base_url, handler)
+    # @param times [Integer|nil]
+    def initialize(url, base_url, handler, times)
       @url_value = url
       @url_matcher = UrlMatcher.new(url, base_url: base_url)
       @handler = handler
+      @counter =
+        if times
+          CountDown.new(times)
+        else
+          StubCounter.new
+        end
     end
 
     def handle(route, request)
+      return false unless @counter.handle
+
       if @url_matcher.match?(request.url)
         @handler.call(route, request)
         true