puppeteer-ruby 0.0.15 → 0.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9bff69308f1dc62011bd6278beb2883c5f16b42dfae0d138c8a442c0ed78cd93
-  data.tar.gz: f336776cfc903db13391c11110650d8103e0eb291fa9a9d79366c9b0f9544b9e
+  metadata.gz: 38a6ae4190bd04cbacb863d04f9862ebc8a37c6811fbfd690426ba051d5ea5d4
+  data.tar.gz: 60b61e143e63ed5e42b0bb6f3d9e5c27262fd2f51064c185e491056a5081707d
 SHA512:
-  metadata.gz: fe90923f1c31681ec8bc0c092a9ca59976d18f682a99491de57f764f76b35ce27482f47b08348adc84f0b09e215c8cfe788730cb53d776b4922d1e397509ab23
-  data.tar.gz: ea4cb7f51c4944d082592c2a6fad51c69e8c3e6f356d6c5e6867cf9da3821249e346db7beee103e96a74f517ee929dcc1c865f79a07837a5f8c10efac357f748
+  metadata.gz: fc3ab652476ee319fab2d691173a0175d4b03d72346329f2fb855a142c3090693f1fb5cfa52abb4badbfbadc7d4eec5028a295f63fb7ddd3e362321564a96b7c
+  data.tar.gz: 6de2484b1b939c3cab1bfa48bb2225c54686f13e7901f3df086d8e5c7b18aa9fc62afb5fd9a785a3fbbf12d2aef50cde1d085f3564ce9afab996f80a39c64936

data/lib/puppeteer.rb

@@ -36,6 +36,8 @@ require 'puppeteer/mouse'
 require 'puppeteer/network_manager'
 require 'puppeteer/page'
 require 'puppeteer/remote_object'
+require 'puppeteer/request'
+require 'puppeteer/response'
 require 'puppeteer/target'
 require 'puppeteer/timeout_settings'
 require 'puppeteer/touch_screen'

data/lib/puppeteer/frame.rb

@@ -208,28 +208,6 @@ class Puppeteer::Frame
 
   define_async_method :async_type_text
 
-  # /**
-  #  * @param {(string|number|Function)} selectorOrFunctionOrTimeout
-  #  * @param {!Object=} options
-  #  * @param {!Array<*>} args
-  #  * @return {!Promise<?Puppeteer.JSHandle>}
-  #  */
-  # waitFor(selectorOrFunctionOrTimeout, options = {}, ...args) {
-  #   const xPathPattern = '//';
-
-  #   if (helper.isString(selectorOrFunctionOrTimeout)) {
-  #     const string = /** @type {string} */ (selectorOrFunctionOrTimeout);
-  #     if (string.startsWith(xPathPattern))
-  #       return this.waitForXPath(string, options);
-  #     return this.waitForSelector(string, options);
-  #   }
-  #   if (helper.isNumber(selectorOrFunctionOrTimeout))
-  #     return new Promise(fulfill => setTimeout(fulfill, /** @type {number} */ (selectorOrFunctionOrTimeout)));
-  #   if (typeof selectorOrFunctionOrTimeout === 'function')
-  #     return this.waitForFunction(selectorOrFunctionOrTimeout, options, ...args);
-  #   return Promise.reject(new Error('Unsupported target type: ' + (typeof selectorOrFunctionOrTimeout)));
-  # }
-
   # @param selector [String]
   # @param visible [Boolean] Wait for element visible (not 'display: none' nor 'visibility: hidden') on true. default to false.
   # @param hidden [Boolean] Wait for element invisible ('display: none' nor 'visibility: hidden') on true. default to false.

data/lib/puppeteer/network_manager.rb

@@ -1,5 +1,7 @@
 class Puppeteer::NetworkManager
+  include Puppeteer::DebugPrint
   include Puppeteer::EventCallbackable
+  include Puppeteer::IfPresent
 
   class Credentials
     # @param username [String|NilClass]
@@ -23,19 +25,39 @@ class Puppeteer::NetworkManager
     @request_id_to_request = {}
 
     # @type {!Map<string, !Protocol.Network.requestWillBeSentPayload>}
