http_stub 0.27.0 → 0.28.0.beta1

data/spec/lib/http_stub/configurator/scenario_spec.rb

@@ -0,0 +1,162 @@
+describe HttpStub::Configurator::Scenario do
+
+  let(:name)                  { "some scenario name" }
+  let(:default_stub_template) { instance_double(HttpStub::Configurator::Stub::Template) }
+
+  let(:scenario) { HttpStub::Configurator::Scenario.new(name, default_stub_template) }
+
+  describe "#build_stub" do
+
+    let(:response_overrides) { { status: 201 } }
+    let(:block_verifier)     { double("BlockVerifier") }
+    let(:block)              { lambda { block_verifier.verify } }
+
+    subject { scenario.build_stub(response_overrides, &block) }
+
+    it "delegates to the provided default stub template" do
+      expect(default_stub_template).to receive(:build_stub).with(response_overrides).and_yield
+      expect(block_verifier).to receive(:verify)
+
+      subject
+    end
+
+    it "returns the built stub" do
+      built_stub = instance_double(HttpStub::Configurator::Stub::Stub)
+      allow(default_stub_template).to receive(:build_stub).and_return(built_stub)
+
+      expect(subject).to eql(built_stub)
+    end
+
+  end
+
+  describe "#add_stub!" do
+
+    let(:stub_hash)  { { stub_key: "stub value" } }
+    let(:built_stub) { instance_double(HttpStub::Configurator::Stub::Stub, to_hash: stub_hash) }
+
+    context "when a block is provided" do
+
+      let(:block_verifier) { double("BlockVerifier") }
+      let(:block)          { lambda { block_verifier.verify } }
+
+      subject { scenario.add_stub!(&block) }
+
+      before(:example) { allow(default_stub_template).to receive(:build_stub).and_return(built_stub) }
+
+      it "builds a stub whose values are initialized via the provided block" do
+        expect(default_stub_template).to receive(:build_stub).with(no_args).and_yield.and_return(built_stub)
+        expect(block_verifier).to receive(:verify)
+
+        subject
+      end
+
+      it "adds the stub to the scenario" do
+        subject
+
+        expect(scenario.to_hash).to include(stubs: [ stub_hash ])
+      end
+
+    end
+
+    context "when a stub is provided" do
+
+      subject { scenario.add_stub!(built_stub) }
+
+      it "adds the stub to the scenario" do
+        subject
+
+        expect(scenario.to_hash).to include(stubs: [ stub_hash ])
+      end
+
+    end
+
+  end
+
+  describe "#add_stubs!" do
+
+    let(:stub_hashes) { (1..3).map { |i| { "stub_#{i}_key" => "stub value #{i}" } } }
+    let(:stubs)       { stub_hashes.map { |hash| instance_double(HttpStub::Configurator::Stub::Stub, to_hash: hash) } }
+
+    subject { scenario.add_stubs!(stubs) }
+
+    it "adds each stub to the scenario" do
+      subject
+
+      expect(scenario.to_hash).to include(stubs: stub_hashes)
+    end
+
+  end
+
+  describe "#activate_scenarios!" do
+
+    let(:scenario_names) { (1..3).map { |i| "scenario name #{i}" } }
+
+    context "when the scenario names are provided as an array" do
+
+      subject { scenario.activate_scenarios!(scenario_names) }
+
+      it "adds the scenario names to scenarios triggered by this scenario" do
+        subject
+
+        expect(scenario.to_hash).to include(triggered_scenario_names: scenario_names)
+      end
+
+    end
+
+    context "when the scenario names are provided as a list of parameters" do
+
+      subject { scenario.activate_scenarios!(*scenario_names) }
+
+      it "adds the scenario names to scenarios triggered by this scenario" do
+        subject
+
+        expect(scenario.to_hash).to include(triggered_scenario_names: scenario_names)
+      end
+
+    end
+
+  end
+
+  describe "#activate!" do
+
+    context "when the scenario is activated" do
+
+      subject { scenario.activate! }
+
+      it "marks the scenario as immediately active" do
+        subject
+
+        expect(scenario.to_hash).to include(activated: true)
+      end
+
+    end
+
+  end
+
+  describe "#to_hash" do
+
+    subject { scenario.to_hash }
+
+    it "includes the name of the scenario" do
+      expect(subject).to include(name: name)
+    end
+
+    context "when the scenario is unchanged" do
+
+      it "includes an activated flag that is false" do
+        expect(scenario.to_hash).to include(activated: false)
+      end
+
+      it "includes stubs that are empty" do
+        expect(scenario.to_hash).to include(stubs: [])
+      end
+
+      it "includes triggered scenario names that are empty" do
+        expect(scenario.to_hash).to include(triggered_scenario_names: [])
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/http_stub/configurator/server_spec.rb

