http_stub 0.27.0 → 0.28.0.beta1

data/spec/lib/http_stub/rake/server_tasks_smoke_spec.rb

@@ -1,75 +1,47 @@
 describe HttpStub::Rake::ServerTasks do
+  include_context "surpressed output"
   include Rake::DSL
 
-  shared_context "verification of generated tasks" do
-    include_context "surpressed output"
+  let(:server_name)  { "test_server_#{SecureRandom.uuid}"}
+  let(:port)         { HttpStub::Port.free_port }
+  let(:configurator) { HttpStub::ConfiguratorFixture.create(port: port) }
 
-    before(:example) { HttpStub::Rake::ServerTasks.new(task_args) }
+  before(:example) { HttpStub::Rake::ServerTasks.new(name: server_name, configurator: configurator) }
 
-    describe "start:foreground task" do
+  describe "start:foreground task" do
 
-      let(:task) { Rake::Task["#{task_args[:name]}:start:foreground"] }
+    let(:task) { Rake::Task["#{server_name}:start:foreground"] }
 
-      context "when invoked" do
+    context "when invoked" do
 
-        before(:example) do
-          Thread.new { task.invoke("--silent") }
-          wait_until_server_has_started
-        end
-
-        after(:example) { wait_until_server_has_stopped }
+      before(:example) do
+        Thread.new { task.invoke("--silent") }
+        wait_until_server_has_started
+      end
 
-        it "starts a stub server that responds to stub requests" do
-          request = Net::HTTP::Post.new("/http_stub/stubs")
-          request.body = { "uri" => "/", "response" => { "status" => 302, "body" => "Some Body" } }.to_json
+      after(:example) { wait_until_server_has_stopped }
 
-          response = Net::HTTP.new("localhost", port).start { |http| http.request(request) }
+      it "starts a stub server that responds to stub requests" do
+        response = HTTParty.get("http://localhost:#{port}/http_stub/stubs")
 
-          expect(response.code).to eql("200")
-        end
+        expect(response.code).to eql(200)
+      end
 
-        def wait_until_server_has_started
-          ::Wait.until!(description: "http stub server #{task_args[:name]} started") do
-            HTTParty.get("http://localhost:#{port}")
-          end
+      def wait_until_server_has_started
+        ::Wait.until!(description: "http stub server #{server_name} started") do
+          HTTParty.get("http://localhost:#{port}")
         end
+      end
 
-        def wait_until_server_has_stopped
-          HttpStub::Server::Application::Application.stop!
-          ::Wait.until_true!(description: "http stub server #{task_args[:name]} stopped") do
-            HTTParty.get("http://localhost:#{port}", timeout: 1) && false rescue true
-          end
+      def wait_until_server_has_stopped
+        HttpStub::Server::Application::Application.stop!
+        ::Wait.until_true!(description: "http stub server #{server_name} stopped") do
+          HTTParty.get("http://localhost:#{port}", timeout: 1) && false rescue true
         end
-
       end
 
     end
 
   end
 
-  context "when a configurer is provided" do
-
-    let(:port)       { 8005 }
-    let(:configurer) do
-      Class.new.tap do |configurer|
-        configurer.send(:include, HttpStub::Configurer)
-        configurer.stub_server.host = "localhost"
-        configurer.stub_server.port = port
-      end
-    end
-    let(:task_args) { { name: :test_server_with_configurer, configurer: configurer } }
-
-    include_context "verification of generated tasks"
-
-  end
-
-  context "when a port is provided" do
-
-    let(:port)      { 8006 }
-    let(:task_args) { { name: :test_server_with_port, port: port } }
-
-    include_context "verification of generated tasks"
-
-  end
-
 end

data/spec/lib/http_stub/rake/server_tasks_spec.rb

@@ -1,78 +1,35 @@
 describe HttpStub::Rake::ServerTasks do
 
-  class HttpStub::Rake::ServerTasksTestCounter
-
-    def self.next
-      @counter ||= 0
-      @counter += 1
-    end
-
-  end
-
-  let(:server_name)     { "server_tasks_test_#{HttpStub::Rake::ServerTasksTestCounter.next}".to_sym }
-  let(:default_args)    { { port: 8001, name: server_name } }
+  let(:server_name)     { "server_tasks_test_#{SecureRandom.uuid}".to_sym }
+  let(:default_args)    { { name: server_name } }
   let(:additional_args) { {} }
   let(:args)            { default_args.merge(additional_args) }
