pact 0.1.28

data/lib/pact/consumer/rspec.rb

@@ -0,0 +1,43 @@
+require_relative '../configuration'
+require_relative '../consumer'
+require_relative 'dsl'
+require_relative 'configuration_dsl'
+
+module Pact
+  module Consumer
+    module RSpec
+      include Pact::Consumer::ConsumerContractBuilders
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include Pact::Consumer::RSpec, :pact => true
+
+  config.before :all, :pact => true do
+    Pact::Consumer::AppManager.instance.spawn_all
+    FileUtils.mkdir_p Pact.configuration.pact_dir
+  end
+
+  config.before :each, :pact => true do | example |
+    example_description = "#{example.example.example_group.description} #{example.example.description}"
+    Pact.configuration.logger.info "Clearing all expectations"
+    Pact::Consumer::AppManager.instance.ports_of_mock_services.each do | port |
+      Net::HTTP.new("localhost", port).delete("/interactions?example_description=#{URI.encode(example_description)}")
+    end
+  end
+
+  config.after :each, :pact => true do | example |
+    example_description = "#{example.example.example_group.description} #{example.example.description}"
+    Pact.configuration.logger.info "Verifying interactions for #{example_description}"
+    Pact.configuration.producer_verifications.each do | producer_verification |
+      producer_verification.call example_description
+    end
+  end
+
+  config.after :suite do
+    Pact.configuration.logger.info "After suite"
+    Pact::Consumer::AppManager.instance.kill_all
+    Pact::Consumer::AppManager.instance.clear_all
+  end
+end

data/lib/pact/consumer/run_condor.rb

@@ -0,0 +1,4 @@
+require_relative 'spawn_app'
+require_relative '../../../boot'
+
+spawn_app CondorAppAssets.new, APP_PORT

data/lib/pact/consumer/run_mock_contract_service.rb

@@ -0,0 +1,13 @@
+require 'net/http'
+require_relative 'spawn_app'
+require_relative 'mock_service'
+
+spawn_app MockService.new, 1234
+
+RSpec.configure do |c|
+  c.before(:each, :type => :feature) do
+    http = Net::HTTP.new('localhost', 1234)
+    request = Net::HTTP::Delete.new('/interactions')
+    response = http.request(request)
+  end
+end

data/lib/pact/consumer/service_consumer.rb

@@ -0,0 +1,22 @@
+module Pact
+  module Consumer
+    class ServiceConsumer
+      attr_accessor :name
+      def initialize options
+        @name = options[:name]
+      end
+
+      def to_s
+        name
+      end
+
+      def as_json options = {}
+        {name: name}
+      end
+
+      def self.from_hash obj
+        ServiceConsumer.new(:name => obj['name'])
+      end
+    end
+  end
+end

data/lib/pact/consumer/service_producer.rb

@@ -0,0 +1,23 @@
+module Pact
+  module Consumer
+    # This is a crap name, it's really just a object for serializing to JSON
+    class ServiceProducer
+      attr_accessor :name
+      def initialize options
+        @name = options[:name] || '[producer name unknown - please update the pact gem in the consumer project to the latest version and regenerate the pacts]'
+      end
+
+      def to_s
+        name
+      end
+
+      def as_json options = {}
+        {name: name}
+      end
+
+      def self.from_hash obj
+        ServiceProducer.new(:name => obj['name'])
+      end
+    end
+  end
+end

data/lib/pact/consumer.rb

@@ -0,0 +1,7 @@
+require_relative 'consumer/interaction'
+require_relative 'consumer/consumer_contract_builder'
+require_relative 'consumer/mock_service'
+require_relative 'consumer/app_manager'
+require_relative 'term'
+require_relative 'request'
+require_relative 'consumer_contract'

data/lib/pact/consumer_contract.rb

