webmock 3.7.1

data/spec/support/network_connection.rb

@@ -0,0 +1,19 @@
+require 'timeout'
+require 'socket'
+
+module NetworkConnection
+  def self.connect_to(host, port, timeout=10)
+    Timeout.timeout(timeout) do
+      TCPSocket.new(host, port)
+    end
+  end
+
+  def self.is_network_available?
+    begin
+      self.connect_to("8.8.8.8", 53, 5)
+      true
+    rescue
+      false
+    end
+  end
+end

data/spec/support/webmock_server.rb

@@ -0,0 +1,70 @@
+require 'webrick'
+require 'logger'
+require 'singleton'
+
+class WebMockServer
+  include Singleton
+
+  attr_reader :port, :started
+
+  def host_with_port
+    "localhost:#{port}"
+  end
+
+  def concurrent
+    unless RUBY_PLATFORM =~ /java/
+      @pid = Process.fork do
+        yield
+      end
+    else
+      Thread.new { yield }
+    end
+  end
+
+  def start
+    @started = true
+    server = WEBrick::GenericServer.new(Port: 0, Logger: Logger.new("/dev/null"))
+    server.logger.level = 0
+    @port = server.config[:Port]
+
+    concurrent do
+      ['TERM', 'INT'].each do |signal|
+        trap(signal) do
+          Thread.new do
+            server.shutdown
+          end
+        end
+      end
+      server.start do |socket|
+        socket.read(1)
+        socket.puts <<-EOT.gsub(/^\s+\|/, '')
+          |HTTP/1.1 200 OK\r
+          |Date: Fri, 31 Dec 1999 23:59:59 GMT\r
+          |Content-Type: text/html\r
+          |Content-Length: 11\r
+          |Set-Cookie: bar\r
+          |Set-Cookie: foo\r
+          |\r
+          |hello world
+        EOT
+      end
+    end
+
+
+    loop do
+      begin
+        TCPSocket.new("localhost", port)
+        sleep 0.1
+        break
+      rescue Errno::ECONNREFUSED
+        sleep 0.1
+      end
+    end
+  end
+
+  def stop
+    if @pid
+      Process.kill('INT', @pid)
+    end
+  end
+end

data/spec/unit/api_spec.rb

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

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

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

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

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