http_stub 0.25.1 → 0.26.0

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

@@ -0,0 +1,167 @@
+describe HttpStub::Configurer::DSL::ServerEndpointTemplate do
+
+  let(:server)                    { instance_double(HttpStub::Configurer::DSL::Server) }
+  let(:session_endpoint_template) { instance_double(HttpStub::Configurer::DSL::SessionEndpointTemplate) }
+  let(:active_session)            do
+    instance_double(HttpStub::Configurer::DSL::Session, endpoint_template: session_endpoint_template)
+  end
+  let(:initial_block_verifier)    { double("BlockVerifier") }
+  let(:block)                     { lambda { initial_block_verifier.verify } }
+
+  let(:server_endpoint_template) { described_class.new(server, active_session, &block) }
+
+  before(:each) { }
+
+  it "creates a session template in the active session that is initialized with the provided block" do
+    expect(active_session).to receive(:endpoint_template).and_yield
+    expect(initial_block_verifier).to receive(:verify)
+
+    server_endpoint_template
+  end
+
+  describe "#match_requests" do
+
+    let(:request_matching_rules) { { uri: "/some/stub/uri", method: :get } }
+
+    subject { server_endpoint_template.match_requests(request_matching_rules) }
+
+    it "delegates to the session template" do
+      expect(session_endpoint_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 { server_endpoint_template.schema(type, definition) }
+
+    it "delegates to the session template" do
+      expect(session_endpoint_template).to receive(:schema).with(type, definition)
+
+      subject
+    end
+
+    it "returns the created schema" do
+      schema = { schema: :some_schema }
+      expect(session_endpoint_template).to receive(:schema).and_return(schema)
+
+      expect(subject).to eql(schema)
+    end
+
+  end
+
+  describe "#respond_with" do
+
+    let(:response_settings) { { status: 204 } }
+
+    subject { server_endpoint_template.respond_with(response_settings) }
+
+    it "delegates to the session templates" do
+      expect(session_endpoint_template).to receive(:respond_with).with(response_settings)
+
+      subject
+    end
+
+  end
+
+  describe "#trigger" do
+
+    let(:trigger_settings) { { scenario: "some scenario name" } }
+
+    subject { server_endpoint_template.trigger(trigger_settings) }
+
+    it "delegates to the session template" do
+      expect(session_endpoint_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 { server_endpoint_template.invoke(&block) }
+
+    it "delegates to the session template" do
+      expect(session_endpoint_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 { server_endpoint_template.build_stub(response_overrides, &block) }
+
+    it "delegates to the session template" do
+      expect(session_endpoint_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 } }
+
+    subject { server_endpoint_template.add_stub!(response_overrides, &block) }
+
+    it "delegates to the session template" do
+      expect(session_endpoint_template).to receive(:add_stub!).with(response_overrides).and_yield
+      expect(block_verifier).to receive(:verify)
+
+      subject
+    end
+
+  end
+
+  describe "#add_scenario!" do
+
+    let(:name)               { "Some scenario name" }
+    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 { server_endpoint_template.add_scenario!(name, response_overrides, &block) }
+
+    before(:example) do
+      allow(session_endpoint_template).to receive(:build_stub).and_return(stub_builder)
+      allow(server).to receive(:add_scenario_with_one_stub!)
+    end
+
+    it "builds a stub using any provided response overrides and block" do
+      expect(session_endpoint_template).to receive(:build_stub).with(response_overrides).and_yield
+      expect(block_verifier).to receive(:verify)
+
+      subject
+    end
+
+    it "adds a one stub scenario to the server with the provided name and created stub builder" do
+      expect(server).to receive(:add_scenario_with_one_stub!).with(name, stub_builder)
+
+      subject
+    end
+
+  end
+
+end

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

@@ -1,12 +1,49 @@
 describe HttpStub::Configurer::DSL::Server do
 
-  let(:server_facade)        { instance_double(HttpStub::Configurer::Server::Facade) }
-  let(:default_stub_builder) { instance_double(HttpStub::Configurer::DSL::StubBuilder) }
+  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) { HttpStub::Configurer::DSL::Server.new(server_facade) }
+  let(:server) { described_class.new }
 
   before(:example) do
-    allow(HttpStub::Configurer::DSL::StubBuilder).to receive(:new).with(no_args).and_return(default_stub_builder)
+    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
@@ -18,121 +55,142 @@ describe HttpStub::Configurer::DSL::Server do
 
   end
 
-  it "produces stub builders" do
-    expect(server).to be_a(HttpStub::Configurer::DSL::StubBuilderProducer)
-  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
 
-  it "activates scenarios" do
-    expect(server).to be_a(HttpStub::Configurer::DSL::ScenarioActivator)
   end
 
-  describe "#base_uri" do
+  describe "#host=" do
 
-    subject { server.base_uri }
+    let(:host) { "some_host" }
 
-    include_context "a server with host and port configured"
+    subject { server.host = host }
 
-    it "returns a uri that combines any established host and port" do
-      expect(subject).to include("some_host:8888")
-    end
+    it "delegates to the servers configuration" do
+      allow(configuration).to receive(:host=).with(host)
 
-    it "returns a uri accessed via http" do
-      expect(subject).to match(/^http:\/\//)
+      subject
     end
 
   end
 
-  describe "#external_base_uri" do
+  describe "#port" do
 
-    subject { server.external_base_uri }
+    let(:port) { "8888" }
 
-    include_context "a server with host and port configured"
+    subject { server.port }
 
-    context "when an external base URI environment variable is established" do
+    it "delegates to the servers configuration" do
+      allow(configuration).to receive(:port).and_return(port)
 
-      let(:external_base_uri) { "http://some/external/base/uri" }
+      expect(subject).to eql(port)
+    end
 
-      before(:example) { ENV["STUB_EXTERNAL_BASE_URI"] = external_base_uri }
-      after(:example)  { ENV["STUB_EXTERNAL_BASE_URI"] = nil }
+  end
 
-      it "returns the environment variable" do
-        expect(subject).to eql(external_base_uri)
-      end
+  describe "#port=" do
 
-    end
+    let(:port) { "8888" }
 
-    context "when an external base URI environment variable is not established" do
+    subject { server.port = port }
 
-      it "returns the base URI" do
-        expect(subject).to eql(server.base_uri)
-      end
+    it "delegates to the servers configuration" do
+      allow(configuration).to receive(:port=).with(port)
 
+      subject
     end
 
-    it "returns a uri that combines any established host and port" do
-      expect(subject).to include("some_host:8888")
-    end
+  end
+
+  describe "#base_uri" do
+
+    let(:base_uri) { "some_host:8888" }
 
-    it "returns a uri accessed via http" do
-      expect(subject).to match(/^http:\/\//)
+    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 "#enable" do
+  describe "#external_base_uri" do
 
-    context "when a feature is provided" do
+    let(:external_base_uri) { "http://some/external/base/uri" }
 
-      let(:feature) { :some_feature }
+    subject { server.external_base_uri }
 
-      subject { server.enable(feature) }
+    it "delegates to the servers configuration" do
+      allow(configuration).to receive(:external_base_uri).and_return(external_base_uri)
 
-      it "enables the feature" do
-        subject
+      expect(subject).to eql(external_base_uri)
+    end
 
-        expect(server.enabled?(feature)).to be(true)
-      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
 
-    context "when features are provided" do
+  end
 
-      let(:features) { (1..3).map { |i| "feature_#{i}".to_sym } }
+  describe "#session_identifer=" do
 
-      subject { server.enable(*features) }
+    let(:session_identifier) { { headers: :some_session_identifier } }
 
-      it "enables the features" do
-        subject
+    subject { server.session_identifier = session_identifier }
 
-        features.each { |feature| expect(server.enabled?(feature)).to be(true) }
-      end
+    it "delegates to the servers configuration" do
+      expect(configuration).to receive(:session_identifier=).with(session_identifier)
 
+      subject
     end
 
   end
 
-  describe "#enabled?" do
+  describe "#enable" do
 
-    let(:feature) { :some_feature }
+    let(:features) { (1..3).map { |i| "feature_#{i}".to_sym } }
 
-    subject { server.enabled?(feature) }
+    subject { server.enable(*features) }
 
-    context "when a feature is enabled" do
+    it "delegates to the sessions configuration" do
+      expect(configuration).to receive(:enable).with(*features)
 
-      before(:example) { server.enable(feature) }
+      subject
+    end
 
-      it "returns false" do
-        expect(subject).to be(true)
-      end
+  end
 
-    end
+  describe "#enabled?" do
+
+    let(:feature) { :some_feature }
 
-    context "when a feature is not enabled" do
+    subject { server.enabled?(feature) }
 
-      it "returns false" do
-        expect(subject).to be(false)
-      end
+    it "delegates to the servers configuration" do
+      expect(configuration).to receive(:enabled?).and_return(true)
 
+      expect(subject).to be(true)
     end
 
   end
@@ -141,10 +199,12 @@ describe HttpStub::Configurer::DSL::Server do
 
     let(:args) { { request_rule_key: "request rule value" } }
 
-    it "establishes request matcher rules on the default stub builder" do
-      expect(default_stub_builder).to receive(:match_requests).with(args)
+    subject { server.request_defaults = args }
 
-      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
@@ -153,82 +213,90 @@ describe HttpStub::Configurer::DSL::Server do
 
     let(:args) { { response_key: "response value" } }
 
-    it "establishes response values on the default stub builder" do
-      expect(default_stub_builder).to receive(:respond_with).with(args)
+    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)
 
-      server.response_defaults = args
+      subject
     end
 
   end
 
-  describe "#has_started!" do
-
-    it "informs the facade that the server has started" do
-      expect(server_facade).to receive(:server_has_started)
-
-      server.has_started!
-    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 "#add_stub!" do
+  describe "#initialize!" do
 
-    let(:stub)         { instance_double(HttpStub::Configurer::Request::Stub) }
-    let(:stub_builder) { instance_double(HttpStub::Configurer::DSL::StubBuilder, build: stub) }
+    subject { server.initialize! }
 
-    before(:example) { allow(server_facade).to receive(:stub_response) }
+    before(:example) do
+      allow(server_facade).to receive(:flush_requests)
+      allow(transactional_session).to receive(:mark_as_default!)
+    end
 
-    shared_examples_for "adding a stub request" do
+    it "flushes requests held by the server facade" do
+      expect(server_facade).to receive(:flush_requests)
 
-      it "builds the stub request" do
-        expect(stub_builder).to receive(:build).and_return(stub)
+      subject
+    end
 
-        subject
-      end
+    it "marks the transactional session as the servers default" do
+      expect(transactional_session).to receive(:mark_as_default!)
 
-      it "informs the server facade of the stub request" do
-        expect(server_facade).to receive(:stub_response).with(stub)
+      subject
+    end
 
-        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
 
-    context "when a stub builder is provided" do
+  end
 
-      subject { server.add_stub!(stub_builder) }
+  describe "#has_started!" do
 
-      it_behaves_like "adding a stub request"
+    subject { server.has_started! }
 
+    before(:example) do
+      allow(server_facade).to receive(:server_has_started)
+      allow(transactional_session).to receive(:mark_as_default!)
     end
 
-    context "when a stub builder is not provided" do
+    it "informs the facade that the server has started" do
+      expect(server_facade).to receive(:server_has_started)
 
-      let(:block_verifier) { double("BlockVerifier") }
-      let(:block)          { lambda { block_verifier.verify } }
+      subject
+    end
 
-      before(:example) do
-        allow(HttpStub::Configurer::DSL::StubBuilder).to receive(:new).and_return(stub_builder)
-        allow(stub_builder).to receive(:invoke)
-      end
+    it "marks the transactional session as the servers default" do
+      expect(transactional_session).to receive(:mark_as_default!)
 
-      subject { server.add_stub!(&block) }
+      subject
+    end
 
-      it "creates a stub builder" do
-        expect(HttpStub::Configurer::DSL::StubBuilder).to receive(:new)
+    it "causes subsequent session operations to be performed against the transactional session" do
+      subject
+      expect(transactional_session).to receive(:activate!)
 
-        subject
-      end
+      server.activate!("some scenario name")
+    end
 
-      it "requests the created builder invoke the provided block" do
-        expect(stub_builder).to receive(:invoke).and_yield
-        expect(block_verifier).to receive(:verify)
+  end
 
-        subject
-      end
+  describe "#reset!" do
+
+    subject { server.reset! }
 
-      it_behaves_like "adding a stub request"
+    it "delegates to the server facade" do
+      expect(server_facade).to receive(:reset)
 
+      subject
     end
 
   end
@@ -236,27 +304,26 @@ describe HttpStub::Configurer::DSL::Server do
   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) }
 
