webmock 1.8.6 → 3.14.0

data/spec/acceptance/patron/patron_spec.rb

@@ -19,23 +19,29 @@ unless RUBY_PLATFORM =~ /java/
         @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.exists?(@file_path)
+          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")
+          stub_request(:get, "www.example.com").to_return(body: "abc")
           @sess.get_file("/", @file_path)
-          File.read(@file_path).should == "abc"
+          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
@@ -44,9 +50,9 @@ unless RUBY_PLATFORM =~ /java/
             tmpfile.chmod(0400)
           end
           begin
-            lambda {
+            expect {
               @sess.get_file("/", "/tmp/read_only_file")
-            }.should raise_error(ArgumentError, "Unable to open specified file.")
+            }.to raise_error(ArgumentError, "Unable to open specified file.")
           ensure
             File.unlink("/tmp/read_only_file")
           end
@@ -54,21 +60,21 @@ unless RUBY_PLATFORM =~ /java/
 
         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")
+          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")
+          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")
-          lambda {
+          stub_request(:post, "www.example.com").with(body: "abc")
+          expect {
             @sess.post_file("/", "/path/to/non/existing/file")
-          }.should raise_error(ArgumentError, "Unable to open specified file.")
+          }.to raise_error(ArgumentError, "Unable to open specified file.")
         end
 
       end
@@ -76,14 +82,14 @@ unless RUBY_PLATFORM =~ /java/
       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")
-          lambda {
+          expect {
             @sess.post("/", nil)
-          }.should raise_error(ArgumentError, "Must provide either data or a filename when doing a PUT or POST")
+          }.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"})
+        stub_request(:copy, "www.example.com/abc").with(headers: {'Destination' => "/def"})
         @sess.copy("/abc", "/def")
       end
 
@@ -96,39 +102,22 @@ unless RUBY_PLATFORM =~ /java/
             Encoding.default_internal = @encoding
           end
 
-          it "should encode body with default encoding" do
-            stub_request(:get, "www.example.com").
-              to_return(:body => "Øl")
-
-            @sess.get("").body.encoding.should == Encoding::UTF_8
-          end
-
-          it "should encode body to default internal" do
+          it "should not encode body with default encoding" do
             stub_request(:get, "www.example.com").
-              to_return(:headers => {'Content-Type' => 'text/html; charset=iso-8859-1'},
-                        :body => "Øl".encode("iso-8859-1"))
+              to_return(body: "Øl")
 
-            @sess.get("").body.encoding.should == Encoding.default_internal
+            expect(@sess.get("").body.encoding).to eq(Encoding::ASCII_8BIT)
+            expect(@sess.get("").inspectable_body.encoding).to eq(Encoding::UTF_8)
           end
 
-          it "should encode body based on encoding-attribute in body" do
+          it "should not encode body to default internal" do
             stub_request(:get, "www.example.com").
-              to_return(:body => "<?xml encoding=\"iso-8859-1\">Øl</xml>".encode("iso-8859-1"))
+              to_return(headers: {'Content-Type' => 'text/html; charset=iso-8859-1'},
+                        body: "Øl".encode("iso-8859-1"))
 
-
-            @sess.get("").body.encoding.should == Encoding::ISO_8859_1
-          end
-
-
-          it "should encode body based on Session#default_response_charset" do
-            stub_request(:get, "www.example.com").
-              to_return(:body => "Øl".encode("iso-8859-1"))
-
-            @sess.default_response_charset = "iso-8859-1"
-
-            @sess.get("").body.encoding.should == Encoding::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

data/spec/acceptance/patron/patron_spec_helper.rb

@@ -2,19 +2,23 @@ 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(:userinfo, :path, :query).normalize.to_s}".gsub(/\/$/,"")
-    sess.username = uri.user
-    sess.password = uri.password
+    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.gsub!(' ','+')
+    uri = uri.gsub(' ','%20')
     response = sess.request(method, uri, options[:headers] || {}, {
-      :data => options[:body]
+      data: options[:body]
     })
     headers = {}
     if response.headers
@@ -24,14 +28,14 @@ module PatronSpecHelper
       end
     end
 
-    status_line_pattern = %r(\AHTTP/(\d+\.\d+)\s+(\d\d\d)\s*([^\r\n]+)?)
-    message = response.status_line.match(status_line_pattern)[3] || ""
+    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
+      body: response.body,
+      headers: WebMock::Util::Headers.normalize_headers(headers),
+      status: response.status.to_s,
+      message: message
     })
   end
 