-    @request_id_to_request_with_be_sent_event
+    @request_id_to_request_with_be_sent_event = {}
 
     @extra_http_headers = {}
 
     @offline = false
 
-    # /** @type {!Set<string>} */
-    # this._attemptedAuthentications = new Set();
+    @attempted_authentications = Set.new
     @user_request_interception_enabled = false
     @protocol_request_interception_enabled = false
     @user_cache_disabled = false
-    # /** @type {!Map<string, string>} */
-    # this._requestIdToInterceptionId = new Map();
+    @request_id_to_interception_id = {}
+
+    @client.on_event('Fetch.requestPaused') do |event|
+      handle_request_paused(event)
+    end
+    @client.on_event('Fetch.authRequired') do |event|
+      handle_auth_required(event)
+    end
+    @client.on_event('Network.requestWillBeSent') do |event|
+      handle_request_will_be_sent(event)
+    end
+    @client.on_event('Network.requestServedFromCache') do |event|
+      handle_request_served_from_cache(event)
+    end
+    @client.on_event('Network.responseReceived') do |event|
+      handle_response_received(event)
+    end
+    @client.on_event('Network.loadingFinished') do |event|
+      handle_loading_finished(event)
+    end
+    @client.on_event('Network.loadingFailed') do |event|
+      handle_loading_failed(event)
+    end
   end
 
   def init
@@ -119,4 +141,140 @@ class Puppeteer::NetworkManager
     cache_disabled = @user_cache_disabled || @protocol_request_interception_enabled
     @client.send_message('Network.setCacheDisabled', cacheDisabled: cache_disabled)
   end
+
+  private def handle_request_will_be_sent(event)
+    # Request interception doesn't happen for data URLs with Network Service.
+    if @protocol_request_interception_enabled && !event['request']['url'].start_with?('data:')
+      request_id = event['requestId']
+      interception_id = @request_id_to_interception_id.delete(request_id)
+      if interception_id
+        handle_request(event, interception_id)
+      else
+        @request_id_to_request_with_be_sent_event[request_id] = event
+      end
+      return
+    end
+    handle_request(event, nil)
+  end
+
+  private def handle_auth_required(event)
+    response = 'Default'
+    if @attempted_authentications.include?(event['requestId'])
+      response = 'CancelAuth'
+    elsif @credentials
+      response = 'ProvideCredentials'
+      @attempted_authentications << event['requestId']
+    end
+
+    username = @credentials&.username
+    password = @credentials&.password
+
+    begin
+      @client.send_message('Fetch.continueWithAuth',
+        requestId: event['requestId'],
+        authChallengeResponse: {
+          response: response,
+          username: username,
+          password: password,
+        },
+      )
+    rescue => err
+      debug_puts(err)
+    end
+  end
+
+  private def handle_request_paused(event)
+    if !@user_request_interception_enabled && @protocol_request_interception_enabled
+      begin
+        @client.send_message('Fetch.continueRequest', requestId: event['requestId'])
+      rescue => err
+        debug_puts(err)
+      end
+    end
+
+    request_id = event['networkId']
+    interception_id = event['requestId']
+    if request_id && (request_will_be_sent_event = @request_id_to_request_with_be_sent_event.delete(request_id))
+      handle_request(request_will_be_sent_event, interception_id)
+    else
+      @request_id_to_interception_id[request_id] = interception_id
+    end
+  end
+
+  private def handle_request(event, interception_id)
+    redirect_chain = []
+    if event['redirectResponse']
+      if_present(@request_id_to_request[event['requestId']]) do |request|
+        handle_request_redirect(request, event['redirectResponse'])
+        redirect_chain = request.internal.redirect_chain
+      end
+    end
+    frame = if_present(event['frameId']) { |frame_id| @frame_manager.frame(frame_id) }
+    request = Puppeteer::Request.new(@client, frame, interception_id, @user_request_interception_enabled, event, redirect_chain)
+    @request_id_to_request[event['requestId']] = request
+    emit_event 'Events.NetworkManager.Request', request
+  end
+
+  private def handle_request_served_from_cache(event)
+    if_present(@request_id_to_request[event['requestId']]) do |request|
+      request.internal.from_memory_cache = true
+    end
+  end
+
+  # @param request [Puppeteer::Request]
+  # @param response_payload [Hash]
+  private def handle_request_redirect(request, response_payload)
+    response = Puppeteer::Response.new(@client, request, response_payload)
+    request.internal.response = response
+    request.internal.redirect_chain << request
+    response.internal.body_loaded_promise.reject(Puppeteer::Response::Redirected.new)
+    @request_id_to_request.delete(request.internal.request_id)
+    @attempted_authentications.delete(request.internal.interception_id)
+    emit_event 'Events.NetworkManager.Response', response
+    emit_event 'Events.NetworkManager.RequestFinished', request
+  end
+
+  # @param event [Hash]
+  private def handle_response_received(event)
+    request = @request_id_to_request[event['requestId']]
+    # FileUpload sends a response without a matching request.
+    return unless request
+
+    response = Puppeteer::Response.new(@client, request, event['response'])
+    request.internal.response = response
+    emit_event 'Events.NetworkManager.Response', response
+  end
+
+  private def handle_loading_finished(event)
+    request = @request_id_to_request[event['requestId']]
+    # For certain requestIds we never receive requestWillBeSent event.
+    # @see https://crbug.com/750469
+    return unless request
+
+
+    # Under certain conditions we never get the Network.responseReceived
+    # event from protocol. @see https://crbug.com/883475
+    if_present(request.response) do |response|
+      response.internal.body_loaded_promise.fulfill(nil)
+    end
+
+    @request_id_to_request.delete(request.internal.request_id)
+    @attempted_authentications.delete(request.internal.interception_id)
+    emit_event 'Events.NetworkManager.RequestFinished', request
+  end
+
+  private def handle_loading_failed(event)
+    request = @request_id_to_request[event['requestId']]
+    # For certain requestIds we never receive requestWillBeSent event.
+    # @see https://crbug.com/750469
+    return unless request
+
+    request.internal.failure_text = event['errorText']
+    if_present(request.response) do |response|
+      response.internal.body_loaded_promise.fulfill(nil)
+    end
+    @request_id_to_request.delete(request.internal.request_id)
+    @attempted_authentications.delete(request.internal.interception_id)
+    emit_event 'Events.NetworkManager.RequestFailed', request
+  end
 end

