webmock 3.5.0 → 3.25.0

data/spec/acceptance/shared/allowing_and_disabling_net_connect.rb

@@ -1,313 +0,0 @@
-shared_context "allowing and disabling net connect" do |*adapter_info|
-  describe "when net connect" do
-    describe "is allowed", net_connect: true do
-      before(:each) do
-        WebMock.allow_net_connect!
-      end
-
-      it "should make a real web request if request is not stubbed" do
-        expect(http_request(:get, webmock_server_url).status).to eq("200")
-      end
-
-      it "should make a real https request if request is not stubbed" do
-        unless http_library == :httpclient
-          result = http_request(:get, "https://www.google.com/").body
-          if result.respond_to? :encode
-            result = result.encode(
-              'UTF-8',
-              'binary',
-              invalid: :replace,
-              undef: :replace,
-              replace: ''
-            )
-          end
-          expect(result).to match(/.*google.*/)
-        end
-      end
-
-      it "should return stubbed response if request was stubbed" do
-        stub_request(:get, "www.example.com").to_return(body: "abc")
-        expect(http_request(:get, "http://www.example.com/").body).to eq("abc")
-      end
-    end
-
-    describe "is not allowed" do
-      before(:each) do
-        WebMock.disable_net_connect!
-      end
-
-      it "should return stubbed response if request was stubbed" do
-        stub_request(:get, "www.example.com").to_return(body: "abc")
-        expect(http_request(:get, "http://www.example.com/").body).to eq("abc")
-      end
-
-      it "should return stubbed response if request with path was stubbed" do
-        stub_request(:get, "www.example.com/hello_world").to_return(body: "abc")
-        expect(http_request(:get, "http://www.example.com/hello_world").body).to eq("abc")
-      end
-
-      it "should raise exception if request was not stubbed" do
-        expect {
-          http_request(:get, "http://www.example.com/")
-        }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/))
-      end
-    end
-
-    describe "is not allowed with exception for localhost" do
-      before(:each) do
-        WebMock.disable_net_connect!(allow_localhost: true)
-      end
-
-      it "should return stubbed response if request was stubbed" do
-        stub_request(:get, "www.example.com").to_return(body: "abc")
-        expect(http_request(:get, "http://www.example.com/").body).to eq("abc")
-      end
-
-      it "should raise exception if request was not stubbed" do
-        expect {
-          http_request(:get, "http://www.example.com/")
-        }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/))
-      end
-
-      it "should make a real request to localhost" do
-        expect {
-          http_request(:get, "http://localhost:12345/")
-        }.to raise_error(connection_refused_exception_class)
-      end
-
-      it "should make a real request to 127.0.0.1" do
-        expect {
-          http_request(:get, "http://127.0.0.1:12345/")
-        }.to raise_error(connection_refused_exception_class)
-      end
-
-      it "should make a real request to 0.0.0.0" do
-        expect {
-          http_request(:get, "http://0.0.0.0:12345/")
-        }.to raise_error(connection_refused_exception_class)
-      end
-    end
-
-    describe "is not allowed, with exceptions" do
-      describe "allowing by host string" do
-        before :each do
-          WebMock.disable_net_connect!(allow: 'httpstat.us')
-        end
-
-        context "when the host is not allowed" do
-          it "should return stubbed response if request was stubbed" do
-            stub_request(:get, 'disallowed.example.com/foo').to_return(body: "abc")
-            expect(http_request(:get, 'http://disallowed.example.com/foo').body).to eq("abc")
-          end
-
-          it "should raise exception if request was not stubbed" do
-            expect {
-              http_request(:get, 'http://disallowed.example.com/')
-            }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://disallowed.example.com))
-          end
-        end
-
-        context "when the host is allowed" do
-          it "should return stubbed response if request was stubbed" do
-            stub_request(:get, 'httpstat.us/200').to_return(body: "abc")
-            expect(http_request(:get, "http://httpstat.us/200").body).to eq("abc")
-          end
-
-          # WARNING: this makes a real HTTP request!
-          it "should make a real request to allowed host", net_connect: true do
-            expect(http_request(:get, "http://httpstat.us/200").status).to eq('200')
-          end
-        end
-      end
-
-      describe "allowing by host:port string" do
-        def replace_with_different_port(uri)
-          uri.sub(%r{:(\d+)}){|m0, m1| ':' + ($~[1].to_i + 1).to_s }
-        end
-
-        let(:allowed_host_with_port) { WebMockServer.instance.host_with_port }
-        let(:disallowed_host_with_port) { replace_with_different_port(allowed_host_with_port) }
-
-        before :each do
-          WebMock.disable_net_connect!(allow: allowed_host_with_port)
-        end
-
-        context "when the host is not allowed" do
-          it "should return stubbed response if request was stubbed" do
-            request_url = "http://#{disallowed_host_with_port}/foo"
-            stub_request(:get, request_url).to_return(body: "abc")
-            expect(http_request(:get, request_url).body).to eq("abc")
-          end
-
-          it "should raise exception if request was not stubbed" do
-            request_url = "http://#{disallowed_host_with_port}/foo"
-            expect {
-              http_request(:get, request_url)
-            }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET #{request_url}))
-          end
-        end
-
-        context "when the host is allowed" do
-          it "should return stubbed response if request was stubbed" do
-            request_url = "http://#{allowed_host_with_port}/foo"
-            stub_request(:get, request_url).to_return(body: "abc")
-            expect(http_request(:get, request_url).body).to eq('abc')
-          end
-
-          it "should make a real request to allowed host", net_connect: true do
-            request_url = "http://#{allowed_host_with_port}/foo"
-            expect(http_request(:get, request_url).status).to eq('200')
-          end
-        end
-      end
-
-      describe "allowing by scheme:host string" do
-        before :each do
-          WebMock.disable_net_connect!(allow: 'https://www.google.pl')
-        end
-
-        context "when the host and scheme is not allowed" do
-          it "should return stubbed response if request was stubbed" do
-            stub_request(:get, 'https://disallowed.example.com/foo').to_return(body: "abc")
-            expect(http_request(:get, 'https://disallowed.example.com/foo').body).to eq("abc")
-          end
-
-          it "should raise exception if request was not stubbed" do
-            expect {
-              http_request(:get, 'https://disallowed.example.com/')
-            }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET https://disallowed.example.com))
-          end
-
-          it "should raise exception if request was made to different port" do
-            expect {
-              http_request(:get, 'https://www.google.pl:80/')
-            }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET https://www.google.pl:80))
-          end
-
-          it "should raise exception if request was made to different scheme" do
-            expect {
-              http_request(:get, 'http://www.google.pl/')
-            }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.google.pl))
-          end
-        end
-
-        context "when the host is allowed" do
-          it "should return stubbed response if request was stubbed" do
-            stub_request(:get, 'https://www.google.pl').to_return(body: "abc")
-            expect(http_request(:get, "https://www.google.pl/").body).to eq("abc")
-          end
-
-          it "should make a real request to allowed host with scheme", net_connect: true do
-            method = http_library == :httpclient ? :head : :get #https://github.com/nahi/httpclient/issues/299
-            expect(http_request(method, "https://www.google.pl/").status).to eq('200')
-          end
-
-          it "should make a real request to allowed host with scheme and port", net_connect: true do
-            method = http_library == :httpclient ? :head : :get
-            expect(http_request(method, "https://www.google.pl:443/").status).to eq('200')
-          end
-        end
-      end
-
-      describe "allowing by regular expression" do
-        before :each do
-          WebMock.disable_net_connect!(allow: %r{httpstat})
-        end
-
-        context "when the host is not allowed" do
-          it "should return stubbed response if request was stubbed" do
-            stub_request(:get, 'disallowed.example.com/foo').to_return(body: "abc")
-            expect(http_request(:get, 'http://disallowed.example.com/foo').body).to eq("abc")
-          end
-
-          it "should raise exception if request was not stubbed" do
-            expect {
-              http_request(:get, 'http://disallowed.example.com/')
-            }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://disallowed.example.com))
-          end
-        end
-
-        context "when the host is allowed" do
-          it "should return stubbed response if request was stubbed" do
-            stub_request(:get, 'httpstat.us/200').to_return(body: "abc")
-            expect(http_request(:get, "http://httpstat.us/200").body).to eq("abc")
-          end
-
-          # WARNING: this makes a real HTTP request!
-          it "should make a real request to allowed host", net_connect: true do
-            expect(http_request(:get, "http://httpstat.us/200").status).to eq('200')
-          end
-
-          it "should make a real request if request is allowed by path regexp and url contains default port", net_connect: true do
-            WebMock.disable_net_connect!(allow: %r{www.google.pl/webhp})
-            method = http_library == :httpclient ? :head : :get
-            expect(http_request(method, 'https://www.google.pl:443/webhp').status).to eq('200')
-          end
-        end
-      end
-
-      describe "allowing by a callable" do
-        before :each do
-          WebMock.disable_net_connect!(allow: lambda{|url| url.to_str.include?('httpstat') })
-        end
-
-        context "when the host is not allowed" do
-          it "should return stubbed response if request was stubbed" do
-            stub_request(:get, 'disallowed.example.com/foo').to_return(body: "abc")
-            expect(http_request(:get, 'http://disallowed.example.com/foo').body).to eq("abc")
-          end
-
-          it "should raise exception if request was not stubbed" do
-            expect {
-              http_request(:get, 'http://disallowed.example.com/')
-            }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://disallowed.example.com))
-          end
-        end
-
-        context "when the host is allowed" do
-          it "should return stubbed response if request was stubbed" do
-            stub_request(:get, 'httpstat.us/200').to_return(body: "abc")
-            expect(http_request(:get, "http://httpstat.us/200").body).to eq("abc")
-          end
-
-          # WARNING: this makes a real HTTP request!
-          it "should make a real request to allowed host", net_connect: true do
-            expect(http_request(:get, "http://httpstat.us/200").status).to eq('200')
-          end
-        end
-      end
-
-      describe "allowing by a list of the above" do
-        before :each do
-          WebMock.disable_net_connect!(allow: [lambda{|_| false }, %r{foobar}, 'httpstat.us'])
-        end
-
-        context "when the host is not allowed" do
-          it "should return stubbed response if request was stubbed" do
-            stub_request(:get, 'disallowed.example.com/foo').to_return(body: "abc")
-            expect(http_request(:get, 'http://disallowed.example.com/foo').body).to eq("abc")
-          end
-
-          it "should raise exception if request was not stubbed" do
-            expect {
-              http_request(:get, 'http://disallowed.example.com/')
-            }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://disallowed.example.com))
-          end
-        end
-
-        context "when the host is allowed" do
-          it "should return stubbed response if request was stubbed" do
-            stub_request(:get, 'httpstat.us/200').to_return(body: "abc")
-            expect(http_request(:get, "http://httpstat.us/200").body).to eq("abc")
-          end
-
-          # WARNING: this makes a real HTTP request!
-          it "should make a real request to allowed host", net_connect: true do
-            expect(http_request(:get, "http://httpstat.us/200").status).to eq('200')
-          end
-        end
-      end
-
-    end
-  end
-end