@@ -0,0 +1,344 @@
+describe HttpStub::Configurator::Server do
+
+  let(:state)                { instance_double(HttpStub::Configurator::State) }
+  let(:server_stub_template) { instance_double(HttpStub::Configurator::Stub::Template) }
+
+  let(:block_verifier)  { double("BlockVerifier") }
+
+  let(:server) { described_class.new(state) }
+
+  before(:example) { allow(HttpStub::Configurator::Stub::Template).to receive(:new).and_return(server_stub_template) }
+
+  it "creates a stub template to hold the default stub settings for the server" do
+    expect(HttpStub::Configurator::Stub::Template).to receive(:new).with(no_args)
+
+    server
+  end
+
+  shared_context "a server with a port configured" do
+
+    before(:example) { server.port =  8888 }
+
+  end
+
+  describe "#port=" do
+
+    let(:port) { "8888" }
+
+    subject { server.port = port }
+
+    it "delegates to the servers state" do
+      allow(state).to receive(:port=).with(port)
+
+      subject
+    end
+
+  end
+
+  describe "#external_base_uri" do
+
+    let(:external_base_uri) { "http://some/external/base/uri" }
+
+    subject { server.external_base_uri }
+
+    it "delegates to the servers state" do
+      allow(state).to receive(:external_base_uri).and_return(external_base_uri)
+
+      expect(subject).to eql(external_base_uri)
+    end
+
+  end
+
+  describe "#session_identifer=" do
+
+    let(:session_identifier) { { headers: :some_session_identifier } }
+
+    subject { server.session_identifier = session_identifier }
+
+    it "delegates to the servers state" do
+      expect(state).to receive(:session_identifier=).with(session_identifier)
+
+      subject
+    end
+
+  end
+
+  describe "#enable" do
+
+    let(:feature) { :a_feature }
+
+    subject { server.enable(feature) }
+
+    it "delegates to the servers state" do
+      expect(state).to receive(:enable).with(feature)
+
+      subject
+    end
+
+  end
+
+  describe "#request_defaults=" do
+
+    let(:args) { { request_rule_key: "request rule value" } }
+
+    subject { server.request_defaults = args }
+
+    it "establishes request matching rules on the default stub template" do
+      expect(server_stub_template).to receive(:match_requests).with(args)
+
+      subject
+    end
+
+  end
+
+  describe "#response_defaults=" do
+
+    let(:args) { { response_key: "response value" } }
+
+    subject { server.response_defaults = args }
+
+    it "establishes response values on the default stub template" do
+      expect(server_stub_template).to receive(:respond_with).with(args)
+
+      subject
+    end
+
+  end
+
+  describe "#endpoint_template" do
+
+    let(:block)             { lambda { block_verifier.verify } }
+    let(:endpoint_template) { instance_double(HttpStub::Configurator::EndpointTemplate) }
+
+    subject { server.endpoint_template(&block) }
+
+    before(:example) { allow(HttpStub::Configurator::EndpointTemplate).to receive(:new).and_return(endpoint_template) }
+
+    it "creates an endpoint template for the server" do
+      expect(HttpStub::Configurator::EndpointTemplate).to receive(:new).with(server, anything)
+
+      subject
+    end
+
+    it "creates an endpoint template extending the servers stub template" do
+      expect(HttpStub::Configurator::EndpointTemplate).to receive(:new).with(anything, server_stub_template)
+
+      subject
+    end
+
+    it "creates an endpoint template using any provided block to initialize the template" do
+      allow(HttpStub::Configurator::EndpointTemplate).to receive(:new).and_yield
+      expect(block_verifier).to receive(:verify)
+
+      subject
+    end
+
+    it "returns the created endpoint template" do
+      expect(subject).to eql(endpoint_template)
+    end
+
+  end
+
+  describe "#add_scenario!" do
+
+    let(:scenario_name)    { "some/scenario/name" }
+    let(:block)            { lambda { |_scenario| "some block" } }
+
+    let(:scenario) { instance_double(HttpStub::Configurator::Scenario) }
+
+    subject { server.add_scenario!(scenario_name, &block) }
+
+    before(:example) do
+      allow(HttpStub::Configurator::Scenario).to receive(:new).and_return(scenario)
+      allow(state).to receive(:add_scenario)
+    end
+
+    it "creates a scenario containing the provided scenario name" do
+      expect(HttpStub::Configurator::Scenario).to receive(:new).with(scenario_name, anything)
+
+      subject
+    end
+
+    it "creates a scenario extending the servers stub template" do
+      expect(HttpStub::Configurator::Scenario).to receive(:new).with(anything, server_stub_template)
+
+      subject
+    end
+
+    it "yields the created scenario to the provided block" do
+      expect { |block| server.add_scenario!(scenario_name, &block) }.to yield_with_args(scenario)
+    end
+
+    it "adds the scenario to submit the configurators state" do
+      expect(state).to receive(:add_scenario).with(scenario)
+
+      subject
+    end
+
+  end
+
+  describe "#add_scenario_with_one_stub!" do
+
+    let(:scenario_name) { "Some scenario name" }
+    let(:block)         { lambda { block_verifier.verify } }
+
+    let(:scenario) { instance_double(HttpStub::Configurator::Scenario, add_stub!: nil) }
+    let(:the_stub) { instance_double(HttpStub::Configurator::Stub::Stub, invoke: nil) }
+
+    subject { server.add_scenario_with_one_stub!(scenario_name, the_stub) }
+
+    before(:each) { allow(server).to receive(:add_scenario!).and_yield(scenario) }
+
+    it "adds a scenario with the provided name" do
+      expect(server).to receive(:add_scenario!).with(scenario_name)
+
+      subject
+    end
+
+    context "when a stub is provided" do
+
+      subject { server.add_scenario_with_one_stub!(scenario_name, the_stub) }
+
+      it "adds the stub to the scenario" do
+        expect(scenario).to receive(:add_stub!).with(the_stub)
+
+        subject
+      end
+
+    end
+
+    context "when a block is provided" do
+
+      subject { server.add_scenario_with_one_stub!(scenario_name, &block) }
+
+      before(:example) { allow(scenario).to receive(:add_stub!).and_yield(the_stub) }
+
+      it "adds an empty stub to the scenario" do
+        expect(scenario).to receive(:add_stub!).with(nil)
+        
+        subject
+      end
+
+      context "that accepts the stub as an argument" do
+
+        let(:block) { lambda { |_stub| block_verifier.verify } }
+
+        it "invokes the stub with no additional argument" do
+          expect(the_stub).to receive(:invoke).with(nil).and_yield(the_stub)
+          expect(block_verifier).to receive(:verify)
+
+          subject
+        end
+
+      end
+
+      context "that accepts the stub and scenario as arguments" do
+
+        let(:block) { lambda { |_stub, _scenario| block_verifier.verify } }
+
+        it "invokes the stub and supplies the scenario" do
+          expect(the_stub).to receive(:invoke).with(scenario).and_yield(the_stub, scenario)
+          expect(block_verifier).to receive(:verify)
+
+          subject
+        end
+
+      end
+
+    end
+
+  end
+
+  describe "#build_stub" do
+
+    let(:block) { lambda { block_verifier.verify } }
+
+    subject { server.build_stub(&block) }
+
+    it "delegates to the servers stub template" do
+      expect(server_stub_template).to receive(:build_stub)
+
+      subject
+    end
+
+    it "initializes the built stub using the provided block" do
+      allow(server_stub_template).to receive(:build_stub).and_yield
+      expect(block_verifier).to receive(:verify)
+
+      subject
+    end
+
+    it "returns the built stub" do
+      built_stub = instance_double(HttpStub::Configurator::Stub::Stub)
+      allow(server_stub_template).to receive(:build_stub).and_return(built_stub)
+
+      expect(subject).to eql(built_stub)
+    end
+
+  end
+
+  describe "#add_stub!" do
+
+    let(:the_stub) { instance_double(HttpStub::Configurator::Stub::Stub) }
+
+    context "when a stub is provided" do
+
+      subject { server.add_stub!(the_stub) }
+
+      it "adds the stub to the configurators state" do
+        expect(state).to receive(:add_stub).with(the_stub)
+
+        subject
+      end
+
+    end
+
+    context "when a block is provided" do
+
+      let(:block) { lambda { block_verifier.verify } }
+
+      subject { server.add_stub!(&block) }
+
+      before(:each) do
+        allow(server_stub_template).to receive(:build_stub).and_return(the_stub)
+        allow(state).to receive(:add_stub)
+      end
+
+      it "builds a stub via the servers stub template" do
+        expect(server_stub_template).to receive(:build_stub)
+
+        subject
+      end
+
+      it "invokes the block with the created stub" do
+        allow(server_stub_template).to receive(:build_stub).and_yield
+        expect(block_verifier).to receive(:verify)
+
+        subject
+      end
+
+      it "adds the stub to the configurators state" do
+        expect(state).to receive(:add_stub).with(the_stub)
+
+        subject
+      end
+
+    end
+
+  end
+
+  describe "#add_stubs!" do
+
+    let(:the_stubs) { (1..3).map { instance_double(HttpStub::Configurator::Stub::Stub) } }
+
+    subject { server.add_stubs!(the_stubs) }
+
+    it "add the stubs to the configurators state" do
+      the_stubs.each { |the_stub| expect(state).to receive(:add_stub).with(the_stub) }
+
+      subject
+    end
+
+  end
+
+end