pact 0.1.28 → 1.3.3

data/lib/pact/provider/rspec.rb

@@ -0,0 +1,181 @@
+require 'open-uri'
+require 'pact/consumer_contract'
+require 'pact/provider/rspec/matchers'
+require 'pact/provider/test_methods'
+require 'pact/provider/configuration'
+
+module Pact
+  module Provider
+    module RSpec
+
+      module InstanceMethods
+        def app
+          Pact.configuration.provider.app
+        end
+      end
+
+      module ClassMethods
+
+        include ::RSpec::Core::DSL
+
+        def honour_pactfile pactfile_uri, options = {}
+          #TODO change puts to use output stream
+          puts "Reading pact at #{pactfile_uri}"
+          puts "Filtering interactions by: #{options[:criteria]}" if options[:criteria] && options[:criteria].any?
+          consumer_contract = Pact::ConsumerContract.from_json(read_pact_from(pactfile_uri, options))
+          ::RSpec.describe "Verifying a pact between #{consumer_contract.consumer.name} and #{consumer_contract.provider.name}", :pactfile_uri => pactfile_uri do
+            honour_consumer_contract consumer_contract, options
+          end
+        end
+
+        def honour_consumer_contract consumer_contract, options = {}
+          describe_consumer_contract consumer_contract, options.merge({:consumer => consumer_contract.consumer.name})
+        end
+
+        private
+
+        def describe_consumer_contract consumer_contract, options
+          consumer_interactions(consumer_contract, options).each do |interaction|
+            describe_interaction_with_provider_state interaction, options
+          end
+        end
+
+        def consumer_interactions(consumer_contract, options)
+          if options[:criteria].nil?
+            consumer_contract.interactions
+          else
+            consumer_contract.find_interactions options[:criteria]
+          end
+        end
+
+        def describe_interaction_with_provider_state interaction, options
+          if interaction.provider_state
+            describe "Given #{interaction.provider_state}" do
+              describe_interaction interaction, options
+            end
+          else
+            describe_interaction interaction, options
+          end
+        end
+
+        def describe_interaction interaction, options
+
+          metadata = {
+            :pact => :verify,
+            :pact_interaction => interaction,
+            :pact_interaction_example_description => interaction_description_for_rerun_command(interaction)
+          }
+
+          describe description_for(interaction), metadata do
+
+            describe "with #{interaction.request.method_and_path}" do
+
+              interaction_context = InteractionContext.new
+
+              before do | example |
+                interaction_context.run_once :before do
+                  Pact.configuration.logger.info "Running example '#{Pact::RSpec.full_description(example)}'"
+                  set_up_provider_state interaction.provider_state, options[:consumer]
+                  replay_interaction interaction
+                  interaction_context.last_response = last_response
+                end
+              end
+
+              after do
+                interaction_context.run_once :after do
+                  tear_down_provider_state interaction.provider_state, options[:consumer]
+                end
+              end
+
+              describe_response Pact::Term.unpack_regexps(interaction.response), interaction_context
+
+            end
+
+          end
+
+        end
+
+        def describe_response expected_response, interaction_context
+
+          describe "returns a response which" do
+
+            include Pact::RSpec::Matchers
+
+            let(:expected_response_status) { expected_response['status'] }
+            let(:expected_response_body) { expected_response['body'] }
+            let(:response) { interaction_context.last_response }
+            let(:response_status) { response.status }
+            let(:response_body) { parse_body_from_response(response) }
+            let(:differ) { Pact.configuration.body_differ_for_content_type diff_content_type }
+            let(:diff_formatter) { Pact.configuration.diff_formatter_for_content_type diff_content_type }
+            let(:expected_content_type) { Pact::Headers.new(expected_response['headers'] || {})['Content-Type'] }
+            let(:actual_content_type) { response.headers['Content-Type']}
+            let(:diff_content_type) { String === expected_content_type ? expected_content_type : actual_content_type } # expected_content_type may be a Regexp
+            let(:diff_options) { { with: differ, diff_formatter: diff_formatter } }
+
+            if expected_response['status']
+              it "has status code #{expected_response['status']}" do
+                expect(response_status).to eql expected_response_status
+              end
+            end
+
+            if expected_response['headers']
+              describe "includes headers" do
+                expected_response['headers'].each do |name, expected_header_value|
+                  it "\"#{name}\" with value #{expected_header_value.inspect}" do
+                    header_value = response.headers[name]
+                    expect(header_value).to match_header(name, expected_header_value)
+                  end
+                end
+              end
+            end
+
+            if expected_response['body']
+              it "has a matching body" do
+                expect(response_body).to match_term expected_response_body, diff_options
+              end
+            end
+          end
+        end
+
+        def description_for interaction
+          interaction.provider_state ? interaction.description : interaction.description.capitalize
+        end
+
+        def interaction_description_for_rerun_command interaction
+          description_for(interaction).capitalize + ( interaction.provider_state ? " given #{interaction.provider_state}" : "")
+        end
+
+        def read_pact_from uri, options = {}
+          Pact::PactFile.read(uri, options)
+        end
+
+      end
+
+      # The "arrange" and "act" parts of the test really only need to be run once,
+      # however, stubbing is not supported in before :all, so this is a
+      # wee hack to enable before :all like functionality using before :each.
+      # In an ideal world, the test setup and execution should be quick enough for
+      # the difference between :all and :each to be unnoticable, but the annoying
+      # reality is, sometimes it does make a difference. This is for you, V!
+
+      class InteractionContext
+
+        attr_accessor :last_response
+
+        def initialize
+          @already_run = []
+        end
+
+        def run_once hook
+          unless @already_run.include?(hook)
+            yield
+            @already_run << hook
+          end
+        end
+
+      end
+    end
+  end
+end
+

