http_stub 0.25.1 → 0.26.0

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

@@ -0,0 +1,150 @@
+describe HttpStub::Configurer::DSL::SessionEndpointTemplate do
+
+  let(:session)                { instance_double(HttpStub::Configurer::DSL::Session) }
+  let(:default_stub_template)  { instance_double(HttpStub::Configurer::DSL::StubBuilderTemplate) }
+  let(:initial_block_verifier) { double("BlockVerifier") }
+  let(:block)                  { lambda { initial_block_verifier.verify } }
+
+  let(:session_stub_template) { instance_double(HttpStub::Configurer::DSL::StubBuilderTemplate) }
+
+  let(:session_endpoint_template) { described_class.new(session, default_stub_template, &block) }
+
+  before(:each) do
+    allow(HttpStub::Configurer::DSL::StubBuilderTemplate).to receive(:new).and_return(session_stub_template)
+  end
+
+  it "creates a stub template that extends the default template and is initialized with the provided block" do
+    expect(HttpStub::Configurer::DSL::StubBuilderTemplate).to receive(:new).with(default_stub_template).and_yield
+    expect(initial_block_verifier).to receive(:verify)
+
+    session_endpoint_template
+  end
+
+  describe "#match_requests" do
+
+    let(:request_matching_rules) { { uri: "/some/stub/uri", method: :get } }
+
+    subject { session_endpoint_template.match_requests(request_matching_rules) }
+
+    it "delegates to the sessions stub template" do
+      expect(session_stub_template).to receive(:match_requests).with(request_matching_rules)
+
+      subject
+    end
+
+  end
+
+  describe "#schema" do
+
+    let(:type)       { :some_schema_type }
+    let(:definition) { "some schema definition" }
+
+    subject { session_endpoint_template.schema(type, definition) }
+
+    it "delegates to the sessions stub template" do
+      expect(session_stub_template).to receive(:schema).with(type, definition)
+
+      subject
+    end
+
+    it "returns the created schema" do
+      schema = { schema: :some_schema }
+      expect(session_stub_template).to receive(:schema).and_return(schema)
+
+      expect(subject).to eql(schema)
+    end
+
+  end
+
+  describe "#respond_with" do
+
+    let(:response_settings) { { status: 204 } }
+
+    subject { session_endpoint_template.respond_with(response_settings) }
+
+    it "delegates to the sessions stub template" do
+      expect(session_stub_template).to receive(:respond_with).with(response_settings)
+
+      subject
+    end
+
+  end
+
+  describe "#trigger" do
+
+    let(:trigger_settings) { { scenario: "some scenario name" } }
+
+    subject { session_endpoint_template.trigger(trigger_settings) }
+
+    it "delegates to the sessions stub template" do
+      expect(session_stub_template).to receive(:trigger).with(trigger_settings)
+
+      subject
+    end
+
+  end
+
+  describe "#invoke" do
+
+    let(:block_verifier) { double("BlockVerifier") }
+    let(:block)          { lambda { block_verifier.verify } }
+
+    subject { session_endpoint_template.invoke(&block) }
+
+    it "delegates to the sessions stub template" do
+      expect(session_stub_template).to receive(:invoke).and_yield
+      expect(block_verifier).to receive(:verify)
+
+      subject
+    end
+
+  end
+
+  describe "#build_stub" do
+
+    let(:response_overrides) { { status: 201 } }
+    let(:block_verifier)     { double("BlockVerifier") }
+    let(:block)              { lambda { block_verifier.verify } }
+
+    subject { session_endpoint_template.build_stub(response_overrides, &block) }
+
+    it "delegates to the sessions stub template" do
+      expect(session_stub_template).to receive(:build_stub).with(response_overrides).and_yield
+      expect(block_verifier).to receive(:verify)
+
+      subject
+    end
+
+  end
+
+  describe "#add_stub!" do
+
+    let(:response_overrides) { { status: 201 } }
+    let(:block_verifier)     { double("BlockVerifier") }
+    let(:block)              { lambda { block_verifier.verify } }
+
+    let(:stub_builder) { instance_double(HttpStub::Configurer::DSL::StubBuilder) }
+
+    subject { session_endpoint_template.add_stub!(response_overrides, &block) }
+
+    before(:example) do
+      allow(session_stub_template).to receive(:build_stub).and_return(stub_builder)
+      allow(session).to receive(:add_stub!)
+    end
+
+    it "builds a stub using any provided response overrides and block" do
+      expect(session_stub_template).to receive(:build_stub).with(response_overrides).and_yield
+      expect(block_verifier).to receive(:verify)
+
+      subject
+    end
+
+    it "adds a stub to the session with the provided name and created stub builder" do
+      expect(session).to receive(:add_stub!).with(stub_builder)
+
+      subject
+    end
+
+  end
+
+end

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

