sharpetronics/httpx
1
0
Fork 0
mirror of https://github.com/HoneyryderChuck/httpx.git synced 2025-11-27 00:03:01 -05:00
Code Issues Projects Releases Wiki Activity

remove form, json, ,xml and body from the Options class

Browse Source 
Options become a bunch of session and connection level parameters, and requests do not need to maintain a separate Options object when they contain a body anymore, instead, objects is shared with the session, while request-only parameters get passed downwards to the request and its body. This reduces allocations of Options, currently the heaviest object to manage.
This commit is contained in:
HoneyryderChuck 2024-01-24 22:42:20 +00:00
parent b686119a6f
commit 8b2ee0b466
33 changed files with 233 additions and 231 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
lib/httpx/options.rb
View File

@ -124,10 +124,6 @@ module HTTPX
# :base_path :: path to prefix given relative paths with (ex: "/v2")
# :max_concurrent_requests :: max number of requests which can be set concurrently
# :max_requests :: max number of requests which can be made on socket before it reconnects.
# :params :: hash or array of key-values which will be encoded and set in the query string of request uris.
# :form :: hash of array of key-values which will be form-or-multipart-encoded in requests body payload.
# :json :: hash of array of key-values which will be JSON-encoded in requests body payload.
# :xml :: Nokogiri XML nodes which will be encoded in requests body payload.
#
# This list of options are enhanced with each loaded plugin, see the plugin docs for details.
def initialize(options = {})
@ -216,7 +212,7 @@ module HTTPX
end
%i[
params form json xml body ssl http2_settings
ssl http2_settings
request_class response_class headers_class request_body_class
response_body_class connection_class options_class
io fallback_protocol debug debug_level resolver_class resolver_options
@ -228,7 +224,7 @@ module HTTPX
OUT
end
REQUEST_BODY_IVARS = %i[@headers @params @form @xml @json @body].freeze
REQUEST_BODY_IVARS = %i[@headers].freeze
def ==(other)
super || options_equals?(other)

2
lib/httpx/plugins/aws_sigv4.rb
View File

@ -160,7 +160,7 @@ module HTTPX
with(sigv4_signer: Signer.new(**options))
end
def build_request(*, _)
def build_request(*)
request = super
return request if request.headers.key?("authorization")

2
lib/httpx/plugins/cookies.rb
View File

@ -53,7 +53,7 @@ module HTTPX
super
end
def build_request(*, _)
def build_request(*)
request = super
request.headers.set_cookie(request.options.cookies[request.uri])
request

42
lib/httpx/plugins/follow_redirects.rb
View File

@ -71,40 +71,39 @@ module HTTPX
# build redirect request
request_body = redirect_request.body
redirect_method = "GET"
redirect_params = {}
if response.status == 305 && options.respond_to?(:proxy)
request_body.rewind
# The requested resource MUST be accessed through the proxy given by
# the Location field. The Location field gives the URI of the proxy.
retry_options = options.merge(headers: redirect_request.headers,
proxy: { uri: redirect_uri },
body: request_body,
max_redirects: max_redirects - 1)
redirect_options = options.merge(headers: redirect_request.headers,
proxy: { uri: redirect_uri },
body: request_body,
max_redirects: max_redirects - 1)
redirect_uri = redirect_request.uri
options = retry_options
options = redirect_options
else
redirect_headers = redirect_request_headers(redirect_request.uri, redirect_uri, request.headers, options)
retry_opts = Hash[options].merge(max_redirects: max_redirects - 1)
redirect_opts = Hash[options]
redirect_params[:max_redirects] = max_redirects - 1
unless request_body.empty?
if response.status == 307
# The method and the body of the original request are reused to perform the redirected request.
redirect_method = redirect_request.verb
request_body.rewind
retry_opts[:body] = request_body
redirect_params[:body] = request_body
else
# redirects are **ALWAYS** GET, so remove body-related headers
REQUEST_BODY_HEADERS.each do |h|
redirect_headers.delete(h)
end
retry_opts.delete(:body)
redirect_params[:body] = nil
end
end
retry_opts[:headers] = redirect_headers.to_h
retry_options = options.class.new(retry_opts)
options = options.class.new(redirect_opts.merge(headers: redirect_headers.to_h))
end
redirect_uri = Utils.to_uri(redirect_uri)
@ -117,23 +116,23 @@ module HTTPX
return ErrorResponse.new(request, error, options)
end
retry_request = build_request(redirect_method, redirect_uri, retry_options)
retry_request = build_request(redirect_method, redirect_uri, redirect_params, options)
request.redirect_request = retry_request
retry_after = response.headers["retry-after"]
redirect_after = response.headers["retry-after"]
if retry_after
if redirect_after
# Servers send the "Retry-After" header field to indicate how long the
# user agent ought to wait before making a follow-up request.
# When sent with any 3xx (Redirection) response, Retry-After indicates
# the minimum time that the user agent is asked to wait before issuing
# the redirected request.
#
retry_after = Utils.parse_retry_after(retry_after)
redirect_after = Utils.parse_retry_after(redirect_after)
log { "redirecting after #{retry_after} secs..." }
pool.after(retry_after) do
log { "redirecting after #{redirect_after} secs..." }
pool.after(redirect_after) do
send_request(retry_request, connections, options)
end
else
@ -149,10 +148,9 @@ module HTTPX
return headers unless headers.key?("authorization")
unless original_uri.origin == redirect_uri.origin
headers = headers.dup
headers.delete("authorization")
end
return headers if original_uri.origin == redirect_uri.origin
headers.delete("authorization")
headers
end

4
lib/httpx/plugins/grpc.rb
View File

@ -110,10 +110,10 @@ module HTTPX
end
module RequestBodyMethods
def initialize(headers, _)
def initialize(*, **)
super
if (compression = headers["grpc-encoding"])
if (compression = @headers["grpc-encoding"])
deflater_body = self.class.initialize_deflater_body(@body, compression)
@body = Transcoder::GRPCEncoding.encode(deflater_body || @body, compressed: !deflater_body.nil?)
else

2
lib/httpx/plugins/oauth.rb
View File

@ -155,7 +155,7 @@ module HTTPX
with(oauth_session: oauth_session.merge(access_token: access_token, refresh_token: refresh_token))
end
def build_request(*, _)
def build_request(*)
request = super
return request if request.headers.key?("authorization")

4
lib/httpx/plugins/proxy/http.rb
View File

@ -163,8 +163,8 @@ module HTTPX
end
class ConnectRequest < Request
def initialize(uri, _options)
super("CONNECT", uri, {})
def initialize(uri, options)
super("CONNECT", uri, options)
@headers.delete("accept")
end

46
lib/httpx/request.rb
View File

@ -46,12 +46,43 @@ module HTTPX
# will be +true+ when request body has been completely flushed.
def_delegator :@body, :empty?
# initializes the instance with the given +verb+, an absolute or relative +uri+, and the
# request options.
def initialize(verb, uri, options = {})
# initializes the instance with the given +verb+ (an upppercase String, ex. 'GEt'),
# an absolute or relative +uri+ (either as String or URI::HTTP object), the
# request +options+ (instance of HTTPX::Options) and an optional Hash of +params+.
#
# Besides any of the options documented in HTTPX::Options (which would override or merge with what
# +options+ sets), it accepts also the following:
#
# :params :: hash or array of key-values which will be encoded and set in the query string of request uris.
# :body :: to be encoded in the request body payload. can be a String, an IO object (i.e. a File), or an Enumerable.
# :form :: hash of array of key-values which will be form-urlencoded- or multipart-encoded in requests body payload.
# :json :: hash of array of key-values which will be JSON-encoded in requests body payload.
# :xml :: Nokogiri XML nodes which will be encoded in requests body payload.
#
# :body, :form, :json and :xml are all mutually exclusive, i.e. only one of them gets picked up.
def initialize(verb, uri, options, params = EMPTY_HASH)
@verb = verb.to_s.upcase
@options = Options.new(options)
@uri = Utils.to_uri(uri)
@headers = options.headers.dup
merge_headers(params.delete(:headers)) if params.key?(:headers)
@headers["user-agent"] ||= USER_AGENT
@headers["accept"] ||= "*/*"
# forego compression in the Range request case
if @headers.key?("range")
@headers.delete("accept-encoding")
else
@headers["accept-encoding"] ||= options.supported_compression_formats
end
@query_params = params.delete(:params) if params.key?(:params)
@body = options.request_body_class.new(@headers, options, **params)
@options = @body.options
if @uri.relative?
origin = @options.origin
raise(Error, "invalid URI: #{@uri}") unless origin
@ -61,11 +92,6 @@ module HTTPX
@uri = origin.merge("#{base_path}#{@uri}")
end
@headers = @options.headers.dup
@headers["user-agent"] ||= USER_AGENT
@headers["accept"] ||= "*/*"
@body = @options.request_body_class.new(@headers, @options)
@state = :idle
@response = nil
@peer_address = nil
@ -172,7 +198,7 @@ module HTTPX
return @query if defined?(@query)
query = []
if (q = @options.params)
if (q = @query_params)
query << Transcoder::Form.encode(q)
end
query << @uri.query if @uri.query

78
lib/httpx/request/body.rb
View File

@ -4,30 +4,53 @@ module HTTPX
# Implementation of the HTTP Request body as a delegator which iterates (responds to +each+) payload chunks.
class Request::Body < SimpleDelegator
class << self
def new(_, options)
return options.body if options.body.is_a?(self)
def new(_, options, body: nil, **params)
if body.is_a?(self)
# request derives its options from body
body.options = options.merge(params)
return body
end
super
end
end
# inits the instance with the request +headers+ and +options+, which contain the payload definition.
def initialize(headers, options)
@headers = headers
attr_accessor :options
# forego compression in the Range request case
if @headers.key?("range")
@headers.delete("accept-encoding")
else
@headers["accept-encoding"] ||= options.supported_compression_formats
# inits the instance with the request +headers+, +options+ and +params+, which contain the payload definition.
# it wraps the given body with the appropriate encoder on initialization.
#
# ..., json: { foo: "bar" }) #=> json encoder
# ..., form: { foo: "bar" }) #=> form urlencoded encoder
# ..., form: { foo: Pathname.open("path/to/file") }) #=> multipart urlencoded encoder
# ..., form: { foo: File.open("path/to/file") }) #=> multipart urlencoded encoder
# ..., form: { body: "bla") }) #=> raw data encoder
def initialize(headers, options, body: nil, form: nil, json: nil, xml: nil, **params)
@headers = headers
@options = options.merge(params)
@body = if body
Transcoder::Body.encode(body)
elsif form
Transcoder::Form.encode(form)
elsif json
Transcoder::JSON.encode(json)
elsif xml
Transcoder::Xml.encode(xml)
end
initialize_body(options)
if @body
if @options.compress_request_body && @headers.key?("content-encoding")
return if @body.nil?
@headers.get("content-encoding").each do |encoding|
@body = self.class.initialize_deflater_body(@body, encoding)
end
end
@headers["content-type"] ||= @body.content_type
@headers["content-length"] = @body.bytesize unless unbounded_body?
end
@headers["content-type"] ||= @body.content_type
@headers["content-length"] = @body.bytesize unless unbounded_body?
super(@body)
end
@ -99,33 +122,6 @@ module HTTPX
end
# :nocov:
private
# wraps the given body with the appropriate encoder.
#
# ..., json: { foo: "bar" }) #=> json encoder
# ..., form: { foo: "bar" }) #=> form urlencoded encoder
# ..., form: { foo: Pathname.open("path/to/file") }) #=> multipart urlencoded encoder
# ..., form: { foo: File.open("path/to/file") }) #=> multipart urlencoded encoder
# ..., form: { body: "bla") }) #=> raw data encoder
def initialize_body(options)
@body = if options.body
Transcoder::Body.encode(options.body)
elsif options.form
Transcoder::Form.encode(options.form)
elsif options.json
Transcoder::JSON.encode(options.json)
elsif options.xml
Transcoder::Xml.encode(options.xml)
end
return unless @body && options.compress_request_body && @headers.key?("content-encoding")
@headers.get("content-encoding").each do |encoding|
@body = self.class.initialize_deflater_body(@body, encoding)
end
end
class << self
# returns the +body+ wrapped with the correct deflater accordinng to the given +encodisng+.
def initialize_deflater_body(body, encoding)

2
lib/httpx/resolver/https.rb
View File

@ -219,7 +219,7 @@ module HTTPX
uri.query = URI.encode_www_form(params)
request = rklass.new("GET", uri, @options)
else
request = rklass.new("POST", uri, @options.merge(body: [payload]))
request = rklass.new("POST", uri, @options, body: [payload])
request.headers["content-type"] = "application/dns-message"
end
request.headers["accept"] = "application/dns-message"

35
lib/httpx/session.rb
View File

@ -1,6 +1,8 @@
# frozen_string_literal: true
module HTTPX
EMPTY_HASH = {}.freeze
# Class implementing the APIs being used publicly.
#
# HTTPX.get(..) #=> delegating to an internal HTTPX::Session object.
@ -9,8 +11,6 @@ module HTTPX
include Loggable
include Chainable
EMPTY_HASH = {}.freeze
# initializes the session with a set of +options+, which will be shared by all
# requests sent from it.
#
@ -65,10 +65,10 @@ module HTTPX
# resp1, resp2 = session.request(["POST", "https://server.org/a", form: { "foo" => "bar" }], ["GET", "https://server.org/b"])
# resp1, resp2 = session.request("GET", ["https://server.org/a", "https://server.org/b"], headers: { "x-api-token" => "TOKEN" })
#
def request(*args, **options)
def request(*args, **params)
raise ArgumentError, "must perform at least one request" if args.empty?
requests = args.first.is_a?(Request) ? args : build_requests(*args, options)
requests = args.first.is_a?(Request) ? args : build_requests(*args, params)
responses = send_requests(*requests)
return responses.first if responses.size == 1
@ -81,10 +81,9 @@ module HTTPX
#
# req = session.build_request("GET", "https://server.com")
# resp = session.request(req)
def build_request(verb, uri, options = EMPTY_HASH)
rklass = @options.request_class
options = @options.merge(options) unless options.is_a?(Options)
request = rklass.new(verb, uri, options)
def build_request(verb, uri, params = EMPTY_HASH, options = @options)
rklass = options.request_class
request = rklass.new(verb, uri, options, params)
request.persistent = @persistent
set_request_callbacks(request)
request
@ -192,22 +191,26 @@ module HTTPX
end
# returns a set of HTTPX::Request objects built from the given +args+ and +options+.
def build_requests(*args, options)
request_options = @options.merge(options)
def build_requests(*args, params)
requests = if args.size == 1
reqs = args.first
reqs.map do |verb, uri, opts = EMPTY_HASH|
build_request(verb, uri, request_options.merge(opts))
# TODO: find a way to make requests share same options object
reqs.map do |verb, uri, ps = EMPTY_HASH|
request_params = params
request_params = request_params.merge(ps) unless ps.empty?
build_request(verb, uri, request_params)
end
else
verb, uris = args
if uris.respond_to?(:each)
uris.enum_for(:each).map do |uri, opts = EMPTY_HASH|
build_request(verb, uri, request_options.merge(opts))
# TODO: find a way to make requests share same options object
uris.enum_for(:each).map do |uri, ps = EMPTY_HASH|
request_params = params
request_params = request_params.merge(ps) unless ps.empty?
build_request(verb, uri, request_params)
end
else
[build_request(verb, uris, request_options)]
[build_request(verb, uris, params)]
end
end
raise ArgumentError, "wrong number of URIs (given 0, expect 1..+1)" if requests.empty?

4
sig/chainable.rbs
View File

@ -3,8 +3,8 @@ module HTTPX
def request: (*Request, **untyped) -> Array[response]
| (Request, **untyped) -> response
| (verb, uri | [uri], **untyped) -> response
| (Array[[verb, uri] | [verb, uri, options]], **untyped) -> Array[response]
| (verb, _Each[uri | [uri, options]], **untyped) -> Array[response]
| (Array[[verb, uri] | [verb, uri, request_params]], **untyped) -> Array[response]
| (verb, _Each[uri | [uri, request_params]], **untyped) -> Array[response]
def accept: (String) -> Session
def wrap: () { (Session) -> void } -> void

6
sig/httpx.rbs
View File

@ -9,9 +9,9 @@ module HTTPX
type uri = http_uri | string
type generic_uri = String | URI::Generic
type verb = "OPTIONS" | "GET" | "HEAD" | "POST" | "PUT" | "DELETE" | "TRACE" | "CONNECT" |
"PROPFIND" | "PROPPATCH" | "MKCOL" | "COPY" | "MOVE" | "LOCK" | "UNLOCK" | "ORDERPATCH" |
"ACL" | "REPORT" | "PATCH" | "SEARCH"
type verb = String
type request_params = Hash[Symbol, untyped]
type ip_family = Integer #Socket::AF_INET6 | Socket::AF_INET

2
sig/io/tcp.rbs
View File

@ -15,7 +15,7 @@ module HTTPX
alias host ip
# TODO: lift when https://github.com/ruby/rbs/issues/1497 fixed
def initialize: (URI::Generic origin, Array[ipaddr]? addresses, options options) ?{ (instance) -> void } -> void
def initialize: (URI::Generic origin, Array[ipaddr]? addresses, Options options) ?{ (instance) -> void } -> void
def add_addresses: (Array[ipaddr] addrs) -> void

14
sig/options.rbs
View File

@ -63,19 +63,7 @@ module HTTPX
# decompress_response_body
attr_reader decompress_response_body: bool
# params
attr_reader params: Transcoder::urlencoded_input?
# form
attr_reader form: Transcoder::urlencoded_input?
# json
attr_reader json: _ToJson?
# body
attr_reader body: bodyIO?
# body
# origin
attr_reader origin: URI::Generic?
# base_path

2
sig/plugins/follow_redirects.rbs
View File

@ -24,7 +24,7 @@ module HTTPX
module InstanceMethods
def max_redirects: (_ToI) -> instance
def redirect_request_headers: (http_uri original_uri, http_uri redirect_uri, Headers headers, Options & _FollowRedirectsOptions options) -> Headers
def handle_after_redirect_request: (http_uri original_uri, http_uri redirect_uri, Request request, Options & _FollowRedirectsOptions options) -> void
def __get_location_from_response: (Response) -> http_uri
end

3
sig/plugins/proxy/http.rbs
View File

@ -16,6 +16,9 @@ module HTTPX
def __http_on_connect: (top, Response) -> void
end
class ConnectRequest < Request
def initialize: (generic_uri uri, Options options) -> void
end
end
end

3
sig/request.rbs
View File

@ -19,12 +19,13 @@ module HTTPX
attr_writer persistent: bool
@query_params: Hash[interned, untyped]?
@trailers: Headers?
@informational_status: Integer?
@query: String?
@drainer: Enumerator[String, void]?
def initialize: (Symbol | String, generic_uri, ?options) -> untyped
def initialize: (Symbol | String verb, generic_uri uri, Options options, ?request_params params) -> untyped
def interests: () -> (:r | :w)

4
sig/request/body.rbs
View File

@ -4,7 +4,7 @@ module HTTPX
@body: body_encoder?
@unbounded_body: bool
def initialize: (Headers headers, Options options) -> void
def initialize: (Headers headers, Options options, ?body: bodyIO, ?form: Transcoder::urlencoded_input?, ?json: _ToJson?, **untyped) -> void
def each: () { (String) -> void } -> void
| () -> Enumerable[String]
@ -25,8 +25,6 @@ module HTTPX
private
def initialize_body: (Options options) -> void
def self.initialize_deflater_body: (body_encoder body, Encoding | String encoding) -> body_encoder
end

15
sig/session.rbs
View File

@ -15,7 +15,7 @@ module HTTPX
def close: (*untyped) -> void
def build_request: (verb, generic_uri, ?options) -> Request
def build_request: (verb verb, generic_uri uri, ?request_params params, ?Options options) -> Request
def initialize: (?options) { (self) -> void } -> void
| (?options) -> void
@ -23,8 +23,11 @@ module HTTPX
private
def pool: -> Pool
def on_response: (Request, response) -> void
def on_promise: (untyped, untyped) -> void
def fetch_response: (Request request, Array[Connection] connections, untyped options) -> response?
def find_connection: (Request request, Array[Connection] connections, Options options) -> Connection
@ -37,11 +40,11 @@ module HTTPX
def build_altsvc_connection: (Connection existing_connection, Array[Connection] connections, URI::Generic alt_origin, String origin, Hash[String, String] alt_params, Options options) -> (Connection & AltSvc::ConnectionMixin)?
def build_requests: (verb, uri, options) -> Array[Request]
| (Array[[verb, uri, options]], options) -> Array[Request]
| (Array[[verb, uri]], options) -> Array[Request]
| (verb, _Each[[uri, options]], Options) -> Array[Request]
| (verb, _Each[uri], options) -> Array[Request]
def build_requests: (verb, uri, request_params) -> Array[Request]
| (Array[[verb, uri, request_params]], Hash[Symbol, untyped]) -> Array[Request]
| (Array[[verb, uri]], request_params) -> Array[Request]
| (verb, _Each[[uri, request_params]], Hash[Symbol, untyped]) -> Array[Request]
| (verb, _Each[uri], request_params) -> Array[Request]
def init_connection: (http_uri uri, Options options) -> Connection

2
standalone_tests/response_json_multi_json_test.rb
View File

@ -18,7 +18,7 @@ class ResponseYajlTest < Minitest::Test
private
def request(verb = "GET", uri = "http://google.com")
Request.new(verb, uri)
Request.new(verb, uri, Options.new)
end
def response(*args)

2
standalone_tests/response_json_oj_test.rb
View File

@ -18,7 +18,7 @@ class ResponseOjTest < Minitest::Test
private
def request(verb = "GET", uri = "http://google.com")
Request.new(verb, uri)
Request.new(verb, uri, Options.new)
end
def response(*args)

2
standalone_tests/response_json_yajl_test.rb
View File

@ -18,7 +18,7 @@ class ResponseYajlTest < Minitest::Test
private
def request(verb = "GET", uri = "http://google.com")
Request.new(verb, uri)
Request.new(verb, uri, Options.new)
end
def response(*args)

2
test/altsvc_test.rb
View File

@ -62,7 +62,7 @@ class AltSvcTest < Minitest::Test
entries = AltSvc.cached_altsvc("http://www.example-clear-cache.com")
assert !entries.empty?
req = Request.new("GET", "http://www.example-clear-cache.com/")
req = Request.new("GET", "http://www.example-clear-cache.com/", Options.new)
res = Response.new(req, 200, "2.0", { "alt-svc" => "clear" })
AltSvc.emit(req, res) {}

16
test/error_response_test.rb
View File

@ -6,24 +6,24 @@ class ErrorResponseTest < Minitest::Test
include HTTPX
def test_error_response_finished?
r1 = ErrorResponse.new(request_mock, RuntimeError.new("wow"), {})
r1 = make_error_response(RuntimeError.new("wow"))
assert r1.finished?
end
def test_error_response_error
error = RuntimeError.new("wow")
r1 = ErrorResponse.new(request_mock, error, {})
r1 = make_error_response(error)
assert r1.error == error
end
def test_error_response_raise_for_status
some_error = Class.new(RuntimeError)
r1 = ErrorResponse.new(request_mock, some_error.new("wow"), {})
r1 = make_error_response(some_error.new("wow"))
assert_raises(some_error) { r1.raise_for_status }
end
def test_error_response_to_s
r = ErrorResponse.new(request_mock, RuntimeError.new("wow"), {})
r = make_error_response(RuntimeError.new("wow"))
str = r.to_s
assert str.match(/wow \(.*RuntimeError.*\)/), "expected \"wow (RuntimeError)\" in \"#{str}\""
end
@ -31,7 +31,7 @@ class ErrorResponseTest < Minitest::Test
def test_error_response_close
response = Response.new(request_mock, 200, "1.1", {})
request_mock.response = response
r = ErrorResponse.new(request_mock, RuntimeError.new("wow"), {})
r = make_error_response(RuntimeError.new("wow"))
assert !response.body.closed?
r.close
assert response.body.closed?
@ -49,6 +49,10 @@ class ErrorResponseTest < Minitest::Test
private
def request_mock
@request_mock ||= Request.new("GET", "http://example.com/")
@request_mock ||= Request.new("GET", "http://example.com/", Options.new)
end
def make_error_response(*args)
ErrorResponse.new(request_mock, *args, request_mock.options)
end
end

52
test/options_test.rb
View File

@ -22,22 +22,6 @@ class OptionsTest < Minitest::Test
assert_match("undefined method `is_a'", ex.message)
end
def test_options_body
opt1 = Options.new
assert opt1.body.nil?, "body shouldn't be set by default"
opt2 = Options.new(:body => "fat")
assert opt2.body == "fat", "body was not set"
end
%i[form json xml].each do |meth|
define_method :"test_options_#{meth}" do
opt1 = Options.new
assert opt1.public_send(meth).nil?, "#{meth} shouldn't be set by default"
opt2 = Options.new(meth => { "foo" => "bar" })
assert opt2.public_send(meth) == { "foo" => "bar" }, "#{meth} was not set"
end
end
def test_options_headers
opt1 = Options.new
assert opt1.headers.to_a.empty?, "headers should be empty"
@ -57,34 +41,34 @@ class OptionsTest < Minitest::Test
end
def test_options_merge_hash
opts = Options.new(body: "fat")
merged_opts = opts.merge(body: "thin")
assert merged_opts.body == "thin", "parameter hasn't been merged"
assert opts.body == "fat", "original parameter has been mutated after merge"
opts = Options.new(fallback_protocol: "fat")
merged_opts = opts.merge(fallback_protocol: "thin")
assert merged_opts.fallback_protocol == "thin", "parameter hasn't been merged"
assert opts.fallback_protocol == "fat", "original parameter has been mutated after merge"
assert !opts.equal?(merged_opts), "merged options should be a different object"
end
def test_options_merge_options
opts = Options.new(body: "fat")
merged_opts2 = opts.merge(Options.new(body: "short"))
assert opts.body == "fat", "original parameter has been mutated after merge"
assert merged_opts2.body == "short", "options parameter hasn't been merged"
opts = Options.new(fallback_protocol: "fat")
merged_opts2 = opts.merge(Options.new(fallback_protocol: "short"))
assert opts.fallback_protocol == "fat", "original parameter has been mutated after merge"
assert merged_opts2.fallback_protocol == "short", "options parameter hasn't been merged"
assert !opts.equal?(merged_opts2), "merged options should be a different object"
end
def test_options_merge_options_empty_hash
opts = Options.new(body: "fat")
opts = Options.new(fallback_protocol: "fat")
merged_opts3 = opts.merge({})
assert opts.equal?(merged_opts3), "merged options should be the same object"
end
def test_options_merge_same_options
opts = Options.new(body: "fat")
opts = Options.new(fallback_protocol: "fat")
merged_opts4 = opts.merge({ body: "fat" })
merged_opts4 = opts.merge({ fallback_protocol: "fat" })
assert opts.equal?(merged_opts4), "merged options should be the same object"
merged_opts5 = opts.merge(Options.new(body: "fat"))
merged_opts5 = opts.merge(Options.new(fallback_protocol: "fat"))
assert opts.equal?(merged_opts5), "merged options should be the same object"
end
@ -99,12 +83,12 @@ class OptionsTest < Minitest::Test
def test_options_merge_attributes_match
foo = Options.new(
:form => { :foo => "foo" },
:http2_settings => { :foo => "foo" },
:headers => { :accept => "json", :foo => "foo" },
)
bar = Options.new(
:form => { :bar => "bar" },
:http2_settings => { :bar => "bar" },
:headers => { :accept => "xml", :bar => "bar" },
:ssl => { :foo => "bar" },
)
@ -114,14 +98,10 @@ class OptionsTest < Minitest::Test
:max_requests => Float::INFINITY,
:debug => nil,
:debug_level => 1,
:params => nil,
:json => nil,
:xml => nil,
:body => nil,
:buffer_size => 16_384,
:window_size => 16_384,
:body_threshold_size => 114_688,
:form => { foo: "foo", :bar => "bar" },
:http2_settings => { foo: "foo", :bar => "bar" },
:timeout => {
connect_timeout: 60,
settings_timeout: 10,
@ -133,7 +113,6 @@ class OptionsTest < Minitest::Test
request_timeout: nil,
},
:ssl => { :foo => "bar" },
:http2_settings => { :settings_enable_push => 0 },
:fallback_protocol => "http/1.1",
:supported_compression_formats => %w[gzip deflate],
:compress_request_body => true,
@ -179,6 +158,5 @@ class OptionsTest < Minitest::Test
opts = Options.new(origin: "http://example.com")
assert opts == Options.new(origin: "http://example.com")
assert Options.new(origin: "http://example.com", headers: { "foo" => "bar" }) == Options.new(origin: "http://example.com")
assert Options.new(json: { "foo" => "bar" }) == Options.new
end
end

2
test/parser_test.rb
View File

@ -32,7 +32,7 @@ class HTTP1ParserTest < Minitest::Test
private
def mock_request
Request.new("GET", "http://google.com")
Request.new("GET", "http://google.com", Options.new)
end
end

48
test/request_test.rb
View File

@ -6,14 +6,14 @@ class RequestTest < Minitest::Test
include HTTPX
def test_request_unsupported_body
ex = assert_raises(HTTPX::Error) { Request.new("POST", "http://example.com/", body: Object.new) }
ex = assert_raises(HTTPX::Error) { make_request("POST", "http://example.com/", body: Object.new) }
assert ex.message.include?("cannot determine size of body")
end
def test_request_verb
r1 = Request.new("GET", "http://example.com/")
r1 = make_request("GET", "http://example.com/")
assert r1.verb == "GET", "unexpected verb (#{r1.verb})"
r2 = Request.new("GET", "http://example.com/")
r2 = make_request("GET", "http://example.com/")
assert r2.verb == "GET", "unexpected verb (#{r1.verb})"
end
@ -22,76 +22,80 @@ class RequestTest < Minitest::Test
end
def test_request_scheme
r1 = Request.new("GET", "http://google.com/path")
r1 = make_request("GET", "http://google.com/path")
assert r1.scheme == "http", "unexpected scheme (#{r1.scheme}"
r2 = Request.new("GET", "https://google.com/path")
r2 = make_request("GET", "https://google.com/path")
assert r2.scheme == "https", "unexpected scheme (#{r2.scheme}"
end
def test_request_authority
r1 = Request.new("GET", "http://google.com/path")
r1 = make_request("GET", "http://google.com/path")
assert r1.authority == "google.com", "unexpected authority (#{r1.authority})"
r2 = Request.new("GET", "http://google.com:80/path")
r2 = make_request("GET", "http://google.com:80/path")
assert r2.authority == "google.com", "unexpected authority (#{r2.authority})"
r3 = Request.new("GET", "http://app.dev:8080/path")
r3 = make_request("GET", "http://app.dev:8080/path")
assert r3.authority == "app.dev:8080", "unexpected authority (#{r3.authority})"
r4 = Request.new("GET", "http://127.0.0.1:80/path")
r4 = make_request("GET", "http://127.0.0.1:80/path")
assert r4.authority == "127.0.0.1", "unexpected authority (#{r4.authority})"
r5 = Request.new("GET", "https://[::1]:443/path")
r5 = make_request("GET", "https://[::1]:443/path")
assert r5.authority == "[::1]", "unexpected authority (#{r5.authority})"
r6 = Request.new("GET", "http://127.0.0.1:81/path")
r6 = make_request("GET", "http://127.0.0.1:81/path")
assert r6.authority == "127.0.0.1:81", "unexpected authority (#{r6.authority})"
r7 = Request.new("GET", "https://[::1]:444/path")
r7 = make_request("GET", "https://[::1]:444/path")
assert r7.authority == "[::1]:444", "unexpected authority (#{r7.authority})"
end
def test_request_path
r1 = Request.new("GET", "http://google.com/")
r1 = make_request("GET", "http://google.com/")
assert r1.path == "/", "unexpected path (#{r1.path})"
r2 = Request.new("GET", "http://google.com/path")
r2 = make_request("GET", "http://google.com/path")
assert r2.path == "/path", "unexpected path (#{r2.path})"
r3 = Request.new("GET", "http://google.com/path?q=bang&region=eu-west-1")
r3 = make_request("GET", "http://google.com/path?q=bang&region=eu-west-1")
assert r3.path == "/path?q=bang&region=eu-west-1", "unexpected path (#{r3.path})"
r4 = Request.new("GET", "https://google.com?q=bang bang")
r4 = make_request("GET", "https://google.com?q=bang bang")
assert r4.path == "/?q=bang%20bang", "must replace unsafe characters"
end
def test_request_body_raw
req = Request.new("POST", "http://example.com/", body: "bang")
req = make_request("POST", "http://example.com/", body: "bang")
assert !req.body.empty?, "body should exist"
assert req.headers["content-type"] == "application/octet-stream", "content type is wrong"
assert req.headers["content-length"] == "4", "content length is wrong"
end
def test_request_body_form
req = Request.new("POST", "http://example.com/", form: { "foo" => "bar" })
req = make_request("POST", "http://example.com/", form: { "foo" => "bar" })
assert !req.body.empty?, "body should exist"
assert req.headers["content-type"] == "application/x-www-form-urlencoded", "content type is wrong"
assert req.headers["content-length"] == "7", "content length is wrong"
end
def test_request_body_json
req = Request.new("POST", "http://example.com/", json: { "foo" => "bar" })
req = make_request("POST", "http://example.com/", json: { "foo" => "bar" })
assert !req.body.empty?, "body should exist"
assert req.headers["content-type"] == "application/json; charset=utf-8", "content type is wrong"
assert req.headers["content-length"] == "13", "content length is wrong"
end
def test_request_body_xml
req = Request.new("POST", "http://example.com/", xml: "<xml></xml>")
req = make_request("POST", "http://example.com/", xml: "<xml></xml>")
assert !req.body.empty?, "body should exist"
assert req.headers["content-type"] == "application/xml; charset=utf-8", "content type is wrong"
assert req.headers["content-length"] == "11", "content length is wrong"
end
def test_request_body_deflater_for_anything
body = Request::Body.new(Headers.new({ "content-encoding" => "unknown" }), Options.new(body: "foo"))
body = Request::Body.new(Headers.new({ "content-encoding" => "unknown" }), Options.new, body: "foo")
assert body.to_s == "foo"
end
private
def resource
@resource ||= Request.new("GET", "http://localhost:3000")
@resource ||= make_request("GET", "http://localhost:3000")
end
def make_request(meth, uri, *args)
Request.new(meth, uri, Options.new, *args)
end
end

44
test/response_cache_store_test.rb
View File

@ -7,21 +7,21 @@ class ResponseCacheStoreTest < Minitest::Test
include HTTPX
def test_store_cache
request = request_class.new("GET", "http://example.com/")
request = make_request("GET", "http://example.com/")
response = cached_response(request)
assert store.lookup(request) == response
assert store.cached?(request)
request2 = request_class.new("GET", "http://example.com/", headers: { "accept" => "text/plain" })
request2 = make_request("GET", "http://example.com/", headers: { "accept" => "text/plain" })
assert store.lookup(request2) == response
request3 = request_class.new("POST", "http://example.com/", headers: { "accept" => "text/plain" })
request3 = make_request("POST", "http://example.com/", headers: { "accept" => "text/plain" })
assert store.lookup(request3).nil?
end
def test_store_error_status
request = request_class.new("GET", "http://example.com/")
request = make_request("GET", "http://example.com/")
_response = cached_response(request, status: 404)
assert !store.cached?(request)
@ -30,71 +30,71 @@ class ResponseCacheStoreTest < Minitest::Test
end
def test_store_no_store
request = request_class.new("GET", "http://example.com/")
request = make_request("GET", "http://example.com/")
_response = cached_response(request, extra_headers: { "cache-control" => "private, no-store" })
assert !store.cached?(request)
end
def test_store_maxage
request = request_class.new("GET", "http://example.com/")
request = make_request("GET", "http://example.com/")
response = cached_response(request, extra_headers: { "cache-control" => "max-age=2" })
assert store.lookup(request) == response
sleep(3)
assert store.lookup(request).nil?
request2 = request_class.new("GET", "http://example2.com/")
request2 = make_request("GET", "http://example2.com/")
_response2 = cached_response(request2, extra_headers: { "cache-control" => "no-cache, max-age=2" })
assert store.lookup(request2).nil?
end
def test_store_expires
request = request_class.new("GET", "http://example.com/")
request = make_request("GET", "http://example.com/")
response = cached_response(request, extra_headers: { "expires" => (Time.now + 2).httpdate })
assert store.lookup(request) == response
sleep(3)
assert store.lookup(request).nil?
request2 = request_class.new("GET", "http://example2.com/")
request2 = make_request("GET", "http://example2.com/")
cached_response(request2, extra_headers: { "cache-control" => "no-cache", "expires" => (Time.now + 2).httpdate })
assert store.lookup(request2).nil?
request_invalid_expires = request_class.new("GET", "http://example3.com/")
request_invalid_expires = make_request("GET", "http://example3.com/")
invalid_expires_response = cached_response(request_invalid_expires, extra_headers: { "expires" => "smthsmth" })
assert store.lookup(request_invalid_expires) == invalid_expires_response
end
def test_store_invalid_date
request_invalid_age = request_class.new("GET", "http://example4.com/")
request_invalid_age = make_request("GET", "http://example4.com/")
response_invalid_age = cached_response(request_invalid_age, extra_headers: { "cache-control" => "max-age=2", "date" => "smthsmth" })
assert store.lookup(request_invalid_age) == response_invalid_age
end
def test_prepare_vary
request = request_class.new("GET", "http://example.com/", headers: { "accept" => "text/plain" })
request = make_request("GET", "http://example.com/", headers: { "accept" => "text/plain" })
cached_response(request, extra_headers: { "vary" => "Accept" })
request2 = request_class.new("GET", "http://example.com/", headers: { "accept" => "text/html" })
request2 = make_request("GET", "http://example.com/", headers: { "accept" => "text/html" })
store.prepare(request2)
assert !request2.headers.key?("if-none-match")
request3 = request_class.new("GET", "http://example.com/", headers: { "accept" => "text/plain" })
request3 = make_request("GET", "http://example.com/", headers: { "accept" => "text/plain" })
store.prepare(request3)
assert request3.headers.key?("if-none-match")
request4 = request_class.new("GET", "http://example.com/", headers: { "accept" => "text/plain", "user-agent" => "Linux Bowser" })
request4 = make_request("GET", "http://example.com/", headers: { "accept" => "text/plain", "user-agent" => "Linux Bowser" })
store.prepare(request4)
assert request4.headers.key?("if-none-match")
end
def test_prepare_vary_asterisk
request = request_class.new("GET", "http://example.com/", headers: { "accept" => "text/plain" })
request = make_request("GET", "http://example.com/", headers: { "accept" => "text/plain" })
cached_response(request, extra_headers: { "vary" => "*" })
request2 = request_class.new("GET", "http://example.com/", headers: { "accept" => "text/html" })
request2 = make_request("GET", "http://example.com/", headers: { "accept" => "text/html" })
store.prepare(request2)
assert !request2.headers.key?("if-none-match")
request3 = request_class.new("GET", "http://example.com/", headers: { "accept" => "text/plain" })
request3 = make_request("GET", "http://example.com/", headers: { "accept" => "text/plain" })
store.prepare(request3)
assert request3.headers.key?("if-none-match")
request4 = request_class.new("GET", "http://example.com/", headers: { "accept" => "text/plain", "user-agent" => "Linux Bowser" })
request4 = make_request("GET", "http://example.com/", headers: { "accept" => "text/plain", "user-agent" => "Linux Bowser" })
store.prepare(request4)
assert !request4.headers.key?("if-none-match")
end
@ -102,7 +102,7 @@ class ResponseCacheStoreTest < Minitest::Test
def test_internal_store_set
internal_store = store.instance_variable_get(:@store)
request = request_class.new("GET", "http://example.com/")
request = make_request("GET", "http://example.com/")
response = cached_response(request)
assert internal_store[request.response_cache_key].size == 1
assert internal_store[request.response_cache_key].include?(response)
@ -128,6 +128,10 @@ class ResponseCacheStoreTest < Minitest::Test
@store ||= Plugins::ResponseCache::Store.new
end
def make_request(meth, uri, *args)
request_class.new(meth, uri, Options.new, *args)
end
def cached_response(request, status: 200, extra_headers: {})
response = response_class.new(request, status, "2.0", { "date" => Time.now.httpdate, "etag" => "ETAG" }.merge(extra_headers))
store.cache(request, response)

2
test/response_test.rb
View File

@ -230,7 +230,7 @@ class ResponseTest < Minitest::Test
private
def request(verb = "GET", uri = "http://google.com")
Request.new(verb, uri)
Request.new(verb, uri, Options.new)
end
def response(*args)

2
test/support/requests/multipart.rb
View File

@ -202,7 +202,7 @@ module Requests
def test_multipart_response_decoder
form_response = HTTPX::Response.new(
HTTPX::Request.new("GET", "http://example.com"),
HTTPX::Request.new("GET", "http://example.com", HTTPX::Options.new),
200,
"2.0",
{ "content-type" => "multipart/form-data; boundary=90" }

10
test/support/requests/plugins/follow_redirects.rb
View File

@ -128,15 +128,15 @@ module Requests
"request should follow insecure URLs (instead: #{insecure_response.status})"
end
def test_plugin_follow_removes_authorization_header
def test_plugin_follow_redirects_removes_authorization_header
return unless origin.start_with?("http://")
session = HTTPX.plugin(:follow_redirects).with(headers: { "authorization" => "Bearer SECRET" })
response = session.get(max_redirect_uri(1))
verify_status(response, 200)
body = json_body(response)
assert body["headers"].key?("Authorization")
# response = session.get(max_redirect_uri(1))
# verify_status(response, 200)
# body = json_body(response)
# assert body["headers"].key?("Authorization")
response = session.get(redirect_uri("#{httpbin_no_proxy}/get"))
verify_status(response, 200)

2
test/support/requests/resolvers.rb
View File

@ -58,7 +58,7 @@ module Requests
uri = URI(build_uri("/get"))
resolver_class = Class.new(HTTPX::Resolver::HTTPS) do
def build_request(_hostname)
@options.request_class.new("POST", @uri)
@options.request_class.new("POST", @uri, @options)
end
end
response = session.head(uri, resolver_class: resolver_class, resolver_options: options)