http_stub 0.25.1 → 0.26.0

data/spec/lib/http_stub/configurer/request/triggers_spec.rb

@@ -0,0 +1,101 @@
+describe HttpStub::Configurer::Request::Triggers do
+
+  let(:scenario_names) { (1..3).map { |i| "Some scenario #{i}" } }
+  let(:stubs)          { (1..3).map { instance_double(HttpStub::Configurer::Request::Stub) } }
+
+  let(:triggers) { HttpStub::Configurer::Request::Triggers.new(scenario_names: scenario_names, stubs: stubs) }
+
+  describe "#response_files" do
+
+    let(:stubs)                   do
+      response_files_per_stub.map do |response_files|
+        instance_double(HttpStub::Configurer::Request::Stub, response_files: response_files)
+      end
+    end
+
+    subject { triggers.response_files }
+
+    context "when many stubs contains response files" do
+
+      let(:response_files_per_stub) do
+        (1..3).map { (1..3).map { HttpStub::Configurer::Request::StubResponseFile } }
+      end
+
+      it "returns all the response files" do
+        expect(subject).to eql(response_files_per_stub.flatten)
+      end
+
+    end
+
+    context "when one stub contains response files" do
+
+      let(:response_files)          { (1..3).map { HttpStub::Configurer::Request::StubResponseFile } }
+      let(:response_files_per_stub) { (1..3).map { |i| i % 2 == 0 ? response_files : [] } }
+
+      it "returns the response files" do
+        expect(subject).to eql(response_files)
+      end
+
+    end
+
+    context "when no stubs contain response files" do
+
+      let(:response_files_per_stub) { (1..3).map { [] } }
+
+      it "returns an empty array" do
+        expect(subject).to eql([])
+      end
+
+    end
+
+  end
+
+  describe "#payload" do
+
+    let(:stub_payloads) { stubs.each_with_index.map { |i| "Stub payload #{i}" } }
+
+    subject { triggers.payload }
+
+    before(:example) do
+      stubs.zip(stub_payloads).each { |stub, payload| allow(stub).to receive(:payload).and_return(payload) }
+    end
+
+    context "when scenario names are provided" do
+
+      it "has a scenario names entry containing the names" do
+        expect(subject).to include(scenario_names: scenario_names)
+      end
+
+    end
+
+    context "when no scenario names are provided" do
+
+      let(:scenario_names) { [] }
+
+      it "has an scenario names entry that is empty" do
+        expect(subject).to include(scenario_names: [])
+      end
+
+    end
+
+    context "when stubs are provided" do
+
+      it "has a stubs entry containing the payload of the stubs" do
+        expect(subject).to include(stubs: stub_payloads)
+      end
+
+    end
+
+    context "when stub are not provided" do
+
+      let(:stubs) { [] }
+
+      it "has a stubs entry that is empty" do
+        expect(subject).to include(stubs: [])
+      end
+
+    end
+
+  end
+
+end

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

@@ -1,19 +1,20 @@
 describe HttpStub::Configurer::Server::CommandProcessor do
 
-  let(:command) { HttpStub::Configurer::Server::Command.new(request: request, description: "performing an operation") }
   let(:server_host)     { "localhost" }
   let(:server_port)     { 8001 }
   let(:server_base_uri) { "http://#{server_host}:#{server_port}" }
-  let(:stub_server) do
-    instance_double(HttpStub::Configurer::DSL::Server, base_uri: server_base_uri, host: server_host, port: server_port)
+  let(:configuration)   do
+    double(HttpStub::Configurer::Server::Configuration, base_uri: server_base_uri, host: server_host, port: server_port)
   end
 
-  let(:configurer) { double(HttpStub::Configurer, stub_server: stub_server) }
-
-  let(:command_processor) { HttpStub::Configurer::Server::CommandProcessor.new(configurer) }
+  let(:command_processor) { HttpStub::Configurer::Server::CommandProcessor.new(configuration) }
 
   describe "#process" do
 
+    let(:command) do
+      HttpStub::Configurer::Server::Command.new(request: request, description: "performing an operation")
+    end
+
     subject { command_processor.process(command) }
 
     context "when the server is running" do
