http_stub 0.27.0 → 0.28.0.beta1

data/spec/lib/http_stub/server/application/routes/session_integration_spec.rb

@@ -1,4 +1,4 @@
-describe HttpStub::Server::Application::Routes::Session, "when an initialized server is running" do
+describe HttpStub::Server::Application::Routes::Session, "when a server is running" do
   include_context "server integration"
 
   let(:response_document) { Nokogiri::HTML(response.body) }

data/spec/lib/http_stub/server/application/routes/status_spec.rb

@@ -1,28 +1,14 @@
 describe HttpStub::Server::Application::Routes::Status do
   include_context "http_stub rack application test"
 
-  let(:status_controller) { instance_double(HttpStub::Server::Status::Controller) }
-
-  before(:example) { allow(HttpStub::Server::Status::Controller).to receive(:new).and_return(status_controller) }
-
   context "when a request to show the servers current status is received" do
 
-    let(:current_status) { "Some status" }
-
     subject { get "/http_stub/status" }
 
-    before(:example) { allow(status_controller).to receive(:current).and_return(current_status) }
-
-    it "retrieves the servers current status via the status controller" do
-      expect(status_controller).to receive(:current).and_return("some status")
-
+    it "responds with a body indicating the server is running" do
       subject
-    end
 
-    it "responds with a body containing the servers current status" do
-      subject
-
-      expect(response.body).to eql(current_status)
+      expect(response.body).to eql("OK")
     end
 
     it "responds with a 200 status code" do
@@ -33,24 +19,4 @@ describe HttpStub::Server::Application::Routes::Status do
 
   end
 
-  context "when a request to mark the server as initialized is received" do
-
-    subject { post "/http_stub/status/initialized" }
-
-    before(:example) { allow(status_controller).to receive(:initialized) }
-
-    it "marks the server as initialized via the status controller" do
-      expect(status_controller).to receive(:initialized)
-
-      subject
-    end
-
-    it "responds without error" do
-      subject
-
-      expect(response.status).to eql(200)
-    end
-
-  end
-
 end

data/spec/lib/http_stub/server/application/routes/stub_integration_spec.rb

@@ -1,44 +1,13 @@
-describe HttpStub::Server::Application::Routes::Stub, "when an initialized server is running" do
+describe HttpStub::Server::Application::Routes::Stub, "when a server is running" do
   include_context "server integration"
 
   let(:response_document) { Nokogiri::HTML(response.body) }
 
   before(:example) { initialize_server }
 
-  describe "POST /http_stub/stubs" do
+  describe "and a configurator with multiple scenarios is initialized" do
 
-    context "when provided with the minimum data required" do
-
-      let(:response) do
-        HTTParty.post(
-          "#{server_uri}/http_stub/stubs",
-          body: { uri: "/some/path", method: "get", response: { status: 200, body: "Some body" } }.to_json
-        )
-      end
-
-      after(:example) { reset_session }
-
-      it "returns a 200 response code" do
-        expect(response.code).to eql(200)
-      end
-
-      it "registers a stub returning the provided response for a matching request" do
-        response
-
-        stubbed_response = HTTParty.get("#{server_uri}/some/path")
-
-        expect(stubbed_response.code).to eql(200)
-        expect(stubbed_response.body).to eql("Some body")
-      end
-
-    end
-
-  end
-
-  describe "and a configurer with multiple scenarios is initialized" do
-    include_context "configurer integration"
-
-    let(:configurer_specification) { { class: HttpStub::Examples::ConfigurerWithExhaustiveScenarios } }
+    let(:configurator) { HttpStub::Examples::ConfiguratorWithExhaustiveScenarios }
 
     describe "GET /http_stub/stubs" do
 

data/spec/lib/http_stub/server/application/routes/stub_spec.rb

@@ -9,34 +9,6 @@ describe HttpStub::Server::Application::Routes::Stub do
     allow(HttpStub::Server::Stub::Match::Controller).to receive(:new).and_return(stub_match_controller)
   end
 
