http_stub 0.25.1 → 0.26.0

data/spec/lib/http_stub/configurer/server/request_processor_spec.rb

@@ -1,10 +1,11 @@
 describe HttpStub::Configurer::Server::RequestProcessor do
 
-  let(:configurer)        { double(HttpStub::Configurer) }
-  let(:command_processor) { instance_double(HttpStub::Configurer::Server::CommandProcessor) }
-  let(:buffered_command_processor)  { instance_double(HttpStub::Configurer::Server::BufferedCommandProcessor) }
+  let(:configuration) { double(HttpStub::Server::Application::Configuration) }
 
-  let(:request_processor)     { HttpStub::Configurer::Server::RequestProcessor.new(configurer) }
+  let(:command_processor)          { instance_double(HttpStub::Configurer::Server::CommandProcessor) }
+  let(:buffered_command_processor) { instance_double(HttpStub::Configurer::Server::BufferedCommandProcessor) }
+
+  let(:request_processor) { described_class.new(configuration) }
 
   before(:example) do
     allow(HttpStub::Configurer::Server::CommandProcessor).to receive(:new).and_return(command_processor)
@@ -15,8 +16,8 @@ describe HttpStub::Configurer::Server::RequestProcessor do
 
   describe "constructor" do
 
-    it "creates a command processor for the configurer" do
-      expect(HttpStub::Configurer::Server::CommandProcessor).to receive(:new).with(configurer)
+    it "creates a command processor based on the servers configuration" do
+      expect(HttpStub::Configurer::Server::CommandProcessor).to receive(:new).with(configuration)
 
       request_processor
     end

data/spec/lib/http_stub/configurer/server/session_facade_spec.rb

