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/acceptance/request_reference_spec.rb DELETED Viewed

@@ -1,42 +0,0 @@
-describe "Request references in response acceptance" do
-  include_context "configurer integration"
-  let(:configurer_specification) { { class: HttpStub::Examples::ConfigurerWithRequestReferences } }
-  context "when a request is made matching a stub that references request attributes" do
-    let(:header_value)    { "some header value" }
-    let(:parameter_value) { "some parameter value" }
-    let(:response) do
-      HTTParty.get("#{server_uri}/some_path", headers: { "header_name"    => header_value },
-                                              query:   { "parameter_name" => parameter_value })
-    end
-    context "the response headers" do
-      it "include request headers" do
-        expect(response.headers["header_referencing_header"]).to eql(header_value)
-      end
-      it "include request parameters" do
-        expect(response.headers["header_referencing_parameter"]).to eql(parameter_value)
-      end
-    end
-    context "the response body" do
-      it "include request headers" do
-        expect(response.body).to include(header_value)
-      end
-      it "include request parameters" do
-        expect(response.body).to include(parameter_value)
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-describe HttpStub::Configurer::DSL::RequestAttributeReferencer do
-  let(:attribute_type) { :some_attribute_type }
-  let(:request_attribute_referencer) { described_class.new(attribute_type) }
-  describe "#[]" do
-    let(:name) { "some_name" }
-    subject { request_attribute_referencer[name] }
-    it "returns a control value" do
-      expect(subject).to start_with("control:")
-    end
-    it "returns a string referring to the referencer request attribute type" do
-      expect(subject).to include("request.some_attribute_type")
-    end
-    it "returns a string that will resolve the value for the provided name" do
-      expect(subject).to end_with("[#{name}]")
-    end
-    context "when the name provided is a symbol" do
-      let(:name) { :some_name }
-      it "returns a string that resolves the value with the provided name" do
-        expect(subject).to end_with("[#{name}]")
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-describe HttpStub::Configurer::DSL::RequestReferencer do
-  let(:request_referencer) { described_class.new }
-  before(:example) { allow(HttpStub::Configurer::DSL::RequestAttributeReferencer).to receive(:new) }
-  describe "#parameters" do
-    subject { request_referencer.parameters }
-    it "returns an attribute request referencer for parameters" do
-      parameter_referencer = instance_double(HttpStub::Configurer::DSL::RequestAttributeReferencer)
-      allow(HttpStub::Configurer::DSL::RequestAttributeReferencer).to(
-        receive(:new).with(:parameters).and_return(parameter_referencer)
-      )
-      expect(subject).to eql(parameter_referencer)
-    end
-  end
-  describe "#headers" do
-    subject { request_referencer.headers }
-    it "returns an attribute request referencer for headers" do
-      header_referencer = instance_double(HttpStub::Configurer::DSL::RequestAttributeReferencer)
-      allow(HttpStub::Configurer::DSL::RequestAttributeReferencer).to(
-        receive(:new).with(:headers).and_return(header_referencer)
-      )
-      expect(subject).to eql(header_referencer)
-    end
-  end
-end

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

@@ -1,201 +0,0 @@
-describe HttpStub::Configurer::DSL::ScenarioBuilder do
-  let(:stub_fixture) { HttpStub::StubFixture.new }
-  let(:scenario_name)        { "some scenario name" }
-  let(:default_stub_template) { instance_double(HttpStub::Configurer::DSL::StubBuilderTemplate) }
-  let(:scenario_builder) { HttpStub::Configurer::DSL::ScenarioBuilder.new(scenario_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_builder.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::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(:stub_builder) { instance_double(HttpStub::Configurer::DSL::StubBuilder) }
-    context "when a block is provided" do
-      let(:block_verifier) { double("BlockVerifier") }
-      let(:block)          { lambda { block_verifier.verify } }
-      subject { scenario_builder.add_stub!(&block) }
-      before(:example) { allow(scenario_builder).to receive(:build_stub).and_return(stub_builder) }
-      it "builds a stub whose values are initialized via the provided block" do
-        expect(scenario_builder).to receive(:build_stub).with(no_args).and_yield
-        expect(block_verifier).to receive(:verify)
-        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 "#add_stubs!" do
-    let(:stub_builders) { (1..3).map { instance_double(HttpStub::Configurer::DSL::StubBuilder) } }
-    subject { scenario_builder.add_stubs!(stub_builders) }
-    it "adds each stub to the scenario builders" do
-      stub_builders.each { |stub_builder| expect(scenario_builder).to receive(:add_stub!).with(stub_builder) }
-      subject
-    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 the scenario registers multiple stubs" 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) { scenario_builder.add_stubs!(stub_builders) }
-      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 the scenario registers no stubs" 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 the scenario activates an array scenarios" do
-      let(:triggered_scenario_names) { (1..3).map { |i| "scenario #{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 the scenario activates a list of scenarios" 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 the scenario activates one scenario" do
-      let(:triggered_scenario_name) { "a scenario" }
-      before(:example) { scenario_builder.activate!(triggered_scenario_name) }
-      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_name ]))
-        )
-        subject
-      end
-    end
-    context "when the scenario does not activate any scenarios" 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/server_spec.rb DELETED Viewed

