http_stub 0.17.0 → 0.18.0

data/spec/lib/http_stub/configurer/dsl/scenario_builder_spec.rb

@@ -17,11 +17,12 @@ describe HttpStub::Configurer::DSL::ScenarioBuilder do
 
   describe "#add_stub!" do
 
-    let(:stub_builder) { instance_double(HttpStub::Configurer::DSL::StubBuilder) }
+    let(:stub_builder) { instance_double(HttpStub::Configurer::DSL::StubBuilder, invoke: nil) }
 
     context "when a block is provided" do
 
-      let(:block) { lambda { |_builder| "some block" } }
+      let(:block_verifier) { double("BlockVerifier") }
+      let(:block) { lambda { block_verifier.verify } }
 
       subject { scenario_builder.add_stub!(&block) }
 
@@ -33,8 +34,9 @@ describe HttpStub::Configurer::DSL::ScenarioBuilder do
         subject
       end
 
-      it "yields the stub builder to the provided block" do
-        expect(block).to receive(:call).with(stub_builder)
+      it "requests the stub builder invoke the provided block" do
+        expect(stub_builder).to receive(:invoke).and_yield
+        expect(block_verifier).to receive(:verify)
 
         subject
       end
@@ -81,7 +83,7 @@ describe HttpStub::Configurer::DSL::ScenarioBuilder do
 
       let(:stubs) { (1..3).map { instance_double(HttpStub::Configurer::Request::Stub) } }
       let(:stub_builders) do
-        stubs.map { |stub| instance_double(HttpStub::Configurer::DSL::StubBuilder, build: stub) }
+        stubs.map { |stub| instance_double(HttpStub::Configurer::DSL::StubBuilder, invoke: nil, build: stub) }
       end
 
       before(:example) do

data/spec/lib/http_stub/configurer/dsl/server_spec.rb

@@ -4,6 +4,14 @@ describe HttpStub::Configurer::DSL::Server do
 
   let(:server) { HttpStub::Configurer::DSL::Server.new(server_facade) }
 
+  shared_context "establish response defaults" do
+
+    let(:response_defaults) { { key: "value" } }
+
+    before(:example) { server.response_defaults = { key: "value" } }
+
+  end
+
   it "produces stub builders" do
     expect(server).to be_a(HttpStub::Configurer::DSL::StubBuilderProducer)
   end
@@ -70,9 +78,13 @@ describe HttpStub::Configurer::DSL::Server do
 
     context "when a stub builder is not provided" do
 
-      let(:block) { lambda { |_stub| "some block" } }
+      let(:block_verifier) { double("BlockVerifier") }
+      let(:block)          { lambda { block_verifier.verify } }
 
-      before(:example) { allow(HttpStub::Configurer::DSL::StubBuilder).to receive(:new).and_return(stub_builder) }
+      before(:example) do
+        allow(HttpStub::Configurer::DSL::StubBuilder).to receive(:new).and_return(stub_builder)
+        allow(stub_builder).to receive(:invoke)
+      end
 
       subject { server.add_stub!(&block) }
 
@@ -82,8 +94,9 @@ describe HttpStub::Configurer::DSL::Server do
         subject
       end
 
-      it "yields the created builder to the provided block" do
-        expect(block).to receive(:call).with(stub_builder)
+      it "requests the created builder invoke the provided block" do
+        expect(stub_builder).to receive(:invoke).and_yield
+        expect(block_verifier).to receive(:verify)
 
         subject
       end
@@ -112,9 +125,7 @@ describe HttpStub::Configurer::DSL::Server do
 
     context "when response defaults have been established" do
 
-      let(:response_defaults) { { key: "value" } }
-
-      before(:example) { server.response_defaults = { key: "value" } }
+      include_context "establish response defaults"
 
       it "creates a scenario builder containing the response defaults" do
         expect(HttpStub::Configurer::DSL::ScenarioBuilder).to receive(:new).with(response_defaults, anything)
