http 5.3.1 → 6.0.0

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

@@ -1,302 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe HTTP::Retriable::Performer do
-  let(:client) do
-    HTTP::Client.new
-  end
-
-  let(:response) do
-    HTTP::Response.new(
-      status:  200,
-      version: "1.1",
-      headers: {},
-      body:    "Hello world!",
-      request: request
-    )
-  end
-
-  let(:request) do
-    HTTP::Request.new(
-      verb: :get,
-      uri:  "http://example.com"
-    )
-  end
-
-  let(:perform_spy) { { counter: 0 } }
-  let(:counter_spy) { perform_spy[:counter] }
-
-  before do
-    stub_const("CustomException", Class.new(StandardError))
-  end
-
-  def perform(options = {}, client_arg = client, request_arg = request, &block)
-    # by explicitly overwriting the default delay, we make a much faster test suite
-    default_options = { delay: 0 }
-    options = default_options.merge(options)
-
-    HTTP::Retriable::Performer
-      .new(options)
-      .perform(client_arg, request_arg) do
-        perform_spy[:counter] += 1
-        block ? yield : response
-      end
-  end
-
-  def measure_wait
-    t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    result = yield
-    t2 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    [t2 - t1, result]
-  end
-
-  describe "#perform" do
-    describe "expected exception" do
-      it "retries the request" do
-        expect do
-          perform(exceptions: [CustomException], tries: 2) do
-            raise CustomException
-          end
-        end.to raise_error HTTP::OutOfRetriesError
-
-        expect(counter_spy).to eq 2
-      end
-    end
-
-    describe "unexpected exception" do
-      it "does not retry the request" do
-        expect do
-          perform(exceptions: [], tries: 2) do
-            raise CustomException
-          end
-        end.to raise_error CustomException
-
-        expect(counter_spy).to eq 1
-      end
-    end
-
-    describe "expected status codes" do
-      def response(**options)
-        HTTP::Response.new(
-          {
-            status:  200,
-            version: "1.1",
-            headers: {},
-            body:    "Hello world!",
-            request: request
-          }.merge(options)
-        )
-      end
-
-      it "retries the request" do
-        expect do
-          perform(retry_statuses: [200], tries: 2)
-        end.to raise_error HTTP::OutOfRetriesError
-
-        expect(counter_spy).to eq 2
-      end
-
-      describe "status codes can be expressed in many ways" do
-        [
-          301,
-          [200, 301, 485],
-          250...400,
-          [250...Float::INFINITY],
-          ->(status_code) { status_code == 301 },
-          [->(status_code) { status_code == 301 }]
-        ].each do |retry_statuses|
-          it retry_statuses.to_s do
-            expect do
-              perform(retry_statuses: retry_statuses, tries: 2) do
-                response(status: 301)
-              end
-            end.to raise_error HTTP::OutOfRetriesError
-          end
-        end
-      end
-    end
-
-    describe "unexpected status code" do
-      it "does not retry the request" do
-        expect(
-          perform(retry_statuses: [], tries: 2)
-        ).to eq response
-
-        expect(counter_spy).to eq 1
-      end
-    end
-
-    describe "on_retry callback" do
-      it "calls the on_retry callback on each retry with exception" do
-        callback_call_spy = 0
-
-        callback_spy = proc do |callback_request, error, callback_response|
-          expect(callback_request).to eq request
-          expect(error).to be_a HTTP::TimeoutError
-          expect(callback_response).to be_nil
-          callback_call_spy += 1
-        end
-
-        expect do
-          perform(tries: 3, on_retry: callback_spy) do
-            raise HTTP::TimeoutError
-          end
-        end.to raise_error HTTP::OutOfRetriesError
-
-        expect(callback_call_spy).to eq 2
-      end
-
-      it "calls the on_retry callback on each retry with response" do
-        callback_call_spy = 0
-
-        callback_spy = proc do |callback_request, error, callback_response|
-          expect(callback_request).to eq request
-          expect(error).to be_nil
-          expect(callback_response).to be response
-          callback_call_spy += 1
-        end
-
-        expect do
-          perform(retry_statuses: [200], tries: 3, on_retry: callback_spy)
-        end.to raise_error HTTP::OutOfRetriesError
-
-        expect(callback_call_spy).to eq 2
-      end
-    end
-
-    describe "delay option" do
-      let(:timing_slack) { 0.05 }
-
-      it "can be a positive number" do
-        time, = measure_wait do
-          perform(delay: 0.1, tries: 3, should_retry: ->(*) { true })
-        rescue HTTP::OutOfRetriesError
-        end
-        expect(time).to be_within(timing_slack).of(0.2)
-      end
-
-      it "can be a proc number" do
-        time, = measure_wait do
-          perform(delay: ->(attempt) { attempt / 10.0 }, tries: 3, should_retry: ->(*) { true })
-        rescue HTTP::OutOfRetriesError
-        end
-        expect(time).to be_within(timing_slack).of(0.3)
-      end
-
-      it "receives correct retry number when a proc" do
-        retry_count = 0
-        retry_proc = proc do |attempt|
-          expect(attempt).to eq(retry_count).and(be > 0)
-          0
-        end
-        begin
-          perform(delay: retry_proc, should_retry: ->(*) { true }) do
-            retry_count += 1
-            response
-          end
-        rescue HTTP::OutOfRetriesError
-        end
-      end
-    end
-
-    describe "should_retry option" do
-      it "decides if the request should be retried" do # rubocop:disable RSpec/MultipleExpectations
-        retry_proc = proc do |req, err, res, attempt|
-          expect(req).to eq request
-          if res
-            expect(err).to be_nil
-            expect(res).to be response
-          else
-            expect(err).to be_a CustomException
-            expect(res).to be_nil
-          end
-
-          attempt < 5
-        end
-
-        begin
-          perform(should_retry: retry_proc) do
-            rand < 0.5 ? response : raise(CustomException)
-          end
-        rescue CustomException
-        end
-
-        expect(counter_spy).to eq 5
-      end
-
-      it "raises the original error if not retryable" do
-        retry_proc = ->(*) { false }
-
-        expect do
-          perform(should_retry: retry_proc) do
-            raise CustomException
-          end
-        end.to raise_error CustomException
-
-        expect(counter_spy).to eq 1
-      end
-
-      it "raises HTTP::OutOfRetriesError if retryable" do
-        retry_proc = ->(*) { true }
-
-        expect do
-          perform(should_retry: retry_proc) do
-            raise CustomException
-          end
-        end.to raise_error HTTP::OutOfRetriesError
-
-        expect(counter_spy).to eq 5
-      end
-    end
-  end
-
-  describe "connection closing" do
-    let(:client) { double(:client) }
-
-    it "does not close the connection if we get a propper response" do
-      expect(client).not_to receive(:close)
-      perform
-    end
-
-    it "closes the connection after each raiseed attempt" do
-      expect(client).to receive(:close).exactly(3).times
-      begin
-        perform(should_retry: ->(*) { true }, tries: 3)
-      rescue HTTP::OutOfRetriesError
-      end
-    end
-
-    it "closes the connection on an unexpected exception" do
-      expect(client).to receive(:close)
-      begin
-        perform do
-          raise CustomException
-        end
-      rescue CustomException
-      end
-    end
-  end
-
-  describe HTTP::OutOfRetriesError do
-    it "has the original exception as a cause if available" do
-      err = nil
-      begin
-        perform(exceptions: [CustomException]) do
-          raise CustomException
-        end
-      rescue described_class => e
-        err = e
-      end
-      expect(err.cause).to be_a CustomException
-    end
-
-    it "has the last raiseed response as an attribute" do
-      err = nil
-      begin
-        perform(should_retry: ->(*) { true })
-      rescue described_class => e
-        err = e
-      end
-      expect(err.response).to be response
-    end
-  end
-end

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

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe HTTP::URI::NORMALIZER do
-  describe "scheme" do
-    it "lower-cases scheme" do
-      expect(HTTP::URI::NORMALIZER.call("HttP://example.com").scheme).to eq "http"
-    end
-  end
-
-  describe "hostname" do
-    it "lower-cases hostname" do
-      expect(HTTP::URI::NORMALIZER.call("http://EXAMPLE.com").host).to eq "example.com"
-    end
-
-    it "decodes percent-encoded hostname" do
-      expect(HTTP::URI::NORMALIZER.call("http://ex%61mple.com").host).to eq "example.com"
-    end
-
-    it "removes trailing period in hostname" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com.").host).to eq "example.com"
-    end
-
-    it "IDN-encodes non-ASCII hostname" do
-      expect(HTTP::URI::NORMALIZER.call("http://exämple.com").host).to eq "xn--exmple-cua.com"
-    end
-  end
-
-  describe "path" do
-    it "ensures path is not empty" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com").path).to eq "/"
-    end
-
-    it "preserves double slashes in path" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com//a///b").path).to eq "//a///b"
-    end
-
-    it "resolves single-dot segments in path" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com/a/./b").path).to eq "/a/b"
-    end
-
-    it "resolves double-dot segments in path" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com/a/b/../c").path).to eq "/a/c"
-    end
-
-    it "resolves leading double-dot segments in path" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com/../a/b").path).to eq "/a/b"
-    end
-
-    it "percent-encodes control characters in path" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com/\x00\x7F\n").path).to eq "/%00%7F%0A"
-    end
-
-    it "percent-encodes space in path" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com/a b").path).to eq "/a%20b"
-    end
-
-    it "percent-encodes non-ASCII characters in path" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com/キョ").path).to eq "/%E3%82%AD%E3%83%A7"
-    end
-
-    it "does not percent-encode non-special characters in path" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com/~.-_!$&()*,;=:@{}").path).to eq "/~.-_!$&()*,;=:@{}"
-    end
-
-    it "preserves escape sequences in path" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com/%41").path).to eq "/%41"
-    end
-  end
-
-  describe "query" do
-    it "allows no query" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com").query).to be_nil
-    end
-
-    it "percent-encodes control characters in query" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com/?\x00\x7F\n").query).to eq "%00%7F%0A"
-    end
-
-    it "percent-encodes space in query" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com/?a b").query).to eq "a%20b"
-    end
-
-    it "percent-encodes non-ASCII characters in query" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com?キョ").query).to eq "%E3%82%AD%E3%83%A7"
-    end
-
-    it "does not percent-encode non-special characters in query" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com/?~.-_!$&()*,;=:@{}?").query).to eq "~.-_!$&()*,;=:@{}?"
-    end
-
-    it "preserves escape sequences in query" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com/?%41").query).to eq "%41"
-    end
-  end
-end