@@ -0,0 +1,336 @@
+describe HttpStub::Configurer::Server::SessionFacade do
+
+  let(:session_id)        { "some session id" }
+  let(:request_processor) { instance_double(HttpStub::Configurer::Server::RequestProcessor) }
+
+  let(:session_facade) { described_class.new(session_id, request_processor) }
+
+  describe "#mark_as_default" do
+
+    let(:request) { instance_double(HttpStub::Configurer::Request::Http::Basic) }
+
+    subject { session_facade.mark_as_default }
+
+    before(:example) do
+      allow(HttpStub::Configurer::Request::Http::Factory).to receive(:post).and_return(request)
+      allow(request_processor).to receive(:submit)
+    end
+
+    it "creates an POST request to mark the session as the default" do
+      expect(HttpStub::Configurer::Request::Http::Factory).to(
+        receive(:post).with("sessions/default", anything).and_return(request)
+      )
+
+      subject
+    end
+
+    it "creates a POST request with the session id as a parameter" do
+      expect(HttpStub::Configurer::Request::Http::Factory).to(
+        receive(:post).with(anything, http_stub_session_id: session_id).and_return(request)
+      )
+
+      subject
+    end
+
+    it "submits the request via the request processor" do
+      expect(request_processor).to receive(:submit).with(hash_including(request: request))
+
+      subject
+    end
+
+    it "describes the request as marking the session" do
+      expect(request_processor).to(
+        receive(:submit).with(hash_including(description: a_string_including("marking")))
+      )
+
+      subject
+    end
+
+    it "describes the request as scoped within the session" do
+      expect(request_processor).to(
+        receive(:submit).with(hash_including(description: a_string_including("session '#{session_id}'")))
+      )
+
+      subject
+    end
+
+  end
+
+  describe "#stub_response" do
+
+    let(:the_stub_description) { "some stub description" }
+    let(:the_stub)             { instance_double(HttpStub::Configurer::Request::Stub, to_s: the_stub_description) }
+
+    let(:request) { instance_double(HttpStub::Configurer::Request::Http::Multipart) }
+
+    subject { session_facade.stub_response(the_stub) }
+
+    before(:example) do
+      allow(HttpStub::Configurer::Request::Http::Factory).to receive(:multipart).and_return(request)
+      allow(request_processor).to receive(:submit)
+    end
+
+    it "creates a multipart request to add a stub" do
+      expect(HttpStub::Configurer::Request::Http::Factory).to(
+        receive(:multipart).with("stubs", anything, anything)
+      )
+
+      subject
+    end
+
+    it "creates a multipart request with the provided stub" do
+      expect(HttpStub::Configurer::Request::Http::Factory).to receive(:multipart).with(anything, the_stub, anything)
+
+      subject
+    end
+
+    it "creates a multipart request identifying the session" do
+      expect(HttpStub::Configurer::Request::Http::Factory).to(
+        receive(:multipart).with(anything, anything, http_stub_session_id: session_id)
+      )
+
+      subject
+    end
+
+    it "submits the request via the request processor" do
+      expect(request_processor).to receive(:submit).with(hash_including(request: request))
+
+      subject
+    end
+
+    it "describes the stub via its string representation" do
+      expect(request_processor).to(
+        receive(:submit).with(hash_including(description: a_string_including("stubbing '#{the_stub_description}'")))
+      )
+
+      subject
+    end
+
+    it "describes the request as scoped within the session" do
+      expect(request_processor).to(
+        receive(:submit).with(hash_including(description: a_string_including("session '#{session_id}'")))
+      )
+
+      subject
+    end
+
+  end
+
+  describe "#activate" do
+
+    let(:scenario_names) { (1..3).map { |i| "scenario name #{i}" } }
+    let(:request)        { instance_double(HttpStub::Configurer::Request::Http::Basic) }
+
+    subject { session_facade.activate(scenario_names) }
+
+    before(:example) do
+      allow(HttpStub::Configurer::Request::Http::Factory).to receive(:post).and_return(request)
+      allow(request_processor).to receive(:submit)
+    end
+
+    it "creates an POST request to activate the scenarios" do
+      expect(HttpStub::Configurer::Request::Http::Factory).to(
+        receive(:post).with("scenarios/activate", anything).and_return(request)
+      )
+
+      subject
+    end
+
+    it "creates a POST request with the session id as a parameter" do
+      expect(HttpStub::Configurer::Request::Http::Factory).to(
+        receive(:post).with(anything, hash_including(http_stub_session_id: session_id)).and_return(request)
+      )
+
+      subject
+    end
+
+    it "creates a POST request with the scenario names as an array parameter" do
+      expect(HttpStub::Configurer::Request::Http::Factory).to(
+        receive(:post).with(anything, hash_including("names[]" => scenario_names)).and_return(request)
+      )
+
+      subject
+    end
+
+    it "submits the request via the request processor" do
+      expect(request_processor).to receive(:submit).with(hash_including(request: request))
+
+      subject
+    end
+
+
+
+    it "describes the activation request including the scenario names" do
+      quoted_scenario_names = scenario_names.map { |name| "'#{name}'" }
+      description_expectation = Regexp.new("activating #{quoted_scenario_names.join(", ")}")
+      expect(request_processor).to(
+        receive(:submit).with(hash_including(description: a_string_matching(description_expectation)))
+      )
+
+      subject
+    end
+
+    it "describes the request as scoped within the session" do
+      expect(request_processor).to(
+        receive(:submit).with(hash_including(description: a_string_including("session '#{session_id}'")))
+      )
+
+      subject
+    end
+
+  end
+
+  describe "#reset_stubs" do
+
+    let(:request) { instance_double(HttpStub::Configurer::Request::Http::Basic) }
+
+    subject { session_facade.reset_stubs }
+
+    before(:example) do
+      allow(HttpStub::Configurer::Request::Http::Factory).to receive(:post).and_return(request)
+      allow(request_processor).to receive(:submit)
+    end
+
+    it "creates a POST request to reset the stubs" do
+      expect(HttpStub::Configurer::Request::Http::Factory).to(
+        receive(:post).with("stubs/reset", anything).and_return(request)
+      )
+
+      subject
+    end
+
+    it "creates a POST request with the session id as a parameter" do
+      expect(HttpStub::Configurer::Request::Http::Factory).to(
+        receive(:post).with(anything, http_stub_session_id: session_id).and_return(request)
+      )
+
+      subject
+    end
+
+    it "submits the request via the request processor" do
+      expect(request_processor).to receive(:submit).with(hash_including(request: request))
+
+      subject
+    end
+
+    it "describes the request as resetting the stubs in memory" do
+      expect(request_processor).to(
+        receive(:submit).with(hash_including(description: a_string_including("resetting stubs")))
+      )
+
+      subject
+    end
+
+    it "describes the request as scoped within the session" do
+      expect(request_processor).to(
+        receive(:submit).with(hash_including(description: a_string_including("session '#{session_id}'")))
+      )
+
+      subject
+    end
+
+  end
+
+  describe "#clear_stubs" do
+
+    let(:request) { instance_double(HttpStub::Configurer::Request::Http::Basic) }
+
+    subject { session_facade.clear_stubs }
+
+    before(:example) do
+      allow(HttpStub::Configurer::Request::Http::Factory).to receive(:delete).and_return(request)
+      allow(request_processor).to receive(:submit)
+    end
+
+    it "creates a DELETE request that deletes a stub" do
+      expect(HttpStub::Configurer::Request::Http::Factory).to(
+        receive(:delete).with("stubs", anything).and_return(request)
+      )
+
+      subject
+    end
+
+    it "creates a DELETE request with the session id as a parameter" do
+      expect(HttpStub::Configurer::Request::Http::Factory).to(
+        receive(:delete).with(anything, http_stub_session_id: session_id).and_return(request)
+      )
+
+      subject
+    end
+
+    it "submits the request via the request processor" do
+      expect(request_processor).to receive(:submit).with(hash_including(request: request))
+
+      subject
+    end
+
+    it "describes the request as clearing the server stubs" do
+      expect(request_processor).to(
+        receive(:submit).with(hash_including(description: a_string_including("clearing stubs")))
+      )
+
+      subject
+    end
+
+    it "describes the request as scoped within the session" do
+      expect(request_processor).to(
+        receive(:submit).with(hash_including(description: a_string_including("session '#{session_id}'")))
+      )
+
+      subject
+    end
+
+  end
+
+  describe "#delete" do
+
+    let(:request) { instance_double(HttpStub::Configurer::Request::Http::Basic) }
+
+    subject { session_facade.delete }
+
+    before(:example) do
+      allow(HttpStub::Configurer::Request::Http::Factory).to receive(:delete).and_return(request)
+      allow(request_processor).to receive(:submit)
+    end
+
+    it "creates a DELETE request intended to delete a session" do
+      expect(HttpStub::Configurer::Request::Http::Factory).to(
+        receive(:delete).with("sessions", anything).and_return(request)
+      )
+
+      subject
+    end
+
+    it "creates a DELETE request with the session id as a parameter" do
+      expect(HttpStub::Configurer::Request::Http::Factory).to(
+        receive(:delete).with(anything, http_stub_session_id: session_id).and_return(request)
+      )
+
+      subject
+    end
+
+    it "submits the request via the request processor" do
+      expect(request_processor).to receive(:submit).with(hash_including(request: request))
+
+      subject
+    end
+
+    it "describes the request as clearing the server stubs" do
+      expect(request_processor).to(
+        receive(:submit).with(hash_including(description: a_string_including("deleting session '#{session_id}'")))
+      )
+
+      subject
+    end
+
+    it "describes the request as scoped within the session" do
+      expect(request_processor).to(
+        receive(:submit).with(hash_including(description: a_string_including("session '#{session_id}'")))
+      )
+
+      subject
+    end
+
+  end
+
+end