data/lib/pact/provider/state/provider_state.rb

@@ -0,0 +1,181 @@
+require 'pact/shared/dsl'
+require 'pact/provider/state/provider_state_configured_modules'
+
+module Pact
+  module Provider::State
+
+    BASE_PROVIDER_STATE_NAME = "__base_provider_state__"
+
+    module DSL
+      def provider_state name, &block
+        ProviderStates.provider_state(name, &block).register
+      end
+
+      def set_up &block
+        ProviderStates.base_provider_state.register.register_set_up &block
+      end
+
+      def tear_down &block
+        ProviderStates.base_provider_state.register_tear_down &block
+      end
+
+      def provider_states_for name, &block
+        ProviderStates.current_namespaces << name
+        instance_eval(&block)
+        ProviderStates.current_namespaces.pop
+      end
+    end
+
+    class ProviderStates
+      def self.provider_state name, &block
+        ProviderState.build(name, current_namespaces.join('.'), &block)
+      end
+
+      def self.base_provider_state
+        fullname = namespaced_name BASE_PROVIDER_STATE_NAME, {:for => current_namespaces.first }
+        provider_states[fullname] ||
+          ProviderState.new(BASE_PROVIDER_STATE_NAME, current_namespaces.join('.'))
+      end
+
+      def self.register name, provider_state
+        provider_states[name] = provider_state
+      end
+
+      def self.provider_states
+        @@provider_states ||= {}
+      end
+
+      def self.current_namespaces
+        @@current_namespaces ||= []
+      end
+
+      def self.get name, options = {}
+        fullname = namespaced_name name, options
+        (provider_states[fullname] || provider_states[fullname.to_sym] || provider_states[name])
+      end
+
+      def self.get_base opts = {}
+        fullname = namespaced_name BASE_PROVIDER_STATE_NAME, opts
+        provider_states[fullname] || NoOpProviderState
+      end
+
+      def self.namespaced_name name, options = {}
+        fullname = options[:for] ? "#{options[:for]}.#{name}" : name
+      end
+    end
+
+    class ProviderState
+
+      attr_accessor :name
+      attr_accessor :namespace
+
+      extend Pact::DSL
+
+      def initialize name, namespace, &block
+        @name = name
+        @namespace = namespace
+        @set_up_defined = false
+        @tear_down_defined = false
+        @no_op_defined = false
+      end
+
+      dsl do
+        def set_up &block
+          self.register_set_up &block
+        end
+
+        def tear_down &block
+          self.register_tear_down &block
+        end
+
+        def no_op
+          self.register_no_op
+        end
+      end
+
+      def register
+        ProviderStates.register(namespaced(name), self)
+        self
+      end
+
+      def finalize
+        validate
+      end
+
+      def register_set_up &block
+        @set_up_block = block
+        @set_up_defined = true
+      end
+
+      def register_tear_down &block
+        @tear_down_block = block
+        @tear_down_defined = true
+      end
+
+      def register_no_op
+        @no_op_defined = true
+      end
+
+      def set_up
+        if @set_up_block
+          include_provider_state_configured_modules
+          instance_eval &@set_up_block
+        end
+      end
+
+      def tear_down
+        if @tear_down_block
+          include_provider_state_configured_modules
+          instance_eval &@tear_down_block
+        end
+      end
+
+      private
+
+      attr_accessor :no_op_defined, :set_up_defined, :tear_down_defined
+
+      def validate
+        if no_op_defined && set_up_defined
+          raise error_message_for_extra_block 'set_up'
+        elsif no_op_defined && tear_down_defined
+          raise error_message_for_extra_block 'tear_down'
+        elsif !(no_op_defined || set_up_defined || tear_down_defined)
+          raise "Please provide a set_up or tear_down block for provider state \"#{name}\". If there is no data to set up or tear down, you can use \"no_op\" instead."
+        end
+      end
+
+      def error_message_for_extra_block block_name
+        "Provider state \"#{name}\" has been defined as a no_op but it also has a #{block_name} block. Please remove one or the other."
+      end
+
+      def namespaced(name)
+        if namespace.empty?
+          name
+        else
+          "#{namespace}.#{name}"
+        end
+      end
+
+      def include_provider_state_configured_modules
+        # Doing this at runtime means the order of the Pact configuration block
+        # and the provider state declarations doesn't matter.
+        # Using include ProviderStateConfiguredModules on the class doesn't seem to work -
+        # modules dynamically added to ProviderStateConfiguredModules don't seem to be
+        # included in the including class.
+        self.extend(ProviderStateConfiguredModules) unless self.singleton_class.ancestors.include?(ProviderStateConfiguredModules)
+      end
+    end
+
+    class NoOpProviderState
+
+      def self.set_up
+
+      end
+
+      def self.tear_down
+
+      end
+
+    end
+  end
+end

