webmock 3.14.0 → 3.24.0

data/spec/acceptance/patron/patron_spec.rb

@@ -1,125 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-require 'acceptance/webmock_shared'
-
-unless RUBY_PLATFORM =~ /java/
-  require 'acceptance/patron/patron_spec_helper'
-  require 'tmpdir'
-  require 'fileutils'
-
-  describe "Patron" do
-    include PatronSpecHelper
-
-    include_examples "with WebMock"
-
-    describe "when custom functionality is used" do
-      before(:each) do
-        @sess = Patron::Session.new
-        @sess.base_url = "http://www.example.com"
-      end
-
-      it "should allow stubbing PATCH request with body" do
-        stub_request(:patch, "http://www.example.com/")
-          .with(body: "abc")
-
-        @sess.patch('/', "abc")
-      end
-
-      describe "file requests" do
-
-        before(:each) do
-          @dir_path = Dir.mktmpdir('webmock-')
-          @file_path = File.join(@dir_path, "webmock_temp_test_file")
-          FileUtils.rm_rf(@file_path) if File.exist?(@file_path)
-        end
-
-        after(:each) do
-          FileUtils.rm_rf(@dir_path) if File.exist?(@dir_path)
-        end
-
-        it "should work with get_file" do
-          stub_request(:get, "www.example.com").to_return(body: "abc")
-          @sess.get_file("/", @file_path)
-          expect(File.read(@file_path)).to eq("abc")
-        end
-
-        it "should raise same error as Patron if file is not readable for get request" do
-          stub_request(:get, "www.example.com")
-          File.open("/tmp/read_only_file", "w") do |tmpfile|
-            tmpfile.chmod(0400)
-          end
-          begin
-            expect {
-              @sess.get_file("/", "/tmp/read_only_file")
-            }.to raise_error(ArgumentError, "Unable to open specified file.")
-          ensure
-            File.unlink("/tmp/read_only_file")
-          end
-        end
-
-        it "should work with put_file" do
-          File.open(@file_path, "w") {|f| f.write "abc"}
-          stub_request(:put, "www.example.com").with(body: "abc")
-          @sess.put_file("/", @file_path)
-        end
-
-        it "should work with post_file" do
-          File.open(@file_path, "w") {|f| f.write "abc"}
-          stub_request(:post, "www.example.com").with(body: "abc")
-          @sess.post_file("/", @file_path)
-        end
-
-        it "should raise same error as Patron if file is not readable for post request" do
-          stub_request(:post, "www.example.com").with(body: "abc")
-          expect {
-            @sess.post_file("/", "/path/to/non/existing/file")
-          }.to raise_error(ArgumentError, "Unable to open specified file.")
-        end
-
-      end
-
-      describe "handling errors same way as patron" do
-        it "should raise error if put request has neither upload_data nor file_name" do
-          stub_request(:post, "www.example.com")
-          expect {
-            @sess.post("/", nil)
-          }.to raise_error(ArgumentError, "Must provide either data or a filename when doing a PUT or POST")
-        end
-      end
-
-      it "should work with WebDAV copy request" do
-        stub_request(:copy, "www.example.com/abc").with(headers: {'Destination' => "/def"})
-        @sess.copy("/abc", "/def")
-      end
-
-      if /^1\.9/ === RUBY_VERSION
-        describe "handling encoding same way as patron" do
-          around(:each) do |example|
-            @encoding = Encoding.default_internal
-            Encoding.default_internal = "UTF-8"
-            example.run
-            Encoding.default_internal = @encoding
-          end
-
-          it "should not encode body with default encoding" do
-            stub_request(:get, "www.example.com").
-              to_return(body: "Øl")
-
-            expect(@sess.get("").body.encoding).to eq(Encoding::ASCII_8BIT)
-            expect(@sess.get("").inspectable_body.encoding).to eq(Encoding::UTF_8)
-          end
-
-          it "should not encode body to default internal" do
-            stub_request(:get, "www.example.com").
-              to_return(headers: {'Content-Type' => 'text/html; charset=iso-8859-1'},
-                        body: "Øl".encode("iso-8859-1"))
-
-            expect(@sess.get("").body.encoding).to eq(Encoding::ASCII_8BIT)
-            expect(@sess.get("").decoded_body.encoding).to eq(Encoding.default_internal)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/acceptance/patron/patron_spec_helper.rb

@@ -1,54 +0,0 @@
-require 'ostruct'
-
-module PatronSpecHelper
-  def http_request(method, uri, options = {}, &block)
-    method = method.to_sym
-    uri = Addressable::URI.heuristic_parse(uri)
-    sess = Patron::Session.new
-    sess.base_url = "#{uri.omit(:path, :query).normalize.to_s}".gsub(/\/$/,"")
-
-    if options[:basic_auth]
-      sess.username = options[:basic_auth][0]
-      sess.password = options[:basic_auth][1]
-    end
-
-    sess.connect_timeout = 30
-    sess.timeout = 30
-    sess.max_redirects = 0
-    uri = "#{uri.path}#{uri.query ? '?' : ''}#{uri.query}"
-    uri = uri.gsub(' ','%20')
-    response = sess.request(method, uri, options[:headers] || {}, {
-      data: options[:body]
-    })
-    headers = {}
-    if response.headers
-      response.headers.each do |k,v|
-        v = v.join(", ") if v.is_a?(Array)
-        headers[k] = v
-      end
-    end
-
-    status_line_pattern = %r(\AHTTP/(\d+(\.\d+)?)\s+(\d\d\d)\s*([^\r\n]+)?)
-    message = response.status_line.match(status_line_pattern)[4] || ""
-
-    OpenStruct.new({
-      body: response.body,
-      headers: WebMock::Util::Headers.normalize_headers(headers),
-      status: response.status.to_s,
-      message: message
-    })
-  end
-
-  def client_timeout_exception_class
-    Patron::TimeoutError
-  end
-
-  def connection_refused_exception_class
-    Patron::ConnectionFailed
-  end
-
-  def http_library
-    :patron
-  end
-
-end

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,148 +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["X-Powered-By"]).to eq( "ASP.NET")
-          expect(@response.headers["Content-Length"]).to eq("11") unless adapter_info.include?(:no_content_length_header)
-        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
-