pact-v2 2.0.0.pre.preview1

data/lib/pact/utils/metrics.rb

@@ -0,0 +1,100 @@
+require 'securerandom'
+require 'digest'
+require 'socket'
+require 'pact/version'
+require 'net/http'
+
+module Pact
+  module Utils
+    class Metrics
+
+      def self.report_metric(event, category, action, value = 1)
+        do_once_per_thread(:pact_metrics_message_shown) do
+          if track_events?
+            Pact.configuration.output_stream.puts "pact WARN: Please note: we are tracking events anonymously to gather important usage statistics like Pact-Ruby version
+              and operating system. To disable tracking, set the 'PACT_DO_NOT_TRACK' environment
+              variable to 'true'."
+          end
+        end
+
+        in_thread do
+          begin
+            if track_events?
+              uri = URI('https://www.google-analytics.com/collect')
+              req = Net::HTTP::Post.new(uri)
+              req.set_form_data(create_tracking_event(event, category, action, value))
+
+              Net::HTTP.start(uri.hostname, uri.port, read_timeout:2, open_timeout:2, :use_ssl => true  ) do |http|
+                http.request(req)
+              end
+            end
+          rescue StandardError => e
+            handle_error(e)
+          end
+        end
+      end
+
+      private
+
+      def self.handle_error e
+        if ENV['PACT_METRICS_DEBUG'] == 'true'
+          Pact.configuration.output_stream.puts("DEBUG: #{e.inspect}\n" + e.backtrace.join("\n"))
+        end
+      end
+
+      def self.in_thread
+        Thread.new do
+          yield
+        end
+      end
+
+      # not super safe to use the thread, but it's good enough for this usecase
+      def self.do_once_per_thread(key)
+        result = nil
+        if !Thread.current[key]
+          result = yield
+        end
+        Thread.current[key] = true
+        result
+      end
+
+      def self.create_tracking_event(event, category, action, value)
+        {
+          "v" => 1,
+          "t" => "event",
+          "tid" => "UA-117778936-1",
+          "cid" => calculate_cid,
+          "an" => "Pact Ruby",
+          "av" => Pact::VERSION,
+          "aid" => "pact-ruby",
+          "aip" => 1,
+          "ds" => ENV['PACT_EXECUTING_LANGUAGE'] ? "client" : "cli",
+          "cd2" => ENV['CI'] == "true" ? "CI" : "unknown",
+          "cd3" => RUBY_PLATFORM,
+          "cd6" => ENV['PACT_EXECUTING_LANGUAGE'] || "unknown",
+          "cd7" => ENV['PACT_EXECUTING_LANGUAGE_VERSION'],
+          "el" => event,
+          "ec" => category,
+          "ea" => action,
+          "ev" => value
+        }
+      end
+
+      def self.track_events?
+        ENV['PACT_DO_NOT_TRACK'] != 'true'
+      end
+
+      def self.calculate_cid
+        if RUBY_PLATFORM.include? "windows"
+          hostname = ENV['COMPUTERNAME']
+        else
+          hostname = ENV['HOSTNAME']
+        end
+        if !hostname
+          hostname = Socket.gethostname
+        end
+        Digest::MD5.hexdigest hostname || SecureRandom.urlsafe_base64(5)
+      end
+    end
+  end
+end

data/lib/pact/utils/string.rb

