http_stub 0.19.1 → 0.20.0

data/lib/http_stub/server/stub/match/string_value_matcher.rb

@@ -0,0 +1,33 @@
+module HttpStub
+  module Server
+    module Stub
+      module Match
+
+        class StringValueMatcher
+
+          private
+
+          MATCHERS = [ HttpStub::Server::Stub::Match::OmittedValueMatcher,
+                       HttpStub::Server::Stub::Match::RegexpValueMatcher,
+                       HttpStub::Server::Stub::Match::ExactValueMatcher ].freeze
+
+          public
+
+          def initialize(stub_value)
+            @stub_match_value = stub_value ? stub_value.to_s : stub_value
+          end
+
+          def matches?(actual_value)
+            !!MATCHERS.find { |matcher| matcher.match?(@stub_match_value, actual_value) }
+          end
+
+          def to_s
+            @stub_match_value
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/http_stub/server/stub/match/truthy_matcher.rb

@@ -0,0 +1,25 @@
+module HttpStub
+  module Server
+    module Stub
+      module Match
+
+        class TruthyMatcher
+
+          class << self
+
+            def matches?(_request, _logger)
+              true
+            end
+
+            def to_s
+              ""
+            end
+
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/http_stub/server/stub/{request_parser.rb → parser.rb}

@@ -2,11 +2,11 @@ module HttpStub
   module Server
     module Stub
 
-      class RequestParser
+      class Parser
 
         def self.parse(request)
           HttpStub::Server::Stub::PayloadFileConsolidator.consolidate!(
-            JSON.parse(request.params["payload"] || request.body.read), request
+            JSON.parse(request.parameters["payload"] || request.body), request
           )
         end
 

data/lib/http_stub/server/stub/payload_file_consolidator.rb

@@ -5,7 +5,7 @@ module HttpStub
       class PayloadFileConsolidator
 
         def self.consolidate!(payload, request)
-          response_file = request.params["response_file_#{payload["id"]}"]
+          response_file = request.parameters["response_file_#{payload["id"]}"]
           payload["response"]["body"] = response_file if response_file
           payload["triggers"].each { |trigger_payload| consolidate!(trigger_payload, request) } if payload["triggers"]
           payload

data/lib/http_stub/server/stub/registry.rb

@@ -4,24 +4,32 @@ module HttpStub
 
       class Registry
 
-        delegate :add, :concat, :all, :clear, to: :@registry
+        delegate :add, :concat, :all, to: :@stub_registry
 
-        def initialize
-          @registry = HttpStub::Server::Registry.new("stub")
+        def initialize(match_registry)
+          @match_registry = match_registry
+          @stub_registry  = HttpStub::Server::Registry.new("stub")
         end
 
-        def find_for(request)
-          stub = @registry.find(criteria: request, request: request)
-          stub.triggers.add_to(self, request) if stub
+        def find(criteria, logger)
+          stub = @stub_registry.find(criteria, logger)
+          if stub && criteria.is_a?(HttpStub::Server::Request)
+            @match_registry.add(HttpStub::Server::Stub::Match::Match.new(stub, criteria), logger)
+            stub.triggers.add_to(self, logger)
+          end
           stub
         end
 
         def remember
-          @remembered_stub = @registry.last
+          @remembered_stub = @stub_registry.last
         end
 
         def recall
-          @registry.rollback_to(@remembered_stub) if @remembered_stub
+          @stub_registry.rollback_to(@remembered_stub) if @remembered_stub
+        end
+
+        def clear(logger)
+          [ @match_registry, @stub_registry ].each { |registry| registry.clear(logger) }
         end
 
       end

data/lib/http_stub/server/stub/response/base.rb

@@ -33,15 +33,15 @@ module HttpStub
 
           end
 
-          attr_reader :status, :body, :delay_in_seconds, :headers
+          attr_reader :status, :headers, :body, :delay_in_seconds
 
           def initialize(args={})
             @original_args    = args
             resolved_args     = self.class.merge_defaults(args)
             @status           = resolved_args["status"]
