webmock 1.8.6 → 3.14.0

data/spec/unit/errors_spec.rb

@@ -4,29 +4,126 @@ describe "errors" do
   describe WebMock::NetConnectNotAllowedError do
     describe "message" do
       it "should have message with request signature and snippet" do
-        request_signature = mock(:to_s => "aaa")
-        request_stub = mock
-        WebMock::RequestStub.stub!(:from_request_signature).and_return(request_stub)
-        WebMock::StubRequestSnippet.stub!(:new).
-          with(request_stub).and_return(mock(:to_s => "bbb"))
-        expected =  "Real HTTP connections are disabled. Unregistered request: aaa" +
-               "\n\nYou can stub this request with the following snippet:\n\n" +
-               "bbb\n\n============================================================"
-        WebMock::NetConnectNotAllowedError.new(request_signature).message.should == expected
+        allow(WebMock::RequestStub).to receive(:from_request_signature).and_return(request_stub)
+        allow(WebMock::StubRequestSnippet).to receive(:new).
+           with(request_stub).and_return(stub_result)
+
+        expected =  \
+          "Real HTTP connections are disabled. Unregistered request: #{request_signature}" \
+          "\n\nYou can stub this request with the following snippet:" \
+          "\n\n#{stub_result}" \
+          "\n\n============================================================"
+        expect(WebMock::NetConnectNotAllowedError.new(request_signature).message).to eq(expected)
       end
 
       it "should have message with registered stubs if available" do
