http_stub 0.19.1 → 0.20.0

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

@@ -0,0 +1,113 @@
+describe HttpStub::Server::Request do
+
+  let(:rack_path_info)      { "/rack/path/info" }
+  let(:rack_request_method) { "some method" }
+  let(:rack_parameters)     { { "parameter_key" => "parameter value" } }
+  let(:rack_body)           { "some request body" }
+  let(:rack_request)        do
+    instance_double(Rack::Request, path_info:      rack_path_info,
+                                   request_method: rack_request_method,
+                                   params:         rack_parameters,
+                                   body:           StringIO.new(rack_body))
+  end
+
+  let(:server_request) { described_class.new(rack_request) }
+
+  before(:example) do
+    allow(HttpStub::Server::HeaderParser).to receive(:parse).and_return({})
+    allow(HttpStub::Server::FormattedHash).to receive(:new)
+  end
+
+  describe "#uri" do
+
+    it "is the rack request path information" do
+      expect(server_request.uri).to eql(rack_path_info)
+    end
+
+  end
+
+  describe "#method" do
+
+    subject { server_request.method }
+
+    it "is the rack request method" do
+      expect(subject).to eql(rack_request_method)
+    end
+
+  end
+
+  describe "#headers" do
+
+    let(:parsed_headers) { { "parsed_header_key" => "parsed header value" } }
+    let(:formatted_hash) { instance_double(HttpStub::Server::FormattedHash) }
+
+    subject { server_request.headers }
+
+    before(:example) do
+      allow(HttpStub::Server::HeaderParser).to receive(:parse).and_return(parsed_headers)
+      allow(HttpStub::Server::FormattedHash).to receive(:new).with(parsed_headers, anything).and_return(formatted_hash)
+    end
+
+    it "parses the headers from the rack request via the header parser" do
+      expect(HttpStub::Server::HeaderParser).to receive(:parse).with(rack_request)
+
+      subject
+    end
+
+    it "creates a formatted hash containing the parsed headers" do
+      expect(HttpStub::Server::FormattedHash).to receive(:new).with(parsed_headers, anything)
+
+      subject
+    end
+
+    it "creates a formatted hash formatted by a ':' request value delimiter" do
+      expect(HttpStub::Server::FormattedHash).to receive(:new).with(anything, ":")
+
+      subject
+    end
+
+    it "is the formattted hash" do
+      expect(subject).to eql(formatted_hash)
+    end
+
+  end
+
+  describe "#parameters" do
+
+    let(:formatted_hash) { instance_double(HttpStub::Server::FormattedHash) }
+
+    subject { server_request.parameters }
+
+    before(:example) do
+      allow(HttpStub::Server::FormattedHash).to receive(:new).with(rack_parameters, anything).and_return(formatted_hash)
+    end
+
+    it "creates a formatted hash containing the rack request parameters" do
+      expect(HttpStub::Server::FormattedHash).to receive(:new).with(rack_parameters, anything)
+
+      subject
+    end
+
+    it "creates a formatted hash with a '=' request value delimiter" do
+      expect(HttpStub::Server::FormattedHash).to receive(:new).with(anything, "=")
+
+      subject
+    end
+
+    it "is the formatted hash" do
+      expect(subject).to eql(formatted_hash)
+    end
+
+  end
+
+  describe "#body" do
+
+    subject { server_request.body }
+
+    it "is the read rack request body" do
+      expect(subject).to eql(rack_body)
+    end
+
+  end
+
+end

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

@@ -1,39 +1,73 @@
 describe HttpStub::Server::Response do
 
-  describe "::SUCCESS" do
-
-    let(:response) { HttpStub::Server::Response::SUCCESS }
+  shared_examples_for "a success response" do
 
     it "has a status of 200" do
-      expect(response.status).to eql(200)
+      expect(subject.status).to eql(200)
     end
 
     it "has a body containing OK to visually indicate success to those interacting via a browser" do
-      expect(response.body).to match(/OK/)
+      expect(subject.body).to match(/OK/)
+    end
+
+  end
+
+  describe "::success" do
+
+    subject { HttpStub::Server::Response::success }
+
+    it_behaves_like "a success response"
+
+    context "when headers are provided" do
+
+      let(:headers) { { "response_header_key" => "response header value" } }
+
+      subject { HttpStub::Server::Response::success(headers) }
+
+      it "established the headers" do
+        expect(subject.headers).to eql(headers)
+      end
+
     end
 
   end
 
