[rubygems/rubygems] Use vendored net-http in Bundler

https://github.com/rubygems/rubygems/commit/0d758e8926

3 files changed, 33 insertions, 33 deletions

diff --git a/spec/bundler/bundler/compact_index_client/updater_spec.rb b/spec/bundler/bundler/compact_index_client/updater_spec.rb
index 1f11dffac9..51b838d2d2 100644
--- a/spec/bundler/bundler/compact_index_client/updater_spec.rb
+++ b/spec/bundler/bundler/compact_index_client/updater_spec.rb
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "net/http"
+require "bundler/vendored_net_http"
 require "bundler/compact_index_client"
 require "bundler/compact_index_client/updater"
 require "tmpdir"
@@ -64,8 +64,8 @@ RSpec.describe Bundler::CompactIndexClient::Updater do
 
       it "does nothing if etags match" do
         expect(fetcher).to receive(:call).once.with(remote_path, headers).and_return(response)
-        allow(response).to receive(:is_a?).with(Net::HTTPPartialContent) { false }
-        allow(response).to receive(:is_a?).with(Net::HTTPNotModified) { true }
+        allow(response).to receive(:is_a?).with(Gem::Net::HTTPPartialContent) { false }
+        allow(response).to receive(:is_a?).with(Gem::Net::HTTPNotModified) { true }
 
         updater.update(remote_path, local_path, etag_path)
 
@@ -77,8 +77,8 @@ RSpec.describe Bundler::CompactIndexClient::Updater do
         expect(fetcher).to receive(:call).once.with(remote_path, headers).and_return(response)
         allow(response).to receive(:[]).with("Repr-Digest") { "sha-256=:#{digest}:" }
         allow(response).to receive(:[]).with("ETag") { "NewEtag" }
-        allow(response).to receive(:is_a?).with(Net::HTTPPartialContent) { true }
-        allow(response).to receive(:is_a?).with(Net::HTTPNotModified) { false }
+        allow(response).to receive(:is_a?).with(Gem::Net::HTTPPartialContent) { true }
+        allow(response).to receive(:is_a?).with(Gem::Net::HTTPNotModified) { false }
         allow(response).to receive(:body) { "c123" }
 
         updater.update(remote_path, local_path, etag_path)
@@ -102,7 +102,7 @@ RSpec.describe Bundler::CompactIndexClient::Updater do
       it "tries the request again if the partial response fails digest check" do
         allow(response).to receive(:[]).with("Repr-Digest") { "sha-256=:baddigest:" }
         allow(response).to receive(:body) { "the beginning of the file changed" }
-        allow(response).to receive(:is_a?).with(Net::HTTPPartialContent) { true }
+        allow(response).to receive(:is_a?).with(Gem::Net::HTTPPartialContent) { true }
         expect(fetcher).to receive(:call).once.with(remote_path, headers).and_return(response)
 
         full_response = double(:full_response, body: full_body, is_a?: false)
@@ -129,8 +129,8 @@ RSpec.describe Bundler::CompactIndexClient::Updater do
 
       it "saves only the etag_path if generated etag matches" do
         expect(fetcher).to receive(:call).once.with(remote_path, headers).and_return(response)
-        allow(response).to receive(:is_a?).with(Net::HTTPPartialContent) { false }
-        allow(response).to receive(:is_a?).with(Net::HTTPNotModified) { true }
+        allow(response).to receive(:is_a?).with(Gem::Net::HTTPPartialContent) { false }
+        allow(response).to receive(:is_a?).with(Gem::Net::HTTPNotModified) { true }
 
         updater.update(remote_path, local_path, etag_path)
 
@@ -142,8 +142,8 @@ RSpec.describe Bundler::CompactIndexClient::Updater do
         expect(fetcher).to receive(:call).once.with(remote_path, headers).and_return(response)
         allow(response).to receive(:[]).with("Repr-Digest") { "sha-256=:#{digest}:" }
         allow(response).to receive(:[]).with("ETag") { "OpaqueEtag" }
-        allow(response).to receive(:is_a?).with(Net::HTTPPartialContent) { true }
-        allow(response).to receive(:is_a?).with(Net::HTTPNotModified) { false }
+        allow(response).to receive(:is_a?).with(Gem::Net::HTTPPartialContent) { true }
+        allow(response).to receive(:is_a?).with(Gem::Net::HTTPNotModified) { false }
         allow(response).to receive(:body) { "c123" }
 
         updater.update(remote_path, local_path, etag_path)
