vagrant-unbundled 2.0.0.1 → 2.0.1.0

data/vendor/bundle/ruby/2.4.0/gems/webmock-2.3.2/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

data/vendor/bundle/ruby/2.4.0/gems/webmock-2.3.2/spec/unit/request_execution_verifier_spec.rb

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

data/vendor/bundle/ruby/2.4.0/gems/webmock-2.3.2/spec/unit/request_pattern_spec.rb

@@ -0,0 +1,590 @@
+require 'spec_helper'
+
+describe WebMock::RequestPattern do
+
+  describe "describing itself" do
+    it "should report string describing itself" do
+      expect(WebMock::RequestPattern.new(:get, "www.example.com",
+      body: "abc", headers: {'A' => 'a', 'B' => 'b'}).to_s).to eq(
+        "GET http://www.example.com/ with body \"abc\" with headers {'A'=>'a', 'B'=>'b'}"
+      )
+    end
+
+    it "should report string describing itself with block" do
+      expect(WebMock::RequestPattern.new(:get, "www.example.com",
+      body: "abc", headers: {'A' => 'a', 'B' => 'b'}).with {|req| true}.to_s).to eq(
+        "GET http://www.example.com/ with body \"abc\" with headers {'A'=>'a', 'B'=>'b'} with given block"
+      )
+    end
+
+    it "should report string describing itself with query params" do
+      expect(WebMock::RequestPattern.new(:get, /.*example.*/, query: {'a' => ['b', 'c']}).to_s).to eq(
+        "GET /.*example.*/ with query params {\"a\"=>[\"b\", \"c\"]}"
+      )
+    end
+
+    it "should report string describing itself with query params as hash including matcher" do
+      expect(WebMock::RequestPattern.new(:get, /.*example.*/,
+      query: WebMock::Matchers::HashIncludingMatcher.new({'a' => ['b', 'c']})).to_s).to eq(
+        "GET /.*example.*/ with query params hash_including({\"a\"=>[\"b\", \"c\"]})"
+      )
+    end
+
+    it "should report string describing itself with body as hash including matcher" do
+      expect(WebMock::RequestPattern.new(:get, /.*example.*/,
+      body: WebMock::Matchers::HashIncludingMatcher.new({'a' => ['b', 'c']})).to_s).to eq(
+        "GET /.*example.*/ with body hash_including({\"a\"=>[\"b\", \"c\"]})"
+      )
+    end
+  end
+
+  describe "with" do
+    before(:each) do
+      @request_pattern =WebMock::RequestPattern.new(:get, "www.example.com")
+    end
+
+    it "should have assigned body pattern" do
+      @request_pattern.with(body: "abc")
+      expect(@request_pattern.to_s).to eq(WebMock::RequestPattern.new(:get, "www.example.com", body: "abc").to_s)
+    end
+
+    it "should have assigned normalized headers pattern" do
+      @request_pattern.with(headers: {'A' => 'a'})
+      expect(@request_pattern.to_s).to eq(WebMock::RequestPattern.new(:get, "www.example.com", headers: {'A' => 'a'}).to_s)
+    end
+
+    it "should raise an error if options passed to `with` are invalid" do
+      expect { @request_pattern.with(foo: "bar") }.to raise_error('Unknown key: "foo". Valid keys are: "body", "headers", "query", "basic_auth"')
+    end
+
+    it "should raise an error if neither options or block is provided" do
+      expect { @request_pattern.with() }.to raise_error('#with method invoked with no arguments. Either options hash or block must be specified.')
+    end
+  end
+
+
+  class WebMock::RequestPattern
+    def match(request_signature)
+      self.matches?(request_signature)
+    end
+  end
+
+  describe "when matching" do
+
+    it "should match if uri matches and method matches" do
+      expect(WebMock::RequestPattern.new(:get, "www.example.com")).
+        to match(WebMock::RequestSignature.new(:get, "www.example.com"))
+    end
+
+    it "should match if uri matches and method pattern is any" do
+      expect(WebMock::RequestPattern.new(:any, "www.example.com")).
+        to match(WebMock::RequestSignature.new(:get, "www.example.com"))
+    end
+
+    it "should not match if request has different method" do
+      expect(WebMock::RequestPattern.new(:post, "www.example.com")).
+        not_to match(WebMock::RequestSignature.new(:get, "www.example.com"))
+    end
+
+    it "should match if uri matches request uri" do
+      expect(WebMock::RequestPattern.new(:get, "www.example.com")).
+        to match(WebMock::RequestSignature.new(:get, "www.example.com"))
+    end
+
+    it "should match if request has unescaped uri" do
+      expect(WebMock::RequestPattern.new(:get, "www.example.com/my%20path")).
+        to match(WebMock::RequestSignature.new(:get, "www.example.com/my path"))
+    end
+
+    it "should match if request has escaped uri" do
+      expect(WebMock::RequestPattern.new(:get, "www.example.com/my path")).
+        to match(WebMock::RequestSignature.new(:get, "www.example.com/my%20path"))
+    end
+
+    it "should match if uri regexp pattern matches unescaped form of request uri" do
+      expect(WebMock::RequestPattern.new(:get, /.*my path.*/)).
+        to match(WebMock::RequestSignature.new(:get, "www.example.com/my%20path"))
+    end
+
+    it "should match if uri regexp pattern matches request uri" do
+      expect(WebMock::RequestPattern.new(:get, /.*example.*/)).
+        to match(WebMock::RequestSignature.new(:get, "www.example.com"))
+    end
+
+    it "should match if uri Addressable::Template pattern matches unescaped form of request uri" do
+      expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com/{any_path}"))).
+        to match(WebMock::RequestSignature.new(:get, "www.example.com/my%20path"))
+    end
+
+    it "should match if uri Addressable::Template pattern matches request uri" do
+      expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com"))).
+        to match(WebMock::RequestSignature.new(:get, "www.example.com"))
+    end
+
+    it "should match for uris with same parameters as pattern" do
+      expect(WebMock::RequestPattern.new(:get, "www.example.com?a=1&b=2")).
+        to match(WebMock::RequestSignature.new(:get, "www.example.com?a=1&b=2"))
+    end
+
+    it "should not match for uris with different parameters" do
+      expect(WebMock::RequestPattern.new(:get, "www.example.com?a=1&b=2")).
+        not_to match(WebMock::RequestSignature.new(:get, "www.example.com?a=2&b=1"))
+    end
+
+    it "should match for uri parameters in different order" do
+      expect(WebMock::RequestPattern.new(:get, "www.example.com?b=2&a=1")).
+        to match(WebMock::RequestSignature.new(:get, "www.example.com?a=1&b=2"))
+    end
+
+    describe "when parameters are escaped" do
+
+      it "should match if uri pattern has escaped parameters and request has unescaped parameters" do
+        expect(WebMock::RequestPattern.new(:get, "www.example.com/?a=a%20b")).
+          to match(WebMock::RequestSignature.new(:get, "www.example.com/?a=a b"))
+      end
+
+      it "should match if uri pattern has unescaped parameters and request has escaped parameters" do
+        expect(WebMock::RequestPattern.new(:get, "www.example.com/?a=a b")).
+          to match(WebMock::RequestSignature.new(:get, "www.example.com/?a=a%20b"))
+      end
+
+      it "should match if uri regexp pattern matches uri with unescaped parameters and request has escaped parameters" do
+        expect(WebMock::RequestPattern.new(:get, /.*a=a b.*/)).
+          to match(WebMock::RequestSignature.new(:get, "www.example.com/?a=a%20b"))
+      end
+
+      it "should match if uri regexp pattern matches uri with escaped parameters and request has unescaped parameters"  do
+        expect(WebMock::RequestPattern.new(:get, /.*a=a%20b.*/)).
+          to match(WebMock::RequestSignature.new(:get, "www.example.com/?a=a b"))
+      end
+
+      it "should match if uri Addressable::Template pattern matches uri without parameter value and request has escaped parameters" do
+        expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com/{?a}"))).
+          to match(WebMock::RequestSignature.new(:get, "www.example.com/?a=a%20b"))
+      end
+
+      it "should match if uri Addressable::Template pattern matches uri without parameter value and request has unescaped parameters"  do
+        expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com/{?a}"))).
+          to match(WebMock::RequestSignature.new(:get, "www.example.com/?a=a b"))
+      end
+
+      it "should match if uri Addressable::Template pattern matches uri with unescaped parameter value and request has unescaped parameters"  do
+        expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com/?a=a b"))).
+          to match(WebMock::RequestSignature.new(:get, "www.example.com/?a=a b"))
+      end
+
+      it "should match if uri Addressable::Template pattern matches uri with escaped parameter value and request has escaped parameters"  do
+        expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com/?a=a%20b"))).
+          to match(WebMock::RequestSignature.new(:get, "www.example.com/?a=a%20b"))
+      end
+
+    end
+
+    describe "when matching requests on query params" do
+
+      describe "when uri is described as regexp" do
+        it "should match request query params" do
+          expect(WebMock::RequestPattern.new(:get, /.*example.*/, query: {"a" => ["b", "c"]})).
+            to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c"))
+        end
+
+        it "should match request query params if params don't match" do
+          expect(WebMock::RequestPattern.new(:get, /.*example.*/, query: {"x" => ["b", "c"]})).
+            not_to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c"))
+        end
+
+        it "should match when query params are declared as HashIncluding matcher matching params" do
+          expect(WebMock::RequestPattern.new(:get, /.*example.*/,
+          query: WebMock::Matchers::HashIncludingMatcher.new({"a" => ["b", "c"]}))).
+            to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
+        end
+
+        it "should not match when query params are declared as HashIncluding matcher not matching params" do
+          expect(WebMock::RequestPattern.new(:get, /.*example.*/,
+          query: WebMock::Matchers::HashIncludingMatcher.new({"x" => ["b", "c"]}))).
+            not_to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
+        end
+
+        it "should match when query params are declared as RSpec HashIncluding matcher matching params" do
+          expect(WebMock::RequestPattern.new(:get, /.*example.*/,
+          query: RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({"a" => ["b", "c"]}))).
+            to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
+        end
+
+        it "should not match when query params are declared as RSpec HashIncluding matcher not matching params" do
+          expect(WebMock::RequestPattern.new(:get, /.*example.*/,
+          query: RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({"a" => ["b", "d"]}))).
+            not_to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
+        end
+      end
+
+      describe "when uri is described as Addressable::Template" do
+        it "should raise error if query params are specified" do
+          expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com"), query: {"a" => ["b", "c"]})).
+            to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c"))
+        end
+
+        it "should match request query params if params don't match" do
+          expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com"), query: {"x" => ["b", "c"]})).
+            not_to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c"))
+        end
+
+        it "should match when query params are declared as HashIncluding matcher matching params" do
+          expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com"),
+          query: WebMock::Matchers::HashIncludingMatcher.new({"a" => ["b", "c"]}))).
+            to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
+        end
+
+        it "should not match when query params are declared as HashIncluding matcher not matching params" do
+          expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com"),
+          query: WebMock::Matchers::HashIncludingMatcher.new({"x" => ["b", "c"]}))).
+            not_to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
+        end
+
+        it "should match when query params are declared as RSpec HashIncluding matcher matching params" do
+          expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com"),
+          query: RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({"a" => ["b", "c"]}))).
+            to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
+        end
+
+        it "should not match when query params are declared as RSpec HashIncluding matcher not matching params" do
+          expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com"),
+          query: RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({"a" => ["b", "d"]}))).
+            not_to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
+        end
+      end
+
+      describe "when uri is described as string" do
+        it "should match when query params are the same as declared in hash" do
+          expect(WebMock::RequestPattern.new(:get, "www.example.com", query: {"a" => ["b", "c"]})).
+            to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c"))
+        end
+
+        it "should not match when query params are different than the declared in hash" do
+          expect(WebMock::RequestPattern.new(:get, "www.example.com", query: {"a" => ["b", "c"]})).
+            not_to match(WebMock::RequestSignature.new(:get, "www.example.com?x[]=b&a[]=c"))
+        end
+
+        it "should match when query params are the same as declared as string" do
+          expect(WebMock::RequestPattern.new(:get, "www.example.com", query: "a[]=b&a[]=c")).
+            to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c"))
+        end
+
+        it "should match when query params are the same as declared both in query option or url" do
+          expect(WebMock::RequestPattern.new(:get, "www.example.com/?x=3", query: "a[]=b&a[]=c")).
+            to match(WebMock::RequestSignature.new(:get, "www.example.com/?x=3&a[]=b&a[]=c"))
+        end
+
+        it "should match when query params are declared as HashIncluding matcher matching params" do
+          expect(WebMock::RequestPattern.new(:get, "www.example.com",
+          query: WebMock::Matchers::HashIncludingMatcher.new({"a" => ["b", "c"]}))).
+            to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
+        end
+
+        it "should not match when query params are declared as HashIncluding matcher not matching params" do
+          expect(WebMock::RequestPattern.new(:get, "www.example.com",
+          query: WebMock::Matchers::HashIncludingMatcher.new({"x" => ["b", "c"]}))).
+            not_to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
+        end
+
+        it "should match when query params are declared as RSpec HashIncluding matcher matching params" do
+          expect(WebMock::RequestPattern.new(:get, "www.example.com",
+          query: RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({"a" => ["b", "c"]}))).
+            to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
+        end
+
+        it "should not match when query params are declared as RSpec HashIncluding matcher not matching params" do
+          expect(WebMock::RequestPattern.new(:get, "www.example.com",
+          query: RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({"a" => ["b", "d"]}))).
+            not_to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
+        end
+
+        context "when using query values notation as flat array" do
+          before :all do
+            WebMock::Config.instance.query_values_notation = :flat_array
+          end
+
+          it "should not match when repeated query params are not the same as declared as string" do
+            expect(WebMock::RequestPattern.new(:get, "www.example.com", query: "a=b&a=c")).
+              to match(WebMock::RequestSignature.new(:get, "www.example.com?a=b&a=c"))
+          end
+
+          after :all do
+            WebMock::Config.instance.query_values_notation = nil
+          end
+        end
+      end
+    end
+
+    describe "when matching requests with body" do
+
+      it "should match if request body and body pattern are the same" do
+        expect(WebMock::RequestPattern.new(:get, "www.example.com", body: "abc")).
+          to match(WebMock::RequestSignature.new(:get, "www.example.com", body: "abc"))
+      end
+
+      it "should match if request body matches regexp" do
+        expect(WebMock::RequestPattern.new(:get, "www.example.com", body: /^abc$/)).
+          to match(WebMock::RequestSignature.new(:get, "www.example.com", body: "abc"))
+      end
+
+      it "should not match if body pattern is different than request body" do
+        expect(WebMock::RequestPattern.new(:get, "www.example.com", body: "def")).
+          not_to match(WebMock::RequestSignature.new(:get, "www.example.com", body: "abc"))
+      end
+
+      it "should not match if request body doesn't match regexp pattern" do
+        expect(WebMock::RequestPattern.new(:get, "www.example.com", body: /^abc$/)).
+          not_to match(WebMock::RequestSignature.new(:get, "www.example.com", body: "xabc"))
+      end
+
+      it "should match if pattern doesn't have specified body" do
+        expect(WebMock::RequestPattern.new(:get, "www.example.com")).
+          to match(WebMock::RequestSignature.new(:get, "www.example.com", body: "abc"))
+      end
+
+      it "should not match if pattern has body specified as nil but request body is not empty" do
+        expect(WebMock::RequestPattern.new(:get, "www.example.com", body: nil)).
+          not_to match(WebMock::RequestSignature.new(:get, "www.example.com", body: "abc"))
+      end
+
+      it "should not match if pattern has empty body but request body is not empty" do
+        expect(WebMock::RequestPattern.new(:get, "www.example.com", body: "")).
+          not_to match(WebMock::RequestSignature.new(:get, "www.example.com", body: "abc"))
+      end
+
+      it "should not match if pattern has body specified but request has no body" do
+        expect(WebMock::RequestPattern.new(:get, "www.example.com", body: "abc")).
+          not_to match(WebMock::RequestSignature.new(:get, "www.example.com"))
+      end
+
+      describe "when body in pattern is declared as a hash" do
+        let(:body_hash) { {:a => '1', :b => 'five', 'c' => {'d' => ['e', 'f']}} }
+
+        describe "for request with url encoded 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", body: 'a=1&c[d][]=e&c[d][]=f&b=five'))
+          end
+
+          it "should match when hash matches body in different order of params" do
+            expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: body_hash)).
+              to match(WebMock::RequestSignature.new(:post, "www.example.com", body: 'a=1&c[d][]=e&b=five&c[d][]=f'))
+          end
+
+          it "should not match when hash doesn't match url encoded body" do
+            expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: body_hash)).
+              not_to match(WebMock::RequestSignature.new(:post, "www.example.com", body: 'c[d][]=f&a=1&c[d][]=e'))
+          end
+
+          it "should not match when body is not url encoded" do
+            expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: body_hash)).
+              not_to match(WebMock::RequestSignature.new(:post, "www.example.com", body: 'foo bar'))
+          end
+
+          it "should match when hash contains regex values" do
+            expect(WebMock::RequestPattern.new(:post, "www.example.com", body: {a: /^\w{5}$/, b: {c: /^\d{3}$/}})).
+              to match(WebMock::RequestSignature.new(:post, "www.example.com", body: 'a=abcde&b[c]=123'))
+          end
+
+          it "should not match when hash does not contains regex values" do
+            expect(WebMock::RequestPattern.new(:post, "www.example.com", body: {a: /^\d+$/, b: {c: /^\d{3}$/}})).
+              not_to match(WebMock::RequestSignature.new(:post, "www.example.com", body: 'a=abcde&b[c]=123'))
+          end
+
+          context 'body is an hash with an array of hashes' do
+            let(:body_hash) { {a: [{'b' => '1'}, {'b' => '2'}]} }
+
+            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", body: 'a[][b]=1&a[][b]=2'))
+            end
+          end
+
+          context 'body is an hash with an array of hashes with multiple keys' do
+            let(:body_hash) { {a: [{'b' => '1', 'a' => '2'}, {'b' => '3'}]} }
+
+            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", body: 'a[][b]=1&a[][a]=2&a[][b]=3'))
+            end
+          end
+        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
+
+          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 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 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}"))
+          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}"))
+          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}"))
+          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
+
+          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 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 "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"))
+
+          end
+        end
+      end
+
+      describe "when body in a pattern is declared as a partial hash matcher" do
+        let(:signature) { WebMock::RequestSignature.new(:post, "www.example.com", body: 'a=1&c[d][]=e&c[d][]=f&b=five') }
+
+       it "should match when query params are declared as HashIncluding matcher matching params" do
+          expect(WebMock::RequestPattern.new(:post, "www.example.com",
+          body: WebMock::Matchers::HashIncludingMatcher.new({:a => '1', 'c' => {'d' => ['e', 'f']}}))).
+            to match(signature)
+        end
+
+        it "should not match when query params are declared as HashIncluding matcher not matching params" do
+          expect(WebMock::RequestPattern.new(:post, "www.example.com",
+          body: WebMock::Matchers::HashIncludingMatcher.new({:x => '1', 'c' => {'d' => ['e', 'f']}}))).
+            not_to match(signature)
+        end
+
+        it "should match when query params are declared as RSpec HashIncluding matcher matching params" do
+          expect(WebMock::RequestPattern.new(:post, "www.example.com",
+          body: RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({:a => '1', 'c' => {'d' => ['e', 'f']}}))).
+            to match(signature)
+        end
+
+        it "should not match when query params are declared as RSpec HashIncluding matcher not matching params" do
+          expect(WebMock::RequestPattern.new(:post, "www.example.com",
+          body: RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({:x => '1', 'c' => {'d' => ['e', 'f']}}))).
+            not_to match(signature)
+        end
+      end
+    end
+
+    it "should match if pattern and request have the same headers" do
+      expect(WebMock::RequestPattern.new(:get, "www.example.com", headers: {'Content-Type' => 'image/jpeg'})).
+        to match(WebMock::RequestSignature.new(:get, "www.example.com", headers: {'Content-Type' => 'image/jpeg'}))
+    end
+
+    it "should match if pattern headers values are regexps matching request header values" do
+      expect(WebMock::RequestPattern.new(:get, "www.example.com", headers: {'Content-Type' => %r{^image/jpeg$}})).
+        to match(WebMock::RequestSignature.new(:get, "www.example.com", headers: {'Content-Type' => 'image/jpeg'}))
+    end
+
+    it "should not match if pattern has different value of header than request" do
+      expect(WebMock::RequestPattern.new(:get, "www.example.com", headers: {'Content-Type' => 'image/png'})).
+        not_to match(WebMock::RequestSignature.new(:get, "www.example.com", headers: {'Content-Type' => 'image/jpeg'}))
+    end
+
+    it "should not match if pattern header value regexp doesn't match request header value" do
+      expect(WebMock::RequestPattern.new(:get, "www.example.com", headers: {'Content-Type' => %r{^image\/jpeg$}})).
+        not_to match(WebMock::RequestSignature.new(:get, "www.example.com", headers: {'Content-Type' => 'image/jpegx'}))
+    end
+
+    it "should match if request has more headers than request pattern" do
+      expect(WebMock::RequestPattern.new(:get, "www.example.com", headers: {'Content-Type' => 'image/jpeg'})).
+        to match(WebMock::RequestSignature.new(:get, "www.example.com", headers: {'Content-Type' => 'image/jpeg', 'Content-Length' => '8888'}))
+    end
+
+    it "should not match if request has less headers than the request pattern" do
+      expect(WebMock::RequestPattern.new(:get, "www.example.com", headers: {'Content-Type' => 'image/jpeg', 'Content-Length' => '8888'})).
+        not_to match(WebMock::RequestSignature.new(:get, "www.example.com", headers: {'Content-Type' => 'image/jpeg'}))
+    end
+
+    it "should match even is header keys are declared in different form" do
+      expect(WebMock::RequestPattern.new(:get, "www.example.com", headers: {'ContentLength' => '8888', 'Content-type' => 'image/png'})).
+        to match(WebMock::RequestSignature.new(:get, "www.example.com", headers: {:ContentLength => 8888, 'content_type' => 'image/png'}))
+    end
+
+    it "should match is pattern doesn't have specified headers" do
+      expect(WebMock::RequestPattern.new(:get, "www.example.com")).
+        to match(WebMock::RequestSignature.new(:get, "www.example.com", headers: {'A' => 'a'}))
+    end
+
+    it "should not match if pattern has nil headers but request has headers" do
+      expect(WebMock::RequestPattern.new(:get, "www.example.com", headers: nil)).
+        not_to match(WebMock::RequestSignature.new(:get, "www.example.com", headers: {'A' => 'a'}))
+    end
+
+    it "should not match if pattern has empty headers but request has headers" do
+      expect(WebMock::RequestPattern.new(:get, "www.example.com", headers: {})).
+        not_to match(WebMock::RequestSignature.new(:get, "www.example.com", headers: {'A' => 'a'}))
+    end
+
+    it "should not match if pattern has specified headers but request has nil headers" do
+      expect(WebMock::RequestPattern.new(:get, "www.example.com", headers: {'A'=>'a'})).
+        not_to match(WebMock::RequestSignature.new(:get, "www.example.com"))
+    end
+
+    it "should not match if pattern has specified headers but request has empty headers" do
+      expect(WebMock::RequestPattern.new(:get, "www.example.com", headers: {'A'=>'a'})).
+        not_to match(WebMock::RequestSignature.new(:get, "www.example.com", headers: {}))
+    end
+
+    it "should match if block given in pattern evaluates request to true" do
+      expect(WebMock::RequestPattern.new(:get, "www.example.com").with { |request| true }).
+        to match(WebMock::RequestSignature.new(:get, "www.example.com"))
+    end
+
+    it "should not match if block given in pattrn evaluates request to false" do
+      expect(WebMock::RequestPattern.new(:get, "www.example.com").with { |request| false }).
+        not_to match(WebMock::RequestSignature.new(:get, "www.example.com"))
+    end
+
+    it "should yield block with request signature" do
+      signature = WebMock::RequestSignature.new(:get, "www.example.com")
+      expect(WebMock::RequestPattern.new(:get, "www.example.com").with { |request| request == signature }).
+        to match(signature)
+    end
+
+  end
+
+
+end