-  describe "::ERROR" do
+  describe "::SUCCESS" do
+
+    subject { HttpStub::Server::Response::SUCCESS }
+
+    it_behaves_like "a success response"
+
+  end
+
+  describe "::NOT_FOUND" do
 
-    let(:response) { HttpStub::Server::Response::ERROR }
+    subject { HttpStub::Server::Response::NOT_FOUND }
 
     it "has a status of 404" do
-      expect(response.status).to eql(404)
+      expect(subject.status).to eql(404)
     end
 
-    it "has a body containing ERROR to visually indicate the error to those interacting via a browser" do
-      expect(response.body).to match(/ERROR/)
+    it "has a body containing NOT FOUND to visually indicate the response to those interacting via a browser" do
+      expect(subject.body).to match(/NOT FOUND/)
     end
 
   end
 
   describe "::EMPTY" do
 
-    let(:response) { HttpStub::Server::Response::EMPTY }
+    subject { HttpStub::Server::Response::EMPTY }
+
+    it "has a status of 200" do
+      expect(subject.status).to eql(200)
+    end
+
+    it "has no body" do
+      expect(subject.body).to be(nil)
+    end
 
     it "is empty" do
-      expect(response.empty?).to be(true)
+      expect(subject).to be_empty
     end
 
   end

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

@@ -1,25 +1,25 @@
 describe HttpStub::Server::Scenario::Activator do
 
-  let(:request)                 { instance_double(Rack::Request) }
-  let(:stubs)                   { (1..3).map { instance_double(HttpStub::Server::Stub::Instance) } }
+  let(:logger)                   { instance_double(Logger) }
+  let(:stubs)                    { (1..3).map { instance_double(HttpStub::Server::Stub::Stub) } }
   let(:triggered_scenario_names) { [] }
-  let(:scenario)                do
+  let(:scenario)                 do
     instance_double(
-      HttpStub::Server::Scenario::Instance, stubs: stubs, triggered_scenario_names: triggered_scenario_names
+      HttpStub::Server::Scenario::Scenario, stubs: stubs, triggered_scenario_names: triggered_scenario_names
     )
   end
-  let(:scenario_registry)       { instance_double(HttpStub::Server::Registry).as_null_object }
-  let(:stub_registry)           { instance_double(HttpStub::Server::Stub::Registry).as_null_object }
-  let(:activator_class)         { HttpStub::Server::Scenario::Activator }
+  let(:scenario_registry)        { instance_double(HttpStub::Server::Registry).as_null_object }
+  let(:stub_registry)            { instance_double(HttpStub::Server::Stub::Registry).as_null_object }
+  let(:activator_class)          { HttpStub::Server::Scenario::Activator }
 
   let(:activator) { activator_class.new(scenario_registry, stub_registry) }
 
   describe "#activate" do
 
-    subject { activator.activate(scenario, request) }
+    subject { activator.activate(scenario, logger) }
 
-    it "adds the scenario's stubs to the stub registry with the provided request" do
-      expect(stub_registry).to receive(:concat).with(stubs, request)
+    it "adds the scenario's stubs to the stub registry with the provided logger" do
+      expect(stub_registry).to receive(:concat).with(stubs, logger)
 
       subject
     end
@@ -29,14 +29,14 @@ describe HttpStub::Server::Scenario::Activator do
       let(:triggered_scenario_names) { (1..3).map { |i| "triggered_scenario_name/#{i}" } }
       let(:triggered_scenarios) do
         triggered_scenario_names.map do
-          instance_double(HttpStub::Server::Scenario::Instance, stubs: [], triggered_scenario_names: [])
+          instance_double(HttpStub::Server::Scenario::Scenario, stubs: [], triggered_scenario_names: [])
         end
       end
 
       before(:each) do
         triggered_scenario_names.zip(triggered_scenarios).each do |triggered_scenario_name, triggered_scenario|
           allow(scenario_registry).to(
-            receive(:find).with(hash_including(criteria: triggered_scenario_name)).and_return(triggered_scenario)
+            receive(:find).with(triggered_scenario_name, anything).and_return(triggered_scenario)
           )
         end
       end