+            @headers          = HttpStub::Server::FormattedHash.new(resolved_args["headers"], ":")
             @body             = resolved_args["body"]
             @delay_in_seconds = resolved_args["delay_in_seconds"]
-            @headers          = HttpStub::Server::Stub::Headers.new(resolved_args["headers"])
           end
 
           def empty?

data/lib/http_stub/server/stub/stub.rb

@@ -0,0 +1,44 @@
+module HttpStub
+  module Server
+    module Stub
+
+      class Stub
+
+        attr_reader :uri, :method, :headers, :parameters, :body, :response, :triggers, :stub_uri
+
+        def initialize(args)
+          @id          = args["id"] || SecureRandom.uuid
+          @uri         = HttpStub::Server::Stub::Match::Rule::Uri.new(args["uri"])
+          @method      = HttpStub::Server::Stub::Match::Rule::Method.new(args["method"])
+          @headers     = HttpStub::Server::Stub::Match::Rule::Headers.new(args["headers"])
+          @parameters  = HttpStub::Server::Stub::Match::Rule::Parameters.new(args["parameters"])
+          @body        = HttpStub::Server::Stub::Match::Rule::Body.create(args["body"])
+          @response    = HttpStub::Server::Stub::Response.create(args["response"])
+          @triggers    = HttpStub::Server::Stub::Triggers.new(args["triggers"])
+          @stub_uri    = "/stubs/#{@id}"
+          @description = args.to_s
+        end
+
+        def matches?(criteria, logger)
+          criteria.is_a?(String) ? matches_by_id?(criteria) : matches_by_rules?(criteria, logger)
+        end
+
+        def to_s
+          @description
+        end
+
+        private
+
+        def matches_by_id?(criteria)
+          criteria == @id
+        end
+
+        def matches_by_rules?(request, logger)
+          [ @uri, @method, @headers, @parameters, @body ].all? { |matcher| matcher.matches?(request, logger) }
+        end
+
+      end
+
+    end
+  end
+end

data/lib/http_stub/server/stub/triggers.rb

@@ -10,8 +10,8 @@ module HttpStub
           @triggers = (triggers || []).map { |trigger| HttpStub::Server::Stub.create(trigger) }
         end
 
-        def add_to(registry, request)
-          @triggers.each { |trigger| registry.add(trigger, request) }
+        def add_to(registry, logger)
+          @triggers.each { |trigger| registry.add(trigger, logger) }
         end
 
         def to_s

data/lib/http_stub/server/views/_match.haml

@@ -0,0 +1,20 @@
+%table
+  %tr
+    %td URI:
+    %td=h(match.request.uri)
+  %tr
+    %td Method:
+    %td=match.request.method
+  %tr
+    %td Headers:
+    %td=h(match.request.headers)
+  %tr
+    %td Parameters:
+    %td=h(match.request.parameters)
+  %tr
+    %td Body:
+    %td=h(match.request.body)
+  %tr
+    %td Matched Stub:
+    %td
+      %a{ href: match.stub.stub_uri, class: :stub } Match

data/lib/http_stub/server/views/matches.haml

@@ -0,0 +1,3 @@
+- matches.each do |match|
+  = partial :match, locals: { match: match }
+  %br

data/lib/http_stub/server/views/stub.haml

@@ -0,0 +1 @@
+= partial :stub, locals: { the_stub: the_stub }

data/lib/http_stub/version.rb

@@ -1,3 +1,3 @@
 module HttpStub
-  VERSION = "0.19.1".freeze
+  VERSION = "0.20.0".freeze
 end

data/spec/acceptance/stub_control_values_spec.rb

@@ -84,7 +84,8 @@ describe "Stub control value acceptance" do
 
         context "and a request that matches is made" do
 
-          let(:response) { HTTParty.get("#{server_uri}/stub_with_parameters?key=matching_value") }
+          let(:parameters) { { "key" => "matching_value" } }
+          let(:response)   { HTTParty.get("#{server_uri}/stub_with_parameters", query: parameters) }
 
           it "replays the stubbed response" do
             expect(response.code).to eql(202)
