http_stub 0.25.1 → 0.26.0

data/spec/spec_helper.rb

@@ -34,15 +34,23 @@ module HttpStub
 end
 
 require_relative 'support/include_in_json'
+require_relative 'support/contain_file'
+require_relative 'support/surpressed_output'
+require_relative 'support/rack/request_fixture'
+require_relative 'support/rack/rack_application_test'
 require_relative 'support/cross_origin_server/integration'
 require_relative 'support/cross_origin_server/index_page'
 require_relative 'support/http_stub/server/request_fixture'
-require_relative 'support/http_stub/server/scenario/scenario_fixture'
+require_relative 'support/http_stub/server/session_fixture'
+require_relative 'support/http_stub/server/scenario_fixture'
+require_relative 'support/http_stub/server/memory_fixture'
 require_relative 'support/http_stub/server/stub/match/match_fixture'
 require_relative 'support/http_stub/server/stub/match/miss_fixture'
 require_relative 'support/http_stub/stub_fixture'
 require_relative 'support/http_stub/scenario_fixture'
+require_relative 'support/http_stub/server/application/http_stub_rack_application_test'
 require_relative 'support/http_stub/empty_configurer'
+require_relative 'support/http_stub/server/driver'
 require_relative 'support/http_stub/server_integration'
 require_relative 'support/http_stub/configurer_integration'
 require_relative 'support/http_stub/stub_registrator'
@@ -50,3 +58,7 @@ require_relative 'support/html_helpers'
 require_relative 'support/http_stub/html_view_including_request_details'
 require_relative 'support/http_stub/html_view_excluding_request_details'
 require_relative 'support/browser_integration'
+
+RSpec.configure do |config|
+  config.after(:suite) { HttpStub::Server::Driver.all.each(&:stop) }
+end

data/spec/support/contain_file.rb

@@ -0,0 +1,23 @@
+RSpec::Matchers.define :contain_file do |expected_path|
+
+  match do |actual_response|
+    actual_file = Tempfile.new(File.basename(expected_path)).tap do |file|
+      file.write(actual_response.parsed_response)
+      file.flush
+    end
+    FileUtils.compare_file(expected_path, actual_file.path)
+  end
+
+  description do
+    "to contain contents of #{expected_path}"
+  end
+
+  failure_message do
+    "expected the response to contain the contents of #{expected_path}"
+  end
+
+  failure_message_when_negated do
+    "expected the response to not contain the contents of #{expected_path}"
+  end
+
+end

data/spec/support/cross_origin_server/application.rb

@@ -1,5 +1,5 @@
 require 'sinatra'
 
-set :port, 8005
+set :port, 8007
 
 set :root, File.dirname(__FILE__)

data/spec/support/cross_origin_server/index_page.rb

@@ -6,8 +6,8 @@ module CrossOriginServer
       @browser = browser
     end
 
-    def load_and_wait_until_available
-      @browser.navigate.to("http://localhost:8005/index.html")
+    def load_and_wait_until_available(stub_port)
+      @browser.navigate.to("http://localhost:8007/index.html?stubPort=#{stub_port}")
       ::Wait.until!(description: "cross origin test page has loaded") { @browser.find_element(id: "scenario_name") }
     end
 

data/spec/support/cross_origin_server/integration.rb

@@ -1,7 +1,8 @@
 shared_context "cross origin server integration" do
 
   before(:context) do
-    @cross_origin_server_pid = Process.spawn("ruby #{File.dirname(__FILE__)}/application.rb")
+    @cross_origin_server_pid = Process.spawn("ruby #{File.dirname(__FILE__)}/application.rb", out: "/dev/null",
+                                                                                              err: "/dev/null")
     ::Wait.until!(description: "cross origin server started") do
       Net::HTTP.get_response(cross_origin_server_host, "/", cross_origin_server_port)
     end
@@ -14,7 +15,7 @@ shared_context "cross origin server integration" do
   end
 
   def cross_origin_server_port
-    8005
+    8007
   end
 
   def cross_origin_server_uri

data/spec/support/cross_origin_server/public/index.html