@@ -0,0 +1,110 @@
+require 'pact/consumer/service_consumer'
+require 'pact/consumer/service_producer'
+require 'pact/consumer/interaction'
+require 'pact/logging'
+require 'pact/json_warning'
+require 'date'
+
+module Pact
+	class ConsumerContract
+
+		include Pact::Logging
+      include Pact::JsonWarning		
+
+		attr_accessor :interactions
+		attr_accessor :consumer
+		attr_accessor :producer
+
+		def initialize(attributes = {})
+			@interactions = attributes[:interactions] || []
+			@consumer = attributes[:consumer]
+			@producer = attributes[:producer]
+		end
+
+		def as_json(options = {})
+			{
+				producer: @producer.as_json,
+				consumer: @consumer.as_json,
+				interactions: @interactions.collect(&:as_json),
+				metadata: {
+					pact_gem: {
+						version: Pact::VERSION
+					}
+				}
+			}
+		end
+
+		def to_json(options = {})
+			as_json(options).to_json(options)
+		end
+
+		def self.from_hash(obj)
+		  new({
+		  	:interactions => obj['interactions'].collect { |hash| Pact::Consumer::Interaction.from_hash(hash)},
+		  	:consumer => Pact::Consumer::ServiceConsumer.from_hash(obj['consumer']),
+		  	:producer => Pact::Consumer::ServiceProducer.from_hash(obj['producer'] || {})
+		  })
+		end
+
+		def self.from_json string
+			deserialised_object = JSON.load(string)
+			from_hash(deserialised_object)
+		end
+
+		def find_interaction criteria
+			interactions = find_interactions criteria
+			if interactions.size == 0
+				raise "Could not find interaction matching #{criteria} in pact file between #{consumer.name} and #{producer.name}."
+			elsif interactions.size > 1
+				raise "Found more than 1 interaction matching #{criteria} in pact file between #{consumer.name} and #{producer.name}."
+			end
+			interactions.first
+		end
+
+		def find_interactions criteria
+			interactions.select{ | interaction| match_criteria? interaction, criteria}
+		end
+
+		def each
+			interactions.each do | interaction |
+				yield interaction
+			end
+		end
+
+		def match_criteria? interaction, criteria
+			criteria.each do | key, value |
+				unless match_criterion interaction[key.to_s], value
+					return false
+				end
+			end
+			true
+		end
+
+		def match_criterion target, criterion
+			target == criterion || (criterion.is_a?(Regexp) && criterion.match(target))
+		end
+
+		def pact_file_name
+			"#{filenamify(consumer.name)}-#{filenamify(producer.name)}.json"
+		end
+
+      def pactfile_path
+        raise 'You must first specify a consumer and service name' unless (consumer && consumer.name && producer && producer.name)
+        @pactfile_path ||= File.join(Pact.configuration.pact_dir, pact_file_name)
+      end
+
+      def update_pactfile
+        logger.debug "Updating pact file for #{producer.name} at #{pactfile_path}"
+        check_for_active_support_json
+        File.open(pactfile_path, 'w') do |f|
+          f.write JSON.pretty_generate(self)
+        end
+      end      		
+
+		private
+
+      def filenamify name
+        name.downcase.gsub(/\s/, '_')
+      end		
+	end
+end

data/lib/pact/json_warning.rb

@@ -0,0 +1,23 @@
+require 'logger'
+require 'json/add/regexp'
+
+module Pact
+  module JsonWarning
+    def check_for_active_support_json
+      # Active support clobbers the as_json methods defined in the json/add directory of the json gem.
+      # These methods are required to serialize and deserialize the Regexp and Symbol classes properly.
+      # You can potentially fix this by making sure the json gem is required AFTER the active_support/json gem
+      # OR if you don't use the json part of activesupport you could only require the parts of active support you really need
+      # OR you can only use strings in your pacts.
+      # Good luck.
+
+      # If someone knows how to make sure the pact gem uses the json gem as_json methods when activesupport/json is used in the calling code,
+      # without breaking the calling code, which may depend on activesupport/json... then please fix this.
+      # Note: we can probably do this in Ruby 2.0 with refinements, but for now, we're all stuck on 1.9 :(
+
+      unless Regexp.new('').as_json.is_a?(Hash)
+        Logger.new($stderr).warn("It appears you are using ActiveSupport json in your project. You are now in rubygems hell. Please see Pact::JsonWarning for more info.")
+      end
+    end
+  end
+end

data/lib/pact/logging.rb

@@ -0,0 +1,14 @@
+require 'logger'
+require_relative 'configuration'
+
+module Pact
+  module Logging
+    def self.included(base)
+      base.extend(self)
+    end
+
+    def logger
+      Pact.configuration.logger
+    end
+  end
+end

data/lib/pact/matchers/matchers.rb