@@ -95,7 +96,8 @@ describe "Stub control value acceptance" do
 
         context "and a request that does not match is made" do
 
-          let(:response) { HTTParty.get("#{server_uri}/stub_with_parameters?key=does_not_match_value") }
+          let(:parameters) { { "key" => "does_not_match_value" } }
+          let(:response)   { HTTParty.get("#{server_uri}/stub_with_parameters", query: parameters) }
 
           it "responds with a 404 status code" do
             expect(response.code).to eql(404)
@@ -127,7 +129,8 @@ describe "Stub control value acceptance" do
 
         context "and a request that does not match is made" do
 
-          let(:response) { HTTParty.get("#{server_uri}/stub_with_omitted_parameters?key=must_be_omitted") }
+          let(:parameters) { { "key" => "must_be_omitted" } }
+          let(:response)   { HTTParty.get("#{server_uri}/stub_with_omitted_parameters", query: parameters) }
 
           it "responds with a 404 status code" do
             expect(response.code).to eql(404)

data/spec/acceptance/stub_match_spec.rb

@@ -0,0 +1,142 @@
+describe "Stub match acceptance" do
+  include_context "configurer integration"
+
+  before(:example) { configurer.initialize! }
+
+  after(:example) { configurer.clear_stubs! }
+
+  describe "GET /stubs/matches" do
+
+    let(:uri)            { "/some/uri" }
+    let(:request_method) { :get }
+    let(:headers)        do
+      (1..3).reduce({}) { |result, i| result.tap { result["header_#{i}"] = "header value #{i}" } }
+    end
+    let(:parameters)     { {} }
+    let(:body)           { nil }
+
+    let(:response)          { HTTParty.get("#{server_uri}/stubs/matches") }
+    let(:response_document) { Nokogiri::HTML(response.body) }
+
+    shared_context "behaviours of a request that is recorded in the stub match log" do
+
+      it "returns a response body that contains the uri of the request" do
+        expect(response.body).to match(/#{escape_html(uri)}/)
+      end
+
+      it "returns a response body that contains the method of the request" do
+        expect(response.body).to match(/#{escape_html(request_method)}/)
+      end
+
+      it "returns a response body that contains the headers of the request whose names are in uppercase" do
+        headers.each do |expected_header_key, expected_header_value|
+          expect(response.body).to match(/#{expected_header_key.upcase}:#{expected_header_value}/)
+        end
+      end
+
+      context "when the request contains parameters" do
+
+        let(:parameters) do
+          (1..3).reduce({}) { |result, i| result.tap { result["parameter_#{i}"] = "parameter value #{i}" } }
+        end
+
+        it "returns a response body that contain the parameters" do
+          parameters.each do |expected_parameter_key, expected_parameter_value|
+            expect(response.body).to match(/#{expected_parameter_key}=#{expected_parameter_value}/)
+          end
+        end
+
+        def issue_request
+          HTTParty.send(request_method, "#{server_uri}#{uri}", headers: headers, query: parameters)
+        end
+
+      end
+
+      context "when the request contains a body" do
+
+        let(:body) { "Some <strong>request body</strong>" }
+
+        it "returns a response body that contains the body" do
+          expect(response.body).to match(/#{escape_html(body)}/)
+        end
+
+        def issue_request
+          HTTParty.send(request_method, "#{server_uri}#{uri}", headers: headers, body: body)
+        end
+
+      end
+
+      def issue_request
+        HTTParty.send(request_method, "#{server_uri}#{uri}", headers: headers)
+      end
+
+    end
+
+    context "when a request has been made matching a stub" do
+
+      before(:example) do
+        register_stub
+
+        issue_request
+      end
+
+      include_context "behaviours of a request that is recorded in the stub match log"
+
+      it "returns a response body that contains a link to the matched stub" do
+        stub_link = response_document.css("a.stub").first
+        expect(full_stub_uri).to end_with(stub_link["href"])
+      end
+
+      def full_stub_uri
+        @register_stub_response.header["location"]
+      end
+
+    end
+
+    context "when a request has been made that does not match a stub" do
+
+      before(:example) { issue_request }
+
+      it_behaves_like "behaviours of a request that is recorded in the stub match log"
+
+    end
+
+    context "when a request has been made configuring a stub" do
+
+      before(:example) { register_stub }
+
+      it "should not be recorded in the stub request log" do
+        expect(response.body).to_not match(/#{uri}/)
+      end
+
+    end
+
+    context "when a request has been made configuring a scenarios" do
+
+      before(:example) { register_scenario }
+
+      it "should not be recorded in the stub request log" do
+        expect(response.body).to_not match(/#{uri}/)
+      end
+
+      def register_scenario
+        stub_server.add_scenario_with_one_stub!("some_scenario", build_stub)
+      end
+
+    end
+
+    def register_stub
+      @register_stub_response = stub_server.add_stub!(build_stub)
+    end
+
+    def build_stub
+      stub_server.build_stub do |stub|
+        stub.match_requests(uri: uri, method: request_method, headers: headers, parameters: parameters, body: body)
+        stub.respond_with(status: 200, body: "Some body")
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/http_stub/configurer/server/command_processor_integration_spec.rb

@@ -28,6 +28,10 @@ describe HttpStub::Configurer::Server::CommandProcessor do
           expect { subject }.not_to raise_error
         end
 
+        it "returns the server response" do
+          expect(subject).to be_a(Net::HTTPResponse)
+        end
+
       end
 
       describe "and the server responds with a non-200 response" do

data/spec/lib/http_stub/server/application_integration_spec.rb

@@ -1,5 +1,4 @@
 describe HttpStub::Server::Application, "when the server is running" do
-  include Rack::Utils
   include_context "server integration"
 
   let(:response_document) { Nokogiri::HTML(response.body) }
@@ -153,7 +152,7 @@ describe HttpStub::Server::Application, "when the server is running" do
 
       it "returns a response whose body contains the response body of a stub returning a file" do
         file_link = response_document.css("a.file").first
-        expect(file_link['href']).to match(/^file:\/\/[^']+\.pdf$/)
+        expect(file_link["href"]).to match(/^file:\/\/[^']+\.pdf$/)
       end
 
       it "returns a response whose body contains the response body of each stub trigger" do
@@ -178,6 +177,20 @@ describe HttpStub::Server::Application, "when the server is running" do
 
     end
 
+    describe "GET /stubs" do
+
+      describe "when multiple stubs are configured" do
+
+        before(:context) { (1..3).each { |i| HTTParty.get("#{server_uri}/scenario_#{i}") } }
+
+        let(:response) { HTTParty.get("#{server_uri}/stubs") }
+
+        include_context "the response contains HTML describing the configurers stubs"
+
+      end
+
+    end
+
     describe "GET /stubs/scenarios" do
 
       let(:response) { HTTParty.get("#{server_uri}/stubs/scenarios") }
@@ -187,14 +200,14 @@ describe HttpStub::Server::Application, "when the server is running" do
           (1..3).map { |i| "/#{scenario_name_prefix}_#{i}" }
         end.flatten
 
-        scenario_links = response_document.css("a.scenario").map { |link| link['href'] }
+        scenario_links = response_document.css("a.scenario").map { |link| link["href"] }
 
         expect(scenario_links).to eql(expected_scenario_links)
       end
 
       it "returns a response whose body contains links to the scenarios triggered by each scenario" do
         response_document.css("a.triggered_scenario").each_with_index do |link, i|
-          expect(link['href']).to eql("/nested_scenario_#{i + 1}")
+          expect(link["href"]).to eql("/nested_scenario_#{i + 1}")
         end
       end
 
@@ -202,20 +215,6 @@ describe HttpStub::Server::Application, "when the server is running" do
 
     end
 
-    describe "GET /stubs" do
-
-      describe "when multiple stubs are configured" do
-
-        before(:context) { (1..3).each { |i| HTTParty.get("#{server_uri}/scenario_#{i}") } }
-
-        let(:response) { HTTParty.get("#{server_uri}/stubs") }
-
-        include_context "the response contains HTML describing the configurers stubs"
-
-      end
-
-    end
-
   end
 
 end