http 5.3.1 → 6.0.1

data/spec/lib/http/response/parser_spec.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe HTTP::Response::Parser do
-  subject(:parser) { described_class.new }
-  let(:raw_response) do
-    "HTTP/1.1 200 OK\r\nContent-Length: 2\r\nContent-Type: application/json\r\nMyHeader: val\r\nEmptyHeader: \r\n\r\n{}"
-  end
-  let(:expected_headers) do
-    {
-      "Content-Length" => "2",
-      "Content-Type"   => "application/json",
-      "MyHeader"       => "val",
-      "EmptyHeader"    => ""
-    }
-  end
-  let(:expected_body) { "{}" }
-
-  before do
-    parts.each { |part| subject.add(part) }
-  end
-
-  context "whole response in one part" do
-    let(:parts) { [raw_response] }
-
-    it "parses headers" do
-      expect(subject.headers.to_h).to eq(expected_headers)
-    end
-
-    it "parses body" do
-      expect(subject.read(expected_body.size)).to eq(expected_body)
-    end
-  end
-
-  context "response in many parts" do
-    let(:parts) { raw_response.chars }
-
-    it "parses headers" do
-      expect(subject.headers.to_h).to eq(expected_headers)
-    end
-
-    it "parses body" do
-      expect(subject.read(expected_body.size)).to eq(expected_body)
-    end
-  end
-
-  context "when got 100 Continue response" do
-    let :raw_response do
-      "HTTP/1.1 100 Continue\r\n\r\n" \
-        "HTTP/1.1 200 OK\r\n" \
-        "Content-Length: 12\r\n\r\n" \
-        "Hello World!"
-    end
-
-    context "when response is feeded in one part" do
-      let(:parts) { [raw_response] }
-
-      it "skips to next non-info response" do
-        expect(subject.status_code).to eq(200)
-        expect(subject.headers).to eq("Content-Length" => "12")
-        expect(subject.read(12)).to eq("Hello World!")
-      end
-    end
-
-    context "when response is feeded in many parts" do
-      let(:parts) { raw_response.chars }
-
-      it "skips to next non-info response" do
-        expect(subject.status_code).to eq(200)
-        expect(subject.headers).to eq("Content-Length" => "12")
-        expect(subject.read(12)).to eq("Hello World!")
-      end
-    end
-  end
-end

data/spec/lib/http/response/status_spec.rb

