http_stub 0.15.5 → 0.16.0.pre1

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

@@ -0,0 +1,62 @@
+describe HttpStub::Configurer::DSL::ScenarioActivator do
+
+  class HttpStub::Configurer::DSL::TestableScenarioActivator
+    include HttpStub::Configurer::DSL::ScenarioActivator
+
+    def activate_all!(uris)
+      # Intentionally blank
+    end
+
+  end
+
+  let(:activator) { HttpStub::Configurer::DSL::TestableScenarioActivator.new }
+
+  describe "#activate!" do
+
+    subject { activator.activate!(uri) }
+
+    context "when a uri is provided" do
+
+      let(:uri) { "some/uri" }
+
+      it "delegates to activate all with the provided uri" do
+        expect(activator).to receive(:activate_all!).with([ uri ])
+
+        subject
+      end
+
+    end
+
+    context "when multiple uri's are provided" do
+
+      let(:uris) { (1..3).map { |i| "uri/#{i}" } }
+
+      context "as multiple arguments" do
+
+        subject { activator.activate!(*uris) }
+
+        it "delegates to activate all the provided uris" do
+          expect(activator).to receive(:activate_all!).with(uris)
+
+          subject
+        end
+
+      end
+
+      context "as an array" do
+
+        subject { activator.activate!(uris) }
+
+        it "delegates to activate all the provided uris" do
+          expect(activator).to receive(:activate_all!).with(uris)
+
+          subject
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,146 @@
+describe HttpStub::Configurer::DSL::ScenarioBuilder do
+
+  let(:stub_fixture) { HttpStub::StubFixture.new }
+
+  let(:response_defaults) { { some_default_key: "some default value" } }
+  let(:scenario_name)     { "some/scenario/name" }
+
+  let(:scenario_builder) { HttpStub::Configurer::DSL::ScenarioBuilder.new(response_defaults, scenario_name) }
+
+  it "activates scenarios" do
+    expect(scenario_builder).to be_a(HttpStub::Configurer::DSL::ScenarioActivator)
+  end
+
+  it "produces stub builders" do
+    expect(scenario_builder).to be_a(HttpStub::Configurer::DSL::StubBuilderProducer)
+  end
+
+  describe "#add_stub!" do
+
+    let(:stub_builder) { instance_double(HttpStub::Configurer::DSL::StubBuilder) }
+
+    context "when a block is provided" do
+
+      let(:block) { lambda { |_builder| "some block" } }
+
+      subject { scenario_builder.add_stub!(&block) }
+
+      before(:example) { allow(HttpStub::Configurer::DSL::StubBuilder).to receive(:new).and_return(stub_builder) }
+
+      it "creates a stub builder with the response defaults provided to the scenario builder" do
+        expect(HttpStub::Configurer::DSL::StubBuilder).to receive(:new).and_return(stub_builder)
+
+        subject
+      end
+
+      it "yields the stub builder to the provided block" do
+        expect(block).to receive(:call).with(stub_builder)
+
+        subject
+      end
+
+      it "results in the stub being built when the scenario is built" do
+        subject
+        expect(stub_builder).to receive(:build)
+
+        scenario_builder.build
+      end
+
+    end
+
+    context "when a builder is provided" do
+
+      subject { scenario_builder.add_stub!(stub_builder) }
+
+      it "results in the stub being built when the scenario is built" do
+        subject
+        expect(stub_builder).to receive(:build)
+
+        scenario_builder.build
+      end
+
+    end
+
+  end
+
+  describe "#build" do
+
+    let(:scenario) { instance_double(HttpStub::Configurer::Request::Scenario) }
+
+    subject { scenario_builder.build }
+
+    before(:example) { allow(HttpStub::Configurer::Request::Scenario).to receive(:new).and_return(scenario) }
+
+    it "creates a scenario that includes the name" do
+      expect(HttpStub::Configurer::Request::Scenario).to receive(:new).with(hash_including(name: scenario_name))
+
+      subject
+    end
+
+    context "when multiple stubs have been added" 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) }
+      end
+
+      before(:example) do
+        allow(HttpStub::Configurer::DSL::StubBuilder).to receive(:new).and_return(*stub_builders)
+        stub_builders.each { scenario_builder.add_stub! { |_builder| "some block" } }
+      end
+
+      it "builds the stubs" do
+        stub_builders.each { |stub_builder| expect(stub_builder).to receive(:build) }
+
+        subject
+      end
+
+      it "creates a scenario that includes the built stubs" do
+        expect(HttpStub::Configurer::Request::Scenario).to receive(:new).with(hash_including(stubs: stubs))
+
+        subject
+      end
+
+    end
+
+    context "when no stubs have been added" do
+
+      it "creates a scenario that has empty stubs" do
+        expect(HttpStub::Configurer::Request::Scenario).to receive(:new).with(hash_including(stubs: []))
+
+        subject
+      end
+
+    end
+
+    context "when triggered scenarios have been added" do
+
+      let(:triggered_scenario_names) { (1..3).map { |i| "activator_#{i}" } }
+
+      before(:example) { scenario_builder.activate!(triggered_scenario_names) }
+
+      it "creates a scenario that includes the triggered scenario names" do
+        expect(HttpStub::Configurer::Request::Scenario).to(
+          receive(:new).with(hash_including(triggered_scenario_names: triggered_scenario_names))
+        )
+
+        subject
+      end
+
+    end
+
+    context "when no scenario activators have been added" do
+
+      it "creates a scenario that has empty triggered scenario names" do
+        expect(HttpStub::Configurer::Request::Scenario).to(
+          receive(:new).with(hash_including(triggered_scenario_names: []))
+        )
+
+        subject
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,120 @@
+describe HttpStub::Configurer::DSL::StubActivatorBuilder do
+
+  let(:stub_fixture) { HttpStub::StubFixture.new }
+
+  let(:response_defaults) { {} }
+  let(:activation_uri)    { "/some/activation/uri" }
+  let(:scenario)          { instance_double(HttpStub::Configurer::Request::Scenario) }
+  let(:scenario_builder) do
+    instance_double(HttpStub::Configurer::DSL::ScenarioBuilder, build: scenario, add_stub!: nil)
+  end
+  let(:stub_builder)      { instance_double(HttpStub::Configurer::DSL::StubBuilder) }
+
+  let(:builder) { HttpStub::Configurer::DSL::StubActivatorBuilder.new(response_defaults) }
+
+  before(:example) do
+    allow(HttpStub::Configurer::DSL::ScenarioBuilder).to receive(:new).and_return(scenario_builder)
+    allow(HttpStub::Configurer::DSL::StubBuilder).to receive(:new).and_return(stub_builder)
+  end
+
+  describe "#on" do
+
+    subject { builder.on(activation_uri) }
+
+    it "creates a scenario builder with the response defaults and activation uri" do
+      expect(HttpStub::Configurer::DSL::ScenarioBuilder).to receive(:new).with(response_defaults, activation_uri)
+
+      subject
+    end
+
+    it "creates a stub builder with the response defaults" do
+      expect(HttpStub::Configurer::DSL::StubBuilder).to receive(:new).with(response_defaults)
+
+      subject
+    end
+
+    it "adds the stub builder to the scenario builder" do
+      expect(scenario_builder).to receive(:add_stub!).with(stub_builder)
+
+      subject
+    end
+
+  end
+
+  describe "#match_requests" do
+
+    let(:request_payload) { stub_fixture.request.configurer_payload }
+
+    before(:example) { builder.on(activation_uri) }
+
+    it "delegates to a stub builder" do
+      expect(stub_builder).to receive(:match_requests).with(stub_fixture.request.uri, request_payload)
+
+      builder.match_requests(stub_fixture.request.uri, request_payload)
+    end
+
+  end
+
+  describe "#respond_with" do
+
+    let(:response_payload) { stub_fixture.response.configurer_payload }
+
+    before(:example) { builder.on(activation_uri) }
+
+    it "delegates to a stub builder" do
+      expect(stub_builder).to receive(:respond_with).with(response_payload)
+
+      builder.respond_with(response_payload)
+    end
+
+  end
+
+  describe "#trigger" do
+
+    before(:example) { builder.on(activation_uri) }
+
+    context "when one triggered stub is provided" do
+
+      let(:trigger_builder) { instance_double(HttpStub::Configurer::DSL::StubBuilder) }
+
+      it "delegates to a stub builder" do
+        expect(stub_builder).to receive(:trigger).with(trigger_builder)
+
+        builder.trigger(trigger_builder)
+      end
+
+    end
+
+    context "when many triggered stubs are provided" do
+
+      let(:trigger_builders) { (1..3).map { instance_double(HttpStub::Configurer::DSL::StubBuilder) } }
+
+      it "delegates to a stub builder" do
+        expect(stub_builder).to receive(:trigger).with(trigger_builders)
+
+        builder.trigger(trigger_builders)
+      end
+
+    end
+
+  end
+
+  describe "#build" do
+
+    subject { builder.build }
+
+    before(:example) { builder.on(activation_uri) }
+
+    it "builds a scenario" do
+      expect(scenario_builder).to receive(:build)
+
+      subject
+    end
+
+    it "returns the built scenario" do
+      expect(subject).to eql(scenario)
+    end
+
+  end
+
+end

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

