http_stub 0.27.0 → 0.28.0.beta1

data/spec/support/http_stub/configurator/stub_fixture.rb

@@ -0,0 +1,58 @@
+module HttpStub
+  module Configurator
+
+    class StubFixture
+
+      class << self
+
+        def create_hash(args={})
+          stub_id = args[:id] || next_id
+          {
+            id:          stub_id,
+            match_rules: {
+              uri:        "/uri/#{stub_id}",
+              method:     :get,
+              headers:    { "header_#{stub_id}"    => "header value #{stub_id}" },
+              parameters: { "parameter_#{stub_id}" => "parameter value #{stub_id}" },
+            },
+            response:    {
+              status: 200,
+              body:   "body #{stub_id}"
+            },
+            triggers:    {
+              scenario_names: [],
+              stubs:          []
+            }
+          }
+        end
+
+        def create(args={})
+          hash = self.create_hash(args)
+          HttpStub::Configurator::Stub.create do |stub|
+            stub.match_requests(hash[:match_rules])
+            stub.respond_with(hash[:response])
+            stub.trigger(hash[:triggers])
+          end
+        end
+
+        def create_hashes
+          (1..3).map { self.create_hash }
+        end
+
+        def many
+          (1..3).map { self.create }
+        end
+
+        private
+
+        def next_id
+          @next_id ||= 0
+          "#{@next_id += 1}"
+        end
+
+      end
+
+    end
+
+  end
+end

data/spec/support/http_stub/configurator_fixture.rb

@@ -0,0 +1,13 @@
+module HttpStub
+
+  class ConfiguratorFixture
+
+    def self.create(args={})
+      Class.new.tap do |configurator|
+        configurator.send(:include, HttpStub::Configurator)
+        configurator.stub_server.port = args[:port] || HttpStub::Port.free_port
+      end
+    end
+
+  end
+end

data/spec/support/http_stub/configurator_with_stub_builder_and_requester.rb

@@ -0,0 +1,14 @@
+shared_context "configurator with stub builder and requester" do
+
+  let(:configurator) { HttpStub::Examples::ConfiguratorWithComprehensiveStubs }
+
+  let(:stub_builder)   { configurator.stub_builder }
+  let(:stub_requester) { HttpStub::StubRequester.new(server_uri, stub_builder) }
+
+  let(:stub_match_rules)        { stub_builder.match_rules }
+  let(:stub_response)           { stub_builder.response }
+  let(:expected_match_response) { stub_requester.expected_response }
+
+  let(:stub_request) { stub_requester.last_request }
+
+end

data/spec/support/http_stub/headers_fixture.rb

@@ -0,0 +1,11 @@
+module HttpStub
+
+  class HeadersFixture
+
+    def self.many
+      (1..3).each_with_object({}) { |i, hash| hash["header_name_#{i}"] = "value #{Random.string}" }
+    end
+
+  end
+
+end

data/spec/support/http_stub/{html_view_excluding_request_details.rb → html_view_excluding_a_stub_request.rb}

@@ -1,11 +1,11 @@
-shared_context "HTML view excluding request details" do
+shared_context "HTML view excluding a stub request" do
 
   it "returns a 200 response" do
     expect(response.code).to eql(200)
   end
 
   it "returns a response body that does not include the request" do
-    expect(response.body).to_not include(escape_html(stub_registrator.request_uri))
+    expect(response.body).to_not include(escape_html(stub_request[:uri]))
   end
 
 end

data/spec/support/http_stub/{html_view_including_request_details.rb → html_view_including_a_stub_request.rb}

@@ -1,31 +1,39 @@
-shared_context "HTML view including request details" do
+shared_context "HTML view including a stub request" do
+
+  let(:ensure_stub_request_is_issued) { response }
 
   it "returns a 200 response" do
     expect(response.code).to eql(200)
   end
 
   it "returns a response body that contains the uri of the request" do
-    expect(response.body).to include(escape_html(stub_registrator.request_body))
+    ensure_stub_request_is_issued
+
+    expect(response.body).to include(escape_html(stub_request[:uri]))
   end
 
   it "returns a response body that contains the method of the request" do
-    expect(response.body).to include(escape_html(stub_registrator.request_method))
+    ensure_stub_request_is_issued
+
+    expect(response.body).to include(escape_html(stub_request[:method]))
   end
 
   it "returns a response body that contains the headers of the request whose names are in uppercase" do