@@ -1,253 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe HTTP::Response::Status do
-  describe ".new" do
-    it "fails if given value does not respond to #to_i" do
-      expect { described_class.new double }.to raise_error TypeError
-    end
-
-    it "accepts any object that responds to #to_i" do
-      expect { described_class.new double :to_i => 200 }.to_not raise_error
-    end
-  end
-
-  describe "#code" do
-    subject { described_class.new("200.0").code }
-    it { is_expected.to eq 200 }
-    it { is_expected.to be_a Integer }
-  end
-
-  describe "#reason" do
-    subject { described_class.new(code).reason }
-
-    context "with unknown code" do
-      let(:code) { 1024 }
-      it { is_expected.to be_nil }
-    end
-
-    described_class::REASONS.each do |code, reason|
-      class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        context 'with well-known code: #{code}' do
-          let(:code) { #{code} }
-          it { is_expected.to eq #{reason.inspect} }
-          it { is_expected.to be_frozen }
-        end
-      RUBY
-    end
-  end
-
-  context "with 1xx codes" do
-    subject { (100...200).map { |code| described_class.new code } }
-
-    it "is #informational?" do
-      expect(subject).to all(satisfy(&:informational?))
-    end
-
-    it "is not #success?" do
-      expect(subject).to all(satisfy { |status| !status.success? })
-    end
-
-    it "is not #redirect?" do
-      expect(subject).to all(satisfy { |status| !status.redirect? })
-    end
-
-    it "is not #client_error?" do
-      expect(subject).to all(satisfy { |status| !status.client_error? })
-    end
-
-    it "is not #server_error?" do
-      expect(subject).to all(satisfy { |status| !status.server_error? })
-    end
-  end
-
-  context "with 2xx codes" do
-    subject { (200...300).map { |code| described_class.new code } }
-
-    it "is not #informational?" do
-      expect(subject).to all(satisfy { |status| !status.informational? })
-    end
-
-    it "is #success?" do
-      expect(subject).to all(satisfy(&:success?))
-    end
-
-    it "is not #redirect?" do
-      expect(subject).to all(satisfy { |status| !status.redirect? })
-    end
-
-    it "is not #client_error?" do
-      expect(subject).to all(satisfy { |status| !status.client_error? })
-    end
-
-    it "is not #server_error?" do
-      expect(subject).to all(satisfy { |status| !status.server_error? })
-    end
-  end
-
-  context "with 3xx codes" do
-    subject { (300...400).map { |code| described_class.new code } }
-
-    it "is not #informational?" do
-      expect(subject).to all(satisfy { |status| !status.informational? })
-    end
-
-    it "is not #success?" do
-      expect(subject).to all(satisfy { |status| !status.success? })
-    end
-
-    it "is #redirect?" do
-      expect(subject).to all(satisfy(&:redirect?))
-    end
-
-    it "is not #client_error?" do
-      expect(subject).to all(satisfy { |status| !status.client_error? })
-    end
-
-    it "is not #server_error?" do
-      expect(subject).to all(satisfy { |status| !status.server_error? })
-    end
-  end
-
-  context "with 4xx codes" do
-    subject { (400...500).map { |code| described_class.new code } }
-
-    it "is not #informational?" do
-      expect(subject).to all(satisfy { |status| !status.informational? })
-    end
-
-    it "is not #success?" do
-      expect(subject).to all(satisfy { |status| !status.success? })
-    end
-
-    it "is not #redirect?" do
-      expect(subject).to all(satisfy { |status| !status.redirect? })
-    end
-
-    it "is #client_error?" do
-      expect(subject).to all(satisfy(&:client_error?))
-    end
-
-    it "is not #server_error?" do
-      expect(subject).to all(satisfy { |status| !status.server_error? })
-    end
-  end
-
-  context "with 5xx codes" do
-    subject { (500...600).map { |code| described_class.new code } }
-
-    it "is not #informational?" do
-      expect(subject).to all(satisfy { |status| !status.informational? })
-    end
-
-    it "is not #success?" do
-      expect(subject).to all(satisfy { |status| !status.success? })
-    end
-
-    it "is not #redirect?" do
-      expect(subject).to all(satisfy { |status| !status.redirect? })
-    end
-
-    it "is not #client_error?" do
-      expect(subject).to all(satisfy { |status| !status.client_error? })
-    end
-
-    it "is #server_error?" do
-      expect(subject).to all(satisfy(&:server_error?))
-    end
-  end
-
-  describe "#to_sym" do
-    subject { described_class.new(code).to_sym }
-
-    context "with unknown code" do
-      let(:code) { 1024 }
-      it { is_expected.to be_nil }
-    end
-
-    described_class::SYMBOLS.each do |code, symbol|
-      class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        context 'with well-known code: #{code}' do
-          let(:code) { #{code} }
-          it { is_expected.to be #{symbol.inspect} }
-        end
-      RUBY
-    end
-  end
-
-  describe "#inspect" do
-    it "returns quoted code and reason phrase" do
-      status = described_class.new 200
-      expect(status.inspect).to eq "#<HTTP::Response::Status 200 OK>"
-    end
-  end
-
-  # testing edge cases only
-  describe "::SYMBOLS" do
-    subject { described_class::SYMBOLS }
-
-    # "OK"
-    its([200]) { is_expected.to be :ok }
-
-    # "Bad Request"
-    its([400]) { is_expected.to be :bad_request }
-  end
-
-  described_class::SYMBOLS.each do |code, symbol|
-    class_eval <<-RUBY, __FILE__, __LINE__ + 1
-      describe '##{symbol}?' do
-        subject { status.#{symbol}? }
-
-        context 'when code is #{code}' do
-          let(:status) { described_class.new #{code} }
-          it { is_expected.to be true }
-        end
-
-        context 'when code is higher than #{code}' do
-          let(:status) { described_class.new #{code + 1} }
-          it { is_expected.to be false }
-        end
-
-        context 'when code is lower than #{code}' do
-          let(:status) { described_class.new #{code - 1} }
-          it { is_expected.to be false }
-        end
-      end
-    RUBY
-  end
-
-  describe ".coerce" do
-    context "with String" do
-      it "coerces reasons" do
-        expect(described_class.coerce("Bad request")).to eq described_class.new 400
-      end
-
-      it "fails when reason is unknown" do
-        expect { described_class.coerce "foobar" }.to raise_error HTTP::Error
-      end
-    end
-
-    context "with Symbol" do
-      it "coerces symbolized reasons" do
-        expect(described_class.coerce(:bad_request)).to eq described_class.new 400
-      end
-
-      it "fails when symbolized reason is unknown" do
-        expect { described_class.coerce(:foobar) }.to raise_error HTTP::Error
-      end
-    end
-
-    context "with Numeric" do
-      it "coerces as Fixnum code" do
-        expect(described_class.coerce(200.1)).to eq described_class.new 200
-      end
-    end
-
-    it "fails if coercion failed" do
-      expect { described_class.coerce(true) }.to raise_error HTTP::Error
-    end
-
-    it "is aliased as `.[]`" do
-      expect(described_class.method(:coerce)).to eq described_class.method :[]
-    end
-  end
-end

data/spec/lib/http/response_spec.rb

@@ -1,262 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe HTTP::Response do
-  let(:body)          { "Hello world!" }
-  let(:uri)           { "http://example.com/" }
-  let(:headers)       { {} }
-  let(:request)       { HTTP::Request.new(:verb => :get, :uri => uri) }
-
-  subject(:response) do
-    HTTP::Response.new(
-      :status  => 200,
-      :version => "1.1",
-      :headers => headers,
-      :body    => body,
-      :request => request
-    )
-  end
-
-  it "includes HTTP::Headers::Mixin" do
-    expect(described_class).to include HTTP::Headers::Mixin
-  end
-
-  describe "to_a" do
-    let(:body)         { "Hello world" }
-    let(:content_type) { "text/plain" }
-    let(:headers)      { {"Content-Type" => content_type} }
-
-    it "returns a Rack-like array" do
-      expect(subject.to_a).to eq([200, headers, body])
-    end
-  end
-
-  describe "#content_length" do
-    subject { response.content_length }
-
-    context "without Content-Length header" do
-      it { is_expected.to be_nil }
-    end
-
-    context "with Content-Length: 5" do
-      let(:headers) { {"Content-Length" => "5"} }
-      it { is_expected.to eq 5 }
-    end
-
-    context "with invalid Content-Length" do
-      let(:headers) { {"Content-Length" => "foo"} }
-      it { is_expected.to be_nil }
-    end
-  end
-
-  describe "mime_type" do
-    subject { response.mime_type }
-
-    context "without Content-Type header" do
-      let(:headers) { {} }
-      it { is_expected.to be_nil }
-    end
-
-    context "with Content-Type: text/html" do
-      let(:headers) { {"Content-Type" => "text/html"} }
-      it { is_expected.to eq "text/html" }
-    end
-
-    context "with Content-Type: text/html; charset=utf-8" do
-      let(:headers) { {"Content-Type" => "text/html; charset=utf-8"} }
-      it { is_expected.to eq "text/html" }
-    end
-  end
-
-  describe "charset" do
-    subject { response.charset }
-
-    context "without Content-Type header" do
-      let(:headers) { {} }
-      it { is_expected.to be_nil }
-    end
-
-    context "with Content-Type: text/html" do
-      let(:headers) { {"Content-Type" => "text/html"} }
-      it { is_expected.to be_nil }
-    end
-
-    context "with Content-Type: text/html; charset=utf-8" do
-      let(:headers) { {"Content-Type" => "text/html; charset=utf-8"} }
-      it { is_expected.to eq "utf-8" }
-    end
-  end
-
-  describe "#parse" do
-    let(:headers)   { {"Content-Type" => content_type} }
-    let(:body)      { '{"foo":"bar"}' }
-
-    context "with known content type" do
-      let(:content_type) { "application/json" }
-      it "returns parsed body" do
-        expect(response.parse).to eq "foo" => "bar"
-      end
-    end
-
-    context "with unknown content type" do
-      let(:content_type) { "application/deadbeef" }
-      it "raises HTTP::Error" do
-        expect { response.parse }.to raise_error HTTP::Error
-      end
-    end
-
-    context "with explicitly given mime type" do
-      let(:content_type) { "application/deadbeef" }
-      it "ignores mime_type of response" do
-        expect(response.parse("application/json")).to eq "foo" => "bar"
-      end
-
-      it "supports mime type aliases" do
-        expect(response.parse(:json)).to eq "foo" => "bar"
-      end
-    end
-  end
-
-  describe "#flush" do
-    let(:body) { double :to_s => "" }
-
-    it "returns response self-reference" do
-      expect(response.flush).to be response
-    end
-
-    it "flushes body" do
-      expect(body).to receive :to_s
-      response.flush
-    end
-  end
-
-  describe "#inspect" do
-    subject { response.inspect }
-
-    let(:headers) { {:content_type => "text/plain"} }
-    let(:body)    { double :to_s => "foobar" }
-
-    it { is_expected.to eq '#<HTTP::Response/1.1 200 OK {"Content-Type"=>"text/plain"}>' }
-  end
-
-  describe "#cookies" do
-    let(:cookies) { ["a=1", "b=2; domain=example.com", "c=3; domain=bad.org"] }
-    let(:headers) { {"Set-Cookie" => cookies} }
-
-    subject(:jar) { response.cookies }
-
-    it { is_expected.to be_an HTTP::CookieJar }
-
-    it "contains cookies without domain restriction" do
-      expect(jar.count { |c| "a" == c.name }).to eq 1
-    end
-
-    it "contains cookies limited to domain of request uri" do
-      expect(jar.count { |c| "b" == c.name }).to eq 1
-    end
-
-    it "does not contains cookies limited to non-requeted uri" do
-      expect(jar.count { |c| "c" == c.name }).to eq 0
-    end
-  end
-
-  describe "#connection" do
-    let(:connection) { double }
-
-    subject(:response) do
-      HTTP::Response.new(
-        :version    => "1.1",
-        :status     => 200,
-        :connection => connection,
-        :request    => request
-      )
-    end
-
-    it "returns the connection object used to instantiate the response" do
-      expect(response.connection).to eq connection
-    end
-  end
-
-  describe "#chunked?" do
-    subject { response }
-    context "when encoding is set to chunked" do
-      let(:headers) { {"Transfer-Encoding" => "chunked"} }
-      it { is_expected.to be_chunked }
-    end
-    it { is_expected.not_to be_chunked }
-  end
-
-  describe "backwards compatibilty with :uri" do
-    context "with no :verb" do
-      subject(:response) do
-        HTTP::Response.new(
-          :status  => 200,
-          :version => "1.1",
-          :headers => headers,
-          :body    => body,
-          :uri     => uri
-        )
-      end
-
-      it "defaults the uri to :uri" do
-        expect(response.request.uri.to_s).to eq uri
-      end
-
-      it "defaults to the verb to :get" do
-        expect(response.request.verb).to eq :get
-      end
-    end
-
-    context "with both a :request and :uri" do
-      subject(:response) do
-        HTTP::Response.new(
-          :status  => 200,
-          :version => "1.1",
-          :headers => headers,
-          :body    => body,
-          :uri     => uri,
-          :request => request
-        )
-      end
-
-      it "raises ArgumentError" do
-        expect { response }.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  describe "#body" do
-    let(:connection) { double(:sequence_id => 0) }
-    let(:chunks)     { ["Hello, ", "World!"] }
-
-    subject(:response) do
-      HTTP::Response.new(
-        :status     => 200,
-        :version    => "1.1",
-        :headers    => headers,
-        :request    => request,
-        :connection => connection
-      )
-    end
-
-    before do
-      allow(connection).to receive(:readpartial) { chunks.shift }
-      allow(connection).to receive(:body_completed?) { chunks.empty? }
-    end
-
-    context "with no Content-Type" do
-      let(:headers) { {} }
-
-      it "returns a body with default binary encoding" do
-        expect(response.body.to_s.encoding).to eq Encoding::BINARY
-      end
-    end
-
-    context "with Content-Type: application/json" do
-      let(:headers) { {"Content-Type" => "application/json"} }
-
-      it "returns a body with a default UTF_8 encoding" do
-        expect(response.body.to_s.encoding).to eq Encoding::UTF_8
-      end
-    end
-  end
-end

data/spec/lib/http/retriable/delay_calculator_spec.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe HTTP::Retriable::DelayCalculator do
-  let(:response) do
-    HTTP::Response.new(
-      status:  200,
-      version: "1.1",
-      headers: {},
-      body:    "Hello world!",
-      request: HTTP::Request.new(verb: :get, uri: "http://example.com")
-    )
-  end
-
-  def call_delay(iterations, **options)
-    described_class.new(options).call(iterations, response)
-  end
-
-  def call_retry_header(value, **options)
-    response.headers["Retry-After"] = value
-    described_class.new(options).call(rand(1...100), response)
-  end
-
-  it "prevents negative sleep time" do
-    expect(call_delay(20, delay: -20)).to eq 0
-  end
-
-  it "backs off exponentially" do
-    expect(call_delay(1)).to be_between 0, 1
-    expect(call_delay(2)).to be_between 1, 2
-    expect(call_delay(3)).to be_between 3, 4
-    expect(call_delay(4)).to be_between 7, 8
-    expect(call_delay(5)).to be_between 15, 16
-  end
-
-  it "can have a maximum wait time" do
-    expect(call_delay(1, max_delay: 5)).to be_between 0, 1
-    expect(call_delay(5, max_delay: 5)).to eq 5
-  end
-
-  it "respects Retry-After headers as integer" do
-    delay_time = rand(6...2500)
-    header_value = delay_time.to_s
-    expect(call_retry_header(header_value)).to eq delay_time
-    expect(call_retry_header(header_value, max_delay: 5)).to eq 5
-  end
-
-  it "respects Retry-After headers as rfc2822 timestamp" do
-    delay_time = rand(6...2500)
-    header_value = (Time.now.gmtime + delay_time).to_datetime.rfc2822.sub("+0000", "GMT")
-    expect(call_retry_header(header_value)).to be_within(1).of(delay_time)
-    expect(call_retry_header(header_value, max_delay: 5)).to eq 5
-  end
-
-  it "respects Retry-After headers as rfc2822 timestamp in the past" do
-    delay_time = rand(6...2500)
-    header_value = (Time.now.gmtime - delay_time).to_datetime.rfc2822.sub("+0000", "GMT")
-    expect(call_retry_header(header_value)).to eq 0
-  end
-
-  it "does not error on invalid Retry-After header" do
-    [ # invalid strings
-      "This is a string with a number 5 in it",
-      "8 Eight is the first digit in this string",
-      "This is a string with a #{Time.now.gmtime.to_datetime.rfc2822} timestamp in it"
-    ].each do |header_value|
-      expect(call_retry_header(header_value)).to eq 0
-    end
-  end
-end