@@ -0,0 +1,105 @@
+describe HttpStub::Configurer::DSL::StubBuilderProducer do
+
+  class HttpStub::Configurer::DSL::TestableStubBuilderProducer
+    include HttpStub::Configurer::DSL::StubBuilderProducer
+
+    def initialize(response_defaults)
+      @response_defaults = response_defaults
+      @builders = []
+    end
+
+    def add_stub!(builder)
+      @builders << builder
+    end
+
+  end
+
+  let(:response_defaults) { { default_key: "default value" } }
+
+  let(:producer) { HttpStub::Configurer::DSL::TestableStubBuilderProducer.new(response_defaults) }
+
+  describe "#build_stub" do
+
+    let(:stub_builder) { instance_double(HttpStub::Configurer::DSL::StubBuilder) }
+
+    before(:example) { allow(HttpStub::Configurer::DSL::StubBuilder).to receive(:new).and_return(stub_builder) }
+
+    subject { producer.build_stub }
+
+    it "creates a stub builder containing the producers response defaults" do
+      expect(HttpStub::Configurer::DSL::StubBuilder).to receive(:new).with(response_defaults)
+
+      subject
+    end
+
+    context "when a block is provided" do
+
+      context "that declares a stub builder parameter" do
+
+        let(:block) { lambda { |_stub_builder| "some block" } }
+
+        subject { producer.build_stub(&block) }
+
+        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
+
+      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
+
+      end
+
+    end
+
+    context "when a block is not provided" do
+
+      subject { producer.build_stub }
+
+      it "returns the built stub" do
+        expect(subject).to eql(stub_builder)
+      end
+
+    end
+
+  end
+
+  describe "#add_stubs!" do
+
+    context "when multiple stub builders are provided" do
+
+      let(:stub_builders) { (1..3).map { instance_double(HttpStub::Configurer::DSL::StubBuilder) } }
+
+      subject { producer.add_stubs!(stub_builders) }
+
+      it "adds each stub to the producer" do
+        stub_builders.each { |stub_builder| expect(producer).to receive(:add_stub!).with(stub_builder) }
+
+        subject
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/http_stub/configurer/{request → dsl}/stub_builder_spec.rb

