http_stub 0.25.1 → 0.26.0

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

@@ -4,23 +4,39 @@ describe HttpStub::Configurer::DSL::StubBuilder do
 
   let(:builder) { HttpStub::Configurer::DSL::StubBuilder.new(default_builder) }
 
+  shared_context "triggers one scenario" do
+
+    let(:trigger_scenario) { "Some triggered scenario" }
+
+    before(:example) { builder.trigger(scenario: trigger_scenario) }
+
+  end
+
+  shared_context "triggers many scenarios" do
+
+    let(:trigger_scenarios) { (1..3).map { |i| "Some triggered scenario #{i}" } }
+
+    before(:example) { builder.trigger(scenarios: trigger_scenarios) }
+
+  end
+
   shared_context "triggers one stub" do
 
-    let(:trigger_stub)    { instance_double(HttpStub::Configurer::Request::Stub) }
-    let(:trigger_builder) { instance_double(HttpStub::Configurer::DSL::StubBuilder, build: trigger_stub) }
+    let(:trigger_stub)         { instance_double(HttpStub::Configurer::Request::Stub) }
+    let(:trigger_stub_builder) { instance_double(described_class, build: trigger_stub) }
 
-    before(:example) { builder.trigger(trigger_builder) }
+    before(:example) { builder.trigger(stub: trigger_stub_builder) }
 
   end
 
   shared_context "triggers many stubs" do
 
-    let(:trigger_stubs)    { (1..3).map { instance_double(HttpStub::Configurer::Request::Stub) } }
-    let(:trigger_builders) do
-      trigger_stubs.map { |stub| instance_double(HttpStub::Configurer::DSL::StubBuilder, build: stub) }
+    let(:trigger_stubs)         { (1..3).map { instance_double(HttpStub::Configurer::Request::Stub) } }
+    let(:trigger_stub_builders) do
+      trigger_stubs.map { |stub| instance_double(described_class, build: stub) }
     end
 
-    before(:example) { builder.trigger(trigger_builders) }
+    before(:example) { builder.trigger(stubs: trigger_stub_builders) }
 
   end
 
@@ -30,9 +46,9 @@ describe HttpStub::Configurer::DSL::StubBuilder do
 
       attr_reader :merged_stub_builders
 
-      def initialize(default_builder)
+      def initialize(parent_builder=nil, &block)
         @merged_stub_builders = []
-        super(default_builder)
+        super(parent_builder, &block)
       end
 
       def merge!(stub_builder)
@@ -41,34 +57,56 @@ describe HttpStub::Configurer::DSL::StubBuilder do
 
     end
 
-    context "when a default builder is provided" do
+    context "when a parent builder is provided" do
 
-      let(:default_builder) { instance_double(HttpStub::Configurer::DSL::StubBuilder) }
+      let(:parent_builder) { instance_double(described_class) }
 
-      let(:builder) { HttpStub::Configurer::DSL::StubBuilderWithObservedMerge.new(default_builder) }
+      let(:builder) { HttpStub::Configurer::DSL::StubBuilderWithObservedMerge.new(parent_builder) }
 
-      it "merges the default builder" do
+      it "merges the parent builder" do
         builder
 
-        expect(builder.merged_stub_builders).to eql([ default_builder ])
+        expect(builder.merged_stub_builders).to eql([ parent_builder ])
       end
 
     end
 
-  end
+    context "when a block is provided" do
+
+      let(:block_verifier) { double("BlockVerifier", verify: nil) }
+      let(:block)          { lambda { |builder| block_verifier.verify(builder) } }
+
+      let(:builder) { HttpStub::Configurer::DSL::StubBuilderWithObservedMerge.new(&block) }
 
-  context "when a default builder is not provided" do
+      it "creates a builder that is yielded to the provided block" do
+        expect(block_verifier).to receive(:verify).with(a_kind_of(described_class))
 
-    let(:builder) { HttpStub::Configurer::DSL::StubBuilderWithObservedMerge.new(nil) }
+        builder
+      end
+
+      it "does not merge any parent builders" do
+        builder
+
+        expect(builder.merged_stub_builders).to eql([])
+      end
+
+    end
+
+    context "when neither a parent builder or block is provided" do
+
+      let(:builder) { HttpStub::Configurer::DSL::StubBuilderWithObservedMerge.new(nil) }
+
+      it "does not merge any parent builder" do
+        builder
 
