pact-v2 2.0.0.pre.preview1

data/lib/pact/provider/verification_results/create.rb

@@ -0,0 +1,88 @@
+require 'pact/provider/verification_results/verification_result'
+module Pact
+  module Provider
+    module VerificationResults
+      class Create
+
+        def self.call pact_source, test_results_hash
+          new(pact_source, test_results_hash).call
+        end
+
+        def initialize pact_source, test_results_hash
+          @pact_source = pact_source
+          @test_results_hash = test_results_hash
+        end
+
+        def call
+          VerificationResult.new(
+            publishable?,
+            !any_failures?,
+            Pact.configuration.provider.application_version,
+            test_results_hash_for_pact_uri,
+            Pact.configuration.provider.build_url
+          )
+        end
+
+        private
+
+        def pact_uri
+          @pact_uri ||= pact_source.uri
+        end
+
+        def any_failures?
+          count_failures_for_pact_uri > 0
+        end
+
+        def publishable?
+          if defined?(@publishable)
+            @publishable
+          else
+            @publishable = pact_source.consumer_contract.interactions.all? do | interaction |
+              examples_for_pact_uri.any?{ |e| example_is_for_interaction?(e, interaction) }
+            end && examples_for_pact_uri.count > 0
+          end
+        end
+
+        def example_is_for_interaction?(example, interaction)
+          # Use the Pact Broker id if supported
+          if interaction._id
+            example[:pact_interaction]._id == interaction._id
+          else
+            # fall back to object equality (based on the field values of the interaction)
+            example[:pact_interaction] == interaction
+          end
+        end
+
+        def examples_for_pact_uri
+          @examples_for_pact_uri ||= test_results_hash[:tests].select{ |e| e[:pact_uri] == pact_uri }
+        end
+
+        def count_failures_for_pact_uri
+          examples_for_pact_uri.count{ |e| e[:status] != 'passed' }
+        end
+
+        def test_results_hash_for_pact_uri
+          {
+            tests: examples_for_pact_uri.collect{ |e| clean_example(e) },
+            summary: {
+              testCount: examples_for_pact_uri.size,
+              failureCount: count_failures_for_pact_uri
+            },
+            metadata: {
+              warning: "These test results use a beta format. Do not rely on it, as it will definitely change.",
+              pactVerificationResultsSpecification: {
+                version: "1.0.0-beta.1"
+              }
+            }
+          }
+        end
+
+        def clean_example(example)
+          example.reject{ |k, v| k == :pact_uri || k == :pact_interaction }
+        end
+
+        attr_reader :pact_source, :test_results_hash
+      end
+    end
+  end
+end

data/lib/pact/provider/verification_results/publish.rb

