pacto 0.3.1 → 0.4.0.rc1

data/lib/pacto/core/contract_registry.rb

@@ -1,43 +1,24 @@
+# -*- encoding : utf-8 -*-
 module Pacto
-  class ContractRegistry
-    def initialize
-      @registry = Hash.new { |hash, key| hash[key] = Set.new }
-    end
-
-    def [](tag)
-      @registry[tag]
-    end
+  class ContractNotFound < StandardError; end
 
-    def register(contract, *tags)
-      tags << :default if tags.empty?
+  class ContractRegistry < Set
+    include Logger
 
-      tags.each do |tag|
-        @registry[tag] << contract
-      end
-
-      self
+    def register(contract)
+      fail ArgumentError, 'expected a Pacto::Contract' unless contract.is_a? Contract
+      logger.debug "Registering #{contract.request_pattern} as #{contract.name}"
+      add contract
     end
 
-    def use(tag, values = {})
-      merged_contracts = @registry[:default] + @registry[tag]
-
-      fail ArgumentError, "contract \"#{tag}\" not found" if merged_contracts.empty?
-
-      merged_contracts.each do |contract|
-        contract.stub_contract! values
-      end
-
-      self
+    def find_by_name(name)
+      contract = select { |c| c.name == name }.first
+      fail ContractNotFound, "No contract found for #{name}" unless contract
+      contract
     end
 
     def contracts_for(request_signature)
-      all_contracts.select { |c| c.matches? request_signature }
-    end
-
-    private
-
-    def all_contracts
-      @registry.values.inject(Set.new, :+)
+      select { |c| c.matches? request_signature }
     end
   end
 end

data/lib/pacto/core/hook.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 module Pacto
   class Hook
     def initialize(&block)

data/lib/pacto/core/http_middleware.rb

@@ -0,0 +1,23 @@
+# -*- encoding : utf-8 -*-
+require 'observer'
+
+module Pacto
+  module Core
+    class HTTPMiddleware
+      include Logger
+      include Observable
+
+      def process(request, response)
+        contracts = Pacto.contracts_for request
+        Pacto.configuration.hook.process contracts, request, response
+
+        changed
+        begin
+          notify_observers request, response
+        rescue StandardError => e
+          logger.error(e)
+        end
+      end
+    end
+  end
+end

data/lib/pacto/core/investigation_registry.rb

@@ -0,0 +1,60 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  class InvestigationRegistry
+    include Singleton
+    include Logger
+    include Resettable
+    attr_reader :investigations
+
+    def initialize
+      @investigations = []
+    end
+
+    def self.reset!
+      instance.reset!
+    end
+
+    def reset!
+      @investigations.clear
+      @stenographer = nil
+    end
+
+    def validated?(request_pattern)
+      matched_investigations = @investigations.select do |investigation|
+        request_pattern.matches? investigation.request
+      end
+      matched_investigations unless matched_investigations.empty?
+    end
+
+    def register_investigation(investigation)
+      @investigations << investigation
+      stenographer.log_investigation investigation
+      logger.info "Detected #{investigation.summary}"
+      logger.debug(investigation.to_s) unless investigation.successful?
+      investigation
+    end
+
+    def unmatched_investigations
+      @investigations.select do |investigation|
+        investigation.contract.nil?
+      end
+    end
+
+    def failed_investigations
+      @investigations.select do |investigation|
+        !investigation.successful?
+      end
+    end
+
+    protected
+
+    def stenographer
+      @stenographer ||= create_stenographer
+    end
+
+    def create_stenographer
+      stenographer_log = File.open(Pacto.configuration.stenographer_log_file, 'a+')
+      Pacto::Observers::Stenographer.new stenographer_log
+    end
+  end
+end

data/lib/pacto/core/modes.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 module Pacto
   class << self
     def generate!

data/lib/pacto/core/pacto_request.rb

