pact 0.1.28 → 1.3.3

data/lib/pact/shared/active_support_support.rb

@@ -0,0 +1,51 @@
+module Pact
+  module ActiveSupportSupport
+
+    extend self
+
+    def fix_all_the_things thing
+      if thing.is_a?(Regexp)
+        fix_regexp(thing)
+      elsif thing.is_a?(Array)
+        thing.each{ | it | fix_all_the_things it }
+      elsif thing.is_a?(Hash)
+          thing.values.each{ | it | fix_all_the_things it }
+      elsif thing.class.name.start_with?("Pact")
+        thing.instance_variables.collect{ | iv_name | thing.instance_variable_get(iv_name)}.each do | iv |
+          fix_all_the_things iv
+        end
+      end
+      thing
+    end
+
+    # ActiveSupport JSON overwrites (i.e. TRAMPLES) the json methods of the Regexp class directly
+    # (beneath its destructive hooves of destruction).
+    # This does not seem to be able to be undone without affecting the JSON serialisation in the
+    # calling project, so the best way I've found to fix this issue is to reattach the
+    # original as_json to the Regexp instances in the ConsumerContract before we write them to the
+    # pact file. If anyone can find a better way, please submit a pull request ASAP!
+    def fix_regexp regexp
+      def regexp.as_json options = {}
+        {:json_class => 'Regexp', "o" => self.options, "s" => self.source }
+      end
+      regexp
+    end
+
+    # Having Active Support JSON loaded somehow kills the formatting of pretty_generate for objects.
+    # Don't ask me why, but it still seems to work for hashes, so the hacky work around is to
+    # reparse the generated JSON into a hash and pretty_generate that... sigh...
+    # Oh ActiveSupport, why....
+    def fix_json_formatting json
+      if json.include?("\n")
+        json
+      else
+        JSON.pretty_generate(JSON.parse(json, create_additions: false))
+      end
+    end
+
+    def remove_unicode json
+      json.gsub(/\\u([0-9A-Za-z]{4})/) {|s| [$1.to_i(16)].pack("U")}
+    end
+
+  end
+end

data/lib/pact/shared/dsl.rb

@@ -0,0 +1,76 @@
+module Pact
+
+  class DslDelegator
+
+    def initialize delegation_target
+      @delegation_target = delegation_target
+    end
+
+    def instance_eval_with_previous_context_available(*args, &block)
+      with_previous_context_available(block.binding) do
+        bind_block_as_instance_method_on_self(&block).call(*args)
+      end
+    end
+
+    protected
+
+    def method_missing(method, *args, &block)
+      if delegation_target_responds_to? method
+        delegation_target.send(method, *args, &block)
+      else
+        previous_context.send(method, *args, &block)
+      end
+    end
+
+    private
+
+    attr_accessor :delegation_target, :previous_context
+
+    def bind_block_as_instance_method_on_self(&block)
+      create_instance_method_from_block(&block).bind(self)
+    end
+
+
+    def create_instance_method_from_block &block
+      meth = self.class.class_eval do
+        define_method :block_as_instance_method_, &block
+        meth = instance_method :block_as_instance_method_
+        remove_method :block_as_instance_method_
+        meth
+      end
+    end
+
+    def with_previous_context_available(binding, &block)
+      @previous_context = binding.eval('self')
+      result = block.call
+      @previous_context = nil
+      result
+    end
+
+    def delegation_target_responds_to?(method)
+      delegation_target.respond_to? method
+    end
+
+  end
+
+
+  # Ripped from http://blog.joecorcoran.co.uk/2013/09/04/simple-pattern-ruby-dsl
+  # and then fixed up by using http://www.skorks.com/2013/03/a-closure-is-not-always-a-closure-in-ruby/
+  # to access variables and methods defined in the calling scope.
+  module DSL
+    def build(*args, &block)
+      new_instance_of_delegation_target_class = self.new(*args)
+      dsl_delegator_class = self.const_get('DSL_DELEGATOR_CLASS')
+      dsl_delegator = dsl_delegator_class.new(new_instance_of_delegation_target_class)
+      dsl_delegator.instance_eval_with_previous_context_available(&block)
+      new_instance_of_delegation_target_class.finalize
+      new_instance_of_delegation_target_class
+    end
+
+    def dsl(&block)
+      dsl_delegator_class = Class.new(DslDelegator, &block)
+      self.const_set('DSL_DELEGATOR_CLASS', dsl_delegator_class)
+    end
+
+  end
+end

