http_stub 0.15.5 → 0.16.0.pre1

data/spec/lib/http_stub/server/stub/method_spec.rb

@@ -0,0 +1,95 @@
+describe HttpStub::Server::Stub::Method do
+
+  let(:raw_stub_method) { "put" }
+
+  let(:the_method) { HttpStub::Server::Stub::Method.new(raw_stub_method) }
+
+  describe "#match?" do
+
+    let(:request_method) { "get" }
+    let(:request)        { instance_double(Rack::Request, request_method: request_method) }
+
+    subject { the_method.match?(request) }
+
+    context "when the request method is identical to the stub method" do
+
+      let(:request_method) { raw_stub_method }
+
+      it "returns true" do
+        expect(subject).to be(true)
+      end
+
+    end
+
+    context "when the request method and stub method are the the same value but have different casing" do
+
+      let(:raw_stub_method) { "GET" }
+
+      it "returns true" do
+        expect(subject).to be(true)
+      end
+
+    end
+
+    context "when the stub method is omitted" do
+
+      context "with a nil value" do
+
+        let(:raw_stub_method) { nil }
+
+        it "returns true" do
+          expect(subject).to be(true)
+        end
+
+      end
+
+      context "with an empty string" do
+
+        let(:raw_stub_method) { "" }
+
+        it "returns true" do
+          expect(subject).to be(true)
+        end
+
+      end
+
+    end
+
+    context "when the request method is different to the stub method" do
+
+      let(:request_method)  { "get" }
+      let(:raw_stub_method) { "delete" }
+
+      it "returns false" do
+        expect(subject).to be(false)
+      end
+
+    end
+
+  end
+
+  describe "#to_s" do
+
+    context "when the stub method provided is not nil" do
+
+      let(:raw_stub_method) { "not_nil" }
+
+      it "returns the stub method provided" do
+        expect(the_method.to_s).to eql(raw_stub_method)
+      end
+
+    end
+
+    context "when the stub method provided is nil" do
+
+      let(:raw_stub_method) { nil }
+
+      it "returns an empty string" do
+        expect(the_method.to_s).to eql("")
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/http_stub/server/{omitted_value_matcher_spec.rb → stub/omitted_value_matcher_spec.rb}

@@ -1,6 +1,6 @@
-describe HttpStub::Server::OmittedValueMatcher  do
+describe HttpStub::Server::Stub::OmittedValueMatcher do
 
-  describe ".match?" do
+  describe "::match?" do
 
     context "when the stubbed value is 'control:omitted'" do
 
@@ -50,7 +50,7 @@ describe HttpStub::Server::OmittedValueMatcher  do
     end
 
     def perform_match
-      HttpStub::Server::OmittedValueMatcher.match?(stub_value, actual_value)
+      HttpStub::Server::Stub::OmittedValueMatcher.match?(stub_value, actual_value)
     end
 
   end

data/spec/lib/http_stub/server/{regexp_value_matcher_spec.rb → stub/regexp_value_matcher_spec.rb}

@@ -1,6 +1,6 @@
-describe HttpStub::Server::RegexpValueMatcher do
+describe HttpStub::Server::Stub::RegexpValueMatcher do
 
-  describe ".match?" do
+  describe "::match?" do
 
     context "when the stub value is a string prefixed with 'regexp:'" do
 
@@ -40,7 +40,7 @@ describe HttpStub::Server::RegexpValueMatcher do
     end
     
     def perform_match
-      HttpStub::Server::RegexpValueMatcher.match?(stub_value, actual_value)
+      HttpStub::Server::Stub::RegexpValueMatcher.match?(stub_value, actual_value)
     end
 
   end

data/spec/lib/http_stub/server/stub/registry_integration_spec.rb

@@ -0,0 +1,56 @@
+describe HttpStub::Server::Stub::Registry, "integrating with real stubs" do
+
+  let(:logger)  { double("Logger").as_null_object }
+  let(:request) { instance_double(Rack::Request, logger: logger) }
+
+  let(:stub_registry) { HttpStub::Server::Stub::Registry.new }
+
+  describe "#recall" do
+
+    subject { stub_registry.recall }
+
+    context "when stubs have been added" do
+
+      let(:stubs) { (1..3).map { |i| create_stub(i) } }
+
+      before(:example) { stubs.each { |stub| stub_registry.add(stub, request) } }
+
+      context "and remembered" do
+
+        before(:example) { stub_registry.remember }
+
+        context "and a stub subsequently added" do
+
+          let(:stub_to_add) { create_stub(4) }
+
+          before(:example) { stub_registry.add(stub_to_add, request) }
+
+          it "should restore all known stubs to the remembered state" do
+            subject
+
+            expect(stub_registry.all).not_to include(stub_to_add)
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+  def create_stub(number)
+    HttpStub::Server::Stub.create(
+      "uri" => "/uri#{number}",
+      "method" => "get",
+      "headers" => {"header_key_#{number}" => "header_value_#{number}"},
+      "parameters" => {"parameter_key_#{number}" => "parameter_value_#{number}"},
+      "response" => {
+        "status" => 200 + number,
+        "body" => "Body #{number}"
+      },
+      "triggers" => []
+    )
+  end
+
+end

