http_stub 0.14.2 → 0.15.0

data/spec/lib/http_stub/configurer/request/stub_spec.rb

@@ -1,41 +1,262 @@
 describe HttpStub::Configurer::Request::Stub do
 
-  describe "#initialize" do
+  let(:fixture)          { HttpStub::StubFixture.new }
+  let(:stub_response)    { instance_double(HttpStub::Configurer::Request::StubResponse).as_null_object }
+  let(:trigger_builders) { [] }
 
-    context "when provided a payload" do
+  let(:stub) do
+    HttpStub::Configurer::Request::Stub.new(fixture.configurer_payload.merge(triggers: trigger_builders))
+  end
+
+  before(:example) { allow(HttpStub::Configurer::Request::StubResponse).to receive(:new).and_return(stub_response) }
+
+  shared_context "triggers one stub" do
+
+    let(:trigger_payload) { HttpStub::StubFixture.new.configurer_payload }
+    let(:trigger_files)   { [] }
+    let(:trigger) do
+      instance_double(HttpStub::Configurer::Request::Stub,
+                      payload: trigger_payload, response_files: trigger_files)
+    end
+    let(:trigger_builders) do
+      [ instance_double(HttpStub::Configurer::Request::StubBuilder, build: trigger) ]
+    end
+
+  end
+
+  shared_context "triggers many stubs" do
+
+    let(:trigger_payloads) { (1..3).map { HttpStub::StubFixture.new.configurer_payload } }
+    let(:triggers_files)   { trigger_payloads.map { [] } }
+    let(:triggers) do
+      trigger_payloads.zip(triggers_files).map do |payload, files|
+        instance_double(HttpStub::Configurer::Request::Stub, payload: payload, response_files: files)
+      end
+    end
+    let(:trigger_builders) do
+      triggers.map do |trigger|
+        instance_double(HttpStub::Configurer::Request::StubBuilder, build: trigger)
+      end
+    end
+
+  end
+
+  describe "#payload" do
+
+    subject { stub.payload }
+
+    before(:example) { allow(HttpStub::Configurer::Request::ControllableValue).to receive(:format) }
+
+    context "when request headers are provided" do
+
+      it "formats the headers into control values" do
+        expect(HttpStub::Configurer::Request::ControllableValue).to receive(:format).with(fixture.request.headers)
+
+        subject
+      end
+
+    end
+
+    context "when no request header is provided" do
+
+      before(:example) do
+        fixture.request.headers = nil
+      end
+
+      it "formats an empty header hash" do
+        expect(HttpStub::Configurer::Request::ControllableValue).to receive(:format).with({})
+
+        subject
+      end
+
+    end
+
+    context "when a request parameter is provided" do
+
+      it "formats the request parameters into control values" do
+        expect(HttpStub::Configurer::Request::ControllableValue).to receive(:format).with(fixture.request.parameters)
+
+        subject
+      end
+
+    end
+
+    context "when no request parameter is provided" do
+
+      before(:example) { fixture.request.parameters = nil }
+
+      it "formats an empty parameter hash" do
+        expect(HttpStub::Configurer::Request::ControllableValue).to receive(:format).with({})
+
+        subject
+      end
+
+    end
+
+    it "creates a stub response with the provided response options" do
+      expect(HttpStub::Configurer::Request::StubResponse).to(
+        receive(:new).with(anything, fixture.response.symbolized).and_return(stub_response)
+      )
+
+      subject
+    end
+
+    context "when many triggers are provided" do
+
+      include_context "triggers many stubs"
+
+      it "builds the request object for each trigger" do
+        trigger_builders.each { |trigger_builder| expect(trigger_builder).to receive(:build) }
+
+        subject
+      end
+
+    end
+
+    context "builds a hash that" do
+
+      it "has an entry containing the control value representation of the uri" do
+        allow(HttpStub::Configurer::Request::ControllableValue).to(
+          receive(:format).with(fixture.request.uri).and_return("uri as a string")
+        )
+
+        expect(subject).to include(uri: "uri as a string")
+      end
+
+      it "has an entry for the method option" do
+        expect(subject).to include(method: fixture.request.http_method)
+      end
 
-      let(:payload) { { payload_key: "payload value" } }
+      it "has an entry containing the string representation of the request headers" do
+        allow(HttpStub::Configurer::Request::ControllableValue).to(
+          receive(:format).with(fixture.request.headers).and_return("request headers as string")
+        )
 