data/lib/pact/provider/state/provider_state_configured_modules.rb

@@ -0,0 +1,13 @@
+require 'rspec/mocks'
+
+module Pact
+  module Provider::State
+    module ProviderStateConfiguredModules
+
+      include ::RSpec::Mocks::ExampleMethods
+
+      # Placeholder for modules configured using config.include
+
+    end
+  end
+end

data/lib/pact/provider/state/provider_state_manager.rb

@@ -0,0 +1,42 @@
+module Pact
+  module Provider::State
+    class ProviderStateManager
+
+      attr_reader :provider_state_name, :consumer
+
+      def initialize provider_state_name, consumer
+        @provider_state_name = provider_state_name
+        @consumer = consumer
+      end
+
+      def set_up_provider_state
+        get_global_base_provider_state.set_up
+        get_consumer_base_provider_state.set_up
+        if provider_state_name
+          get_provider_state.set_up
+        end
+      end
+
+      def tear_down_provider_state
+        if provider_state_name
+          get_provider_state.tear_down
+        end
+        get_consumer_base_provider_state.tear_down
+        get_global_base_provider_state.tear_down
+      end
+
+      def get_provider_state
+        Pact.provider_world.provider_states.get(provider_state_name, :for => consumer)
+      end
+
+      def get_consumer_base_provider_state
+        Pact.provider_world.provider_states.get_base(:for => consumer)
+      end
+
+      def get_global_base_provider_state
+        Pact.provider_world.provider_states.get_base
+      end
+
+    end
+  end
+end

data/lib/pact/provider/state/provider_state_proxy.rb

@@ -0,0 +1,39 @@
+module Pact
+  module Provider::State
+    class ProviderStateProxy
+
+      attr_reader :missing_provider_states
+
+      def initialize
+        @missing_provider_states = {}
+      end
+
+      def get name, options = {}
+        unless provider_state = ProviderStates.get(name, options)
+          register_missing_provider_state name, options[:for]
+          raise error_message name, options[:for]
+        end
+        provider_state
+      end
+
+      def get_base options = {}
+        ProviderStates.get_base options
+      end
+
+      private
+
+      def error_message name, consumer
+        "Could not find provider state \"#{name}\" for consumer #{consumer}"
+      end
+
+      def register_missing_provider_state name, consumer
+        missing_states_for(consumer) << name unless missing_states_for(consumer).include?(name)
+      end
+
+      def missing_states_for consumer
+        @missing_provider_states[consumer] ||= []
+      end
+
+    end
+  end
+end

data/lib/pact/provider/test_methods.rb

