http.rb 0.21.0 → 0.22.0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: http.rb
 version: !ruby/object:Gem::Version
-  version: 0.21.0
+  version: 0.22.0
 platform: ruby
 authors:
 - thoran
@@ -10,7 +10,21 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-mock
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -24,7 +38,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -38,7 +52,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -94,16 +108,16 @@ files:
 - lib/Thoran/Array/FirstX/firstX.rb
 - lib/Thoran/String/ToConst/to_const.rb
 - lib/URI/Generic/use_sslQ.rb
-- spec/HTTP/RETRY_spec.rb
-- spec/HTTP/delete_spec.rb
-- spec/HTTP/get_spec.rb
-- spec/HTTP/head_spec.rb
-- spec/HTTP/options_spec.rb
-- spec/HTTP/patch_spec.rb
-- spec/HTTP/post_spec.rb
-- spec/HTTP/put_spec.rb
-- spec/HTTP/trace_spec.rb
-- spec/spec_helper.rb
+- test/HTTP/RETRY_test.rb
+- test/HTTP/delete_test.rb
+- test/HTTP/get_test.rb
+- test/HTTP/head_test.rb
+- test/HTTP/options_test.rb
+- test/HTTP/patch_test.rb
+- test/HTTP/post_test.rb
+- test/HTTP/put_test.rb
+- test/HTTP/trace_test.rb
+- test/helper.rb
 homepage: http://github.com/thoran/HTTP
 licenses:
 - MIT

data/spec/HTTP/RETRY_spec.rb

