pact 0.1.28 → 1.3.3

data/lib/pact/matchers/expected_type.rb

@@ -0,0 +1,35 @@
+require 'pact/matchers/difference_indicator'
+
+module Pact
+  class ExpectedType < Pact::DifferenceIndicator
+
+    def initialize value
+      @value = value
+    end
+
+    def type
+      @value.class.name
+    end
+
+    def to_json options = {}
+      type
+    end
+
+    def as_json options = {}
+      type
+    end
+
+    def eq? other
+      self.class == other.class && other.type == type
+    end
+
+    def == other
+      eq? other
+    end
+
+    def to_s
+      type
+    end
+
+  end
+end

data/lib/pact/matchers/index_not_found.rb

@@ -0,0 +1,15 @@
+require 'pact/matchers/difference_indicator'
+
+module Pact
+  class IndexNotFound < Pact::DifferenceIndicator
+
+    def to_s
+      "<index not found>"
+    end
+
+    def empty?
+      true
+    end
+  end
+
+end

data/lib/pact/matchers/list_diff_formatter.rb

@@ -0,0 +1,101 @@
+module Pact
+  module Matchers
+    class ListDiffFormatter
+
+      attr_reader :diff
+
+      def initialize diff, options = {}
+        @diff = diff
+      end
+
+      def self.call diff, options = {}
+        new(diff, options).call
+      end
+
+      def to_hash
+        diff
+      end
+
+      def call
+        to_s
+      end
+
+      def to_s
+        diff_descriptions(diff).join("\n")
+      end
+
+      def diff_descriptions obj, path = [], descriptions = []
+        case obj
+        when Hash then handle_hash obj, path, descriptions
+        when Array then handle_array obj, path, descriptions
+        when Difference then handle_difference obj, path, descriptions
+        when TypeDifference then handle_mismatched_type obj, path, descriptions
+        when RegexpDifference then handle_mismatched_regexp obj, path, descriptions
+        when NoDiffIndicator then nil
+        else
+          raise "Invalid diff, expected Hash, Array, NoDiffIndicator or Difference, found #{obj.class}"
+        end
+        descriptions
+      end
+
+      def handle_hash hash, path, descriptions
+        hash.each_pair do | key, value |
+          diff_descriptions value, path + [key.inspect], descriptions
+        end
+      end
+
+      def handle_array array, path, descriptions
+        array.each_with_index do | obj, index |
+          diff_descriptions obj, path + [index], descriptions
+        end
+      end
+
+      def handle_difference difference, path, descriptions
+        case difference.expected
+        when Pact::UnexpectedKey then handle_unexpected_key(difference, path, descriptions)
+        when Pact::UnexpectedIndex then handle_unexpected_index(difference, path, descriptions)
+        else
+          case difference.actual
+          when Pact::KeyNotFound then handle_key_not_found(difference, path, descriptions)
+          when Pact::IndexNotFound then handle_index_not_found(difference, path, descriptions)
+          else
+            handle_mismatched_value(difference, path, descriptions)
+          end
+        end
+      end
+
+      def handle_unexpected_index difference, path, descriptions
+        descriptions << "\tAt:\n\t\t#{path_to_s(path)}\n\tArray contained unexpected item:\n\t\t#{difference.actual.ai}"
+      end
+
+      def handle_mismatched_value difference, path, descriptions
+        descriptions << "\tAt:\n\t\t#{path_to_s(path)}\n\tExpected:\n\t\t#{difference.expected.ai}\n\tActual:\n\t\t#{difference.actual.ai}"
+      end
+
+      def handle_mismatched_regexp difference, path, descriptions
+        descriptions << "\tAt:\n\t\t#{path_to_s(path)}\n\tExpected to match:\n\t\t#{difference.expected.inspect}\n\tActual:\n\t\t#{difference.actual.ai}"
+      end
+
+      def handle_mismatched_type difference, path, descriptions
+        descriptions << "\tAt:\n\t\t#{path_to_s(path)}\n\tExpected type:\n\t\t#{difference.expected}\n\tActual type:\n\t\t#{difference.actual}"
+      end
+
+      def handle_index_not_found difference, path, descriptions
+        descriptions << "\tAt:\n\t\t#{path_to_s(path)}\n\tMissing index with value:\n\t\t#{difference.expected.ai}"
+      end
+
+      def handle_key_not_found difference, path, descriptions
+        descriptions << "\tAt:\n\t\t#{path_to_s(path)}\n\tMissing key with value:\n\t\t#{difference.expected.ai}"
+      end
+
+      def handle_unexpected_key difference, path, descriptions
+        descriptions << "\tAt:\n\t\t#{path_to_s(path)}\n\tHash contained unexpected key with value:\n\t\t#{difference.actual.ai}"
+      end
+
+      def path_to_s path
+        "[" + path.join("][") + "]"
+      end
+
+    end
+  end
+end

