http_stub 0.14.2 → 0.15.0

data/spec/lib/http_stub/{models → server}/string_value_matcher_spec.rb

@@ -1,8 +1,8 @@
-describe HttpStub::Models::StringValueMatcher do
+describe HttpStub::Server::StringValueMatcher do
 
   let(:stub_value) { "some stub value" }
 
-  let(:string_value_matcher) { HttpStub::Models::StringValueMatcher.new(stub_value) }
+  let(:string_value_matcher) { HttpStub::Server::StringValueMatcher.new(stub_value) }
 
   describe "#match?" do
 
@@ -11,37 +11,37 @@ describe HttpStub::Models::StringValueMatcher do
     shared_examples_for "a StringValueMatcher that matches an expected stub value" do
 
       it "determines if actual value should be omitted" do
-        expect(HttpStub::Models::OmittedValueMatcher).to receive(:match?).with(expected_stub_match_value, actual_value)
+        expect(HttpStub::Server::OmittedValueMatcher).to receive(:match?).with(expected_stub_match_value, actual_value)
 
         perform_match
       end
 
       it "determines if the actual value matches a regular expression" do
-        expect(HttpStub::Models::RegexpValueMatcher).to receive(:match?).with(expected_stub_match_value, actual_value)
+        expect(HttpStub::Server::RegexpValueMatcher).to receive(:match?).with(expected_stub_match_value, actual_value)
 
         perform_match
       end
 
       it "determines if the actual value exactly matches the stub value" do
-        expect(HttpStub::Models::ExactValueMatcher).to receive(:match?).with(expected_stub_match_value, actual_value)
+        expect(HttpStub::Server::ExactValueMatcher).to receive(:match?).with(expected_stub_match_value, actual_value)
 
         perform_match
       end
 
       it "determines if actual value should be omitted" do
-        expect(HttpStub::Models::OmittedValueMatcher).to receive(:match?).with(expected_stub_match_value, actual_value)
+        expect(HttpStub::Server::OmittedValueMatcher).to receive(:match?).with(expected_stub_match_value, actual_value)
 
         perform_match
       end
 
       it "determines if the actual value matches a regular expression" do
-        expect(HttpStub::Models::RegexpValueMatcher).to receive(:match?).with(expected_stub_match_value, actual_value)
+        expect(HttpStub::Server::RegexpValueMatcher).to receive(:match?).with(expected_stub_match_value, actual_value)
 
         perform_match
       end
 
       it "determines if the actual value exactly matches the stub value" do
-        expect(HttpStub::Models::ExactValueMatcher).to receive(:match?).with(expected_stub_match_value, actual_value)
+        expect(HttpStub::Server::ExactValueMatcher).to receive(:match?).with(expected_stub_match_value, actual_value)
 
         perform_match
       end
@@ -68,7 +68,7 @@ describe HttpStub::Models::StringValueMatcher do
 
     context "when an omitted match occurs" do
 
-      before(:example) { expect(HttpStub::Models::OmittedValueMatcher).to receive(:match?).and_return(true) }
+      before(:example) { expect(HttpStub::Server::OmittedValueMatcher).to receive(:match?).and_return(true) }
 
       it "returns true" do
         expect(perform_match).to be_truthy
@@ -78,7 +78,7 @@ describe HttpStub::Models::StringValueMatcher do
 
     context "when a regular expression match occurs" do
 
-      before(:example) { expect(HttpStub::Models::RegexpValueMatcher).to receive(:match?).and_return(true) }
+      before(:example) { expect(HttpStub::Server::RegexpValueMatcher).to receive(:match?).and_return(true) }
 
       it "returns true" do
         expect(perform_match).to be_truthy
@@ -88,7 +88,7 @@ describe HttpStub::Models::StringValueMatcher do
 
     context "when an exact match occurs" do
 
-      before(:example) { expect(HttpStub::Models::ExactValueMatcher).to receive(:match?).and_return(true) }
+      before(:example) { expect(HttpStub::Server::ExactValueMatcher).to receive(:match?).and_return(true) }
 
       it "returns true" do
         expect(perform_match).to be_truthy

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