-    before(:example) { allow(server_facade).to receive(:define_scenario) }
-
-    let(:block) { lambda { |_scenario| "some block" } }
+    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
 
-    subject { server.add_scenario!(scenario_name, &block) }
-
-    it "creates a scenario builder containing the servers default stub builder" do
-      expect(HttpStub::Configurer::DSL::ScenarioBuilder).to receive(:new).with(default_stub_builder, anything)
+    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 containing the provided scenario name" do
-      expect(HttpStub::Configurer::DSL::ScenarioBuilder).to receive(:new).with(anything, scenario_name)
+    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
@@ -281,9 +348,8 @@ describe HttpStub::Configurer::DSL::Server do
 
   describe "#add_scenario_with_one_stub!" do
 
-    let(:scenario_name)  { "Some scenario name" }
-    let(:block_verifier) { double("BlockVerifier") }
-    let(:block)          { lambda { block_verifier.verify } }
+    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) }
@@ -318,8 +384,7 @@ describe HttpStub::Configurer::DSL::Server do
 
     context "when a block is provided" do
 
-      let(:block_verifier) { double("BlockVerifier") }
-      let(:block)          { lambda { block_verifier.verify } }
+      let(:block) { lambda { block_verifier.verify } }
 
       subject { server.add_scenario_with_one_stub!(scenario_name, &block) }
 