data/spec/acceptance/shared/allowing_and_disabling_net_connect.rb

@@ -1,24 +1,33 @@
 shared_context "allowing and disabling net connect" do |*adapter_info|
   describe "when net connect" do
-    describe "is allowed", :net_connect => true 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
-        http_request(:get, webmock_server_url).status.should == "200"
+        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
-          http_request(:get, "https://www.google.com/").
-            body.should =~ /.*google.*/
+          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")
-        http_request(:get, "http://www.example.com/").body.should == "abc"
+        stub_request(:get, "www.example.com").to_return(body: "abc")
+        expect(http_request(:get, "http://www.example.com/").body).to eq("abc")
       end
     end
 
@@ -28,115 +37,277 @@ shared_context "allowing and disabling net connect" do |*adapter_info|
       end
 
       it "should return stubbed response if request was stubbed" do
-        stub_request(:get, "www.example.com").to_return(:body => "abc")
-        http_request(:get, "http://www.example.com/").body.should == "abc"
+        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")
-        http_request(:get, "http://www.example.com/hello_world").body.should == "abc"
+        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
-        lambda {
+        expect {
           http_request(:get, "http://www.example.com/")
-        }.should raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered 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)
+        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")
-        http_request(:get, "http://www.example.com/").body.should == "abc"
+        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
-        lambda {
+        expect {
           http_request(:get, "http://www.example.com/")
-        }.should raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered 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
-        lambda {
+        expect {
           http_request(:get, "http://localhost:12345/")
-        }.should raise_error(connection_refused_exception_class)
+        }.to raise_error(connection_refused_exception_class)
       end
 
       it "should make a real request to 127.0.0.1" do
-        lambda {
+        expect {
           http_request(:get, "http://127.0.0.1:12345/")
-        }.should raise_error(connection_refused_exception_class)
+        }.to raise_error(connection_refused_exception_class)
       end
 
       it "should make a real request to 0.0.0.0" do
-        lambda {
+        expect {
           http_request(:get, "http://0.0.0.0:12345/")
-        }.should raise_error(connection_refused_exception_class)
+        }.to raise_error(connection_refused_exception_class)
       end
     end
 
-    describe "is not allowed with exception for allowed domains" do
-      let(:host_with_port){ WebMockServer.instance.host_with_port }
+    describe "is not allowed, with exceptions" do
+      describe "allowing by host string" do
+        before :each do
+          WebMock.disable_net_connect!(allow: 'httpstat.us')
+        end
 
-      before(:each) do
-        WebMock.disable_net_connect!(:allow => ["www.example.org", host_with_port])
+        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
 
-      context "when the host is not allowed" do
-        it "should return stubbed response if request was stubbed" do
-          stub_request(:get, "www.example.com").to_return(:body => "abc")
-          http_request(:get, "http://www.example.com/").body.should == "abc"
+      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
 
-        it "should raise exception if request was not stubbed" do
-          lambda {
-            http_request(:get, "http://www.example.com/")
-          }.should raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/))
+        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
 
-      context "when the host with port is not allowed" do
-        it "should return stubbed response if request was stubbed" do
-          stub_request(:get, "http://localhost:2345").to_return(:body => "abc")
-          http_request(:get, "http://localhost:2345/").body.should == "abc"
+      describe "allowing by scheme:host string" do
+        before :each do
+          WebMock.disable_net_connect!(allow: 'https://www.google.pl')
         end
 
-        it "should raise exception if request was not stubbed" do
-          lambda {
-            http_request(:get, "http://localhost:2345/")
-          }.should raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://localhost:2345/))
+        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
 
-      context "when the host is allowed" do
-        it "should raise exception if request was not stubbed" do
-          lambda {
-            http_request(:get, "http://www.example.com/")
-          }.should raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/))
+      describe "allowing by regular expression" do
+        before :each do
+          WebMock.disable_net_connect!(allow: %r{httpstat})
         end
 
-        it "should make a real request to allowed host", :net_connect => true do
-          http_request(:get, "http://www.example.org/").status.should == "302"
+        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
 
-      context "when the host with port is allowed" do
-        it "should make a real request to allowed host", :net_connect => true do
-          http_request(:get, "http://#{host_with_port}/").status.should == "200"
+      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
 
-      context "when the host is allowed but not port" do
-        it "should make a real request to allowed host", :net_connect => true do
-          lambda {
-            http_request(:get, "http://localhost:123/")
-          }.should raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://localhost:123/))
+      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