@@ -0,0 +1,85 @@
+describe HttpStub::Server::StubActivatorController do
+
+  let(:request)                 { double("HttpRequest") }
+  let(:the_stub)                { double(HttpStub::Server::Stub) }
+  let(:stub_activator)          { double(HttpStub::Server::StubActivator, the_stub: the_stub) }
+  let(:stub_activator_registry) { double("HttpStub::Server::StubActivatorRegistry").as_null_object }
+  let(:stub_registry)           { double("HttpStub::Server::StubRegistry").as_null_object }
+
+  let(:controller) { HttpStub::Server::StubActivatorController.new(stub_activator_registry, stub_registry) }
+
+  before(:example) { allow(HttpStub::Server::StubActivator).to receive(:create_from).and_return(stub_activator) }
+
+  describe "#register" do
+
+    subject { controller.register(request) }
+
+    it "creates a stub activator from the provided request" do
+      expect(HttpStub::Server::StubActivator).to receive(:create_from).with(request).and_return(stub_activator)
+
+      subject
+    end
+
+    it "adds the created activator to the activator registry with the provided request" do
+      expect(stub_activator_registry).to receive(:add).with(stub_activator, request)
+
+      subject
+    end
+
+    it "returns a success response" do
+      expect(subject).to eql(HttpStub::Server::Response::SUCCESS)
+    end
+
+  end
+
+  describe "#activate" do
+
+    describe "when a stub activator has been registered that is activated by the request" do
+
+      before(:example) do
+        allow(stub_activator_registry).to receive(:find_for).with(request).and_return(stub_activator)
+      end
+
+      it "adds the activators stub to the stub registry" do
+        expect(stub_registry).to receive(:add).with(the_stub, request)
+
+        controller.activate(request)
+      end
+
+      it "returns a success response" do
+        expect(controller.activate(request)).to eql(HttpStub::Server::Response::SUCCESS)
+      end
+
+    end
+
+    describe "when no stub activator is activated by the request" do
+
+      before(:example) do
+        allow(stub_activator_registry).to receive(:find_for).with(request).and_return(nil)
+      end
+
+      it "does not add a stub to the registry" do
+        expect(stub_registry).not_to receive(:add)
+
+        controller.activate(request)
+      end
+
+      it "returns an empty response" do
+        expect(controller.activate(request)).to eql(HttpStub::Server::Response::EMPTY)
+      end
+
+    end
+
+  end
+
+  describe "#clear" do
+
+    it "clears the activator registry" do
+      expect(stub_activator_registry).to receive(:clear).with(request)
+
+      controller.clear(request)
+    end
+
+  end
+
+end

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

@@ -0,0 +1,124 @@
+describe HttpStub::Server::StubActivator do
+
+  let(:activation_uri)  { "/some/activation/uri" }
+  let(:args)            { { "activation_uri" => activation_uri } }
+  let(:underlying_stub) { instance_double(HttpStub::Server::Stub) }
+
+  let(:stub_activator) { HttpStub::Server::StubActivator.new(args) }
+
+  before(:example) { allow(HttpStub::Server::Stub).to receive(:new).and_return(underlying_stub) }
+
+  describe "::create_from" do
+
+    let(:payload) { args.to_json }
+
+    subject { HttpStub::Server::StubActivator.create_from(request) }
+
+    shared_context "verification a stub activator is created from a request" do
+
+      it "creates a stub activator with JSON parsed from the request payload" do
+        expect(HttpStub::Server::StubActivator).to receive(:new).with(args)
+
+        subject
+      end
+
+      it "returns the created stub activator" do
+        created_stub_activator = instance_double(HttpStub::Server::StubActivator)
+        allow(HttpStub::Server::StubActivator).to receive(:new).and_return(created_stub_activator)
+
+        expect(subject).to eql(created_stub_activator)
+      end
+
+    end
+
+    context "when the request body contains the payload" do
+
+      let(:request) { double("HttpRequest", params: {}, body: double("RequestBody", read: payload)) }
+
+      include_context "verification a stub activator is created from a request"
+
+    end
+
+    context "when the request contains a payload parameter" do
+
+      let(:request) { double("HttpRequest", params: { "payload" => payload }) }
+
+      include_context "verification a stub activator is created from a request"
+
+    end
+
+  end
+
+  describe "#satisfies?" do
+
+    let(:request) { double("HttpRequest", path_info: request_path_info) }
+
+    describe "when the request uri exactly matches the activator's activation uri" do
+
+      let(:request_path_info) { activation_uri }
+
+      it "returns true" do
+        expect(stub_activator.satisfies?(request)).to be_truthy
+      end
+
+    end
+
+    describe "when the activator's activation uri is a substring of the request uri" do
+
+      let(:request_path_info) { "#{activation_uri}/with/additional/paths" }
+
+      it "returns false" do
+        expect(stub_activator.satisfies?(request)).to be_falsey
+      end
+
+    end
+
+    describe "when the request uri is completely different to the activator's activation uri" do
+
+      let(:request_path_info) { "/completely/different/path" }
+
+      it "returns false" do
+        expect(stub_activator.satisfies?(request)).to be_falsey
+      end
+
+    end
+
+  end
+
+  describe "#the_stub" do
+
+    it "returns a HttpStub::Server::Stub constructed from the activator's arguments" do
+      expect(stub_activator.the_stub).to eql(underlying_stub)
+    end
+
+  end
+
+  describe "#activation_uri" do
+
+    it "returns the value provided in the request body" do
+      expect(stub_activator.activation_uri).to eql(activation_uri)
+    end
+
+  end
+
+  describe "#clear" do
+
+    it "delegates to a HttpStub::Server::Stub constructed from the activator's arguments" do
+      expect(underlying_stub).to receive(:clear)
+
+      expect(stub_activator.clear)
+    end
+
+  end
+
+  describe "#to_s" do
+
+    it "returns the string representation of the activation arguments" do
+      expect(args).to receive(:to_s).and_return("activation args string")
+
+      expect(stub_activator.to_s).to eql("activation args string")
+    end
+
+  end
+
+end

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