@@ -0,0 +1,59 @@
+# -*- encoding : utf-8 -*-
+require 'hashie/mash'
+
+module Pacto
+  class PactoRequest
+    # FIXME: Need case insensitive header lookup, but case-sensitive storage
+    attr_accessor :headers, :body, :method, :uri
+
+    def initialize(data)
+      mash = Hashie::Mash.new data
+      @headers = mash.headers.nil? ? {} : mash.headers
+      @body    = mash.body
+      @method  = mash[:method]
+      @uri     = mash.uri
+      normalize
+    end
+
+    def to_hash
+      {
+        method: method,
+        uri: uri,
+        headers: headers,
+        body: body
+      }
+    end
+
+    def to_s
+      string = Pacto::UI.colorize_method(method)
+      string << " #{relative_uri}"
+      string << " with body (#{body.bytesize} bytes)" if body
+      string
+    end
+
+    def relative_uri
+      uri.to_s.tap do |s|
+        s.slice!(uri.normalized_site)
+      end
+    end
+
+    def parsed_body
+      if body.is_a?(String) && content_type == 'application/json'
+        JSON.parse(body)
+      else
+        body
+      end
+    rescue
+      body
+    end
+
+    def content_type
+      headers['Content-Type']
+    end
+
+    def normalize
+      @method = @method.to_s.downcase.to_sym
+      @uri = @uri.normalize if @uri
+    end
+  end
+end

data/lib/pacto/core/pacto_response.rb

@@ -0,0 +1,41 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  class PactoResponse
+    # FIXME: Need case insensitive header lookup, but case-sensitive storage
+    attr_accessor :headers, :body, :status, :parsed_body
+    attr_reader :parsed_body
+
+    def initialize(data)
+      mash = Hashie::Mash.new data
+      @headers = mash.headers.nil? ? {} : mash.headers
+      @body = mash.body
+      @status  = mash.status.to_i
+    end
+
+    def to_hash
+      {
+        status: status,
+        headers: headers,
+        body: body
+      }
+    end
+
+    def to_s
+      string = "STATUS: #{status}"
+      string << " with body (#{body.bytesize} bytes)" if body
+      string
+    end
+
+    def parsed_body
+      if body.is_a?(String) && content_type == 'application/json'
+        JSON.parse(body)
+      else
+        body
+      end
+    end
+
+    def content_type
+      headers['Content-Type']
+    end
+  end
+end

data/lib/pacto/dash.rb

@@ -0,0 +1,9 @@
+# -*- encoding : utf-8 -*-
+require 'hashie'
+
+module Pacto
+  class Dash < Hashie::Dash
+    include Hashie::Extensions::Coercion
+    include Hashie::Extensions::Dash::IndifferentAccess
+  end
+end

data/lib/pacto/erb_processor.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 module Pacto
   class ERBProcessor
     include Logger

data/lib/pacto/exceptions/invalid_contract.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 class InvalidContract < ArgumentError
   attr_reader :errors
 

data/lib/pacto/extensions.rb

@@ -1,32 +1,19 @@
+# -*- encoding : utf-8 -*-
 module Pacto
   module Extensions
     # Adapted from Faraday
     HeaderKeyMap = Hash.new do |map, key|
       split_char = key.to_s.include?('-') ? '-' : '_'
       map[key] = key.to_s.split(split_char).     # :user_agent => %w(user agent)
-          each { |w| w.capitalize! }.   # => %w(User Agent)
+          each(&:capitalize!).   # => %w(User Agent)
           join('-')                     # => "User-Agent"
     end
     HeaderKeyMap[:etag] = 'ETag'
 
     def self.normalize_header_keys(headers)
-      headers.reduce({}) do |normalized, (key, value)|
+      headers.each_with_object({}) do |(key, value), normalized|
         normalized[HeaderKeyMap[key]] = value
-        normalized
-      end
-    end
-
-    module HashSubsetOf
-      # FIXME: Only used by HashMergeProcessor, which I'd like to deprecate
-      def normalize_keys
-        reduce({}) do |normalized, (key, value)|
-          normalized[key.to_s.downcase] = value
-          normalized
-        end
       end
     end
   end
 end
-
-# FIXME: Let's not extend Hash...
-Hash.send(:include, Pacto::Extensions::HashSubsetOf)

data/lib/pacto/forensics/investigation_filter.rb