data/lib/pact/matchers/matchers.rb

@@ -1,82 +1,136 @@
 require 'awesome_print'
 require 'pact/term'
+require 'pact/something_like'
+require 'pact/shared/null_expectation'
+require 'pact/shared/key_not_found'
+require 'pact/matchers/unexpected_key'
+require 'pact/matchers/unexpected_index'
+require 'pact/matchers/index_not_found'
+require 'pact/matchers/difference'
+require 'pact/matchers/regexp_difference'
+require 'pact/matchers/type_difference'
+require 'pact/matchers/expected_type'
+require 'pact/matchers/actual_type'
+require 'pact/matchers/no_diff_indicator'
 
 module Pact
   module Matchers
 
-    NO_DIFF_INDICATOR = 'no difference here!'
+    NO_DIFF_INDICATOR = NoDiffIndicator.new
+    DEFAULT_OPTIONS = {allow_unexpected_keys: true, type: false}.freeze
 
-    def diff expected, actual, options = {}
+    def diff expected, actual, opts = {}
+      calculate_diff(Pact::Term.unpack_regexps(expected), actual, DEFAULT_OPTIONS.merge(opts))
+    end
+
+    def type_diff expected, actual, opts = {}
+      calculate_diff Pact::Term.unpack_regexps(expected), actual, DEFAULT_OPTIONS.merge(opts).merge(type: true)
+    end
+
+    private
+
+    def calculate_diff expected, actual, opts = {}
+      options = DEFAULT_OPTIONS.merge(opts)
       case expected
       when Hash then hash_diff(expected, actual, options)
       when Array then array_diff(expected, actual, options)
-      when Pact::Term then diff(expected.matcher, actual, options)
       when Regexp then regexp_diff(expected, actual, options)
+      when Pact::SomethingLike then calculate_diff(expected.contents, actual, options.merge(:type => true))
       else object_diff(expected, actual, options)
       end
     end
 
-    def structure_diff expected, actual
-      diff expected, actual, {structure: true}
-    end
+    alias_method :structure_diff, :type_diff # Backwards compatibility
 
     def regexp_diff regexp, actual, options
-      if actual != nil && regexp.match(actual)
+      if actual.is_a?(String) && regexp.match(actual)
         {}
       else
-        {expected: regexp, actual: actual}
+        RegexpDifference.new regexp, actual
       end
     end
 
     def array_diff expected, actual, options
       if actual.is_a? Array
-        if expected.length == actual.length
-          difference = []
-          diff_found = false
-          expected.each_with_index do | item, index|
-            if (item_diff = diff(item, actual[index], options)).any?
-              diff_found = true
-              difference << item_diff
-            else
-              difference << NO_DIFF_INDICATOR
-            end
-          end
-          diff_found ? difference : {}
+        actual_array_diff expected, actual, options
+      else
+        Difference.new expected, actual
+      end
+    end
+
+    def actual_array_diff expected, actual, options
+      difference = []
+      diff_found = false
+      length = [expected.length, actual.length].max
+      length.times do | index|
+        expected_item = expected.fetch(index, Pact::UnexpectedIndex.new)
+        actual_item = actual.fetch(index, Pact::IndexNotFound.new)
+        if (item_diff = calculate_diff(expected_item, actual_item, options)).any?
+          diff_found = true
+          difference << item_diff
         else
-          {expected: expected, actual: actual}
+          difference << NO_DIFF_INDICATOR
+        end
+      end
+      diff_found ? difference : {}
+    end
+
+    def actual_hash_diff expected, actual, options
+      difference = expected.keys.inject({}) do |calculate_diff, key|
+        if (diff_at_key = calculate_diff(expected[key], actual.fetch(key, Pact::KeyNotFound.new), options)).any?
+          calculate_diff[key] = diff_at_key
         end
+        calculate_diff
+      end
+      difference.merge(check_for_unexpected_keys(expected, actual, options))
+    end
+
+    def check_for_unexpected_keys expected, actual, options
+      if options[:allow_unexpected_keys]
+        {}
       else
-        {expected: expected, actual: actual}
+        (actual.keys - expected.keys).inject({}) do | calculate_diff, key |
+          calculate_diff[key] = Difference.new(UnexpectedKey.new, actual[key])
+          calculate_diff
+        end
       end
     end
 
     def hash_diff expected, actual, options
       if actual.is_a? Hash
-        expected.keys.inject({}) do |diff, key|
-          if (diff_at_key = diff(expected[key], actual[key], options)).any?
-            diff[key] = diff_at_key
-          end
-          diff
-        end
+        actual_hash_diff expected, actual, options
       else
-        {expected: expected, actual: actual}
+        Difference.new expected, actual
       end
     end
 