-        request_signature = mock(:to_s => "aaa")
-        request_stub = mock
-        WebMock::StubRegistry.instance.stub!(:request_stubs).and_return([request_stub])
-        WebMock::RequestStub.stub!(:from_request_signature).and_return(request_stub)
-        WebMock::StubRequestSnippet.stub!(:new).
-          with(request_stub).and_return(mock(:to_s => "bbb"))
-        expected =  "Real HTTP connections are disabled. Unregistered request: aaa" +
-               "\n\nYou can stub this request with the following snippet:\n\n" +
-               "bbb\n\nregistered request stubs:\n\nbbb\n\n============================================================"
-        WebMock::NetConnectNotAllowedError.new(request_signature).message.should == expected
+        allow(WebMock::StubRegistry.instance).to receive(:request_stubs).and_return([request_stub])
+        allow(WebMock::RequestStub).to receive(:from_request_signature).and_return(request_stub)
+        allow(WebMock::StubRequestSnippet).to receive(:new).
+           with(request_stub).and_return(stub_result)
+        allow_any_instance_of(WebMock::RequestBodyDiff).to receive(:body_diff).and_return({})
+
+        expected =  \
+          "Real HTTP connections are disabled. Unregistered request: #{request_signature}" \
+          "\n\nYou can stub this request with the following snippet:" \
+          "\n\n#{stub_result}" \
+          "\n\nregistered request stubs:" \
+          "\n\n#{stub_result}" \
+          "\n\n============================================================"
+        expect(WebMock::NetConnectNotAllowedError.new(request_signature).message).to eq(expected)
+      end
+
+      it "should not be caught by a rescue block without arguments" do
+        allow(WebMock::RequestStub).to receive(:from_request_signature).and_return(request_stub)
+        allow(WebMock::StubRequestSnippet).to receive(:new).
+          with(request_stub).and_return(stub_result)
+
+        exception = WebMock::NetConnectNotAllowedError.new(request_signature)
+
+        expect do
+          begin
+            raise exception
+          rescue
+            raise "exception should not be caught"
+          end
+        end.to raise_exception exception
+      end
+
+      it "should print body diff if available" do
+        allow(WebMock::StubRegistry.instance).to receive(:request_stubs).and_return([request_stub])
+        allow(WebMock::RequestStub).to receive(:from_request_signature).and_return(request_stub)
+        allow(WebMock::StubRequestSnippet).to receive(:new).
+           with(request_stub).and_return(stub_result)
+        allow_any_instance_of(WebMock::RequestBodyDiff).to receive(:body_diff).and_return(body_diff)
+        expected =  \
+          "Real HTTP connections are disabled. Unregistered request: #{request_signature}" \
+          "\n\nYou can stub this request with the following snippet:" \
+          "\n\n#{stub_result}" \
+          "\n\nregistered request stubs:" \
+          "\n\n#{stub_result}" \
+          "\n\nBody diff:\n [[\"+\", \"test\", \"test2\"], [\"-\", \"test3\"], [\"~\", \"test5\", \"test6\"]]" \
+          "\n\n\n============================================================"
+        expect(WebMock::NetConnectNotAllowedError.new(request_signature).message).to eq(expected)
+      end
+
+      context "WebMock.show_body_diff? is false" do
+        before do
+          WebMock.hide_body_diff!
+        end
+        it "should not show body diff" do
+          allow(WebMock::StubRegistry.instance).to receive(:request_stubs).and_return([request_stub])
+          allow(WebMock::RequestStub).to receive(:from_request_signature).and_return(request_stub)
+          allow(WebMock::StubRequestSnippet).to receive(:new).
+             with(request_stub).and_return(stub_result)
+          expect_any_instance_of(WebMock::RequestBodyDiff).to_not receive(:body_diff)
+          expected =  \
+            "Real HTTP connections are disabled. Unregistered request: #{request_signature}" \
+            "\n\nYou can stub this request with the following snippet:" \
+            "\n\n#{stub_result}" \
+            "\n\nregistered request stubs:" \
+            "\n\n#{stub_result}" \
+            "\n\n============================================================"
+          expect(WebMock::NetConnectNotAllowedError.new(request_signature).message).to eq(expected)
+        end
+      end
+
+      context "WebMock.show_stubbing_instructions? is false" do
+        before do
+          WebMock.hide_stubbing_instructions!
+        end
+
+        it "should have message with request signature and snippet" do
+          allow(WebMock::RequestStub).to receive(:from_request_signature).and_return(request_stub)
+          allow(WebMock::StubRequestSnippet).to receive(:new).
+            with(request_stub).and_return(stub_result)
+
+          expected =  \
+            "Real HTTP connections are disabled. Unregistered request: #{request_signature}" \
+            "\n\n============================================================"
+          expect(WebMock::NetConnectNotAllowedError.new(request_signature).message).to eq(expected)
+        end
+
+        it "should have message with registered stubs if available" do
+          allow(WebMock::StubRegistry.instance).to receive(:request_stubs).and_return([request_stub])
+          allow(WebMock::RequestStub).to receive(:from_request_signature).and_return(request_stub)
+          allow(WebMock::StubRequestSnippet).to receive(:new).
+            with(request_stub).and_return(stub_result)
+          allow(request_stub).to receive(:request_pattern).and_return(body_pattern)
+
+          expected =  \
+            "Real HTTP connections are disabled. Unregistered request: #{request_signature}" \
+            "\n\nregistered request stubs:" \
+            "\n\n#{stub_result}" \
+            "\n\n============================================================"
+          expect(WebMock::NetConnectNotAllowedError.new(request_signature).message).to eq(expected)
+        end
       end
     end
+
+    let(:request_signature) { double(:request_signature, to_s: rand(10**20).to_s) }
+    let(:stub_result)       { double(:stub_result, to_s: rand(10**20).to_s) }
+    let(:request_stub)      { double(:request_stub) }
+    let(:body_pattern)      { double(:body_pattern, body_pattern: nil)}
+    let(:body_diff)         { [["+", "test", "test2"], ["-", "test3"], ["~", "test5", "test6"]] }
   end
 end

data/spec/unit/http_lib_adapters/http_lib_adapter_registry_spec.rb

@@ -9,7 +9,7 @@ describe WebMock::HttpLibAdapterRegistry do
       WebMock::HttpLibAdapterRegistry.instance.each_adapter {|n,a|
         adapters << [n, a]
       }
-      adapters.should include([:my_lib, MyAdapter])
+      expect(adapters).to include([:my_lib, MyAdapter])
       WebMock::HttpLibAdapterRegistry.instance.
         http_lib_adapters.delete(:my_lib)
     end

data/spec/unit/http_lib_adapters/http_lib_adapter_spec.rb

@@ -4,8 +4,8 @@ describe WebMock::HttpLibAdapter do
   describe "adapter_for" do
     it "should add adapter to adapter registry" do
       class MyAdapter < WebMock::HttpLibAdapter; end
