pact 0.1.28 → 1.3.3

data/lib/pact/consumer.rb

@@ -1,7 +1,10 @@
-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'
+require 'pact/consumer_contract'
+require 'pact/consumer/configuration'
+require 'pact/consumer/consumer_contract_builder'
+require 'pact/consumer/consumer_contract_builders'
+require 'pact/consumer/interaction_builder'
+require 'pact/consumer/mock_service'
+require 'pact/consumer/mock_service_client'
+require 'pact/consumer/app_manager'
+require 'pact/term'
+require 'pact/something_like'

data/lib/pact/consumer_contract/consumer_contract.rb

@@ -0,0 +1,115 @@
+require 'pact/logging'
+require 'pact/something_like'
+require 'pact/symbolize_keys'
+require 'pact/term'
+require 'pact/version'
+require 'pact/shared/active_support_support'
+require 'date'
+require 'json/add/regexp'
+require 'open-uri'
+require_relative 'service_consumer'
+require_relative 'service_provider'
+require_relative 'interaction'
+require_relative 'request'
+require_relative 'pact_file'
+require_relative 'file_name'
+
+
+
+module Pact
+
+  class ConsumerContract
+
+    include SymbolizeKeys
+    include Logging
+    include FileName
+    include ActiveSupportSupport
+
+    attr_accessor :interactions
+    attr_accessor :consumer
+    attr_accessor :provider
+
+    def initialize(attributes = {})
+      @interactions = attributes[:interactions] || []
+      @consumer = attributes[:consumer]
+      @provider = attributes[:provider]
+    end
+
+    def to_hash
+      {
+        provider: @provider.as_json,
+        consumer: @consumer.as_json,
+        interactions: @interactions.collect(&:as_json),
+        metadata: {
+          pactSpecificationVersion: "1.0.0"
+        }
+      }
+    end
+
+    def as_json(options = {})
+      fix_all_the_things to_hash
+    end
+
+    def to_json(options = {})
+      as_json.to_json(options)
+    end
+
+    def self.from_hash(hash)
+      hash = symbolize_keys(hash)
+      new({
+        :interactions => hash[:interactions].collect { |hash| Interaction.from_hash(hash)},
+        :consumer => ServiceConsumer.from_hash(hash[:consumer]),
+        :provider => ServiceProvider.from_hash(hash[:provider])
+      })
+    end
+
+    def self.from_json string
+      deserialised_object = JSON.load(maintain_backwards_compatiblity_with_producer_keys(string))
+      from_hash(deserialised_object)
+    end
+
+    def self.from_uri uri, options = {}
+      from_json(Pact::PactFile.read(uri, options))
+    end
+
+    def self.maintain_backwards_compatiblity_with_producer_keys string
+      string.gsub('"producer":', '"provider":').gsub('"producer_state":', '"provider_state":')
+    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 #{provider.name}."
+      elsif interactions.size > 1
+        raise "Found more than 1 interaction matching #{criteria} in pact file between #{consumer.name} and #{provider.name}."
+      end
+      interactions.first
+    end
+
+    def find_interactions criteria
+      interactions.select{ | interaction| interaction.matches_criteria?(criteria)}
+    end
+
+    def each
+      interactions.each do | interaction |
+        yield interaction
+      end
+    end
+
+    def pact_file_name
+      file_name consumer.name, provider.name
+    end
+
+    def pactfile_path
+      raise 'You must first specify a consumer and service name' unless (consumer && consumer.name && provider && provider.name)
+      @pactfile_path ||= file_path consumer.name, provider.name
+    end
+
+    def update_pactfile
+      logger.debug "Updating pact file for #{provider.name} at #{pactfile_path}"
+      File.open(pactfile_path, 'w') do |f|
+        f.write fix_json_formatting(JSON.pretty_generate(self))
+      end
+    end
+  end
+end

data/lib/pact/consumer_contract/consumer_contract_writer.rb

