pact-v2 2.0.0.pre.preview1

data/lib/pact/provider/rspec.rb

@@ -0,0 +1,234 @@
+require 'open-uri'
+require 'pact/consumer_contract'
+require 'pact/provider/rspec/matchers'
+require 'pact/provider/test_methods'
+require 'pact/provider/configuration'
+require 'pact/provider/matchers/messages'
+
+
+module Pact
+  module Provider
+    module RSpec
+
+      module InstanceMethods
+        def app
+          Pact.configuration.provider.app
+        end
+      end
+
+      module ClassMethods
+        EMPTY_ARRAY = [].freeze
+
+        include ::RSpec::Core::DSL
+
+        def honour_pactfile pact_source, pact_json, options
+          pact_uri = pact_source.uri
+          Pact.configuration.output_stream.puts "INFO: Reading pact at #{pact_uri}"
+          consumer_contract = Pact::ConsumerContract.from_json(pact_json)
+
+          suffix = pact_uri.metadata[:pending] ? " [PENDING]": ""
+          example_group_description = "Verifying a pact between #{consumer_contract.consumer.name} and #{consumer_contract.provider.name}#{suffix}"
+          example_group_metadata = { pactfile_uri: pact_uri, pact_criteria: options[:criteria] }
+
+          ::RSpec.describe example_group_description, example_group_metadata do
+            honour_consumer_contract consumer_contract, options.merge(
+              pact_json: pact_json,
+              pact_uri: pact_uri,
+              pact_source: pact_source,
+              consumer_contract: consumer_contract,
+              criteria: options[:criteria]
+            )
+          end
+        end
+
+        def honour_consumer_contract consumer_contract, options = {}
+          describe_consumer_contract consumer_contract, options.merge(consumer: consumer_contract.consumer.name, pact_context: InteractionContext.new)
+        end
+
+        private
+
+        def describe_consumer_contract consumer_contract, options
+          consumer_interactions(consumer_contract, options).tap{ |interactions|
+            if interactions.empty?
+              # If there are no interactions, the documentation formatter never fires to print this out,
+              # so print it out here.
+              Pact.configuration.output_stream.puts "DEBUG: All interactions for #{options[:pact_uri]} have been filtered out by criteria: #{options[:criteria]}" if options[:criteria] && options[:criteria].any?
+            end
+          }.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
+          # pact_uri and pact_interaction are used by
+          # Pact::Provider::RSpec::PactBrokerFormatter
+
+          # pact_interaction_example_description is used by
+          # Pact::Provider::RSpec::Formatter and Pact::Provider::RSpec::Formatter2
+
+          # pact: verify is used to allow RSpec before and after hooks.
+          metadata = {
+            pact: :verify,
+            pact_interaction: interaction,
+            pact_interaction_example_description: interaction_description_for_rerun_command(interaction),
+            pact_uri: options[:pact_uri],
+            pact_source: options[:pact_source],
+            pact_ignore_failures: options[:pact_source].pending? || options[:ignore_failures],
+            pact_consumer_contract: options[:consumer_contract]
+          }
+
+          describe description_for(interaction), metadata do
+
+            interaction_context = InteractionContext.new
+            pact_context = options[:pact_context]
+
+            before do | example |
+              interaction_context.run_once :before do
+                Pact.configuration.logger.info "Running example '#{Pact::RSpec.full_description(example)}'"
+                provider_states_result = set_up_provider_states interaction.provider_states, options[:consumer]
+                state_params = provider_states_result[interaction.provider_state];
+                replay_interaction interaction, options[:request_customizer], state_params
+                interaction_context.last_response = last_response
+              end
+            end
+
+            after do
+              interaction_context.run_once :after do
+                tear_down_provider_states interaction.provider_states, options[:consumer]
+              end
+            end
+
+            if interaction.respond_to?(:message?) && interaction.message?
+              describe_message Pact::Response.new(interaction.response), interaction_context
+            else
+              describe "with #{interaction.request.method_and_path}" do
+                describe_response Pact::Response.new(interaction.response), interaction_context
+              end
+            end
+          end
+        end
+
+        def describe_message expected_response, interaction_context
+          include Pact::RSpec::Matchers
+          extend Pact::Matchers::Messages
+
+
+          let(:expected_contents) { expected_response.body[:contents].as_json }
+          let(:response) { interaction_context.last_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(:diff_options) { { with: differ, diff_formatter: diff_formatter } }
+          let(:diff_content_type) { 'application/json' }
+          let(:response_body) { parse_body_from_response(response) }
+          let(:actual_contents) { response_body['contents'] }
+
+          it "has matching content" do | example |
+            if response.status != 200
+              raise "An error was raised while verifying the message. The response body is: #{response.body}"
+            end
+            set_metadata(example, :pact_actual_contents, actual_contents)
+            expect(actual_contents).to match_term expected_contents, diff_options, example
+          end
+        end
+
+        def describe_response expected_response, interaction_context
+
+          describe "returns a response which" do
+
+            include Pact::RSpec::Matchers
+            extend Pact::Matchers::Messages
+
+            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 | example |
+                set_metadata(example, :pact_actual_status, response_status)
+                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}\" which #{expected_desc_for_it(expected_header_value)}" do  | example |
+                    set_metadata(example, :pact_actual_headers, response.headers)
+                    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 | example |
+                set_metadata(example, :pact_actual_body, response_body)
+                expect(response_body).to match_term expected_response_body, diff_options, example
+              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
+      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,180 @@
+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('.'))
+        provider_states[fullname]
+      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 = {}
+        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 params = {}
+        if @set_up_block
+          include_provider_state_configured_modules
+          instance_exec params, &@set_up_block
+        end
+      end
+
+      def tear_down params = {}
+        if @tear_down_block
+          include_provider_state_configured_modules
+          instance_exec params, &@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 params = {}
+
+      end
+
+      def self.tear_down params = {}
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'rspec/mocks'
+
+module Pact
+  module Provider
+    module State
+      module ProviderStateConfiguredModules
+
+        include ::RSpec::Mocks::ExampleMethods
+
+        # Placeholder for modules configured using config.include
+
+      end
+    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, :params, :consumer
+
+      def initialize provider_state_name, params, consumer
+        @provider_state_name = provider_state_name
+        @params = params
+        @consumer = consumer
+      end
+
+      def set_up_provider_state
+        get_global_base_provider_state.set_up(params)
+        get_consumer_base_provider_state.set_up(params)
+        if provider_state_name
+          get_provider_state.set_up(params)
+        end
+      end
+
+      def tear_down_provider_state
+        if provider_state_name
+          get_provider_state.tear_down(params)
+        end
+        get_consumer_base_provider_state.tear_down(params)
+        get_global_base_provider_state.tear_down(params)
+      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/state/set_up.rb

