http_stub 0.15.5 → 0.16.0.pre1

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

@@ -0,0 +1,56 @@
+describe HttpStub::Server::Stub::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 a payload parameter" do
+
+      let(:payload) { HttpStub::StubFixture.new.server_payload }
+      let(:params)  { { "payload" => payload.to_json } }
+
+      it "consolidates any files into the payload" do
+        expect(HttpStub::Server::Stub::PayloadFileConsolidator).to receive(:consolidate!).with(payload, request)
+
+        subject
+      end
+
+      it "returns the consolidated payload" do
+        consolidated_payload = { consolidated_payload_key: "consolidated payload value" }
+        allow(HttpStub::Server::Stub::PayloadFileConsolidator).to(
+          receive(:consolidate!).and_return(consolidated_payload)
+        )
+
+        expect(subject).to eql(consolidated_payload)
+      end
+
+    end
+
+    context "when the request body contains the payload (for API backwards compatibility)" do
+
+      let(:body_hash) { HttpStub::StubFixture.new.server_payload }
+
+      it "consolidates any files into the body" do
+        expect(HttpStub::Server::Stub::PayloadFileConsolidator).to receive(:consolidate!).with(body_hash, request)
+
+        subject
+      end
+
+      it "returns the consolidated body" do
+        consolidated_body = { consolidated_body_key: "consolidated body value" }
+        allow(HttpStub::Server::Stub::PayloadFileConsolidator).to receive(:consolidate!).and_return(consolidated_body)
+
+        expect(subject).to eql(consolidated_body)
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/http_stub/server/{stub_response → stub/response}/base_spec.rb

@@ -1,4 +1,4 @@
-describe HttpStub::Server::StubResponse::Base do
+describe HttpStub::Server::Stub::Response::Base do
 
   let(:status)           { 202 }
   let(:headers)          { nil }
@@ -8,7 +8,7 @@ describe HttpStub::Server::StubResponse::Base do
     { "status" => status, "headers" => headers, "body" => body, "delay_in_seconds" => delay_in_seconds }
   end
 
-  let(:testable_response_class) { Class.new(HttpStub::Server::StubResponse::Base) }
+  let(:testable_response_class) { Class.new(HttpStub::Server::Stub::Response::Base) }
 
   let(:response) { testable_response_class.new(args) }
 
@@ -97,7 +97,7 @@ describe HttpStub::Server::StubResponse::Base do
     let(:response_header_hash) { response.headers.to_hash }
 
     it "is Headers" do
-      expect(response.headers).to be_a(HttpStub::Server::Headers)
+      expect(response.headers).to be_a(HttpStub::Server::Stub::Headers)
     end
 
     context "when default headers have been added" do
@@ -186,10 +186,10 @@ describe HttpStub::Server::StubResponse::Base do
 
   describe "#type" do
 
-    class HttpStub::Server::StubResponse::TestableBaseClass < HttpStub::Server::StubResponse::Base
+    class HttpStub::Server::Stub::Response::TestableBaseClass < HttpStub::Server::Stub::Response::Base
     end
 
-    let(:testable_response_class) { HttpStub::Server::StubResponse::TestableBaseClass }
+    let(:testable_response_class) { HttpStub::Server::Stub::Response::TestableBaseClass }
 
     it "returns the name of the concrete base instance underscored" do
       expect(response.type).to eql("testable_base_class")

data/spec/lib/http_stub/server/{stub_response → stub/response}/file_spec.rb

@@ -1,4 +1,4 @@
-describe HttpStub::Server::StubResponse::File do
+describe HttpStub::Server::Stub::Response::File do
 
   let(:status)         { 321 }
   let(:headers)        { {} }
@@ -12,10 +12,10 @@ describe HttpStub::Server::StubResponse::File do
     }
   end
 
-  let(:response_file) { HttpStub::Server::StubResponse::File.new(args) }
+  let(:response_file) { HttpStub::Server::Stub::Response::File.new(args) }
 
   it "is a base response" do
-    expect(response_file).to be_a(HttpStub::Server::StubResponse::Base)
+    expect(response_file).to be_a(HttpStub::Server::Stub::Response::Base)
   end
 
   describe "#uri" do

data/spec/lib/http_stub/server/{stub_response → stub/response}/text_spec.rb

@@ -1,14 +1,14 @@
-describe HttpStub::Server::StubResponse::Text do
+describe HttpStub::Server::Stub::Response::Text do
 
   let(:status)  { 123 }
   let(:headers) { {} }
   let(:body)    { "Some text body" }
   let(:args) { { "status" => status, "headers" => headers, "body" => body } }
 
-  let(:response_text) { HttpStub::Server::StubResponse::Text.new(args) }
+  let(:response_text) { HttpStub::Server::Stub::Response::Text.new(args) }
 
   it "is a base response" do