@@ -0,0 +1,84 @@
+require 'pact/consumer_contract'
+require 'pact/consumer/interactions_filter'
+require 'pact/consumer_contract/file_name'
+
+module Pact
+
+  class ConsumerContractWriter
+
+    attr_reader :consumer_contract_details, :pactfile_write_mode, :interactions, :logger
+
+    def initialize consumer_contract_details, logger
+      @logger = logger
+      @consumer_contract_details = consumer_contract_details
+      @pactfile_write_mode = consumer_contract_details.fetch(:pactfile_write_mode, :overwrite).to_sym
+      @interactions = consumer_contract_details.fetch(:interactions)
+    end
+
+    def consumer_contract
+      @consumer_contract ||= Pact::ConsumerContract.new(
+        consumer: ServiceConsumer.new(name: consumer_contract_details[:consumer][:name]),
+        provider: ServiceProvider.new(name: consumer_contract_details[:provider][:name]),
+        interactions: interactions_for_new_consumer_contract)
+    end
+
+    def write
+      consumer_contract.update_pactfile
+      consumer_contract.to_json
+    end
+
+    def interactions_for_new_consumer_contract
+      if pactfile_write_mode == :update
+        merged_interactions = existing_interactions
+        filter = Consumer::UpdatableInteractionsFilter.new(merged_interactions)
+        interactions.each {|i| filter << i }
+        merged_interactions
+      else
+        interactions
+      end
+    end
+
+    def existing_interactions
+      interactions = []
+      if pactfile_exists?
+        begin
+          interactions = existing_consumer_contract.interactions
+          info_and_puts "*****************************************************************************"
+          info_and_puts "Updating existing file .#{pactfile_path.gsub(Dir.pwd, '')} as config.pactfile_write_mode is :update"
+          info_and_puts "Only interactions defined in this test run will be updated."
+          info_and_puts "As interactions are identified by description and provider state, pleased note that if either of these have changed, the old interactions won't be removed from the pact file until the specs are next run with :pactfile_write_mode => :overwrite."
+          info_and_puts "*****************************************************************************"
+        rescue StandardError => e
+          warn_and_stderr "Could not load existing consumer contract from #{pactfile_path} due to #{e}"
+          logger.error e
+          logger.error e.backtrace
+          warn_and_stderr "Creating a new file."
+        end
+      end
+      interactions
+    end
+
+    def pactfile_exists?
+      File.exist?(pactfile_path)
+    end
+
+    def pactfile_path
+      Pact::FileName.file_path consumer_contract_details[:consumer][:name], consumer_contract_details[:provider][:name]
+    end
+
+    def existing_consumer_contract
+      Pact::ConsumerContract.from_uri(pactfile_path)
+    end
+
+    def warn_and_stderr msg
+      Pact.configuration.error_stream.puts msg
+      logger.warn msg
+    end
+
+    def info_and_puts msg
+      $stdout.puts msg
+      logger.info msg
+    end
+  end
+
+end

data/lib/pact/consumer_contract/file_name.rb

@@ -0,0 +1,19 @@
+module Pact
+
+  module FileName
+
+    extend self
+
+    def file_name consumer_name, provider_name
+      "#{filenamify(consumer_name)}-#{filenamify(provider_name)}.json"
+    end
+
+    def file_path consumer_name, provider_name, pact_dir = Pact.configuration.pact_dir
+      File.join(pact_dir, file_name(consumer_name, provider_name))
+    end
+
+    def filenamify name
+      name.downcase.gsub(/\s/, '_')
+    end
+  end
+end

data/lib/pact/consumer_contract/headers.rb

@@ -0,0 +1,51 @@
+module Pact
+
+  class DuplicateHeaderError < StandardError; end
+  class InvalidHeaderNameTypeError < StandardError; end
+
+  class Headers < Hash
+
+    def initialize hash = {}
+      hash.each_pair do | key, value |
+        check_for_invalid key
+        self[find_matching_key(key)] = value
+      end
+      self.freeze
+    end
+
+    def [] key
+      super(find_matching_key(key))
+    end
+
+    def fetch *args, &block
+      args[0] = find_matching_key(args[0]) if args.first
+      super(*args, &block)
+    end
+
+    def key? key
+      super(find_matching_key(key))
+    end
+
+    alias_method :has_key?, :key?
+    alias_method :include?, :key?
+
+    private
+
+    def find_matching_key key
+      key = key.to_s
+      match = keys.find { |k| k.downcase == key.downcase }
+      match.nil? ? key : match
+    end
+
+    def check_for_invalid key
+      unless (String === key || Symbol === key)
+        raise InvalidHeaderNameTypeError.new "Header name (#{key}) must be a String or a Symbol."
+      end
+      if key? key
+        raise DuplicateHeaderError.new "Duplicate header found (#{find_matching_key(key)} and #{key}. Please use a comma separated single value when multiple headers with the same name are required."
+      end
+    end
+
+  end
+
+end

