http 5.3.1 → 6.0.1

data/spec/lib/http/features/auto_deflate_spec.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe HTTP::Features::AutoDeflate do
-  subject { HTTP::Features::AutoDeflate.new }
-
-  it "raises error for wrong type" do
-    expect { HTTP::Features::AutoDeflate.new(:method => :wrong) }.
-      to raise_error(HTTP::Error) { |error|
-        expect(error.message).to eq("Only gzip and deflate methods are supported")
-      }
-  end
-
-  it "accepts gzip method" do
-    expect(HTTP::Features::AutoDeflate.new(:method => :gzip).method).to eq "gzip"
-  end
-
-  it "accepts deflate method" do
-    expect(HTTP::Features::AutoDeflate.new(:method => :deflate).method).to eq "deflate"
-  end
-
-  it "accepts string as method" do
-    expect(HTTP::Features::AutoDeflate.new(:method => "gzip").method).to eq "gzip"
-  end
-
-  it "uses gzip by default" do
-    expect(subject.method).to eq("gzip")
-  end
-
-  describe "#deflated_body" do
-    let(:body)          { %w[bees cows] }
-    let(:deflated_body) { subject.deflated_body(body) }
-
-    context "when method is gzip" do
-      subject { HTTP::Features::AutoDeflate.new(:method => :gzip) }
-
-      it "returns object which yields gzipped content of the given body" do
-        io = StringIO.new
-        io.set_encoding(Encoding::BINARY)
-        gzip = Zlib::GzipWriter.new(io)
-        gzip.write("beescows")
-        gzip.close
-        gzipped = io.string
-
-        expect(deflated_body.each.to_a.join).to eq gzipped
-      end
-
-      it "caches compressed content when size is called" do
-        io = StringIO.new
-        io.set_encoding(Encoding::BINARY)
-        gzip = Zlib::GzipWriter.new(io)
-        gzip.write("beescows")
-        gzip.close
-        gzipped = io.string
-
-        expect(deflated_body.size).to eq gzipped.bytesize
-        expect(deflated_body.each.to_a.join).to eq gzipped
-      end
-    end
-
-    context "when method is deflate" do
-      subject { HTTP::Features::AutoDeflate.new(:method => :deflate) }
-
-      it "returns object which yields deflated content of the given body" do
-        deflated = Zlib::Deflate.deflate("beescows")
-
-        expect(deflated_body.each.to_a.join).to eq deflated
-      end
-
-      it "caches compressed content when size is called" do
-        deflated = Zlib::Deflate.deflate("beescows")
-
-        expect(deflated_body.size).to eq deflated.bytesize
-        expect(deflated_body.each.to_a.join).to eq deflated
-      end
-    end
-  end
-end

data/spec/lib/http/features/auto_inflate_spec.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe HTTP::Features::AutoInflate do
-  subject(:feature) { HTTP::Features::AutoInflate.new }
-
-  let(:connection) { double }
-  let(:headers)    { {} }
-
-  let(:response) do
-    HTTP::Response.new(
-      :version    => "1.1",
-      :status     => 200,
-      :headers    => headers,
-      :connection => connection,
-      :request    => HTTP::Request.new(:verb => :get, :uri => "http://example.com")
-    )
-  end
-
-  describe "#wrap_response" do
-    subject(:result) { feature.wrap_response(response) }
-
-    context "when there is no Content-Encoding header" do
-      it "returns original request" do
-        expect(result).to be response
-      end
-    end
-
-    context "for identity Content-Encoding header" do
-      let(:headers) { {:content_encoding => "identity"} }
-
-      it "returns original request" do
-        expect(result).to be response
-      end
-    end
-
-    context "for unknown Content-Encoding header" do
-      let(:headers) { {:content_encoding => "not-supported"} }
-
-      it "returns original request" do
-        expect(result).to be response
-      end
-    end
-
-    context "for deflate Content-Encoding header" do
-      let(:headers) { {:content_encoding => "deflate"} }
-
-      it "returns a HTTP::Response wrapping the inflated response body" do
-        expect(result.body).to be_instance_of HTTP::Response::Body
-      end
-    end
-
-    context "for gzip Content-Encoding header" do
-      let(:headers) { {:content_encoding => "gzip"} }
-
-      it "returns a HTTP::Response wrapping the inflated response body" do
-        expect(result.body).to be_instance_of HTTP::Response::Body
-      end
-    end
-
-    context "for x-gzip Content-Encoding header" do
-      let(:headers) { {:content_encoding => "x-gzip"} }
-
-      it "returns a HTTP::Response wrapping the inflated response body" do
-        expect(result.body).to be_instance_of HTTP::Response::Body
-      end
-    end
-
-    # TODO(ixti): We should refactor API to either make uri non-optional,
-    #   or add reference to request into response object (better).
-    context "when response has uri" do
-      let(:response) do
-        HTTP::Response.new(
-          :version    => "1.1",
-          :status     => 200,
-          :headers    => {:content_encoding => "gzip"},
-          :connection => connection,
-          :request    => HTTP::Request.new(:verb => :get, :uri => "https://example.com")
-        )
-      end
-
-      it "preserves uri in wrapped response" do
-        expect(result.uri).to eq HTTP::URI.parse("https://example.com")
-      end
-    end
-  end
-end