-  describe "when a stub registration request within a session is received" do
-    include_context "request includes a session identifier"
-
-    let(:payload) { { uri: "/a_path", method: "a method", response: { status: 200, body: "Foo" } }.to_json }
-
-    let(:registration_response) { instance_double(HttpStub::Server::Stub::Response::Base) }
-
-    subject { post "/http_stub/stubs" }
-
-    before(:example) do
-      allow(request).to receive(:body).and_return(payload)
-      allow(stub_controller).to receive(:register).and_return(registration_response)
-    end
-
-    it "registers the stub via the stub controller" do
-      expect(stub_controller).to receive(:register).and_return(registration_response)
-
-      subject
-    end
-
-    it "processes the stub controllers response via the response pipeline" do
-      expect(response_pipeline).to receive(:process).with(registration_response)
-
-      subject
-    end
-
-  end
-
   describe "when a request to list the stubs in a session is received" do
     include_context "request includes a session identifier"
 
@@ -98,27 +70,6 @@ describe HttpStub::Server::Application::Routes::Stub do
 
   end
 
-  describe "when a request to clear the stubs in a session is received" do
-    include_context "request includes a session identifier"
-
-    subject { delete "/http_stub/stubs" }
-
-    before(:example) { allow(stub_controller).to receive(:clear) }
-
-    it "clears the stubs for the current user via the stub controller" do
-      expect(stub_controller).to receive(:clear).with(request, anything)
-
-      subject
-    end
-
-    it "responds with a 200 status code" do
-      subject
-
-      expect(response.status).to eql(200)
-    end
-
-  end
-
   describe "when a request to list the stub matches in a session is received" do
     include_context "request includes a session identifier"
 
@@ -139,7 +90,7 @@ describe HttpStub::Server::Application::Routes::Stub do
 
     let(:uri)                 { "/some/matched/uri" }
     let(:method)              { "some http method" }
-    let(:last_match_response) { instance_double(HttpStub::Server::Stub::Response::Base) }
+    let(:last_match_response) { HttpStub::Server::Stub::ResponseFixture.create }
 
     subject { get "/http_stub/stubs/matches/last" }
 
@@ -154,8 +105,8 @@ describe HttpStub::Server::Application::Routes::Stub do
       subject
     end
 
-    it "processes the match result controllers response via the response pipeline" do
-      expect(response_pipeline).to receive(:process).with(last_match_response)
+    it "serves the match result controllers response" do
+      expect(last_match_response).to receive(:serve_on).with(an_instance_of(app_class))
 
       subject
     end
@@ -179,7 +130,7 @@ describe HttpStub::Server::Application::Routes::Stub do
 
   describe "when any other request is received" do
 
-    let(:stub_response) { instance_double(HttpStub::Server::Stub::Response::Base) }
+    let(:stub_response) { HttpStub::Server::Stub::ResponseFixture.create }
 
     subject { get "/some_path" }
 
@@ -191,8 +142,8 @@ describe HttpStub::Server::Application::Routes::Stub do
       subject
     end
 
-    it "processes the response via the response pipeline" do
-      expect(response_pipeline).to receive(:process).with(stub_response)
+    it "serves the response" do
+      expect(stub_response).to receive(:serve_on).with(an_instance_of(app_class))
 
       subject
     end

data/spec/lib/http_stub/server/daemon_integration_spec.rb

@@ -1,6 +1,10 @@
 describe HttpStub::Server::Daemon do
 
-  let(:server) { HttpStub::Server::Daemon.new(name: :example_server_daemon, port: 8002) }
+  let(:server_name_in_rakefile) { :example_server_daemon }
+  let(:port_in_rakefile)        { 8001 }
+
+  let(:configurator) { HttpStub::ConfiguratorFixture.create(port: port_in_rakefile) }
+  let(:server)       { HttpStub::Server::Daemon.new(name: server_name_in_rakefile, configurator: configurator) }
 
   it_behaves_like "a managed http server"
 

data/spec/lib/http_stub/server/daemon_spec.rb

@@ -1,11 +1,5 @@
 describe HttpStub::Server::Daemon do
 
-  let(:server_port) { 8888 }
-
-  let(:server_daemon) { create_daemon_without_configurer }
-
-  before(:example) { allow(server_daemon.logger).to receive(:info) }
-
   describe "::log_dir" do
 
     before(:example) { @original_log_dir = HttpServerManager.log_dir }
