webmock 3.0.1 → 3.20.0

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_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

data/spec/unit/request_execution_verifier_spec.rb

@@ -1,208 +0,0 @@
-require 'spec_helper'
-
-describe WebMock::RequestExecutionVerifier do
-  before(:each) do
-    @verifier = WebMock::RequestExecutionVerifier.new
-    @request_pattern = double(WebMock::RequestPattern, to_s: "www.example.com")
-    @verifier.request_pattern = @request_pattern
-    allow(WebMock::RequestRegistry.instance).to receive(:to_s).and_return("executed requests")
-    @executed_requests_info = "\n\nThe following requests were made:\n\nexecuted requests\n" + "="*60
-  end
-
-  describe "description" do
-
-    it "reports the description" do
-      @verifier.expected_times_executed = 2
-      expect(@verifier.description).to eq "request www.example.com 2 times"
-    end
-
-    it "reports description correctly when expectation is 1 time" do
-      @verifier.expected_times_executed = 1
-      expect(@verifier.description).to eq "request www.example.com 1 time"
-    end
-
-    context "at_least_times_executed is set" do
-      it "reports description correctly when expectation at least 2 times" do
-        @verifier.at_least_times_executed = 2
-        expect(@verifier.description).to eq "request www.example.com at least 2 times"
-      end
-
-      it "reports description correctly when expectation is at least 3 times" do
-        @verifier.at_least_times_executed = 3
-        expect(@verifier.description).to eq "request www.example.com at least 3 times"
-      end
-    end
-
-    context "at_most_times_executed is set" do
-      it "reports description correctly when expectation is at most 2 times" do
-        @verifier.at_most_times_executed = 2
-        expect(@verifier.description).to eq "request www.example.com at most 2 times"
-      end
-
-      it "reports description correctly when expectation is at most 1 time" do
-        @verifier.at_most_times_executed = 1
-        expect(@verifier.description).to eq "request www.example.com at most 1 time"
-      end
-    end
-
-  end
-
-  describe "failure message" do
-
-    it "reports the failure message" do
-      @verifier.times_executed = 0
-      @verifier.expected_times_executed = 2
-      expected_text = "The request www.example.com was expected to execute 2 times but it executed 0 times"
-      expected_text << @executed_requests_info
-      expect(@verifier.failure_message).to eq(expected_text)
-    end
-
-    it "reports failure message correctly when executed times is one" do
-      @verifier.times_executed = 1
-      @verifier.expected_times_executed = 1
-      expected_text = "The request www.example.com was expected to execute 1 time but it executed 1 time"
-      expected_text << @executed_requests_info
-      expect(@verifier.failure_message).to eq(expected_text)
-    end
-
-    context "at_least_times_executed is set" do
-      it "reports failure message correctly when executed times is one" do
-        @verifier.times_executed = 1
-        @verifier.at_least_times_executed = 2
-        expected_text = "The request www.example.com was expected to execute at least 2 times but it executed 1 time"
-        expected_text << @executed_requests_info
-        expect(@verifier.failure_message).to eq(expected_text)
-      end
-
-      it "reports failure message correctly when executed times is two" do
-        @verifier.times_executed = 2
-        @verifier.at_least_times_executed = 3
-        expected_text = "The request www.example.com was expected to execute at least 3 times but it executed 2 times"
-        expected_text << @executed_requests_info
-        expect(@verifier.failure_message).to eq(expected_text)
-      end
-    end
-
-    context "at_most_times_executed is set" do
-      it "reports failure message correctly when executed times is three" do
-        @verifier.times_executed = 3
-        @verifier.at_most_times_executed = 2
-        expected_text = "The request www.example.com was expected to execute at most 2 times but it executed 3 times"
-        expected_text << @executed_requests_info
-        expect(@verifier.failure_message).to eq(expected_text)
-      end
-
-      it "reports failure message correctly when executed times is two" do
-        @verifier.times_executed = 2
-        @verifier.at_most_times_executed = 1
-        expected_text = "The request www.example.com was expected to execute at most 1 time but it executed 2 times"
-        expected_text << @executed_requests_info
-        expect(@verifier.failure_message).to eq(expected_text)
-      end
-    end
-  end
-
-  describe "negative failure message" do
-
-    it "reports failure message if it executed number of times specified" do
-      @verifier.times_executed = 2
-      @verifier.expected_times_executed = 2
-      expected_text = "The request www.example.com was not expected to execute 2 times but it executed 2 times"
-      expected_text << @executed_requests_info
-      expect(@verifier.failure_message_when_negated).to eq(expected_text)
-    end
-
-    it "reports failure message when not expected request but it executed" do
-      @verifier.times_executed = 1
-      expected_text = "The request www.example.com was not expected to execute but it executed 1 time"
-      expected_text << @executed_requests_info
-      expect(@verifier.failure_message_when_negated).to eq(expected_text)
-    end
-
-    context "at_least_times_executed is set" do
-      it "reports failure message correctly when executed times is one" do
-        @verifier.times_executed = 3
-        @verifier.at_least_times_executed = 2
-        expected_text = "The request www.example.com was not expected to execute at least 2 times but it executed 3 times"
-        expected_text << @executed_requests_info
-        expect(@verifier.failure_message_when_negated).to eq(expected_text)
-      end
-
-      it "reports failure message correctly when executed times is two" do
-        @verifier.times_executed = 2
-        @verifier.at_least_times_executed = 2
-        expected_text = "The request www.example.com was not expected to execute at least 2 times but it executed 2 times"
-        expected_text << @executed_requests_info
-        expect(@verifier.failure_message_when_negated).to eq(expected_text)
-      end
-    end
-
-    context "at_most_times_executed is set" do
-      it "reports failure message correctly when executed times is three" do
-        @verifier.times_executed = 2
-        @verifier.at_most_times_executed = 3
-        expected_text = "The request www.example.com was not expected to execute at most 3 times but it executed 2 times"
-        expected_text << @executed_requests_info
-        expect(@verifier.failure_message_when_negated).to eq(expected_text)
-      end
-
-      it "reports failure message correctly when executed times is one" do
-        @verifier.times_executed = 1
-        @verifier.at_most_times_executed = 2
-        expected_text = "The request www.example.com was not expected to execute at most 2 times but it executed 1 time"
-        expected_text << @executed_requests_info
-        expect(@verifier.failure_message_when_negated).to eq(expected_text)
-      end
-    end
-
-  end
-
-  describe "matches?" do
-
-    it "succeeds if request was executed expected number of times" do
-      expect(WebMock::RequestRegistry.instance).
-        to receive(:times_executed).with(@request_pattern).and_return(10)
-      @verifier.expected_times_executed = 10
-      expect(@verifier.matches?).to be_truthy
-    end
-
-    it "fails if request was not executed expected number of times" do
-      expect(WebMock::RequestRegistry.instance).
-        to receive(:times_executed).with(@request_pattern).and_return(10)
-      @verifier.expected_times_executed = 5
-      expect(@verifier.matches?).to be_falsey
-    end
-
-  end
-
-  describe "does_not_match?" do
-
-    it "fails if request executed expected number of times" do
-      expect(WebMock::RequestRegistry.instance).
-        to receive(:times_executed).with(@request_pattern).and_return(10)
-      @verifier.expected_times_executed = 10
-      expect(@verifier.does_not_match?).to be_falsey
-    end
-
-    it "succeeds if request was not executed at all and expected number of times was not set" do
-      expect(WebMock::RequestRegistry.instance).
-        to receive(:times_executed).with(@request_pattern).and_return(0)
-      expect(@verifier.does_not_match?).to be_truthy
-    end
-
-    it "fails if request was executed and expected number of times was not set" do
-      expect(WebMock::RequestRegistry.instance).
-        to receive(:times_executed).with(@request_pattern).and_return(1)
-      expect(@verifier.does_not_match?).to be_falsey
-    end
-
-    it "succeeds if request was not executed expected number of times" do
-      expect(WebMock::RequestRegistry.instance).
-        to receive(:times_executed).with(@request_pattern).and_return(10)
-      @verifier.expected_times_executed = 5
-      expect(@verifier.does_not_match?).to be_truthy
-    end
-
-  end
-
-end