webmock 3.9.1 → 3.18.1

data/spec/unit/request_pattern_spec.rb

@@ -534,69 +534,105 @@ describe WebMock::RequestPattern do
         end
 
         describe "for request with json body and content type is set to json" do
-          it "should match when hash matches body" do
-            expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: body_hash)).
-              to match(WebMock::RequestSignature.new(:post, "www.example.com", headers: {content_type: 'application/json'},
-                                                         body: "{\"a\":\"1\",\"c\":{\"d\":[\"e\",\"f\"]},\"b\":\"five\"}"))
-              end
+          shared_examples "a json body" do
+            it "should match when hash matches body" do
+              expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: body_hash)).
+                to match(WebMock::RequestSignature.new(:post, "www.example.com", headers: {content_type: content_type},
+                                                           body: "{\"a\":\"1\",\"c\":{\"d\":[\"e\",\"f\"]},\"b\":\"five\"}"))
+                end
 
-          it "should match if hash matches body in different form" do
-            expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: body_hash)).
-              to match(WebMock::RequestSignature.new(:post, "www.example.com", headers: {content_type: 'application/json'},
-                                                         body: "{\"a\":\"1\",\"b\":\"five\",\"c\":{\"d\":[\"e\",\"f\"]}}"))
-              end
+            it "should match if hash matches body in different form" do
+              expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: body_hash)).
+                to match(WebMock::RequestSignature.new(:post, "www.example.com", headers: {content_type: content_type},
+                                                           body: "{\"a\":\"1\",\"b\":\"five\",\"c\":{\"d\":[\"e\",\"f\"]}}"))
+                end
+
+            it "should match if the request body has a top level array" do
+              expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: [{a: 1}])).
+                to match(WebMock::RequestSignature.new(:post, "www.example.com",
+                headers: {content_type: content_type}, body: "[{\"a\":1}]"))
+            end
 
-          it "should not match when body is not json" do
-            expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: body_hash)).
-              not_to match(WebMock::RequestSignature.new(:post, "www.example.com",
-                                                             headers: {content_type: 'application/json'}, body: "foo bar"))
-          end
+            it "should not match if the request body has a different top level array" do
+              expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: ["a", "b"])).
+                not_to match(WebMock::RequestSignature.new(:post, "www.example.com",
+                headers: {content_type: content_type}, body: "[\"a\", \"c\"]"))
+            end
+
+            it "should not match when body is not json" do
+              expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: body_hash)).
+                not_to match(WebMock::RequestSignature.new(:post, "www.example.com",
+                                                               headers: {content_type: content_type}, body: "foo bar"))
+            end
+
+            it "should not match if request body is different" do
+              expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: {a: 1, b: 2})).
+                not_to match(WebMock::RequestSignature.new(:post, "www.example.com",
+                headers: {content_type: content_type}, body: "{\"a\":1,\"c\":null}"))
+            end
+
+            it "should not match if request body is has less params than pattern" do
+              expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: {a: 1, b: 2})).
+                not_to match(WebMock::RequestSignature.new(:post, "www.example.com",
+                headers: {content_type: content_type}, body: "{\"a\":1}"))
+            end
 
-          it "should not match if request body is different" do
-            expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: {a: 1, b: 2})).
-              not_to match(WebMock::RequestSignature.new(:post, "www.example.com",
-              headers: {content_type: 'application/json'}, body: "{\"a\":1,\"c\":null}"))
+            it "should not match if request body is has more params than pattern" do
+              expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: {a: 1})).
+                not_to match(WebMock::RequestSignature.new(:post, "www.example.com",
+                headers: {content_type: content_type}, body: "{\"a\":1,\"c\":1}"))
+            end
           end
 
-          it "should not match if request body is has less params than pattern" do
-            expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: {a: 1, b: 2})).
-              not_to match(WebMock::RequestSignature.new(:post, "www.example.com",
-              headers: {content_type: 'application/json'}, body: "{\"a\":1}"))
+          context "standard application/json" do
+            let(:content_type) { 'application/json' }
+            it_behaves_like "a json body"
           end
 