-      WebMock::HttpLibAdapterRegistry.instance.
-        should_receive(:register).with(:my_lib, MyAdapter)
+      expect(WebMock::HttpLibAdapterRegistry.instance).
+        to receive(:register).with(:my_lib, MyAdapter)
       MyAdapter.adapter_for(:my_lib)
     end
   end

data/spec/unit/matchers/hash_excluding_matcher_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+module WebMock
+  module Matchers
+    describe HashExcludingMatcher do
+      it 'stringifies the given hash keys' do
+        expect(HashExcludingMatcher.new(a: 1, b: 2)).not_to eq('a' => 1, 'b' => 2)
+      end
+
+      it 'sorts elements in the hash' do
+        expect(HashExcludingMatcher.new(b: 2, a: 1)).not_to eq('a' => 1, 'b' => 2)
+      end
+
+      it 'describes itself properly' do
+        expect(HashExcludingMatcher.new(a: 1).inspect).to eq 'hash_excluding({"a"=>1})'
+      end
+
+      describe 'success' do
+        it 'match with hash with a missing key' do
+          expect(HashExcludingMatcher.new(a: 1)).to eq('b' => 2)
+        end
+
+        it 'match an empty hash with a given key' do
+          expect(HashExcludingMatcher.new(a: 1)).to eq({})
+        end
+
+        it 'match when values are nil but keys are different' do
+          expect(HashExcludingMatcher.new(a: nil)).to eq('b' => nil)
+        end
+
+        describe 'when matching an empty hash' do
+          it 'does not matches against any hash' do
+            expect(HashExcludingMatcher.new({})).to eq(a: 1, b: 2, c: 3)
+          end
+        end
+      end
+
+      describe 'failing' do
+        it 'does not match a hash with a one missing key when one pair is matching' do
+          expect(HashExcludingMatcher.new(a: 1, b: 2)).not_to eq('b' => 2)
+        end
+
+        it 'match a hash with an incorrect value' do
+          expect(HashExcludingMatcher.new(a: 1, b: 2)).not_to eq('a' => 1, 'b' => 3)
+        end
+
+        it 'does not matches the same hash' do
+          expect(HashExcludingMatcher.new('a' => 1, 'b' => 2)).not_to eq('a' => 1, 'b' => 2)
+        end
+
+        it 'does not matches a hash with extra stuff' do
+          expect(HashExcludingMatcher.new(a: 1)).not_to eq('a' => 1, 'b' => 2)
+        end
+
+        it 'does not match a non-hash' do
+          expect(HashExcludingMatcher.new(a: 1)).not_to eq 1
+        end
+      end
+    end
+  end
+end