data/lib/puppeteer/page.rb

@@ -689,41 +689,94 @@ class Puppeteer::Page
 
   define_async_method :async_wait_for_navigation
 
-  # /**
-  #  * @param {(string|Function)} urlOrPredicate
-  #  * @param {!{timeout?: number}=} options
-  #  * @return {!Promise<!Puppeteer.Request>}
-  #  */
-  # async waitForRequest(urlOrPredicate, options = {}) {
-  #   const {
-  #     timeout = this._timeoutSettings.timeout(),
-  #   } = options;
-  #   return helper.waitForEvent(this._frameManager.networkManager(), Events.NetworkManager.Request, request => {
-  #     if (helper.isString(urlOrPredicate))
-  #       return (urlOrPredicate === request.url());
-  #     if (typeof urlOrPredicate === 'function')
-  #       return !!(urlOrPredicate(request));
-  #     return false;
-  #   }, timeout, this._sessionClosePromise());
-  # }
+  private def wait_for_network_manager_event(event_name, predicate:, timeout:)
+    option_timeout = timeout || @timeout_settings.timeout
 
-  # /**
-  #  * @param {(string|Function)} urlOrPredicate
-  #  * @param {!{timeout?: number}=} options
-  #  * @return {!Promise<!Puppeteer.Response>}
-  #  */
-  # async waitForResponse(urlOrPredicate, options = {}) {
-  #   const {
-  #     timeout = this._timeoutSettings.timeout(),
-  #   } = options;
-  #   return helper.waitForEvent(this._frameManager.networkManager(), Events.NetworkManager.Response, response => {
-  #     if (helper.isString(urlOrPredicate))
-  #       return (urlOrPredicate === response.url());
-  #     if (typeof urlOrPredicate === 'function')
-  #       return !!(urlOrPredicate(response));
-  #     return false;
-  #   }, timeout, this._sessionClosePromise());
-  # }
+    @wait_for_network_manager_event_listener_ids ||= {}
+    if_present(@wait_for_network_manager_event_listener_ids[event_name]) do |listener_id|
+      @frame_manager.network_manager.remove_event_listener(listener_id)
+    end
+
+    promise = resolvable_future
+
+    @wait_for_network_manager_event_listener_ids[event_name] =
+      @frame_manager.network_manager.add_event_listener(event_name) do |event_target|
+        if predicate.call(event_target)
+          promise.fulfill(nil)
+        end
+      end
+
+    begin
+      Timeout.timeout(option_timeout / 1000.0) do
+        await_any(promise, session_close_promise)
+      end
+    rescue Timeout::Error
+      raise Puppeteer::TimeoutError.new("waiting for #{event_name} failed: timeout #{timeout}ms exceeded")
+    ensure
+      @frame_manager.network_manager.remove_event_listener(@wait_for_network_manager_event_listener_ids[event_name])
+    end
+  end
+
+  private def session_close_promise
+    @disconnect_promise ||= resolvable_future do |future|
+      @client.observe_first('Events.CDPSession.Disconnected') do
+        future.reject(Puppeteer::CDPSession::Error.new('Target Closed'))
+      end
+    end
+  end
+
+  # - Waits until request URL matches
+  #  `wait_for_request(url: 'https://example.com/awesome')`
+  # - Waits until request matches the given predicate
+  #  `wait_for_request(predicate: -> (req){ req.url.start_with?('https://example.com/search') })`
+  #
+  # @param url [String]
+  # @param predicate [Proc(Puppeteer::Request -> Boolean)]
+  private def wait_for_request(url: nil, predicate: nil, timeout: nil)
+    if !url && !predicate
+      raise ArgumentError.new('url or predicate must be specified')
+    end
+    if predicate && !predicate.is_a?(Proc)
+      raise ArgumentError.new('predicate must be a proc.')
+    end
+    request_predicate =
+      if url
+        -> (request) { request.url == url }
+      else
+        -> (request) { predicate.call(request) }
+      end
+
+    wait_for_network_manager_event('Events.NetworkManager.Request',
+      predicate: request_predicate,
+      timeout: timeout,
+    )
+  end
+
+  define_async_method :async_wait_for_request
+
+  # @param url [String]
+  # @param predicate [Proc(Puppeteer::Request -> Boolean)]
+  private def wait_for_response(url: nil, predicate: nil, timeout: nil)
+    if !url && !predicate
+      raise ArgumentError.new('url or predicate must be specified')
+    end
+    if predicate && !predicate.is_a?(Proc)
+      raise ArgumentError.new('predicate must be a proc.')
+    end
+    response_predicate =
+      if url
+        -> (response) { response.url == url }
+      else
+        -> (response) { predicate.call(response) }
+      end
+
+    wait_for_network_manager_event('Events.NetworkManager.Response',
+      predicate: response_predicate,
+      timeout: timeout,
+    )
+  end
+
+  define_async_method :async_wait_for_response
 
   # @param timeout [number|nil]
   # @param wait_until [string|nil] 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2'