@@ -0,0 +1,143 @@
+require 'json'
+require 'pact/errors'
+require 'pact/retry'
+require 'pact/hal/entity'
+require 'pact/hal/http_client'
+
+# TODO move this to the pact broker client
+
+module Pact
+  module Provider
+    module VerificationResults
+      class PublicationError < Pact::Error; end
+
+      class Publish
+
+        PUBLISH_RELATION = 'pb:publish-verification-results'.freeze
+        PROVIDER_RELATION = 'pb:provider'.freeze
+        VERSION_TAG_RELATION = 'pb:version-tag'.freeze
+        BRANCH_VERSION_RELATION = 'pb:branch-version'.freeze
+
+        def self.call pact_source, verification_result, options = {}
+          new(pact_source, verification_result, options).call
+        end
+
+        def initialize pact_source, verification_result, options = {}
+          @pact_source = pact_source
+          @verification_result = verification_result
+          http_client_options = pact_source.uri.options.reject{ |k, v| ![:username, :password, :token].include?(k) }
+          @http_client = Pact::Hal::HttpClient.new(http_client_options.merge(verbose: options[:verbose]))
+          @pact_entity = Pact::Hal::Entity.new(pact_source.uri, pact_source.pact_hash, http_client)
+        end
+
+        def call
+          if can_publish_verification_results?
+            create_branch_version_if_configured
+            tag_versions_if_configured
+            publish_verification_results
+            true
+          else
+            false
+          end
+        end
+
+        private
+        attr_reader :pact_source, :verification_result, :pact_entity, :http_client
+
+        def can_publish_verification_results?
+          return false unless Pact.configuration.provider.publish_verification_results?
+
+          if !pact_entity.can?(PUBLISH_RELATION)
+            Pact.configuration.error_stream.puts "WARN: Cannot publish verification for #{consumer_name} as there is no link named pb:publish-verification-results in the pact JSON. If you are using a pact broker, please upgrade to version 2.0.0 or later."
+            return false
+          end
+
+          if !verification_result.publishable?
+            Pact.configuration.error_stream.puts "WARN: Cannot publish verification for #{consumer_name} as not all interactions have been verified. Re-run the verification without the filter parameters or environment variables to publish the verification."
+            return false
+          end
+          true
+        end
+
+        def hacky_tag_url provider_entity
+          hacky_tag_url = provider_entity._link('self').href + "/versions/{version}/tags/{tag}"
+          Pact::Hal::Link.new('href' => hacky_tag_url)
+        end
+
+        def tag_versions_if_configured
+          if Pact.configuration.provider.tags.any?
+            if pact_entity.can?(PROVIDER_RELATION)
+              tag_versions
+            else
+              Pact.configuration.error_stream.puts "WARN: Could not tag provider version as the pb:provider link cannot be found"
+            end
+          end
+        end
+
+        def create_branch_version_if_configured
+          if Pact.configuration.provider.branch
+            branch_version_link = provider_entity._link(BRANCH_VERSION_RELATION)
+            if branch_version_link
+              version_number = Pact.configuration.provider.application_version
+              branch = Pact.configuration.provider.branch
+
+              Pact.configuration.output_stream.puts "INFO: Creating #{provider_name} version #{version_number} with branch \"#{branch}\""
+              branch_entity = branch_version_link.expand(
+                version: version_number,
+                branch: branch
+              ).put
+              unless branch_entity.success?
+                raise PublicationError.new("Error returned from tagging request: status=#{branch_entity.response.code} body=#{branch_entity.response.body}")
+              end
+            else
+              raise PublicationError.new("This version of the Pact Broker does not support version branches. Please update to version 2.58.0 or later.")
+            end
+          end
+        end
+
+        def tag_versions
+          tag_link = provider_entity._link(VERSION_TAG_RELATION) || hacky_tag_url(provider_entity)
+          provider_application_version = Pact.configuration.provider.application_version
+
+          Pact.configuration.provider.tags.each do | tag |
+            Pact.configuration.output_stream.puts "INFO: Tagging version #{provider_application_version} of #{provider_name} as #{tag.inspect}"
+            tag_entity = tag_link.expand(version: provider_application_version, tag: tag).put
+            unless tag_entity.success?
+              raise PublicationError.new("Error returned from tagging request: status=#{tag_entity.response.code} body=#{tag_entity.response.body}")
+            end
+          end
+        end
+
+        def publish_verification_results
+          verification_entity = nil
+          begin
+            # The verifications resource didn't have the content_types_provided set correctly, so publishing fails if we don't have */*
+            verification_entity = pact_entity.post(PUBLISH_RELATION, verification_result, { "Accept" => "application/hal+json, */*" })
+          rescue StandardError => e
+            error_message = "Failed to publish verification results due to: #{e.class} #{e.message} #{e.backtrace.join("\n")}"
+            raise PublicationError.new(error_message)
+          end
+
+          if verification_entity.success?
+            new_resource_url = verification_entity._link('self').href
+            Pact.configuration.output_stream.puts "INFO: Verification results published to #{new_resource_url}"
+          else
+            raise PublicationError.new("Error returned from verification results publication #{verification_entity.response.code} #{verification_entity.response.body}")
+          end
+        end
+
+        def consumer_name
+          pact_source.pact_hash['consumer']['name']
+        end
+
+        def provider_name
+          pact_source.pact_hash['provider']['name']
+        end
+
+        def provider_entity
+          @provider_entity ||= pact_entity.get!(PROVIDER_RELATION)
+        end
+      end
+    end
+  end
+end

data/lib/pact/provider/verification_results/publish_all.rb

