webmock 3.14.0 → 3.24.0

data/spec/unit/api_spec.rb

@@ -1,175 +0,0 @@
-require 'spec_helper'
-
-describe WebMock::API do
-  describe '#hash_including' do
-    subject { klass.new.hash_including(args) }
-    let(:args) { { data: :one } }
-
-    context 'when mixed into a class that does not define `hash_including`' do
-      let(:klass) do
-        Class.new do
-          include WebMock::API
-        end
-      end
-
-      it 'uses WebMock::Matchers::HashIncludingMatcher' do
-        expect(subject).to be_a(WebMock::Matchers::HashIncludingMatcher)
-      end
-
-      #  by testing equality for HashIncludingMatcher (which stringifies the passed hash) we are
-      #  testing HashIncludingMatcher.initialize behavior as well
-      context "when args correspond to an hash" do
-        it "creates 'HashIncludingMatcher'" do
-          expect(subject).to eq("data" => :one)
-        end
-      end
-
-      context "when args are one or many keys" do
-        subject {klass.new.hash_including(:foo, :bar)}
-        let(:anything) { WebMock::Matchers::AnyArgMatcher.new(nil) }
-
-        it "creates 'HashIncludingMatcher' with keys anythingized" do
-          expect(subject).to eq("foo" => anything, "bar" => anything )
-        end
-      end
-
-      context "when args are both keys and key/value pairs" do
-        subject {klass.new.hash_including(:foo, :bar, data: :one)}
-        let(:anything) { WebMock::Matchers::AnyArgMatcher.new(nil) }
-
-        it "creates 'HashIncludingMatcher' with keys anythingized" do
-          expect(subject).to eq("foo" => anything, "bar" => anything, "data" => :one)
-        end
-      end
-
-      context "when args are an empty hash" do
-        subject {klass.new.hash_including({})}
-
-        it "creates 'HashIncludingMatcher' with an empty hash" do
-          expect(subject).to eq({})
-        end
-      end
-    end
-
-
-    context 'when mixed into a class with a parent that defines `hash_including`' do
-      subject { klass.new.hash_including(*args) }
-      let(:args) { %w(:foo, :bar, {:data => :one}) }
-      let(:klass) do
-        Class.new(
-          Class.new do
-            def hash_including(*args)
-              args
-            end
-          end
-        ) { include WebMock::API }
-      end
-
-      it 'uses super and passes the args untampered' do
-        expect(subject).to eq(args)
-      end
-    end
-  end
-
-  describe '#hash_excluding' do
-    subject { klass.new.hash_excluding(args) }
-    let(:args) { { data: :one } }
-
-    context 'when mixed into a class that does not define `hash_including`' do
-      let(:klass) do
-        Class.new do
-          include WebMock::API
-        end
-      end
-
-      it 'uses WebMock::Matchers::HashIncludingMatcher' do
-        expect(subject).to be_a(WebMock::Matchers::HashExcludingMatcher)
-      end
-
-      #  by testing equality for HashIncludingMatcher (which stringifies the passed hash) we are
-      #  testing HashIncludingMatcher.initialize behavior as well
-      context 'when args correspond to an hash' do
-        context 'creates "HashExcludingMatcher"' do
-          it 'equals hash with similar key but different value' do
-            expect(subject).to eq('data' => :two)
-          end
-
-          it 'equals hash with similar value but different key' do
-            expect(subject).to eq('data2' => :one)
-          end
-
-          it 'equals hash with defferent value and key' do
-            expect(subject).to eq('data2' => :two)
-          end
-
-          it 'not equals with similar value and key' do
-            expect(subject).not_to eq('data' => :one)
-          end
-        end
-      end
-
-      context 'when args are one or many keys' do
-        subject { klass.new.hash_excluding(:foo, :bar) }
-        let(:anything) { WebMock::Matchers::AnyArgMatcher.new(nil) }
-
-        it "creates 'HashExcludingMatcher' with keys anythingized" do
-          expect(subject).not_to eq('foo' => anything, 'bar' => anything )
-        end
-      end
-
-      context 'when args are both keys and key/value pairs' do
-        subject { klass.new.hash_excluding(:foo, :bar, data: :one) }
-        let(:anything) { WebMock::Matchers::AnyArgMatcher.new(nil) }
-
-        it 'creates "HashExcludingMatcher" with keys anythingized' do
-          expect(subject).not_to eq('foo' => anything, 'bar' => anything, 'data' => :one)
-        end
-      end
-
-      context 'when args are an empty hash' do
-        subject { klass.new.hash_excluding({}) }
-
-        it 'creates "HashExcludingMatcher" with an empty hash' do
-          expect(subject).to eq({})
-        end
-      end
-    end
-
-    context 'when mixed into a class with a parent that defines `hash_excluding`' do
-      subject { klass.new.hash_excluding(*args) }
-      let(:args) { %w(:foo, :bar, {:data => :one}) }
-      let(:klass) do
-        Class.new(
-          Class.new do
-            def hash_excluding(*args)
-              args
-            end
-          end
-        ) { include WebMock::API }
-      end
-
-      it 'uses super and passes the args untampered' do
-        expect(subject).to eq(args)
-      end
-    end
-  end
-
-  describe '#reset_executed_requests!' do
-    subject {  WebMock::API.reset_executed_requests! }
-
-    let(:request_signature) { WebMock::RequestSignature.new(:get, "www.example.com") }
-    let(:request_pattern)   { WebMock::RequestPattern.new(:get, "www.example.com") }
-
-    before do
-      WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
-    end
-
-    it 'resets request registry counter' do
-      expect{
-        subject
-      }.to change{
-        WebMock::RequestRegistry.instance.times_executed(request_pattern)
-      }.from(1).to(0)
-    end
-  end
-end

