pact 1.3.3 → 1.4.0

data/lib/pact/consumer/mock_service/mock_service_administration_endpoint.rb

@@ -1,31 +0,0 @@
-require 'pact/consumer/mock_service/rack_request_helper'
-module Pact
-  module Consumer
-    class MockServiceAdministrationEndpoint
-
-      attr_accessor :logger, :name
-
-      def initialize name, logger
-        @name = name
-        @logger = logger
-      end
-
-      include RackRequestHelper
-
-      def match? env
-        headers_from(env)['X-Pact-Mock-Service'] &&
-        env['REQUEST_PATH'] == request_path &&
-          env['REQUEST_METHOD'] == request_method
-      end
-
-      def request_path
-        raise NotImplementedError
-      end
-
-      def request_method
-        raise NotImplementedError
-      end
-
-    end
-  end
-end

data/lib/pact/consumer/mock_service/pact_post.rb

@@ -1,33 +0,0 @@
-require 'pact/consumer/mock_service/mock_service_administration_endpoint'
-require 'pact/consumer_contract/consumer_contract_writer'
-
-module Pact
-  module Consumer
-    class PactPost < MockServiceAdministrationEndpoint
-
-      attr_accessor :consumer_contract, :interactions
-
-      def initialize name, logger, interactions
-        super name, logger
-        @interactions = interactions
-      end
-
-      def request_path
-        '/pact'
-      end
-
-      def request_method
-        'POST'
-      end
-
-      def respond env
-        consumer_contract_details = JSON.parse(env['rack.input'].string, symbolize_names: true)
-        logger.info "Writing pact with details #{consumer_contract_details}"
-        consumer_contract_writer = ConsumerContractWriter.new(consumer_contract_details.merge(interactions: interactions), logger)
-        json = consumer_contract_writer.write
-
-        [200, {'Content-Type' =>'application/json'}, [json]]
-      end
-    end
-  end
-end

data/lib/pact/consumer/mock_service/rack_request_helper.rb

@@ -1,51 +0,0 @@
-module Pact
-  module Consumer
-
-    module RackRequestHelper
-      REQUEST_KEYS = {
-        'REQUEST_METHOD' => :method,
-        'PATH_INFO' => :path,
-        'QUERY_STRING' => :query,
-        'rack.input' => :body
-      }
-
-      def params_hash env
-        env["QUERY_STRING"].split("&").collect{| param| param.split("=")}.inject({}){|params, param| params[param.first] = URI.decode(param.last); params }
-      end
-
-      def request_as_hash_from env
-        request = env.inject({}) do |memo, (k, v)|
-          request_key = REQUEST_KEYS[k]
-          memo[request_key] = v if request_key
-          memo
-        end
-
-        request[:headers] = headers_from env
-        body_string = request[:body].read
-
-        if body_string.empty?
-          request.delete :body
-        else
-          body_is_json = request[:headers]['Content-Type'] =~ /json/
-          request[:body] =  body_is_json ? JSON.parse(body_string) : body_string
-        end
-        request[:method] = request[:method].downcase
-        request
-      end
-
-      private
-
-      def headers_from env
-        headers = env.reject{ |key, value| !(key.start_with?("HTTP") || key == 'CONTENT_TYPE' || key == 'CONTENT_LENGTH')}
-        headers.inject({}) do | hash, header |
-          hash[standardise_header(header.first)] = header.last
-          hash
-        end
-      end
-
-      def standardise_header header
-        header.gsub(/^HTTP_/, '').split("_").collect{|word| word[0] + word[1..-1].downcase}.join("-")
-      end
-    end
-  end
-end

data/lib/pact/consumer/mock_service/verification_get.rb