@@ -36,84 +30,21 @@ describe HttpStub::Server::Daemon do
 
   describe "constructor" do
 
-    context "when a configurer is provided" do
-
-      let(:server_host) { "some_host" }
-      let(:stub_server) { instance_double(HttpStub::Configurer::DSL::Server, host: server_host, port: server_port) }
-      let(:configurer)  { double(HttpStub::Configurer, stub_server: stub_server) }
-
-      let(:server_daemon) { create_daemon_with_configurer }
-
-      it "establishes the daemons host as the configurers server host" do
-        expect(server_daemon.host).to eql(server_host)
-      end
-
-      it "establishes the daemons port as the configurers server port" do
-        expect(server_daemon.port).to eql(server_port)
-      end
-
-    end
-
-    context "when a configurer is not provided" do
-
-      let(:server_daemon) { create_daemon_without_configurer }
-
-      it "defaults the daemons host to 'localhost'" do
-        expect(server_daemon.host).to eql("localhost")
-      end
-
-      it "establishes the daemons port as the provided value" do
-        expect(server_daemon.port).to eql(server_port)
-      end
-
-    end
-
-  end
-
-  describe "#start!" do
-
-    before(:example) { allow(server_daemon).to receive(:running?).and_return(true) }
-
-    context "when a configurer is provided" do
-
-      let(:configurer) { double(HttpStub::Configurer).as_null_object }
-
-      let(:server_daemon) { create_daemon_with_configurer }
-
-      it "initializes the configurer" do
-        expect(configurer).to receive(:initialize!)
-
-        server_daemon.start!
-      end
+    let(:server_port)  { 8888 }
+    let(:configurator) { Class.new { include HttpStub::Configurator } }
 
-      it "logs that the server with the provided name has been initialized" do
-        expect(server_daemon.logger).to receive(:info).with("sample_server_daemon initialized")
+    let(:server_daemon) { HttpStub::Server::Daemon.new(name: :sample_server_daemon, configurator: configurator) }
 
-        server_daemon.start!
-      end
+    before(:example) { configurator.state.port = server_port }
 
+    it "establishes the daemons host as localhost by default" do
+      expect(server_daemon.host).to eql("localhost")
     end
 
-    context "when no configurer is provided" do
-
-      let(:server_daemon) { create_daemon_without_configurer }
-
-      it "does not log that the server has been initialized" do
-        expect(server_daemon.logger).not_to receive(:info).with("sample_server_daemon initialized")
-
-        server_daemon.start!
-      end
-
+    it "establishes the daemons port as the configured port" do
+      expect(server_daemon.port).to eql(server_port)
     end
 
   end
 
-  def create_daemon_with_configurer
-    HttpStub::Server::Daemon.new(name: :sample_server_daemon, configurer: configurer)
-  end
-
-  def create_daemon_without_configurer
-    HttpStub::Server::Daemon.new(name: :sample_server_daemon, port: server_port)
-  end
-
 end

data/spec/lib/http_stub/server/memory/controller_spec.rb

@@ -1,9 +1,8 @@
 describe HttpStub::Server::Memory::Controller do
 
-  let(:session_configuration) { instance_double(HttpStub::Server::Session::Configuration) }
-  let(:server_memory)         { instance_double(HttpStub::Server::Memory::Memory) }
+  let(:server_memory) { instance_double(HttpStub::Server::Memory::Memory) }
 
-  let(:controller) { described_class.new(session_configuration, server_memory) }
+  let(:controller) { described_class.new(server_memory) }
 
   describe "#find_stubs" do
 
@@ -19,29 +18,4 @@ describe HttpStub::Server::Memory::Controller do
 
   end
 
-  describe "#reset" do
-
-    let(:logger) { instance_double(Logger) }
-
-    subject { controller.reset(logger) }
-
-    before(:example) do
-      allow(session_configuration).to receive(:reset)
-      allow(server_memory).to receive(:reset)
-    end
-
-    it "resets the servers session configuration" do
-      expect(session_configuration).to receive(:reset)
-
-      subject
-    end
-
-    it "resets the servers memory providing the logger" do
-      expect(server_memory).to receive(:reset).with(logger)
-
-      subject
-    end
-
-  end
-
 end