@@ -0,0 +1,74 @@
+describe HttpStub::Server::StubController do
+
+  let(:request)  { double("HttpRequest") }
+  let(:response) { double(HttpStub::Server::Response) }
+  let(:the_stub) { double(HttpStub::Server::Stub, response: response) }
+  let(:registry) { double(HttpStub::Server::Registry).as_null_object }
+
+  let(:controller) { HttpStub::Server::StubController.new(registry) }
+
+  before(:example) { allow(HttpStub::Server::StubFactory).to receive(:create).and_return(the_stub) }
+
+  describe "#register" do
+
+    subject { controller.register(request) }
+
+    it "creates a stub from the provided request via the factory" do
+      expect(HttpStub::Server::StubFactory).to receive(:create).with(request).and_return(the_stub)
+
+      subject
+    end
+
+    it "adds the stub to the stub registry" do
+      expect(registry).to receive(:add).with(the_stub, request)
+
+      subject
+    end
+
+    it "returns a success response" do
+      expect(subject).to eql(HttpStub::Server::Response::SUCCESS)
+    end
+
+  end
+
+  describe "#replay" do
+
+    describe "when a stub has been registered that should be replayed for the request" do
+
+      before(:example) do
+        allow(registry).to receive(:find_for).with(request).and_return(the_stub)
+      end
+
+      it "returns the stubs response" do
+        expect(the_stub).to receive(:response).and_return(response)
+
+        expect(controller.replay(request)).to eql(response)
+      end
+
+    end
+
+    describe "when no stub should be replayed for the request" do
+
+      before(:example) do
+        allow(registry).to receive(:find_for).with(request).and_return(nil)
+      end
+
+      it "returns an empty response" do
+        expect(controller.replay(request)).to eql(HttpStub::Server::Response::EMPTY)
+      end
+
+    end
+
+  end
+
+  describe "#clear" do
+
+    it "clears the stub registry" do
+      expect(registry).to receive(:clear).with(request)
+
+      controller.clear(request)
+    end
+
+  end
+
+end

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

