http_stub 0.15.5 → 0.16.0.pre1

data/spec/lib/http_stub/server/scenario/instance_spec.rb

@@ -0,0 +1,126 @@
+describe HttpStub::Server::Scenario::Instance do
+
+  let(:name)                     { "some_scenario_name" }
+  let(:number_of_stubs)          { 3 }
+  let(:stubs)                    { (1..number_of_stubs).map { instance_double(HttpStub::Server::Stub::Instance) } }
+  let(:triggered_scenario_names) { (1..3).map { |i| "triggered/scenario/name/#{i}" } }
+  let(:args) do
+    HttpStub::ScenarioFixture.new.with_name!(name).
+      with_stubs!(number_of_stubs).
+      with_triggered_scenario_names!(triggered_scenario_names).
+      server_payload
+  end
+
+  let(:scenario) { HttpStub::Server::Scenario::Instance.new(args) }
+
+  before(:example) { allow(HttpStub::Server::Stub).to receive(:create).and_return(*stubs) }
+
+  describe "#constructor" do
+
+    context "when many stub payloads are provided" do
+
+      let(:number_of_stubs) { 3 }
+
+      it "creates an underlying stub for each stub payload provided" do
+        args["stubs"].each { |stub_args| expect(HttpStub::Server::Stub).to receive(:create).with(stub_args) }
+
+        scenario
+      end
+
+    end
+
+    context "when one stub payload is provided" do
+
+      let(:number_of_stubs) { 1 }
+
+      it "creates an underlying stub for each stub payload provided" do
+        expect(HttpStub::Server::Stub).to receive(:create).with(args["stubs"].first)
+
+        scenario
+      end
+
+    end
+
+  end
+
+  describe "#satisfies?" do
+
+    subject { scenario.satisfies?(other_name) }
+
+    describe "when the scenario's name exactly matches the provided name" do
+
+      let(:other_name) { name }
+
+      it "returns true" do
+        expect(subject).to be(true)
+      end
+
+    end
+
+    describe "when the scenario's name is a substring of the provided name" do
+
+      let(:other_name) { "#{name}_with_additional_context" }
+
+      it "returns false" do
+        expect(subject).to be(false)
+      end
+
+    end
+
+    describe "when the scenario's name is completely different to the provided name" do
+
+      let(:other_name) { "completely_different_scenario_name" }
+
+      it "returns false" do
+        expect(subject).to be(false)
+      end
+
+    end
+
+  end
+
+  describe "#uri" do
+
+    it "returns the scenario's name with '/' prefixed" do
+      expect(scenario.uri).to eql("/#{name}")
+    end
+
+  end
+
+  describe "#stubs" do
+
+    it "returns the HttpStub::Server::Stub's constructed from the scenario's arguments" do
+      expect(scenario.stubs).to eql(stubs)
+    end
+
+  end
+
+  describe "#triggered_scenario_names" do
+
+    it "returns the value provided in the payload" do
+      expect(scenario.triggered_scenario_names).to eql(triggered_scenario_names)
+    end
+
+  end
+
+  describe "#triggered_scenarios" do
+
+    it "returns an array containing the triggered scenario names and uris" do
+      expected_details = triggered_scenario_names.reduce([]) { |result, name| result << [name, "/#{name}"] }
+
+      expect(scenario.triggered_scenarios).to eql(expected_details)
+    end
+
+  end
+
+  describe "#to_s" do
+
+    it "returns the string representation of the activation arguments" do
+      expect(args).to receive(:to_s).and_return("scenario string representation")
+
+      expect(scenario.to_s).to eql("scenario string representation")
+    end
+
+  end
+
+end

data/spec/lib/http_stub/server/scenario/request_parser_spec.rb