-      let(:request) { HttpStub::Configurer::Request::Stub.new(payload) }
+        expect(subject).to include(headers: "request headers as string")
+      end
+
+      it "has an entry containing the string representation of the request parameters" do
+        allow(HttpStub::Configurer::Request::ControllableValue).to(
+          receive(:format).with(fixture.request.parameters).and_return("request parameters as string")
+        )
 
-      it "creates a HTTP POST request" do
-        expect(request.method).to eql("POST")
+        expect(subject).to include(parameters: "request parameters as string")
       end
 
-      it "submits the request to '/stubs'" do
-        expect(request.path).to eql("/stubs")
+      it "has an entry containing the response payload" do
+        allow(stub_response).to receive(:payload).and_return("response payload")
+
+        expect(subject).to include(response: "response payload")
+      end
+
+      context "when a trigger is added" do
+
+        include_context "triggers one stub"
+
+        it "has a triggers entry containing the stub trigger payload" do
+          expect(subject).to include(triggers: [ trigger_payload ])
+        end
+
       end
 
-      it "sets the content type to json" do
-        expect(request.content_type).to eql("application/json")
+      context "when many triggers are added" do
+
+        include_context "triggers many stubs"
+
+        it "has a triggers entry containing the stub trigger payloads" do
+          expect(subject).to include(triggers: trigger_payloads)
+        end
+
       end
 
-      it "sets the body to the JSON representation of the provided payload" do
-        expect(request.body).to eql(payload.to_json)
+      context "when no triggers are added" do
+
+        it "has a triggers entry containing an empty hash" do
+          expect(subject).to include(triggers: [])
+        end
+
       end
 
     end
 
   end
 
-  describe "#stub_uri" do
+  describe "#response_files" do
+
+    subject { stub.response_files }
+
+    context "when the response contains a file" do
+
+      let(:response_file) { instance_double(HttpStub::Configurer::Request::StubResponseFile) }
+
+      before(:example) { allow(stub_response).to receive(:file).and_return(response_file) }
+
+      context "and the triggers contain files" do
+
+        include_context "triggers many stubs"
+
+        let(:triggers_files) do
+          trigger_payloads.map { (1..3).map { instance_double(HttpStub::Configurer::Request::StubResponseFile) } }
+        end
+
+        it "returns the stub response's file and the triggers files" do
+          expect(subject).to eql(([ response_file ] + triggers_files).flatten)
+        end
 
-    let(:stub_uri) { "/some/stub/uri" }
+      end
+
+      context "and the triggers contain no files" do
+
+        include_context "triggers many stubs"
+
+        let(:triggers_files) { trigger_payloads.map { (1..3).map { [] } } }
+
+        it "returns the stub response's file" do
+          expect(subject).to eql([ response_file ])
+        end
+
+      end
+
+    end
+
+    context "when the response body does not contain a file" do
+
+      before(:example) { allow(stub_response).to receive(:file).and_return(nil) }
+
+      context "and the triggers contain files" do
+
+        include_context "triggers many stubs"
+
+        let(:triggers_files) do
+          trigger_payloads.map { (1..3).map { instance_double(HttpStub::Configurer::Request::StubResponseFile) } }
+        end
+
+        it "returns the stub response's file and the triggers files" do
+          expect(subject).to eql(triggers_files.flatten)
+        end
+
+      end
+
+      context "and no triggers contain a file" do
+
+        include_context "triggers many stubs"
+
+        let(:triggers_files) { trigger_payloads.map { (1..3).map { [] } } }
+
+        it "returns a empty array" do
+          expect(subject).to eql([])
+        end
+
+      end
+
+    end
+
+  end
 
-    let(:request) { HttpStub::Configurer::Request::Stub.new(uri: stub_uri) }
+  describe "#to_s" do
 
-    it "should return the uri from the payload" do
-      expect(request.stub_uri).to eql(stub_uri)
+    it "returns the request uri" do
+      expect(stub.to_s).to eql(fixture.request.uri)
     end
 
   end

data/spec/lib/http_stub/configurer/server/command_processor_integration_spec.rb

@@ -19,7 +19,7 @@ describe HttpStub::Configurer::Server::CommandProcessor do
 
       describe "and the server responds with a 200 response" do
 
-        let(:request) { Net::HTTP::Get.new("/stubs") }
+        let(:request) { create_get_request("/stubs") }
 
         it "executes without error" do
           expect { subject }.not_to raise_error