data/lib/pact/shared/jruby_support.rb

@@ -0,0 +1,18 @@
+module Pact
+  module JRubySupport
+
+    # Under jruby, JSON.pretty_generate inserts a blank new line between the opening and closing
+    # brackets of an empty hash, like so:
+    # {
+    #   "empty": {
+    #
+    #   }
+    # }
+    # This screws up the UnixDiffFormatter, so we need to remove the blank lines.
+
+    def fix_blank_lines_in_empty_hashes json
+      json.gsub(/({\n)\n(\s*})/,'\1\2')
+    end
+
+  end
+end

data/lib/pact/shared/json_differ.rb

@@ -0,0 +1,15 @@
+require 'pact/matchers/matchers'
+
+module Pact
+  class JsonDiffer
+
+    extend Matchers
+
+
+    def self.call expected, actual, options = {}
+      diff expected, actual, options
+    end
+
+
+  end
+end

data/lib/pact/shared/key_not_found.rb

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

data/lib/pact/shared/null_expectation.rb

@@ -0,0 +1,31 @@
+module Pact
+  class NullExpectation
+    def to_s
+      "<No expectation>"
+    end
+
+    def ==(other_object)
+     other_object.is_a? NullExpectation
+    end
+
+    def ===(other_object)
+     other_object.is_a? NullExpectation
+    end
+
+    def eql?(other_object)
+      self == other_object
+    end
+
+    def hash
+      2934820948209428748274238642672
+    end
+
+    def empty?
+      true
+    end
+
+    def nil?
+      true
+    end
+  end
+end

data/lib/pact/shared/request.rb

@@ -0,0 +1,80 @@
+require 'pact/matchers'
+require 'pact/symbolize_keys'
+require 'pact/consumer_contract/headers'
+
+module Pact
+
+  module Request
+
+    class Base
+      include Pact::Matchers
+      include Pact::SymbolizeKeys
+      extend Pact::Matchers
+
+      attr_reader :method, :path, :headers, :body, :query, :options
+
+      def initialize(method, path, headers, body, query)
+        @method = method.to_s
+        @path = path.chomp('/')
+        @headers = Hash === headers ? Headers.new(headers) : headers # Could be a NullExpectation - TODO make this more elegant
+        @body = body
+        @query = query
+      end
+
+      def to_json(options = {})
+        as_json.to_json(options)
+      end
+
+      def as_json options = {}
+        to_hash
+      end
+
+      def to_hash
+        hash = {
+          method: method,
+          path: path,
+        }
+
+        hash.merge!(query: query) unless query.is_a? self.class.key_not_found.class
+        hash.merge!(headers: headers) unless headers.is_a? self.class.key_not_found.class
+        hash.merge!(body: body) unless body.is_a? self.class.key_not_found.class
+        hash
+      end
+
+      def method_and_path
+        "#{method.upcase} #{full_path}"
+      end
+
+      def full_path
+        display_path + display_query
+      end
+
+      def content_type
+        return nil if headers.is_a? self.class.key_not_found.class
+        headers['Content-Type']
+      end
+
+      protected
+
+      def self.key_not_found
+        raise NotImplementedError
+      end
+
+      def to_hash_without_body
+        keep_keys = [:method, :path, :headers, :query]
+        as_json.reject{ |key, value| !keep_keys.include? key }.tap do | hash |
+          hash[:method] = method.upcase
+        end
+      end
+
+      def display_path
+        path.empty? ? "/" : path
+      end
+
+      def display_query
+        (query.nil? || query.empty?) ? '' : "?#{Pact::Reification.from_term(query)}"
+      end
+
+    end
+  end
+end

data/lib/pact/shared/text_differ.rb

@@ -0,0 +1,14 @@
+require 'pact/matchers/matchers'
+require 'pact/matchers/difference'
+
+module Pact
+  class TextDiffer
+
+    extend Matchers
+
+    def self.call expected, actual, options = {}
+      diff expected, actual, options
+    end
+
+  end
+end

data/lib/pact/something_like.rb