data/spec/lib/http_stub/server/{stub_registry_spec.rb → stub/registry_spec.rb}

@@ -1,15 +1,15 @@
-describe HttpStub::Server::StubRegistry do
+describe HttpStub::Server::Stub::Registry do
 
   let(:registry)      { instance_double(HttpStub::Server::Registry) }
 
-  let(:stub_registry) { HttpStub::Server::StubRegistry.new }
+  let(:stub_registry) { HttpStub::Server::Stub::Registry.new }
 
   before(:example) { allow(HttpStub::Server::Registry).to receive(:new).and_return(registry) }
 
   describe "#add" do
 
-    let(:stub)    { instance_double(HttpStub::Server::Stub) }
-    let(:request) { double("HttpRequest") }
+    let(:stub)    { instance_double(HttpStub::Server::Stub::Instance) }
+    let(:request) { instance_double(Rack::Request) }
 
     it "delegates to an underlying simple registry" do
       expect(registry).to receive(:add).with(stub, request)
@@ -19,24 +19,37 @@ describe HttpStub::Server::StubRegistry do
 
   end
 
+  describe "#concat" do
+
+    let(:stubs)   { (1..3).map { instance_double(HttpStub::Server::Stub::Instance) } }
+    let(:request) { instance_double(Rack::Request) }
+
+    it "delegates to an underlying simple registry" do
+      expect(registry).to receive(:concat).with(stubs, request)
+
+      stub_registry.concat(stubs, request)
+    end
+
+  end
+
   describe "#find_for" do
 
-    let(:request) { double("HttpRequest") }
+    let(:request) { instance_double(Rack::Request) }
 
     subject { stub_registry.find_for(request) }
 
-    it "delegates to an underlying simple registry" do
-      expect(registry).to receive(:find_for).with(request)
+    it "delegates to an underlying simple registry to find based on the request" do
+      expect(registry).to receive(:find).with(criteria: request, request: request)
 
       subject
     end
 
     context "when a stub is found" do
 
-      let(:triggers) { instance_double(HttpStub::Server::StubTriggers) }
-      let(:stub)     { instance_double(HttpStub::Server::Stub, triggers: triggers) }
+      let(:triggers) { instance_double(HttpStub::Server::Stub::Triggers) }
+      let(:stub)     { instance_double(HttpStub::Server::Stub::Instance, triggers: triggers) }
 
-      before(:example) { allow(registry).to receive(:find_for).and_return(stub) }
+      before(:example) { allow(registry).to receive(:find).and_return(stub) }
 
       it "should add the stubs triggers to the registry" do
         expect(triggers).to receive(:add_to).with(stub_registry, request)
@@ -54,7 +67,7 @@ describe HttpStub::Server::StubRegistry do
 
     context "when a stub is not found" do
 
-      before(:example) { allow(registry).to receive(:find_for).and_return(nil) }
+      before(:example) { allow(registry).to receive(:find).and_return(nil) }
 
       it "returns the result from the underlying registry" do
         expect(subject).to eql(nil)
@@ -70,7 +83,7 @@ describe HttpStub::Server::StubRegistry do
 
     context "when the state of the registry has been remembered" do
 
-      let(:last_stub_remembered) { instance_double(HttpStub::Server::Stub) }
+      let(:last_stub_remembered) { instance_double(HttpStub::Server::Stub::Instance) }
 
       before(:example) do
         allow(registry).to receive(:last).and_return(last_stub_remembered)
@@ -99,7 +112,7 @@ describe HttpStub::Server::StubRegistry do
 
   describe "#all" do
 
-    let(:stubs) { (1..3).map { instance_double(HttpStub::Server::Stub) } }
+    let(:stubs) { (1..3).map { instance_double(HttpStub::Server::Stub::Instance) } }
 
     subject { stub_registry.all }
 
@@ -119,7 +132,7 @@ describe HttpStub::Server::StubRegistry do
 
   describe "#clear" do
 
-    let(:request) { double("HttpRequest") }
+    let(:request) { instance_double(Rack::Request) }
 
     it "delegates to an underlying simple registry" do
       expect(registry).to receive(:clear).with(request)