@@ -338,124 +403,189 @@ describe HttpStub::Configurer::DSL::Server do
 
   describe "#endpoint_template" do
 
-    let(:block_verifier)    { double("BlockVerifier") }
-    let(:block)             { lambda { block_verifier.verify } }
-    let(:endpoint_template) { instance_double(HttpStub::Configurer::DSL::EndpointTemplate, invoke: nil) }
+    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::EndpointTemplate).to receive(:new).and_return(endpoint_template)
+      allow(HttpStub::Configurer::DSL::ServerEndpointTemplate).to receive(:new).and_return(server_endpoint_template)
     end
 
-    it "requests the endpoint template invoke the provided block" do
-      expect(endpoint_template).to receive(:invoke).and_yield
-      expect(block_verifier).to receive(:verify)
+    it "creates an endpoint template for the server" do
+      expect(HttpStub::Configurer::DSL::ServerEndpointTemplate).to receive(:new).with(server, anything)
 
       subject
     end
 
-    it "creates a template for the server" do
-      expect(HttpStub::Configurer::DSL::EndpointTemplate).to receive(:new).with(server).and_return(endpoint_template)
+    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(endpoint_template)
+      expect(subject).to eql(server_endpoint_template)
     end
 
   end
 
-  describe "#add_activator!" do
+  describe "#session" do
 