@@ -0,0 +1,90 @@
+# -*- encoding : utf-8 -*-
+module Pacto
+  module Forensics
+    class FilterExhaustedError < StandardError
+      attr_reader :suspects
+
+      def initialize(msg, filter, suspects = [])
+        @suspects = suspects
+        if filter.respond_to? :description
+          msg = "#{msg} #{filter.description}"
+        else
+          msg = "#{msg} #{filter}"
+        end
+        super(msg)
+      end
+    end
+
+    class InvestigationFilter
+      # CaseEquality makes sense for some of the rspec matchers and compound matching behavior
+      # rubocop:disable Style/CaseEquality
+      attr_reader :investigations, :filtered_investigations
+
+      def initialize(investigations, track_suspects = true)
+        investigations ||= []
+        @investigations = investigations.dup
+        @filtered_investigations = @investigations.dup
+        @track_suspects = track_suspects
+      end
+
+      def with_name(contract_name)
+        @filtered_investigations.keep_if do |investigation|
+          return false if investigation.contract.nil?
+
+          contract_name === investigation.contract.name
+        end
+        self
+      end
+
+      def with_request(request_constraints)
+        return self if request_constraints.nil?
+        [:headers, :body].each do |section|
+          filter_request_section(section, request_constraints[section])
+        end
+        self
+      end
+
+      def with_response(response_constraints)
+        return self if response_constraints.nil?
+        [:headers, :body].each do |section|
+          filter_response_section(section, response_constraints[section])
+        end
+        self
+      end
+
+      def successful_investigations
+        @filtered_investigations.select(&:successful?)
+      end
+
+      def unsuccessful_investigations
+        @filtered_investigations - successful_investigations
+      end
+
+      protected
+
+      def filter_request_section(section, filter)
+        suspects = []
+        section = :parsed_body if section == :body
+        @filtered_investigations.keep_if do |investigation|
+          candidate = investigation.request.send(section)
+          suspects << candidate if @track_suspects
+          filter === candidate
+        end if filter
+        fail FilterExhaustedError.new("no requests matched #{section}", filter, suspects) if @filtered_investigations.empty?
+      end
+
+      def filter_response_section(section, filter)
+        section = :parsed_body if section == :body
+        suspects = []
+        @filtered_investigations.keep_if do |investigation|
+          candidate = investigation.response.send(section)
+          suspects << candidate if @track_suspects
+          filter === candidate
+        end if filter
+        fail FilterExhaustedError.new("no responses matched #{section}", filter, suspects) if @filtered_investigations.empty?
+      end
+
+      # rubocop:enable Style/CaseEquality
+    end
+  end
+end

data/lib/pacto/forensics/investigation_matcher.rb

@@ -0,0 +1,80 @@
+# -*- encoding : utf-8 -*-
+RSpec::Matchers.define :have_investigated do |service_name|
+  match do
+    investigations = Pacto::InvestigationRegistry.instance.investigations
+    @service_name = service_name
+
+    begin
+      @investigation_filter = Pacto::Forensics::InvestigationFilter.new(investigations)
+      @investigation_filter.with_name(@service_name)
+        .with_request(@request_constraints)
+        .with_response(@response_constraints)
+
+      @matched_investigations = @investigation_filter.filtered_investigations
+      @unsuccessful_investigations = @investigation_filter.unsuccessful_investigations
+
+      !@matched_investigations.empty? && (@allow_citations || @unsuccessful_investigations.empty?)
+    rescue Pacto::Forensics::FilterExhaustedError => e
+      @filter_error = e
+      false
+    end
+  end
+
+  def describe(obj)
+    obj.respond_to?(:description) ? obj.description : obj.to_s
+  end
+
+  description do
+    buffer = StringIO.new
+    buffer.puts "to have investigated #{@service_name}"
+    if @request_constraints
+      buffer.puts '  with request matching'
+      @request_constraints.each do |k, v|
+        buffer.puts "    #{k}: #{describe(v)}"
+      end
+    end
+    buffer.puts '  and' if @request_constraints && @response_constraints
+    if @response_constraint
+      buffer.puts '  with response matching'
+      @request_constraints.each do |k, v|
+        buffer.puts "    #{k}: #{describe(v)}"
+      end
+    end
+    buffer.string
+  end
+
+  chain :with_request do |request_constraints|
+    @request_constraints = request_constraints
+  end
+
+  chain :with_response do |response_constraints|
+    @response_constraints = response_constraints
+  end
+
+  chain :allow_citations do
+    @allow_citations = true
+  end
+
+  failure_message do | group |
+    buffer = StringIO.new
+    buffer.puts "expected #{group} " + description
+    if @filter_error
+      buffer.puts "but #{@filter_error.message}"
+      unless @filter_error.suspects.empty?
+        buffer.puts '  suspects:'
+        @filter_error.suspects.each do |suspect|
+          buffer.puts "    #{suspect}"
+        end
+      end
+    elsif @matched_investigations.empty?
+      investigated_services = @investigation_filter.investigations.map(&:contract).compact.map(&:name).uniq
+      buffer.puts "but it was not among the services investigated: #{investigated_services}"
+    elsif @unsuccessful_investigations
+      buffer.puts 'but investigation errors were found:'
+      @unsuccessful_investigations.each do |investigation|
+        buffer.puts "  #{investigation}"
+      end
+    end
+    buffer.string
+  end
+end