-    stub_registrator.request_headers.each do |expected_header_key, expected_header_value|
+    ensure_stub_request_is_issued
+
+    stub_request[:headers].each do |expected_header_key, expected_header_value|
       expect(response.body).to include("#{expected_header_key.upcase}:#{expected_header_value}")
     end
   end
 
   context "when the request contains parameters" do
 
-    def configure_stub_registrator
-      stub_registrator.with_request_parameters
-    end
+    before(:example) { stub_builder.with_request_parameters! }
 
     it "returns a response body that contains the parameters" do
-      stub_registrator.request_parameters.each do |expected_parameter_key, expected_parameter_value|
+      ensure_stub_request_is_issued
+
+      stub_request[:parameters].each do |expected_parameter_key, expected_parameter_value|
         expect(response.body).to include("#{expected_parameter_key}=#{expected_parameter_value}")
       end
     end
@@ -34,12 +42,12 @@ shared_context "HTML view including request details" do
 
   context "when the request contains a body" do
 
-    def configure_stub_registrator
-      stub_registrator.with_request_body
-    end
+    before(:example) { stub_builder.with_request_body! }
 
     it "returns a response body that contains the body" do
-      expect(response.body).to include("#{escape_html(stub_registrator.request_body)}")
+      ensure_stub_request_is_issued
+
+      expect(response.body).to include("#{escape_html(stub_request[:body])}")
     end
 
   end

data/spec/support/http_stub/port.rb

@@ -0,0 +1,12 @@
+module HttpStub
+
+  class Port
+
+    def self.free_port
+      tcp_server = TCPServer.new(@host, 0)
+      tcp_server.local_address.ip_port.tap { tcp_server.close }
+    end
+
+  end
+
+end

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

@@ -7,14 +7,13 @@ shared_context "http_stub rack application test" do
   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(:configurator) { Class.new { include HttpStub::Configurator } }
 
   let(:app_class) { HttpStub::Server::Application::Application }
-  let(:app)       { app_class.new! }
 
   before(:example) do
+    app_class.configure(configurator)
     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

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

@@ -5,15 +5,16 @@ module HttpStub
 
       DRIVERS = {}
 
-      private_constant :DRIVERS
+      DEV_NULL = "/dev/null".freeze
 
-      attr_reader :session_id, :host, :port, :uri
+      private_constant :DRIVERS, :DEV_NULL
+
+      attr_reader :session_id, :host, :port, :uri, :client
 
       class << self
 
-        def find_or_create(specification)
-          resolved_specification = { name: "example_server", port: 8001 }.merge(specification)
-          DRIVERS[resolved_specification] ||= self.new(resolved_specification)
+        def find_or_create(configurator)
+          DRIVERS[configurator] ||= self.new(configurator)
         end
 
         def all
@@ -22,18 +23,22 @@ module HttpStub
 
       end
 
-      def initialize(specification)
-        @name = specification[:name]
-        @host = "localhost"
-        @port = specification[:port]
-        @uri  = "http://#{@host}:#{@port}"
+      def initialize(configurator)
+        @configurator = configurator
+        @host         = "localhost"
       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)
+        return if @port
+        ::Wait.until!(description: "server on an available port started") do
+          @port = HttpStub::Port.free_port
+          @pid = Process.spawn("rake launch_server configurator=#{@configurator.name} port=#{@port}", out: DEV_NULL,
+                                                                                                      err: DEV_NULL)
+          ::Wait.until!(description: "http stub server for #{@configurator.name} started", timeout_in_seconds: 3) do
+            Net::HTTP.get_response(@host, "/http_stub/status", @port)
+            @uri    = "http://#{@host}:#{@port}"
+            @client = HttpStub::Client.create(@uri)
+          end
         end
       end
 
@@ -42,7 +47,7 @@ module HttpStub
       end
 
       def reset_session
-        HTTParty.post("#{@uri}/http_stub/stubs/reset", body: { http_stub_session_id: @session_id })
+        @client.session(@session_id).reset!
       end
 
       def stop

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

@@ -5,8 +5,8 @@ module HttpStub
 
       class << self
 
-        def create(session_configuration=HttpStub::Server::Session::Configuration.new(nil))
-          HttpStub::Server::Memory::Memory.new(session_configuration)
+        def create(configurator_state=HttpStub::Configurator::State.new)
+          HttpStub::Server::Memory::Memory.new(configurator_state)
         end
 
       end

data/spec/support/http_stub/server/request/sinatra_request_fixture.rb