@@ -160,6 +171,102 @@ describe HttpStub::Configurer::DSL::Server do
 
   end
 
+  describe "#add_one_stub_scenario!" do
+
+    let(:scenario_name)  { "some_scenario_name" }
+    let(:block_verifier) { double("BlockVerifier") }
+    let(:block)          { lambda { block_verifier.verify } }
+
+    let(:scenario_builder) { instance_double(HttpStub::Configurer::DSL::ScenarioBuilder) }
+    let(:stub_builder)     { instance_double(HttpStub::Configurer::DSL::StubBuilder, invoke: nil) }
+
+    subject { server.add_one_stub_scenario!(scenario_name, &block) }
+
+    before(:each) do
+      allow(server).to receive(:add_scenario!).and_yield(scenario_builder)
+      allow(scenario_builder).to receive(:add_stub!).and_yield(stub_builder)
+    end
+
+    it "adds a scenario with the provided name" do
+      expect(server).to receive(:add_scenario!).with(scenario_name)
+
+      subject
+    end
+
+    it "adds a stub to the scenario" do
+      expect(scenario_builder).to receive(:add_stub!)
+
+      subject
+    end
+
+    it "requests the stub builder invoke the provided block" do
+      expect(stub_builder).to receive(:invoke).and_yield
+      expect(block_verifier).to receive(:verify)
+
+      subject
+    end
+
+  end
+
+  describe "#endpoint_template" do
+
+    let(:block_verifier)    { double("BlockVerifier") }
+    let(:block)             { lambda { block_verifier.verify } }
+    let(:endpoint_template) { instance_double(HttpStub::Configurer::DSL::EndpointTemplate, invoke: nil) }
+
+    subject { server.endpoint_template(&block) }
+
+    before(:example) do
+      allow(HttpStub::Configurer::DSL::EndpointTemplate).to receive(:new).and_return(endpoint_template)
+    end
+
+    it "requests the endpoint template invoke the provided block" do
+      expect(endpoint_template).to receive(:invoke).and_yield
+      expect(block_verifier).to receive(:verify)
+
+      subject
+    end
+
+    it "returns the created endpoint template" do
+      expect(subject).to eql(endpoint_template)
+    end
+
+    it "creates a template for the server" do
+      expect(HttpStub::Configurer::DSL::EndpointTemplate).to(
+        receive(:new).with(server, anything).and_return(endpoint_template)
+      )
+
+      subject
+    end
+
+    context "when response defaults have been established" do
+
+      include_context "establish response defaults"
+
+      it "creates a template with the defaults" do
+        expect(HttpStub::Configurer::DSL::EndpointTemplate).to(
+          receive(:new).with(anything, response_defaults).and_return(endpoint_template)
+        )
+
+        subject
+      end
+
+    end
+
+    context "when no response defaults have been established" do
+
+      it "creates a template with empty response defaults" do
+        expect(HttpStub::Configurer::DSL::EndpointTemplate).to(
+          receive(:new).with(anything, {}).and_return(endpoint_template)
+        )
+
+        subject
+      end
+
+    end
+
+  end
+
   describe "#add_activator!" do
 
     let(:scenario) { instance_double(HttpStub::Configurer::Request::Scenario) }

data/spec/lib/http_stub/configurer/dsl/stub_builder_producer_spec.rb

@@ -34,40 +34,20 @@ describe HttpStub::Configurer::DSL::StubBuilderProducer do
 
     context "when a block is provided" do
 
-      context "that declares a stub builder parameter" do
+      let(:block) { lambda { |_stub_builder| "some block" } }
 
-        let(:block) { lambda { |_stub_builder| "some block" } }
+      subject { producer.build_stub(&block) }
 
-        subject { producer.build_stub(&block) }
+      before(:example) { allow(stub_builder).to receive(:invoke) }
 
-        it "yields the created builder to the provided block" do
-          expect(block).to receive(:call).with(stub_builder)
-
-          subject
-        end
-
-        it "returns the created builder" do
-          expect(subject).to eql(stub_builder)
-        end
+      it "requests the stub builder invoke block" do
+        expect(stub_builder).to receive(:invoke).and_yield(block)
 