-          it "should not match if request body is has more params than pattern" do
-            expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: {a: 1})).
-              not_to match(WebMock::RequestSignature.new(:post, "www.example.com",
-              headers: {content_type: 'application/json'}, body: "{\"a\":1,\"c\":1}"))
+          context "custom json content type" do
+            let(:content_type) { 'application/vnd.api+json' }
+            it_behaves_like "a json body"
           end
         end
 
         describe "for request with xml body and content type is set to xml" do
           let(:body_hash) { {"opt" => {:a => '1', :b => 'five', 'c' => {'d' => ['e', 'f']}}} }
 
-          it "should match when hash matches body" do
-            expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: body_hash)).
-              to match(WebMock::RequestSignature.new(:post, "www.example.com", headers: {content_type: 'application/xml'},
-                                                         body: "<opt a=\"1\" b=\"five\">\n  <c>\n    <d>e</d>\n    <d>f</d>\n  </c>\n</opt>\n"))
-              end
+          shared_examples "a xml body" do
+            it "should match when hash matches body" do
+              expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: body_hash)).
+                to match(WebMock::RequestSignature.new(:post, "www.example.com", headers: {content_type: content_type},
+                                                           body: "<opt a=\"1\" b=\"five\">\n  <c>\n    <d>e</d>\n    <d>f</d>\n  </c>\n</opt>\n"))
+                end
 
-          it "should match if hash matches body in different form" do
-            expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: body_hash)).
-              to match(WebMock::RequestSignature.new(:post, "www.example.com", headers: {content_type: 'application/xml'},
-                                                         body: "<opt b=\"five\" a=\"1\">\n  <c>\n    <d>e</d>\n    <d>f</d>\n  </c>\n</opt>\n"))
-              end
+            it "should match if hash matches body in different form" do
+              expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: body_hash)).
+                to match(WebMock::RequestSignature.new(:post, "www.example.com", headers: {content_type: content_type},
+                                                           body: "<opt b=\"five\" a=\"1\">\n  <c>\n    <d>e</d>\n    <d>f</d>\n  </c>\n</opt>\n"))
+                end
 
-          it "should not match when body is not xml" do
-            expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: body_hash)).
-              not_to match(WebMock::RequestSignature.new(:post, "www.example.com",
-                                                             headers: {content_type: 'application/xml'}, body: "foo bar"))
-              end
+            it "should not match when body is not xml" do
+              expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: body_hash)).
+                not_to match(WebMock::RequestSignature.new(:post, "www.example.com",
+                                                               headers: {content_type: content_type}, body: "foo bar"))
+                end
 
-          it "matches when the content type include a charset" do
-            expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: body_hash)).
-              to match(WebMock::RequestSignature.new(:post, "www.example.com", headers: {content_type: 'application/xml;charset=UTF-8'},
-                                                         body: "<opt a=\"1\" b=\"five\">\n  <c>\n    <d>e</d>\n    <d>f</d>\n  </c>\n</opt>\n"))
+            it "matches when the content type include a charset" do
+              expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: body_hash)).
+                to match(WebMock::RequestSignature.new(:post, "www.example.com", headers: {content_type: "#{content_type};charset=UTF-8"},
+                                                           body: "<opt a=\"1\" b=\"five\">\n  <c>\n    <d>e</d>\n    <d>f</d>\n  </c>\n</opt>\n"))
+
+            end
+          end
+
+          context "standard application/xml" do
+            let(:content_type) { 'application/xml' }
+            it_behaves_like "a xml body"
+          end
 
+          context "custom xml content type" do
+            let(:content_type) { 'application/atom+xml' }
+            it_behaves_like "a xml body"
           end
         end
       end

data/spec/unit/request_signature_spec.rb

@@ -18,7 +18,7 @@ describe WebMock::RequestSignature do
     end
 
     it "assigns normalized headers" do
-      expect(WebMock::Util::Headers).to receive(:normalize_headers).with('A' => 'a').and_return('B' => 'b')
+      allow(WebMock::Util::Headers).to receive(:normalize_headers).with({'A' => 'a'}.freeze).and_return('B' => 'b')
       expect(
         WebMock::RequestSignature.new(:get, "www.example.com", headers: {'A' => 'a'}).headers
       ).to eq({'B' => 'b'})
@@ -125,11 +125,21 @@ describe WebMock::RequestSignature do
       expect(subject.url_encoded?).to be true
     end
 