-    it "does not merge a builder" do
-      builder
+        expect(builder.merged_stub_builders).to eql([])
+      end
 
-      expect(builder.merged_stub_builders).to eql([])
     end
 
   end
 
+
   describe "#match_requests" do
 
     let(:fixture) { HttpStub::StubFixture.new }
@@ -139,12 +177,70 @@ describe HttpStub::Configurer::DSL::StubBuilder do
 
   describe "#trigger" do
 
-    subject { builder.trigger(instance_double(HttpStub::Configurer::DSL::StubBuilder)) }
+    let(:args) { {} }
+
+    subject { builder.trigger(args) }
 
     it "returns the builder to support method chaining" do
       expect(subject).to eql(builder)
     end
 
+    context "when scenarios are provided" do
+
+      let(:scenarios) { (1..3).map { |i| "Scenario name #{i}" } }
+
+      let(:args) { { scenarios: scenarios } }
+
+      it "adds the scenarios" do
+        subject
+
+        expect(builder.triggers).to include(scenarios: scenarios)
+      end
+
+    end
+
+    context "when a scenario is provided" do
+
+      let(:scenario) { "Some scenario name" }
+
+      let(:args) { { scenario: scenario } }
+
+      it "adds the scenario" do
+        subject
+
+        expect(builder.triggers).to include(scenarios: [ scenario ])
+      end
+
+    end
+
+    context "when stubs are provided" do
+
+      let(:stubs) { (1..3).map { instance_double(described_class) } }
+
+      let(:args) { { stubs: stubs } }
+
+      it "adds the stubs" do
+        subject
+
+        expect(builder.triggers).to include(stubs: stubs)
+      end
+
+    end
+
+    context "when a stub is provided" do
+
+      let(:stub) { instance_double(described_class) }
+
+      let(:args) { { stub: stub } }
+
+      it "adds the stub" do
+        subject
+
+        expect(builder.triggers).to include(stubs: [ stub ])
+      end
+
+    end
+
   end
 
   describe "#invoke" do
@@ -181,10 +277,11 @@ describe HttpStub::Configurer::DSL::StubBuilder do
 
     shared_context "a completely configured provided builder" do
 
-      let(:provided_triggers) { (1..3).map { instance_double(HttpStub::Configurer::DSL::StubBuilder) } }
+      let(:provided_trigger_scenarios)     { (1..3).map { |i| "Triggered scenario #{i}" } }
+      let(:provided_trigger_stub_builders) { (1..3).map { instance_double(described_class) } }
 
       let(:provided_builder) do
-        HttpStub::Configurer::DSL::StubBuilder.new.tap do |builder|
+        described_class.new.tap do |builder|
           builder.match_requests(uri: "/replacement_uri", method: :put,
                                  headers:    { request_header_key: "replacement request header value",
                                                other_request_header_key: "other request header value" },
@@ -195,7 +292,8 @@ describe HttpStub::Configurer::DSL::StubBuilder do
                                           other_response_header_key: "other response header value" },
                                body: "replacement body value",
                                delay_in_seconds: 3)
-          builder.trigger(provided_triggers)
+          builder.trigger(scenarios: provided_trigger_scenarios,
+                          stubs:     provided_trigger_stub_builders)
         end
       end
 
@@ -203,7 +301,8 @@ describe HttpStub::Configurer::DSL::StubBuilder do
 
     context "when the builder has been completely configured" do
 
-      let(:original_triggers) { (1..3).map { instance_double(HttpStub::Configurer::DSL::StubBuilder) } }
+      let(:original_trigger_scenarios)     { (1..3).map { |i| "Original trigger scenario #{i}" } }
+      let(:original_trigger_stub_builders) { (1..3).map { instance_double(described_class) } }
 
       before(:example) do
         builder.match_requests(uri: "/original_uri", method: :get,
@@ -213,7 +312,8 @@ describe HttpStub::Configurer::DSL::StubBuilder do
                              headers: { response_header_key: "original response header value" },
                              body: "original body",
                              delay_in_seconds: 2)