@@ -157,8 +157,8 @@ RSpec.describe Bundler::CompactIndexClient::Updater do
         allow(response).to receive(:[]).with("Repr-Digest") { nil }
         allow(response).to receive(:[]).with("Digest") { nil }
         allow(response).to receive(:[]).with("ETag") { "OpaqueEtag" }
-        allow(response).to receive(:is_a?).with(Net::HTTPPartialContent) { false }
-        allow(response).to receive(:is_a?).with(Net::HTTPNotModified) { false }
+        allow(response).to receive(:is_a?).with(Gem::Net::HTTPPartialContent) { false }
+        allow(response).to receive(:is_a?).with(Gem::Net::HTTPNotModified) { false }
         allow(response).to receive(:body) { full_body }
 
         updater.update(remote_path, local_path, etag_path)
@@ -170,7 +170,7 @@ RSpec.describe Bundler::CompactIndexClient::Updater do
       it "tries the request again if the partial response fails digest check" do
         allow(response).to receive(:[]).with("Repr-Digest") { "sha-256=:baddigest:" }
         allow(response).to receive(:body) { "the beginning of the file changed" }
-        allow(response).to receive(:is_a?).with(Net::HTTPPartialContent) { true }
+        allow(response).to receive(:is_a?).with(Gem::Net::HTTPPartialContent) { true }
         expect(fetcher).to receive(:call).once.with(remote_path, headers) do
           # During the failed first request, we simulate another process writing the etag.
           # This ensures the second request doesn't generate the md5 etag again but just uses whatever is written.
diff --git a/spec/bundler/bundler/fetcher/downloader_spec.rb b/spec/bundler/bundler/fetcher/downloader_spec.rb
index 22aa3a8b0c..88a8c174f1 100644
--- a/spec/bundler/bundler/fetcher/downloader_spec.rb
+++ b/spec/bundler/bundler/fetcher/downloader_spec.rb
@@ -27,7 +27,7 @@ RSpec.describe Bundler::Fetcher::Downloader do
     end
 
     context "logging" do
-      let(:http_response) { Net::HTTPSuccess.new("1.1", 200, "Success") }
+      let(:http_response) { Gem::Net::HTTPSuccess.new("1.1", 200, "Success") }
 
       it "should log the HTTP response code and message to debug" do
         expect(Bundler).to receive_message_chain(:ui, :debug).with("HTTP 200 Success #{uri}")
@@ -35,8 +35,8 @@ RSpec.describe Bundler::Fetcher::Downloader do
       end
     end
 
-    context "when the request response is a Net::HTTPRedirection" do
-      let(:http_response) { Net::HTTPRedirection.new(httpv, 308, "Moved") }
+    context "when the request response is a Gem::Net::HTTPRedirection" do
+      let(:http_response) { Gem::Net::HTTPRedirection.new(httpv, 308, "Moved") }
 
       before { http_response["location"] = "http://www.redirect-uri.com/api/v2/endpoint" }
 
@@ -59,24 +59,24 @@ RSpec.describe Bundler::Fetcher::Downloader do
       end
     end
 
-    context "when the request response is a Net::HTTPSuccess" do
-      let(:http_response) { Net::HTTPSuccess.new("1.1", 200, "Success") }
+    context "when the request response is a Gem::Net::HTTPSuccess" do
+      let(:http_response) { Gem::Net::HTTPSuccess.new("1.1", 200, "Success") }
 
       it "should return the response body" do
         expect(subject.fetch(uri, options, counter)).to eq(http_response)
       end
     end
 
-    context "when the request response is a Net::HTTPRequestEntityTooLarge" do
-      let(:http_response) { Net::HTTPRequestEntityTooLarge.new("1.1", 413, "Too Big") }
+    context "when the request response is a Gem::Net::HTTPRequestEntityTooLarge" do
+      let(:http_response) { Gem::Net::HTTPRequestEntityTooLarge.new("1.1", 413, "Too Big") }
 
       it "should raise a Bundler::Fetcher::FallbackError with the response body" do
         expect { subject.fetch(uri, options, counter) }.to raise_error(Bundler::Fetcher::FallbackError, "Body with info")
       end
     end
 