-    expect(response_text).to be_a(HttpStub::Server::StubResponse::Base)
+    expect(response_text).to be_a(HttpStub::Server::Stub::Response::Base)
   end
 
   describe "#serve_on" do

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

@@ -1,24 +1,24 @@
-describe HttpStub::Server::StubResponse do
+describe HttpStub::Server::Stub::Response do
 
   describe "::create" do
 
     let(:response_args) { { "body" => body } }
 
-    subject { HttpStub::Server::StubResponse.create(response_args) }
+    subject { HttpStub::Server::Stub::Response.create(response_args) }
 
     context "when the body contains text" do
 
       let(:body) { "some text" }
 
       it "creates a text response" do
-        expect(HttpStub::Server::StubResponse::Text).to receive(:new).with(response_args)
+        expect(HttpStub::Server::Stub::Response::Text).to receive(:new).with(response_args)
 
         subject
       end
 
       it "returns the created response" do
-        response = instance_double(HttpStub::Server::StubResponse::Text)
-        allow(HttpStub::Server::StubResponse::Text).to receive(:new).and_return(response)
+        response = instance_double(HttpStub::Server::Stub::Response::Text)
+        allow(HttpStub::Server::Stub::Response::Text).to receive(:new).and_return(response)
 
         expect(subject).to eql(response)
       end
@@ -30,14 +30,14 @@ describe HttpStub::Server::StubResponse do
       let(:body) { { "file" => { "path" => "a/file.path", "name" => "a_file.name" } } }
 
       it "creates a file response" do
-        expect(HttpStub::Server::StubResponse::File).to receive(:new).with(response_args)
+        expect(HttpStub::Server::Stub::Response::File).to receive(:new).with(response_args)
 
         subject
       end
 
       it "returns the created response" do
-        response = instance_double(HttpStub::Server::StubResponse::File)
-        allow(HttpStub::Server::StubResponse::File).to receive(:new).and_return(response)
+        response = instance_double(HttpStub::Server::Stub::Response::File)
+        allow(HttpStub::Server::Stub::Response::File).to receive(:new).and_return(response)
 
         expect(subject).to eql(response)
       end

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

@@ -1,8 +1,8 @@
-describe HttpStub::Server::StringValueMatcher do
+describe HttpStub::Server::Stub::StringValueMatcher do
 
   let(:stub_value) { "some stub value" }
 
-  let(:string_value_matcher) { HttpStub::Server::StringValueMatcher.new(stub_value) }
+  let(:string_value_matcher) { HttpStub::Server::Stub::StringValueMatcher.new(stub_value) }
 
   describe "#match?" do
 
@@ -11,37 +11,49 @@ describe HttpStub::Server::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::Server::OmittedValueMatcher).to receive(:match?).with(expected_stub_match_value, actual_value)
+        expect(HttpStub::Server::Stub::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::Server::RegexpValueMatcher).to receive(:match?).with(expected_stub_match_value, actual_value)
+        expect(HttpStub::Server::Stub::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::Server::ExactValueMatcher).to receive(:match?).with(expected_stub_match_value, actual_value)
+        expect(HttpStub::Server::Stub::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::Server::OmittedValueMatcher).to receive(:match?).with(expected_stub_match_value, actual_value)
+        expect(HttpStub::Server::Stub::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::Server::RegexpValueMatcher).to receive(:match?).with(expected_stub_match_value, actual_value)
+        expect(HttpStub::Server::Stub::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::Server::ExactValueMatcher).to receive(:match?).with(expected_stub_match_value, actual_value)
+        expect(HttpStub::Server::Stub::ExactValueMatcher).to(
+          receive(:match?).with(expected_stub_match_value, actual_value)
+        )
 
         perform_match
       end
@@ -50,7 +62,7 @@ describe HttpStub::Server::StringValueMatcher do
 
     context "when the provided stub value is a string" do
 
-      let(:stub_value) { "some stub value" }
+      let(:stub_value)                { "some stub value" }
       let(:expected_stub_match_value) { "some stub value" }
 
       it_should_behave_like "a StringValueMatcher that matches an expected stub value"
@@ -59,7 +71,7 @@ describe HttpStub::Server::StringValueMatcher do
 
     context "when the provided stub value is not a string" do
 
-      let(:stub_value) { 88 }
+      let(:stub_value)                { 88 }
       let(:expected_stub_match_value) { "88" }
 
       it_should_behave_like "a StringValueMatcher that matches an expected stub value"
@@ -68,7 +80,7 @@ describe HttpStub::Server::StringValueMatcher do
 
     context "when an omitted match occurs" do
 