@@ -1,14 +1,14 @@
-describe HttpStub::Configurer::Request::StubBuilder do
+describe HttpStub::Configurer::DSL::StubBuilder do
 
   let(:response_defaults) { {} }
 
-  let(:builder) { HttpStub::Configurer::Request::StubBuilder.new(response_defaults) }
+  let(:builder) { HttpStub::Configurer::DSL::StubBuilder.new(response_defaults) }
 
   shared_context "triggers one stub" do
 
     let(:trigger_stub) { instance_double(HttpStub::Configurer::Request::Stub) }
     let(:trigger_builder) do
-      instance_double(HttpStub::Configurer::Request::StubBuilder, build: trigger_stub)
+      instance_double(HttpStub::Configurer::DSL::StubBuilder, build: trigger_stub)
     end
 
     before(:example) { builder.trigger(trigger_builder) }
@@ -19,23 +19,51 @@ describe HttpStub::Configurer::Request::StubBuilder 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::Request::StubBuilder, build: stub) }
+      trigger_stubs.map { |stub| instance_double(HttpStub::Configurer::DSL::StubBuilder, build: stub) }
     end
 
     before(:example) { builder.trigger(trigger_builders) }
 
   end
 
+  describe "#match_requests" do
+
+    let(:fixture) { HttpStub::StubFixture.new }
+
+    subject { builder.match_requests(fixture.request.uri, fixture.request.symbolized) }
+
+    it "returns the builder to support method chaining" do
+      expect(subject).to eql(builder)
+    end
+
+  end
+
   describe "#respond_with" do
 
+    subject { builder.respond_with(status: 201) }
+
     it "does not modify any provided response defaults" do
       original_response_defaults = response_defaults.clone
 
-      builder.respond_with(status: 201)
+      subject
 
       expect(response_defaults).to eql(original_response_defaults)
     end
 
+    it "returns the builder to support method chaining" do
+      expect(subject).to eql(builder)
+    end
+
+  end
+
+  describe "#trigger" do
+
+    subject { builder.trigger(instance_double(HttpStub::Configurer::DSL::StubBuilder)) }
+
+    it "returns the builder to support method chaining" do
+      expect(subject).to eql(builder)
+    end
+
   end
 
   describe "#build" do