@@ -0,0 +1,35 @@
+# Can't use refinements because of Travelling Ruby
+
+module Pact
+  module Utils
+    module String
+
+      extend self
+
+      # ripped from rubyworks/facets, thank you
+      def camelcase(string, *separators)
+        case separators.first
+        when Symbol, TrueClass, FalseClass, NilClass
+          first_letter = separators.shift
+        end
+
+        separators = ['_', '\s'] if separators.empty?
+
+        str = string.dup
+
+        separators.each do |s|
+          str = str.gsub(/(?:#{s}+)([a-z])/){ $1.upcase }
+        end
+
+        case first_letter
+        when :upper, true
+          str = str.gsub(/(\A|\s)([a-z])/){ $1 + $2.upcase }
+        when :lower, false
+          str = str.gsub(/(\A|\s)([A-Z])/){ $1 + $2.downcase }
+        end
+
+        str
+      end
+    end
+  end
+end

data/lib/pact/v2/configuration.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    class Configuration
+      attr_reader :before_provider_state_proc, :after_provider_state_proc
+
+      class GlobalProviderConfigurationError < ::Pact::V2::Error; end
+
+      def before_provider_state_setup(&block)
+        raise GlobalProviderConfigurationError, "no block given" unless block
+
+        @before_provider_state_proc = block
+      end
+
+      def after_provider_state_teardown(&block)
+        raise GlobalProviderConfigurationError, "no block given" unless block
+
+        @after_provider_state_proc = block
+      end
+    end
+  end
+end

data/lib/pact/v2/consumer/grpc_interaction_builder.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require "pact/ffi/sync_message_consumer"
+require "pact/ffi/plugin_consumer"
+require "pact/ffi/logger"
+
+module Pact
+  module V2
+    module Consumer
+      class GrpcInteractionBuilder
+        CONTENT_TYPE = "application/protobuf"
+        GRPC_CONTENT_TYPE = "application/grpc"
+        PROTOBUF_PLUGIN_NAME = "protobuf"
+        PROTOBUF_PLUGIN_VERSION = "0.6.5"
+
+        class PluginInitError < Pact::V2::FfiError; end
+
+        # https://docs.rs/pact_ffi/0.4.17/pact_ffi/plugins/fn.pactffi_using_plugin.html
+        INIT_PLUGIN_ERRORS = {
+          1 => {reason: :internal_error, status: 1, description: "A general panic was caught"},
+          2 => {reason: :plugin_load_failed, status: 2, description: "Failed to load the plugin"},
+          3 => {reason: :invalid_handle, status: 3, description: "Pact Handle is not valid"}
+        }.freeze
+
+        # https://docs.rs/pact_ffi/0.4.17/pact_ffi/plugins/fn.pactffi_interaction_contents.html
+        CREATE_INTERACTION_ERRORS = {
+          1 => {reason: :internal_error, status: 1, description: "A general panic was caught"},
+          2 => {reason: :mock_server_already_running, status: 2, description: "The mock server has already been started"},
+          3 => {reason: :invalid_handle, status: 3, description: "The interaction handle is invalid"},
+          4 => {reason: :invalid_content_type, status: 4, description: "The content type is not valid"},
+          5 => {reason: :invalid_contents, status: 5, description: "The contents JSON is not valid JSON"},
+          6 => {reason: :plugin_error, status: 6, description: "The plugin returned an error"}
+        }.freeze
+
+        class CreateInteractionError < Pact::V2::FfiError; end
+
+        class InteractionMismatchesError < Pact::V2::Error; end
+
+        class InteractionBuilderError < Pact::V2::Error; end
+
+        def initialize(pact_config, description: nil)
+          @pact_config = pact_config
+          @description = description || ""
+          @proto_path = nil
+          @proto_include_dirs = []
+          @service_name = nil
+          @method_name = nil
+          @request = nil
+          @response = nil
+          @response_meta = nil
+          @provider_state_meta = nil
+        end
+
+        def with_service(proto_path, method, include_dirs = [])
+          raise InteractionBuilderError.new("invalid grpc method: cannot be blank") if method.blank?
+
+          service_name, method_name = method.split("/") || []
+          raise InteractionBuilderError.new("invalid grpc method: #{method}, should be like service/SomeMethod") if service_name.blank? || method_name.blank?
+
+          absolute_path = File.expand_path(proto_path)
+          raise InteractionBuilderError.new("proto file #{proto_path} does not exist") unless File.exist?(absolute_path)
+
+          @proto_path = absolute_path
+          @service_name = service_name
+          @method_name = method_name
+          @proto_include_dirs = include_dirs.map { |dir| File.expand_path(dir) }
+
+          self
+        end
+
+        def given(provider_state, metadata = {})
+          @provider_state_meta = {provider_state => metadata}
+          self
+        end
+
+        def upon_receiving(description)
+          @description = description
+          self
+        end
+
+        def with_request(req_hash)
+          @request = InteractionContents.plugin(req_hash)
+          self
+        end
+
+        def will_respond_with(resp_hash)
+          @response = InteractionContents.plugin(resp_hash)
+          self
+        end
+
+        def will_respond_with_meta(meta_hash)
+          @response_meta = InteractionContents.plugin(meta_hash)
+          self
+        end
+
+        def interaction_json
+          result = {
+            "pact:proto": @proto_path,
+            "pact:proto-service": "#{@service_name}/#{@method_name}",
+            "pact:content-type": CONTENT_TYPE,
+            request: @request
+          }
+
+          result["pact:protobuf-config"] = {additionalIncludes: @proto_include_dirs} if @proto_include_dirs.present?
+
+          result[:response] = @response if @response.is_a?(Hash)
+          result[:responseMetadata] = @response_meta if @response_meta.is_a?(Hash)
+
+          JSON.dump(result)
+        end
+
+        def validate!
+          raise InteractionBuilderError.new("uninitialized service params, use #with_service to configure") if @proto_path.blank? || @service_name.blank? || @method_name.blank?
+          raise InteractionBuilderError.new("invalid request format, should be a hash") unless @request.is_a?(Hash)
+          raise InteractionBuilderError.new("invalid response format, should be a hash") unless @response.is_a?(Hash) || @response_meta.is_a?(Hash)
+        end
+
+        def execute(&block)
+          raise InteractionBuilderError.new("interaction is designed to be used one-time only") if defined?(@used)
+
+          validate!
+
+          pact_handle = init_pact
+          init_plugin!(pact_handle)
+
+          message_pact = PactFfi::SyncMessageConsumer.new_interaction(pact_handle, @description)
+          @provider_state_meta&.each_pair do |provider_state, meta|
+            if meta.present?
+              meta.each_pair { |k, v| PactFfi.given_with_param(message_pact, provider_state, k.to_s, v.to_s) }
+            else
+              PactFfi.given(message_pact, provider_state)
+            end
+          end
+
+          result = PactFfi::PluginConsumer.interaction_contents(message_pact, 0, GRPC_CONTENT_TYPE, interaction_json)
+          if CREATE_INTERACTION_ERRORS[result].present?
+            error = CREATE_INTERACTION_ERRORS[result]
+            raise CreateInteractionError.new("There was an error while trying to add interaction \"#{@description}\"", error[:reason], error[:status])
+          end
+
+          mock_server = MockServer.create_for_grpc!(pact: pact_handle, host: @pact_config.mock_host, port: @pact_config.mock_port)
+
+          yield(message_pact, mock_server)
+
+          if mock_server.matched?
+            mock_server.write_pacts!(@pact_config.pact_dir)
+          else
+            msg = mismatches_error_msg(mock_server)
+            raise InteractionMismatchesError.new(msg)
+          end
+        ensure
+          @used = true
+          mock_server&.cleanup
+          PactFfi::PluginConsumer.cleanup_plugins(pact_handle)
+          PactFfi.free_pact_handle(pact_handle)
+        end
+
+        private
+
+        def mismatches_error_msg(mock_server)
+          rspec_example_desc = RSpec.current_example&.description
+          return "interaction for #{@service_name}/#{@method_name} has mismatches: #{mock_server.mismatches}" if rspec_example_desc.blank?
+
+          "#{rspec_example_desc} has mismatches: #{mock_server.mismatches}"
+        end
+
+        def init_pact
+          handle = PactFfi.new_pact(@pact_config.consumer_name, @pact_config.provider_name)
+          PactFfi.with_specification(handle, PactFfi::FfiSpecificationVersion["SPECIFICATION_VERSION_V4"])
+          PactFfi.with_pact_metadata(handle, "pact-ruby-v2", "pact-ffi", PactFfi.version)
+
+          Pact::V2::Native::Logger.log_to_stdout(@pact_config.log_level)
+
+          handle
+        end
+
+        def init_plugin!(pact_handle)
+          result = PactFfi::PluginConsumer.using_plugin(pact_handle, PROTOBUF_PLUGIN_NAME, PROTOBUF_PLUGIN_VERSION)
+          return result if INIT_PLUGIN_ERRORS[result].blank?
+
+          error = INIT_PLUGIN_ERRORS[result]
+          raise PluginInitError.new("There was an error while trying to initialize plugin #{PROTOBUF_PLUGIN_NAME}/#{PROTOBUF_PLUGIN_VERSION}", error[:reason], error[:status])
+        end
+      end
+    end
+  end
+end

data/lib/pact/v2/consumer/http_interaction_builder.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "pact/ffi/sync_message_consumer"
+require "pact/ffi/plugin_consumer"
+require "pact/ffi/logger"
+require "json"
+
+module Pact
+  module V2
+    module Consumer
+      class HttpInteractionBuilder
+        DESCRIPTION_PREFIX = "http: "
+
+        # https://docs.rs/pact_ffi/0.4.17/pact_ffi/plugins/fn.pactffi_interaction_contents.html
+        CREATE_INTERACTION_ERRORS = {
+          1 => {reason: :internal_error, status: 1, description: "A general panic was caught"},
+          2 => {reason: :mock_server_already_running, status: 2, description: "The mock server has already been started"},
+          3 => {reason: :invalid_handle, status: 3, description: "The interaction handle is invalid"},
+          4 => {reason: :invalid_content_type, status: 4, description: "The content type is not valid"},
+          5 => {reason: :invalid_contents, status: 5, description: "The contents JSON is not valid JSON"},
+          6 => {reason: :plugin_error, status: 6, description: "The plugin returned an error"}
+        }.freeze
+
+        class CreateInteractionError < Pact::V2::FfiError; end
+
+        class InteractionMismatchesError < Pact::V2::Error; end
+
+        class InteractionBuilderError < Pact::V2::Error; end
+
+        class << self
+          def create_finalizer(pact_handle)
+            proc { PactFfi.free_pact_handle(pact_handle) }
+          end
+        end
+
+        def initialize(pact_config, description: nil)
+          @pact_config = pact_config
+          @description = description || ""
+
+          @pact_handle = pact_config.pact_handle ||= init_pact
+          @pact_interaction = PactFfi.new_interaction(pact_handle, @description)
+
+          ObjectSpace.define_finalizer(self, self.class.create_finalizer(pact_interaction))
+        end
+
+        def given(provider_state, metadata = {})
+          if metadata.present?
+            PactFfi.given_with_params(pact_interaction, provider_state, JSON.dump(metadata))
+          else
+            PactFfi.given(pact_interaction, provider_state)
+          end
+
+          self
+        end
+
+        def upon_receiving(description)
+          @description = description
+          PactFfi.upon_receiving(pact_interaction, @description)
+          self
+        end
+
+        def with_request(method: nil, path: nil, query: {}, headers: {}, body: nil)
+          interaction_part = PactFfi::FfiInteractionPart["INTERACTION_PART_REQUEST"]
+          PactFfi.with_request(pact_interaction, method.to_s, format_value(path))
+
+          # Processing as an array of hashes, allows us to consider duplicate keys
+          # which should be passed to the core, at a non 0 index
+          if query.is_a?(Array)
+            key_index = Hash.new(0)
+            query.each do |query_item|
+              InteractionContents.basic(query_item).each_pair do |key, value_item|
+                PactFfi.with_query_parameter_v2(pact_interaction, key.to_s, key_index[key], format_value(value_item))
+                key_index[key] += 1
+              end
+            end
+          else
+            InteractionContents.basic(query).each_pair do |key, value_item|
+              PactFfi.with_query_parameter_v2(pact_interaction, key.to_s, 0, format_value(value_item))
+            end
+          end
+
+          InteractionContents.basic(headers).each_pair do |key, value_item|
+            PactFfi.with_header_v2(pact_interaction, interaction_part, key.to_s, 0, format_value(value_item))
+          end
+
+          if body
+            PactFfi.with_body(pact_interaction, interaction_part, "application/json", format_value(InteractionContents.basic(body)))
+          end
+
+          self
+        end
+
+        def will_respond_with(status: nil, headers: {}, body: nil)
+          interaction_part = PactFfi::FfiInteractionPart["INTERACTION_PART_RESPONSE"]
+          PactFfi.response_status(pact_interaction, status)
+
+          InteractionContents.basic(headers).each_pair do |key, value_item|
+            PactFfi.with_header_v2(pact_interaction, interaction_part, key.to_s, 0, format_value(value_item))
+          end
+
+          if body
+            PactFfi.with_body(pact_interaction, interaction_part, "application/json", format_value(InteractionContents.basic(body)))
+          end
+
+          self
+        end
+
+        def execute(&block)
+          raise InteractionBuilderError.new("interaction is designed to be used one-time only") if defined?(@used)
+
+          mock_server = MockServer.create_for_http!(
+            pact: pact_handle, host: pact_config.mock_host, port: pact_config.mock_port
+          )
+
+          yield(mock_server)
+
+          if mock_server.matched?
+            mock_server.write_pacts!(pact_config.pact_dir)
+          else
+            msg = mismatches_error_msg(mock_server)
+            raise InteractionMismatchesError.new(msg)
+          end
+        ensure
+          @used = true
+          mock_server&.cleanup
+          # Reset the pact handle to allow for a new interaction to be built
+          # without previous interactions being included
+          @pact_config.reset_pact
+        end
+
+        private
+
+        attr_reader :pact_handle, :pact_interaction, :pact_config
+
+        def mismatches_error_msg(mock_server)
+          rspec_example_desc = RSpec.current_example&.description
+          mismatches = JSON.pretty_generate(JSON.parse(mock_server.mismatches))
+          mismatches_with_colored_keys = mismatches.gsub(/"([^"]+)":/) { |match| "\e[34m#{match}\e[0m" } # Blue keys / white values
+
+          "#{rspec_example_desc} has mismatches: #{mismatches_with_colored_keys}"
+        end
+
+        def init_pact
+          handle = PactFfi.new_pact(pact_config.consumer_name, pact_config.provider_name)
+          PactFfi.with_specification(handle, PactFfi::FfiSpecificationVersion["SPECIFICATION_VERSION_#{pact_config.pact_specification}"])
+          PactFfi.with_pact_metadata(handle, "pact-ruby-v2", "pact-ffi", PactFfi.version)
+
+          Pact::V2::Native::Logger.log_to_stdout(pact_config.log_level)
+
+          handle
+        end
+
+        def format_value(obj)
+          return obj if obj.is_a?(String)
+
+          return JSON.dump({value: obj}) if obj.is_a?(Array)
+
+          JSON.dump(obj)
+        end
+      end
+    end
+  end
+end

data/lib/pact/v2/consumer/interaction_contents.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Consumer
+      class InteractionContents < Hash
+        BASIC_FORMAT = :basic
+        PLUGIN_FORMAT = :plugin
+
+        attr_reader :format
+
+        def self.basic(contents_hash)
+          new(contents_hash, BASIC_FORMAT)
+        end
+
+        def self.plugin(contents_hash)
+          new(contents_hash, PLUGIN_FORMAT)
+        end
+
+        def initialize(contents_hash, format)
+          init_hash(contents_hash, format).each_pair { |k, v| self[k] = v }
+          @format = format
+        end
+
+        private
+
+        def serialize(hash, format)
+          # serialize recursively
+          if hash.is_a?(String)
+            return hash
+          end
+          if hash.is_a?(Pact::V2::Matchers::Base)
+            return hash.as_basic if format == :basic
+            return hash.as_plugin if format == :plugin
+          end
+          hash.each_pair do |key, value|
+            next serialize(value, format) if value.is_a?(Hash)
+            next hash[key] = value.map { |v| serialize(v, format) } if value.is_a?(Array)
+            if value.is_a?(Pact::V2::Matchers::Base)
+              hash[key] = value.as_basic if format == :basic
+              hash[key] = value.as_plugin if format == :plugin
+            end
+          end
+
+          hash
+        end
+
+        def init_hash(hash, format)
+          serialize(hash.deep_dup, format)
+        end
+      end
+    end
+  end
+end