@@ -0,0 +1,49 @@
+require 'pact/symbolize_keys'
+module Pact
+
+  # Specifies that the actual object should be considered a match if
+  # it includes the same keys, and the values of the keys are of the same class.
+
+  class SomethingLike
+    include SymbolizeKeys
+
+    attr_reader :contents
+
+    def initialize contents
+      @contents = contents
+    end
+
+    def to_hash
+      {
+        :json_class => self.class.name,
+        :contents => contents
+      }
+    end
+
+    def as_json
+      to_hash
+    end
+
+    def to_json opts = {}
+      as_json.to_json opts
+    end
+
+    def self.json_create hash
+      new(symbolize_keys(hash)[:contents])
+    end
+
+    def eq other
+      self == other
+    end
+
+    def == other
+      other.is_a?(SomethingLike) && other.contents == self.contents
+    end
+
+    def generate
+      contents
+    end
+  end
+end
+
+

data/lib/pact/symbolize_keys.rb

@@ -0,0 +1,12 @@
+module Pact
+  module SymbolizeKeys
+
+    def self.included(base)
+      base.extend(self)
+    end
+
+    def symbolize_keys hash
+      hash.inject({}) { |memo, (k,v)| memo[k.to_sym] = v; memo }
+    end
+  end
+end

data/lib/pact/tasks/task_helper.rb

@@ -0,0 +1,36 @@
+require 'pact/provider/pact_helper_locator'
+require 'rake/file_utils'
+require 'shellwords'
+
+module Pact
+  module TaskHelper
+
+    extend self
+
+    def execute_pact_verify pact_uri = nil, pact_helper = nil, rspec_opts = nil
+      execute_cmd verify_command(pact_helper || Pact::Provider::PactHelperLocater.pact_helper_path, pact_uri, rspec_opts)
+    end
+
+    def handle_verification_failure
+      exit_status = yield
+      abort if exit_status != 0
+    end
+
+    def verify_command pact_helper, pact_uri, rspec_opts
+      command_parts = []
+      # Clear SPEC_OPTS, otherwise we can get extra formatters, creating duplicate output eg. CI Reporting.
+      # Allow deliberate configuration using rspec_opts in VerificationTask.
+      command_parts << "SPEC_OPTS=#{Shellwords.escape(rspec_opts || '')}"
+      command_parts << FileUtils::RUBY
+      command_parts << "-S pact verify"
+      command_parts << "-h" << (pact_helper.end_with?(".rb") ? pact_helper : pact_helper + ".rb")
+      (command_parts << "-p" << pact_uri) if pact_uri
+      command_parts.flatten.join(" ")
+    end
+
+    def execute_cmd command
+      system(command) ? 0 : 1
+    end
+
+  end
+end

data/lib/pact/tasks/verification_task.rb

@@ -0,0 +1,87 @@
+require 'rake/tasklib'
+
+=begin
+  To create a rake pact:verify:<something> task
+
+  Pact::VerificationTask.new(:head) do | pact |
+    pact.uri 'http://master.cd.vpc.realestate.com.au/browse/BIQ-MAS/latestSuccessful/artifact/JOB2/Pacts/mas-contract_transaction_service.json'
+     pact.uri 'http://master.cd.vpc.realestate.com.au/browse/BIQ-IMAGINARY-CONSUMER/latestSuccessful/artifact/JOB2/Pacts/imaginary_consumer-contract_transaction_service.json'
+  end
+
+  The pact.uri may be a local file system path or a remote URL.
+
+  To run a pact:verify:xxx task you need to define a pact_helper.rb, ideally in spec/service_consumers.
+  It should contain your service_provider definition, and load any provider state definition files.
+  It should also load all your app's dependencies (eg by calling out to spec_helper)
+
+  Eg.
+
+  require 'spec_helper'
+  require 'provider_states_for_my_consumer'
+
+  Pact.service_provider "My Provider" do
+    app { TestApp.new }
+  end
+
+=end
+
+module Pact
+  class VerificationTask < ::Rake::TaskLib
+
+    attr_reader :pact_spec_configs
+    attr_accessor :rspec_opts
+
+    def initialize(name)
+      @rspec_opts = nil
+      @pact_spec_configs = []
+      @name = name
+      yield self
+      rake_task
+    end
+
+    def uri(uri, options = {})
+      @pact_spec_configs << {uri: uri, pact_helper: options[:pact_helper]}
+    end
+
+    private
+
+    attr_reader :name
+
+    # def parse_pactfile config
+    #   Pact::ConsumerContract.from_uri config[:uri]
+    # end
+
+    # def publish_report config, output, result, provider_ref, reports_dir
+    #   consumer_contract = parse_pactfile config
+    #   #TODO - when checking out a historical version, provider ref will be prod, however it will think it is head. Fix this!!!!
+    #   report = Provider::VerificationReport.new(
+    #     :result => result,
+    #     :output => output,
+    #     :consumer => {:name => consumer_contract.consumer.name, :ref => name},
+    #     :provider => {:name => consumer_contract.provider.name, :ref => provider_ref}
+    #   )
+
+    #   FileUtils.mkdir_p reports_dir
+    #   File.open("#{reports_dir}/#{report.report_file_name}", "w") { |file| file << JSON.pretty_generate(report) }
+    # end
+
+    def rake_task
+      namespace :pact do
+
+        desc "Verify provider against the consumer pacts for #{name}"
+        task "verify:#{name}" do |t, args|
+
+          require 'pact/tasks/task_helper'
+
+          exit_statuses = pact_spec_configs.collect do | config |
+            Pact::TaskHelper.execute_pact_verify config[:uri], config[:pact_helper], rspec_opts
+          end
+
+          Pact::TaskHelper.handle_verification_failure do
+            exit_statuses.count{ | status | status != 0 }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/tasks.rb

