http_stub 0.25.1 → 0.26.0

data/spec/lib/http_stub/extensions/core/uri_spec.rb

@@ -0,0 +1,75 @@
+describe HttpStub::Extensions::Core::URI do
+
+  it "patches ::URI" do
+    expect(::URI.included_modules).to include(described_class)
+  end
+
+  describe "::add_parameters" do
+
+    let(:original_parameters) { {} }
+    let(:arg_parameters)      { {} }
+    let(:uri)                 do
+      uri = URI.parse("https://some-host:8888/some/path")
+      uri.query = "#{URI.encode_www_form(original_parameters)}"
+      uri.to_s
+    end
+
+    subject { ::URI.add_parameters(uri, arg_parameters) }
+
+    it "preserves the uri's host, port and path" do
+      expect(subject).to start_with("https://some-host:8888/some/path")
+    end
+
+    context "when the uri has parameters" do
+
+      let(:original_parameters) { (1..3).each_with_object({}) { |i, hash| hash["parameter_#{i}"] = "value #{i}" } }
+
+      context "and parameters are to be replaced" do
+
+        let(:arg_parameters) { { "parameter_2" => "updated value 2", "parameter_3" => "updated value 3" } }
+
+        it "replaces the parameters" do
+          expect(effective_parameters).to include(arg_parameters)
+        end
+
+        it "retains other parameters" do
+          expect(effective_parameters).to include("parameter_1" => "value 1")
+        end
+
+      end
+
+      context "and other parameters are to be added" do
+
+        let(:arg_parameters) do
+           (1..3).each_with_object({}) { |i, hash| hash["another_parameter_#{i}"] = "another value #{i}" }
+        end
+
+        it "adds the parameter" do
+          expect(effective_parameters).to include(arg_parameters)
+        end
+
+        it "retains other parameters" do
+          expect(effective_parameters).to include(original_parameters)
+        end
+
+      end
+
+    end
+
+    context "when the uri does not have parameters" do
+
+      let(:arg_parameters) { (1..3).each_with_object({}) { |i, hash| hash["parameter_#{i}"] = "value #{i}" } }
+
+      it "adds the parameters" do
+        expect(effective_parameters).to include(arg_parameters)
+      end
+
+    end
+
+    def effective_parameters
+      URI.decode_www_form(URI.parse(subject).query).to_h
+    end
+
+  end
+
+end

data/spec/lib/http_stub/extensions/rack/handler_spec.rb

@@ -1,7 +1,7 @@
 describe HttpStub::Extensions::Rack::Handler do
 
   it "patches Rack::Handler" do
-    expect(::Rack::Handler.included_modules).to include(HttpStub::Extensions::Rack::Handler)
+    expect(::Rack::Handler.included_modules).to include(described_class)
   end
 
   context "when mixed in to a module" do

data/spec/lib/http_stub/extensions/sinatra/namespace_spec.rb

@@ -0,0 +1,36 @@
+describe "Sinatra::Namespace loading customisations" do
+  include Rake::DSL
+  include_context "rack application test"
+
+  class HttpStub::Extensions::SinatraNamespaceTestApplication < Sinatra::Base
+
+    register Sinatra::Namespace
+
+    namespace "/sinatra_namespace_extension" do
+
+      get do
+        halt 200
+      end
+
+    end
+
+  end
+
+  let(:app_class) { HttpStub::Extensions::SinatraNamespaceTestApplication }
+
+  it "preserves Rake's namespace" do
+    rake_namespace = namespace(:some_rake_namespace) {}
+    expect(rake_namespace).to be_an_instance_of(Rake::NameSpace)
+  end
+
+  it "scopes Sinatra's namespace to be available to those extending Sinatra::Namespace" do
+    issue_a_request
+
+    expect(response.status).to eql(200)
+  end
+
+  def issue_a_request
+    get "/sinatra_namespace_extension"
+  end
+
+end

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

@@ -2,6 +2,7 @@ describe HttpStub::Rake::ServerTasks do
   include Rake::DSL
 
   shared_context "verification of generated tasks" do
+    include_context "surpressed output"
 
     before(:example) { HttpStub::Rake::ServerTasks.new(task_args) }
 
@@ -12,7 +13,7 @@ describe HttpStub::Rake::ServerTasks do
       context "when invoked" do
 
         before(:example) do
-          Thread.new { task.invoke("--trace") }
+          Thread.new { task.invoke("--silent") }
           wait_until_server_has_started
         end
 
@@ -48,7 +49,7 @@ describe HttpStub::Rake::ServerTasks do
 
   context "when a configurer is provided" do
 