@@ -0,0 +1,50 @@
+require'pact/provider/verification_results/create'
+require'pact/provider/verification_results/publish'
+
+module Pact
+  module Provider
+    module VerificationResults
+      class PublishAll
+
+        def self.call pact_sources, test_results_hash, options = {}
+          new(pact_sources, test_results_hash, options).call
+        end
+
+        def initialize pact_sources, test_results_hash, options = {}
+          @pact_sources = pact_sources
+          @test_results_hash = test_results_hash
+          @options = options
+        end
+
+        def call
+          verification_results.collect do | (pact_source, verification_result) |
+            published = false
+            begin
+              published = Publish.call(pact_source, verification_result, { verbose: options[:verbose] })
+            ensure
+              print_after_verification_notices(pact_source, verification_result, published)
+            end
+          end
+        end
+
+        private
+
+        def verification_results
+          pact_sources.collect do | pact_source |
+            [pact_source, Create.call(pact_source, test_results_hash)]
+          end
+        end
+
+        def print_after_verification_notices(pact_source, verification_result, published)
+          if pact_source.uri.metadata[:notices]
+            pact_source.uri.metadata[:notices].after_verification_notices_text(verification_result.success, published).each do | text |
+              Pact.configuration.output_stream.puts "DEBUG: #{text}"
+            end
+          end
+        end
+
+        attr_reader :pact_sources, :test_results_hash, :options
+      end
+    end
+  end
+end

data/lib/pact/provider/verification_results/verification_result.rb

@@ -0,0 +1,40 @@
+require 'json'
+
+module Pact
+  module Provider
+    module VerificationResults
+      class VerificationResult
+        attr_reader :success, :provider_application_version, :test_results_hash
+
+        def initialize publishable, success, provider_application_version, test_results_hash, build_url
+          @publishable = publishable
+          @success = success
+          @provider_application_version = provider_application_version
+          @test_results_hash = test_results_hash
+          @build_url = build_url
+        end
+
+        def publishable?
+          @publishable
+        end
+
+        def provider_application_version_set?
+          !!provider_application_version
+        end
+
+        def to_json(options = {})
+          {
+            success: success,
+            providerApplicationVersion: provider_application_version,
+            testResults: test_results_hash,
+            buildUrl: @build_url
+          }.to_json(options)
+        end
+
+        def to_s
+          "[success: #{success}, providerApplicationVersion: #{provider_application_version}]"
+        end
+      end
+    end
+  end
+end

data/lib/pact/provider/world.rb

@@ -0,0 +1,50 @@
+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
+
+      attr_accessor :pact_sources, :failed_examples, :verbose
+
+      def provider_states
+        @provider_states_proxy ||= Pact::Provider::State::ProviderStateProxy.new
+      end
+
+      def add_pact_verification verification
+        pact_verifications << verification
+      end
+
+      def pact_verifications
+        @pact_verifications ||= []
+      end
+
+      def pact_urls
+        (pact_verifications.collect(&:uri) + pact_uris_from_pact_uri_sources).compact
+      end
+
+      def add_pact_uri_source pact_uri_source
+        pact_uri_sources << pact_uri_source
+      end
+
+      private
+
+      def pact_uri_sources
+        @pact_uri_sources ||= []
+      end
+
+      def pact_uris_from_pact_uri_sources
+        pact_uri_sources.collect(&:call).flatten
+      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/retry.rb

@@ -0,0 +1,37 @@
+require 'pact/errors'
+
+module Pact
+  class Retry
+    class RescuableError
+      UNRESCUEABLE = [Pact::Error]
+
+      def self.===(e)
+        case e
+          when *UNRESCUEABLE then
+            false
+          else
+            true
+        end
+      end
+    end
+
+    def self.until_true options = {}
+      max_tries = options.fetch(:times, 3)
+      tries = 0
+      while true
+        begin
+          return yield
+        rescue RescuableError => e
+          tries += 1
+          $stderr.puts "Error making request - #{e.class} #{e.message} #{e.backtrace.find {|l| l.include?('pact_provider')}}, attempt #{tries} of #{max_tries}"
+          raise e if max_tries == tries
+          sleep options
+        end
+      end
+    end
+
+    def self.sleep options
+      Kernel.sleep options.fetch(:sleep, 5)
+    end
+  end
+end

data/lib/pact/tasks/task_helper.rb