data/lib/pact/consumer_contract/interaction.rb

@@ -0,0 +1,67 @@
+require 'pact/consumer_contract/request'
+require 'pact/symbolize_keys'
+require 'pact/shared/active_support_support'
+
+module Pact
+   class Interaction
+    include ActiveSupportSupport
+      include SymbolizeKeys
+
+      attr_accessor :description, :request, :response, :provider_state
+
+      def initialize attributes = {}
+        @description = attributes[:description]
+        @request = attributes[:request]
+        @response = attributes[:response]
+        @provider_state = attributes[:provider_state] || attributes[:providerState]
+      end
+
+      def self.from_hash hash
+        request = Pact::Request::Expected.from_hash(hash['request'])
+        new(symbolize_keys(hash).merge({request: request}))
+      end
+
+      def to_hash
+        hash = { :description => @description }
+        hash[:provider_state] = @provider_state if @provider_state #Easier to read when provider state at top
+        hash.merge(:request => @request.as_json, :response => @response)
+      end
+
+      def as_json options = {}
+        fix_all_the_things to_hash
+      end
+
+      def to_json(options = {})
+        as_json.to_json(options)
+      end
+
+      def matches_criteria? criteria
+        criteria.each do | key, value |
+          unless match_criterion self.send(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 == other
+        other.is_a?(Interaction) && as_json == other.as_json
+      end
+
+      def eq? other
+        self == other
+      end
+
+      def description_with_provider_state_quoted
+        provider_state ? "\"#{description}\" given \"#{provider_state}\"" : "\"#{description}\""
+      end
+
+      def to_s
+        JSON.pretty_generate(self)
+      end
+   end
+end

data/lib/pact/consumer_contract/pact_file.rb

@@ -0,0 +1,24 @@
+module Pact
+
+  module PactFile
+
+    extend self
+
+    def read uri, options = {}
+      pact = open(uri.to_s) { | file | file.read }
+      if options[:save_pactfile_to_tmp]
+        save_pactfile_to_tmp pact, ::File.basename(uri.to_s)
+      end
+      pact
+    rescue StandardError => e
+      $stderr.puts "Error reading file from #{uri}"
+      $stderr.puts "#{e.to_s} #{e.backtrace.join("\n")}"
+      raise e
+    end
+
+    def save_pactfile_to_tmp pact, name
+      ::FileUtils.mkdir_p Pact.configuration.tmp_dir
+      ::File.open(Pact.configuration.tmp_dir + "/#{name}", "w") { |file|  file << pact}
+    end
+  end
+end

data/lib/pact/consumer_contract/request.rb

@@ -0,0 +1,73 @@
+require 'pact/shared/request'
+require 'pact/shared/null_expectation'
+
+module Pact
+
+  module Request
+
+    class Expected < Pact::Request::Base
+
+      DEFAULT_OPTIONS = {:allow_unexpected_keys => false}.freeze
+      attr_accessor :options #Temporary hack
+
+      def self.from_hash(hash)
+        sym_hash = symbolize_keys hash
+        method = sym_hash.fetch(:method)
+        path = sym_hash.fetch(:path)
+        query = sym_hash.fetch(:query, key_not_found)
+        headers = sym_hash.fetch(:headers, key_not_found)
+        body = sym_hash.fetch(:body, key_not_found)
+        options = sym_hash.fetch(:options, {})
+        new(method, path, headers, body, query, options)
+      end
+
+      def initialize(method, path, headers, body, query, options = {})
+        super(method, path, headers, body, query)
+        @options = options
+      end
+
+      def matches?(actual_request)
+        difference(actual_request).empty?
+      end
+
+      def matches_route? actual_request
+        diff({:method => method, :path => path}, {:method => actual_request.method, :path => actual_request.path}).empty?
+      end
+
+      def difference(actual_request)
+        request_diff = diff(to_hash_without_body, actual_request.to_hash_without_body)
+        unless body.is_a? NullExpectation
+          request_diff.merge(body_difference(actual_request.body))
+        else
+          request_diff
+        end
+      end
+
+      protected
+
+      def self.key_not_found
+        Pact::NullExpectation.new
+      end
+
+      private
+
+      # Options is a dirty hack to allow Condor to send extra keys in the request,
+      # as it's too much work to set up an exactly matching expectation.
+      # Need to implement a proper matching strategy and remove this.
+      # Do not rely on it!
+      def runtime_options
+        DEFAULT_OPTIONS.merge(symbolize_keys(options))
+      end
+
+      def body_difference(actual_body)
+        body_differ.call({:body => body}, {body: actual_body}, allow_unexpected_keys: runtime_options[:allow_unexpected_keys_in_body])
+      end
+
+      def body_differ
+        Pact.configuration.body_differ_for_content_type content_type
+      end
+
+    end
+
+  end
+end

data/lib/pact/consumer_contract/service_consumer.rb

@@ -0,0 +1,28 @@
+require 'pact/symbolize_keys'
+
+module Pact
+  class ServiceConsumer
+    include SymbolizeKeys
+
+    attr_accessor :name
+    def initialize options
+      @name = options[:name]
+    end
+
+    def to_s
+      name
+    end
+
+    def to_hash
+      {name: name}
+    end
+
+    def as_json options = {}
+      to_hash
+    end
+
+    def self.from_hash hash
+      new(symbolize_keys(hash))
+    end
+  end
+end

data/lib/pact/consumer_contract/service_provider.rb

@@ -0,0 +1,28 @@
+require 'pact/symbolize_keys'
+
+module Pact
+  class ServiceProvider
+    include SymbolizeKeys
+
+    attr_accessor :name
+    def initialize options
+      @name = options[:name] || '[provider 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 to_hash
+      {name: name}
+    end
+
+    def as_json options = {}
+      to_hash
+    end
+
+    def self.from_hash hash
+      new(symbolize_keys(hash))
+    end
+  end
+end

data/lib/pact/consumer_contract.rb

@@ -1,110 +1 @@
-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
+require 'pact/consumer_contract/consumer_contract'

data/lib/pact/doc/doc_file.rb

@@ -0,0 +1,40 @@
+module Pact
+  module Doc
+
+    class DocFile
+
+      def initialize consumer_contract, dir, consumer_contract_renderer, file_extension
+        @dir = dir
+        @consumer_contract = consumer_contract
+        @consumer_contract_renderer = consumer_contract_renderer
+        @file_extension = file_extension
+      end
+
+      def write
+        File.open(path, "w") { |io|  io << doc_file_contents }
+      end
+
+      def title
+        consumer_contract.provider.name
+      end
+
+      def name
+        "#{consumer_contract.consumer.name} - #{consumer_contract.provider.name}#{file_extension}"
+      end
+
+      private
+
+      attr_reader :dir, :consumer_contract, :consumer_contract_renderer, :file_extension
+
+
+      def path
+        File.join(dir, name)
+      end
+
+      def doc_file_contents
+        consumer_contract_renderer.call(consumer_contract)
+      end
+
+    end
+  end
+end

data/lib/pact/doc/generate.rb

@@ -0,0 +1,11 @@
+module Pact
+  module Doc
+    class Generate
+
+      def self.call pact_dir  = Pact.configuration.pact_dir, doc_dir = Pact.configuration.doc_dir, doc_generators = Pact.configuration.doc_generators
+        doc_generators.each{| doc_generator| doc_generator.call pact_dir, doc_dir }
+      end
+
+    end
+  end
+end