playwright-ruby-client 1.14.beta3 → 1.15.beta3

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/browser_type.rb

@@ -42,7 +42,6 @@ module Playwright
       raise 'Connecting over CDP is only supported in Chromium.' unless name == 'chromium'
 
       params = {
-        sdkLanguage: 'ruby',
         endpointURL: endpointURL,
         headers: headers,
         slowMo: slowMo,

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/frame.rb

@@ -584,6 +584,14 @@ 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)
     end

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/playwright.rb

@@ -30,6 +30,15 @@ module Playwright
       end.to_h
     end
 
+    # used only from Playwright#connect_to_browser_server
+    private def pre_launched_browser
+      unless @initializer['preLaunchedBrowser']
+        raise 'Malformed endpoint. Did you use launchServer method?'
+      end
+
+      ::Playwright::ChannelOwners::Browser.from(@initializer['preLaunchedBrowser'])
+    end
+
     private def parse_device_descriptor(descriptor)
       # This return value can be passed into Browser#new_context as it is.
       # ex:

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