-        builder.trigger(original_triggers)
+        builder.trigger(scenarios: original_trigger_scenarios,
+                        stubs:     original_trigger_stub_builders)
       end
 
       context "and a builder that is completely configured is provided" do
@@ -272,17 +372,23 @@ describe HttpStub::Configurer::DSL::StubBuilder do
           expect(builder.response).to include(delay_in_seconds: 3)
         end
 
-        it "adds to the triggers" do
+        it "adds to the triggered scenarios" do
+          subject
+
+          expect(builder.triggers).to include(scenarios: original_trigger_scenarios + provided_trigger_scenarios)
+        end
+
+        it "adds to the triggered stubs" do
           subject
 
-          expect(builder.triggers).to eql(original_triggers + provided_triggers)
+          expect(builder.triggers).to include(stubs: original_trigger_stub_builders + provided_trigger_stub_builders)
         end
 
       end
 
       context "and a builder that is empty is provided" do
 
-        let(:provided_builder) { HttpStub::Configurer::DSL::StubBuilder.new }
+        let(:provided_builder) { described_class.new }
 
         it "preserves the uri" do
           subject
@@ -332,10 +438,16 @@ describe HttpStub::Configurer::DSL::StubBuilder do
           expect(builder.response).to include(delay_in_seconds: 2)
         end
 
-        it "preserves the triggers" do
+        it "preserves the triggered scenarios" do
+          subject
+
+          expect(builder.triggers).to include(scenarios: original_trigger_scenarios)
+        end
+
+        it "preserves the triggered stubs" do
           subject
 
-          expect(builder.triggers).to eql(original_triggers)
+          expect(builder.triggers).to include(stubs: original_trigger_stub_builders)
         end
 
       end
@@ -398,10 +510,16 @@ describe HttpStub::Configurer::DSL::StubBuilder do
         expect(builder.response).to include(delay_in_seconds: 3)
       end
 
-      it "assumes the provided triggers" do
+      it "assumes the provided triggered scenarios" do
         subject
 
-        expect(builder.triggers).to eql(provided_triggers)
+        expect(builder.triggers).to include(scenarios: provided_trigger_scenarios)
+      end
+
+      it "assumes the provided triggered stubs" do
+        subject
+
+        expect(builder.triggers).to include(stubs: provided_trigger_stub_builders)
       end
 
     end
@@ -411,7 +529,7 @@ describe HttpStub::Configurer::DSL::StubBuilder do
   describe "#build" do
 
     let(:fixture)  { HttpStub::StubFixture.new }
-    let(:triggers) { [] }
+    let(:triggers) { { scenarios: [], stubs: [] } }
     let(:stub)     { instance_double(HttpStub::Configurer::Request::Stub) }
 
     subject do
@@ -440,22 +558,44 @@ describe HttpStub::Configurer::DSL::StubBuilder do
 
       describe "creates a stub payload with triggers that" do
 
-        context "when a trigger is added" do
+        context "when a scenario trigger is added" do
+          include_context "triggers one scenario"
+
+          it "contains the provided trigger scenario name" do
+            expect_stub_to_be_created_with_triggers(scenario_names: [ trigger_scenario ])
+
+            subject
+          end
+
+        end
+
+        context "when many scenario triggers are added" do
+          include_context "triggers many scenarios"
+
+          it "contains the provided trigger scenario names" do
+            expect_stub_to_be_created_with_triggers(scenario_names: trigger_scenarios)
+
+            subject
+          end
+
+        end
+
+        context "when a stub trigger is added" do
           include_context "triggers one stub"
 
-          it "contain the provided trigger builder" do
-            expect_stub_to_be_created_with(triggers: [ trigger_builder ])
+          it "contains the provided trigger builder" do
+            expect_stub_to_be_created_with_triggers(stubs: [ trigger_stub ])
 
             subject
           end
 
         end
 
-        context "when many triggers are added" do
+        context "when many stub triggers are added" do
           include_context "triggers many stubs"
 
-          it "contain the provided trigger builders" do
-            expect_stub_to_be_created_with(triggers: trigger_builders)
+          it "contains the provided trigger builders" do
+            expect_stub_to_be_created_with_triggers(stubs: trigger_stubs)
 
             subject
           end
@@ -485,12 +625,17 @@ describe HttpStub::Configurer::DSL::StubBuilder do
             delay_in_seconds: 8
           }
         end
