pact 1.3.3 → 1.4.0.rc2

data/lib/pact/consumer/mock_service_interaction_expectation.rb

@@ -1,37 +0,0 @@
-require 'pact/reification'
-
-# Represents the Interaction in the form required by the MockService
-# The json generated will be posted to the MockService to register the expectation
-module Pact
-  module Consumer
-    class MockServiceInteractionExpectation
-
-
-      def initialize interaction
-        @interaction = interaction
-      end
-
-      def to_hash
-        hash = {:description => interaction.description}
-        hash[:provider_state] = interaction.provider_state if interaction.provider_state
-        options = interaction.request.options.empty? ? {} : { options: interaction.request.options}
-        hash[:request] = interaction.request.as_json.merge(options)
-        hash[:response] = interaction.response
-        hash
-      end
-
-      def as_json options = {}
-        to_hash
-      end
-
-      def to_json opts = {}
-        as_json.to_json(opts)
-      end
-
-      private
-
-      attr_reader :interaction
-
-    end
-  end
-end

data/lib/pact/consumer/request.rb

@@ -1,27 +0,0 @@
-require 'pact/shared/request'
-require 'pact/shared/key_not_found'
-
-module Pact
-  module Consumer
-    module Request
-      class Actual < Pact::Request::Base
-
-        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)
-          headers = sym_hash.fetch(:headers)
-          body = sym_hash.fetch(:body, nil)
-          new(method, path, headers, body, query)
-        end
-
-        protected
-
-        def self.key_not_found
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/pact/consumer/server.rb

@@ -1,90 +0,0 @@
-require 'uri'
-require 'net/http'
-require 'rack'
-
-# Copied shamelessly from Capybara
-module Pact
-  class Server
-    class Middleware
-      attr_accessor :error
-
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        if env["PATH_INFO"] == "/__identify__"
-          [200, {}, [@app.object_id.to_s]]
-        else
-          begin
-            @app.call(env)
-          rescue StandardError => e
-            @error = e unless @error
-            raise e
-          end
-        end
-      end
-    end
-
-    class << self
-      def ports
-        @ports ||= {}
-      end
-    end
-
-    attr_reader :app, :port
-
-    def initialize(app, port)
-      @app = app
-      @middleware = Middleware.new(@app)
-      @server_thread = nil # supress warnings
-      @port = port
-    end
-
-    def reset_error!
-      @middleware.error = nil
-    end
-
-    def error
-      @middleware.error
-    end
-
-    def host
-      "localhost"
-    end
-
-    def responsive?
-      return false if @server_thread && @server_thread.join(0)
-
-      res = Net::HTTP.start(host, @port) { |http| http.get('/__identify__') }
-
-      if res.is_a?(Net::HTTPSuccess) or res.is_a?(Net::HTTPRedirection)
-        return res.body == @app.object_id.to_s
-      end
-    rescue SystemCallError
-      return false
-    end
-
-    def run_default_server(app, port)
-      require 'rack/handler/webrick'
-      Rack::Handler::WEBrick.run(app, :Port => port, :AccessLog => [], :Logger => WEBrick::Log::new(nil, 0))
-    end
-
-    def boot
-      unless responsive?
-        Pact::Server.ports[@app.object_id] = @port
-
-        @server_thread = Thread.new do
-          run_default_server(@middleware, @port)
-        end
-
-        Timeout.timeout(60) { @server_thread.join(0.1) until responsive? }
-      end
-    rescue Timeout::Error
-      raise "Rack application timed out during boot"
-    else
-      self
-    end
-
-  end
-end

data/lib/pact/consumer_contract.rb

@@ -1 +0,0 @@
-require 'pact/consumer_contract/consumer_contract'

data/lib/pact/consumer_contract/consumer_contract.rb

@@ -1,115 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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