data/spec/lib/http/features/instrumentation_spec.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe HTTP::Features::Instrumentation do
-  subject(:feature) { HTTP::Features::Instrumentation.new(:instrumenter => instrumenter) }
-
-  let(:instrumenter) { TestInstrumenter.new }
-
-  before do
-    test_instrumenter = Class.new(HTTP::Features::Instrumentation::NullInstrumenter) do
-      attr_reader :output
-
-      def initialize
-        @output = {}
-      end
-
-      def start(_name, payload)
-        output[:start] = payload
-      end
-
-      def finish(_name, payload)
-        output[:finish] = payload
-      end
-    end
-
-    stub_const("TestInstrumenter", test_instrumenter)
-  end
-
-  describe "logging the request" do
-    let(:request) do
-      HTTP::Request.new(
-        :verb    => :post,
-        :uri     => "https://example.com/",
-        :headers => {:accept => "application/json"},
-        :body    => '{"hello": "world!"}'
-      )
-    end
-
-    it "should log the request" do
-      feature.wrap_request(request)
-
-      expect(instrumenter.output[:start]).to eq(:request => request)
-    end
-  end
-
-  describe "logging the response" do
-    let(:response) do
-      HTTP::Response.new(
-        :version => "1.1",
-        :status  => 200,
-        :headers => {:content_type => "application/json"},
-        :body    => '{"success": true}',
-        :request => HTTP::Request.new(:verb => :get, :uri => "https://example.com")
-      )
-    end
-
-    it "should log the response" do
-      feature.wrap_response(response)
-
-      expect(instrumenter.output[:finish]).to eq(:response => response)
-    end
-  end
-
-  describe "logging errors" do
-    let(:request) do
-      HTTP::Request.new(
-        :verb    => :post,
-        :uri     => "https://example.com/",
-        :headers => {:accept => "application/json"},
-        :body    => '{"hello": "world!"}'
-      )
-    end
-
-    let(:error) { HTTP::TimeoutError.new }
-
-    it "should log the error" do
-      feature.on_error(request, error)
-
-      expect(instrumenter.output[:finish]).to eq(:request => request, :error => error)
-    end
-  end
-end

data/spec/lib/http/features/logging_spec.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-require "logger"
-
-RSpec.describe HTTP::Features::Logging do
-  subject(:feature) do
-    logger           = Logger.new(logdev)
-    logger.formatter = ->(severity, _, _, message) { format("** %s **\n%s\n", severity, message) }
-
-    described_class.new(:logger => logger)
-  end
-
-  let(:logdev) { StringIO.new }
-
-  describe "logging the request" do
-    let(:request) do
-      HTTP::Request.new(
-        :verb    => :post,
-        :uri     => "https://example.com/",
-        :headers => {:accept => "application/json"},
-        :body    => '{"hello": "world!"}'
-      )
-    end
-
-    it "should log the request" do
-      feature.wrap_request(request)
-
-      expect(logdev.string).to eq <<~OUTPUT
-        ** INFO **
-        > POST https://example.com/
-        ** DEBUG **
-        Accept: application/json
-        Host: example.com
-        User-Agent: http.rb/#{HTTP::VERSION}
-
-        {"hello": "world!"}
-      OUTPUT
-    end
-  end
-
-  describe "logging the response" do
-    let(:response) do
-      HTTP::Response.new(
-        :version => "1.1",
-        :status  => 200,
-        :headers => {:content_type => "application/json"},
-        :body    => '{"success": true}',
-        :request => HTTP::Request.new(:verb => :get, :uri => "https://example.com")
-      )
-    end
-
-    it "should log the response" do
-      feature.wrap_response(response)
-
-      expect(logdev.string).to eq <<~OUTPUT
-        ** INFO **
-        < 200 OK
-        ** DEBUG **
-        Content-Type: application/json
-
-        {"success": true}
-      OUTPUT
-    end
-  end
-end