-        let(:trigger_defaults) { (1..3).map { instance_double(HttpStub::Configurer::DSL::StubBuilder) } }
+        let(:trigger_scenario_defaults)      { (1..3).map { |i| "Default trigger scenario #{i}" } }
+        let(:trigger_stub_defaults)          { (1..3).map { instance_double(HttpStub::Configurer::Request::Stub) } }
+        let(:trigger_stub_builder_defaults)  do
+          trigger_stub_defaults.map { |stub| instance_double(described_class, build: stub) }
+        end
 
         let(:default_builder) do
-          instance_double(HttpStub::Configurer::DSL::StubBuilder, request: request_defaults,
-                                                                  response: response_defaults,
-                                                                  triggers: trigger_defaults)
+          instance_double(described_class, request:  request_defaults,
+                                           response: response_defaults,
+                                           triggers: { scenarios: trigger_scenario_defaults,
+                                                       stubs:     trigger_stub_builder_defaults })
         end
 
         describe "the built request payload" do
@@ -557,12 +702,24 @@ describe HttpStub::Configurer::DSL::StubBuilder do
 
         end
 
-        describe "the built response triggers" do
+        describe "the built triggers payload" do
+
+          let(:trigger_scenarios)     { (1..3).map { |i| "Trigger scenario #{i}" } }
+          let(:trigger_stubs)         { (1..3).map { instance_double(HttpStub::Configurer::Request::Stub) } }
+          let(:trigger_stub_builders) do
+            trigger_stubs.map { |stub| instance_double(described_class, build: stub) }
+          end
+
+          let(:triggers) { { scenarios: trigger_scenarios, stubs: trigger_stub_builders } }
+
+          it "combines any scenario defaults with values established in the stub" do
+            expect_stub_to_be_created_with_triggers(scenario_names: trigger_scenario_defaults + trigger_scenarios)
 
-          let(:triggers) { (1..3).map { instance_double(HttpStub::Configurer::DSL::StubBuilder) } }
+            subject
+          end
 
-          it "combines any defaults with values values established in the stub" do
-            expect_stub_to_be_created_with(triggers: trigger_defaults + triggers)
+          it "combines any stub defaults with values established in the stub" do
+            expect_stub_to_be_created_with_triggers(stubs: trigger_stub_defaults + trigger_stubs)
 
             subject
           end
@@ -581,6 +738,10 @@ describe HttpStub::Configurer::DSL::StubBuilder do
       expect(HttpStub::Configurer::Request::Stub).to receive(:new).with(hash_including(args))
     end
 
+    def expect_stub_to_be_created_with_triggers(args)
+      expect_stub_to_be_created_with(triggers: hash_including(args))
+    end
+
   end
 
 end

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