-    context "when the request response is a Net::HTTPUnauthorized" do
-      let(:http_response) { Net::HTTPUnauthorized.new("1.1", 401, "Unauthorized") }
+    context "when the request response is a Gem::Net::HTTPUnauthorized" do
+      let(:http_response) { Gem::Net::HTTPUnauthorized.new("1.1", 401, "Unauthorized") }
 
       it "should raise a Bundler::Fetcher::AuthenticationRequiredError with the uri host" do
         expect { subject.fetch(uri, options, counter) }.to raise_error(Bundler::Fetcher::AuthenticationRequiredError,
@@ -98,8 +98,8 @@ RSpec.describe Bundler::Fetcher::Downloader do
       end
     end
 
-    context "when the request response is a Net::HTTPForbidden" do
-      let(:http_response) { Net::HTTPForbidden.new("1.1", 403, "Forbidden") }
+    context "when the request response is a Gem::Net::HTTPForbidden" do
+      let(:http_response) { Gem::Net::HTTPForbidden.new("1.1", 403, "Forbidden") }
       let(:uri) { Bundler::URI("http://user:password@www.uri-to-fetch.com") }
 
       it "should raise a Bundler::Fetcher::AuthenticationForbiddenError with the uri host" do
@@ -108,12 +108,12 @@ RSpec.describe Bundler::Fetcher::Downloader do
       end
     end
 
-    context "when the request response is a Net::HTTPNotFound" do
-      let(:http_response) { Net::HTTPNotFound.new("1.1", 404, "Not Found") }
+    context "when the request response is a Gem::Net::HTTPNotFound" do
+      let(:http_response) { Gem::Net::HTTPNotFound.new("1.1", 404, "Not Found") }
 
-      it "should raise a Bundler::Fetcher::FallbackError with Net::HTTPNotFound" do
+      it "should raise a Bundler::Fetcher::FallbackError with Gem::Net::HTTPNotFound" do
         expect { subject.fetch(uri, options, counter) }.
-          to raise_error(Bundler::Fetcher::FallbackError, "Net::HTTPNotFound: http://www.uri-to-fetch.com/api/v2/endpoint")
+          to raise_error(Bundler::Fetcher::FallbackError, "Gem::Net::HTTPNotFound: http://www.uri-to-fetch.com/api/v2/endpoint")
       end
 
       context "when the there are credentials provided in the request" do
@@ -121,16 +121,16 @@ RSpec.describe Bundler::Fetcher::Downloader do
 
         it "should raise a Bundler::Fetcher::FallbackError that doesn't contain the password" do
           expect { subject.fetch(uri, options, counter) }.
-            to raise_error(Bundler::Fetcher::FallbackError, "Net::HTTPNotFound: http://username@www.uri-to-fetch.com/api/v2/endpoint")
+            to raise_error(Bundler::Fetcher::FallbackError, "Gem::Net::HTTPNotFound: http://username@www.uri-to-fetch.com/api/v2/endpoint")
         end
       end
     end
 
     context "when the request response is some other type" do
-      let(:http_response) { Net::HTTPBadGateway.new("1.1", 500, "Fatal Error") }
+      let(:http_response) { Gem::Net::HTTPBadGateway.new("1.1", 500, "Fatal Error") }
 
       it "should raise a Bundler::HTTPError with the response class and body" do
-        expect { subject.fetch(uri, options, counter) }.to raise_error(Bundler::HTTPError, "Net::HTTPBadGateway: Body with info")
+        expect { subject.fetch(uri, options, counter) }.to raise_error(Bundler::HTTPError, "Gem::Net::HTTPBadGateway: Body with info")
       end
     end
   end
@@ -140,7 +140,7 @@ RSpec.describe Bundler::Fetcher::Downloader do
     let(:response)     { double(:response) }
 
     before do
-      allow(Net::HTTP::Get).to receive(:new).with("/api/v2/endpoint", options).and_return(net_http_get)
+      allow(Gem::Net::HTTP::Get).to receive(:new).with("/api/v2/endpoint", options).and_return(net_http_get)
       allow(connection).to receive(:request).with(uri, net_http_get).and_return(response)
     end
 
diff --git a/spec/bundler/bundler/fetcher_spec.rb b/spec/bundler/bundler/fetcher_spec.rb
index 53d201d31d..5a2c568693 100644
--- a/spec/bundler/bundler/fetcher_spec.rb
+++ b/spec/bundler/bundler/fetcher_spec.rb
@@ -167,7 +167,7 @@ RSpec.describe Bundler::Fetcher do
     let(:version) { "1.3.17" }
     let(:platform) { "platform" }
     let(:downloader) { double("downloader") }
-    let(:body) { double(Net::HTTP::Get, body: downloaded_data) }
+    let(:body) { double(Gem::Net::HTTP::Get, body: downloaded_data) }
 
     context "when attempting to load a Gem::Specification" do
       let(:spec) { Gem::Specification.new(name, version) }