-    def class_diff expected, actual
-      if expected.class != actual.class
-        actual_display = actual.nil? ? nil : {:class => actual.class, :value => actual }
-        expected_display = expected.nil? ? nil : {:class => expected.class, eg: expected}
-        {:expected => expected_display, :actual => actual_display}
-      else
+    def type_difference expected, actual
+      if types_match? expected, actual
         {}
+      else
+        TypeDifference.new type_diff_expected_display(expected), type_diff_actual_display(actual)
       end
     end
 
+    def type_diff_actual_display actual
+      actual.is_a?(KeyNotFound) ?  actual : ActualType.new(actual)
+    end
+
+    def type_diff_expected_display expected
+      ExpectedType.new(expected)
+    end
+
+    def types_match? expected, actual
+      #There must be a more elegant way to do this
+      expected.class == actual.class ||
+        (expected.is_a?(TrueClass) && actual.is_a?(FalseClass)) ||
+          (expected.is_a?(FalseClass) && actual.is_a?(TrueClass))
+    end
+
     def object_diff expected, actual, options
-      return class_diff(expected, actual) if options[:structure]
+      return type_difference(expected, actual) if options[:type]
       if expected != actual
-        {:expected => expected, :actual => actual}
+        Difference.new expected, actual
       else
         {}
       end

data/lib/pact/matchers/no_diff_indicator.rb

@@ -0,0 +1,18 @@
+module Pact
+  module Matchers
+    class NoDiffIndicator
+
+      def to_json options = {}
+        to_s
+      end
+
+      def to_s
+        'no difference here!'
+      end
+
+      def == other
+        other.is_a? NoDiffIndicator
+      end
+    end
+  end
+end

data/lib/pact/matchers/regexp_difference.rb

@@ -0,0 +1,13 @@
+require 'pact/matchers/base_difference'
+
+module Pact
+  module Matchers
+    class RegexpDifference < BaseDifference
+
+      def as_json options = {}
+        {:EXPECTED_TO_MATCH => expected.inspect, :ACTUAL => actual}
+      end
+
+    end
+  end
+end

data/lib/pact/matchers/type_difference.rb

@@ -0,0 +1,16 @@
+require 'pact/matchers/base_difference'
+
+module Pact
+  module Matchers
+    class TypeDifference < BaseDifference
+
+      def as_json options = {}
+        if KeyNotFound === actual
+          {:EXPECTED_TYPE => expected.as_json, :ACTUAL => actual.as_json }
+        else
+          {:EXPECTED_TYPE => expected.as_json, :ACTUAL_TYPE => actual.as_json }
+        end
+      end
+    end
+  end
+end

data/lib/pact/matchers/unexpected_index.rb

@@ -0,0 +1,11 @@
+require 'pact/matchers/difference_indicator'
+
+module Pact
+  class UnexpectedIndex < Pact::DifferenceIndicator
+
+    def to_s
+      '<index not to exist>'
+    end
+
+  end
+end

data/lib/pact/matchers/unexpected_key.rb

@@ -0,0 +1,11 @@
+require 'pact/matchers/difference_indicator'
+
+module Pact
+  class UnexpectedKey < Pact::DifferenceIndicator
+
+    def to_s
+      '<key not to exist>'
+    end
+
+  end
+end

data/lib/pact/matchers/unix_diff_formatter.rb