@@ -0,0 +1,59 @@
+describe HttpStub::Server::Scenario::RequestParser do
+
+  let(:request_parser) { described_class }
+
+  describe "::parse" do
+
+    let(:params)    { {} }
+    let(:body_hash) { {} }
+    let(:request)   { instance_double(Rack::Request, params: params, body: StringIO.new(body_hash.to_json)) }
+
+    subject { request_parser.parse(request) }
+
+    context "when the request contains many stubs" do
+
+      let(:payload)       { HttpStub::ScenarioFixture.new.with_stubs!(3).server_payload }
+      let(:stub_payloads) { payload["stubs"] }
+      let(:params)        { { "payload" => payload.to_json } }
+
+      it "consolidates any files into each stub payload" do
+        stub_payloads.each do |stub_payload|
+          expect(HttpStub::Server::Stub::PayloadFileConsolidator).to receive(:consolidate!).with(stub_payload, request)
+        end
+
+        subject
+      end
+
+      it "consolidates any files in each stub payload" do
+        stub_payloads.each_with_index.each do |stub_payload|
+          allow(HttpStub::Server::Stub::PayloadFileConsolidator).to receive(:consolidate!).with(stub_payload, anything)
+        end
+
+        expect(subject).to eql(payload)
+      end
+
+    end
+
+    context "when the request contains one stub" do
+
+      let(:payload)      { HttpStub::ScenarioFixture.new.with_stubs!(1).server_payload }
+      let(:stub_payload) { payload["stubs"].first }
+      let(:params)       { { "payload" => payload.to_json } }
+
+      it "consolidates any file into the stub payload" do
+        expect(HttpStub::Server::Stub::PayloadFileConsolidator).to receive(:consolidate!).with(stub_payload, request)
+
+        subject
+      end
+
+      it "consolidates any file in the stub payload" do
+        allow(HttpStub::Server::Stub::PayloadFileConsolidator).to receive(:consolidate!).with(stub_payload, anything)
+
+        expect(subject).to eql(payload)
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,24 @@
+describe HttpStub::Server::Scenario do
+
+  let(:args) { HttpStub::ScenarioFixture.new.server_payload }
+
+  describe "::create" do
+
+    subject { HttpStub::Server::Scenario.create(args) }
+
+    it "creates a scenario instance with the provided arguments" do
+      expect(HttpStub::Server::Scenario::Instance).to receive(:new).with(args)
+
+      subject
+    end
+
+    it "returns the created scenario" do
+      scenario = instance_double(HttpStub::Server::Scenario::Instance)
+      allow(HttpStub::Server::Scenario::Instance).to receive(:new).and_return(scenario)
+
+      expect(subject).to eql(scenario)
+    end
+
+  end
+
+end

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

@@ -1,16 +1,16 @@
-describe HttpStub::Server::StubController do
+describe HttpStub::Server::Stub::Controller do
 
-  let(:request)            { instance_double(Rack::Request) }
-  let(:payload)            { HttpStub::StubFixture.new.server_payload }
-  let(:response)           { instance_double(HttpStub::Server::StubResponse::Base) }
-  let(:the_stub)           { instance_double(HttpStub::Server::Stub, response: response) }
-  let(:registry)           { instance_double(HttpStub::Server::StubRegistry).as_null_object }
+  let(:request)  { instance_double(Rack::Request) }
+  let(:payload)  { HttpStub::StubFixture.new.server_payload }
+  let(:response) { instance_double(HttpStub::Server::Stub::Response::Base) }
+  let(:the_stub) { instance_double(HttpStub::Server::Stub::Instance, response: response) }
+  let(:registry) { instance_double(HttpStub::Server::Stub::Registry).as_null_object }
 
-  let(:controller) { HttpStub::Server::StubController.new(registry) }
+  let(:controller) { HttpStub::Server::Stub::Controller.new(registry) }
 
   before(:example) do
-    allow(HttpStub::Server::RequestParser).to receive(:parse).and_return(payload)
-    allow(HttpStub::Server::Stub).to receive(:new).and_return(the_stub)
+    allow(HttpStub::Server::Stub::RequestParser).to receive(:parse).and_return(payload)
+    allow(HttpStub::Server::Stub).to receive(:create).and_return(the_stub)
   end
 
   describe "#register" do
@@ -18,13 +18,13 @@ describe HttpStub::Server::StubController do
     subject { controller.register(request) }
 
     it "parses the payload from the request" do
-      expect(HttpStub::Server::RequestParser).to receive(:parse).with(request).and_return(payload)
+      expect(HttpStub::Server::Stub::RequestParser).to receive(:parse).with(request).and_return(payload)
 
       subject
     end
 
     it "creates a stub with the parsed payload" do
-      expect(HttpStub::Server::Stub).to receive(:new).with(payload).and_return(the_stub)
+      expect(HttpStub::Server::Stub).to receive(:create).with(payload).and_return(the_stub)
 
       subject
     end
@@ -45,9 +45,7 @@ describe HttpStub::Server::StubController 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
+      before(:example) { allow(registry).to receive(:find_for).with(request).and_return(the_stub) }
 
       it "returns the stubs response" do
         expect(the_stub).to receive(:response).and_return(response)
@@ -59,9 +57,7 @@ describe HttpStub::Server::StubController do
 
     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
