RubyGems - http_stub - Versions diffs - 0.27.0 → 0.28.0.beta1 - Mend

http_stub 0.27.0 → 0.28.0.beta1

Files changed (299) hide show

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

@@ -1,150 +0,0 @@
-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 DELETED Viewed

@@ -1,97 +0,0 @@
-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 DELETED Viewed

@@ -1,210 +0,0 @@
-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 "#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