+    it "returns true if the headers are urlencoded with a specified charset" do
+      subject.headers = { "Content-Type" => "application/x-www-form-urlencoded; charset=UTF-8" }
+      expect(subject.url_encoded?).to be true
+    end
+
     it "returns false if the headers are NOT urlencoded" do
       subject.headers = { "Content-Type" => "application/made-up-format" }
       expect(subject.url_encoded?).to be false
     end
 
+    it "returns false when no content type header is present" do
+      subject.headers = { "Some-Header" => "some-value" }
+      expect(subject.url_encoded?).to be false
+    end
+
     it "returns false when no headers are set" do
       subject.headers = nil
       expect(subject.url_encoded?).to be false
@@ -142,11 +152,21 @@ describe WebMock::RequestSignature do
       expect(subject.json_headers?).to be true
     end
 
+    it "returns true if the headers are json with a specified charset" do
+      subject.headers = { "Content-Type" => "application/json; charset=UTF-8" }
+      expect(subject.json_headers?).to be true
+    end
+
     it "returns false if the headers are NOT json" do
       subject.headers = { "Content-Type" => "application/made-up-format" }
       expect(subject.json_headers?).to be false
     end
 
+    it "returns false when no content type header is present" do
+      subject.headers = { "Some-Header" => "some-value" }
+      expect(subject.json_headers?).to be false
+    end
+
     it "returns false when no headers are set" do
       subject.headers = nil
       expect(subject.json_headers?).to be false

data/spec/unit/request_stub_spec.rb

@@ -50,6 +50,41 @@ describe WebMock::RequestStub do
 
   end
 
+  describe "to_return_json" do
+
+    it "should raise if a block is given" do
+      expect {
+        @request_stub.to_return_json(body: "abc", status: 500) { puts "don't call me" }
+      }.to raise_error(ArgumentError, '#to_return_json does not support passing a block')
+    end
+
+    it "should assign responses normally" do
+      @request_stub.to_return_json([{body: "abc"}, {body: "def"}])
+      expect([@request_stub.response.body, @request_stub.response.body]).to eq(["abc", "def"])
+    end
+
+    it "should json-ify a Hash body" do
+      @request_stub.to_return_json(body: {abc: "def"}, status: 500)
+      expect(@request_stub.response.body).to eq({abc: "def"}.to_json)
+      expect(@request_stub.response.status).to eq([500, ""])
+    end
+
+    it "should apply the content_type header" do
+      @request_stub.to_return_json(body: {abc: "def"}, status: 500)
+      expect(@request_stub.response.headers).to eq({"Content-Type"=>"application/json"})
+    end
+
+    it "should preserve existing headers" do
+      @request_stub.to_return_json(headers: {"A" => "a"}, body: "")
+      expect(@request_stub.response.headers).to eq({"A"=>"a", "Content-Type"=>"application/json"})
+    end
+
+    it "should allow callsites to override content_type header" do
+      @request_stub.to_return_json(headers: {content_type: 'application/super-special-json'})
+      expect(@request_stub.response.headers).to eq({"Content-Type"=>"application/super-special-json"})
+    end
+  end
+
   describe "then" do
     it "should return stub without any modifications, acting as syntactic sugar" do
       expect(@request_stub.then).to eq(@request_stub)

data/spec/unit/response_spec.rb

@@ -31,7 +31,7 @@ describe WebMock::Response do
   end
 
   it "should report normalized headers" do
-    expect(WebMock::Util::Headers).to receive(:normalize_headers).with('A' => 'a').and_return('B' => 'b')
+    allow(WebMock::Util::Headers).to receive(:normalize_headers).with({'A' => 'a'}.freeze).and_return('B' => 'b')
     @response = WebMock::Response.new(headers: {'A' => 'a'})
     expect(@response.headers).to eq({'B' => 'b'})
   end
@@ -130,14 +130,46 @@ describe WebMock::Response do
     # Users of webmock commonly make the mistake of stubbing the response
     # body to return a hash, to prevent this:
     #
-    it "should error if not given one of the allowed types" do
+    it "should error if given a non-allowed type: a hash" do
       expect { WebMock::Response.new(body: Hash.new) }.to \
         raise_error(WebMock::Response::InvalidBody)
     end
 
+    it "should error if given a non-allowed type: something that is not a hash" do
+      expect { WebMock::Response.new(body: 123) }.to \
+        raise_error(WebMock::Response::InvalidBody)
+    end
   end
 
   describe "from raw response" do