@@ -0,0 +1,85 @@
+require 'awesome_print'
+require 'pact/term'
+
+module Pact
+  module Matchers
+
+    NO_DIFF_INDICATOR = 'no difference here!'
+
+    def diff expected, actual, options = {}
+      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)
+      else object_diff(expected, actual, options)
+      end
+    end
+
+    def structure_diff expected, actual
+      diff expected, actual, {structure: true}
+    end
+
+    def regexp_diff regexp, actual, options
+      if actual != nil && regexp.match(actual)
+        {}
+      else
+        {expected: regexp, actual: 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 : {}
+        else
+          {expected: expected, actual: actual}
+        end
+      else
+        {expected: expected, actual: actual}
+      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
+      else
+        {expected: expected, actual: 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
+        {}
+      end
+    end
+
+    def object_diff expected, actual, options
+      return class_diff(expected, actual) if options[:structure]
+      if expected != actual
+        {:expected => expected, :actual => actual}
+      else
+        {}
+      end
+    end
+  end
+end

data/lib/pact/matchers.rb

@@ -0,0 +1 @@
+require_relative 'matchers/matchers'

data/lib/pact/producer/configuration_dsl.rb

@@ -0,0 +1,62 @@
+require 'ostruct'
+
+
+module Pact
+  module Producer
+    module ConfigurationDSL
+
+      def producer &block
+        @producer ||= nil
+        if block_given?
+          @producer = ProducerDSL.new(&block).create_producer_config
+        elsif @producer
+          @producer
+        else
+          raise "Please configure your producer. See the Producer section in the README for examples."
+        end
+      end
+
+      class ProducerConfig
+        attr_accessor :name
+
+        def initialize name, &app_block
+          @name = name
+          @app_block = app_block
+        end
+
+        def app
+          @app_block.call
+        end
+      end
+
+      class ProducerDSL
+
+        def initialize &block
+          @app = nil
+          @name = nil
+          instance_eval(&block)
+        end
+
+        def validate
+          raise "Please provide a name for the Producer" unless @name
+          raise "Please configure an app for the Producer" unless @app_block
+        end
+
+        def name name
+          @name = name
+        end
+
+        def app &block
+          @app_block = block
+        end
+
+        def create_producer_config
+          validate
+          ProducerConfig.new(@name, &@app_block)
+        end
+      end
+    end
+  end
+end
+
+Pact::Configuration.send(:include, Pact::Producer::ConfigurationDSL)

data/lib/pact/producer/matchers.rb

@@ -0,0 +1,22 @@
+require 'pact/term'
+require 'awesome_print'
+require 'pact/matchers'
+require 'awesome_print'
+
+RSpec::Matchers.define :match_term do |expected|
+  include Pact::Matchers
+
+  match do |actual|
+    if (difference = diff(expected, actual)).any?
+      @message = difference
+      false
+    else
+      true
+    end
+  end
+
+  failure_message_for_should do | actual |
+    @message.ai
+  end
+
+end

data/lib/pact/producer/pact_spec_runner.rb

@@ -0,0 +1,57 @@
+require 'open-uri'
+require 'rspec'
+require 'rspec/core'
+require 'rspec/core/formatters/documentation_formatter'
+require_relative 'rspec'
+
+module Pact
+	module Producer
+		class PactSpecRunner
+
+			extend Pact::Producer::RSpec::ClassMethods
+
+			def self.run(spec_definitions, options = {})
+				initialize_specs spec_definitions
+				configure_rspec options
+				run_specs
+			end
+
+			private
+
+			def self.initialize_specs spec_definitions
+				spec_definitions.each do | spec_definition |
+					require spec_definition[:support_file] if spec_definition[:support_file]
+					options = {consumer: spec_definition[:consumer], save_pactfile_to_tmp: true}
+					honour_pactfile spec_definition[:uri], options
+				end
+			end
+
+			def self.configure_rspec options
+				config = ::RSpec.configuration
+				config.color = true
+
+				unless options[:silent]
+					config.error_stream = $stderr
+					config.output_stream = $stdout
+				end
+
+				formatter = ::RSpec::Core::Formatters::DocumentationFormatter.new(config.output)
+				reporter =  ::RSpec::Core::Reporter.new(formatter)
+				config.instance_variable_set(:@reporter, reporter)
+			end
+
+			def self.run_specs
+				config = ::RSpec.configuration
+				world = ::RSpec::world
+				config.reporter.report(world.example_count, nil) do |reporter|
+				  begin
+				    config.run_hook(:before, :suite)
+				    world.example_groups.ordered.map {|g| g.run(reporter)}.all? ? 0 : config.failure_exit_code
+				  ensure
+				    config.run_hook(:after, :suite)
+				  end
+				end
+			end
+		end
+	end
+end

data/lib/pact/producer/producer_state.rb

@@ -0,0 +1,81 @@
+module Pact
+  module Producer
+
+    module DSL
+      def producer_state name, &block
+        ProducerState.producer_state(name, &block).register
+      end
+
+      def with_consumer name, &block
+        ProducerState.current_namespaces << name
+        instance_eval(&block)
+        ProducerState.current_namespaces.pop
+      end
+    end
+
+    class ProducerState
+
+      attr_accessor :name
+      attr_accessor :namespace
+
+      def self.producer_state name, &block
+        ProducerState.new(name, current_namespaces.join('.'), &block)
+      end
+
+      def self.register name, producer_state
+        producer_states[name] = producer_state
+      end
+
+      def self.producer_states
+        @@producer_states ||= {}
+      end
+
+      def self.current_namespaces
+        @@current_namespaces ||= []
+      end
+
+      def self.get name, options = {}
+        fullname = options[:for] ? "#{options[:for]}.#{name}" : name
+        (producer_states[fullname] || producer_states[fullname.to_sym]) || producer_states[name]
+      end
+
+      def register
+        self.class.register(namespaced(name), self)
+      end
+
+      def initialize name, namespace, &block
+        @name = name
+        @namespace = namespace
+        instance_eval(&block)
+      end
+
+      def set_up &block
+        if block_given?
+          @set_up_block = block
+        elsif @set_up_block
+          instance_eval &@set_up_block
+        end
+      end
+
+      def tear_down &block
+        if block_given?
+          @tear_down_block = block
+        elsif @tear_down_block
+          instance_eval &@tear_down_block
+        end
+      end
+
+      private
+
+      def namespaced(name)
+        if namespace.empty?
+          name
+        else
+          "#{namespace}.#{name}"
+        end
+      end
+    end
+  end
+end
+
+Pact.send(:extend, Pact::Producer::DSL)