-    let(:scenario) { instance_double(HttpStub::Configurer::Request::Scenario) }
-    let(:stub_activator_builder) do
-      instance_double(HttpStub::Configurer::DSL::StubActivatorBuilder, build: scenario)
-    end
+    let(:session_id) { "some session id" }
 
-    before(:example) { allow(server_facade).to receive(:define_scenario) }
+    let(:session) { instance_double(HttpStub::Configurer::DSL::Session) }
 
-    let(:block) { lambda { |_activator| "some block" } }
+    subject { server.session(session_id) }
 
-    before(:example) do
-      allow(HttpStub::Configurer::DSL::StubActivatorBuilder).to receive(:new).and_return(stub_activator_builder)
+    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
 
-    subject { server.add_activator!(&block) }
+  end
+
+  describe "#activate!" do
 
-    it "creates a stub activator builder containing the servers default stub builder" do
-      expect(HttpStub::Configurer::DSL::StubActivatorBuilder).to receive(:new).with(default_stub_builder)
+    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
 
-    it "yields the created builder to the provided block" do
-      expect { |block| server.add_activator!(&block) }.to yield_with_args(stub_activator_builder)
+  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
 
-    it "builds a scenario request" do
-      expect(stub_activator_builder).to receive(:build).and_return(scenario)
+  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 "informs the server facade to submit the scenario request" do
-      expect(server_facade).to receive(:define_scenario).with(scenario)
+    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 "#activate!" do
+  describe "#add_stub!" do
 
-    let(:scenario_name) { "/some/scenario/name" }
+    context "when a stub builder is provided" do
 
-    it "delegates to the server facade" do
-      expect(server_facade).to receive(:activate).with(scenario_name)
+      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
 
-      server.activate!(scenario_name)
     end
 
-  end
+    context "when a block is provided" do
 
-  describe "#remember_stubs" do
+      let(:block) { lambda { block_verifier.verify } }
 
-    it "delegates to the server facade" do
-      expect(server_facade).to receive(:remember_stubs)
+      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
 
-      server.remember_stubs
     end
 
   end
 
-  describe "#recall_stubs!" do
+  describe "#add_stubs!" do
 
-    it "delegates to the server facade" do
-      expect(server_facade).to receive(:recall_stubs)
+    let(:stub_builders) { (1..3).map { instance_double(HttpStub::Configurer::DSL::StubBuilder) } }
 
-      server.recall_stubs!
+    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 "#clear_stubs!" do
+  describe "#recall_stubs!" do
 
-    it "delegates to the server facade" do
-      expect(server_facade).to receive(:clear_stubs)
+    subject { server.recall_stubs! }
 
-      server.clear_stubs!
+    it "resets the default session" do
+      expect(default_session).to receive(:reset!)
+
+      subject
     end
 
   end
 
-  describe "#clear_scenarios!" do
+  describe "#clear_stubs!" do
+
+    subject { server.clear_stubs! }
 
-    it "delegates to the server facade" do
-      expect(server_facade).to receive(:clear_scenarios)
+    it "delegates to the default session" do
+      expect(default_session).to receive(:clear!)
 
-      server.clear_scenarios!
+      subject
     end
 
   end