@@ -0,0 +1,117 @@
+describe HttpStub::Server::StubFactory do
+
+  describe "::create" do
+
+    let(:params)    { {} }
+    let(:body_hash) { {} }
+    let(:request)   { instance_double(Rack::Request, params: params, body: StringIO.new(body_hash.to_json)) }
+
+    subject { HttpStub::Server::StubFactory.create(request) }
+
+    shared_context "returns the created stub" do
+
+      it "returns the created stub" do
+        stub = instance_double(HttpStub::Server::Stub)
+        allow(HttpStub::Server::Stub).to receive(:new).and_return(stub)
+
+        expect(subject).to eql(stub)
+      end
+
+    end
+
+    context "when the request contains a payload parameter" do
+
+      let(:payload) { HttpStub::StubFixture.new.server_payload }
+      let(:params)  { { "payload" => payload.to_json } }
+
+      it "creates the stub with the payload" do
+        expect(HttpStub::Server::Stub).to receive(:new).with(payload)
+
+        subject
+      end
+
+      include_context "returns the created stub"
+
+    end
+
+    context "when the request body contains the payload (for API backwards compatibility)" do
+
+      let(:body_hash) { HttpStub::StubFixture.new.server_payload }
+
+      it "creates the stub with the request body" do
+        expect(HttpStub::Server::Stub).to receive(:new).with(body_hash)
+
+        subject
+      end
+
+      include_context "returns the created stub"
+
+    end
+
+    context "when a stub payload contains a response file and has a corresponding file parameter" do
+
+      let(:stub_fixture) { HttpStub::StubFixture.new.with_file_response! }
+      let(:payload)      { stub_fixture.server_payload }
+      let(:file_params)  { { "response_file_#{stub_fixture.id}" => stub_fixture.file_parameter } }
+      let(:params)       { { "payload" => payload.to_json }.merge(file_params) }
+
+      it "creates the stub with a response body that contains the file parameter value" do
+        expected_args = payload.clone.tap { |hash| hash["response"]["body"] = stub_fixture.file_parameter }
+        expect(HttpStub::Server::Stub).to receive(:new).with(expected_args)
+
+        subject
+      end
+
+      include_context "returns the created stub"
+
+    end
+
+    context "when a stub payload contains triggers" do
+
+      let(:stub_fixture) { HttpStub::StubFixture.new.with_triggers!(trigger_fixtures) }
+      let(:payload)      { stub_fixture.server_payload }
+
+      context "and the trigger payloads contain response text" do
+
+        let(:trigger_fixtures) { (1..3).map { HttpStub::StubFixture.new.with_text_response! } }
+        let(:params)           { { "payload" => payload.to_json } }
+
+        it "creates the stub with the stub payload unchanged" do
+          expect(HttpStub::Server::Stub).to receive(:new).with(payload)
+
+          subject
+        end
+
+        include_context "returns the created stub"
+
+      end
+
+      context "and the trigger payloads contain a response file with corresponding file parameters" do
+
+        let(:trigger_fixtures) { (1..3).map { HttpStub::StubFixture.new.with_file_response! } }
+        let(:file_params) do
+          trigger_fixtures.reduce({}) do |result, fixture|
+            result.merge("response_file_#{fixture.id}" => fixture.file_parameter)
+          end
+        end
+        let(:params)           { { "payload" => payload.to_json }.merge(file_params) }
+
+        it "creates the stub with the trigger response bodies replaced by the files" do
+          expected_args = stub_fixture.server_payload
+          expected_args["triggers"].zip(trigger_fixtures.map(&:file_parameter)).each do |trigger, file_param|
+            trigger["response"]["body"] = file_param
+          end
+          expect(HttpStub::Server::Stub).to receive(:new).with(expected_args)
+
+          subject
+        end
+
+        include_context "returns the created stub"
+
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/http_stub/{models → server}/stub_headers_spec.rb

@@ -1,12 +1,12 @@
-describe HttpStub::Models::StubHeaders do
+describe HttpStub::Server::StubHeaders do
 
   let(:request) { double("HttpRequest") }
   let(:stubbed_headers) { { "stub_key" => "value" } }
 
-  let(:stub_headers) { HttpStub::Models::StubHeaders.new(stubbed_headers) }
+  let(:stub_headers) { HttpStub::Server::StubHeaders.new(stubbed_headers) }
 
   it "is Headers" do
-    expect(stub_headers).to be_a(HttpStub::Models::Headers)
+    expect(stub_headers).to be_a(HttpStub::Server::Headers)
   end
 
   describe "when stubbed headers are provided" do
@@ -14,7 +14,7 @@ describe HttpStub::Models::StubHeaders 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::Models::HashWithStringValueMatchers).to receive(:new).with(downcased_and_underscored_hash)
+      expect(HttpStub::Server::HashWithStringValueMatchers).to receive(:new).with(downcased_and_underscored_hash)
 
       stub_headers
     end
@@ -26,7 +26,7 @@ describe HttpStub::Models::StubHeaders do
     let(:stubbed_headers) { nil }
 
     it "creates a regexpable representation of an empty hash" do