data/spec/lib/http/uri_spec.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe HTTP::URI do
-  let(:example_ipv6_address) { "2606:2800:220:1:248:1893:25c8:1946" }
-
-  let(:example_http_uri_string)  { "http://example.com" }
-  let(:example_https_uri_string) { "https://example.com" }
-  let(:example_ipv6_uri_string) { "https://[#{example_ipv6_address}]" }
-
-  subject(:http_uri)  { described_class.parse(example_http_uri_string) }
-  subject(:https_uri) { described_class.parse(example_https_uri_string) }
-  subject(:ipv6_uri) { described_class.parse(example_ipv6_uri_string) }
-
-  it "knows URI schemes" do
-    expect(http_uri.scheme).to eq "http"
-    expect(https_uri.scheme).to eq "https"
-  end
-
-  it "sets default ports for HTTP URIs" do
-    expect(http_uri.port).to eq 80
-  end
-
-  it "sets default ports for HTTPS URIs" do
-    expect(https_uri.port).to eq 443
-  end
-
-  describe "#host" do
-    it "strips brackets from IPv6 addresses" do
-      expect(ipv6_uri.host).to eq("2606:2800:220:1:248:1893:25c8:1946")
-    end
-  end
-
-  describe "#normalized_host" do
-    it "strips brackets from IPv6 addresses" do
-      expect(ipv6_uri.normalized_host).to eq("2606:2800:220:1:248:1893:25c8:1946")
-    end
-  end
-
-  describe "#host=" do
-    it "updates cached values for #host and #normalized_host" do
-      expect(http_uri.host).to eq("example.com")
-      expect(http_uri.normalized_host).to eq("example.com")
-
-      http_uri.host = "[#{example_ipv6_address}]"
-
-      expect(http_uri.host).to eq(example_ipv6_address)
-      expect(http_uri.normalized_host).to eq(example_ipv6_address)
-    end
-
-    it "ensures IPv6 addresses are bracketed in the inner Addressable::URI" do
-      expect(http_uri.host).to eq("example.com")
-      expect(http_uri.normalized_host).to eq("example.com")
-
-      http_uri.host = example_ipv6_address
-
-      expect(http_uri.host).to eq(example_ipv6_address)
-      expect(http_uri.normalized_host).to eq(example_ipv6_address)
-      expect(http_uri.instance_variable_get(:@uri).host).to eq("[#{example_ipv6_address}]")
-    end
-  end
-
-  describe "#dup" do
-    it "doesn't share internal value between duplicates" do
-      duplicated_uri = http_uri.dup
-      duplicated_uri.host = "example.org"
-
-      expect(duplicated_uri.to_s).to eq("http://example.org")
-      expect(http_uri.to_s).to eq("http://example.com")
-    end
-  end
-end