@@ -0,0 +1,47 @@
+require 'pact/logging'
+require 'rack/test'
+require 'pact/consumer_contract/interaction'
+require 'pact/provider/state/provider_state'
+require 'pact/provider/state/provider_state_proxy'
+require 'pact/provider/request'
+require 'pact/provider/world'
+require 'pact/provider/state/provider_state_manager'
+
+module Pact
+  module Provider
+    module TestMethods
+
+      include Pact::Logging
+      include Rack::Test::Methods
+
+      def replay_interaction interaction
+        request = Request::Replayable.new(interaction.request)
+        args = [request.path, request.body, request.headers]
+
+        logger.info "Sending #{request.method.upcase} request to path: \"#{request.path}\" with headers: #{request.headers}, see debug logs for body"
+        logger.debug "body :#{request.body}"
+        response = self.send(request.method.downcase, *args)
+        logger.info "Received response with status: #{response.status}, headers: #{response.headers}, see debug logs for body"
+        logger.debug "body: #{response.body}"
+      end
+
+      def parse_body_from_response rack_response
+        case rack_response.headers['Content-Type']
+        when /json/
+          JSON.load(rack_response.body)
+        else
+          rack_response.body
+        end
+      end
+
+      def set_up_provider_state provider_state_name, consumer
+        State::ProviderStateManager.new(provider_state_name, consumer).set_up_provider_state
+      end
+
+      def tear_down_provider_state provider_state_name, consumer
+        State::ProviderStateManager.new(provider_state_name, consumer).tear_down_provider_state
+      end
+
+    end
+  end
+end

data/lib/pact/provider/verification_report.rb

@@ -0,0 +1,36 @@
+require 'pact/consumer_contract'
+
+module Pact::Provider
+  class VerificationReport
+
+    include Pact::FileName
+
+    def initialize (options)
+      @consumer = options[:consumer]
+      @provider = options[:provider]
+      @result = options[:result]
+      @output = options[:output]
+    end
+
+    def to_hash
+      {
+        :consumer => @consumer,
+        :provider => @provider,
+        :result => @result,
+        :output => @output
+      }
+    end
+
+    def as_json options = {}
+      to_hash
+    end
+
+    def to_json(options = {})
+      as_json.to_json(options)
+    end
+
+    def report_file_name
+      file_name("#{@consumer[:name]}_#{@consumer[:ref]}", "#{@provider[:name]}_#{@provider[:ref]}")
+    end
+  end
+end

data/lib/pact/provider/world.rb

@@ -0,0 +1,23 @@
+require 'pact/provider/state/provider_state_proxy'
+
+module Pact
+
+  def self.provider_world
+    @world ||= Pact::Provider::World.new
+  end
+
+  # internal api, for testing only
+  def self.clear_provider_world
+    @world = nil
+  end
+
+  module Provider
+    class World
+
+      def provider_states
+        @provider_states_proxy ||= Pact::Provider::State::ProviderStateProxy.new
+      end
+
+    end
+  end
+end

data/lib/pact/provider.rb

@@ -0,0 +1,3 @@
+require 'pact/configuration'
+require 'pact/provider/configuration'
+require 'pact/provider/world'

data/lib/pact/reification.rb

@@ -4,19 +4,21 @@ module Pact
   module Reification
 
     def self.from_term(term)
-      case
-      when term.respond_to?(:generate)
+      case term
+      when Pact::Term, Regexp, Pact::SomethingLike
         term.generate
-      when term.is_a?(Hash)
+      when Hash
         term.inject({}) do |mem, (key,term)|
           mem[key] = from_term(term)
         mem
         end
-      when term.is_a?(Array)
+      when Array
         term.inject([]) do |mem, term|
           mem << from_term(term)
           mem
         end
+      when Pact::Request::Base
+        from_term(term.to_hash)
       else
         term
       end

data/lib/pact/rspec.rb

@@ -0,0 +1,53 @@
+require 'rspec'
+# This is horrible, must work out a better way of doing this
+module Pact
+  module RSpec
+
+    def self.color_enabled?
+      if ::RSpec.configuration.respond_to?(:color_enabled?)
+        ::RSpec.configuration.color_enabled?(::RSpec.configuration.output_stream)
+      else
+        ::RSpec.configuration.color_enabled?
+      end
+    end
+
+    def self.formatter_class
+      if ::RSpec::Core::Formatters.respond_to?(:register)
+        require 'pact/provider/rspec/formatter_rspec_3'
+        Pact::Provider::RSpec::Formatter
+      else
+        require 'pact/provider/rspec/formatter_rspec_2'
+        Pact::Provider::RSpec::Formatter2
+      end
+
+    end
+
+    def self.full_description example
+      example.respond_to?(:full_description) ? example.full_description : example.example.full_description
+    end
+
+    def self.runner_defined?
+      defined?(::RSpec::Core::Runner)
+    end
+
+    def self.is_rspec_3
+      ::RSpec::Core::Formatters.respond_to?(:register)
+    end
+
+    def self.is_rspec_2
+      !is_rspec_3
+    end
+
+    def self.with_rspec_3
+      if is_rspec_3
+        yield
+      end
+    end
+
+    def self.with_rspec_2
+      if is_rspec_2
+        yield
+      end
+    end
+  end
+end