data/spec/acceptance/shared/callbacks.rb

@@ -1,147 +0,0 @@
-shared_context "callbacks" do |*adapter_info|
-  describe "when after_request callback is declared" do
-    before(:each) do
-      @called = nil
-      WebMock.reset_callbacks
-      stub_request(:get, "http://www.example.com")
-    end
-
-    it "should not invoke callback unless request is made" do
-      WebMock.after_request {
-        @called = true
-      }
-      expect(@called).to eq(nil)
-    end
-
-    it "should invoke a callback after request is made" do
-      WebMock.after_request {
-        @called = true
-      }
-      http_request(:get, "http://www.example.com/")
-      expect(@called).to eq(true)
-    end
-
-    it "should not invoke a callback if this http library should be ignored" do
-      WebMock.after_request(except: [http_library()]) {
-        @called = true
-      }
-      http_request(:get, "http://www.example.com/")
-      expect(@called).to eq(nil)
-    end
-
-    it "should invoke a callback even if other http libraries should be ignored" do
-      WebMock.after_request(except: [:other_lib]) {
-        @called = true
-      }
-      http_request(:get, "http://www.example.com/")
-      expect(@called).to eq(true)
-    end
-
-    it "should pass request signature to the callback" do
-      WebMock.after_request(except: [:other_lib])  do |request_signature, _|
-        @request_signature = request_signature
-      end
-      http_request(:get, "http://www.example.com/")
-      expect(@request_signature.uri.to_s).to eq("http://www.example.com:80/")
-    end
-
-    after(:each) do
-      WebMock::StubRegistry.instance.global_stubs.clear
-    end
-
-    it 'passes the same request signature instance to the callback that was passed to the global stub callback' do
-      global_stub_request_sig = after_request_request_sig = nil
-      WebMock.globally_stub_request do |request_sig|
-        global_stub_request_sig = request_sig
-        nil
-      end
-
-      WebMock.after_request do |request_sig, _|
-        after_request_request_sig = request_sig
-      end
-
-      http_request(:get, "http://www.example.com/")
-      expect(global_stub_request_sig).to be(after_request_request_sig)
-    end
-
-    context "passing response to callback" do
-      context "when request is stubbed" do
-        before(:each) do
-          stub_request(:get, "http://www.example.com").
-          to_return(
-            status: [200, "hello"],
-            headers: {'Content-Length' => '666', 'Hello' => 'World'},
-            body: "foo bar"
-          )
-          WebMock.after_request(except: [:other_lib])  do |_, response|
-            @response = response
-          end
-          http_request(:get, "http://www.example.com/")
-        end
-
-        it "should pass response to callback with the status and message" do
-          expect(@response.status).to eq([200, "hello"])
-        end
-
-        it "should pass response to callback with headers" do
-          expect(@response.headers).to eq({
-            'Content-Length' => '666',
-            'Hello' => 'World'
-          })
-        end
-
-        it "should pass response to callback with body" do
-          expect(@response.body).to eq("foo bar")
-        end
-      end
-
-      describe "when request is not stubbed", net_connect: true do
-        before(:each) do
-          WebMock.reset!
-          WebMock.allow_net_connect!
-          WebMock.after_request(except: [:other_lib])  do |_, response|
-            @response = response
-          end
-          http_request(:get, "http://httpstat.us/201", headers: { "Accept" => "*" })
-        end
-
-        it "should pass real response to callback with status and message" do
-          expect(@response.status[0]).to eq(201)
-          expect(@response.status[1]).to eq("Created") unless adapter_info.include?(:no_status_message)
-        end
-
-        it "should pass real response to callback with headers" do
-          expect(@response.headers["Content-Length"]).to eq("11")
-        end
-
-        it "should pass response to callback with body" do
-          expect(@response.body.size).to eq(11)
-        end
-      end
-    end
-
-    it "should invoke multiple callbacks in order of their declarations" do
-      WebMock.after_request { @called = 1 }
-      WebMock.after_request { @called += 1 }
-      http_request(:get, "http://www.example.com/")
-      expect(@called).to eq(2)
-    end
-
-    it "should invoke callbacks only for real requests if requested", net_connect: true do
-      WebMock.after_request(real_requests_only: true) { @called = true }
-      http_request(:get, "http://www.example.com/")
-      expect(@called).to eq(nil)
-      WebMock.allow_net_connect!
-      http_request(:get, "http://www.example.net/")
-      expect(@called).to eq(true)
-    end
-
-    it "should not invoke any callbacks after callbacks were reset" do
-      WebMock.after_request { @called = 1 }
-      WebMock.reset_callbacks
-      stub_request(:get, "http://www.example.com/")
-      http_request(:get, "http://www.example.com/")
-      expect(@called).to eq(nil)
-    end
-  end
-end