@@ -4,7 +4,8 @@
 
   function activateScenario() {
     var request = new XMLHttpRequest();
-    request.open("POST", "http://localhost:8001/http_stub/scenarios/activate", false);
+    var stubPort = document.URL.match(/stubPort=(.+)$/)[1];
+    request.open("POST", "http://localhost:" + stubPort + "/http_stub/scenarios/activate", false);
     request.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
 
     var result = "Failed";

data/spec/support/http_stub/configurer_integration.rb

@@ -1,26 +1,24 @@
 shared_context "configurer integration" do
   include_context "server integration"
 
-  let(:configurer)       { HttpStub::EmptyConfigurer }
-  let(:stub_server)      { configurer.stub_server }
+  let(:configurer_specification)           { {} }
+  let(:effective_configurer_specification) do
+    { class: HttpStub::EmptyConfigurer, initialize: true }.merge(configurer_specification)
+  end
+
+  let(:server_specification) { effective_configurer_specification.slice(:name, :port) }
+
+  let(:configurer)  { effective_configurer_specification[:class] }
+  let(:stub_server) { configurer.stub_server }
+
   let(:stub_registrator) { HttpStub::StubRegistrator.new(stub_server) }
 
   before(:example) do
     stub_server.host = server_host
     stub_server.port = server_port
+    configurer.initialize! if effective_configurer_specification[:initialize]
   end
 
-  after(:example) do
-    stub_server.clear_stubs!
-    stub_server.clear_scenarios!
-  end
-
-  def expect_response_to_contain_file(path)
-    response_file = Tempfile.new(File.basename(path)).tap do |file|
-      file.write(response.parsed_response)
-      file.flush
-    end
-    expect(FileUtils.compare_file(path, response_file.path)).to be(true)
-  end
+  after(:example) { stub_server.reset! }
 
 end

data/spec/support/http_stub/server/application/http_stub_rack_application_test.rb

@@ -0,0 +1,47 @@
+shared_context "http_stub rack application test" do
+  include_context "rack application test"
+
+  let(:response)      { last_response }
+  let(:response_body) { response.body.to_s }
+
+  let(:request)         { HttpStub::Server::RequestFixture.create }
+  let(:request_factory) { instance_double(HttpStub::Server::Request::Factory, create: request) }
+
+  let(:response_pipeline) { instance_double(HttpStub::Server::Application::ResponsePipeline, process: nil) }
+
+  let(:app_class) { HttpStub::Server::Application::Application }
+  let(:app)       { app_class.new! }
+
+  before(:example) do
+    allow(HttpStub::Server::Request::Factory).to receive(:new).and_return(request_factory)
+    allow(HttpStub::Server::Application::ResponsePipeline).to receive(:new).and_return(response_pipeline)
+  end
+
+  shared_context "enabled session support" do
+
+    let(:session_identifier) { { header: :some_session_identifier } }
+
+    before(:example) do
+      @original_session_identifier = app_class.settings.session_identifier
+      app_class.set :session_identifier, session_identifier
+    end
+
+    after(:example) { app_class.set :session_identifier, @original_session_identifier }
+
+  end
+
+  shared_context "request excludes a session identifier" do
+
+    before(:example) { allow(request).to receive(:session_id).and_return(nil) }
+
+  end
+
+  shared_context "request includes a session identifier" do
+
+    let(:session_id) { SecureRandom.uuid }
+
+    before(:example) { allow(request).to receive(:session_id).and_return(session_id) }
+
+  end
+
+end

data/spec/support/http_stub/server/driver.rb

@@ -0,0 +1,56 @@
+module HttpStub
+  module Server
+
+    class Driver
+
+      DRIVERS = {}
+
+      private_constant :DRIVERS
+
+      attr_reader :default_session_id, :host, :port, :uri
+
+      class << self
+
+        def find_or_create(specification)
+          resolved_specification = { name: "example_server", port: 8001 }.merge(specification)
+          DRIVERS[resolved_specification] ||= self.new(resolved_specification)
+        end
+
+        def all
+          DRIVERS.values
+        end
+
+      end
+
+      def initialize(specification)
+        @name = specification[:name]
+        @host = "localhost"
+        @port = specification[:port]
+        @uri  = "http://#{@host}:#{@port}"
+      end
+
+      def start
+        return if @pid
+        @pid = Process.spawn("rake #{@name}:start:foreground", out: "/dev/null", err: "/dev/null")
+        ::Wait.until!(description: "http stub server #{@name} started") do
+          Net::HTTP.get_response(@host, "/", @port)
+        end
+      end
+
+      def default_session_id=(session_id)
+        @default_session_id = session_id
+        HTTParty.post("#{@uri}/http_stub/sessions/default", body: { http_stub_session_id: session_id })
+      end
+
+      def reset_session
+        HTTParty.post("#{@uri}/http_stub/stubs/reset", body: { http_stub_session_id: @default_session_id })
+      end
+
+      def stop
+        Process.kill(9, @pid)
+      end
+
+    end
+
+  end
+end

data/spec/support/http_stub/server/memory_fixture.rb

@@ -0,0 +1,17 @@
+module HttpStub
+  module Server
+
+    class MemoryFixture
+
+      class << self
+
+        def create(session_configuration=HttpStub::Server::Session::Configuration.new(nil))
+          HttpStub::Server::Memory::Memory.new(session_configuration)
+        end
+
+      end
+
+    end
+
+  end
+end

data/spec/support/http_stub/server/request_fixture.rb

@@ -5,16 +5,17 @@ module HttpStub
 
       class << self
 
-        def create
-          HttpStub::Server::Request.create(create_rack_request)
+        def create(rack_request=Rack::RequestFixture.create)
+          request_factory.create(rack_request, rack_request.params, HttpServerManager::Test::SilentLogger)
         end
 
         private
 
-        def create_rack_request
-          Rack::Request.new("PATH_INFO"      => "/some/path/info",
-                            "REQUEST_METHOD" => "GET",
-                            "rack.input"     => StringIO.new)
+        def request_factory
+          @session_configuration ||= HttpStub::Server::Session::Configuration.new(nil)
+          @request_factory       ||= HttpStub::Server::Request::Factory.new(
+            @session_configuration, HttpStub::Server::MemoryFixture.create(@session_configuration)
+          )
         end
 
       end

data/spec/support/http_stub/server/scenario_fixture.rb

@@ -0,0 +1,13 @@
+module HttpStub
+  module Server
+
+    class ScenarioFixture
+
+      def self.create(name="empty")
+        HttpStub::Server::Scenario::Scenario.new("name" => name, "stubs" => [], "triggered_scenario_names" => [])
+      end
+
+    end
+
+  end
+end

data/spec/support/http_stub/server/session_fixture.rb

@@ -0,0 +1,27 @@
+module HttpStub
+  module Server
+
+    class SessionFixture
+
+      class << self
+
+        def create(id=SecureRandom.uuid)
+          HttpStub::Server::Session::Session.new(id, scenario_registry, HttpStub::Server::Session::Empty)
+        end
+
+        def memory
+          self.create(HttpStub::Server::Session::MEMORY_SESSION_ID)
+        end
+
+        private
+
+        def scenario_registry
+          @scenario_registry ||= HttpStub::Server::Registry.new("scenario")
+        end
+
+      end
+
+    end
+
+  end
+end

data/spec/support/http_stub/server_integration.rb

@@ -2,29 +2,24 @@ shared_context "server integration" do
   include Rack::Utils
   include HtmlHelpers
 
-  before(:context) do
-    @server_pid = Process.spawn("rake #{server_name}:start:foreground --trace")
-    ::Wait.until!(description: "http stub server #{server_name} started") do
-      Net::HTTP.get_response(server_host, "/", server_port)
-    end
-  end
-
-  after(:context) { Process.kill(9, @server_pid) }
+  let(:server_specification) { {} }
+  let(:server_driver)        { HttpStub::Server::Driver.find_or_create(server_specification) }
+  let(:server_host)          { server_driver.host }
+  let(:server_port)          { server_driver.port }
+  let(:server_uri)           { server_driver.uri }
 
-  def server_name
-    "example_server"
-  end
+  before(:example) { server_driver.start }
 
-  def server_host
-    "localhost"
+  def default_session_id
+    server_driver.default_session_id
   end
 
-  def server_port
-    8001
+  def establish_default_session(session_id)
+    server_driver.default_session_id = session_id
   end
 
-  def server_uri
-    "http://#{server_host}:#{server_port}"
+  def reset_session
+    server_driver.reset_session
   end
 
 end

data/spec/support/http_stub/stub_fixture.rb

@@ -2,7 +2,7 @@ module HttpStub
 
   class StubFixture
 
-    attr_reader :id, :request, :response
+    attr_reader :id, :request, :response, :triggers
 
     class Part
 
@@ -54,7 +54,10 @@ module HttpStub
         body:             "body #{@id}",
         delay_in_seconds: 8
       )