+      before(:example) { allow(registry).to receive(:find_for).with(request).and_return(nil) }
 
       it "returns an empty response" do
         expect(controller.replay(request)).to eql(HttpStub::Server::Response::EMPTY)

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

@@ -1,6 +1,6 @@
-describe HttpStub::Server::ExactValueMatcher do
+describe HttpStub::Server::Stub::ExactValueMatcher do
 
-  describe ".match?" do
+  describe "::match?" do
 
     let(:stub_value) { "some stub value" }
 
@@ -25,7 +25,7 @@ describe HttpStub::Server::ExactValueMatcher do
     end
 
     def perform_match
-      HttpStub::Server::ExactValueMatcher.match?(stub_value, actual_value)
+      HttpStub::Server::Stub::ExactValueMatcher.match?(stub_value, actual_value)
     end
 
   end

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

@@ -1,4 +1,4 @@
-describe HttpStub::Server::HashWithStringValueMatchers do
+describe HttpStub::Server::Stub::HashWithStringValueMatchers do
 
   let(:stubbed_hash) do
     (1..3).reduce({}) do |result, i|
@@ -8,13 +8,15 @@ describe HttpStub::Server::HashWithStringValueMatchers do
   end
 
   let(:value_matchers) do
-    stubbed_hash.values.map { |value| double(HttpStub::Server::StringValueMatcher, to_s: value).as_null_object }
+    stubbed_hash.values.map { |value| double(HttpStub::Server::Stub::StringValueMatcher, to_s: value).as_null_object }
   end
 
-  let(:value_matcher_hash) { HttpStub::Server::HashWithStringValueMatchers.new(stubbed_hash) }
+  let(:value_matcher_hash) { HttpStub::Server::Stub::HashWithStringValueMatchers.new(stubbed_hash) }
 
   before(:example) do
-    value_matchers.each { |value| allow(HttpStub::Server::StringValueMatcher).to receive(:new).with(value.to_s).and_return(value) }
+    value_matchers.each do |value|
+      allow(HttpStub::Server::Stub::StringValueMatcher).to receive(:new).with(value.to_s).and_return(value)
+    end
   end
 
   it "is a hash" do
@@ -25,7 +27,7 @@ describe HttpStub::Server::HashWithStringValueMatchers do
 
     it "creates a value matcher representation of each value in the hash" do
       value_matchers.each do |value|
-        expect(HttpStub::Server::StringValueMatcher).to receive(:new).with(value.to_s).and_return(value)
+        expect(HttpStub::Server::Stub::StringValueMatcher).to receive(:new).with(value.to_s).and_return(value)
       end
 
       expect(value_matcher_hash.values).to eql(value_matchers)

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

@@ -1,8 +1,8 @@
-describe HttpStub::Server::Headers do
+describe HttpStub::Server::Stub::Headers do
 
   let(:header_hash) { {} }
 
-  let(:headers) { HttpStub::Server::Headers.new(header_hash) }
+  let(:headers) { HttpStub::Server::Stub::Headers.new(header_hash) }
 
   it "is a Hash" do
     expect(headers).to be_a(Hash)

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