data/spec/acceptance/shared/complex_cross_concern_behaviors.rb

@@ -1,36 +0,0 @@
-shared_context "complex cross-concern behaviors" do |*adapter_info|
-  it 'allows a response with multiple values for the same header to be recorded and played back exactly as-is' do
-    WebMock.allow_net_connect!
-
-    recorded_response = nil
-    WebMock.after_request { |_,r| recorded_response = r }
-    real_response = http_request(:get, webmock_server_url)
-
-    stub_request(:get, webmock_server_url).to_return(
-      status: recorded_response.status,
-      body: recorded_response.body,
-      headers: recorded_response.headers
-    )
-
-    played_back_response = http_request(:get, webmock_server_url)
-
-    expect(played_back_response.headers.keys).to include('Set-Cookie')
-    expect(played_back_response).to eq(real_response)
-  end
-
-  let(:no_content_url) { 'http://httpstat.us/204' }
-  [nil, ''].each do |stub_val|
-    it "returns the same value (nil or "") for a request stubbed as #{stub_val.inspect} that a real empty response has", net_connect: true do
-      unless http_library == :curb
-        WebMock.allow_net_connect!
-
-        real_response = http_request(:get, no_content_url)
-        stub_request(:get, no_content_url).to_return(status: 204, body: stub_val)
-        stubbed_response = http_request(:get, no_content_url)
-
-        expect(stubbed_response.body).to eq(real_response.body)
-      end
-    end
-  end
-end
-

