webmock 3.7.1

data/spec/unit/matchers/hash_including_matcher_spec.rb

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

data/spec/unit/rack_response_spec.rb

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

@@ -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/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