+    describe "when input is a StringIO" do
+      before(:each) do
+        @io = StringIO.new(File.read(CURL_EXAMPLE_OUTPUT_PATH))
+        @response = WebMock::Response.new(@io)
+      end
+
+      it "should read status" do
+        expect(@response.status).to eq([202, "OK"])
+      end
+
+      it "should read headers" do
+        expect(@response.headers).to eq(
+          "Date"=>"Sat, 23 Jan 2010 01:01:05 GMT",
+          "Content-Type"=>"text/html; charset=UTF-8",
+          "Content-Length"=>"419",
+          "Connection"=>"Keep-Alive",
+          "Accept"=>"image/jpeg, image/png"
+        )
+      end
+
+      it "should read body" do
+        expect(@response.body.size).to eq(419)
+      end
+
+      it "should close IO" do
+        expect(@io).to be_closed
+      end
+    end
 
     describe "when input is IO" do
       before(:each) do
@@ -152,12 +184,12 @@ describe WebMock::Response do
 
       it "should read headers" do
         expect(@response.headers).to eq({
-          "Date"=>"Sat, 23 Jan 2010 01:01:05 GMT",
-          "Content-Type"=>"text/html; charset=UTF-8",
-          "Content-Length"=>"419",
-          "Connection"=>"Keep-Alive",
-          "Accept"=>"image/jpeg, image/png"
-          })
+                                          "Date"=>"Sat, 23 Jan 2010 01:01:05 GMT",
+                                          "Content-Type"=>"text/html; charset=UTF-8",
+                                          "Content-Length"=>"419",
+                                          "Connection"=>"Keep-Alive",
+                                          "Accept"=>"image/jpeg, image/png"
+        })
       end
 
       it "should read body" do
@@ -182,12 +214,12 @@ describe WebMock::Response do
 
       it "should read headers" do
         expect(@response.headers).to eq({
-          "Date"=>"Sat, 23 Jan 2010 01:01:05 GMT",
-          "Content-Type"=>"text/html; charset=UTF-8",
-          "Content-Length"=>"419",
-          "Connection"=>"Keep-Alive",
-          "Accept"=>"image/jpeg, image/png"
-          })
+                                          "Date"=>"Sat, 23 Jan 2010 01:01:05 GMT",
+                                          "Content-Type"=>"text/html; charset=UTF-8",
+                                          "Content-Length"=>"419",
+                                          "Connection"=>"Keep-Alive",
+                                          "Accept"=>"image/jpeg, image/png"
+        })
       end
 
       it "should read body" do
@@ -234,11 +266,11 @@ describe WebMock::Response do
       it "should evaluate new response with evaluated options" do
         request_signature = WebMock::RequestSignature.new(:post, "www.example.com", body: "abc", headers: {'A' => 'a'})
         response = WebMock::DynamicResponse.new(lambda {|request|
-          {
-            body: request.body,
-            headers: request.headers,
-            status: 302
-          }
+                                                  {
+                                                    body: request.body,
+                                                    headers: request.headers,
+                                                    status: 302
+                                                  }
         })
         evaluated_response = response.evaluate(request_signature)
         expect(evaluated_response.body).to eq("abc")

data/spec/unit/webmock_spec.rb

@@ -57,4 +57,58 @@ describe "WebMock" do
       end
     end
   end
