http_stub 0.25.1 → 0.26.0

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

@@ -0,0 +1,59 @@
+describe HttpStub::Server::Application::Configuration do
+
+  let(:configuration) { described_class.new(args) }
+
+  describe "#settings" do
+
+    subject { configuration.settings }
+
+    context "when a configurer is provided" do
+
+      let(:port)                      { 8888 }
+      let(:session_identifier)        { { parameters: :some_session_parameter } }
+      let(:cross_origin_support_flag) { true }
+      let(:stub_server)               do
+        instance_double(HttpStub::Configurer::DSL::Server, port: port, session_identifier: session_identifier)
+      end
+      let(:configurer)         { double(HttpStub::Configurer, stub_server: stub_server) }
+      let(:args)               { { configurer: configurer } }
+
+      before(:example) do
+        allow(stub_server).to receive(:enabled?).with(:cross_origin_support).and_return(cross_origin_support_flag)
+      end
+
+      it "has the configurers port" do
+        expect(subject).to include(port: port)
+      end
+
+      it "has the configurers session identifier" do
+        expect(subject).to include(session_identifier: session_identifier)
+      end
+
+      it "has the configurers cross origin support flag" do
+        expect(subject).to include(cross_origin_support: cross_origin_support_flag)
+      end
+
+    end
+
+    context "when a configurer is not provided" do
+
+      let(:port) { 8889 }
+      let(:args) { { port: port } }
+
+      it "has the provided port" do
+        expect(subject).to include(port: port)
+      end
+
+      it "has a nil session identifier" do
+        expect(subject).to include(session_identifier: nil)
+      end
+
+      it "has disabled cross origin support" do
+        expect(subject).to include(cross_origin_support: false)
+      end
+
+    end
+
+  end
+
+end

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

@@ -1,33 +1,36 @@
 describe HttpStub::Server::Application::CrossOriginSupport do
   include Rack::Test::Methods
 
-  let(:application_header_names) { (1..3).map { |i| "APPLICATION_HEADER_#{i}" } }
-  let(:application_headers)      do
-    application_header_names.each_with_object({}) { |name, result| result["HTTP_#{name}"] = "#{name} value" }
-  end
+  let(:response) { last_response }
 
-  let(:access_control_request_method)       { "PATCH" }
-  let(:access_control_request_header_names) { (1..3).map { |i| "ACCESS_CONTROL_HEADER_#{i}" } }
-  let(:access_control_request_headers)      do
-    {
-      "ACCESS_CONTROL_REQUEST_METHOD"  => access_control_request_method,
-      "ACCESS_CONTROL_REQUEST_HEADERS" => access_control_request_header_names.join(",")
-    }
-  end
+  describe "when registered in an application" do
 
-  let(:response) { last_response }
+    class HttpStub::Server::Application::CrossOriginSupportTestApplication < Sinatra::Base
+
+      def http_stub_request
+        HttpStub::Server::RequestFixture.create(request)
+      end
 
-  let(:app_class) { Class.new(Sinatra::Base) }
+    end
 
-  let(:app) { app_class.new! }
+    let(:application_header_names) { (1..3).map { |i| "APPLICATION_HEADER_#{i}" } }
+    let(:application_headers)      do
+      application_header_names.each_with_object({}) { |name, result| result["HTTP_#{name}"] = "#{name} value" }
+    end
 
-  before(:example) do
-    app_class.before { @http_stub_request = HttpStub::Server::Request.create(request) }
-  end
+    let(:access_control_request_method)       { "PATCH" }
+    let(:access_control_request_header_names) { (1..3).map { |i| "ACCESS_CONTROL_HEADER_#{i}" } }
+    let(:access_control_request_headers)      do
+      {
+        "ACCESS_CONTROL_REQUEST_METHOD"  => access_control_request_method,
+        "ACCESS_CONTROL_REQUEST_HEADERS" => access_control_request_header_names.join(",")
+      }
+    end
 
-  describe "when registered in an application" do
+    let(:app_class) { HttpStub::Server::Application::CrossOriginSupportTestApplication }
+    let(:app)       { app_class.new! }
 
-    before(:example) { app_class.register described_class }
+    before(:example) { app_class.register(described_class) }
 
     shared_examples_for "a request whose response contains access control headers" do
 

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

