http_stub 0.22.4 → 0.23.0

data/lib/http_stub/server/stub/match/hash_with_string_value_matchers.rb

@@ -1,26 +0,0 @@
-module HttpStub
-  module Server
-    module Stub
-      module Match
-
-        class HashWithStringValueMatchers < Hash
-
-          def initialize(stub_hash)
-            stub_hash.each_pair do |key, value|
-              self[key] = HttpStub::Server::Stub::Match::StringValueMatcher.new(value)
-            end
-          end
-
-          def matches?(actual_hash)
-            !(self.find do |key_and_value_matcher|
-              key, value_matcher = key_and_value_matcher
-              !value_matcher.matches?(actual_hash[key])
-            end)
-          end
-
-        end
-
-      end
-    end
-  end
-end

data/lib/http_stub/server/stub/match/truthy_matcher.rb

@@ -1,25 +0,0 @@
-module HttpStub
-  module Server
-    module Stub
-      module Match
-
-        class TruthyMatcher
-
-          class << self
-
-            def matches?(_request, _logger)
-              true
-            end
-
-            def to_s
-              ""
-            end
-
-          end
-
-        end
-
-      end
-    end
-  end
-end

data/spec/lib/http_stub/server/header_parser_spec.rb

@@ -1,51 +0,0 @@
-describe HttpStub::Server::HeaderParser do
-
-  let(:non_header_env_elements) do
-    {
-      "rack.version"       => [1, 3],
-      "rack.multithreaded" => true,
-      "rack.multiprocess"  => false
-    }
-  end
-  let(:env)     { non_header_env_elements.merge(header_env_elements) }
-  let(:request) { instance_double(Rack::Request, env: env) }
-
-  let(:header_parser) { described_class }
-
-  describe "::parse" do
-
-    subject { header_parser.parse(request) }
-
-    describe "when the request contains environment entries in upper case" do
-
-      let(:header_env_elements) { { "KEY_1" => "value1", "KEY_2" => "value2", "KEY_3" => "value3" } }
-
-      it "returns a hash containing those entries" do
-        expect(subject).to eql("KEY_1" => "value1", "KEY_2" => "value2", "KEY_3" => "value3")
-      end
-
-    end
-
-    describe "when the request contains environment entries in upper case prefixed with 'HTTP_'" do
-
-      let(:header_env_elements) { { "HTTP_KEY_1" => "value1", "HTTP_KEY_2" => "value2", "HTTP_KEY_3" => "value3" } }
-
-      it "returns a hash containing those entries with the prefix removed" do
-        expect(subject).to include("KEY_1" => "value1", "KEY_2" => "value2", "KEY_3" => "value3")
-      end
-
-    end
-
-    describe "when only has environment entries in lower case" do
-
-      let(:header_env_elements) { {} }
-
-      it "returns an empty hash" do
-        expect(subject).to eql({})
-      end
-
-    end
-
-  end
-
-end

data/spec/lib/http_stub/server/stub/match/hash_with_string_value_matchers_spec.rb

@@ -1,166 +0,0 @@
-describe HttpStub::Server::Stub::Match::HashWithStringValueMatchers do
-
-  let(:stubbed_hash) do
-    (1..3).reduce({}) do |result, i|
-      result["key#{i}"] = "value#{i}"
-      result
-    end
-  end
-
-  let(:value_matchers) do
-    stubbed_hash.values.map do |value|
-      double(HttpStub::Server::Stub::Match::StringValueMatcher, to_s: value).as_null_object
-    end
-  end
-
-  let(:value_matcher_hash) { HttpStub::Server::Stub::Match::HashWithStringValueMatchers.new(stubbed_hash) }
-
-  before(:example) do
-    value_matchers.each do |value|
-      allow(HttpStub::Server::Stub::Match::StringValueMatcher).to receive(:new).with(value.to_s).and_return(value)
-    end
-  end
-
-  it "is a hash" do
-    expect(value_matcher_hash).to be_a(Hash)
-  end
-
-  describe "constructor" do
-
-    it "creates a value matcher representation of each value in the hash" do
-      value_matchers.each do |value|
-        expect(HttpStub::Server::Stub::Match::StringValueMatcher).to receive(:new).with(value.to_s).and_return(value)
-      end
-
-      expect(value_matcher_hash.values).to eql(value_matchers)
-    end
-    
-  end
-  
-  describe "#matches?" do
-
-    subject { value_matcher_hash.matches?(provided_hash) }
-    
-    context "when the stubbed hash contains multiple entries" do
-
-      context "and the provided hash has the same number of entries" do
-
-        context "and the keys match" do
-
-          let(:provided_hash) do
-            stubbed_hash.reduce({}) do |result, entry|
-              result[entry[0]] = "another #{entry[1]}"
-              result
-            end
-          end
-
-          context "and the values match" do
-
-            before(:example) do
-              value_matchers.each do |value|
-                allow(value).to receive(:matches?).with("another #{value}").and_return(true)
-              end
-            end
-            
-            it "returns true" do
-              expect(subject).to be(true)
-            end
-            
-          end
-
-          context "and a value does not match" do
-
-            before(:example) do
-              value_matchers.each do |value|
-                allow(value).to receive(:matches?).with("another #{value}").and_return(true)
-              end
-
-              non_matching_value = value_matchers[1]
-              allow(non_matching_value).to receive(:matches?).with("another #{non_matching_value}").and_return(false)
-            end
-
-            it "returns false" do
-              expect(subject).to be(false)
-            end
-
-          end
-          
-        end
-
-        context "and a key does not match" do
-
-          let(:provided_hash) { { "key1" => "value1", "differentkey2" => "another value2", "key3" => "value3" } }
-
-          it "determines if the corresponding value matches nil" do
-            expected_values = [ "value1", nil, "value3" ]
-            value_matchers.zip(expected_values).each do |value_matcher, expected_value|
-              allow(value_matcher).to receive(:matches?).with(expected_value)
-            end
-
-            subject
-          end
-
-          it "returns the result of evaluating the value matchers" do
-            value_matchers.each { |value| allow(value).to receive(:matches?).and_return(true) }
-
-            expect(subject).to be(true)
-          end
-
-        end
-
-      end
-
-      context "and the provided hash contains more entries" do
-
-        let(:provided_hash) do
-          (1..5).reduce({}) do |result, i|
-            result["key#{i}"] = "another value#{i}"
-            result
-          end
-        end
-
-        context "and it has matching keys and values" do
-
-          before(:example) do
-            value_matchers.each { |value| allow(value).to receive(:matches?).with("another #{value}").and_return(true) }
-          end
-
-          it "returns true" do
-            expect(subject).to be(true)
-          end
-          
-        end
-        
-      end
-      
-    end
-
-    context "when the stubbed hash is empty" do
-
-      let(:stubbed_hash) { {} }
-
-      context "and the provided hash is not empty" do
-
-        let(:provided_hash) { { "key" => "value" } }
-
-        it "returns true" do
-          expect(subject).to be(true)
-        end
-
-      end
-
-      context "and the provided hash is empty" do
-
-        let(:provided_hash) { {} }
-
-        it "returns true" do
-          expect(subject).to be(true)
-        end
-
-      end
-      
-    end
-    
-  end
-  
-end