-    let(:port)       { 8004 }
+    let(:port)       { 8005 }
     let(:configurer) do
       Class.new.tap do |configurer|
         configurer.send(:include, HttpStub::Configurer)
@@ -64,7 +65,7 @@ describe HttpStub::Rake::ServerTasks do
 
   context "when a port is provided" do
 
-    let(:port)      { 8003 }
+    let(:port)      { 8006 }
     let(:task_args) { { name: :test_server_with_port, port: port } }
 
     include_context "verification of generated tasks"

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

@@ -9,25 +9,30 @@ describe HttpStub::Rake::ServerTasks do
 
   end
 
-  let(:server_name)  { "server_tasks_test_#{HttpStub::Rake::ServerTasksTestCounter.next}".to_sym }
-  let(:default_args) { { port: 8001, name: server_name } }
-  let(:args)         { {} }
-  let(:configurer)   { double(HttpStub::Configurer).as_null_object }
+  let(:server_name)     { "server_tasks_test_#{HttpStub::Rake::ServerTasksTestCounter.next}".to_sym }
+  let(:default_args)    { { port: 8001, 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(default_args.merge(args)) }
+  before(:example) { HttpStub::Rake::ServerTasks.new(args) }
 
   describe "the configure task" do
 
-    context "when a configurer is provided" do
+    let(:task) { Rake::Task["#{server_name}:configure"] }
 
-      let(:args) { { configurer: configurer } }
+    context "when executed" do
 
-      context "and the task is 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!)
 
-          Rake::Task["#{server_name}:configure"].execute
+          subject
         end
 
       end
@@ -37,7 +42,39 @@ describe HttpStub::Rake::ServerTasks do
     context "when a configurer is not provided" do
 
       it "does not generate a task" do
-        expect { Rake::Task["#{server_name}:configure"] }.to raise_error(/Don't know how to build task/)
+        expect { task }.to raise_error(/Don't know how to build task/)
+      end
+
+    end
+
+  end
+
+  describe "the start foreground task" do
+
+    let(:application) { HttpStub::Server::Application::Application }
+
+    let(:task) { Rake::Task["#{server_name}:start:foreground"] }
+
+    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
+
+        subject
       end
 
     end

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

@@ -1,353 +1,96 @@
 describe HttpStub::Server::Application::Application do
-  include Rack::Test::Methods
+  include_context "http_stub rack application test"
 
-  let(:response)      { last_response }
-  let(:response_body) { response.body.to_s }
+  describe "::configure" do
 
-  let(:scenario_registry)   { instance_double(HttpStub::Server::Registry) }
-  let(:stub_registry)       { instance_double(HttpStub::Server::Stub::Registry) }
-  let(:stub_match_registry) { instance_double(HttpStub::Server::Registry) }
-  let(:stub_miss_registry)  { instance_double(HttpStub::Server::Registry) }
-
-  let(:scenario_controller)   { instance_double(HttpStub::Server::Scenario::Controller) }
-  let(:stub_controller)       { instance_double(HttpStub::Server::Stub::Controller) }
-  let(:stub_match_controller) { instance_double(HttpStub::Server::Stub::Match::Controller) }
-
-  let(:response_pipeline) { instance_double(HttpStub::Server::Application::ResponsePipeline, process: nil) }
-
-  let(:app) { HttpStub::Server::Application::Application.new! }
-
-  before(:example) do
-    allow(HttpStub::Server::Registry).to receive(:new).with("scenario").and_return(scenario_registry)
-    allow(HttpStub::Server::Stub::Registry).to receive(:new).and_return(stub_registry)
-    allow(HttpStub::Server::Registry).to receive(:new).with("stub match").and_return(stub_match_registry)
-    allow(HttpStub::Server::Registry).to receive(:new).with("stub miss").and_return(stub_miss_registry)
-    allow(HttpStub::Server::Scenario::Controller).to receive(:new).and_return(scenario_controller)
-    allow(HttpStub::Server::Stub::Controller).to receive(:new).and_return(stub_controller)
-    allow(HttpStub::Server::Stub::Match::Controller).to receive(:new).and_return(stub_match_controller)
-    allow(HttpStub::Server::Application::ResponsePipeline).to receive(:new).and_return(response_pipeline)
-  end
-
-  context "when the diagnostics landing page is retrieved" do
-
-    subject { get "/http_stub" }
-
-    it "responds without error" do
-      subject
-
-      expect(response.status).to eql(200)
-    end
-
-  end
-
-  context "when a stub registration request is received" do
-
-    let(:registration_response) { instance_double(HttpStub::Server::Stub::Response::Base) }
-
-    subject do
-      post "/http_stub/stubs", { uri: "/a_path", method: "a method", response: { status: 200, body: "Foo" } }.to_json
-    end
-
-    before(:example) { allow(stub_controller).to receive(:register).and_return(registration_response) }
-
-    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
-
-  context "when a request to list the stubs is received" do
-
-    let(:found_stubs) { [ HttpStub::Server::Stub::Empty::INSTANCE ] }
-
-    subject { get "/http_stub/stubs" }
-
-    it "retrieves the stubs from the registry" do
-      expect(stub_registry).to receive(:all).and_return(found_stubs)
-
-      subject
-    end
-
-  end
-
-  context "when a request to show a stub is received" do
-
-    let(:stub_id)    { SecureRandom.uuid }
-    let(:found_stub) { HttpStub::Server::Stub::Empty::INSTANCE }
-
-    subject { get "/http_stub/stubs/#{stub_id}" }
-
-    it "retrieves the stub from the registry" do
-      expect(stub_registry).to receive(:find).with(stub_id, anything).and_return(found_stub)
-
-      subject
-    end
-
-  end
-
-  context "when a request to clear the stubs is received" do
-
-    subject { delete "/http_stub/stubs" }
-
-    before(:example) { allow(stub_controller).to receive(:clear) }
-
-    it "delegates clearing to the stub controller" do
-      expect(stub_controller).to receive(:clear)
-
-      subject
-    end
-
-    it "responds with a 200 status code" do
-      subject
-
-      expect(response.status).to eql(200)
-    end
-
-  end
-
-  context "when a request to commit the stubs to memory is received" do
-
-    subject { post "/http_stub/stubs/memory" }
-
-    before(:example) { allow(stub_registry).to receive(:remember) }
-
-    it "remembers the stubs in the stub registry" do
-      expect(stub_registry).to receive(:remember)
-
-      subject
-    end
-
-    it "responds with a 200 status code" do
-      subject
-
-      expect(response.status).to eql(200)
-    end
-
-  end
-
-  context "when a request to recall the stubs in memory is received" do
-
-    subject { get "/http_stub/stubs/memory" }
-
-    before(:example) { allow(stub_registry).to receive(:recall) }
-
-    it "recalls the stubs remembered by the stub registry" do
-      expect(stub_registry).to receive(:recall)
-
-      subject
-    end
-
-    it "responds with a 200 status code" do
-      subject
-
-      expect(response.status).to eql(200)
+    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
 
-  end
-
-  context "when a request to list the stub matches is received" do
-
-    let(:found_matches) { [ HttpStub::Server::Stub::Match::MatchFixture.create ] }
+    subject { described_class.configure(args) }
 
-    subject { get "/http_stub/stubs/matches" }
+    before(:example) { allow(HttpStub::Server::Application::Configuration).to receive(:new).and_return(configuration) }
 
-    it "retrieves the matches from the match registry" do
-      expect(stub_match_registry).to receive(:all).and_return(found_matches)
+    it "creates application configuration encapsulating the arguments" do
+      expect(HttpStub::Server::Application::Configuration).to receive(:new).with(args).and_return(configuration)
 
       subject
     end
 
-  end
-
-  context "when a request to retrieve the last match for an endpoint is received" do
-
-    let(:uri)                 { "/some/matched/uri" }
-    let(:method)              { "some http method" }
-    let(:last_match_response) { instance_double(HttpStub::Server::Stub::Response::Base) }
-
-    subject { get "/http_stub/stubs/matches/last", "uri" => uri, "method" => method }
-
-    before(:example) { allow(stub_match_controller).to receive(:find_last).and_return(last_match_response) }
-
-    it "retrieves the last match from the match result registry for the provided request" do
-      expect(stub_match_controller).to(
-        receive(:find_last).with(an_instance_of(HttpStub::Server::Request::Request), anything)
-      )
-
+    it "establishes the configured settings on the application" 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)
-
-      subject
+      configured_settings.each { |name, value| expect(described_class.settings.send(name)).to eql(value) }
     end
 
   end
 
-  context "when a request to list the stub misses is received" do
-
-    let(:found_misses) { [ HttpStub::Server::Stub::Match::MissFixture.create ] }
-
-    subject { get "/http_stub/stubs/misses" }
-
-    it "retrieves the misses from the miss registry" do
-      expect(stub_miss_registry).to receive(:all).and_return(found_misses)
-
-      subject
-    end
-
-  end
-
-  context "when a scenario registration request is received" do
-
-    let(:registration_response) { instance_double(HttpStub::Server::Stub::Response::Base) }
-
-    before(:example) { allow(scenario_controller).to receive(:register).and_return(registration_response) }
-
-    subject do
-      post "/http_stub/scenarios",
-           {
-             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
-
-    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::Scenario::ScenarioFixture.create }
-
-    subject { get "/http_stub/scenarios?#{URI.encode_www_form(:name => scenario_name)}" }
-
-    it "retrieves the scenario from the scenario registry" do
-      expect(scenario_registry).to receive(:find).with(scenario_name, anything).and_return(found_scenario)
-
-      subject
-    end
-
+  it "disables all standard HTTP security measures to allow stubs full control of responses" do
+    expect(app.settings.protection).to eql(false)
   end
 
-  context "when a request to list the scenarios is received" do
-
-    let(:found_scenarios) { [ HttpStub::Server::Scenario::ScenarioFixture.create ] }
-
-    subject { get "/http_stub/scenarios" }
-
-    it "retrieves the stubs from the registry" do
-      expect(scenario_registry).to receive(:all).and_return(found_scenarios)
-
-      subject
-    end
-
+  it "disables cross origin support by default" do
+    expect(app.settings.cross_origin_support).to eql(false)
   end
 
-  context "when a scenario activation request is received" do
+  describe "the session configuration" do
 
-    let(:scenario_name)       { "Some scenario name" }
-    let(:activation_response) { instance_double(HttpStub::Server::Stub::Response::Base) }
+    let(:session_configuration) { instance_double(HttpStub::Server::Session::Configuration).as_null_object }
 
-    subject { post "/http_stub/scenarios/activate", :name => scenario_name }
+    context "when a session identifier is set" do
 
-    before(:example) { allow(scenario_controller).to receive(:activate).and_return(activation_response) }
+      include_context "enabled session support"
 
-    it "activates the scenario via the scenario controller" do
-      expect(scenario_controller).to receive(:activate).with(scenario_name, anything).and_return(activation_response)
-
-      subject
-    end
+      it "is created on startup with the session identifier"  do
+        expect(HttpStub::Server::Session::Configuration).to receive(:new).with(session_identifier)
 
-    it "processes the scenario controllers response via the response pipeline" do
-      expect(response_pipeline).to receive(:process).with(activation_response)
+        app
+      end
 
-      subject
     end
 
-  end
-
-  context "when a request to clear the scenarios has been received" do
-
-    subject { delete "/http_stub/scenarios" }
+    context "when a session identifier is not configured" do
 
-    before(:example) { allow(scenario_controller).to receive(:clear) }
+      it "is created on startup with a nil session identifier"  do
+        expect(HttpStub::Server::Session::Configuration).to receive(:new).with(nil)
 
-    it "delegates clearing to the scenario controller" do
-      expect(scenario_controller).to receive(:clear)
+        app
+      end
 
-      subject
-    end
-
-    it "responds with a 200 status code" do
-      subject
-
-      expect(response.status).to eql(200)
     end
 
-  end
-
-  context "when a request for the diagnostic pages stylesheet has been received" do
-
-    subject { get "/application.css" }
-
-    it "responds without error" do
-      subject
+    it "is reused on all requests" do
+      expect(HttpStub::Server::Session::Configuration).to receive(:new).once
 
-      expect(response.status).to eql(200)
+      issue_a_request
+      issue_a_request
     end
 
   end
 
-  context "when another type of request is received" do
+  describe "the memory" do
 
-    let(:stub_response) { instance_double(HttpStub::Server::Stub::Response::Base) }
+    let(:server_memory) { instance_double(HttpStub::Server::Memory::Memory).as_null_object }
 
-    subject { get "/a_path" }
+    it "is created on startup" do
+      expect(HttpStub::Server::Memory::Memory).to receive(:new).and_return(server_memory)
 
-    before(:example) { allow(stub_controller).to receive(:match).and_return(stub_response) }
-
-    it "attempts to match the request to a stub response via the stub controller" do
-      expect(stub_controller).to receive(:match).with(an_instance_of(HttpStub::Server::Request::Request), anything)
-
-      subject
+      app
     end
 
-    it "processes the response via the response pipeline" do
-      expect(response_pipeline).to receive(:process).with(stub_response)
+    it "is reused on all requests" do
+      expect(HttpStub::Server::Memory::Memory).to receive(:new).once.and_return(server_memory)
 
-      subject
+      issue_a_request
+      issue_a_request
     end
 
   end
 
-  it "disables all standard HTTP security measures to allow stubs full control of responses" do
-    expect(app.settings.protection).to eql(false)
-  end
-
-  it "disables cross origin support by default" do
-    expect(app.settings.cross_origin_support).to eql(false)
+  def issue_a_request
+    get "/application.css"
   end
 
 end