@@ -1,251 +0,0 @@
-# spec/HTTP/RETRY_spec.rb
-
-require_relative '../spec_helper'
-require 'http'
-
-describe "retry behaviour" do
-  let(:uri){'http://example.com/path'}
-
-  before do
-    allow(HTTP::RETRY).to receive(:sleep)
-  end
-
-  describe "defaults" do
-    it "does not retry by default" do
-      stub_request(:get, uri).to_return(status: 503)
-      response = HTTP.get(uri)
-      expect(response.code.to_i).to eq(503)
-      expect(WebMock).to have_requested(:get, uri).times(1)
-    end
-
-    it "does not retry on a transient exception by default" do
-      stub_request(:get, uri).to_raise(Errno::ECONNRESET)
-      expect{HTTP.get(uri)}.to raise_error(Errno::ECONNRESET)
-      expect(WebMock).to have_requested(:get, uri).times(1)
-    end
-  end
-
-  describe "retry on transient exception" do
-    it "retries and succeeds when the failure is transient" do
-      stub_request(:get, uri).
-        to_raise(Errno::ECONNRESET).then.
-        to_raise(Errno::ECONNRESET).then.
-        to_return(status: 200, body: '')
-      response = HTTP.get(uri, {}, {}, {retries: 3})
-      expect(response.success?).to eq(true)
-      expect(WebMock).to have_requested(:get, uri).times(3)
-    end
-
-    it "re-raises the exception after retries are exhausted" do
-      stub_request(:get, uri).to_raise(Errno::ECONNRESET)
-      expect{HTTP.get(uri, {}, {}, {retries: 2})}.to raise_error(Errno::ECONNRESET)
-      expect(WebMock).to have_requested(:get, uri).times(3)
-    end
-
-    it "retries on SocketError (DNS failure)" do
-      stub_request(:get, uri).
-        to_raise(SocketError).then.
-        to_return(status: 200, body: '')
-      response = HTTP.get(uri, {}, {}, {retries: 3})
-      expect(response.success?).to eq(true)
-      expect(WebMock).to have_requested(:get, uri).times(2)
-    end
-
-    it "does not retry on a non-listed exception" do
-      stub_request(:get, uri).to_raise(OpenSSL::SSL::SSLError)
-      expect{HTTP.get(uri, {}, {}, {retries: 3})}.to raise_error(OpenSSL::SSL::SSLError)
-      expect(WebMock).to have_requested(:get, uri).times(1)
-    end
-  end
-
-  describe "retry on status code" do
-    it "retries on 503 then succeeds" do
-      stub_request(:get, uri).
-        to_return({status: 503}, {status: 503}, {status: 200, body: ''})
-      response = HTTP.get(uri, {}, {}, {retries: 3})
-      expect(response.success?).to eq(true)
-      expect(WebMock).to have_requested(:get, uri).times(3)
-    end
-
-    it "retries on 502" do
-      stub_request(:get, uri).to_return({status: 502}, {status: 200, body: ''})
-      response = HTTP.get(uri, {}, {}, {retries: 3})
-      expect(response.success?).to eq(true)
-      expect(WebMock).to have_requested(:get, uri).times(2)
-    end
-
-    it "retries on 504" do
-      stub_request(:get, uri).to_return({status: 504}, {status: 200, body: ''})
-      response = HTTP.get(uri, {}, {}, {retries: 3})
-      expect(response.success?).to eq(true)
-      expect(WebMock).to have_requested(:get, uri).times(2)
-    end
-
-    it "does not retry on 500 by default" do
-      stub_request(:get, uri).to_return(status: 500)
-      response = HTTP.get(uri, {}, {}, {retries: 3})
-      expect(response.code.to_i).to eq(500)
-      expect(WebMock).to have_requested(:get, uri).times(1)
-    end
-
-    it "does not retry on 404" do
-      stub_request(:get, uri).to_return(status: 404)
-      response = HTTP.get(uri, {}, {}, {retries: 3})
-      expect(response.code.to_i).to eq(404)
-      expect(WebMock).to have_requested(:get, uri).times(1)
-    end
-
-    it "returns the last response when retries are exhausted" do
-      stub_request(:get, uri).to_return(status: 503)
-      response = HTTP.get(uri, {}, {}, {retries: 2})
-      expect(response.code.to_i).to eq(503)
-      expect(WebMock).to have_requested(:get, uri).times(3)
-    end
-  end
-
-  describe "Retry-After header" do
-    it "honours integer Retry-After on 429" do
-      stub_request(:get, uri).
-        to_return({status: 429, headers: {'Retry-After' => '2'}}, {status: 200, body: ''})
-      expect(HTTP::RETRY).to receive(:sleep).with(2)
-      response = HTTP.get(uri, {}, {}, {retries: 3})
-      expect(response.success?).to eq(true)
-    end
-
-    it "honours integer Retry-After on 503" do
-      stub_request(:get, uri).
-        to_return({status: 503, headers: {'Retry-After' => '5'}}, {status: 200, body: ''})
-      expect(HTTP::RETRY).to receive(:sleep).with(5)
-      response = HTTP.get(uri, {}, {}, {retries: 3})
-      expect(response.success?).to eq(true)
-    end
-  end
-
-  describe "configuration" do
-    it "treats retries: 0 as no retries" do
-      stub_request(:get, uri).to_return(status: 503)
-      response = HTTP.get(uri, {}, {}, {retries: 0})
-      expect(response.code.to_i).to eq(503)
-      expect(WebMock).to have_requested(:get, uri).times(1)
-    end
-
-    it "respects a custom retry_status_codes list" do
-      stub_request(:get, uri).to_return({status: 500}, {status: 200, body: ''})
-      response = HTTP.get(uri, {}, {}, {retries: 3, retry_status_codes: [500]})
-      expect(response.success?).to eq(true)
-      expect(WebMock).to have_requested(:get, uri).times(2)
-    end
-
-    it "respects a custom retry_exceptions list" do
-      stub_request(:get, uri).
-        to_raise(OpenSSL::SSL::SSLError).then.
-        to_return(status: 200, body: '')
-      response = HTTP.get(uri, {}, {}, {retries: 3, retry_exceptions: [OpenSSL::SSL::SSLError]})
-      expect(response.success?).to eq(true)
-      expect(WebMock).to have_requested(:get, uri).times(2)
-    end
-
-    it "does not pass retry options through to Net::HTTP" do
-      stub_request(:get, uri).to_return(status: 200, body: '')
-      net_http_object = Net::HTTP.new(URI.parse(uri).host, URI.parse(uri).port)
-      allow(Net::HTTP).to receive(:new).and_return(net_http_object)
-      expect(net_http_object).to receive(:options=) do |opts|
-        expect(opts).not_to include(:retries, :retry_delay, :retry_status_codes, :retry_exceptions, :retry_verbs)
-      end
-      HTTP.get(uri, {}, {}, {
-        retries: 3,
-        retry_delay: 0.1,
-        retry_status_codes: [500],
-        retry_exceptions: [Errno::ECONNRESET],
-        retry_verbs: %i{get}
-      })
-    end
-  end
-
-  describe "backoff timing" do
-    it "increases the delay between successive retries" do
-      delays = []
-      allow(HTTP::RETRY).to receive(:sleep){|d| delays << d}
-      stub_request(:get, uri).to_return(status: 503)
-      HTTP.get(uri, {}, {}, {retries: 3, retry_delay: 1.0})
-      expect(delays.length).to eq(3)
-      expect(delays[1]).to be > delays[0] * 0.8
-      expect(delays[2]).to be > delays[1] * 0.8
-    end
-  end
-
-  describe "verb-based retry default" do
-    it "does not retry POST by default even when retries are enabled" do
-      stub_request(:post, uri).to_return(status: 503)
-      HTTP.post(uri, {}, {}, {retries: 3})
-      expect(WebMock).to have_requested(:post, uri).times(1)
-    end
-
-    it "does not retry PATCH by default" do
-      stub_request(:patch, uri).to_return(status: 503)
-      HTTP.patch(uri, {}, {}, {retries: 3})
-      expect(WebMock).to have_requested(:patch, uri).times(1)
-    end
-
-    it "retries PUT by default (idempotent)" do
-      stub_request(:put, uri).to_return({status: 503}, {status: 200, body: ''})
-      response = HTTP.put(uri, {}, {}, {retries: 3})
-      expect(response.success?).to eq(true)
-      expect(WebMock).to have_requested(:put, uri).times(2)
-    end
-
-    it "retries DELETE by default (idempotent)" do
-      stub_request(:delete, uri).to_return({status: 503}, {status: 200, body: ''})
-      response = HTTP.delete(uri, {}, {}, {retries: 3})
-      expect(response.success?).to eq(true)
-      expect(WebMock).to have_requested(:delete, uri).times(2)
-    end
-
-    it "retries POST when opted in via retry_verbs" do
-      stub_request(:post, uri).to_return({status: 503}, {status: 200, body: ''})
-      response = HTTP.post(uri, {}, {}, {retries: 3, retry_verbs: %i{get post}})
-      expect(response.success?).to eq(true)
-      expect(WebMock).to have_requested(:post, uri).times(2)
-    end
-  end
-end
-
-describe HTTP, ".retry_after" do
-  it "returns integer seconds for a delta-seconds Retry-After header" do
-    response = instance_double(Net::HTTPResponse)
-    allow(response).to receive(:[]).with('Retry-After').and_return('5')
-    expect(HTTP.retry_after(response)).to eq(5)
-  end
-
-  it "parses an HTTP-date Retry-After header" do
-    base = Time.utc(2026, 5, 22, 12, 0, 0)
-    retry_at_header = (base + 5).httpdate
-    response = instance_double(Net::HTTPResponse)
-    allow(response).to receive(:[]).with('Retry-After').and_return(retry_at_header)
-    allow(Time).to receive(:now).and_return(base)
-    expect(HTTP.retry_after(response)).to be_within(0.001).of(5.0)
-  end
-
-  it "returns nil when Retry-After is absent" do
-    response = instance_double(Net::HTTPResponse)
-    allow(response).to receive(:[]).with('Retry-After').and_return(nil)
-    expect(HTTP.retry_after(response)).to be_nil
-  end
-
-  it "returns nil when Retry-After is malformed" do
-    response = instance_double(Net::HTTPResponse)
-    allow(response).to receive(:[]).with('Retry-After').and_return('not a date')
-    expect(HTTP.retry_after(response)).to be_nil
-  end
-end
-
-describe HTTP, ".backoff_delay" do
-  it "grows exponentially with attempt number" do
-    base = 1.0
-    delays = (1..4).map{|attempt| HTTP.backoff_delay(base, attempt)}
-    expect(delays[0]).to be_within(0.2).of(1.0)
-    expect(delays[1]).to be_within(0.4).of(2.0)
-    expect(delays[2]).to be_within(0.8).of(4.0)
-    expect(delays[3]).to be_within(1.6).of(8.0)
-  end
-end