@@ -0,0 +1,114 @@
+require 'pact/shared/jruby_support'
+require 'pact/matchers/differ'
+
+module Pact
+  module Matchers
+
+    class UnixDiffFormatter
+
+      include JRubySupport
+
+      def initialize diff, options = {}
+        @diff = diff
+        @colour = options.fetch(:colour, false)
+        @differ = Pact::Matchers::Differ.new(@colour)
+      end
+
+      def self.call diff, options = {colour: Pact.configuration.color_enabled}
+        new(diff, options).call
+      end
+
+      def call
+        to_s
+      end
+
+      def to_s
+        expected = generate_string(diff, :expected)
+        actual = generate_string(diff, :actual)
+        @differ.diff_as_string(actual, expected).lstrip + "\n" + key
+      end
+
+      private
+
+      def handle thing, target
+        case thing
+        when Hash then copy_hash(thing, target)
+        when Array then copy_array(thing, target)
+        when Difference then copy_diff(thing, target)
+        when TypeDifference then copy_diff(thing, target)
+        when RegexpDifference then copy_diff(thing, target)
+        when NoDiffIndicator then copy_no_diff(thing, target)
+        else copy_object(thing, target)
+        end
+      end
+
+      def generate_string diff, target
+        comparable = handle(diff, target)
+        begin
+          # Can't think of an elegant way to check if we can pretty generate other than to try it and maybe fail
+          fix_blank_lines_in_empty_hashes JSON.pretty_generate(comparable)
+        rescue JSON::GeneratorError
+          comparable.to_s
+        end
+      end
+
+      def copy_hash hash, target
+        hash.keys.each_with_object({}) do | key, new_hash |
+          value = handle hash[key], target
+          new_hash[key] = value unless (KeyNotFound === value || UnexpectedKey === value)
+        end
+      end
+
+      def copy_array array, target
+        array.each_index.each_with_object([]) do | index, new_array |
+          value = handle array[index], target
+          new_array[index] = value unless (UnexpectedIndex === value || IndexNotFound === value)
+        end
+      end
+
+      def copy_no_diff(thing, target)
+        thing
+      end
+
+      def copy_diff difference, target
+        if target == :actual
+          handle difference.actual, target
+        else
+          handle difference.expected, target
+        end
+      end
+
+      def copy_object object, target
+        if Regexp === object
+          RegexpDecorator.new(object)
+        else
+          object
+        end
+      end
+
+      def key
+        "Key: " + @differ.red("-") + @differ.red(" means \"expected, but was not found\". \n") +
+        @differ.green("     +") + @differ.green(" means \"actual, should not be found\". \n") +
+        "     Values where the expected matches the actual are not shown.\n"
+      end
+
+      class RegexpDecorator
+
+        def initialize regexp
+          @regexp = regexp
+        end
+
+        def to_json options={}
+          @regexp.inspect
+        end
+
+        def as_json
+          @regexp.inspect
+        end
+      end
+
+      attr_reader :diff
+    end
+
+  end
+end

data/lib/pact/project_root.rb

@@ -0,0 +1,7 @@
+require 'pathname'
+
+module Pact
+  def self.project_root
+    @project_root ||= Pathname.new(File.expand_path('../../../',__FILE__)).freeze
+  end
+end

data/lib/pact/provider/configuration/configuration_extension.rb

@@ -0,0 +1,58 @@
+require 'pact/provider/state/provider_state'
+require 'pact/provider/state/provider_state_configured_modules'
+
+module Pact
+
+  module Provider
+
+    module Configuration
+
+      module ConfigurationExtension
+
+        def provider= provider
+          @provider = provider
+        end
+
+        def provider
+          if defined? @provider
+            @provider
+          else
+            raise "Please configure your provider. See the Provider section in the README for examples."
+          end
+        end
+
+        def add_pact_verification verification
+          pact_verifications << verification
+        end
+
+        def pact_verifications
+          @pact_verifications ||= []
+        end
+
+        def config_ru_path
+          @config_ru_path ||= './config.ru'
+        end
+
+        def config_ru_path= config_ru_path
+          @config_ru_path = config_ru_path
+        end
+
+        def color_enabled
+          # Can't use ||= when the variable might be false, it will execute the expression if it's false
+          defined?(@color_enabled) ? @color_enabled : true
+        end
+
+        def color_enabled= color_enabled
+          @color_enabled = color_enabled
+        end
+
+        def include mod
+          Pact::Provider::State::ProviderStateConfiguredModules.instance_eval do
+            include mod
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/pact/provider/configuration/dsl.rb

@@ -0,0 +1,13 @@
+require 'pact/provider/configuration/service_provider_dsl'
+
+module Pact
+
+  module Provider
+
+    module DSL
+      def service_provider name, &block
+        Configuration::ServiceProviderDSL.build(name, &block)
+      end
+    end
+  end
+end

data/lib/pact/provider/configuration/pact_verification.rb

@@ -0,0 +1,46 @@
+require 'pact/provider/pact_verification'
+require 'pact/shared/dsl'
+
+module Pact
+  module Provider
+
+    module Configuration
+
+      class PactVerification
+
+        extend Pact::DSL
+
+        attr_accessor :consumer_name, :pact_uri, :ref
+
+        def initialize consumer_name, options = {}
+          @consumer_name = consumer_name
+          @ref = options.fetch(:ref, :head)
+          @pact_uri = nil
+        end
+
+        dsl do
+          def pact_uri pact_uri
+            self.pact_uri = pact_uri
+          end
+        end
+
+        def finalize
+          validate
+          create_pact_verification
+        end
+
+        private
+
+        def create_pact_verification
+          verification = Pact::Provider::PactVerification.new(consumer_name, pact_uri, ref)
+          Pact.configuration.add_pact_verification verification
+        end
+
+        def validate
+          raise "Please provide a pact_uri for the verification" unless pact_uri
+        end
+
+      end
+    end
+  end
+end

data/lib/pact/provider/configuration/service_provider_config.rb

@@ -0,0 +1,16 @@
+module Pact
+  module Provider
+    module Configuration
+      class ServiceProviderConfig
+
+        def initialize &app_block
+          @app_block = app_block
+        end
+
+        def app
+          @app_block.call
+        end
+      end
+    end
+  end
+end