@@ -0,0 +1,97 @@
+describe HttpStub::Configurer::DSL::SessionFactory do
+
+  let(:server_facade)         { instance_double(HttpStub::Configurer::Server::Facade) }
+  let(:default_stub_template) { instance_double(HttpStub::Configurer::DSL::StubBuilderTemplate) }
+
+  let(:session) { instance_double(HttpStub::Configurer::DSL::Session) }
+
+  let(:session_factory) { described_class.new(server_facade, default_stub_template) }
+
+  describe "#create" do
+
+    let(:id) { "some_session_id" }
+
+    subject { create_session }
+
+    it "creates a session with the provided ID" do
+      expect(HttpStub::Configurer::DSL::Session).to receive(:new).with(id, anything, anything)
+
+      subject
+    end
+
+    it "creates a session uses the stubs server facade" do
+      expect(HttpStub::Configurer::DSL::Session).to receive(:new).with(anything, server_facade, anything)
+
+      subject
+    end
+
+    it "creates a session uses the stubs default stub template" do
+      expect(HttpStub::Configurer::DSL::Session).to receive(:new).with(anything, anything, default_stub_template)
+
+      subject
+    end
+
+    it "returns the created session" do
+      allow(HttpStub::Configurer::DSL::Session).to receive(:new).and_return(session)
+
+      expect(subject).to eql(session)
+
+    end
+
+    context "when a session has been created" do
+
+      before(:example) do
+        allow(HttpStub::Configurer::DSL::Session).to receive(:new).and_return(session).once
+
+        create_session
+      end
+
+      it "returns the same session when a session with the same ID is created" do
+        expect(subject).to be(session)
+      end
+
+    end
+
+    def create_session
+      session_factory.create(id)
+    end
+
+  end
+
+  describe "#memory" do
+
+    subject { session_factory.memory }
+
+    it "creates a session whose ID is an internal memory identifier" do
+      expect(session_factory).to receive(:create).with("http_stub_memory")
+
+      subject
+    end
+
+    it "returns the created session" do
+      allow(session_factory).to receive(:create).and_return(session)
+
+      expect(subject).to eql(session)
+    end
+
+  end
+
+  describe "#transactional" do
+
+    subject { session_factory.transactional }
+
+    it "creates a session whose ID is an internal transactional space identifier" do
+      expect(session_factory).to receive(:create).with("http_stub_transactional")
+
+      subject
+    end
+
+    it "returns the created session" do
+      allow(session_factory).to receive(:create).and_return(session)
+
+      expect(subject).to eql(session)
+    end
+
+  end
+
+end

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