-      expect(HttpStub::Models::HashWithStringValueMatchers).to receive(:new).with({})
+      expect(HttpStub::Server::HashWithStringValueMatchers).to receive(:new).with({})
 
       stub_headers
     end
@@ -36,15 +36,15 @@ describe HttpStub::Models::StubHeaders do
   describe "#match?" do
 
     let(:request_headers) { { "request_key" => "value" } }
-    let(:regexpable_stubbed_headers) { double(HttpStub::Models::HashWithStringValueMatchers).as_null_object }
+    let(:regexpable_stubbed_headers) { double(HttpStub::Server::HashWithStringValueMatchers).as_null_object }
 
     before(:example) do
-      allow(HttpStub::Models::HashWithStringValueMatchers).to receive(:new).and_return(regexpable_stubbed_headers)
-      allow(HttpStub::Models::RequestHeaderParser).to receive(:parse).with(request).and_return(request_headers)
+      allow(HttpStub::Server::HashWithStringValueMatchers).to receive(:new).and_return(regexpable_stubbed_headers)
+      allow(HttpStub::Server::RequestHeaderParser).to receive(:parse).with(request).and_return(request_headers)
     end
 
     it "parses the requests headers into a hash" do
-      expect(HttpStub::Models::RequestHeaderParser).to receive(:parse).with(request).and_return(request_headers)
+      expect(HttpStub::Server::RequestHeaderParser).to receive(:parse).with(request).and_return(request_headers)
 
       stub_headers.match?(request)
     end

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

@@ -1,17 +1,17 @@
-describe HttpStub::Models::StubParameters do
+describe HttpStub::Server::StubParameters do
 
   let(:request_parameters) { double("RequestParameters") }
   let(:request) { double("HttpRequest", params: request_parameters) }
 
   let(:stubbed_parameters) { { "key1" => "value1", "key2" => "value2", "key3" => "value3" } }
-  let(:regexpable_stubbed_paremeters) { double(HttpStub::Models::HashWithStringValueMatchers).as_null_object }
+  let(:regexpable_stubbed_paremeters) { double(HttpStub::Server::HashWithStringValueMatchers).as_null_object }
 
-  let(:stub_parameters) { HttpStub::Models::StubParameters.new(stubbed_parameters) }
+  let(:stub_parameters) { HttpStub::Server::StubParameters.new(stubbed_parameters) }
 
   describe "when stubbed parameters are provided" do
 
     it "creates a regexpable representation of the stubbed parameters" do
-      expect(HttpStub::Models::HashWithStringValueMatchers).to receive(:new).with(stubbed_parameters)
+      expect(HttpStub::Server::HashWithStringValueMatchers).to receive(:new).with(stubbed_parameters)
 
       stub_parameters
     end
@@ -23,7 +23,7 @@ describe HttpStub::Models::StubParameters do
     let(:stubbed_parameters) { nil }
 
     it "creates a regexpable representation of an empty hash" do
-      expect(HttpStub::Models::HashWithStringValueMatchers).to receive(:new).with({})
+      expect(HttpStub::Server::HashWithStringValueMatchers).to receive(:new).with({})
 
       stub_parameters
     end
@@ -33,7 +33,7 @@ describe HttpStub::Models::StubParameters do
   describe "#match?" do
 
     it "delegates to the regexpable representation of the stubbed parameters to determine a match" do
-      allow(HttpStub::Models::HashWithStringValueMatchers).to receive(:new).and_return(regexpable_stubbed_paremeters)
+      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)
 
       expect(stub_parameters.match?(request)).to be(true)

data/spec/lib/http_stub/{models → server}/stub_registry_integration_spec.rb

@@ -1,9 +1,9 @@
-describe HttpStub::Models::StubRegistry, "integrating with real stubs" do
+describe HttpStub::Server::StubRegistry, "integrating with real stubs" do
 
   let(:logger)  { double("Logger").as_null_object }
   let(:request) { double("HttpRequest", logger: logger) }
 
-  let(:stub_registry) { HttpStub::Models::StubRegistry.new }
+  let(:stub_registry) { HttpStub::Server::StubRegistry.new }
 
   describe "#recall" do
 
@@ -44,7 +44,7 @@ describe HttpStub::Models::StubRegistry, "integrating with real stubs" do
   end
 
   def create_stub(number)
-    HttpStub::Models::Stub.new(
+    HttpStub::Server::Stub.new(
       {
         "uri" => "/uri#{number}",
         "method" => "get",