@@ -44,7 +44,7 @@ describe HttpStub::Server::Scenario::Activator do
       it "finds each triggered scenario in the scenario registry" do
         triggered_scenario_names.zip(triggered_scenarios).each do |triggered_scenario_name, triggered_scenario|
           expect(scenario_registry).to(
-            receive(:find).with(criteria: triggered_scenario_name, request: request).and_return(triggered_scenario)
+            receive(:find).with(triggered_scenario_name, logger).and_return(triggered_scenario)
           )
         end
 
@@ -62,8 +62,8 @@ describe HttpStub::Server::Scenario::Activator do
             @activate_args = []
           end
 
-          def activate(scenario, request)
-            @activate_args << [ scenario, request ]
+          def activate(scenario, logger)
+            @activate_args << [ scenario, logger ]
             super
           end
 
@@ -72,8 +72,8 @@ describe HttpStub::Server::Scenario::Activator do
         let(:activator_class) { HttpStub::Server::Scenario::ActivatorRetainingActivateArgs }
 
         it "activates the scenario's" do
-          expected_activate_args = triggered_scenarios.reduce([ [ scenario, request ] ]) do |result, triggered_scenario|
-            result << [ triggered_scenario, request ]
+          expected_activate_args = triggered_scenarios.reduce([ [ scenario, logger ] ]) do |result, triggered_scenario|
+            result << [ triggered_scenario, logger ]
           end
 
           subject
@@ -89,7 +89,7 @@ describe HttpStub::Server::Scenario::Activator do
 
         before(:example) do
           allow(scenario_registry).to(
-            receive(:find).with(hash_including(criteria: scenario_name_not_found)).and_return(nil)
+            receive(:find).with(scenario_name_not_found, anything).and_return(nil)
           )
         end
 

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

@@ -1,10 +1,11 @@
 describe HttpStub::Server::Scenario::Controller do
 
-  let(:request_path_info) { "/some/request/path" }
-  let(:request)           { instance_double(Rack::Request, path_info: request_path_info) }
+  let(:request_uri)       { "/some/request/path" }
+  let(:request)           { instance_double(HttpStub::Server::Request, uri: request_uri) }
+  let(:logger)            { instance_double(Logger) }
   let(:payload)           { HttpStub::ScenarioFixture.new.server_payload }
-  let(:stubs)             { (1..3).map { instance_double(HttpStub::Server::Stub::Instance) } }
-  let(:scenario)          { instance_double(HttpStub::Server::Scenario::Instance, stubs: stubs) }
+  let(:stubs)             { (1..3).map { instance_double(HttpStub::Server::Stub::Stub) } }
+  let(:scenario)          { instance_double(HttpStub::Server::Scenario::Scenario, stubs: stubs) }
   let(:scenario_registry) { instance_double(HttpStub::Server::Registry).as_null_object }
   let(:stub_registry)     { instance_double(HttpStub::Server::Stub::Registry).as_null_object }
   let(:activator)         { instance_double(HttpStub::Server::Scenario::Activator).as_null_object }
@@ -13,16 +14,16 @@ describe HttpStub::Server::Scenario::Controller do
 
   before(:example) do
     allow(HttpStub::Server::Scenario::Activator).to receive(:new).and_return(activator)
-    allow(HttpStub::Server::Scenario::RequestParser).to receive(:parse).and_return(payload)
+    allow(HttpStub::Server::Scenario::Parser).to receive(:parse).and_return(payload)
     allow(HttpStub::Server::Scenario).to receive(:create).and_return(scenario)
   end
 
   describe "#register" do
 
-    subject { controller.register(request) }
+    subject { controller.register(request, logger) }
 
     it "parses the payload from the request" do
-      expect(HttpStub::Server::Scenario::RequestParser).to receive(:parse).with(request).and_return(payload)
+      expect(HttpStub::Server::Scenario::Parser).to receive(:parse).with(request).and_return(payload)
 
       subject
     end
@@ -33,8 +34,8 @@ describe HttpStub::Server::Scenario::Controller do
       subject
     end
 
-    it "adds the created scenario to the scenario registry with the provided request" do
-      expect(scenario_registry).to receive(:add).with(scenario, request)
+    it "adds the created scenario to the scenario registry with the provided logger" do
+      expect(scenario_registry).to receive(:add).with(scenario, logger)
 
       subject
     end