data/spec/acceptance/shared/enabling_and_disabling_webmock.rb

@@ -1,95 +0,0 @@
-shared_context "enabled and disabled webmock" do |*adapter_info|
-  describe "when webmock is disabled" do
-    before(:each) do
-      WebMock.disable!
-    end
-    after(:each) do
-      WebMock.enable!
-    end
-    include_context "disabled WebMock"
-  end
-
-  describe "when webmock is enabled again" do
-    before(:each) do
-      WebMock.disable!
-      WebMock.enable!
-    end
-    include_context "enabled WebMock"
-  end
-
-  describe "when webmock is disabled except this lib" do
-    before(:each) do
-      WebMock.disable!(except: [http_library])
-    end
-    after(:each) do
-      WebMock.enable!
-    end
-    include_context "enabled WebMock"
-  end
-
-  describe "when webmock is enabled except this lib" do
-    before(:each) do
-      WebMock.disable!
-      WebMock.enable!(except: [http_library])
-    end
-    after(:each) do
-      WebMock.enable!
-    end
-    include_context "disabled WebMock"
-  end
-end
-
-shared_context "disabled WebMock" do
-  it "should not register executed requests" do
-    http_request(:get, webmock_server_url)
-    expect(a_request(:get, webmock_server_url)).not_to have_been_made
-  end
-
-  it "should not block unstubbed requests" do
-    expect {
-      http_request(:get, webmock_server_url)
-    }.not_to raise_error
-  end
-
-  it "should return real response even if there are stubs" do
-    stub_request(:get, /.*/).to_return(body: "x")
-    expect(http_request(:get, webmock_server_url).body).to eq("hello world")
-  end
-
-  it "should not invoke any callbacks" do
-    WebMock.reset_callbacks
-    stub_request(:get, webmock_server_url)
-    @called = nil
-    WebMock.after_request { @called = 1 }
-    http_request(:get, webmock_server_url)
-    expect(@called).to eq(nil)
-  end
-end
-
-shared_context "enabled WebMock" do
-  it "should register executed requests" do
-    WebMock.allow_net_connect!
-    http_request(:get, webmock_server_url)
-    expect(a_request(:get, webmock_server_url)).to have_been_made
-  end
-
-  it "should block unstubbed requests" do
-    expect {
-      http_request(:get, "http://www.example.com/")
-    }.to raise_error(WebMock::NetConnectNotAllowedError)
-  end
-
-  it "should return stubbed response" do
-    stub_request(:get, /.*/).to_return(body: "x")
-    expect(http_request(:get, "http://www.example.com/").body).to eq("x")
-  end
-
-  it "should invoke callbacks" do
-    WebMock.allow_net_connect!
-    WebMock.reset_callbacks
-    @called = nil
-    WebMock.after_request { @called = 1 }
-    http_request(:get, webmock_server_url)
-    expect(@called).to eq(1)
-  end
-end

data/spec/acceptance/shared/precedence_of_stubs.rb

@@ -1,15 +0,0 @@
-shared_context "precedence of stubs" do |*adapter_info|
-  describe "when choosing a matching request stub" do
-    it "should use the last declared matching request stub" do
-      stub_request(:get, "www.example.com").to_return(body: "abc")
-      stub_request(:get, "www.example.com").to_return(body: "def")
-      expect(http_request(:get, "http://www.example.com/").body).to eq("def")
-    end
-
-    it "should not be affected by the type of uri or request method" do
-      stub_request(:get, "www.example.com").to_return(body: "abc")
-      stub_request(:any, /.*example.*/).to_return(body: "def")
-      expect(http_request(:get, "http://www.example.com/").body).to eq("def")
-    end
-  end
-end