data/spec/lib/http_stub/configurer_spec.rb

@@ -0,0 +1,105 @@
+describe HttpStub::Configurer do
+
+  class HttpStub::Configurer::TestableConfigurer
+    include HttpStub::Configurer
+  end
+
+  let(:configurer_class) { HttpStub::Configurer::TestableConfigurer }
+  let(:configurer)       { configurer_class.new }
+
+  describe "::stub_server" do
+
+    subject { configurer_class.stub_server }
+
+    it "creates a server DSL" do
+      expect(HttpStub::Configurer::DSL::Server).to receive(:new)
+
+      subject
+    end
+
+    it "returns the created server DSL" do
+      server = instance_double(HttpStub::Configurer::DSL::Server)
+      allow(HttpStub::Configurer::DSL::Server).to receive(:new).and_return(server)
+
+      expect(subject).to eql(server)
+    end
+
+    it "reuses the stub server in subsequent requests" do
+      server = configurer_class.stub_server
+
+      expect(subject).to be(server)
+    end
+
+  end
+
+  describe "::initialize!" do
+
+    subject { configurer_class.initialize! }
+
+    before(:example) { allow(configurer_class.stub_server).to receive(:initialize!) }
+
+    context "when included in a class with an on_initialize class method" do
+
+      let(:configurer_class) do
+        Class.new do
+          include HttpStub::Configurer
+
+          def self.on_initialize
+            # Intentionally blank
+          end
+        end
+      end
+
+      context "and the class has not been initialized previously" do
+
+        it "invokes the on_initialize method" do
+          expect(configurer_class).to receive(:on_initialize)
+
+          subject
+        end
+
+      end
+
+      context "and the class has been initialized previously" do
+
+        before(:example) { configurer_class.initialize! }
+
+        it "does not re-invoke the on_initialize method" do
+          expect(configurer_class).to_not receive(:on_initialize)
+
+          subject
+        end
+
+      end
+
+    end
+
+    context "when included in a class without an on_initialize method" do
+
+      let(:configurer_class) { Class.new { include HttpStub::Configurer } }
+
+      it "executes without error" do
+        expect { subject }.to_not raise_error
+      end
+
+    end
+
+    it "initializes the stub server" do
+      expect(configurer_class.stub_server).to receive(:initialize!)
+
+      subject
+    end
+
+  end
+
+  describe "#stub_server" do
+
+    subject { configurer.stub_server }
+
+    it "returns the same server as the class method" do
+      expect(subject).to be(configurer_class.stub_server)
+    end
+
+  end
+
+end