+
+  describe ".net_http_connect_on_start?" do
+    let(:uri) { Addressable::URI.parse("http://example.org:5432") }
+
+    it "will not connect on start when false" do
+      WebMock.disable_net_connect!
+      expect(WebMock.net_http_connect_on_start?(uri)).to be(false)
+    end
+
+    it "will connect on start when true" do
+      WebMock.disable_net_connect!(net_http_connect_on_start: true)
+      expect(WebMock.net_http_connect_on_start?(uri)).to be(true)
+    end
+
+    it "will connect on start when regexp matches" do
+      WebMock.disable_net_connect!(net_http_connect_on_start: /example/)
+      expect(WebMock.net_http_connect_on_start?(uri)).to be(true)
+    end
+
+    it "will not connect on start when regexp does not match" do
+      WebMock.disable_net_connect!(net_http_connect_on_start: /nope/)
+      expect(WebMock.net_http_connect_on_start?(uri)).to be(false)
+    end
+
+    it "will connect on start when host matches" do
+      WebMock.disable_net_connect!(net_http_connect_on_start: "example.org")
+      expect(WebMock.net_http_connect_on_start?(uri)).to be(true)
+    end
+
+    it "will not connect on start when host does not match" do
+      WebMock.disable_net_connect!(net_http_connect_on_start: "localhost")
+      expect(WebMock.net_http_connect_on_start?(uri)).to be(false)
+    end
+
+    it "will connect on start when host + port matches" do
+      WebMock.disable_net_connect!(net_http_connect_on_start: "example.org:5432")
+      expect(WebMock.net_http_connect_on_start?(uri)).to be(true)
+    end
+
+    it "will not connect on start when host + port does not match" do
+      WebMock.disable_net_connect!(net_http_connect_on_start: "example.org:80")
+      expect(WebMock.net_http_connect_on_start?(uri)).to be(false)
+    end
+
+    it "will connect on start when scheme + host + port matches" do
+      WebMock.disable_net_connect!(net_http_connect_on_start: "http://example.org:5432")
+      expect(WebMock.net_http_connect_on_start?(uri)).to be(true)
+    end
+
+    it "will not connect on start when scheme + host + port does not match" do
+      WebMock.disable_net_connect!(net_http_connect_on_start: "https://example.org:5432")
+      expect(WebMock.net_http_connect_on_start?(uri)).to be(false)
+    end
+  end
 end

data/test/test_webmock.rb

@@ -3,4 +3,10 @@ require File.expand_path(File.dirname(__FILE__) + '/shared_test')
 
 class TestWebMock < Test::Unit::TestCase
   include SharedTest
+
+  def teardown
+    # Ensure global Test::Unit teardown was called
+    assert_empty WebMock::RequestRegistry.instance.requested_signatures.hash
+    assert_empty WebMock::StubRegistry.instance.request_stubs
+  end
 end

data/webmock.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
   s.authors     = ['Bartosz Blimke']
   s.email       = ['bartosz.blimke@gmail.com']
-  s.homepage    = 'http://github.com/bblimke/webmock'
+  s.homepage    = 'https://github.com/bblimke/webmock'
   s.summary     = %q{Library for stubbing HTTP requests in Ruby.}
   s.description = %q{WebMock allows stubbing HTTP requests and setting expectations on HTTP requests.}
   s.license     = "MIT"
@@ -21,9 +21,9 @@ Gem::Specification.new do |s|
     'wiki_uri'          => 'https://github.com/bblimke/webmock/wiki'
   }
 
-  s.required_ruby_version = '>= 2.0'
+  s.required_ruby_version = '>= 2.3'
 
-  s.add_dependency 'addressable', '>= 2.3.6'
+  s.add_dependency 'addressable', '>= 2.8.0'
   s.add_dependency 'crack', '>= 0.3.2'
   s.add_dependency 'hashdiff', ['>= 0.4.0', '< 2.0.0']
 
@@ -31,6 +31,8 @@ Gem::Specification.new do |s|
     s.add_development_dependency 'patron',   '>= 0.4.18'
     s.add_development_dependency 'curb',     '>= 0.7.16'
     s.add_development_dependency 'typhoeus', '>= 0.5.0'
+    s.add_development_dependency 'em-http-request', '>= 1.0.2'
+    s.add_development_dependency 'em-synchrony',    '>= 1.0.0'
   end
 
   s.add_development_dependency 'http',            '>= 0.8.0'
@@ -38,13 +40,12 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rack',            ((RUBY_VERSION < '2.2.2') ? '1.6.0' : '> 1.6')
   s.add_development_dependency 'rspec',           '>= 3.1.0'
   s.add_development_dependency 'httpclient',      '>= 2.2.4'
-  s.add_development_dependency 'em-http-request', '>= 1.0.2'
-  s.add_development_dependency 'em-synchrony',    '>= 1.0.0'
   s.add_development_dependency 'excon',           '>= 0.27.5'
   s.add_development_dependency 'async-http',      '>= 0.48.0'
   s.add_development_dependency 'minitest',        '>= 5.0.0'
   s.add_development_dependency 'test-unit',       '>= 3.0.0'
   s.add_development_dependency 'rdoc',            '>  3.5.0'
+  s.add_development_dependency 'webrick'
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")