@@ -0,0 +1,16 @@
+module HttpStub
+  module Server
+    module Request
+
+      class SinatraRequestFixture
+
+        def self.create(args={})
+          rack_request = Rack::RequestFixture.create(args)
+          HttpStub::Server::Request::SinatraRequest.new(rack_request, rack_request.params)
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -5,17 +5,22 @@ module HttpStub
 
       class << self
 
-        def create(rack_request=Rack::RequestFixture.create)
-          request_factory.create(rack_request, rack_request.params, HttpServerManager::Test::SilentLogger)
+        def create(args={})
+          rack_request = args[:rack_request] || create_rack_request(args)
+          request_factory.create(rack_request, rack_request.params, HttpStub::Server::SilentLogger)
         end
 
         private
 
+        def create_rack_request(args)
+          rack_request_args = args.merge({}).tap { |rack_request_args| rack_request_args.delete(:session_id) }
+          rack_request_args.deep_merge!(headers: { session_id: args[:session_id] }) if args[:session_id]
+          Rack::RequestFixture.create(rack_request_args)
+        end
+
         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)
-          )
+          @server_memory   ||= HttpStub::Server::Memory::Memory.new(HttpStub::Configurator::State.new)
+          @request_factory ||= HttpStub::Server::Request::Factory.new({ header: :session_id }, @server_memory)
         end
 
       end

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

@@ -3,8 +3,20 @@ module HttpStub
 
     class ScenarioFixture
 
-      def self.create(name="empty")
-        HttpStub::Server::Scenario::Scenario.new("name" => name, "stubs" => [], "triggered_scenario_names" => [])
+      class << self
+
+        def with_stubs(args={})
+          self.create(args.merge(stubs: HttpStub::Configurator::StubFixture.create_hashes))
+        end
+
+        def create(args={})
+          HttpStub::Server::Scenario::Scenario.new(HttpStub::Configurator::ScenarioFixture.create_hash(args))
+        end
+
+        def many
+          (1..3).map { self.create }
+        end
+
       end
 
     end

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

@@ -3,22 +3,8 @@ module HttpStub
 
     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
-
+      def self.create(id=SecureRandom.uuid)
+        HttpStub::Server::Session::Session.new(id, HttpStub::Server::Registry.new("scenario"), [])
       end
 
     end

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

@@ -0,0 +1,7 @@
+module HttpStub
+  module Server
+
+    SilentLogger = HttpServerManager::Test::SilentLogger
+
+  end
+end

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

@@ -0,0 +1,17 @@
+module HttpStub
+  module Server
+
+    class SimpleRequest
+
+      attr_reader :headers, :parameters
+
+      def initialize(args)
+        resolved_args = { headers: {}, parameters: {} }.with_indifferent_access.merge(args)
+        @headers    = resolved_args[:headers]
+        @parameters = resolved_args[:parameters]
+      end
+
+    end
+
+  end
+end

data/spec/support/http_stub/server/stub/match/match_fixture.rb

@@ -9,7 +9,7 @@ module HttpStub
             HttpStub::Server::Stub::Match::Match.new(
               HttpStub::Server::RequestFixture.create,
               HttpStub::Server::Response::OK,
-              HttpStub::Server::Stub::Stub.new(HttpStub::StubFixture.new.server_payload)
+              HttpStub::Server::StubFixture.create
             )
           end
 

data/spec/support/http_stub/server/stub/response/blocks_fixture.rb

@@ -0,0 +1,54 @@
+module HttpStub
+  module Server
+    module Stub
+      module Response
+
+        class BlocksFixture
+
+          class << self
+
+            def simple
+              lambda do
+                {
+                  status:           200,
+                  headers:          HttpStub::HeadersFixture.many,
+                  body:             "simple content",
+                  delay_in_seconds: 8
+                }
+              end
+            end
+
+            def containing(value)
+              lambda do
+                {
+                  status:           201,
+                  headers:          HttpStub::HeadersFixture.many,
+                  body:             "value provided = #{value}",
+                  delay_in_seconds: 18
+                }
+              end
+            end
+
+            def with_request_interpolation
+              lambda do |request|
+                {
+                  status:           200,
+                  headers:          HttpStub::HeadersFixture.many,
+                  body:             "parameter[:some_parameter] = #{request.parameters[:some_parameter]}",
+                  delay_in_seconds: 28
+                }
+              end
+            end
+
+            def many
+              [ simple, containing("some value"), with_request_interpolation ]
+            end
+
+          end
+
+        end
+
+      end
+    end
+  end
+end