@@ -29,7 +29,7 @@ describe HttpStub::Configurer::Server::CommandProcessor do
 
       describe "and the server responds with a non-200 response" do
 
-        let(:request) { Net::HTTP::Get.new("/causes_error") }
+        let(:request) { create_get_request("/causes_error") }
 
         it "raises an exception that includes the server base URI" do
           expect { subject }.to raise_error(/#{server_base_uri}/)
@@ -45,7 +45,7 @@ describe HttpStub::Configurer::Server::CommandProcessor do
 
     context "when the server is unavailable" do
 
-      let(:request) { Net::HTTP::Get.new("/does/not/exist") }
+      let(:request) { create_get_request("/does/not/exist") }
 
       it "raises an exception that includes the server base URI" do
         expect { subject }.to raise_error(/#{server_base_uri}/)
@@ -57,6 +57,10 @@ describe HttpStub::Configurer::Server::CommandProcessor do
 
     end
 
+    def create_get_request(path)
+      HttpStub::Configurer::Request::Http::Basic.new(Net::HTTP::Get.new(path))
+    end
+
   end
 
 end

data/spec/lib/http_stub/configurer/server/command_spec.rb

@@ -1,15 +1,16 @@
 describe HttpStub::Configurer::Server::Command do
 
-  let(:request)     { double("HttpRequest") }
-  let(:description) { "Some Description" }
-  let(:args)        { { request: request, description: description } }
+  let(:http_request) { double("HttpRequest") }
+  let(:request)      { double("HttpStubRequest", to_http_request: http_request) }
+  let(:description)  { "Some Description" }
+  let(:args)         { { request: request, description: description } }
 
   let(:command) { HttpStub::Configurer::Server::Command.new(args) }
 
-  describe "#request" do
+  describe "#http_request" do
 
-    it "exposes the provided request" do
-      expect(command.request).to eql(request)
+    it "returns the provided request adapted to a http request" do
+      expect(command.http_request).to eql(http_request)
     end
 
   end

data/spec/lib/http_stub/configurer/server/dsl_spec.rb

@@ -16,10 +16,10 @@ describe HttpStub::Configurer::Server::DSL do
 
   describe "#build_stub" do
 
-    let(:stub_payload_builder) { instance_double(HttpStub::Configurer::Request::StubPayloadBuilder) }
+    let(:stub_builder) { instance_double(HttpStub::Configurer::Request::StubBuilder) }
 
     before(:example) do
-      allow(HttpStub::Configurer::Request::StubPayloadBuilder).to receive(:new).and_return(stub_payload_builder)
+      allow(HttpStub::Configurer::Request::StubBuilder).to receive(:new).and_return(stub_builder)
     end
 
     subject { dsl.build_stub }
@@ -30,8 +30,8 @@ describe HttpStub::Configurer::Server::DSL do
 
       before(:example) { dsl.response_defaults = { key: "value" } }
 
-      it "creates a stub payload builder containing the response defaults" do
-        expect(HttpStub::Configurer::Request::StubPayloadBuilder).to receive(:new).with(response_defaults)
+      it "creates a stub builder containing the response defaults" do
+        expect(HttpStub::Configurer::Request::StubBuilder).to receive(:new).with(response_defaults)
 
         subject
       end
@@ -40,8 +40,8 @@ describe HttpStub::Configurer::Server::DSL do
 
     context "when no response defaults have been established" do
 
-      it "creates a stub payload builder with empty response defaults" do
-        expect(HttpStub::Configurer::Request::StubPayloadBuilder).to receive(:new).with({})
+      it "creates a stub builder with empty response defaults" do
+        expect(HttpStub::Configurer::Request::StubBuilder).to receive(:new).with({})
 
         subject
       end
@@ -55,13 +55,13 @@ describe HttpStub::Configurer::Server::DSL do
       subject { dsl.build_stub(&block) }
 
       it "yields the created builder to the provided block" do
-        expect(block).to receive(:call).with(stub_payload_builder)
+        expect(block).to receive(:call).with(stub_builder)
 
         subject
       end
 
       it "returns the created builder" do
-        expect(subject).to eql(stub_payload_builder)
+        expect(subject).to eql(stub_builder)
       end
 
     end
@@ -71,7 +71,7 @@ describe HttpStub::Configurer::Server::DSL do
       subject { dsl.build_stub }
 
       it "returns the built stub" do
-        expect(subject).to eql(stub_payload_builder)
+        expect(subject).to eql(stub_builder)
       end
 
     end
@@ -80,70 +80,56 @@ describe HttpStub::Configurer::Server::DSL do
 
   describe "#add_stub!" do
 
-    let(:stub_payload)         { { stub_payload_key: "stub payload value" } }
-    let(:stub_payload_builder) do
-      instance_double(HttpStub::Configurer::Request::StubPayloadBuilder, build: stub_payload)
-    end
-    let(:stub_request)         { instance_double(HttpStub::Configurer::Request::Stub) }
-
-    before(:example) do
-      allow(HttpStub::Configurer::Request::Stub).to receive(:new).and_return(stub_request)
-      allow(server_facade).to receive(:stub_response)
-    end
+    let(:stub)         { instance_double(HttpStub::Configurer::Request::Stub) }
+    let(:stub_builder) { instance_double(HttpStub::Configurer::Request::StubBuilder, build: stub) }
 
-    shared_examples_for "adding a stub payload" do
+    before(:example) { allow(server_facade).to receive(:stub_response) }
 
-      it "builds the stub payload" do
-        expect(stub_payload_builder).to receive(:build).and_return(stub_payload)
+    shared_examples_for "adding a stub request" do
 
-        subject
-      end
-
-      it "creates a stub request with the built payload" do
-        expect(HttpStub::Configurer::Request::Stub).to receive(:new).with(stub_payload).and_return(stub_request)
+      it "builds the stub request" do
+        expect(stub_builder).to receive(:build).and_return(stub)
 
         subject
       end
 
       it "informs the server facade of the stub request" do
-        expect(server_facade).to receive(:stub_response).with(stub_request)
+        expect(server_facade).to receive(:stub_response).with(stub)
 
         subject
       end
 
     end
 
-    context "when a stub payload builder is provided" do
+    context "when a stub builder is provided" do
 
-      subject { dsl.add_stub!(stub_payload_builder) }
+      subject { dsl.add_stub!(stub_builder) }
 
-      it_behaves_like "adding a stub payload"
+      it_behaves_like "adding a stub request"
 
     end
 
-    context "when a stub payload builder is not provided" do
+    context "when a stub builder is not provided" do
 
       let(:block) { lambda { |_stub| "some block" } }
 
-      before(:example) do
-        allow(HttpStub::Configurer::Request::StubPayloadBuilder).to receive(:new).and_return(stub_payload_builder)
-      end
+      before(:example) { allow(HttpStub::Configurer::Request::StubBuilder).to receive(:new).and_return(stub_builder) }
 
       subject { dsl.add_stub!(&block) }
 
-      it "creates a stub payload builder" do
-        expect(HttpStub::Configurer::Request::StubPayloadBuilder).to receive(:new)
+      it "creates a stub builder" do
+        expect(HttpStub::Configurer::Request::StubBuilder).to receive(:new)
 
         subject
       end
 
       it "yields the created builder to the provided block" do
-        expect(block).to receive(:call).with(stub_payload_builder)
+        expect(block).to receive(:call).with(stub_builder)
 
         subject
       end
 
-      it_behaves_like "adding a stub payload"
+      it_behaves_like "adding a stub request"
 
     end
 
@@ -151,43 +137,25 @@ describe HttpStub::Configurer::Server::DSL do
 
   describe "#add_stubs!" do
 
-    context "when multiple stub payload builders are provided" do
+    context "when multiple stub builders are provided" do
 
-      let(:stub_payloads)         { (1..3).map { |i| { "stub_payload_key_#{i}" => "stub payload value #{i}" } } }
-      let(:stub_payload_builders) do
-        stub_payloads.map do |payload|
-          instance_double(HttpStub::Configurer::Request::StubPayloadBuilder, build: payload)
-        end
-      end
-      let(:stub_requests)         do
-        (1..stub_payloads.length).map { instance_double(HttpStub::Configurer::Request::Stub) }
-      end
-
-      subject { dsl.add_stubs!(stub_payload_builders) }
-
-      before(:example) do
-        allow(HttpStub::Configurer::Request::Stub).to receive(:new).and_return(*stub_requests)
-        allow(server_facade).to receive(:stub_response)
+      let(:stubs) { (1..3).map { instance_double(HttpStub::Configurer::Request::Stub) } }
+      let(:stub_builders) do
+        stubs.map { |stub| instance_double(HttpStub::Configurer::Request::StubBuilder, build: stub) }
       end
 
-      it "builds the each stub payload" do
-        stub_payload_builders.zip(stub_payloads).each do |stub_payload_builder, stub_payload|
-          expect(stub_payload_builder).to receive(:build).and_return(stub_payload)
-        end
+      subject { dsl.add_stubs!(stub_builders) }
 
-        subject
-      end
+      before(:example) { allow(server_facade).to receive(:stub_response) }
 
-      it "creates a stub request for each built payload" do
-        stub_payloads.zip(stub_requests).each do |stub_payload, stub_request|
-          expect(HttpStub::Configurer::Request::Stub).to receive(:new).with(stub_payload).and_return(stub_request)
-        end
+      it "builds each stub" do
+        stubs.zip(stub_builders).each { |stub, stub_builder| expect(stub_builder).to receive(:build).and_return(stub) }
 
         subject
       end
 
-      it "informs the server facade of each stub request" do
-        stub_requests.each { |stub_request| expect(server_facade).to receive(:stub_response).with(stub_request) }
+      it "informs the server facade of each built stub" do
+        stubs.each { |stub| expect(server_facade).to receive(:stub_response).with(stub) }
 
         subject
       end
@@ -198,63 +166,59 @@ describe HttpStub::Configurer::Server::DSL do
 
   describe "#add_activator!" do
 
-    let(:stub_activator_payload)         { { activator_payload_key: "activator payload value" } }
-    let(:stub_activator_payload_builder) do
-      instance_double(HttpStub::Configurer::Request::StubActivatorPayloadBuilder, build: stub_activator_payload)
+    let(:stub_activator) { instance_double(HttpStub::Configurer::Request::StubActivator) }
+    let(:stub_activator_builder) do
+      instance_double(HttpStub::Configurer::Request::StubActivatorBuilder, build: stub_activator)
     end
-    let(:stub_activator_request)         { instance_double(HttpStub::Configurer::Request::StubActivator) }
 
-    before(:example) do
-      allow(HttpStub::Configurer::Request::StubActivator).to receive(:new).and_return(stub_activator_request)
-      allow(server_facade).to receive(:stub_activator)
-    end
+    before(:example) { allow(server_facade).to receive(:stub_activator) }
 
     let(:block) { lambda { |_activator| "some block" } }
 
     before(:example) do
-      allow(HttpStub::Configurer::Request::StubActivatorPayloadBuilder).to(
-        receive(:new).and_return(stub_activator_payload_builder)
-      )
+      allow(HttpStub::Configurer::Request::StubActivatorBuilder).to receive(:new).and_return(stub_activator_builder)
     end
 
     subject { dsl.add_activator!(&block) }
 
     context "when response defaults have been established" do
 
-    end
+      let(:response_defaults) { { key: "value" } }
 
-    context "when no response defaults have been established" do
+      before(:example) { dsl.response_defaults = { key: "value" } }
 
-    end
+      it "creates a stub activator builder containing the response defaults" do
+        expect(HttpStub::Configurer::Request::StubActivatorBuilder).to receive(:new).with(response_defaults)
 
-    it "creates a stub activator payload builder" do
-      expect(HttpStub::Configurer::Request::StubActivatorPayloadBuilder).to receive(:new)
+        subject
+      end
 
-      subject
     end
 
-    it "yields the created builder to the provided block" do
-      expect(block).to receive(:call).with(stub_activator_payload_builder)
+    context "when no response defaults have been established" do
+
+      it "creates a stub activator builder with empty response defaults" do
+        expect(HttpStub::Configurer::Request::StubActivatorBuilder).to receive(:new).with({})
+
+        subject
+      end
 
-      subject
     end
 
-    it "builds the stub activator payload" do
-      expect(stub_activator_payload_builder).to receive(:build).and_return(stub_activator_payload)
+    it "yields the created builder to the provided block" do
+      expect(block).to receive(:call).with(stub_activator_builder)
 
       subject
     end
 
-    it "creates a stub activator request with the built payload" do
-      expect(HttpStub::Configurer::Request::StubActivator).to(
-        receive(:new).with(stub_activator_payload).and_return(stub_activator_request)
-      )
+    it "builds the stub activator request" do
+      expect(stub_activator_builder).to receive(:build).and_return(stub_activator)
 
       subject
     end
 
     it "informs the server facade to submit the stub activator request" do
-      expect(server_facade).to receive(:stub_activator).with(stub_activator_request)
+      expect(server_facade).to receive(:stub_activator).with(stub_activator)
 
       subject
     end