@@ -0,0 +1,62 @@
+require 'pact/configuration'
+require 'pact/provider/pact_helper_locator'
+require 'rake/file_utils'
+require 'shellwords'
+
+module Pact
+  module TaskHelper
+
+    PACT_INTERACTION_RERUN_COMMAND = "bundle exec rake pact:verify:at[<PACT_URI>] PACT_DESCRIPTION=\"<PACT_DESCRIPTION>\" PACT_PROVIDER_STATE=\"<PACT_PROVIDER_STATE>\""
+    PACT_INTERACTION_RERUN_COMMAND_FOR_BROKER = "bundle exec rake pact:verify:at[<PACT_URI>] PACT_BROKER_INTERACTION_ID=\"<PACT_BROKER_INTERACTION_ID>\""
+
+    extend self
+
+    def execute_pact_verify pact_uri = nil, pact_helper = nil, rspec_opts = nil, verification_opts = {}
+      execute_cmd verify_command(pact_helper || Pact::Provider::PactHelperLocater.pact_helper_path, pact_uri, rspec_opts, verification_opts)
+    end
+
+    def handle_verification_failure
+      exit_status = yield
+      abort if exit_status != 0
+    end
+
+    def verify_command pact_helper, pact_uri, rspec_opts, verification_opts
+      command_parts = []
+      # Clear SPEC_OPTS, otherwise we can get extra formatters, creating duplicate output eg. CI Reporting.
+      # Allow deliberate configuration using rspec_opts in VerificationTask.
+      command_parts << "SPEC_OPTS=#{Shellwords.escape(rspec_opts || '')}"
+      command_parts << FileUtils::RUBY
+      command_parts << "-S pact verify"
+      command_parts << "--pact-helper" << Shellwords.escape(pact_helper.end_with?(".rb") ? pact_helper : pact_helper + ".rb")
+      (command_parts << "--pact-uri" << pact_uri) if pact_uri
+      command_parts << "--ignore-failures" if verification_opts[:ignore_failures]
+      command_parts << "--pact-broker-username" << ENV['PACT_BROKER_USERNAME'] if ENV['PACT_BROKER_USERNAME']
+      command_parts << "--pact-broker-password" << ENV['PACT_BROKER_PASSWORD'] if ENV['PACT_BROKER_PASSWORD']
+      command_parts << "--backtrace" if ENV['BACKTRACE'] == 'true'
+      command_parts << "--description #{Shellwords.escape(ENV['PACT_DESCRIPTION'])}" if ENV['PACT_DESCRIPTION']
+      command_parts << "--provider-state #{Shellwords.escape(ENV['PACT_PROVIDER_STATE'])}" if ENV['PACT_PROVIDER_STATE']
+      command_parts << "--pact-broker-interaction-id #{Shellwords.escape(ENV['PACT_BROKER_INTERACTION_ID'])}" if ENV['PACT_BROKER_INTERACTION_ID']
+      command_parts << "--interaction-index #{Shellwords.escape(ENV['PACT_INTERACTION_INDEX'])}" if ENV['PACT_INTERACTION_INDEX']
+      command_parts.flatten.join(" ")
+    end
+
+    def execute_cmd command
+      Pact.configuration.output_stream.puts command
+      temporarily_set_env_var 'PACT_EXECUTING_LANGUAGE', 'ruby' do
+        temporarily_set_env_var 'PACT_INTERACTION_RERUN_COMMAND', PACT_INTERACTION_RERUN_COMMAND do
+          temporarily_set_env_var 'PACT_INTERACTION_RERUN_COMMAND_FOR_BROKER', PACT_INTERACTION_RERUN_COMMAND_FOR_BROKER do
+            exit_status = system(command) ? 0 : 1
+          end
+        end
+      end
+    end
+
+    def temporarily_set_env_var name, value
+      original_value = ENV[name]
+      ENV[name] ||= value
+      yield
+    ensure
+      ENV[name] = original_value
+    end
+  end
+end

data/lib/pact/tasks/verification_task.rb