@@ -1,575 +0,0 @@
-describe HttpStub::Configurer::DSL::Server do
-  let(:configuration)         { instance_double(HttpStub::Configurer::Server::Configuration) }
-  let(:server_facade)         { instance_double(HttpStub::Configurer::Server::Facade) }
-  let(:default_stub_template) { instance_double(HttpStub::Configurer::DSL::StubBuilderTemplate) }
-  let(:memory_session)        { instance_double(HttpStub::Configurer::DSL::Session) }
-  let(:transactional_session) { instance_double(HttpStub::Configurer::DSL::Session) }
-  let(:session_factory)       do
-    instance_double(HttpStub::Configurer::DSL::SessionFactory, memory:        memory_session,
-                                                               transactional: transactional_session)
-  end
-  let(:default_session) { memory_session }
-  let(:block_verifier)  { double("BlockVerifier") }
-  let(:server) { described_class.new }
-  before(:example) do
-    allow(HttpStub::Configurer::Server::Configuration).to receive(:new).and_return(configuration)
-    allow(HttpStub::Configurer::Server::Facade).to receive(:new).and_return(server_facade)
-    allow(HttpStub::Configurer::DSL::StubBuilderTemplate).to receive(:new).and_return(default_stub_template)
-    allow(HttpStub::Configurer::DSL::SessionFactory).to receive(:new).and_return(session_factory)
-  end
-  it "creates a server configuration" do
-    expect(HttpStub::Configurer::Server::Configuration).to receive(:new)
-    server
-  end
-  it "creates a facade to interact with the stub server based on the configuration" do
-    expect(HttpStub::Configurer::Server::Facade).to receive(:new).with(configuration)
-    server
-  end
-  it "creates a stub builder template to hold the default stub settings for the server" do
-    expect(HttpStub::Configurer::DSL::StubBuilderTemplate).to receive(:new).with(no_args)
-    server
-  end
-  it "creates a session factory that creates sessions interacting with the servers facade and stub template" do
-    expect(HttpStub::Configurer::DSL::SessionFactory).to receive(:new).with(server_facade, default_stub_template)
-    server
-  end
-  shared_context "a server with host and port configured" do
-    before(:example) do
-      server.host = "some_host"
-      server.port =  8888
-    end
-  end
-  describe "#host" do
-    let(:host) { "some_host" }
-    subject { server.host }
-    it "delegates to the servers configuration" do
-      allow(configuration).to receive(:host).and_return(host)
-      expect(subject).to eql(host)
-    end
-  end
-  describe "#host=" do
-    let(:host) { "some_host" }
-    subject { server.host = host }
-    it "delegates to the servers configuration" do
-      allow(configuration).to receive(:host=).with(host)
-      subject
-    end
-  end
-  describe "#port" do
-    let(:port) { "8888" }
-    subject { server.port }
-    it "delegates to the servers configuration" do
-      allow(configuration).to receive(:port).and_return(port)
-      expect(subject).to eql(port)
-    end
-  end
-  describe "#port=" do
-    let(:port) { "8888" }
-    subject { server.port = port }
-    it "delegates to the servers configuration" do
-      allow(configuration).to receive(:port=).with(port)
-      subject
-    end
-  end
-  describe "#base_uri" do
-    let(:base_uri) { "some_host:8888" }
-    subject { server.base_uri }
-    it "delegates to the servers configuration" do
-      allow(configuration).to receive(:base_uri).and_return(base_uri)
-      expect(subject).to eql(base_uri)
-    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 configuration" do
-      allow(configuration).to receive(:external_base_uri).and_return(external_base_uri)
-      expect(subject).to eql(external_base_uri)
-    end
-  end
-  describe "#session_identifier" do
-    let(:session_identifier) { { headers: :some_session_identifier } }
-    subject { server.session_identifier }
-    it "delegates to the servers configuration" do
-      allow(configuration).to receive(:session_identifier).and_return(session_identifier)
-      expect(subject).to eql(session_identifier)
-    end
-  end
-  describe "#session_identifer=" do
-    let(:session_identifier) { { headers: :some_session_identifier } }
-    subject { server.session_identifier = session_identifier }
-    it "delegates to the servers configuration" do
-      expect(configuration).to receive(:session_identifier=).with(session_identifier)
-      subject
-    end
-  end
-  describe "#enable" do
-    let(:features) { (1..3).map { |i| "feature_#{i}".to_sym } }
-    subject { server.enable(*features) }
-    it "delegates to the sessions configuration" do
-      expect(configuration).to receive(:enable).with(*features)
-      subject
-    end
-  end
-  describe "#enabled?" do
-    let(:feature) { :some_feature }
-    subject { server.enabled?(feature) }
-    it "delegates to the servers configuration" do
-      expect(configuration).to receive(:enabled?).and_return(true)
-      expect(subject).to be(true)
-    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(default_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(default_stub_template).to receive(:respond_with).with(args)
-      subject
-    end
-  end
-  it "causes session operations to be performed against the memory session prior to initialization" do
-    expect(memory_session).to receive(:activate!)
-    server.activate!("some scenario name")
-  end
-  describe "#initialize!" do
-    subject { server.initialize! }
-    before(:example) { allow(server_facade).to receive(:initialize_server) }
-    it "initializes the server via the facade" do
-      expect(server_facade).to receive(:initialize_server)
-      subject
-    end
-    it "causes subsequent session operations to be performed against the transactional session" do
-      subject
-      expect(transactional_session).to receive(:activate!)
-      server.activate!("some scenario name")
-    end
-  end
-  describe "#has_started!" do
-    subject { server.has_started! }
-    before(:example) { allow(server_facade).to receive(:server_has_started) }
-    it "informs the facade that the server has started" do
-      expect(server_facade).to receive(:server_has_started)
-      subject
-    end
-    it "causes subsequent session operations to be performed against the transactional session" do
-      subject
-      expect(transactional_session).to receive(:activate!)
-      server.activate!("some scenario name")
-    end
-  end
-  describe "#reset!" do
-    subject { server.reset! }
-    it "delegates to the server facade" do
-      expect(server_facade).to receive(:reset)
-      subject
-    end
-  end
-  describe "#add_scenario!" do
-    let(:scenario_name)    { "some/scenario/name" }
-    let(:block)            { lambda { |_scenario| "some block" } }
-    let(:scenario)         { instance_double(HttpStub::Configurer::Request::Scenario) }
-    let(:scenario_builder) { instance_double(HttpStub::Configurer::DSL::ScenarioBuilder, build: scenario) }
-    subject { server.add_scenario!(scenario_name, &block) }
-    before(:example) do
-      allow(HttpStub::Configurer::DSL::ScenarioBuilder).to receive(:new).and_return(scenario_builder)
-      allow(server_facade).to receive(:define_scenario)
-    end
-    it "creates a scenario builder containing the provided scenario name" do
-      expect(HttpStub::Configurer::DSL::ScenarioBuilder).to receive(:new).with(scenario_name, anything)
-      subject
-    end
-    it "creates a scenario builder extending the servers default stub template" do
-      expect(HttpStub::Configurer::DSL::ScenarioBuilder).to receive(:new).with(anything, default_stub_template)
-      subject
-    end
-    it "yields the created builder to the provided block" do
-      expect { |block| server.add_scenario!(scenario_name, &block) }.to yield_with_args(scenario_builder)
-    end
-    it "builds the scenario request" do
-      expect(scenario_builder).to receive(:build).and_return(scenario)
-      subject
-    end
-    it "informs the server facade to submit the scenario request" do
-      expect(server_facade).to receive(:define_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_builder) { instance_double(HttpStub::Configurer::DSL::ScenarioBuilder, add_stub!: nil) }
-    let(:stub_builder)     { instance_double(HttpStub::Configurer::DSL::StubBuilder, invoke: nil) }
-    subject { server.add_scenario_with_one_stub!(scenario_name, stub_builder) }
-    before(:each) { allow(server).to receive(:add_scenario!).and_yield(scenario_builder) }
-    it "adds a scenario with the provided name" do
-      expect(server).to receive(:add_scenario!).with(scenario_name)
-      subject
-    end
-    it "adds a stub to the scenario" do
-      expect(scenario_builder).to receive(:add_stub!)
-      subject
-    end
-    context "when a builder is provided" do
-      subject { server.add_scenario_with_one_stub!(scenario_name, stub_builder) }
-      it "adds a stub to the scenario with the provided builder" do
-        expect(scenario_builder).to receive(:add_stub!).with(stub_builder)
-        subject
-      end
-    end
-    context "when a block is provided" do
-      let(:block) { lambda { block_verifier.verify } }
-      subject { server.add_scenario_with_one_stub!(scenario_name, &block) }
-      before(:example) { allow(scenario_builder).to receive(:add_stub!).and_yield(stub_builder) }
-      it "requests the stub builder invoke the provided block" do
-        expect(stub_builder).to receive(:invoke).and_yield
-        expect(block_verifier).to receive(:verify)
-        subject
-      end
-    end
-  end
-  describe "#endpoint_template" do
-    let(:block)                    { lambda { block_verifier.verify } }
-    let(:server_endpoint_template) { instance_double(HttpStub::Configurer::DSL::ServerEndpointTemplate) }
-    subject { server.endpoint_template(&block) }
-    before(:example) do
-      allow(HttpStub::Configurer::DSL::ServerEndpointTemplate).to receive(:new).and_return(server_endpoint_template)
-    end
-    it "creates an endpoint template for the server" do
-      expect(HttpStub::Configurer::DSL::ServerEndpointTemplate).to receive(:new).with(server, anything)
-      subject
-    end
-    it "creates an endpoint template using the curently default session" do
-      expect(HttpStub::Configurer::DSL::ServerEndpointTemplate).to receive(:new).with(anything, default_session)
-      subject
-    end
-    it "creates an endpoint template using any provided block to initialize the template" do
-      allow(HttpStub::Configurer::DSL::ServerEndpointTemplate).to receive(:new).and_yield
-      expect(block_verifier).to receive(:verify)
-      subject
-    end
-    it "returns the created endpoint template" do
-      expect(subject).to eql(server_endpoint_template)
-    end
-  end
-  describe "#session" do
-    let(:session_id) { "some session id" }
-    let(:session) { instance_double(HttpStub::Configurer::DSL::Session) }
-    subject { server.session(session_id) }
-    before(:example) { allow(session_factory).to receive(:create).and_return(session) }
-    it "creates a DSL for interacting with a session for the provided ID via the session factory" do
-      expect(session_factory).to receive(:create).with(session_id)
-      subject
-    end
-    it "returns the created session" do
-      expect(subject).to eql(session)
-    end
-  end
-  describe "#activate!" do
-    let(:scenario_name) { "Some scenario name" }
-    subject { server.activate!(scenario_name) }
-    it "delegates to the default session" do
-      expect(default_session).to receive(:activate!).with(scenario_name)
-      subject
-    end
-  end
-  describe "#clear_sessions!" do
-    subject { server.clear_sessions! }
-    it "delegates to the server facade" do
-      expect(server_facade).to receive(:clear_sessions)
-      subject
-    end
-  end
-  describe "#build_stub" do
-    let(:block) { lambda { block_verifier.verify } }
-    subject { server.build_stub(&block) }
-    it "delegates to the default session" do
-      expect(default_session).to receive(:build_stub)
-      subject
-    end
-    it "initializes the built stub using the provided block" do
-      allow(default_session).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_session).to receive(:build_stub).and_return(built_stub)
-      expect(subject).to eql(built_stub)
-    end
-  end
-  describe "#add_stub!" do
-    context "when a stub builder is provided" do
-      let(:stub_builder) { instance_double(HttpStub::Configurer::DSL::StubBuilder) }
-      subject { server.add_stub!(stub_builder) }
-      it "delegates to the default session" do
-        expect(default_session).to receive(:add_stub!).with(stub_builder)
-        subject
-      end
-    end
-    context "when a block is provided" do
-      let(:block) { lambda { block_verifier.verify } }
-      subject { server.add_stub!(&block) }
-      it "delegates to the default session" do
-        expect(default_session).to receive(:add_stub!)
-        subject
-      end
-      it "supplies the provided block to the session" do
-        allow(default_session).to receive(:add_stub!).and_yield
-        expect(block_verifier).to receive(:verify)
-        subject
-      end
-    end
-  end
-  describe "#add_stubs!" do
-    let(:stub_builders) { (1..3).map { instance_double(HttpStub::Configurer::DSL::StubBuilder) } }
-    subject { server.add_stubs!(stub_builders) }
-    it "delegates to the default session" do
-      expect(default_session).to receive(:add_stubs!).with(stub_builders)
-      subject
-    end
-  end
-  describe "#recall_stubs!" do
-    subject { server.recall_stubs! }
-    it "resets the default session" do
-      expect(default_session).to receive(:reset!)
-      subject
-    end
-  end
-  describe "#clear_stubs!" do
-    subject { server.clear_stubs! }
-    it "delegates to the default session" do
-      expect(default_session).to receive(:clear!)
-      subject
-    end
-  end
-end