@@ -0,0 +1,93 @@
+describe HttpStub::Server::Application::RequestSupport, "when integrated into a complete Rack application" do
+
+  context "when included in an application" do
+    include_context "rack application test"
+
+    class HttpStub::Server::Application::RequestSupport::IntegrationTestApplication < Sinatra::Base
+
+      def initialize
+        @session_configuration = HttpStub::Server::Session::Configuration.new(nil)
+        @server_memory         = HttpStub::Server::Memory::Memory.new(@session_configuration)
+        super()
+      end
+
+      include HttpStub::Server::Application::RequestSupport
+
+      get "/accesses_uri" do
+        halt 200, "Request path: #{http_stub_request.uri}"
+      end
+
+      post "/with_body_and_establishes_request_multiple_times" do
+        establish_http_stub_request
+        halt 200, "Request body: #{http_stub_request.body}"
+      end
+
+      post "/without_body" do
+        establish_http_stub_request
+        halt 200
+      end
+
+      any_request_method "/any_request_method_test" do
+        halt 200
+      end
+
+      def logger
+        HttpServerManager::Test::SilentLogger
+      end
+
+    end
+
+    let(:app_class) { HttpStub::Server::Application::RequestSupport::IntegrationTestApplication }
+    let(:app)       { app_class.new! }
+
+    describe "#http_stub_request" do
+
+      context "when an action accesses the request" do
+
+        it "retrieves the request attributes successfully" do
+          get "/accesses_uri"
+
+          expect(response.body).to end_with("accesses_uri")
+        end
+
+        context "and the action is a POST with a body that establishes the request multiple times" do
+
+          it "retains any request body provided" do
+            post "/with_body_and_establishes_request_multiple_times", "some body"
+
+            expect(response.body).to end_with("some body")
+          end
+
+        end
+
+        context "and the action is a POST without a body" do
+
+          it "executes without error" do
+            post "/without_body"
+
+            expect(response.status).to eql(200)
+          end
+
+        end
+
+      end
+
+    end
+
+    describe "#any_request_method" do
+
+      [ :get, :post, :put, :patch, :delete, :options ].each do |request_method|
+
+        it "handles #{request_method} requests for the provided endpoint" do
+          self.send(request_method, "/any_request_method_test")
+
+          expect(response.status).to eql(200)
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,61 @@
+describe HttpStub::Server::Application::RequestSupport do
+
+  context "when included in an application" do
+    include_context "rack application test"
+
+    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
+        super()
+      end
+
+      get "/request_support_test" do
+        halt 200
+      end
+
+    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(:app_class) { HttpStub::Server::Application::RequestSupport::TestApplication }
+    let(:app)       { app_class.new!(session_configuration, server_memory) }
+
+    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)
+
+        subject
+      end
+
+      it "creates a factory for creating http_stub requests based on the servers memory" do
+        expect(HttpStub::Server::Request::Factory).to receive(:new).with(anything, server_memory)
+
+        subject
+      end
+
+    end
+
+    describe "when servicing a request" 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)
+        expect(request_factory).to receive(:create).with(a_kind_of(Rack::Request), anything, anything)
+
+        subject
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,30 @@
+describe HttpStub::Server::Application::ResponseSupport do
+
+  context "when included in an application" do
+    include_context "rack application test"
+
+    class HttpStub::Server::Application::ResponseSupportTestApplication < Sinatra::Base
+
+      include HttpStub::Server::Application::ResponseSupport
+
+      get "/response_support_test" do
+        halt 200
+      end
+
+    end
+
+    let(:app_class) { HttpStub::Server::Application::ResponseSupportTestApplication }
+
+    it "creates a response pipeline for the application when handling a request" do
+      expect(HttpStub::Server::Application::ResponsePipeline).to receive(:new).with(an_instance_of(app_class))
+
+      issue_a_request
+    end
+
+    def issue_a_request
+      get "/response_support_test"
+    end
+
+  end
+
+end

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

@@ -0,0 +1,41 @@
+describe HttpStub::Server::Application::Routes::Memory do
+  include_context "http_stub rack application test"
+
+  let(:memory_controller) { instance_double(HttpStub::Server::Memory::Controller) }
+
+  before(:example) { allow(HttpStub::Server::Memory::Controller).to receive(:new).and_return(memory_controller) }
+
+  context "when a request to show the servers memory is received" 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 }
+      expect(memory_controller).to receive(:find_stubs).and_return(memorized_stubs)
+
+      subject
+    end
+
+  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/resource_spec.rb

@@ -0,0 +1,16 @@
+describe HttpStub::Server::Application::Routes::Resource do
+  include_context "http_stub rack application test"
+
+  context "when a request for the administration pages stylesheet has been received" do
+
+    subject { get "/application.css" }
+
+    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

@@ -0,0 +1,117 @@
+describe HttpStub::Server::Application::Routes::Scenario do
+  include_context "http_stub rack application test"
+
+  let(:scenario_controller) { instance_double(HttpStub::Server::Scenario::Controller) }
+
+  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" }
+    let(:found_scenario) { HttpStub::Server::ScenarioFixture.create }
+
+    subject { get "/http_stub/scenarios" }
+
+    before(:example) { allow(request).to receive(:parameters).and_return(name: scenario_name) }
+
+    it "retrieves the scenario via the scenario controller" do
+      expect(scenario_controller).to receive(:find).with(request, anything).and_return(found_scenario)
+
+      subject
+    end
+
+  end
+
+  context "when a request to list the scenarios is received" do
+
+    let(:found_scenarios) { [ HttpStub::Server::ScenarioFixture.create ] }
+
+    subject { get "/http_stub/scenarios" }
+
+    it "retrieves the scenarios via the scenario controller" do
+      expect(scenario_controller).to receive(:find_all).and_return(found_scenarios)
+
+      subject
+    end
+
+  end
+
+  context "when a request to active scenarios is received" do
+
+    let(:scenario_names)      { (1..3).map { |i| "scenario name #{i}" } }
+    let(:activation_response) { instance_double(HttpStub::Server::Stub::Response::Base) }
+
+    subject { post "/http_stub/scenarios/activate" }
+
+    before(:example) do
+      allow(request).to receive(:parameters).and_return(names: scenario_names)
+      allow(scenario_controller).to receive(:activate).and_return(activation_response)
+    end
+
+    it "activates the scenario via the scenario controller" do
+      expect(scenario_controller).to receive(:activate).with(request, anything).and_return(activation_response)
+
+      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)
+
+      subject
+    end
+
+    it "responds with a 200 status code" do
+      subject
+
+      expect(response.status).to eql(200)
+    end
+
+  end
+
+end