@@ -0,0 +1,2 @@
+load File.expand_path('../tasks/pact.rake', File.dirname(__FILE__))
+require 'pact/tasks/verification_task'

data/lib/pact/templates/provider_state.erb

@@ -0,0 +1,14 @@
+Could not find one or more provider states.
+Have you required the provider states file for this consumer in your pact_helper.rb?
+If you have not yet defined these states, here is a template:
+<% consumers.keys.each do | consumer_name | %>
+Pact.provider_states_for "<%= consumer_name %>" do
+<% consumers[consumer_name].each do | provider_state | %>
+  provider_state "<%= provider_state %>" do
+    set_up do
+      # Your set up code goes here
+    end
+  end
+<% end %>
+end
+<% end %>

data/lib/pact/term.rb

@@ -1,19 +1,46 @@
+require 'pact/shared/active_support_support'
+require 'json/add/regexp'
+
 module Pact
   class Term
 
+    include Pact::ActiveSupportSupport
+
     attr_reader :generate, :matcher
 
     def self.json_create(obj)
       new(generate: obj['data']['generate'], matcher: obj['data']['matcher'])
     end
 
+    def self.unpack_regexps source
+      case source
+      when Pact::Term then source.matcher
+      when Array then unpack_regexps_from_array source
+      when Hash then unpack_regexps_from_hash source
+      else
+        source
+      end
+    end
+
     def initialize(attributes = {})
       @generate = attributes[:generate]
       @matcher = attributes[:matcher]
+      raise "Please specify a matcher for the Term" unless @matcher != nil
+      raise "Please specify a value to generate for the Term" unless @generate != nil
+      raise "Value to generate \"#{@generate}\" does not match regular expression #{@matcher}" unless @generate =~ @matcher
+    end
+
+    def to_hash
+      { json_class: self.class.name, data: { generate: generate, matcher: fix_regexp(matcher)} }
+    end
+
+    def as_json(options = {})
+      to_hash
     end
 
+
     def to_json(options = {})
-      { json_class: self.class.name, data: { generate: generate, matcher: matcher} }.to_json(options)
+      as_json.to_json(options)
     end
 
     def match(literal)
@@ -26,7 +53,7 @@ module Pact
     end
 
     def to_s
-      "Pact::Term matcher: #{matcher.to_s}" + (generate.nil? ? "" : " generate: \"#{generate}\"")
+      "Pact::Term matcher: #{matcher.inspect}" + (generate.nil? ? "" : " generate: \"#{generate}\"")
     end
 
     def diff_with_actual(actual)
@@ -36,5 +63,23 @@ module Pact
       }
     end
 
+    def empty?
+      false
+    end
+
+    private
+
+    def self.unpack_regexps_from_array source
+      source.each_with_object([]) do | item, destination |
+        destination << unpack_regexps(item)
+      end
+    end
+
+    def self.unpack_regexps_from_hash source
+      source.keys.each_with_object({}) do | key, destination |
+        destination[key] = unpack_regexps source[key]
+      end
+    end
+
   end
 end

data/lib/pact/version.rb

@@ -1,3 +1,3 @@
 module Pact
-  VERSION = "0.1.28"
+  VERSION = "1.3.3"
 end

data/lib/pact.rb