@@ -762,20 +815,19 @@ class Puppeteer::Page
     @client.send_message('Emulation.setScriptExecutionDisabled', value: !enabled)
   end
 
-  # /**
-  #  * @param {boolean} enabled
-  #  */
-  # async setBypassCSP(enabled) {
-  #   await this._client.send('Page.setBypassCSP', { enabled });
-  # }
+  # @param enabled [Boolean]
+  def bypass_csp=(enabled)
+    @client.send_message('Page.setBypassCSP', enabled: enabled)
+  end
 
-  # /**
-  #  * @param {?string} type
-  #  */
-  # async emulateMediaType(type) {
-  #   assert(type === 'screen' || type === 'print' || type === null, 'Unsupported media type: ' + type);
-  #   await this._client.send('Emulation.setEmulatedMedia', {media: type || ''});
-  # }
+  # @param media_type [String|Symbol|nil] either of (media, print, nil)
+  def emulate_media_type(media_type)
+    media_type_str = media_type.to_s
+    unless ['screen', 'print', ''].include?(media_type_str)
+      raise ArgumentError.new("Unsupported media type: #{media_type}")
+    end
+    @client.send_message('Emulation.setEmulatedMedia', media: media_type_str)
+  end
 
   # /**
   #  * @param {?Array<MediaFeature>} features