-      before(:example) { expect(HttpStub::Server::OmittedValueMatcher).to receive(:match?).and_return(true) }
+      before(:example) { expect(HttpStub::Server::Stub::OmittedValueMatcher).to receive(:match?).and_return(true) }
 
       it "returns true" do
         expect(perform_match).to be_truthy
@@ -78,7 +90,7 @@ describe HttpStub::Server::StringValueMatcher do
 
     context "when a regular expression match occurs" do
 
-      before(:example) { expect(HttpStub::Server::RegexpValueMatcher).to receive(:match?).and_return(true) }
+      before(:example) { expect(HttpStub::Server::Stub::RegexpValueMatcher).to receive(:match?).and_return(true) }
 
       it "returns true" do
         expect(perform_match).to be_truthy
@@ -88,7 +100,7 @@ describe HttpStub::Server::StringValueMatcher do
 
     context "when an exact match occurs" do
 
-      before(:example) { expect(HttpStub::Server::ExactValueMatcher).to receive(:match?).and_return(true) }
+      before(:example) { expect(HttpStub::Server::Stub::ExactValueMatcher).to receive(:match?).and_return(true) }
 
       it "returns true" do
         expect(perform_match).to be_truthy

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

@@ -1,18 +1,16 @@
-describe HttpStub::Server::StubTriggers do
+describe HttpStub::Server::Stub::Triggers do
 
   let(:trigger_bodies)     { (1..3).map { |i| "trigger body #{i}" } }
-  let(:stubs_for_triggers) { (1..trigger_bodies.length).map { instance_double(HttpStub::Server::Stub) } }
-  let(:stub_triggers)      { HttpStub::Server::StubTriggers.new(trigger_bodies) }
+  let(:stubs_for_triggers) { (1..trigger_bodies.length).map { instance_double(HttpStub::Server::Stub::Instance) } }
+  let(:stub_triggers)      { HttpStub::Server::Stub::Triggers.new(trigger_bodies) }
 
-  before(:example) do
-    allow(HttpStub::Server::Stub).to receive(:new).and_return(*stubs_for_triggers)
-  end
+  before(:example) { allow(HttpStub::Server::Stub).to receive(:create).and_return(*stubs_for_triggers) }
 
   describe "constructor" do
 
     it "creates a stub for each provided trigger" do
       trigger_bodies.zip(stubs_for_triggers).each do |body, stub|
-        expect(HttpStub::Server::Stub).to receive(:new).with(body).and_return(stub)
+        expect(HttpStub::Server::Stub).to receive(:create).with(body).and_return(stub)
       end
 
       stub_triggers
@@ -22,8 +20,8 @@ describe HttpStub::Server::StubTriggers do
 
   describe "#add_to" do
 
-    let(:registry) { instance_double(HttpStub::Server::StubRegistry) }
-    let(:request)  { instance_double("HttpRequest") }
+    let(:registry) { instance_double(HttpStub::Server::Stub::Registry) }
+    let(:request)  { instance_double(Rack::Request) }
 
     it "adds each stub to the provided registry" do
       stubs_for_triggers.each { |stub_for_trigger| expect(registry).to receive(:add).with(stub_for_trigger, request) }

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

@@ -0,0 +1,43 @@
+describe HttpStub::Server::Stub::Uri do
+
+  let(:raw_uri)       { "/some/uri" }
+  let(:value_matcher) { instance_double(HttpStub::Server::Stub::StringValueMatcher).as_null_object }
+
+  let(:uri) { HttpStub::Server::Stub::Uri.new(raw_uri) }
+
+  before(:example) { allow(HttpStub::Server::Stub::StringValueMatcher).to receive(:new).and_return(value_matcher) }
+
+  describe "constructor" do
+
+    it "creates a value matcher for the provided uri" do
+      expect(HttpStub::Server::Stub::StringValueMatcher).to receive(:new).with(raw_uri)
+
+      uri
+    end
+
+  end
+
+  describe "#match?" do
+
+    let(:request_uri) { "/some/uri" }
+    let(:request)     { instance_double(Rack::Request, path_info: request_uri) }
+
+    it "delegates to the value matcher representation of the provided uri" do
+      expect(value_matcher).to receive(:match?).with(request_uri).and_return(true)
+
+      expect(uri.match?(request)).to be_truthy
+    end
+
+  end
+
+  describe "#to_s" do
+
+    it "delegates to the value matcher representation of the provided uri" do
+      expect(value_matcher).to receive(:to_s).and_return("some value matcher string")
+
+      expect(uri.to_s).to eql("some value matcher string")
+    end
+
+  end
+
+end

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

@@ -1,197 +1,22 @@
 describe HttpStub::Server::Stub do
 