data/spec/lib/http_stub/server/{request_header_parser_spec.rb → stub/request_header_parser_spec.rb}

@@ -1,4 +1,4 @@
-describe HttpStub::Server::RequestHeaderParser do
+describe HttpStub::Server::Stub::RequestHeaderParser do
 
   let(:non_header_env_elements) do
     {
@@ -7,8 +7,8 @@ describe HttpStub::Server::RequestHeaderParser do
       "rack.multiprocess"  => false
     }
   end
-  let(:env) { non_header_env_elements.merge(header_env_elements) }
-  let(:request) { double("HttpRequest", env: env) }
+  let(:env)     { non_header_env_elements.merge(header_env_elements) }
+  let(:request) { instance_double(Rack::Request, env: env) }
 
   describe "::parse" do
 
@@ -17,7 +17,7 @@ describe HttpStub::Server::RequestHeaderParser do
       let(:header_env_elements) { { "KEY_1" => "value1", "KEY_2" => "value2", "KEY_3" => "value3" } }
 
       it "returns a hash containing those entries" do
-        expect(HttpStub::Server::RequestHeaderParser.parse(request)).to eql("KEY_1" => "value1",
+        expect(HttpStub::Server::Stub::RequestHeaderParser.parse(request)).to eql("KEY_1" => "value1",
                                                                             "KEY_2" => "value2",
                                                                             "KEY_3" => "value3")
       end
@@ -29,7 +29,7 @@ describe HttpStub::Server::RequestHeaderParser 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(HttpStub::Server::RequestHeaderParser.parse(request)).to include("KEY_1" => "value1",
+        expect(HttpStub::Server::Stub::RequestHeaderParser.parse(request)).to include("KEY_1" => "value1",
                                                                                 "KEY_2" => "value2",
                                                                                 "KEY_3" => "value3")
       end
@@ -41,7 +41,7 @@ describe HttpStub::Server::RequestHeaderParser do
       let(:header_env_elements) { {} }
 
       it "returns an empty hash" do
-        expect(HttpStub::Server::RequestHeaderParser.parse(request)).to eql({})
+        expect(HttpStub::Server::Stub::RequestHeaderParser.parse(request)).to eql({})
       end
       
     end

data/spec/lib/http_stub/server/stub/request_headers_spec.rb

@@ -0,0 +1,68 @@
+describe HttpStub::Server::Stub::RequestHeaders do
+
+  let(:request)         { instance_double(Rack::Request) }
+  let(:stubbed_headers) { { "stub_key" => "value" } }
+
+  let(:request_headers) { HttpStub::Server::Stub::RequestHeaders.new(stubbed_headers) }
+
+  it "is Headers" do
+    expect(request_headers).to be_a(HttpStub::Server::Stub::Headers)
+  end
+
+  describe "when stubbed headers are provided" do
+
+    it "creates a regexpable representation of the stubbed headers whose keys are downcased and underscored" do
+      downcased_and_underscored_hash = { "another_stub_key" => "value" }
+      expect(stubbed_headers).to receive(:downcase_and_underscore_keys).and_return(downcased_and_underscored_hash)
+      expect(HttpStub::Server::Stub::HashWithStringValueMatchers).to receive(:new).with(downcased_and_underscored_hash)
+
+      request_headers
+    end
+
+  end
+
+  describe "when the stubbed headers are nil" do
+
+    let(:stubbed_headers) { nil }
+
+    it "creates a regexpable representation of an empty hash" do
+      expect(HttpStub::Server::Stub::HashWithStringValueMatchers).to receive(:new).with({})
+
+      request_headers
+    end
+
+  end
+
+  describe "#match?" do
+
+    let(:parsed_headers) { { "request_key" => "value" } }
+    let(:regexpable_stubbed_headers) { double(HttpStub::Server::Stub::HashWithStringValueMatchers).as_null_object }
+
+    before(:example) do
+      allow(HttpStub::Server::Stub::HashWithStringValueMatchers).to receive(:new).and_return(regexpable_stubbed_headers)
+      allow(HttpStub::Server::Stub::RequestHeaderParser).to receive(:parse).with(request).and_return(parsed_headers)
+    end
+
+    it "parses the requests headers into a hash" do
+      expect(HttpStub::Server::Stub::RequestHeaderParser).to receive(:parse).with(request).and_return(parsed_headers)
+
+      request_headers.match?(request)
+    end
+
+    it "downcases and underscore the keys in the request header hash" do
+      expect(parsed_headers).to receive(:downcase_and_underscore_keys)
+
+      request_headers.match?(request)
+    end
+
+    it "delegates to the regexpable representation of the stubbed headers to determine a match" do
+      downcased_and_underscored_hash = { "another_request_key" => "value" }
+      allow(parsed_headers).to receive(:downcase_and_underscore_keys).and_return(downcased_and_underscored_hash)
+      expect(regexpable_stubbed_headers).to receive(:match?).with(downcased_and_underscored_hash).and_return(true)
+
+      expect(request_headers.match?(request)).to be_truthy
+    end
+
+  end
+
+end

data/spec/lib/http_stub/server/{stub_parameters_spec.rb → stub/request_parameters_spec.rb}

@@ -1,19 +1,19 @@
-describe HttpStub::Server::StubParameters do
+describe HttpStub::Server::Stub::RequestParameters do
 
-  let(:request_parameters) { double("RequestParameters") }
-  let(:request) { double("HttpRequest", params: request_parameters) }
+  let(:raw_request_parameters) { double("RequestParameters") }
+  let(:request)                { instance_double(Rack::Request, params: raw_request_parameters) }
 
-  let(:stubbed_parameters) { { "key1" => "value1", "key2" => "value2", "key3" => "value3" } }
-  let(:regexpable_stubbed_paremeters) { double(HttpStub::Server::HashWithStringValueMatchers).as_null_object }
+  let(:stubbed_parameters)            { { "key1" => "value1", "key2" => "value2", "key3" => "value3" } }
+  let(:regexpable_stubbed_paremeters) { double(HttpStub::Server::Stub::HashWithStringValueMatchers).as_null_object }
 
-  let(:stub_parameters) { HttpStub::Server::StubParameters.new(stubbed_parameters) }
+  let(:request_parameters) { HttpStub::Server::Stub::RequestParameters.new(stubbed_parameters) }
 
   describe "when stubbed parameters are provided" do
 
     it "creates a regexpable representation of the stubbed parameters" do
-      expect(HttpStub::Server::HashWithStringValueMatchers).to receive(:new).with(stubbed_parameters)
+      expect(HttpStub::Server::Stub::HashWithStringValueMatchers).to receive(:new).with(stubbed_parameters)
 
-      stub_parameters
+      request_parameters
     end
 
   end
@@ -23,9 +23,9 @@ describe HttpStub::Server::StubParameters do
     let(:stubbed_parameters) { nil }
 
     it "creates a regexpable representation of an empty hash" do
-      expect(HttpStub::Server::HashWithStringValueMatchers).to receive(:new).with({})
+      expect(HttpStub::Server::Stub::HashWithStringValueMatchers).to receive(:new).with({})
 
-      stub_parameters
+      request_parameters
     end
 
   end
@@ -33,28 +33,30 @@ describe HttpStub::Server::StubParameters do
   describe "#match?" do
 
     it "delegates to the regexpable representation of the stubbed parameters to determine a match" do
-      allow(HttpStub::Server::HashWithStringValueMatchers).to receive(:new).and_return(regexpable_stubbed_paremeters)
-      expect(regexpable_stubbed_paremeters).to receive(:match?).with(request_parameters).and_return(true)
+      allow(HttpStub::Server::Stub::HashWithStringValueMatchers).to receive(:new).and_return(regexpable_stubbed_paremeters)
+      expect(regexpable_stubbed_paremeters).to receive(:match?).with(raw_request_parameters).and_return(true)
 
-      expect(stub_parameters.match?(request)).to be(true)
+      expect(request_parameters.match?(request)).to be(true)
     end
 
   end
 
   describe "#to_s" do
 
+    subject { request_parameters.to_s }
+
     describe "when multiple parameters are provided" do
 
       let(:stubbed_parameters) { { "key1" => "value1", "key2" => "value2", "key3" => "value3" } }
 
       it "returns a string containing each parameter formatted as a conventional request parameter" do
-        result = stub_parameters.to_s
+        result = subject
 
         stubbed_parameters.each { |key, value| expect(result).to match(/#{key}=#{value}/) }
       end
 
       it "separates each parameter with the conventional request parameter delimiter" do
-        expect(stub_parameters.to_s).to match(/key\d.value\d\&key\d.value\d\&key\d.value\d/)
+        expect(subject).to match(/key\d.value\d\&key\d.value\d\&key\d.value\d/)
       end
 
     end
@@ -64,7 +66,7 @@ describe HttpStub::Server::StubParameters do
       let(:stubbed_parameters) { {} }
 
       it "returns an empty string" do
-        expect(stub_parameters.to_s).to eql("")
+        expect(subject).to eql("")
       end
 
     end
@@ -74,7 +76,7 @@ describe HttpStub::Server::StubParameters do
       let(:stubbed_parameters) { nil }
 
       it "returns an empty string" do
-        expect(stub_parameters.to_s).to eql("")
+        expect(subject).to eql("")
       end
 
     end