data/spec/unit/matchers/hash_including_matcher_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+module WebMock
+  module Matchers
+
+    describe HashIncludingMatcher do
+
+      it "stringifies the given hash keys" do
+        expect(HashIncludingMatcher.new(a: 1, b: 2)).to eq("a" => 1, "b" => 2)
+      end
+
+      it "sorts elements in the hash" do
+        expect(HashIncludingMatcher.new(b: 2, a: 1)).to eq("a" => 1, "b" => 2)
+      end
+
+      it "describes itself properly" do
+        expect(HashIncludingMatcher.new(a: 1).inspect).to eq "hash_including({\"a\"=>1})"
+      end
+
+      describe "success" do
+        it "matches the same hash" do
+          expect(HashIncludingMatcher.new("a" => 1, "b" => 2)).to eq("a" => 1, "b" => 2)
+        end
+
+        it "matches a hash with extra stuff" do
+          expect(HashIncludingMatcher.new(a: 1)).to eq("a" => 1, "b" => 2)
+        end
+
+        describe "when matching anythingized keys" do
+          let(:anything) { WebMock::Matchers::AnyArgMatcher.new(nil) }
+
+          it "matches an int against anything()" do
+            expect(HashIncludingMatcher.new(a: anything, b: 2)).to eq({'a' => 1, 'b' => 2})
+          end
+
+          it "matches a string against anything()" do
+            expect(HashIncludingMatcher.new(a: anything, b: 2)).to eq({'a' => "1", 'b' => 2})
+          end
+
+          it "matches if the key is present" do
+            expect(HashIncludingMatcher.new(a: anything)).to eq({'a' => 1, 'b' => 2})
+          end
+
+          it "matches if more keys are present" do
+            expect(HashIncludingMatcher.new(a: anything, b: anything)).to eq({'a' => 1, 'b' => 2, 'c' => 3})
+          end
+
+          it "matches if passed many keys and many key/value pairs" do
+            expect(HashIncludingMatcher.new(a: anything, b: anything, c: 3, e: 5)).to eq({'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5})
+          end
+        end
+
+        describe "when matching an empty hash" do
+          it "matches against any hash" do
+            expect(HashIncludingMatcher.new({})).to eq({a: 1, b: 2, c: 3})
+          end
+        end
+      end
+
+      describe "failing" do
+        it "does not match a non-hash" do
+          expect(HashIncludingMatcher.new(a: 1)).not_to eq 1
+        end
+
+        it "does not match a hash with a missing key" do
+          expect(HashIncludingMatcher.new(a: 1)).not_to eq('b' => 2)
+        end
+
+        it "does not match an empty hash with a given key" do
+          expect(HashIncludingMatcher.new(a: 1)).not_to eq({})
+        end
+
+        it "does not match a hash with a missing key when one pair is matching" do
+          expect(HashIncludingMatcher.new(a: 1, b: 2)).not_to eq('b' => 2)
+        end
+
+        it "does not match a hash with an incorrect value" do
+          expect(HashIncludingMatcher.new(a: 1, b: 2)).not_to eq('a' => 1, 'b' => 3)
+        end
+
+        it "does not match when values are nil but keys are different" do
+          expect(HashIncludingMatcher.new(a: nil)).not_to eq('b' => nil)
+        end
+      end
+    end
+  end
+end

data/spec/unit/rack_response_spec.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 require 'spec_helper'
 
 describe WebMock::RackResponse do
@@ -9,26 +10,36 @@ describe WebMock::RackResponse do
     request = WebMock::RequestSignature.new(:get, 'www.example.com')
     response = @rack_response.evaluate(request)
 
-    response.status.first.should == 200
-    response.body.should include('This is my root!')
+    expect(response.status.first).to eq(200)
+    expect(response.body).to include('This is my root!')
+  end
+
+  it "should set the reason phrase based on the status code" do
+    request = WebMock::RequestSignature.new(:get, 'www.example.com')
+    response = @rack_response.evaluate(request)
+    expect(response.status).to eq([200, "OK"])
+
+    request = WebMock::RequestSignature.new(:get, 'www.example.com/error')
+    response = @rack_response.evaluate(request)
+    expect(response.status).to eq([500, "Internal Server Error"])
   end
 
   it "should behave correctly when the rack response is not a simple array of strings" do
     request = WebMock::RequestSignature.new(:get, 'www.example.com/non_array_response')
     response = @rack_response.evaluate(request)
 
-    response.status.first.should == 200
-    response.body.should include('This is not in an array!')
+    expect(response.status.first).to eq(200)
+    expect(response.body).to include('This is not in an array!')
   end
 
   it "should shouldn't blow up when hitting a locked resource twice" do
     @locked_rack_response = WebMock::RackResponse.new(MyLockedRackApp)
-    request   = WebMock::RequestSignature.new(:get, 'www.example.com/locked')
-    response  = @locked_rack_response.evaluate(request)
+    request = WebMock::RequestSignature.new(:get, 'www.example.com/locked')
+    @locked_rack_response.evaluate(request)
     response2 = @locked_rack_response.evaluate(request)
 
-    response2.body.should include('Single threaded response.')
-    response2.status.first.should == 200
+    expect(response2.body).to include('Single threaded response.')
+    expect(response2.status.first).to eq(200)
   end
 
   it "should send along params" do
@@ -36,17 +47,44 @@ describe WebMock::RackResponse do
 
     response = @rack_response.evaluate(request)
 
-    response.status.first.should == 200
-    response.body.should include('Hello, Johnny')
+    expect(response.status.first).to eq(200)
+    expect(response.body).to include('Hello, Johnny')
   end
 
   it "should send along POST params" do
     request = WebMock::RequestSignature.new(:post, 'www.example.com/greet',
-      :body => 'name=Jimmy'
+      body: 'name=Jimmy'
     )
 
     response = @rack_response.evaluate(request)
-    response.body.should include('Good to meet you, Jimmy!')
+    expect(response.body).to include('Good to meet you, Jimmy!')
+  end
+
+  it "should send params with proper content length if params have non-ascii symbols" do
+    request = WebMock::RequestSignature.new(:post, 'www.example.com/greet',
+      body: 'name=Олег'
+    )
+
+    response = @rack_response.evaluate(request)
+    expect(response.body).to include('Good to meet you, Олег!')
+  end
+
+  describe 'rack error output' do
+    before :each do
+      @original_stderr = $stderr
+      $stderr = StringIO.new
+    end
+
+    after :each do
+      $stderr = @original_stderr
+    end
+
+    it 'should behave correctly when an app uses rack.errors' do
+      request = WebMock::RequestSignature.new(:get, 'www.example.com/error')
+
+      expect { @rack_response.evaluate(request) }.to_not raise_error
+      expect($stderr.length).to_not eq 0
+    end
   end
 
   describe 'basic auth request' do
@@ -60,15 +98,15 @@ describe WebMock::RackResponse do
     it 'should be failure when wrong credentials' do
       request = WebMock::RequestSignature.new(:get, 'foo:bar@www.example.com')
       response = @rack_response_with_basic_auth.evaluate(request)
-      response.status.first.should == 401
-      response.body.should_not include('This is my root!')
+      expect(response.status.first).to eq(401)
+      expect(response.body).not_to include('This is my root!')
     end
 
     it 'should be success when valid credentials' do
       request = WebMock::RequestSignature.new(:get, 'username:password@www.example.com')
       response = @rack_response_with_basic_auth.evaluate(request)
-      response.status.first.should == 200
-      response.body.should include('This is my root!')
+      expect(response.status.first).to eq(200)
+      expect(response.body).to include('This is my root!')
     end
   end
 end

data/spec/unit/request_body_diff_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+RSpec.describe WebMock::RequestBodyDiff do
+  subject { WebMock::RequestBodyDiff.new(request_signature, request_stub) }
+
+  let(:uri) { "http://example.com" }
+  let(:method) { "GET" }
+
+  let(:request_stub) { WebMock::RequestStub.new(method, uri) }
+  let(:request_signature) { WebMock::RequestSignature.new(method, uri) }
+
+  let(:request_stub_body) { { "key" => "value"} }
+  let(:request_signature_body) { {"key" => "different value"}.to_json }
+
+  let(:request_pattern) {
+    WebMock::RequestPattern.new(
+      method, uri, {body: request_stub_body}
+    )
+  }
+
+  before :each do
+    request_stub.request_pattern = request_pattern
+    request_signature.headers = {"Content-Type" => "application/json"}
+    request_signature.body = request_signature_body
+  end
+
+  describe "#body_diff" do
+    context "request signature is unparseable json" do
+      let(:request_signature_body) { "youcan'tparsethis!" }
+
+      it "returns an empty hash" do
+        expect(subject.body_diff).to eq({})
+      end
+    end
+
+    context "request stub body as unparseable json" do
+      let(:request_stub_body) { "youcan'tparsethis!" }
+
+      it "returns an empty hash" do
+        expect(subject.body_diff).to eq({})
+      end
+    end
+
+    context "request stub body pattern is hash" do
+      let(:request_stub_body) { { "key" => "value"} }
+
+      it "generates a diff" do
+        expect(subject.body_diff).to eq(
+          [["~", "key", "different value", "value"]]
+        )
+      end
+    end
+
+    context "request signature doesn't have json headers" do
+      before :each do
+        request_signature.headers = {"Content-Type" => "application/xml"}
+      end
+
+      it "returns an empty hash" do
+        expect(subject.body_diff).to eq({})
+      end
+    end
+
+    context "request stub body pattern is a string" do
+      let(:request_stub_body) { { "key" => "value"}.to_json }
+
+      it "generates a diff" do
+        expect(subject.body_diff).to eq(
+          [["~", "key", "different value", "value"]]
+        )
+      end
+    end
+
+    context "stub request has no request pattern" do
+      let(:request_signature_body) { nil }
+
+      it "returns an empty hash" do
+        expect(subject.body_diff).to eq({})
+      end
+    end
+
+    context "stub request has no body pattern" do
+      let(:request_stub_body) { nil }
+
+      it "returns an empty hash" do
+        expect(subject.body_diff).to eq({})
+      end
+    end
+  end
+end