-  let(:configurer)      { double(HttpStub::Configurer).as_null_object }
-
-  before(:example) { HttpStub::Rake::ServerTasks.new(args) }
-
-  describe "the configure task" do
-
-    let(:task) { Rake::Task["#{server_name}:configure"] }
-
-    context "when executed" do
-
-      subject { task.execute }
-
-      context "with a configurer" do
-
-        let(:additional_args) { { configurer: configurer } }
 
-        it "initializes the provided configurer" do
-          expect(configurer).to receive(:initialize!)
+  let(:server_tasks) { HttpStub::Rake::ServerTasks.new(args) }
 
-          subject
-        end
-
-      end
-
-    end
-
-    context "when a configurer is not provided" do
-
-      it "does not generate a task" do
-        expect { task }.to raise_error(/Don't know how to build task/)
-      end
+  context "when a configurator is not provided" do
 
+    it "raises an error on creation indicating a configurator is required" do
+      expect { server_tasks }.to raise_error(/configurator must be specified/)
     end
 
   end
 
   describe "the start foreground task" do
 
-    let(:application) { HttpStub::Server::Application::Application }
+    let(:configurator)    { HttpStub::ConfiguratorFixture.create }
+    let(:additional_args) { { configurator: configurator } }
 
     let(:task) { Rake::Task["#{server_name}:start:foreground"] }
 
+    before(:example) { server_tasks }
+
     context "when executed" do
 
       subject { task.execute }
 
-      before(:example) do
-        allow(HttpStub::Server::Application::Application).to receive(:configure)
-        allow(HttpStub::Server::Application::Application).to receive(:run!)
-      end
-
-      it "configures the application using the tasks arguments" do
-        expect(application).to receive(:configure).with(args)
-
-        subject
-      end
-
-      it "runs the configured application" do
-        expect(application).to receive(:configure).ordered
-        expect(application).to receive(:run!).ordered
+      it "starts a server with the provided configurator" do
+        expect(HttpStub::Server).to receive(:start).with(configurator)
 
         subject
       end

data/spec/lib/http_stub/server/application/application_spec.rb

@@ -3,21 +3,11 @@ describe HttpStub::Server::Application::Application do
 
   describe "::configure" do
 
-    let(:args)                { { some_argument_key: "some argument value" } }
     let(:configured_settings) { { setting_1: "value 1", setting_2: "value 2", setting_3: "value 3" } }
-    let(:configuration)       do
-      instance_double(HttpStub::Server::Application::Configuration, settings: configured_settings)
-    end
-
-    subject { described_class.configure(args) }
 
-    before(:example) { allow(HttpStub::Server::Application::Configuration).to receive(:new).and_return(configuration) }
+    before(:example) { allow(configurator.state).to receive(:application_settings).and_return(configured_settings) }
 
-    it "creates application configuration encapsulating the arguments" do
-      expect(HttpStub::Server::Application::Configuration).to receive(:new).with(args).and_return(configuration)
-
-      subject
-    end
+    subject { described_class.configure(configurator) }
 
     it "establishes the configured settings on the application" do
       subject
@@ -35,47 +25,12 @@ describe HttpStub::Server::Application::Application do
     expect(app.settings.cross_origin_support).to eql(false)
   end
 
-  describe "the session configuration" do
-
-    let(:session_configuration) { instance_double(HttpStub::Server::Session::Configuration).as_null_object }
-
-    context "when a session identifier is set" do
-
-      include_context "enabled session support"
-
-      it "is created on startup with the session identifier"  do
-        expect(HttpStub::Server::Session::Configuration).to receive(:new).with(session_identifier)
-
-        app
-      end
-
-    end
-
-    context "when a session identifier is not configured" do
-
-      it "is created on startup with a nil session identifier"  do
-        expect(HttpStub::Server::Session::Configuration).to receive(:new).with(nil)
-
-        app
-      end
-
-    end
-
-    it "is reused on all requests" do
-      expect(HttpStub::Server::Session::Configuration).to receive(:new).once
-
-      issue_a_request
-      issue_a_request
-    end
-
-  end
-
   describe "the memory" do
 
     let(:server_memory) { instance_double(HttpStub::Server::Memory::Memory).as_null_object }
 
-    it "is created on startup" do
-      expect(HttpStub::Server::Memory::Memory).to receive(:new).and_return(server_memory)
+    it "is created with the configured state" do
+      expect(HttpStub::Server::Memory::Memory).to receive(:new).with(configurator.state).and_return(server_memory)
 
       app
     end

data/spec/lib/http_stub/server/application/cross_origin_support_spec.rb

@@ -1,14 +1,12 @@
 describe HttpStub::Server::Application::CrossOriginSupport do
-  include Rack::Test::Methods
-
-  let(:response) { last_response }
+  include_context "rack application test"
 
   describe "when registered in an application" do
 
     class HttpStub::Server::Application::CrossOriginSupportTestApplication < Sinatra::Base
 
       def http_stub_request
-        HttpStub::Server::RequestFixture.create(request)
+        HttpStub::Server::RequestFixture.create(rack_request: request)
       end
 
     end
@@ -28,7 +26,6 @@ describe HttpStub::Server::Application::CrossOriginSupport do
     end
 
     let(:app_class) { HttpStub::Server::Application::CrossOriginSupportTestApplication }
-    let(:app)       { app_class.new! }
 
     before(:example) { app_class.register(described_class) }
 

data/spec/lib/http_stub/server/application/request_support_integration_spec.rb

@@ -5,9 +5,10 @@ describe HttpStub::Server::Application::RequestSupport, "when integrated into a
 
     class HttpStub::Server::Application::RequestSupport::IntegrationTestApplication < Sinatra::Base
 
+      set :session_identifier, nil
+
       def initialize
-        @session_configuration = HttpStub::Server::Session::Configuration.new(nil)
-        @server_memory         = HttpStub::Server::Memory::Memory.new(@session_configuration)
+        @server_memory = HttpStub::Server::MemoryFixture.create
         super()
       end
 
@@ -32,13 +33,12 @@ describe HttpStub::Server::Application::RequestSupport, "when integrated into a
       end
 
       def logger
-        HttpServerManager::Test::SilentLogger
+        HttpStub::Server::SilentLogger
       end
 
     end
 
     let(:app_class) { HttpStub::Server::Application::RequestSupport::IntegrationTestApplication }
-    let(:app)       { app_class.new! }
 
     describe "#http_stub_request" do
 

data/spec/lib/http_stub/server/application/request_support_spec.rb

@@ -6,9 +6,8 @@ describe HttpStub::Server::Application::RequestSupport do
     class HttpStub::Server::Application::RequestSupport::TestApplication < Sinatra::Base
       include HttpStub::Server::Application::RequestSupport
 
-      def initialize(session_configuration, server_memory)
-        @session_configuration = session_configuration
-        @server_memory         = server_memory
+      def initialize(server_memory)
+        @server_memory = server_memory
         super()
       end
 
@@ -18,19 +17,24 @@ describe HttpStub::Server::Application::RequestSupport do
 
     end
 
-    let(:session_configuration) { instance_double(HttpStub::Server::Session::Configuration) }
-    let(:server_memory)         { instance_double(HttpStub::Server::Memory::Memory) }
-    let(:request_factory)       { instance_double(HttpStub::Server::Request::Factory) }
+    let(:session_identifier)   { { header: :some_session_id  } }
+    let(:server_memory)        { instance_double(HttpStub::Server::Memory::Memory) }
+
+    let(:request_factory)      { instance_double(HttpStub::Server::Request::Factory) }
 
     let(:app_class) { HttpStub::Server::Application::RequestSupport::TestApplication }
-    let(:app)       { app_class.new!(session_configuration, server_memory) }
+    let(:app)       { app_class.new!(server_memory) }
+
+    before(:example) do
+      HttpStub::Server::Application::RequestSupport::TestApplication.set(:session_identifier, session_identifier)
+    end
 
     describe "constructor" do
 
       subject { app }
 
-      it "creates a factory for creating http_stub using the servers session configuration" do
-        expect(HttpStub::Server::Request::Factory).to receive(:new).with(session_configuration, anything)
+      it "creates a factory for creating http_stub requests using the configured session identifier" do
+        expect(HttpStub::Server::Request::Factory).to receive(:new).with(session_identifier, anything)
 
         subject
       end
@@ -47,8 +51,9 @@ describe HttpStub::Server::Application::RequestSupport do
 
       subject { get "/request_support_test" }
 
-      it "creates a http_stub request for rack requests issued" do
-        allow(HttpStub::Server::Request::Factory).to receive(:new).and_return(request_factory)
+      before(:example) { allow(HttpStub::Server::Request::Factory).to receive(:new).and_return(request_factory) }
+
+      it "creates a http_stub request for the issued rack request" do
         expect(request_factory).to receive(:create).with(a_kind_of(Rack::Request), anything, anything)
 
         subject

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

@@ -10,7 +10,7 @@ describe HttpStub::Server::Application::Routes::Memory do
     subject { get "/http_stub/memory" }
 
     it "retrieves the servers memorized stub via the memory controller" do
-      memorized_stubs = (1..3).map { HttpStub::Server::Stub::Empty::INSTANCE }
+      memorized_stubs = (1..3).map { HttpStub::Server::StubFixture.create }
       expect(memory_controller).to receive(:find_stubs).and_return(memorized_stubs)
 
       subject
@@ -18,24 +18,4 @@ describe HttpStub::Server::Application::Routes::Memory do
 
   end
 
-  context "when a request to reset the servers memory is received" do
-
-    subject { delete "/http_stub/memory" }
-
-    before(:example) { allow(memory_controller).to receive(:reset) }
-
-    it "resets the servers memory via the memory controller" do
-      expect(memory_controller).to receive(:reset)
-
-      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/scenario_spec.rb

@@ -5,38 +5,6 @@ describe HttpStub::Server::Application::Routes::Scenario do
 
   before(:example) { allow(HttpStub::Server::Scenario::Controller).to receive(:new).and_return(scenario_controller) }
 
-  context "when a scenario registration request is received" do
-
-    let(:payload) do
-      {
-        uri: "/a_scenario_path",
-        stubs: [ { uri: "/a_path", method: "a method", response: { status: 200, body: "Foo" } } ],
-        triggered_scenario_names: [ "some/uri/to/activate" ]
-      }.to_json
-    end
-    let(:registration_response) { instance_double(HttpStub::Server::Stub::Response::Base) }
-
-    before(:example) do
-      allow(request).to receive(:body).and_return(payload)
-      allow(scenario_controller).to receive(:register).and_return(registration_response)
-    end
-
-    subject { post "/http_stub/scenarios" }
-
-    it "registers the scenario via the scenario controller" do
-      expect(scenario_controller).to receive(:register).and_return(registration_response)
-
-      subject
-    end
-
-    it "processes the scenario controllers response via the response pipeline" do
-      expect(response_pipeline).to receive(:process).with(registration_response)
-
-      subject
-    end
-
-  end
-
   context "when a request to show a scenario is received" do
 
     let(:scenario_name)  { "Some scenario name" }
@@ -68,10 +36,10 @@ describe HttpStub::Server::Application::Routes::Scenario do
 
   end
 
-  context "when a request to active scenarios is received" do
+  context "when a request to activate a scenario is received" do
 
     let(:scenario_names)      { (1..3).map { |i| "scenario name #{i}" } }
-    let(:activation_response) { instance_double(HttpStub::Server::Stub::Response::Base) }
+    let(:activation_response) { HttpStub::Server::Stub::ResponseFixture.create }
 
     subject { post "/http_stub/scenarios/activate" }
 
@@ -86,32 +54,12 @@ describe HttpStub::Server::Application::Routes::Scenario do
       subject
     end
 
-    it "processes the scenario controllers response via the response pipeline" do
-      expect(response_pipeline).to receive(:process).with(activation_response)
-
-      subject
-    end
-
-  end
-
-  context "when a request to clear the scenarios has been received" do
-
-    subject { delete "/http_stub/scenarios" }
-
-    before(:example) { allow(scenario_controller).to receive(:clear) }
-
-    it "delegates clearing to the scenario controller" do
-      expect(scenario_controller).to receive(:clear).with(anything)
+    it "serves the scenario controllers response" do
+      expect(activation_response).to receive(:serve_on).with(an_instance_of(app_class))
 
       subject
     end
 
-    it "responds with a 200 status code" do
-      subject
-
-      expect(response.status).to eql(200)
-    end
-
   end
 
 end