-  let(:raw_stub_headers) do
-    {
-        "header1" => "header_value1",
-        "header2" => "header_value2",
-        "header3" => "header_value3"
-    }
-  end
-  let(:raw_stub_parameters) do
-    {
-        "param1" => "param_value1",
-        "param2" => "param_value2",
-        "param3" => "param_value3"
-    }
-  end
-  let(:stub_method) { "get" }
-  let(:stub_trigger) 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_args) do
-    {
-      "uri" =>        "/a_path",
-      "method" =>     stub_method,
-      "headers" =>    raw_stub_headers,
-      "parameters" => raw_stub_parameters,
-      "response" => {
-        "status" => 201,
-        "body" =>   "Some body"
-      },
-      "triggers" => [ stub_trigger ]
-    }
-  end
-  let(:stub_uri)        { instance_double(HttpStub::Server::StubUri, match?: true) }
-  let(:stub_headers)    { instance_double(HttpStub::Server::StubHeaders, match?: true) }
-  let(:stub_parameters) { instance_double(HttpStub::Server::StubParameters, match?: true) }
-  let(:stub_response)   { instance_double(HttpStub::Server::StubResponse::Base) }
-  let(:stub_triggers)   { instance_double(HttpStub::Server::StubTriggers) }
-
-  let(:the_stub) { HttpStub::Server::Stub.new(stub_args) }
-
-  before(:example) do
-    allow(HttpStub::Server::StubUri).to receive(:new).and_return(stub_uri)
-    allow(HttpStub::Server::StubHeaders).to receive(:new).and_return(stub_headers)
-    allow(HttpStub::Server::StubParameters).to receive(:new).and_return(stub_parameters)
-    allow(HttpStub::Server::StubResponse).to receive(:create).and_return(stub_response)
-    allow(HttpStub::Server::StubTriggers).to receive(:new).and_return(stub_triggers)
-  end
-
-  describe "#satisfies?" do
-
-    let(:request_uri)    { "/a_request_uri" }
-    let(:request_method) { stub_method }
-    let(:request)        { instance_double(Rack::Request, :request_method => request_method) }
-
-    describe "when the request uri matches" do
-
-      before(:example) { allow(stub_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(stub_headers).to receive(:match?).with(request).and_return(true) }
-
-            describe "and a parameter match is configured" do
-
-              describe "that matches" do
-
-                before(:example) { allow(stub_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 uri does not match" do
-
-      before(:example) { allow(stub_uri).to receive(:match?).with(request).and_return(false) }
-
-      it "returns false" do
-        expect(the_stub.satisfies?(request)).to be_falsey
-      end
-
-    end
-
-    describe "when the request method does not match" do
-
-      let(:request_method) { "post" }
-
-      it "returns false" do
-        expect(the_stub.satisfies?(request)).to be_falsey
-      end
-
-    end
-
-    describe "when the headers do not match" do
+  let(:args) { HttpStub::StubFixture.new.server_payload }
 
-      before(:example) { allow(stub_headers).to receive(:match?).with(request).and_return(false) }
+  describe "::create" do
 
-      it "returns false" do
-        expect(the_stub.satisfies?(request)).to be_falsey
-      end
+    subject { HttpStub::Server::Stub.create(args) }
 
-    end
-
-    describe "when the parameters do not match" do
-
-      before(:example) { allow(stub_parameters).to receive(:match?).with(request).and_return(false) }
-
-      it "returns false" do
-        expect(the_stub.satisfies?(request)).to be_falsey
-      end
-
-    end
-
-  end
-
-  describe "#uri" do
-
-    it "returns the parameters model encapsulating the uri provided in the request body" do
-      expect(the_stub.uri).to eql(stub_uri)
-    end
-
-  end
-
-  describe "#method" do
-
-    it "returns the value provided in the request body" do
-      expect(the_stub.method).to eql(stub_method)
-    end
-
-  end
-
-  describe "#headers" do
+    it "creates a stub instance with the provided arguments" do
+      expect(HttpStub::Server::Stub::Instance).to receive(:new).with(args)
 
-    it "returns the headers model encapsulating the headers provided in the request body" do
-      expect(the_stub.headers).to eql(stub_headers)
+      subject
     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(stub_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(stub_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(stub_triggers)
-    end
-
-  end
-
-  describe "#to_s" do
-
-    it "returns a string representation of the stub arguments" do
-      expect(stub_args).to receive(:to_s).and_return("stub arguments string")
+    it "returns the created stub" do
+      the_stub = instance_double(HttpStub::Server::Stub::Instance)
+      allow(HttpStub::Server::Stub::Instance).to receive(:new).and_return(the_stub)
 
-      expect(the_stub.to_s).to eql("stub arguments string")
+      expect(subject).to eql(the_stub)
     end
 
   end