@@ -0,0 +1,13 @@
+require 'pact/provider/state/provider_state_manager'
+
+module Pact
+  module Provider
+    module State
+      class SetUp
+        def self.call provider_state_name, consumer, options = {}
+          State::ProviderStateManager.new(provider_state_name, options[:params], consumer).set_up_provider_state
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+require 'pact/provider/state/provider_state_manager'
+
+module Pact
+  module Provider
+    module State
+      class TearDown
+        def self.call provider_state_name, consumer, options = {}
+          State::ProviderStateManager.new(provider_state_name, options[:params], consumer).tear_down_provider_state
+        end
+      end
+    end
+  end
+end

data/lib/pact/provider/test_methods.rb

@@ -0,0 +1,77 @@
+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_customizer = nil, state_params = nil
+        request = Request::Replayable.new(interaction.request, state_params)
+        request = request_customizer.call(request, interaction) if request_customizer
+        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 = if self.respond_to?(:custom_request)
+          self.custom_request(request.method.upcase, *args)
+        else
+          self.send(request.method.downcase, *args)
+        end
+        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/
+          # For https://github.com/pact-foundation/pact-net/issues/237
+          # Only required for the pact-ruby-standalone ¯\_(ツ)_/¯
+          JSON.load("[#{rack_response.body}]").first
+        else
+          rack_response.body
+        end
+      end
+
+      def set_up_provider_states provider_states, consumer, options = {}
+        provider_states_result = {};
+        # If there are no provider state, execute with an nil state to ensure global and base states are executed
+        Pact.configuration.provider_state_set_up.call(nil, consumer, options) if provider_states.nil? || provider_states.empty?
+        provider_states.each do | provider_state |
+          result = Pact.configuration.provider_state_set_up.call(provider_state.name, consumer, options.merge(params: provider_state.params))
+          if result.is_a?(Hash)
+            provider_states_result[provider_state.name] = result
+          end
+        end
+
+        provider_states_result
+      end
+
+      def tear_down_provider_states provider_states, consumer, options = {}
+        # If there are no provider state, execute with an nil state to ensure global and base states are executed
+        Pact.configuration.provider_state_tear_down.call(nil, consumer, options) if provider_states.nil? || provider_states.empty?
+        provider_states.reverse_each do | provider_state |
+          Pact.configuration.provider_state_tear_down.call(provider_state.name, consumer, options.merge(params: provider_state.params))
+        end
+      end
+
+      def set_metadata example, key, value
+        Pact::RSpec.with_rspec_3 do
+          example.metadata[key] = value
+        end
+
+        Pact::RSpec.with_rspec_2 do
+          example.example.metadata[key] = value
+        end
+      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