@@ -47,20 +48,20 @@ describe HttpStub::Server::Scenario::Controller do
 
   describe "#activate" do
 
-    subject { controller.activate(request) }
+    subject { controller.activate(request, logger) }
 
     it "finds a scenario whose name matches the request path omitting the '/' prefix" do
-      expect(scenario_registry).to receive(:find).with(criteria: "some/request/path", request: request)
+      expect(scenario_registry).to receive(:find).with("some/request/path", logger)
 
       subject
     end
 
-    describe "when a scenario is found that satisfies the request" do
+    describe "when a scenario is found that matches the request" do
 
       before(:example) { allow(scenario_registry).to receive(:find).and_return(scenario) }
 
       it "activates the scenario via the activator" do
-        expect(activator).to receive(:activate).with(scenario, request)
+        expect(activator).to receive(:activate).with(scenario, logger)
 
         subject
       end
@@ -91,10 +92,12 @@ describe HttpStub::Server::Scenario::Controller do
 
   describe "#clear" do
 
+    subject { controller.clear(logger) }
+
     it "clears the scenario registry" do
-      expect(scenario_registry).to receive(:clear).with(request)
+      expect(scenario_registry).to receive(:clear).with(logger)
 
-      controller.clear(request)
+      subject
     end
 
   end

data/spec/lib/http_stub/server/scenario/{request_parser_spec.rb → parser_spec.rb}

@@ -1,20 +1,20 @@
-describe HttpStub::Server::Scenario::RequestParser do
+describe HttpStub::Server::Scenario::Parser do
 
-  let(:request_parser) { described_class }
+  let(: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)) }
+    let(:parameters) { {} }
+    let(:body_hash)  { {} }
+    let(:request)    { instance_double(HttpStub::Server::Request, parameters: parameters, body: body_hash.to_json) }
 
-    subject { request_parser.parse(request) }
+    subject { 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 } }
+      let(:parameters)    { { "payload" => payload.to_json } }
 
       it "consolidates any files into each stub payload" do
         stub_payloads.each do |stub_payload|
@@ -38,7 +38,7 @@ describe HttpStub::Server::Scenario::RequestParser do
 
       let(:payload)      { HttpStub::ScenarioFixture.new.with_stubs!(1).server_payload }
       let(:stub_payload) { payload["stubs"].first }
-      let(:params)       { { "payload" => payload.to_json } }
+      let(:parameters)   { { "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)

data/spec/lib/http_stub/server/scenario/{instance_spec.rb → scenario_spec.rb}

@@ -1,8 +1,8 @@
-describe HttpStub::Server::Scenario::Instance do
+describe HttpStub::Server::Scenario::Scenario 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(:stubs)                    { (1..number_of_stubs).map { instance_double(HttpStub::Server::Stub::Stub) } }
   let(:triggered_scenario_names) { (1..3).map { |i| "triggered/scenario/name/#{i}" } }
   let(:args) do
     HttpStub::ScenarioFixture.new.with_name!(name).
@@ -11,7 +11,7 @@ describe HttpStub::Server::Scenario::Instance do
       server_payload
   end
 
-  let(:scenario) { HttpStub::Server::Scenario::Instance.new(args) }
+  let(:scenario) { HttpStub::Server::Scenario::Scenario.new(args) }
 
   before(:example) { allow(HttpStub::Server::Stub).to receive(:create).and_return(*stubs) }
 
@@ -43,9 +43,11 @@ describe HttpStub::Server::Scenario::Instance do
 
   end
 
-  describe "#satisfies?" do
+  describe "#matches?" do
 
-    subject { scenario.satisfies?(other_name) }
+    let(:logger) { instance_double(Logger) }
+
+    subject { scenario.matches?(other_name, logger) }
 
     describe "when the scenario's name exactly matches the provided name" do
 

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

@@ -7,14 +7,14 @@ describe HttpStub::Server::Scenario 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)
+      expect(HttpStub::Server::Scenario::Scenario).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)
+      scenario = instance_double(HttpStub::Server::Scenario::Scenario)
+      allow(HttpStub::Server::Scenario::Scenario).to receive(:new).and_return(scenario)
 
       expect(subject).to eql(scenario)
     end