data/spec/unit/errors_spec.rb

@@ -1,129 +0,0 @@
-require 'spec_helper'
-
-describe "errors" do
-  describe WebMock::NetConnectNotAllowedError do
-    describe "message" do
-      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\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
-        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

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-describe WebMock::HttpLibAdapterRegistry do
-  describe "each_adapter" do
-    it "should yield block over each adapter" do
-      class MyAdapter < WebMock::HttpLibAdapter; end
-      WebMock::HttpLibAdapterRegistry.instance.register(:my_lib, MyAdapter)
-      adapters = []
-      WebMock::HttpLibAdapterRegistry.instance.each_adapter {|n,a|
-        adapters << [n, a]
-      }
-      expect(adapters).to include([:my_lib, MyAdapter])
-      WebMock::HttpLibAdapterRegistry.instance.
-        http_lib_adapters.delete(:my_lib)
-    end
-  end
-end

data/spec/unit/http_lib_adapters/http_lib_adapter_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-
-describe WebMock::HttpLibAdapter do
-  describe "adapter_for" do
-    it "should add adapter to adapter registry" do
-      class MyAdapter < WebMock::HttpLibAdapter; end
-      expect(WebMock::HttpLibAdapterRegistry.instance).
-        to receive(:register).with(:my_lib, MyAdapter)
-      MyAdapter.adapter_for(:my_lib)
-    end
-  end
-end

data/spec/unit/matchers/hash_excluding_matcher_spec.rb

@@ -1,61 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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,112 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-describe WebMock::RackResponse do
-  before :each do
-    @rack_response = WebMock::RackResponse.new(MyRackApp)
-  end
-
-  it "should hook up to a rack appliance" do
-    request = WebMock::RequestSignature.new(:get, 'www.example.com')
-    response = @rack_response.evaluate(request)
-
-    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)
-
-    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')
-    @locked_rack_response.evaluate(request)
-    response2 = @locked_rack_response.evaluate(request)
-
-    expect(response2.body).to include('Single threaded response.')
-    expect(response2.status.first).to eq(200)
-  end
-
-  it "should send along params" do
-    request = WebMock::RequestSignature.new(:get, 'www.example.com/greet?name=Johnny')
-
-    response = @rack_response.evaluate(request)
-
-    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'
-    )
-
-    response = @rack_response.evaluate(request)
-    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
-    before :each do
-      @rack_response_with_basic_auth = WebMock::RackResponse.new(
-        Rack::Auth::Basic.new(MyRackApp) do |username, password|
-          username == 'username' && password == 'password'
-        end
-      )
-    end
-    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)
-      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)
-      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

@@ -1,90 +0,0 @@
-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