data/spec/lib/http_stub/server/memory/initial_state_spec.rb

@@ -0,0 +1,57 @@
+describe HttpStub::Server::Memory::InitialState do
+
+  let(:scenario_hashes)    { (1..3).map { HttpStub::Configurator::ScenarioFixture.create_hash } }
+  let(:stub_hashes)        { (1..3).map { HttpStub::Configurator::StubFixture.create_hash } }
+  let(:configurator_state) do
+    instance_double(HttpStub::Configurator::State, scenario_hashes: scenario_hashes, stub_hashes: stub_hashes)
+  end
+
+  let(:initial_state) { described_class.new(configurator_state) }
+
+  describe "#load_scenarios" do
+
+    subject { initial_state.load_scenarios }
+
+    it "returns the provided scenarios" do
+      expected_scenario_names = scenario_hashes.map { |hash| hash[:name] }.reverse
+
+      expect(subject.map(&:name)).to contain_exactly(*expected_scenario_names)
+    end
+
+  end
+
+  describe "#load_stubs" do
+
+    let(:scenario_registry) { HttpStub::Server::Scenario::Registry.new(scenarios) }
+
+    subject { initial_state.load_stubs(scenario_registry) }
+
+    context "when scenarios have been activated" do
+
+      let(:scenarios) { (1..3).map { |i| HttpStub::Server::ScenarioFixture.with_stubs(activated: i % 2 > 0) } }
+
+      it "contains the provided stubs and those activated by each activated scenario" do
+        activated_stubs = [ scenarios.first, scenarios.last ].map(&:stubs).flatten
+
+        expect_stub_ids_to_contain_exactly(stub_hashes.map { |hash| hash[:id] } + activated_stubs.map(&:stub_id))
+      end
+
+    end
+
+    context "when no scenarios have been activated" do
+
+      let(:scenarios) { (1..3).map { HttpStub::Server::ScenarioFixture.create(activated: false) } }
+
+      it "returns the provided stubs" do
+        expect_stub_ids_to_contain_exactly(stub_hashes.map { |hash| hash[:id] })
+      end
+
+    end
+
+    def expect_stub_ids_to_contain_exactly(expected_ids)
+      expect(subject.map(&:stub_id)).to contain_exactly(*expected_ids)
+    end
+
+  end
+
+end

data/spec/lib/http_stub/server/memory/memory_spec.rb

@@ -1,152 +1,64 @@
 describe HttpStub::Server::Memory::Memory do
 
-  let(:session_configuration) { instance_double(HttpStub::Server::Session::Configuration) }
+  let(:loaded_scenarios) { HttpStub::Server::ScenarioFixture.many }
+  let(:loaded_stubs)     { HttpStub::Server::StubFixture.many }
 
-  let(:memory_session)    { instance_double(HttpStub::Server::Session::Session) }
-  let(:scenario_registry) { instance_double(HttpStub::Server::Registry) }
-  let(:session_registry)  { instance_double(HttpStub::Server::Session::Registry) }
+  let(:configurator_state) { HttpStub::Configurator::State.new }
 
-  let(:memory) { described_class.new(session_configuration) }
-
-  before(:example) do
-    allow(HttpStub::Server::Session::Session).to receive(:new).and_return(memory_session)
-    allow(HttpStub::Server::Registry).to receive(:new).and_return(scenario_registry)
-    allow(HttpStub::Server::Session::Registry).to receive(:new).and_return(session_registry)
-  end
-
-  it "creates a simple scenario registry" do
-    expect(HttpStub::Server::Registry).to receive(:new).with("scenario")
-
-    memory
-  end
-
-  it "creates a memory session" do
-    expect(HttpStub::Server::Session::Session).to(
-      receive(:new).with(HttpStub::Server::Session::MEMORY_SESSION_ID, anything, anything)
-    )
-
-    memory
-  end
-
-  it "creates a memory session containing the scenario registry" do
-    expect(HttpStub::Server::Session::Session).to receive(:new).with(anything, scenario_registry, anything)
-
-    memory
+  let(:initial_state) do
+    instance_double(HttpStub::Server::Memory::InitialState, load_scenarios: loaded_scenarios, load_stubs: loaded_stubs)
   end
 