@@ -0,0 +1,203 @@
+describe HttpStub::Configurer::DSL::StubBuilderTemplate do
+
+  let(:parent_uri)             { "/some/parent/uri" }
+  let(:parent_template)        do
+    described_class.new.tap do |template|
+      template.match_requests(uri: parent_uri)
+      template.respond_with(body: "parent template body")
+    end
+  end
+  let(:initial_request_method) { :put }
+  let(:initial_block)          { lambda { |stub| stub.match_requests(method: initial_request_method) } }
+
+  let(:stub_builder_template) { described_class.new }
+
+  shared_context "mocked stub builder" do
+
+    let(:stub_builder) { instance_double(HttpStub::Configurer::DSL::StubBuilder) }
+
+    before(:example) { allow(HttpStub::Configurer::DSL::StubBuilder).to receive(:new).and_return(stub_builder) }
+
+  end
+
+  it "creates a stub builder to hold values established on the template" do
+    allow(HttpStub::Configurer::DSL::StubBuilder).to receive(:new)
+
+    stub_builder_template
+  end
+
+  describe "#match_requests" do
+    include_context "mocked stub builder"
+
+    let(:request_matching_rules) { { uri: "/some/stub/uri", method: :get } }
+
+    subject { stub_builder_template.match_requests(request_matching_rules) }
+
+    it "delegates to the templates stub builder" do
+      expect(stub_builder).to receive(:match_requests).with(request_matching_rules)
+
+      subject
+    end
+
+  end
+
+  describe "#schema" do
+    include_context "mocked stub builder"
+
+    let(:type)       { :some_schema_type }
+    let(:definition) { "some schema definition" }
+
+    subject { stub_builder_template.schema(type, definition) }
+
+    it "delegates to the templates stub builder" do
+      expect(stub_builder).to receive(:schema).with(type, definition)
+
+      subject
+    end
+
+    it "returns the created schema" do
+      schema = { schema: :some_schema }
+      expect(stub_builder).to receive(:schema).and_return(schema)
+
+      expect(subject).to eql(schema)
+    end
+
+  end
+
+  describe "#respond_with" do
+    include_context "mocked stub builder"
+
+    let(:response_settings) { { status: 204 } }
+
+    subject { stub_builder_template.respond_with(response_settings) }
+
+    it "delegates to the templates stub builder" do
+      expect(stub_builder).to receive(:respond_with).with(response_settings)
+
+      subject
+    end
+
+  end
+
+  describe "#trigger" do
+    include_context "mocked stub builder"
+
+    let(:trigger_settings) { { scenario: "some scenario name" } }
+
+    subject { stub_builder_template.trigger(trigger_settings) }
+
+    it "delegates to the templates stub builder" do
+      expect(stub_builder).to receive(:trigger).with(trigger_settings)
+
+      subject
+    end
+
+  end
+
+  describe "#invoke" do
+    include_context "mocked stub builder"
+
+    let(:block_verifier) { double("BlockVerifier") }
+    let(:block)          do
+      lambda do |stub|
+        @yielded_stub = stub
+        block_verifier.verify
+      end
+    end
+
+    let(:stub_builder) { HttpStub::Configurer::DSL::StubBuilder.new }
+
+    subject { stub_builder_template.invoke(&block) }
+
+    it "invokes the block with the templates stub builder" do
+      expect(block_verifier).to receive(:verify)
+
+      subject
+
+      expect(@yielded_stub).to eql(stub_builder)
+    end
+
+  end
+
+  describe "#build_stub" do
+
+    let(:stub_builder_template) { described_class.new(parent_template) }
+    let(:response_overrides)    { { status: 201, body: "response overrides body" } }
+    let(:block)                 do
+      lambda do |stub|
+        stub.match_requests(uri: "/some/block/uri")
+        stub.respond_with(body: "block body")
+      end
+    end
+
+    let(:stub_builder_template) { described_class.new(parent_template) }
+
+    subject { stub_builder_template.build_stub }
+
+    context "when a parent template had been provided" do
+
+      it "creates a stub capable of containing values established in the parent template" do
+        expect(subject.request[:uri]).to eql(parent_uri)
+      end
+
+    end
+
+    context "when an initial block had been provided" do
+
+      let(:stub_builder_template) { described_class.new(&initial_block) }
+
+      it "creates a stub capable of containing values established in the initial block" do
+        expect(subject.request[:method]).to eql(initial_request_method)
+      end
+
+    end
+
+    context "when response overrides are provided upon building the stub" do
+
+      subject { stub_builder_template.build_stub(response_overrides) }
+
+      it "creates a stub containing the overrides" do
+        expect(subject.response[:status]).to eql(201)
+      end
+
+      it "overrides any values initially established" do
+        expect(subject.response[:body]).to eql("response overrides body")
+      end
+
+    end
+
+    context "when a block is provided upon building the stub" do
+
+      subject { stub_builder_template.build_stub(&block) }
+
+      it "creates a stub that is modified by the block" do
+        expect(subject.request[:uri]).to eql("/some/block/uri")
+      end
+
+      it "overrides any values initially established" do
+        expect(subject.response[:body]).to eql("block body")
+      end
+
+    end
+
+    context "when both response overrides and a block are provided" do
+
+      subject { stub_builder_template.build_stub(response_overrides, &block) }
+
+      it "creates a stub containing response overrides" do
+        expect(subject.response[:status]).to eql(201)
+      end
+
+      it "creates a stub that is modified by the block" do
+        expect(subject.request[:uri]).to eql("/some/block/uri")
+      end
+
+      it "creates a stub with values established in the block taking precedence over response overrides" do
+        expect(subject.response[:body]).to eql("block body")
+      end
+
+    end
+
+  end
+
+end