+        subject
       end
 
-      context "that has no parameters" do
-
-        subject { producer.build_stub { match_requests("/some/request/uri") } }
-
-        before(:example) { allow(stub_builder).to receive(:match_requests) }
-
-        it "executes the block in the context of the builder" do
-          expect(stub_builder).to receive(:match_requests).with("/some/request/uri")
-
-          subject
-        end
-
-        it "returns the created builder" do
-          expect(subject).to eql(stub_builder)
-        end
-
+      it "returns the stub builder" do
+        expect(subject).to eql(stub_builder)
       end
 
     end
@@ -76,7 +56,7 @@ describe HttpStub::Configurer::DSL::StubBuilderProducer do
 
       subject { producer.build_stub }
 
-      it "returns the built stub" do
+      it "returns the stub builder" do
         expect(subject).to eql(stub_builder)
       end
 

data/spec/lib/http_stub/configurer/dsl/stub_builder_spec.rb

@@ -84,6 +84,269 @@ describe HttpStub::Configurer::DSL::StubBuilder do
 
   end
 
+  describe "#invoke" do
+
+    context "when the block accepts an argument" do
+
+      subject { builder.invoke { |builder| builder.match_requests("/some_uri") } }
+
+      it "invokes the block with the builder as the argument" do
+        expect(builder).to receive(:match_requests).with("/some_uri")
+
+        subject
+      end
+
+    end
+
+    context "when the block accepts no arguments" do
+
+      subject { builder.invoke { match_requests("/some_uri") } }
+
+      it "invokes the block in the context of the builder" do
+        expect(builder).to receive(:match_requests).with("/some_uri")
+
+        subject
+      end
+
+    end
+
+  end
+
+  describe "#merge!" do
+
+    subject { builder.merge!(provided_builder) }
+
+    shared_context "a completely configured provided builder" do
+
+      let(:provided_triggers) { (1..3).map { instance_double(HttpStub::Configurer::DSL::StubBuilder) } }
+
+      let(:provided_builder) do
+        HttpStub::Configurer::DSL::StubBuilder.new({}).tap do |builder|
+          builder.match_requests("/replacement_uri", method: :put,
+                                 headers:    { request_header_key: "replacement request header value",
+                                               other_request_header_key: "other request header value" },
+                                 parameters: { parameter_key: "replacement parameter value",
+                                               other_request_parameter_key: "other request parameter value" })
+          builder.respond_with(status: 203,
+                               headers: { response_header_key: "reaplcement response header value",
+                                          other_response_header_key: "other response header value" },
+                               body: "replacement body value",
+                               delay_in_seconds: 3)
+          builder.trigger(provided_triggers)
+        end
+      end
+
+    end
+
+    context "when the builder has been completely configured" do
+
+      let(:original_triggers) { (1..3).map { instance_double(HttpStub::Configurer::DSL::StubBuilder) } }
+
+      before(:example) do
+        builder.match_requests("/original_uri", method: :get,
+                               headers:    { request_header_key: "original request header value" },
+                               parameters: { parameter_key: "original parameter value" })
+        builder.respond_with(status: 202,
+                             headers: { response_header_key: "original response header value" },
+                             body: "original body",
+                             delay_in_seconds: 2)
+        builder.trigger(original_triggers)
+      end
+
+      context "and a builder that is completely configured is provided" do
+
+        include_context "a completely configured provided builder"
+
+        it "replaces the uri" do
+          subject
+
+          expect(builder.request).to include(uri: "/replacement_uri")
+        end
+
+        it "replaces the request method" do
+          subject
+
+          expect(builder.request).to include(method: :put)
+        end
+
+        it "deeply merges the request headers" do
+          subject
+
+          expect(builder.request).to include(headers: { request_header_key: "replacement request header value",
+                                                        other_request_header_key: "other request header value" })
+        end
+
+        it "deeply merges the request parameters" do
+          subject
+
+          expect(builder.request).to(
+            include(parameters: { parameter_key: "replacement parameter value",
+                                  other_request_parameter_key: "other request parameter value" })
+          )
+        end
+
+        it "replaces the response status" do
+          subject
+
+          expect(builder.response).to include(status: 203)
+        end
+
+        it "deeply merges the response headers" do
+          subject
+
+          expect(builder.response).to include(headers: { response_header_key: "reaplcement response header value",
+                                                         other_response_header_key: "other response header value" })
+        end
+
+        it "replaces the body" do
+          subject
+
+          expect(builder.response).to include(body: "replacement body value")
+        end
+
+        it "replaces the response delay" do
+          subject
+
+          expect(builder.response).to include(delay_in_seconds: 3)
+        end
+
+        it "adds to the triggers" do
+          subject
+
+          expect(builder.triggers).to eql(original_triggers + provided_triggers)
+        end
+
+      end
+
+      context "and a builder that is empty is provided" do
+
+        let(:provided_builder) { HttpStub::Configurer::DSL::StubBuilder.new({}) }
+
+        it "preserves the uri" do
+          subject
+
+          expect(builder.request).to include(uri: "/original_uri")
+        end
+
+        it "preserves the request method" do
+          subject
+
+          expect(builder.request).to include(method: :get)
+        end
+
+        it "preserves the request headers" do
+          subject
+
+          expect(builder.request).to include(headers: { request_header_key: "original request header value" })
+        end
+
+        it "preserves the request parameters" do
+          subject
+
+          expect(builder.request).to include(parameters: { parameter_key: "original parameter value" })
+        end
+
+        it "preserves the response status" do
+          subject
+
+          expect(builder.response).to include(status: 202)
+        end
+
+        it "preserves the response headers" do
+          subject
+
+          expect(builder.response).to include(headers: { response_header_key: "original response header value" })
+        end
+
+        it "preserves the body" do
+          subject
+
+          expect(builder.response).to include(body: "original body")
+        end
+
+        it "preserves the response delay" do
+          subject
+
+          expect(builder.response).to include(delay_in_seconds: 2)
+        end
+
+        it "preserves the triggers" do
+          subject
+
+          expect(builder.triggers).to eql(original_triggers)
+        end
+
+      end
+
+    end
+
+    context "when the builder has not been previously configured" do
+
+      include_context "a completely configured provided builder"
+
+      it "assumes the provided uri" do
+        subject
+
+        expect(builder.request).to include(uri: "/replacement_uri")
+      end
+
+      it "assumes the provided request method" do
+        subject
+
+        expect(builder.request).to include(method: :put)
+      end
+
+      it "assumes the provided request headers" do
+        subject
+
+        expect(builder.request).to include(headers: { request_header_key: "replacement request header value",
+                                                      other_request_header_key: "other request header value" })
+      end
+
+      it "assumes the provided request parameters" do
+        subject
+
+        expect(builder.request).to(
+          include(parameters: { parameter_key: "replacement parameter value",
+                                other_request_parameter_key: "other request parameter value" })
+        )
+      end
+
+      it "assumes the provided response status" do
+        subject
+
+        expect(builder.response).to include(status: 203)
+      end
+
+      it "assumes the provided response headers" do
+        subject
+
+        expect(builder.response).to include(headers: { response_header_key: "reaplcement response header value",
+                                                       other_response_header_key: "other response header value" })
+      end
+
+      it "assumes the provided response body" do
+        subject
+
+        expect(builder.response).to include(body: "replacement body value")
+      end
+
+      it "assumes the provided response delay" do
+        subject
+
+        expect(builder.response).to include(delay_in_seconds: 3)
+      end
+
+      it "assumes the provided triggers" do
+        subject
+
+        expect(builder.triggers).to eql(provided_triggers)
+      end
+
+    end
+
+  end
+
   describe "#build" do
 
     let(:fixture) { HttpStub::StubFixture.new }