@@ -795,7 +847,7 @@ class Puppeteer::Page
 
   # @param timezone_id [String?]
   def emulate_timezone(timezone_id)
-    @client.send_message('Emulation.setTimezoneOverride', timezoneId: timezoneId || '')
+    @client.send_message('Emulation.setTimezoneOverride', timezoneId: timezone_id || '')
   rescue => err
     if err.message.include?('Invalid timezone')
       raise ArgumentError.new("Invalid timezone ID: #{timezone_id}")
@@ -1034,16 +1086,6 @@ class Puppeteer::Page
 
   define_async_method :async_type_text
 
-  # /**
-  #  * @param {(string|number|Function)} selectorOrFunctionOrTimeout
-  #  * @param {!{visible?: boolean, hidden?: boolean, timeout?: number, polling?: string|number}=} options
-  #  * @param {!Array<*>} args
-  #  * @return {!Promise<!Puppeteer.JSHandle>}
-  #  */
-  # waitFor(selectorOrFunctionOrTimeout, options = {}, ...args) {
-  #   return this.mainFrame().waitFor(selectorOrFunctionOrTimeout, options, ...args);
-  # }
-
   # @param selector [String]
   # @param visible [Boolean] Wait for element visible (not 'display: none' nor 'visibility: hidden') on true. default to false.
   # @param hidden [Boolean] Wait for element invisible ('display: none' nor 'visibility: hidden') on true. default to false.

data/lib/puppeteer/request.rb