data/spec/HTTP/delete_spec.rb

@@ -1,268 +0,0 @@
-# spec/HTTP/delete_spec.rb
-
-require_relative '../spec_helper'
-require 'http'
-
-describe ".delete" do
-  context "with uri-only supplied" do
-    before do
-      stub_request(:delete, 'http://example.com/path').
-        with(headers: {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
-          to_return(status: 200, body: '', headers: {})
-    end
-
-    context "uri as a string" do
-      let(:uri){'http://example.com/path'}
-      let(:parsed_uri){URI.parse(uri)}
-      let(:net_http_object){Net::HTTP.new(parsed_uri.host, parsed_uri.port)}
-
-      it "creates an instance of URI" do
-        expect(URI).to receive(:parse).with(uri).and_return(parsed_uri)
-        response = HTTP.delete(uri)
-        expect(response.success?).to eq(true)
-      end
-
-      it "creates a new Net::HTTP object" do
-        expect(Net::HTTP).to receive(:new).with(parsed_uri.host, parsed_uri.port).and_return(net_http_object)
-        response = HTTP.delete(uri)
-        expect(response.success?).to eq(true)
-      end
-    end
-
-    context "uri as a URI" do
-      let(:uri_string){'http://example.com/path'}
-      let(:uri){URI.parse(uri_string)}
-      let(:net_http_object){Net::HTTP.new(uri.host, uri.port)}
-
-      it "returns an instance of URI" do
-        expect(uri).to eq(uri)
-        HTTP.delete(uri)
-      end
-
-      it "creates a new Net::HTTP object" do
-        expect(Net::HTTP).to receive(:new).with(uri.host, uri.port).and_return(net_http_object)
-        response = HTTP.delete(uri)
-        expect(response.success?).to eq(true)
-      end
-    end
-  end
-
-  context "with args supplied" do
-    let(:uri){'http://example.com/path'}
-    let(:parsed_uri){URI.parse(uri)}
-    let(:args) do; {a: 1, b: 2}; end
-    let(:x_www_form_urlencoded_arguments) do; args.x_www_form_urlencode; end
-    let(:get_argument){parsed_uri.request_uri + '?' + x_www_form_urlencoded_arguments}
-    let(:request_object){Net::HTTP::Delete.new(get_argument)}
-
-    before do
-      stub_request(:delete, 'http://example.com/path?a=1&b=2').
-        with(headers: {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
-          to_return(status: 200, body: '', headers: {})
-    end
-
-    it "x_www_form_urlencode's the args" do
-      expect(args).to receive(:x_www_form_urlencode).and_return(x_www_form_urlencoded_arguments)
-      response = HTTP.delete(uri, args)
-      expect(response.success?).to eq(true)
-    end
-
-    it "creates a new Net::HTTP::Delete object" do
-      expect(Net::HTTP::Delete).to receive(:new).with(get_argument).and_return(request_object)
-      response = HTTP.delete(uri, args)
-      expect(response.success?).to eq(true)
-    end
-  end
-
-  context "with headers supplied" do
-    let(:uri){'http://example.com/path'}
-    let(:parsed_uri){URI.parse(uri)}
-    let(:headers) do; {'User-Agent' => 'Rspec'}; end
-    let(:get_argument){parsed_uri.request_uri}
-    let(:request_object){Net::HTTP::Delete.new(get_argument)}
-
-    before do
-      stub_request(:delete, 'http://example.com/path').
-        with(headers: {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Rspec'}).
-          to_return(status: 200, body: '', headers: {})
-    end
-
-    it "sets the headers on the request object" do
-      allow(Net::HTTP::Delete).to receive(:new).with(get_argument).and_return(request_object)
-      response = HTTP.delete(uri, {}, headers)
-      expect(request_object['User-Agent']).to eq('Rspec')
-      expect(response.success?).to eq(true)
-    end
-  end
-
-  context "with options supplied" do
-    let(:uri){'http://example.com/path'}
-    let(:parsed_uri){URI.parse(uri)}
-    let(:net_http_object){Net::HTTP.new(parsed_uri.host, parsed_uri.port)}
-    let(:options) do; {use_ssl: true}; end
-
-    before do
-      stub_request(:delete, 'https://example.com:80/path').
-        with(headers: {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
-          to_return(status: 200, body: '', headers: {})
-    end
-
-    it "sets the use_ssl option on the Net::HTTP instance" do
-      allow(Net::HTTP).to receive(:new).with(parsed_uri.host, parsed_uri.port).and_return(net_http_object)
-      response = HTTP.delete(uri, {}, {}, options)
-      expect(net_http_object.instance_variable_get(:@use_ssl)).to be_truthy
-      expect(response.success?).to eq(true)
-    end
-  end
-
-  context "with block supplied" do
-    let(:uri){'http://example.com/path'}
-
-    before do
-      stub_request(:delete, 'http://example.com/path').
-        with(headers: {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
-          to_return(status: 200, body: '', headers: {})
-    end
-
-    it "yields an instance of Net::HTTPResponse" do
-      expect{|b| HTTP.delete(uri, &b)}.to yield_with_args(Net::HTTPResponse)
-    end
-  end
-
-  context "with redirection" do
-    let(:request_uri){'http://example.com/path'}
-    let(:redirect_uri){'http://redirected.com'}
-
-    before do
-      stub_request(:get, redirect_uri).
-        with(headers: {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
-          to_return(status: 200, body: '', headers: {})
-    end
-
-    context "via 301" do
-      before do
-        stub_request(:delete, request_uri).
-          with(headers: {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
-            to_return(status: 301, body: '', headers: {'location' => redirect_uri})
-      end
-
-      it "does a redirect" do
-        expect(HTTP).to receive(:delete).once.with(request_uri).and_call_original
-        expect(HTTP).to receive(:get).once.with(redirect_uri, {}, {}, {use_ssl: false, verify_mode: OpenSSL::SSL::VERIFY_PEER}).and_call_original
-        response = HTTP.delete(request_uri)
-        expect(response.success?).to eq(true)
-      end
-    end
-
-    context "via 302" do
-      before do
-        stub_request(:delete, request_uri).
-          with(headers: {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
-            to_return(status: 302, body: '', headers: {'location' => redirect_uri})
-      end
-
-      it "does a redirect" do
-        expect(HTTP).to receive(:delete).once.with(request_uri).and_call_original
-        expect(HTTP).to receive(:get).once.with(redirect_uri, {}, {}, {use_ssl: false, verify_mode: OpenSSL::SSL::VERIFY_PEER}).and_call_original
-        response = HTTP.delete(request_uri)
-        expect(response.success?).to eq(true)
-      end
-    end
-  end
-
-  context "with path only redirection" do
-    let(:request_uri){'http://example.com/path'}
-    let(:redirect_path){'/new_path'}
-    let(:redirect_uri){"http://example.com#{redirect_path}"}
-
-    before do
-      stub_request(:get, redirect_uri).
-        with(headers: {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
-          to_return(status: 200, body: '', headers: {})
-    end
-
-    context "via 301" do
-      before do
-        stub_request(:delete, request_uri).
-          with(headers: {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
-            to_return(status: 301, body: '', headers: {'location' => redirect_path})
-      end
-
-      it "does a redirect" do
-        expect(HTTP).to receive(:delete).once.with(request_uri).and_call_original
-        expect(HTTP).to receive(:get).once.with(redirect_uri, {}, {}, {use_ssl: false, verify_mode: OpenSSL::SSL::VERIFY_PEER}).and_call_original
-        response = HTTP.delete(request_uri)
-        expect(response.success?).to eq(true)
-      end
-    end
-
-    context "via 302" do
-      before do
-        stub_request(:delete, request_uri).
-          with(headers: {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
-            to_return(status: 302, body: '', headers: {'location' => redirect_path})
-      end
-
-      it "does a redirect" do
-        expect(HTTP).to receive(:delete).once.with(request_uri).and_call_original
-        expect(HTTP).to receive(:get).once.with(redirect_uri, {}, {}, {use_ssl: false, verify_mode: OpenSSL::SSL::VERIFY_PEER}).and_call_original
-        response = HTTP.delete(request_uri)
-        expect(response.success?).to eq(true)
-      end
-    end
-  end
-
-  context "with verb-preserving redirection via 307" do
-    let(:request_uri){'http://example.com/path'}
-    let(:redirect_uri){'http://redirected.com'}
-
-    before do
-      stub_request(:delete, request_uri).
-        with(headers: {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
-          to_return(status: 307, body: '', headers: {'location' => redirect_uri})
-      stub_request(:delete, redirect_uri).
-        with(headers: {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
-          to_return(status: 200, body: '', headers: {})
-    end
-
-    it "preserves the verb" do
-      expect(HTTP).to receive(:delete).with(request_uri).and_call_original.ordered
-      expect(HTTP).to receive(:delete).with(redirect_uri, {}, {}, {use_ssl: false, verify_mode: OpenSSL::SSL::VERIFY_PEER}).and_call_original.ordered
-      response = HTTP.delete(request_uri)
-      expect(response.success?).to eq(true)
-    end
-  end
-
-  context "no_redirect true" do
-    let(:request_uri){'http://example.com/path'}
-    let(:redirect_uri){'http://redirected.com'}
-
-    context "via 301" do
-      before do
-        stub_request(:delete, request_uri).
-          with(headers: {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
-            to_return(status: 301, body: '', headers: {'location' => redirect_uri})
-      end
-
-      it "doesn't redirect" do
-        expect(HTTP).to receive(:delete).once.with(request_uri, {}, {}, {no_redirect: true}).and_call_original
-        response = HTTP.delete(request_uri, {}, {}, {no_redirect: true})
-        expect(response.redirection?).to eq(true)
-      end
-    end
-
-    context "via 302" do
-      before do
-        stub_request(:delete, request_uri).
-          with(headers: {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
-            to_return(status: 302, body: '', headers: {'location' => redirect_uri})
-      end
-
-      it "doesn't redirect" do
-        expect(HTTP).to receive(:delete).once.with(request_uri, {}, {}, {no_redirect: true}).and_call_original
-        response = HTTP.delete(request_uri, {}, {}, {no_redirect: true})
-        expect(response.redirection?).to eq(true)
-      end
-    end
-  end
-end