data/spec/lib/http/features/raise_error_spec.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe HTTP::Features::RaiseError do
-  subject(:feature) { described_class.new(ignore: ignore) }
-
-  let(:connection) { double }
-  let(:status) { 200 }
-  let(:ignore) { [] }
-
-  describe "#wrap_response" do
-    subject(:result) { feature.wrap_response(response) }
-
-    let(:response) do
-      HTTP::Response.new(
-        version:    "1.1",
-        status:     status,
-        headers:    {},
-        connection: connection,
-        request:    HTTP::Request.new(verb: :get, uri: "https://example.com")
-      )
-    end
-
-    context "when status is 200" do
-      it "returns original request" do
-        expect(result).to be response
-      end
-    end
-
-    context "when status is 399" do
-      let(:status) { 399 }
-
-      it "returns original request" do
-        expect(result).to be response
-      end
-    end
-
-    context "when status is 400" do
-      let(:status) { 400 }
-
-      it "raises" do
-        expect { result }.to raise_error(HTTP::StatusError, "Unexpected status code 400")
-      end
-    end
-
-    context "when status is 599" do
-      let(:status) { 599 }
-
-      it "raises" do
-        expect { result }.to raise_error(HTTP::StatusError, "Unexpected status code 599")
-      end
-    end
-
-    context "when error status is ignored" do
-      let(:status) { 500 }
-      let(:ignore) { [500] }
-
-      it "returns original request" do
-        expect(result).to be response
-      end
-    end
-  end
-end

data/spec/lib/http/headers/mixin_spec.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe HTTP::Headers::Mixin do
-  let :dummy_class do
-    Class.new do
-      include HTTP::Headers::Mixin
-
-      def initialize(headers)
-        @headers = headers
-      end
-    end
-  end
-
-  let(:headers) { HTTP::Headers.new }
-  let(:dummy)   { dummy_class.new headers }
-
-  describe "#headers" do
-    it "returns @headers instance variable" do
-      expect(dummy.headers).to be headers
-    end
-  end
-
-  describe "#[]" do
-    it "proxies to headers#[]" do
-      expect(headers).to receive(:[]).with(:accept)
-      dummy[:accept]
-    end
-  end
-
-  describe "#[]=" do
-    it "proxies to headers#[]" do
-      expect(headers).to receive(:[]=).with(:accept, "text/plain")
-      dummy[:accept] = "text/plain"
-    end
-  end
-end

data/spec/lib/http/headers/normalizer_spec.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe HTTP::Headers::Normalizer do
-  subject(:normalizer) { described_class.new }
-
-  include_context RSpec::Memory
-
-  describe "#call" do
-    it "normalizes the header" do
-      expect(normalizer.call("content_type")).to eq "Content-Type"
-    end
-
-    it "returns a non-frozen string" do
-      expect(normalizer.call("content_type")).not_to be_frozen
-    end
-
-    it "evicts the oldest item when cache is full" do
-      max_headers = (1..described_class::Cache::MAX_SIZE).map { |i| "Header#{i}" }
-      max_headers.each { |header| normalizer.call(header) }
-      normalizer.call("New-Header")
-      cache_store = normalizer.instance_variable_get(:@cache).instance_variable_get(:@store)
-      expect(cache_store.keys).to eq(max_headers[1..] + ["New-Header"])
-    end
-
-    it "retuns mutable strings" do
-      normalized_headers = Array.new(3) { normalizer.call("content_type") }
-
-      expect(normalized_headers)
-        .to satisfy { |arr| arr.uniq.size == 1 }
-        .and(satisfy { |arr| arr.map(&:object_id).uniq.size == normalized_headers.size })
-        .and(satisfy { |arr| arr.none?(&:frozen?) })
-    end
-
-    it "allocates minimal memory for normalization of the same header" do
-      normalizer.call("accept") # XXX: Ensure normalizer is pre-allocated
-
-      # On first call it is expected to allocate during normalization
-      expect { normalizer.call("content_type") }.to limit_allocations(
-        Array     => 1,
-        MatchData => 1,
-        String    => 6
-      )
-
-      # On subsequent call it is expected to only allocate copy of a cached string
-      expect { normalizer.call("content_type") }.to limit_allocations(
-        Array     => 0,
-        MatchData => 0,
-        String    => 1
-      )
-    end
-  end
-end