@@ -0,0 +1,336 @@
+class Puppeteer::Request
+  include Puppeteer::DebugPrint
+  include Puppeteer::IfPresent
+
+  # defines some methods used only in NetworkManager, Response
+  class InternalAccessor
+    def initialize(request)
+      @request = request
+    end
+
+    def request_id
+      @request.instance_variable_get(:@request_id)
+    end
+
+    def interception_id
+      @request.instance_variable_get(:@interception_id)
+    end
+
+    # @param response [Puppeteer::Response]
+    def response=(response)
+      @request.instance_variable_set(:@response, response)
+    end
+
+    def redirect_chain
+      @request.instance_variable_get(:@redirect_chain)
+    end
+
+    def failure_text=(failure_text)
+      @request.instance_variable_set(:@failure_text, failure_text)
+    end
+
+    def from_memory_cache=(from_memory_cache)
+      @request.instance_variable_set(:@from_memory_cache, from_memory_cache)
+    end
+
+    def from_memory_cache?
+      @request.instance_variable_get(:@from_memory_cache)
+    end
+  end
+
+  # @param client [Puppeteer::CDPSession]
+  # @param frame [Puppeteer::Frame]
+  # @param interception_id [string|nil]
+  # @param allow_interception [boolean]
+  # @param event [Hash]
+  # @param redirect_chain Array<Request>
+  def initialize(client, frame, interception_id, allow_interception, event, redirect_chain)
+    @client = client
+    @request_id = event['requestId']
+    @is_navigation_request = event['requestId'] == event['loaderId'] && event['type'] == 'Document'
+    @interception_id = interception_id
+    @allow_interception = allow_interception
+    @url = event['request']['url']
+    @resource_type = event['type'].downcase
+    @method = event['request']['method']
+    @post_data = event['request']['postData']
+    @frame = frame
+    @redirect_chain = redirect_chain
+    @headers = {}
+    event['request']['headers'].each do |key, value|
+      @headers[key.downcase] = value
+    end
+    @from_memory_cache = false
+
+    @internal = InternalAccessor.new(self)
+  end
+
+  attr_reader :internal
+  attr_reader :url, :resource_type, :method, :post_data, :headers, :response, :frame
+
+  def navigation_request?
+    @is_navigation_request
+  end
+
+  def redirect_chain
+    @redirect_chain.dup
+  end
+
+  def failure
+    if_present(@failure_text) do |failure_text|
+      { errorText: @failure_text }
+    end
+  end
+
+  private def headers_to_array(headers)
+    return nil unless headers
+
+    headers.map do |key, value|
+      { name: key, value: value.to_s }
+    end
+  end
+
+  class InterceptionNotEnabledError < StandardError
+    def initialize
+      super('Request Interception is not enabled!')
+    end
+  end
+
+  class AlreadyHandledError < StandardError
+    def initialize
+      super('Request is already handled!')
+    end
+  end
+
+  # proceed request on request interception.
+  #
+  # Example:
+  #
+  # ````
+  # page.on 'request' do |req|
+  #   # Override headers
+  #   headers = req.headers.merge(
+  #     foo: 'bar', # set "foo" header
+  #     origin: nil, # remove "origin" header
+  #   )
+  #   req.continue(headers: headers)
+  # end
+  # ```
+  #`
+  # @param error_code [String|Symbol]
+  def continue(url: nil, method: nil, post_data: nil, headers: nil)
+    # Request interception is not supported for data: urls.
+    return if @url.start_with?('data:')
+
+    unless @allow_interception
+      raise InterceptionNotEnabledError.new
+    end
+    if @interception_handled
+      raise AlreadyHandledError.new
+    end
+    @interception_handled = true
+
+    overrides = {
+      url: url,
+      method: method,
+      post_data: post_data,
+      headers: headers_to_array(headers),
+    }.compact
+    begin
+      @client.send_message('Fetch.continueRequest',
+        requestId: @interception_id,
+        **overrides,
+      )
+    rescue => err
+      # In certain cases, protocol will return error if the request was already canceled
+      # or the page was closed. We should tolerate these errors.
+      debug_puts(err)
+    end
+  end
+
+  # Mocking response.
+  #
+  # Example:
+  #
+  # ```
+  # page.on 'request' do |req|
+  #   req.respond(
+  #     status: 404,
+  #     content_type: 'text/plain',
+  #     body: 'Not Found!'
+  #   )
+  # end
+  # ````
+  #
+  # @param status [Integer]
+  # @param headers [Hash<String, String>]
+  # @param content_type [String]
+  # @param body [String]
+  def respond(status: nil, headers: nil, content_type: nil, body: nil)
+    # Mocking responses for dataURL requests is not currently supported.
+    return if @url.start_with?('data:')
+
+    unless @allow_interception
+      raise InterceptionNotEnabledError.new
+    end
+    if @interception_handled
+      raise AlreadyHandledError.new
+    end
+    @interception_handled = true
+
+    mock_response_headers = {}
+    headers&.each do |key, value|
+      mock_response_headers[key.downcase] = value
+    end
+    if content_type
+      mock_response_headers['content-type'] = content_type
+    end
+    if body
+      mock_response_headers['content-length'] = body.length
+    end
+
+    mock_response = {
+      responseCode: status || 200,
+      responsePhrase: STATUS_TEXTS[(status || 200).to_s],
+      responseHeaders: headers_to_array(mock_response_headers),
+      body: if_present(body) { |mock_body| Base64.strict_encode64(mock_body) },
+    }.compact
+    begin
+      @client.send_message('Fetch.fulfillRequest',
+        requestId: @interception_id,
+        **mock_response,
+      )
+    rescue => err
+      # In certain cases, protocol will return error if the request was already canceled
+      # or the page was closed. We should tolerate these errors.
+      debug_puts(err)
+    end
+  end
+
+  # abort request on request interception.
+  #
+  # Example:
+  #
+  # ````
+  # page.on 'request' do |req|
+  #   if req.url.include?("porn")
+  #     req.abort
+  #   else
+  #     req.continue
+  #   end
+  # end
+  # ```
+  #`
+  # @param error_code [String|Symbol]
+  def abort(error_code: :failed)
+    # Request interception is not supported for data: urls.
+    return if @url.start_with?('data:')
+
+    error_reason = ERROR_REASONS[error_code.to_s]
+    unless error_reason
+      raise ArgumentError.new("Unknown error code: #{error_code}")
+    end
+    unless @allow_interception
+      raise InterceptionNotEnabledError.new
+    end
+    if @interception_handled
+      raise AlreadyHandledError.new
+    end
+    @interception_handled = true
+
+    begin
+      @client.send_message('Fetch.failRequest',
+        requestId: @interception_id,
+        errorReason: error_reason,
+      )
+    rescue => err
+      # In certain cases, protocol will return error if the request was already canceled
+      # or the page was closed. We should tolerate these errors.
+      debug_puts(err)
+    end
+  end
+
+  ERROR_REASONS = {
+    'aborted' => 'Aborted',
+    'accessdenied' => 'AccessDenied',
+    'addressunreachable' => 'AddressUnreachable',
+    'blockedbyclient' => 'BlockedByClient',
+    'blockedbyresponse' => 'BlockedByResponse',
+    'connectionaborted' => 'ConnectionAborted',
+    'connectionclosed' => 'ConnectionClosed',
+    'connectionfailed' => 'ConnectionFailed',
+    'connectionrefused' => 'ConnectionRefused',
+    'connectionreset' => 'ConnectionReset',
+    'internetdisconnected' => 'InternetDisconnected',
+    'namenotresolved' => 'NameNotResolved',
+    'timedout' => 'TimedOut',
+    'failed' => 'Failed',
+  }.freeze
+
+  # List taken from https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml with extra 306 and 418 codes.
+  STATUS_TEXTS = {
+    '100' => 'Continue',
+    '101' => 'Switching Protocols',
+    '102' => 'Processing',
+    '103' => 'Early Hints',
+    '200' => 'OK',
+    '201' => 'Created',
+    '202' => 'Accepted',
+    '203' => 'Non-Authoritative Information',
+    '204' => 'No Content',
+    '205' => 'Reset Content',
+    '206' => 'Partial Content',
+    '207' => 'Multi-Status',
+    '208' => 'Already Reported',
+    '226' => 'IM Used',
+    '300' => 'Multiple Choices',
+    '301' => 'Moved Permanently',
+    '302' => 'Found',
+    '303' => 'See Other',
+    '304' => 'Not Modified',
+    '305' => 'Use Proxy',
+    '306' => 'Switch Proxy',
+    '307' => 'Temporary Redirect',
+    '308' => 'Permanent Redirect',
+    '400' => 'Bad Request',
+    '401' => 'Unauthorized',
+    '402' => 'Payment Required',
+    '403' => 'Forbidden',
+    '404' => 'Not Found',
+    '405' => 'Method Not Allowed',
+    '406' => 'Not Acceptable',
+    '407' => 'Proxy Authentication Required',
+    '408' => 'Request Timeout',
+    '409' => 'Conflict',
+    '410' => 'Gone',
+    '411' => 'Length Required',
+    '412' => 'Precondition Failed',
+    '413' => 'Payload Too Large',
+    '414' => 'URI Too Long',
+    '415' => 'Unsupported Media Type',
+    '416' => 'Range Not Satisfiable',
+    '417' => 'Expectation Failed',
+    '418' => 'I\'m a teapot',
+    '421' => 'Misdirected Request',
+    '422' => 'Unprocessable Entity',
+    '423' => 'Locked',
+    '424' => 'Failed Dependency',
+    '425' => 'Too Early',
+    '426' => 'Upgrade Required',
+    '428' => 'Precondition Required',
+    '429' => 'Too Many Requests',
+    '431' => 'Request Header Fields Too Large',
+    '451' => 'Unavailable For Legal Reasons',
+    '500' => 'Internal Server Error',
+    '501' => 'Not Implemented',
+    '502' => 'Bad Gateway',
+    '503' => 'Service Unavailable',
+    '504' => 'Gateway Timeout',
+    '505' => 'HTTP Version Not Supported',
+    '506' => 'Variant Also Negotiates',
+    '507' => 'Insufficient Storage',
+    '508' => 'Loop Detected',
+    '510' => 'Not Extended',
+    '511' => 'Network Authentication Required',
+  }.freeze
+end