@@ -0,0 +1,222 @@
+describe HttpStub::Configurer::DSL::Session do
+
+  let(:id)                    { "some_session_id" }
+  let(:session_facade)        { instance_double(HttpStub::Configurer::Server::SessionFacade) }
+  let(:server_facade)         do
+    instance_double(HttpStub::Configurer::Server::Facade, create_session_facade: session_facade)
+  end
+  let(:default_stub_template) { instance_double(HttpStub::Configurer::DSL::StubBuilderTemplate) }
+
+  let(:block_verifier) { double("BlockVerifier") }
+
+  let(:session) { described_class.new(id, server_facade, default_stub_template) }
+
+  it "creates a facade the session uses to interact with the stub server" do
+    expect(server_facade).to receive(:create_session_facade).with(id)
+
+    session
+  end
+
+  describe "#mark_as_default!" do
+
+    subject { session.mark_as_default! }
+
+    it "marks the session as the servers default via the session facade" do
+      expect(session_facade).to receive(:mark_as_default)
+
+      subject
+    end
+
+  end
+
+  describe "#endpoint_template" do
+
+    let(:block)                    { lambda { block_verifier.verify } }
+    let(:session_endpoint_template) { instance_double(HttpStub::Configurer::DSL::SessionEndpointTemplate) }
+
+    subject { session.endpoint_template(&block) }
+
+    before(:example) do
+      allow(HttpStub::Configurer::DSL::SessionEndpointTemplate).to receive(:new).and_return(session_endpoint_template)
+    end
+
+    it "creates an endpoint template for the session" do
+      expect(HttpStub::Configurer::DSL::SessionEndpointTemplate).to receive(:new).with(session, anything)
+
+      subject
+    end
+
+    it "creates an endpoint template that extends the default stub template" do
+      expect(HttpStub::Configurer::DSL::SessionEndpointTemplate).to receive(:new).with(anything, default_stub_template)
+
+      subject
+    end
+
+    it "creates an endpoint template using any provided block to initialize the template" do
+      allow(HttpStub::Configurer::DSL::SessionEndpointTemplate).to receive(:new).and_yield
+      expect(block_verifier).to receive(:verify)
+
+      subject
+    end
+
+    it "returns the created endpoint template" do
+      expect(subject).to eql(session_endpoint_template)
+    end
+
+  end
+
+  describe "#activate!" do
+
+    let(:scenario_names) { (1..3).map { |i| "Scenario name #{i}" } }
+
+    subject { session.activate!(*scenario_names) }
+
+    it "delegates to the session facade in order to activate the scenarios" do
+      expect(session_facade).to receive(:activate).with(scenario_names)
+
+      subject
+    end
+
+  end
+
+  describe "#build_stub" do
+
+    let(:block) { lambda { block_verifier.verify } }
+
+    subject { session.build_stub(&block) }
+
+    it "delegates to the servers default stub template" do
+      expect(default_stub_template).to receive(:build_stub)
+
+      subject
+    end
+
+    it "initializes the built stub using the provided block" do
+      allow(default_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::Configurer::DSL::StubBuilder)
+      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(:built_stub)   { instance_double(HttpStub::Configurer::Request::Stub) }
+    let(:stub_builder) { instance_double(HttpStub::Configurer::DSL::StubBuilder, build: built_stub) }
+
+    before(:example) { allow(session_facade).to receive(:stub_response) }
+
+    context "when a stub builder is provided" do
+
+      subject { session.add_stub!(stub_builder) }
+
+      it "builds a stub from the provided builder" do
+        expect(stub_builder).to receive(:build)
+
+        subject
+      end
+
+      it "registers the built stub via the session facade" do
+        expect(session_facade).to receive(:stub_response).with(built_stub)
+
+        subject
+      end
+
+    end
+
+    context "when a block is provided" do
+
+      let(:block) { lambda { block_verifier.verify } }
+
+      subject { session.add_stub!(&block) }
+
+      before(:example) { allow(default_stub_template).to receive(:build_stub).and_return(stub_builder) }
+
+      it "creates a stub builder via the servers default stub template" do
+        expect(default_stub_template).to receive(:build_stub)
+
+        subject
+      end
+
+      it "supplies the provided block when creating the stub builder" do
+        allow(default_stub_template).to receive(:build_stub).and_return(stub_builder).and_yield
+        expect(block_verifier).to receive(:verify)
+
+        subject
+      end
+
+      it "builds a stub from the created builder" do
+        expect(stub_builder).to receive(:build)
+
+        subject
+      end
+
+      it "registers the built stub via the session facade" do
+        expect(session_facade).to receive(:stub_response).with(built_stub)
+
+        subject
+      end
+
+    end
+
+  end
+
+  describe "#add_stubs!" do
+
+    let(:stub_builders) { (1..3).map { instance_double(HttpStub::Configurer::DSL::StubBuilder) } }
+
+    subject { session.add_stubs!(stub_builders) }
+
+    it "adds each provided stub" do
+      stub_builders.each { |stub_builder| allow(session).to receive(:add_stub!).with(stub_builder) }
+
+      subject
+    end
+
+  end
+
+  describe "#reset!" do
+
+    subject { session.reset! }
+
+    it "resets the sessions stubs via the session facade" do
+      expect(session_facade).to receive(:reset_stubs)
+
+      subject
+    end
+
+  end
+
+  describe "#clear!" do
+
+    subject { session.clear! }
+
+    it "clears the sessions stubs via the session facade" do
+      expect(session_facade).to receive(:clear_stubs)
+
+      subject
+    end
+
+  end
+
+  describe "#delete!" do
+
+    subject { session.delete! }
+
+    it "deletes the session via the session facade" do
+      expect(session_facade).to receive(:delete)
+
+      subject
+    end
+
+  end
+
+end