@@ -0,0 +1,201 @@
+describe HttpStub::Server::Stub::Instance do
+
+  let(:request_header_payload) do
+    {
+        "header1" => "header_value1",
+        "header2" => "header_value2",
+        "header3" => "header_value3"
+    }
+  end
+  let(:request_parameter_payload) do
+    {
+        "param1" => "param_value1",
+        "param2" => "param_value2",
+        "param3" => "param_value3"
+    }
+  end
+  let(:request_method_payload) { "get" }
+  let(:trigger_payload) do
+    {
+      "uri" =>        "/a_triggered_path",
+      "method" =>     "post",
+      "headers" =>    { "triggered_header" => "triggered_header_value" },
+      "parameters" => { "triggered_parameter" => "triggered_parameter_value" },
+      "response" => {
+        "status" => 203,
+        "body" =>   "Triggered body"
+      }
+    }
+  end
+  let(:stub_payload) do
+    {
+      "uri" =>        "/a_path",
+      "method" =>     stub_method,
+      "headers" =>    request_header_payload,
+      "parameters" => request_parameter_payload,
+      "response" => {
+        "status" => 201,
+        "body" =>   "Some body"
+      },
+      "triggers" => [ trigger_payload ]
+    }
+  end
+  let(:stub_method)        { instance_double(HttpStub::Server::Stub::Method, match?: true) }
+  let(:uri)                { instance_double(HttpStub::Server::Stub::Uri, match?: true) }
+  let(:request_headers)    { instance_double(HttpStub::Server::Stub::RequestHeaders, match?: true) }
+  let(:request_parameters) { instance_double(HttpStub::Server::Stub::RequestParameters, match?: true) }
+  let(:response)           { instance_double(HttpStub::Server::Stub::Response::Base) }
+  let(:triggers)           { instance_double(HttpStub::Server::Stub::Triggers) }
+
+  let(:the_stub) { HttpStub::Server::Stub::Instance.new(stub_payload) }
+
+  before(:example) do
+    allow(HttpStub::Server::Stub::Method).to receive(:new).and_return(stub_method)
+    allow(HttpStub::Server::Stub::Uri).to receive(:new).and_return(uri)
+    allow(HttpStub::Server::Stub::RequestHeaders).to receive(:new).and_return(request_headers)
+    allow(HttpStub::Server::Stub::RequestParameters).to receive(:new).and_return(request_parameters)
+    allow(HttpStub::Server::Stub::Response).to receive(:create).and_return(response)
+    allow(HttpStub::Server::Stub::Triggers).to receive(:new).and_return(triggers)
+  end
+
+  describe "#satisfies?" do
+
+    let(:request_method) { request_method_payload }
+    let(:request_uri)    { "/a_request_uri" }
+    let(:request)        { instance_double(Rack::Request, :request_method => request_method_payload) }
+
+    describe "when the request uri matches" do
+
+      before(:example) { allow(uri).to receive(:match?).with(request).and_return(true) }
+
+      describe "and the request method matches" do
+
+        describe "and a header match is configured" do
+
+          describe "that matches" do
+
+            before(:example) { allow(request_headers).to receive(:match?).with(request).and_return(true) }
+
+            describe "and a parameter match is configured" do
+
+              describe "that matches" do
+
+                before(:example) { allow(request_parameters).to receive(:match?).with(request).and_return(true) }
+
+                it "returns true" do
+                  expect(the_stub.satisfies?(request)).to be_truthy
+                end
+
+              end
+
+            end
+
+          end
+
+        end
+
+      end
+
+    end
+
+    describe "when the request method does not match" do
+
+      before(:example) { allow(stub_method).to receive(:match?).with(request).and_return(false) }
+
+      it "returns false" do
+        expect(the_stub.satisfies?(request)).to be(false)
+      end
+
+    end
+
+    describe "when the request uri does not match" do
+
+      before(:example) { allow(uri).to receive(:match?).with(request).and_return(false) }
+
+      it "returns false" do
+        expect(the_stub.satisfies?(request)).to be(false)
+      end
+
+    end
+
+    describe "when the headers do not match" do
+
+      before(:example) { allow(request_headers).to receive(:match?).with(request).and_return(false) }
+
+      it "returns false" do
+        expect(the_stub.satisfies?(request)).to be(false)
+      end
+
+    end
+
+    describe "when the parameters do not match" do
+
+      before(:example) { allow(request_parameters).to receive(:match?).with(request).and_return(false) }
+
+      it "returns false" do
+        expect(the_stub.satisfies?(request)).to be(false)
+      end
+
+    end
+
+  end
+
+  describe "#method" do
+
+    it "returns the method model encapsulating the method provided in the request body" do
+      expect(the_stub.method).to eql(stub_method)
+    end
+
+  end
+
+  describe "#uri" do
+
+    it "returns the rui model encapsulating the uri provided in the request body" do
+      expect(the_stub.uri).to eql(uri)
+    end
+
+  end
+
+  describe "#headers" do
+
+    it "returns the headers model encapsulating the headers provided in the request body" do
+      expect(the_stub.headers).to eql(request_headers)
+    end
+
+  end
+
+  describe "#parameters" do
+
+    it "returns the parameters model encapsulating the parameters provided in the request body" do
+      expect(the_stub.parameters).to eql(request_parameters)
+    end
+
+  end
+
+  describe "#response" do
+
+    it "exposes the response model encapsulating the response provided in the request body" do
+      expect(the_stub.response).to eql(response)
+    end
+
+  end
+
+  describe "#triggers" do
+
+    it "returns the triggers model encapsulating the triggers provided in the request body" do
+      expect(the_stub.triggers).to eql(triggers)
+    end
+
+  end
+
+  describe "#to_s" do
+
+    it "returns a string representation of the stub arguments" do
+      expect(stub_payload).to receive(:to_s).and_return("stub arguments string")
+
+      expect(the_stub.to_s).to eql("stub arguments string")
+    end
+
+  end
+
+end