-  it "creates a memory session containing an empty memory session" do
-    expect(HttpStub::Server::Session::Session).to(
-      receive(:new).with(anything, anything, HttpStub::Server::Session::Empty)
-    )
-
-    memory
-  end
-
-  it "creates a session registry containing the session configuration" do
-    expect(HttpStub::Server::Session::Registry).to receive(:new).with(session_configuration, anything, anything)
-
-    memory
-  end
-
-  it "creates a session registry containing the scenario registry" do
-    expect(HttpStub::Server::Session::Registry).to receive(:new).with(anything, scenario_registry, anything)
-
-    memory
-  end
-
-  it "creates a session registry initalised with the memory session" do
-    expect(HttpStub::Server::Session::Registry).to receive(:new).with(anything, anything, memory_session)
-
-    memory
-  end
-
-  describe "#status" do
-
-    subject { memory.status }
+  let(:memory) { described_class.new(configurator_state) }
 
-    it "defaults to 'Started'" do
-      expect(subject).to eql("Started")
-    end
-
-    context "when the memory has been initialized" do
+  before(:example) { expect(HttpStub::Server::Memory::InitialState).to receive(:new).and_return(initial_state) }
 
-      before(:example) { memory.initialized! }
+  describe "#scenario_registry" do
 
-      it "reflects the memory is 'Initialized'" do
-        expect(subject).to eql("Initialized")
-      end
+    subject { memory.scenario_registry }
 
+    it "returns a scenario registry" do
+      expect(subject).to be_an_instance_of(HttpStub::Server::Scenario::Registry)
     end
 
-  end
-
-  describe "#scenarios" do
-
-    subject { memory.scenarios }
-
-    it "returns the servers scenario registry" do
-      expect(subject).to eql(scenario_registry)
-    end
-
-  end
-
-  describe "#sessions" do
-
-    subject { memory.sessions }
-
-    it "returns the servers session registry" do
-      expect(subject).to eql(session_registry)
+    it "contains the loaded scenarios" do
+      expect(subject.all.map(&:name)).to contain_exactly(*loaded_scenarios.map(&:name))
     end
 
   end
 
   describe "#stubs" do
 
-    let(:stubs) { (1..3).map { instance_double(HttpStub::Server::Stub::Stub) } }
-
     subject { memory.stubs }
 
-    before(:example) { allow(memory_session).to receive(:stubs).and_return(stubs) }
-
-    it "returns the stubs within the memory session" do
-      expect(subject).to eql(stubs)
+    it "contains the loaded stubs" do
+      expect(subject).to eql(loaded_stubs)
     end
 
   end
 
-  describe "#reset" do
+  describe "#session_registry" do
 
-    let(:logger) { instance_double(Logger) }
+    let(:logger) { HttpStub::Server::SilentLogger }
 
-    subject { memory.reset(logger) }
+    subject { memory.session_registry }
 
-    before(:example) do
-      allow(scenario_registry).to receive(:clear)
-      allow(session_registry).to receive(:clear)
+    it "returns a session registry" do
+      expect(subject).to be_an_instance_of(HttpStub::Server::Session::Registry)
     end
 
-    it "clears the servers scenarios" do
-      expect(scenario_registry).to receive(:clear).with(logger)
-
-      subject
+    it "contains the loaded scenarios" do
+      loaded_scenarios.each do |scenario|
+        expect { obtain_session.activate_scenario!(scenario.name, logger) }.to_not raise_error
+      end
     end
 
-    it "clears the servers sessions" do
-      expect(session_registry).to receive(:clear).with(logger)
-
-      subject
+    it "contains the loaded stubs" do
+      expect(obtain_session.stubs.map(&:stub_id)).to contain_exactly(*loaded_stubs.map(&:stub_id))
     end
 
-    context "when the memory had been initialized" do
-
-      before(:example) { memory.initialized! }
-
-      it "resets the servers status to the default value" do
-        subject
-
-        expect(memory.status).to eql("Started")
-      end
-
+    def obtain_session
+      subject.find_or_create("some id", logger)
     end
 
   end