@@ -0,0 +1,95 @@
+require 'rake/tasklib'
+
+=begin
+  To create a rake pact:verify:<something> task
+
+  Pact::VerificationTask.new(:head) do | pact |
+    pact.uri 'http://master.cd.vpc.realestate.com.au/browse/BIQ-MAS/latestSuccessful/artifact/JOB2/Pacts/mas-contract_transaction_service.json'
+     pact.uri 'http://master.cd.vpc.realestate.com.au/browse/BIQ-IMAGINARY-CONSUMER/latestSuccessful/artifact/JOB2/Pacts/imaginary_consumer-contract_transaction_service.json'
+  end
+
+  The pact.uri may be a local file system path or a remote URL.
+
+  To run a pact:verify:xxx task you need to define a pact_helper.rb, ideally in spec/service_consumers.
+  It should contain your service_provider definition, and load any provider state definition files.
+  It should also load all your app's dependencies (eg by calling out to spec_helper)
+
+  Eg.
+
+  require 'spec_helper'
+  require 'provider_states_for_my_consumer'
+
+  Pact.service_provider "My Provider" do
+    app { TestApp.new }
+  end
+
+=end
+
+module Pact
+  class VerificationTask < ::Rake::TaskLib
+
+    attr_reader :pact_spec_configs
+    attr_accessor :rspec_opts
+    attr_accessor :ignore_failures
+    attr_accessor :_pact_helper
+
+    def initialize(name)
+      @rspec_opts = nil
+      @ignore_failures = false
+      @pact_spec_configs = []
+      @name = name
+      yield self
+      rake_task
+    end
+
+    def pact_helper(pact_helper)
+      @pact_spec_configs << { pact_helper: pact_helper }
+    end
+
+    def uri(uri, options = {})
+      @pact_spec_configs << {uri: uri, pact_helper: options[:pact_helper]}
+    end
+
+    private
+
+    attr_reader :name
+
+    # def parse_pactfile config
+    #   Pact::ConsumerContract.from_uri config[:uri]
+    # end
+
+    # def publish_report config, output, result, provider_ref, reports_dir
+    #   consumer_contract = parse_pactfile config
+    #   #TODO - when checking out a historical version, provider ref will be prod, however it will think it is head. Fix this!!!!
+    #   report = Provider::VerificationReport.new(
+    #     :result => result,
+    #     :output => output,
+    #     :consumer => {:name => consumer_contract.consumer.name, :ref => name},
+    #     :provider => {:name => consumer_contract.provider.name, :ref => provider_ref}
+    #   )
+
+    #   FileUtils.mkdir_p reports_dir
+    #   File.open("#{reports_dir}/#{report.report_file_name}", "w") { |file| file << JSON.pretty_generate(report) }
+    # end
+
+    def rake_task
+      namespace :pact do
+
+        desc "Verify provider against the consumer pacts for #{name}"
+        task "verify:#{name}" do |t, args|
+
+          require 'pact/tasks/task_helper'
+
+          exit_statuses = pact_spec_configs.collect do | config |
+            Pact::TaskHelper.execute_pact_verify config[:uri], config[:pact_helper], rspec_opts, { ignore_failures: ignore_failures }
+          end
+
+          Pact::TaskHelper.handle_verification_failure do
+            exit_statuses.count{ | status | status != 0 }
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/pact/tasks.rb

@@ -0,0 +1,2 @@
+load File.expand_path('../tasks/pact.rake', File.dirname(__FILE__))
+require 'pact/tasks/verification_task'

data/lib/pact/templates/help.erb

@@ -0,0 +1,22 @@
+# For assistance debugging failures
+
+* The pact files have been stored locally in the following temp directory:
+    <%= temp_dir %>
+
+* The requests and responses are logged in the following log file:
+    <%= log_path %>
+
+* Add BACKTRACE=true to the `rake pact:verify` command to see the full backtrace
+
+* If the diff output is confusing, try using another diff formatter.
+  The options are :unix, :embedded and :list
+
+    Pact.configure do | config |
+      config.diff_formatter = :embedded
+    end
+
+  See https://github.com/pact-foundation/pact-ruby/blob/master/documentation/configuration.md#diff_formatter for examples and more information.
+
+* Check out https://github.com/pact-foundation/pact-ruby/wiki/Troubleshooting
+
+* Ask a question on stackoverflow and tag it `pact-ruby`

data/lib/pact/templates/provider_state.erb

@@ -0,0 +1,14 @@
+Could not find one or more provider states.
+Have you required the provider states file for this consumer in your pact_helper.rb?
+If you have not yet defined these states, here is a template:
+<% consumers.keys.each do | consumer_name | %>
+Pact.provider_states_for "<%= consumer_name %>" do
+<% consumers[consumer_name].each do | provider_state | %>
+  provider_state "<%= provider_state %>" do
+    set_up do
+      # Your set up code goes here
+    end
+  end
+<% end %>
+end
+<% end %>