@@ -21,7 +22,7 @@ describe HttpStub::Configurer::Server::CommandProcessor do
 
       describe "and the server responds with a 200 response" do
 
-        let(:request) { create_get_request("/http_stub/stubs") }
+        let(:request) { create_get_request("stubs") }
 
         it "executes without error" do
           expect { subject }.not_to raise_error
@@ -35,7 +36,7 @@ describe HttpStub::Configurer::Server::CommandProcessor do
 
       describe "and the server responds with a non-200 response" do
 
-        let(:request) { create_get_request("/causes_error") }
+        let(:request) { create_get_request("causes_error") }
 
         it "raises an exception that includes the server base URI" do
           expect { subject }.to raise_error(/#{server_base_uri}/)
@@ -53,7 +54,7 @@ describe HttpStub::Configurer::Server::CommandProcessor do
 
       subject { command_processor.process(command, open_timeout: 1) }
 
-      let(:request) { create_get_request("/does/not/exist") }
+      let(:request) { create_get_request("does/not/exist") }
 
       it "raises an exception that includes the server base URI" do
         expect { subject }.to raise_error(/#{server_base_uri}/)
@@ -66,7 +67,7 @@ describe HttpStub::Configurer::Server::CommandProcessor do
     end
 
     def create_get_request(path)
-      HttpStub::Configurer::Request::Http::Basic.new(Net::HTTP::Get.new(path))
+      HttpStub::Configurer::Request::Http::Basic.new(method: :get, path: path)
     end
 
   end

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

@@ -0,0 +1,139 @@
+describe HttpStub::Configurer::Server::Configuration do
+
+  let(:configuration) { described_class.new }
+
+  shared_context "a configuration with host and port configured" do
+
+    before(:example) do
+      configuration.host = "some_host"
+      configuration.port =  8888
+    end
+
+  end
+
+  describe "#session_identifier" do
+
+    let(:session_identifier) { { headers: :some_session_identifier } }
+
+    subject { configuration.session_identifier }
+
+    before(:example) { configuration.session_identifier = session_identifier }
+
+    it "returns any configured value" do
+      expect(subject).to eql(session_identifier)
+    end
+
+  end
+
+  describe "#base_uri" do
+
+    subject { configuration.base_uri }
+
+    include_context "a configuration with host and port configured"
+
+    it "returns a uri that combines any established host and port" do
+      expect(subject).to include("some_host:8888")
+    end
+
+    it "returns a uri accessed via http" do
+      expect(subject).to match(/^http:\/\//)
+    end
+
+  end
+
+  describe "#external_base_uri" do
+
+    subject { configuration.external_base_uri }
+
+    include_context "a configuration with host and port configured"
+
+    context "when an external base URI environment variable is established" do
+
+      let(:external_base_uri) { "http://some/external/base/uri" }
+
+      before(:example) { ENV["STUB_EXTERNAL_BASE_URI"] = external_base_uri }
+      after(:example)  { ENV["STUB_EXTERNAL_BASE_URI"] = nil }
+
+      it "returns the environment variable" do
+        expect(subject).to eql(external_base_uri)
+      end
+
+    end
+
+    context "when an external base URI environment variable is not established" do
+
+      it "returns the base URI" do
+        expect(subject).to eql(configuration.base_uri)
+      end
+
+    end
+
+    it "returns a uri that combines any established host and port" do
+      expect(subject).to include("some_host:8888")
+    end
+
+    it "returns a uri accessed via http" do
+      expect(subject).to match(/^http:\/\//)
+    end
+
+  end
+
+  describe "#enable" do
+
+    context "when a feature is provided" do
+
+      let(:feature) { :some_feature }
+
+      subject { configuration.enable(feature) }
+
+      it "enables the feature" do
+        subject
+
+        expect(configuration.enabled?(feature)).to be(true)
+      end
+
+    end
+
+    context "when features are provided" do
+
+      let(:features) { (1..3).map { |i| "feature_#{i}".to_sym } }
+
+      subject { configuration.enable(*features) }
+
+      it "enables the features" do
+        subject
+
+        features.each { |feature| expect(configuration.enabled?(feature)).to be(true) }
+      end
+
+    end
+
+  end
+
+  describe "#enabled?" do
+
+    let(:feature) { :some_feature }
+
+    subject { configuration.enabled?(feature) }
+
+    context "when a feature is enabled" do
+
+      before(:example) { configuration.enable(feature) }
+
+      it "returns false" do
+        expect(subject).to be(true)
+      end
+
+    end
+
+    context "when a feature is not enabled" do
+
+      it "returns false" do
+        expect(subject).to be(false)
+      end
+
+    end
+
+  end
+
+end

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

@@ -1,116 +1,98 @@
 describe HttpStub::Configurer::Server::Facade do
 
-  let(:configurer)        { double(HttpStub::Configurer) }
+  let(:configuration) { double(HttpStub::Configurer::Server::Configuration) }
+
   let(:request_processor) { instance_double(HttpStub::Configurer::Server::RequestProcessor) }
 
-  let(:facade) { HttpStub::Configurer::Server::Facade.new(configurer) }
+  let(:facade) { HttpStub::Configurer::Server::Facade.new(configuration) }
 
   before(:example) do
     allow(HttpStub::Configurer::Server::RequestProcessor).to receive(:new).and_return(request_processor)
   end
   
-  describe "constructor" do
-
-    it "creates a request processor with the provided configurer" do
-      expect(HttpStub::Configurer::Server::RequestProcessor).to receive(:new).with(configurer)
-      
-      facade
-    end
+  it "creates a request processor with the provided configuration" do
+    expect(HttpStub::Configurer::Server::RequestProcessor).to receive(:new).with(configuration)
 
+    facade
   end
 
-  describe "#stub_response" do
-
-    let(:model_description) { "some model description" }
-    let(:model)             { instance_double(HttpStub::Configurer::Request::Stub, to_s: model_description) }
-    let(:request)           { instance_double(HttpStub::Configurer::Request::Http::Multipart) }
+  describe "#server_has_started" do
 
-    subject { facade.stub_response(model) }
+    subject { facade.server_has_started }
 
-    before(:example) do
-      allow(request_processor).to receive(:submit)
-      allow(HttpStub::Configurer::Request::Http::Factory).to receive(:multipart).and_return(request)
-    end
-
-    it "creates a multipart request with the provided model" do
-      expect(HttpStub::Configurer::Request::Http::Factory).to receive(:multipart).with(model)
+    it "informs the request processor to disable buffering requests" do
+      expect(request_processor).to receive(:disable_buffering!)
 
       subject
     end
 
-    it "submits the request via the request processor" do
-      expect(request_processor).to receive(:submit).with(hash_including(request: request))
+  end
 
-      subject
-    end
+  describe "#flush_requests" do
+
+    subject { facade.flush_requests }
 
-    it "describes the model via its string representation" do
-      expect(request_processor).to receive(:submit).with(hash_including(description: "stubbing '#{model_description}'"))
+    it "informs the request processor to flush it's requests" do
+      expect(request_processor).to receive(:flush!)
 
       subject
     end
 
   end
 
-  describe "#define_scenario" do
+  describe "#reset" do
 
-    let(:model_description) { "some model description" }
-    let(:model)             { instance_double(HttpStub::Configurer::Request::Scenario, to_s: model_description) }
-    let(:request)           { instance_double(HttpStub::Configurer::Request::Http::Multipart) }
+    let(:request) { instance_double(HttpStub::Configurer::Request::Http::Basic) }
 
-    subject { facade.define_scenario(model) }
+    subject { facade.reset }
 
     before(:example) do
+      allow(HttpStub::Configurer::Request::Http::Factory).to receive(:delete).and_return(request)
       allow(request_processor).to receive(:submit)
-      allow(HttpStub::Configurer::Request::Http::Factory).to receive(:multipart).and_return(request)
     end
 
-    it "creates a multipart request with the provided model" do
-      expect(HttpStub::Configurer::Request::Http::Factory).to receive(:multipart).with(model)
+    it "creates a DELETE request for the memory endpoint" do
+      expect(HttpStub::Configurer::Request::Http::Factory).to receive(:delete).with("memory").and_return(request)
 
       subject
     end
 
-    it "submits the request via the request processor" do
+    it "submits the HTTP Stub request via the request processor" do
       expect(request_processor).to receive(:submit).with(hash_including(request: request))
 
       subject
     end
 
-    it "describes the model via its string representation" do
-      expect(request_processor).to(
-        receive(:submit).with(hash_including(description: "registering scenario '#{model_description}'"))
-      )
+    it "describes the request as resetting the server" do
+      expect(request_processor).to receive(:submit).with(hash_including(description: "resetting server"))
 
       subject
     end
 
   end
 
-  describe "#activate" do
+  describe "#define_scenario" do
+
+    let(:scenario_description) { "some scenario description" }
+    let(:scenario)             { instance_double(HttpStub::Configurer::Request::Scenario, to_s: scenario_description) }
 
-    let(:scenario_name) { "some/scenario/name" }
-    let(:request)       { instance_double(HttpStub::Configurer::Request::Http::Basic) }
+    let(:request) { instance_double(HttpStub::Configurer::Request::Http::Multipart) }
 
-    subject { facade.activate(scenario_name) }
+    subject { facade.define_scenario(scenario) }
 
     before(:example) do
-      allow(HttpStub::Configurer::Request::Http::Factory).to receive(:post).and_return(request)
       allow(request_processor).to receive(:submit)
+      allow(HttpStub::Configurer::Request::Http::Factory).to receive(:multipart).and_return(request)
     end
 
-    it "creates an POST request to activate a scenario" do
-      expect(HttpStub::Configurer::Request::Http::Factory).to(
-        receive(:post).with("/http_stub/scenarios/activate", anything).and_return(request)
-      )
+    it "creates a multipart request to the scenarios endpoint" do
+      expect(HttpStub::Configurer::Request::Http::Factory).to receive(:multipart).with("scenarios", anything)
 
       subject
     end
 
-    it "creates a POST request with the scenario name as a parameter" do
-      expect(HttpStub::Configurer::Request::Http::Factory).to(
-        receive(:post).with(anything, hash_including(:name => scenario_name)).and_return(request)
-      )
+    it "creates a multipart request with the provided scenario" do
+      expect(HttpStub::Configurer::Request::Http::Factory).to receive(:multipart).with(anything, scenario)
 
       subject
     end
@@ -121,128 +103,89 @@ describe HttpStub::Configurer::Server::Facade do
       subject
     end
 
-    it "describes the activation request using the provided scenario name" do
-      expect(request_processor).to receive(:submit).with(hash_including(description: "activating '#{scenario_name}'"))
+    it "describes the scenario via its string representation" do
+      expect(request_processor).to(
+        receive(:submit).with(hash_including(description: "registering scenario '#{scenario_description}'"))
+      )
 
       subject
     end
 
   end
 
-  describe "#remember_stubs" do
+  describe "#clear_scenarios" do
 
     let(:request) { instance_double(HttpStub::Configurer::Request::Http::Basic) }
 
-    subject { facade.remember_stubs }
+    subject { facade.clear_scenarios }
 
     before(:example) do
-      allow(HttpStub::Configurer::Request::Http::Factory).to receive(:post).and_return(request)
+      allow(HttpStub::Configurer::Request::Http::Factory).to receive(:delete).and_return(request)
       allow(request_processor).to receive(:submit)
     end
 
-    it "creates a POST request for the /http_stub/stubs/memory endpoint" do
-      expect(HttpStub::Configurer::Request::Http::Factory).to(
-        receive(:post).with("/http_stub/stubs/memory").and_return(request)
-      )
+    it "creates a DELETE request for the scenarios endpoint" do
+      expect(HttpStub::Configurer::Request::Http::Factory).to receive(:delete).with("scenarios").and_return(request)
 
       subject
     end
 
-    it "submits the request via the request processor" do
+    it "submits the HTTP Stub request via the request processor" do
       expect(request_processor).to receive(:submit).with(hash_including(request: request))
 
       subject
     end
 
-    it "describes the request as committing the servers stubs to memory" do
-      expect(request_processor).to receive(:submit).with(hash_including(description: "committing stubs to memory"))
+    it "describes the request as clearing the servers scenarios" do
+      expect(request_processor).to receive(:submit).with(hash_including(description: "clearing scenarios"))
 
       subject
     end
 
   end
 
-  describe "#recall_stubs" do
-
-    let(:request) { instance_double(HttpStub::Configurer::Request::Http::Basic) }
-
-    subject { facade.recall_stubs }
-
-    before(:example) do
-      allow(HttpStub::Configurer::Request::Http::Factory).to receive(:get).and_return(request)
-      allow(request_processor).to receive(:submit)
-    end
+  describe "#create_session_facade" do
 
-    it "creates a GET request for the /http_stub/stubs/memory endpoint" do
-      expect(HttpStub::Configurer::Request::Http::Factory).to(
-        receive(:get).with("/http_stub/stubs/memory").and_return(request)
-      )
+    let(:session_id) { "some session id" }
 
-      subject
-    end
+    let(:session_facade) { instance_double(HttpStub::Configurer::Server::SessionFacade) }
 
-    it "submits the request via the request processor" do
-      expect(request_processor).to receive(:submit).with(hash_including(request: request))
+    subject { facade.create_session_facade(session_id) }
 
-      subject
-    end
+    before(:example) { allow(HttpStub::Configurer::Server::SessionFacade).to receive(:new).and_return(session_facade) }
 
-    it "describes the request as recalling the servers stubs in memory" do
-      expect(request_processor).to receive(:submit).with(hash_including(description: "recalling stubs in memory"))
+    it "creates a session facade for the provided session" do
+      expect(HttpStub::Configurer::Server::SessionFacade).to receive(:new).with(session_id, anything)
 
       subject
-    end
-
-  end
-
-  describe "#clear_stubs" do
 
-    let(:request) { instance_double(HttpStub::Configurer::Request::Http::Basic) }
-
-    subject { 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 for the /http_stub/stubs endpoint" do
-      expect(HttpStub::Configurer::Request::Http::Factory).to(
-        receive(:delete).with("/http_stub/stubs").and_return(request)
-      )
+    it "creates a session facade that processes requests the server facades request processor" do
+      expect(HttpStub::Configurer::Server::SessionFacade).to receive(:new).with(anything, request_processor)
 
       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: "clearing stubs"))
-
-      subject
+    it "returns the created session facade" do
+      expect(subject).to eql(session_facade)
     end
 
   end
 
-  describe "#clear_scenarios" do
+  describe "#clear_sessions" do
 
     let(:request) { instance_double(HttpStub::Configurer::Request::Http::Basic) }
 
-    subject { facade.clear_scenarios }
+    subject { facade.clear_sessions }
 
     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 for the /http_stub/scenarios endpoint" do
-      expect(HttpStub::Configurer::Request::Http::Factory).to(
-        receive(:delete).with("/http_stub/scenarios").and_return(request)
-      )
+    it "creates a DELETE request for the sessions endpoint" do
+      expect(HttpStub::Configurer::Request::Http::Factory).to receive(:delete).with("sessions").and_return(request)
 
       subject
     end
@@ -253,32 +196,12 @@ describe HttpStub::Configurer::Server::Facade do
       subject
     end
 
-    it "describes the request as clearing the server scenarios" do
-      expect(request_processor).to receive(:submit).with(hash_including(description: "clearing scenarios"))
+    it "describes the request as clearing the servers sessions" do
+      expect(request_processor).to receive(:submit).with(hash_including(description: "clearing sessions"))
 
       subject
     end
 
   end
 
-  describe "#server_has_started" do
-
-    it "informs the request processor to disable buffering requests" do
-      expect(request_processor).to receive(:disable_buffering!)
-
-      facade.server_has_started
-    end
-
-  end
-
-  describe "#flush_requests" do
-
-    it "informs the request processor to flush it's requests" do
-      expect(request_processor).to receive(:flush!)
-
-      facade.flush_requests
-    end
-
-  end
-
 end