data/lib/puppeteer/response.rb

@@ -0,0 +1,113 @@
+require 'json'
+
+class Puppeteer::Response
+  include Puppeteer::IfPresent
+
+  class Redirected < StandardError
+    def initialize
+      super('Response body is unavailable for redirect responses')
+    end
+  end
+
+  # defines methods used only in NetworkManager
+  class InternalAccessor
+    def initialize(response)
+      @response = response
+    end
+
+    def body_loaded_promise
+      @response.instance_variable_get(:@body_loaded_promise)
+    end
+  end
+
+  class RemoteAddress
+    def initialize(ip:, port:)
+      @ip = ip
+      @port = port
+    end
+    attr_reader :ip, :port
+  end
+
+  # @param client [Puppeteer::CDPSession]
+  # @param request [Puppeteer::Request]
+  # @param response_payload [Hash]
+  def initialize(client, request, response_payload)
+    @client = client
+    @request = request
+
+    @body_loaded_promise = resolvable_future
+    @remote_address = RemoteAddress.new(
+      ip: response_payload['remoteIPAddress'],
+      port: response_payload['remotePort'],
+    )
+
+    @status = response_payload['status']
+    @status_text = response_payload['statusText']
+    @url = request.url
+    @from_disk_cache = !!response_payload['fromDiskCache']
+    @from_service_worker = !!response_payload['fromServiceWorker']
+
+    @headers = {}
+    response_payload['headers'].each do |key, value|
+      @headers[key.downcase] = value
+    end
+    @security_details = if_present(response_payload['securityDetails']) do |security_payload|
+      SecurityDetails.new(security_payload)
+    end
+
+    @internal = InternalAccessor.new(self)
+  end
+
+  attr_reader :internal
+
+  attr_reader :remote_address, :url, :status, :status_text, :headers, :security_details, :request
+
+  # @return [Boolean]
+  def ok?
+    @status == 0 || (@status >= 200 && @status <= 299)
+  end
+
+  def buffer
+    await @body_loaded_promise
+    response = @client.send_message('Network.getResponseBody', requestId: @request.internal.request_id)
+    if response['base64Encoded']
+      Base64.decode64(response['body'])
+    else
+      response['body']
+    end
+  end
+
+  # @param text [String]
+  def text
+    buffer
+  end
+
+  # @param json [Hash]
+  def json
+    JSON.parse(text)
+  end
+
+  def from_cache?
+    @from_disk_cache || @request.internal.from_memory_cache?
+  end
+
+  def from_service_worker?
+    @from_service_worker
+  end
+
+  def frame
+    @request.frame
+  end
+
+  class SecurityDetails
+    def initialize(security_payload)
+      @subject_name = security_payload['subjectName']
+      @issuer = security_payload['issuer']
+      @valid_from = security_payload['validFrom']
+      @valid_to = security_payload['validTo']
+      @protocol = security_payload['protocol']
+    end
+
+    attr_reader :subject_name, :issuer, :valid_from, :valid_to, :protocol
+  end
+end

data/lib/puppeteer/version.rb

@@ -1,3 +1,3 @@
 class Puppeteer
-  VERSION = '0.0.15'
+  VERSION = '0.0.16'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppeteer-ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.15
+  version: 0.0.16
 platform: ruby
 authors:
 - YusukeIwaki
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-06-28 00:00:00.000000000 Z
+date: 2020-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -227,6 +227,8 @@ files:
 - lib/puppeteer/page/pdf_options.rb
 - lib/puppeteer/page/screenshot_options.rb
 - lib/puppeteer/remote_object.rb
+- lib/puppeteer/request.rb
+- lib/puppeteer/response.rb
 - lib/puppeteer/target.rb
 - lib/puppeteer/timeout_settings.rb
 - lib/puppeteer/touch_screen.rb