@@ -1,68 +0,0 @@
-require 'pact/consumer/mock_service/mock_service_administration_endpoint'
-
-module Pact
-  module Consumer
-    class VerificationGet < MockServiceAdministrationEndpoint
-
-      include RackRequestHelper
-      attr_accessor :interaction_list, :log_description
-
-      def initialize name, logger, interaction_list, log_description
-        super name, logger
-        @interaction_list = interaction_list
-        @log_description = log_description
-      end
-
-      def request_path
-        '/interactions/verification'
-      end
-
-      def request_method
-        'GET'
-      end
-
-      def respond env
-        if interaction_list.all_matched?
-          logger.info "Verifying - interactions matched for example \"#{example_description(env)}\""
-          [200, {'Content-Type' => 'text/plain'}, ['Interactions matched']]
-        else
-          error_message = FailureMessage.new(interaction_list).to_s
-          logger.warn "Verifying - actual interactions do not match expected interactions for example \"#{example_description(env)}\". \n#{error_message}"
-          logger.warn error_message
-          [500, {'Content-Type' => 'text/plain'}, ["Actual interactions do not match expected interactions for mock #{name}.\n\n#{error_message}See #{log_description} for details."]]
-        end
-      end
-
-      def example_description env
-        params_hash(env)['example_description']
-      end
-
-      class FailureMessage
-
-        def initialize interaction_list
-          @interaction_list = interaction_list
-        end
-
-        def to_s
-          titles_and_summaries.collect do | title, summaries |
-            "#{title}:\n\t#{summaries.join("\n\t")}\n\n" if summaries.any?
-          end.compact.join
-
-        end
-
-        private
-
-        attr_reader :interaction_list
-
-        def titles_and_summaries
-          {
-            "Incorrect requests" => interaction_list.interaction_mismatches_summaries,
-            "Missing requests" => interaction_list.missing_interactions_summaries,
-            "Unexpected requests" => interaction_list.unexpected_requests_summaries,
-          }
-        end
-
-      end
-    end
-  end
-end

data/lib/pact/consumer/mock_service.rb

@@ -1,2 +0,0 @@
-require 'pact/consumer/mock_service/app'
-

data/lib/pact/consumer/mock_service_client.rb

@@ -1,65 +0,0 @@
-require 'net/http'
-require 'pact/consumer/mock_service_interaction_expectation'
-
-module Pact
-  module Consumer
-    class MockServiceClient
-
-      MOCK_SERVICE_ADMINISTRATON_HEADERS = {'X-Pact-Mock-Service' => 'true'}
-
-      def initialize port
-        @http = Net::HTTP.new('localhost', port)
-      end
-
-      def verify example_description
-        response = http.request_get("/interactions/verification?example_description=#{URI.encode(example_description)}", MOCK_SERVICE_ADMINISTRATON_HEADERS)
-        raise "\e[31m#{response.body}\e[m" unless response.is_a? Net::HTTPSuccess
-      end
-
-      def log msg
-        http.request_get("/log?msg=#{URI.encode(msg)}", MOCK_SERVICE_ADMINISTRATON_HEADERS)
-      end
-
-      def wait_for_interactions wait_max_seconds, poll_interval
-        wait_until_true(wait_max_seconds, poll_interval) do
-          response = http.request_get("/interactions/missing", MOCK_SERVICE_ADMINISTRATON_HEADERS)
-          JSON.parse(response.body)['size'] == 0
-        end
-      end
-
-      def clear_interactions example_description
-        http.delete("/interactions?example_description=#{URI.encode(example_description)}", MOCK_SERVICE_ADMINISTRATON_HEADERS)
-      end
-
-      def add_expected_interaction interaction
-        response = http.request_post('/interactions', MockServiceInteractionExpectation.new(interaction).to_json, MOCK_SERVICE_ADMINISTRATON_HEADERS.merge("Content-Type" => "application/json"))
-        raise "\e[31m#{response.body}\e[m" unless response.is_a? Net::HTTPSuccess
-      end
-
-      def self.clear_interactions port, example_description
-        Net::HTTP.new("localhost", port).delete("/interactions?example_description=#{URI.encode(example_description)}", MOCK_SERVICE_ADMINISTRATON_HEADERS)
-      end
-
-      def write_pact pacticipant_details
-        response = http.request_post("/pact", pacticipant_details.to_json, MOCK_SERVICE_ADMINISTRATON_HEADERS.merge("Content-Type" => "application/json"))
-        raise "\e[31m#{response.body}\e[m" unless response.is_a? Net::HTTPSuccess
-        response.body
-      end
-
-      private
-
-      attr_reader :http
-
-      #todo: in need a better home (where can we move it?)
-      def wait_until_true timeout=3, interval=0.1
-        time_limit = Time.now + timeout
-        loop do
-          result =  yield
-          return if result || Time.now >= time_limit
-          sleep interval
-        end
-      end
-
-    end
-  end
-end

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/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