-      @trigger_fixtures = []
+      @triggers = {
+        scenario_names: [],
+        stub_fixtures:  []
+      }
     end
 
     def request=(options)
@@ -78,15 +81,22 @@ module HttpStub
                                      name: "payload_#{@id}_file.name" } })
     end
 
-    def with_triggers!(triggers)
-      self.tap { @trigger_fixtures.concat(triggers) }
+    def with_triggered_scenarios!(scenario_names)
+      self.tap { @triggers[:scenario_names].concat(scenario_names) }
+    end
+
+    def with_triggered_stubs!(stubs)
+      self.tap { @triggers[:stub_fixtures].concat(stubs) }
     end
 
     def configurer_payload
       {
         request:  @request.symbolized,
         response: @response.symbolized,
-        triggers: @trigger_fixtures.map(&:configurer_payload)
+        triggers: {
+          scenario_names: @triggers[:scenario_names],
+          stubs:          @triggers[:stub_fixtures].map(&:configurer_payload)
+        }
       }
     end
 
@@ -99,7 +109,10 @@ module HttpStub
         "headers"    => @request.headers,
         "parameters" => @request.parameters,
         "response"   => @response.stringified,
-        "triggers"   => @trigger_fixtures.map(&:server_payload)
+        "triggers"   => {
+          "scenario_names" => @triggers[:scenario_names],
+          "stubs"          => @triggers[:stub_fixtures].map(&:server_payload)
+        }
       }
     end
 

data/spec/support/include_in_json.rb

@@ -4,6 +4,10 @@ RSpec::Matchers.define :include_in_json do |expected_hash|
     actual_json.include?(expected_hash.to_json[1..-2])
   end
 
+  description do
+    "include JSON"
+  end
+
   failure_message do |actual_json|
     "expected the JSON #{actual_json} to include #{expected_hash.to_json}"
   end
@@ -12,8 +16,4 @@ RSpec::Matchers.define :include_in_json do |expected_hash|
     "expected the JSON #{actual_json} to exclude #{expected_hash.to_json}"
   end
 
-  description do
-    "include JSON"
-  end
-
 end