@@ -1,5 +1,5 @@
 require_relative 'pact/version'
 require_relative 'pact/configuration'
 require_relative 'pact/consumer'
-require_relative 'pact/producer'
+require_relative 'pact/provider'
 require_relative 'pact/consumer_contract'

data/lib/tasks/pact.rake

@@ -1,6 +1,29 @@
+
 namespace :pact do
-	desc "Runs all the tasks prefixed with pact:verify in this project"
+
+  desc "Verifies the pact files configured in the pact_helper.rb against this service provider."
   task :verify do
-    Rake::Task.tasks.find_all{ | task| task.name.start_with? "pact:verify:"}.map(&:invoke)
+
+    require 'pact/tasks/task_helper'
+
+    include Pact::TaskHelper
+
+    handle_verification_failure do
+      execute_pact_verify
+    end
   end
+
+  desc "Verifies the pact at the given URI against this service provider."
+  task 'verify:at', :pact_uri do | t, args |
+    require 'term/ansicolor'
+    require 'pact/tasks/task_helper'
+
+    include Pact::TaskHelper
+
+    abort(::Term::ANSIColor.red("Please provide a pact URI. eg. rake pact:verify:at[../my-consumer/spec/pacts/my_consumer-my_provider.json]")) unless args[:pact_uri]
+    handle_verification_failure do
+      execute_pact_verify args[:pact_uri]
+    end
+  end
+
 end

data/pact.gemspec

@@ -6,11 +6,11 @@ require 'pact/version'
 Gem::Specification.new do |gem|
   gem.name          = "pact"
   gem.version       = Pact::VERSION
-  gem.authors       = ["James Fraser", "Sergei Matheson", "Brent Snook", "Ronald Holshausen", "Bethany Skurrie"]
+  gem.authors       = ["James Fraser", "Sergei Matheson", "Brent Snook", "Ronald Holshausen", "Beth Skurrie"]
   gem.email         = ["james.fraser@alumni.swinburne.edu", "sergei.matheson@gmail.com", "brent@fuglylogic.com", "uglyog@gmail.com", "bskurrie@dius.com.au"]
-  gem.description   = %q{Define a pact between service consumers and providers}
-  gem.summary       = %q{Define a pact between service consumers and providers}
-  gem.homepage      = "https://github.com/uglyog/pact.git"
+  gem.description   = %q{Enables consumer driven contract testing, providing a mock service and DSL for the consumer project, and interaction playback and verification for the service provider project.}
+  gem.summary       = %q{Enables consumer driven contract testing, providing a mock service and DSL for the consumer project, and interaction playback and verification for the service provider project.}
+  gem.homepage      = "https://github.com/realestate-com-au/pact"
 
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
@@ -19,18 +19,20 @@ Gem::Specification.new do |gem|
   gem.license       = 'MIT'
 
   gem.add_runtime_dependency 'randexp', '~> 0.1.7'
-  gem.add_runtime_dependency 'hashie', '~> 2.0.5'
-  gem.add_runtime_dependency 'rspec', '~> 2.12'
+  gem.add_runtime_dependency 'rspec', '>=2.14'
   gem.add_runtime_dependency 'find_a_port', '~> 1.0.1'
   gem.add_runtime_dependency 'rack-test', '~> 0.6.2'
-  gem.add_runtime_dependency 'awesome_print', '~> 1.1.0'
-  gem.add_runtime_dependency 'capybara', '~> 2.1.0'
+  gem.add_runtime_dependency 'awesome_print', '~> 1.1'
   gem.add_runtime_dependency 'thor'
-  gem.add_runtime_dependency 'thin'
   gem.add_runtime_dependency 'json' #Not locking down a version because buncher gem requires 1.6, while other projects use 1.7.
+  gem.add_runtime_dependency 'webrick'
+  gem.add_runtime_dependency 'term-ansicolor', '~> 1.0'
 
-  gem.add_development_dependency 'geminabox-client'
   gem.add_development_dependency 'rake', '~> 10.0.3'
-  gem.add_development_dependency 'webmock', '~> 1.9.3'
+  gem.add_development_dependency 'webmock', '~> 1.18.0'
   gem.add_development_dependency 'pry'
+  gem.add_development_dependency 'fakefs', '~> 0.4'
+  gem.add_development_dependency 'hashie', '~> 2.0'
+  gem.add_development_dependency 'activesupport'
+  gem.add_development_dependency 'faraday'
 end