sbmt-pact 0.12.0

data/lib/sbmt/pact/matchers.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Pact
+    module Matchers
+      PACT_SPEC_V1 = 1
+      PACT_SPEC_V2 = 2
+      PACT_SPEC_V3 = 3
+      PACT_SPEC_V4 = 4
+
+      ANY_STRING_REGEX = /.*/
+      UUID_REGEX = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i
+
+      # simplified
+      ISO8601_REGEX = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)*(.\d{2}:\d{2})*/i
+
+      def match_exactly(arg)
+        V1::Equality.new(arg)
+      end
+
+      def match_type_of(arg)
+        V2::Type.new(arg)
+      end
+
+      def match_include(arg)
+        V3::Include.new(arg)
+      end
+
+      def match_any_string(sample = "any")
+        V2::Regex.new(ANY_STRING_REGEX, sample)
+      end
+
+      def match_any_integer(sample = 10)
+        V3::Integer.new(sample)
+      end
+
+      def match_any_decimal(sample = 10.0)
+        V3::Decimal.new(sample)
+      end
+
+      def match_any_number(sample = 10.0)
+        V3::Number.new(sample)
+      end
+
+      def match_any_boolean(sample = true)
+        V3::Boolean.new(sample)
+      end
+
+      def match_uuid(sample = "e1d01e04-3a2b-4eed-a4fb-54f5cd257338")
+        V2::Regex.new(UUID_REGEX, sample)
+      end
+
+      def match_regex(regex, sample)
+        V2::Regex.new(regex, sample)
+      end
+
+      def match_datetime(format, sample)
+        V3::DateTime.new(format, sample)
+      end
+
+      def match_iso8601(sample = "2024-08-12T12:25:00.243118+03:00")
+        V2::Regex.new(ISO8601_REGEX, sample)
+      end
+
+      def match_date(format, sample)
+        V3::Date.new(format, sample)
+      end
+
+      def match_time(format, sample)
+        V3::Time.new(format, sample)
+      end
+
+      def match_each(template, min = nil)
+        V3::Each.new(template, min)
+      end
+
+      def match_each_regex(regex, sample)
+        match_each_value(sample, match_regex(regex, sample))
+      end
+
+      def match_each_key(template, key_matchers)
+        V4::EachKey.new(key_matchers.is_a?(Array) ? key_matchers : [key_matchers], template)
+      end
+
+      def match_each_value(template, value_matchers = V2::Type.new(""))
+        V4::EachValue.new(value_matchers.is_a?(Array) ? value_matchers : [value_matchers], template)
+      end
+
+      def match_each_kv(template, key_matchers)
+        V4::EachKeyValue.new(key_matchers.is_a?(Array) ? key_matchers : [key_matchers], template)
+      end
+    end
+  end
+end

data/lib/sbmt/pact/native/blocking_verifier.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "ffi"
+require "pact/ffi/verifier"
+
+module Sbmt
+  module Pact
+    module Native
+      module BlockingVerifier
+        extend FFI::Library
+        ffi_lib DetectOS.get_bin_path
+
+        attach_function :execute, :pactffi_verifier_execute, %i[pointer], :int32, blocking: true
+      end
+    end
+  end
+end

data/lib/sbmt/pact/native/logger.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "pact/ffi/logger"
+
+module Sbmt
+  module Pact
+    module Native
+      module Logger
+        LOG_LEVELS = {
+          off: PactFfi::FfiLogLevelFilter["LOG_LEVEL_OFF"],
+          error: PactFfi::FfiLogLevelFilter["LOG_LEVEL_ERROR"],
+          warn: PactFfi::FfiLogLevelFilter["LOG_LEVEL_WARN"],
+          info: PactFfi::FfiLogLevelFilter["LOG_LEVEL_INFO"],
+          debug: PactFfi::FfiLogLevelFilter["LOG_LEVEL_DEBUG"],
+          trace: PactFfi::FfiLogLevelFilter["LOG_LEVEL_TRACE"]
+        }.freeze
+
+        def self.log_to_stdout(log_level)
+          raise "invalid log level for PactFfi::FfiLogLevelFilter" unless LOG_LEVELS.key?(log_level)
+          PactFfi::Logger.log_to_stdout(LOG_LEVELS[log_level])
+        end
+      end
+    end
+  end
+end

data/lib/sbmt/pact/provider/async_message_verifier.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "pact/ffi/verifier"
+require "sbmt/pact/native/logger"
+
+module Sbmt
+  module Pact
+    module Provider
+      class AsyncMessageVerifier < BaseVerifier
+        PROVIDER_TRANSPORT_TYPE = "message"
+        INTERACTION_FILTER_REGEX = "^async:.+"
+
+        def initialize(pact_config)
+          super
+
+          raise ArgumentError, "pact_config must be an instance of Sbmt::Pact::Provider::PactConfig::Message" unless pact_config.is_a?(::Sbmt::Pact::Provider::PactConfig::Async)
+        end
+
+        private
+
+        def add_provider_transport(pact_handle)
+          setup_uri = URI(@pact_config.message_setup_url)
+          PactFfi::Verifier.add_provider_transport(pact_handle, PROVIDER_TRANSPORT_TYPE, setup_uri.port, setup_uri.path, "")
+        end
+
+        def set_filter_info(pact_handle)
+          PactFfi::Verifier.set_filter_info(pact_handle, INTERACTION_FILTER_REGEX, nil, 0)
+        end
+      end
+    end
+  end
+end

data/lib/sbmt/pact/provider/base_verifier.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "pact/ffi/verifier"
+require "sbmt/pact/native/logger"
+require "sbmt/pact/native/blocking_verifier"
+
+module Sbmt
+  module Pact
+    module Provider
+      class BaseVerifier
+        PROVIDER_TRANSPORT_TYPE = nil
+        attr_reader :logger
+
+        class VerificationError < Sbmt::Pact::FfiError; end
+
+        class VerifierError < Sbmt::Pact::Error; end
+
+        DEFAULT_CONSUMER_SELECTORS = {"deployed" => true, "environment" => "production"}.freeze
+
+        # https://docs.rs/pact_ffi/0.4.17/pact_ffi/verifier/fn.pactffi_verify.html#errors
+        VERIFICATION_ERRORS = {
+          1 => {reason: :verification_failed, status: 1, description: "The verification process failed, see output for errors"},
+          2 => {reason: :null_pointer, status: 2, description: "A null pointer was received"},
+          3 => {reason: :internal_error, status: 3, description: "The method panicked"},
+          4 => {reason: :invalid_arguments, status: 4, description: "Invalid arguments were provided to the verification process"}
+        }.freeze
+
+        # env below are set up by pipeline-builder
+        # see paas/cicd/images/pact/pipeline-builder/-/blob/master/internal/commands/consumers-pipeline/ruby.go
+        def initialize(pact_config)
+          raise ArgumentError, "pact_config must be a subclass of Sbmt::Pact::Provider::PactConfig::Base" unless pact_config.is_a?(::Sbmt::Pact::Provider::PactConfig::Base)
+          @pact_config = pact_config
+          @logger = Logger.new($stdout)
+        end
+
+        def verify!
+          raise VerifierError.new("interaction is designed to be used one-time only") if defined?(@used)
+
+          if consumer_selectors.blank?
+            logger.info("[verifier] does not need to verify consumer #{@pact_config.consumer_name}")
+            return
+          end
+
+          exception = nil
+          pact_handle = init_pact
+
+          start_servers!
+
+          logger.info("[verifier] starting provider verification")
+
+          result = Sbmt::Pact::Native::BlockingVerifier.execute(pact_handle)
+          if VERIFICATION_ERRORS[result].present?
+            error = VERIFICATION_ERRORS[result]
+            exception = VerificationError.new("There was an error while trying to verify provider \"#{@pact_config.provider_name}\"", error[:reason], error[:status])
+          end
+        ensure
+          @used = true
+          PactFfi::Verifier.shutdown(pact_handle) if pact_handle
+          stop_servers
+
+          raise exception if exception
+        end
+
+        private
+
+        def init_pact
+          handle = PactFfi::Verifier.new_for_application("sbmt-pact", PactFfi.version)
+          set_provider_info(handle)
+          PactFfi::Verifier.set_provider_state(handle, @pact_config.provider_setup_url, 1, 1)
+          PactFfi::Verifier.set_verification_options(handle, 0, 10000)
+          PactFfi::Verifier.set_publish_options(handle, @pact_config.provider_version, "", nil, 0, "")
+
+          configure_verification_source(handle)
+
+          PactFfi::Verifier.set_no_pacts_is_error(handle, 1)
+
+          add_provider_transport(handle)
+          set_filter_info(handle)
+
+          Sbmt::Pact::Native::Logger.log_to_stdout(@pact_config.log_level)
+
+          logger.info("[verifier] verification initialized for provider #{@pact_config.provider_name}, version #{@pact_config.provider_version}, transport #{self.class::PROVIDER_TRANSPORT_TYPE}")
+
+          handle
+        end
+
+        def set_provider_info(pact_handle)
+          PactFfi::Verifier.set_provider_info(pact_handle, @pact_config.provider_name, "", "", 0, "")
+        end
+
+        def add_provider_transport(pact_handle)
+          raise Sbmt::Pact::ImplementationRequired, "Implement #add_provider_transport in a subclass"
+        end
+
+        def set_filter_info(pact_handle)
+          # e.g. PactFfi::Verifier.set_filter_info(pact_handle, "^grpc:.+", nil, 0)
+          raise Sbmt::Pact::ImplementationRequired, "Implement #set_filter_info in a subclass"
+        end
+
+        def start_servers!
+          logger.info("[verifier] starting services")
+
+          @servers_started = true
+          @pact_config.start_servers
+        end
+
+        def stop_servers
+          return unless @servers_started
+
+          logger.info("[verifier] stopping services")
+
+          @pact_config.stop_servers
+        end
+
+        def configure_verification_source(handle)
+          if @pact_config.pact_broker_proxy_url.blank?
+            path = Rails.root.join("pacts").to_s
+            logger.info("[verifier] pact broker url is not set, using #{path} as a verification source")
+            return PactFfi::Verifier.add_directory_source(handle, path)
+          end
+
+          logger.info("[verifier] using pact broker url #{@pact_config.broker_url} with consumer selectors: #{JSON.dump(consumer_selectors)} as a verification source")
+
+          filters = consumer_selectors.map do |selector|
+            FFI::MemoryPointer.from_string(JSON.dump(selector).to_s)
+          end
+          filters_ptr = FFI::MemoryPointer.new(:pointer, filters.size + 1)
+          filters_ptr.write_array_of_pointer(filters)
+          PactFfi::Verifier.broker_source_with_selectors(handle, @pact_config.pact_broker_proxy_url, @pact_config.broker_username, @pact_config.broker_password, nil, 0, nil, nil, 0, nil, filters_ptr, filters.size, nil, 0)
+        end
+
+        def consumer_selectors
+          @consumer_selectors ||= build_consumer_selectors(@pact_config.verify_only, @pact_config.consumer_name, @pact_config.consumer_branch)
+        end
+
+        def build_consumer_selectors(verify_only, consumer_name, consumer_branch)
+          # if verify_only and consumer_name are defined - select only needed consumer
+          if verify_only.present?
+            # select proper consumer branch if defined
+            if consumer_name.present?
+              return [] unless verify_only.include?(consumer_name)
+              return [{"branch" => consumer_branch, "consumer" => consumer_name}] if consumer_branch.present?
+              return [DEFAULT_CONSUMER_SELECTORS.merge("consumer" => consumer_name)]
+            end
+            # or default selectors
+            return verify_only.map { |name| DEFAULT_CONSUMER_SELECTORS.merge("consumer" => name) }
+          end
+
+          # select provided consumer_name
+          return [{"branch" => consumer_branch, "consumer" => consumer_name}] if consumer_name.present? && consumer_branch.present?
+          return [DEFAULT_CONSUMER_SELECTORS.merge("consumer" => consumer_name)] if consumer_name.present?
+
+          [DEFAULT_CONSUMER_SELECTORS]
+        end
+      end
+    end
+  end
+end

data/lib/sbmt/pact/provider/grpc_verifier.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "pact/ffi/verifier"
+require "sbmt/pact/native/logger"
+
+module Sbmt
+  module Pact
+    module Provider
+      class GrpcVerifier < BaseVerifier
+        PROVIDER_TRANSPORT_TYPE = "grpc"
+        INTERACTION_FILTER_REGEX = "^grpc:.+"
+
+        def initialize(pact_config)
+          super
+
+          raise ArgumentError, "pact_config must be an instance of Sbmt::Pact::Provider::PactConfig::Grpc" unless pact_config.is_a?(::Sbmt::Pact::Provider::PactConfig::Grpc)
+          @grpc_server = GrufServer.new(host: "127.0.0.1:#{@pact_config.grpc_port}", services: @pact_config.grpc_services)
+        end
+
+        private
+
+        def add_provider_transport(pact_handle)
+          PactFfi::Verifier.add_provider_transport(pact_handle, PROVIDER_TRANSPORT_TYPE, @pact_config.grpc_port, "", "")
+        end
+
+        def set_filter_info(pact_handle)
+          PactFfi::Verifier.set_filter_info(pact_handle, INTERACTION_FILTER_REGEX, nil, 0)
+        end
+
+        def start_servers!
+          super
+          @grpc_server.start
+        end
+
+        def stop_servers
+          super
+          @grpc_server.stop
+        end
+      end
+    end
+  end
+end

data/lib/sbmt/pact/provider/gruf_server.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Pact
+    module Provider
+      # inspired by Gruf::Cli::Executor
+      class GrufServer
+        SERVER_STOP_TIMEOUT_SEC = 15
+
+        def initialize(options = {})
+          @options = options
+
+          setup!
+
+          @server_pid = nil
+
+          @services = @options[:services].is_a?(Array) ? @options[:services] : []
+          @logger = @options[:logger] || ::Logger.new($stdout)
+        end
+
+        def start
+          raise "server already running, stop server before starting new one" if @thread
+
+          @logger.info("[gruf] starting standalone server with options: #{@options}")
+
+          @server = Gruf::Server.new(Gruf.server_options)
+          @services.each { |s| @server.add_service(s) } if @services.any?
+          @thread = Thread.new do
+            @logger.debug "[gruf] starting grpc server"
+            @server.start!
+          end
+          @server.server.wait_till_running(10)
+
+          @logger.info("[gruf] standalone server started")
+        end
+
+        def stop
+          @logger.info("[gruf] stopping standalone server")
+
+          @server&.server&.stop
+          @thread&.join(SERVER_STOP_TIMEOUT_SEC)
+          @thread&.kill
+
+          @logger.info("[gruf] standalone server stopped")
+        end
+
+        ##
+        # Run the server
+        #
+        def run
+          start
+
+          yield
+        rescue => e
+          @logger.fatal("FATAL ERROR: #{e.message} #{e.backtrace.join("\n")}")
+          raise
+        ensure
+          stop
+        end
+
+        private
+
+        def setup!
+          Gruf.server_binding_url = @options[:host] if @options[:host]
+          if @options[:suppress_default_interceptors]
+            Gruf.interceptors.remove(Gruf::Interceptors::ActiveRecord::ConnectionReset)
+            Gruf.interceptors.remove(Gruf::Interceptors::Instrumentation::OutputMetadataTimer)
+          end
+          Gruf.backtrace_on_error = true if @options[:backtrace_on_error]
+          Gruf.health_check_enabled = true if @options[:health_check]
+        end
+      end
+    end
+  end
+end

data/lib/sbmt/pact/provider/http_server.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Pact
+    module Provider
+      # inspired by Gruf::Cli::Executor
+      class HttpServer
+        SERVER_STOP_TIMEOUT_SEC = 15
+
+        def initialize(options = {})
+          @options = options
+
+          @server_pid = nil
+
+          @host = @options[:host] || "localhost"
+          @logger = @options[:logger] || ::Logger.new($stdout)
+        end
+
+        def start
+          raise "server already running, stop server before starting new one" if @thread
+
+          @logger.info("[webrick] starting server with options: #{@options}")
+
+          @thread = Thread.new do
+            @logger.debug "[webrick] starting http server"
+
+            ::Rack::Handler::WEBrick.run(Rails.application,
+              Host: @options[:host],
+              Port: @options[:port],
+              Logger: @logger,
+              StartCallback: -> { @started = true }) do |server|
+              @server = server
+            end
+          end
+          sleep 0.001 until @started
+
+          @logger.info("[webrick] server started")
+        end
+
+        def stop
+          @logger.info("[webrick] stopping server")
+
+          @server&.shutdown
+          @thread&.join(SERVER_STOP_TIMEOUT_SEC)
+          @thread&.kill
+
+          @logger.info("[webrick] server stopped")
+        end
+
+        ##
+        # Run the server
+        #
+        def run
+          start
+
+          yield
+        rescue => e
+          @logger.fatal("FATAL ERROR: #{e.message} #{e.backtrace.join("\n")}")
+          raise
+        ensure
+          stop
+        end
+      end
+    end
+  end
+end

data/lib/sbmt/pact/provider/http_verifier.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "pact/ffi/verifier"
+require "sbmt/pact/native/logger"
+
+module Sbmt
+  module Pact
+    module Provider
+      class HttpVerifier < BaseVerifier
+        PROVIDER_TRANSPORT_TYPE = "http"
+
+        def initialize(pact_config)
+          super
+
+          raise ArgumentError, "pact_config must be an instance of Sbmt::Pact::Provider::PactConfig::Http" unless pact_config.is_a?(::Sbmt::Pact::Provider::PactConfig::Http)
+          @http_server = HttpServer.new(host: "127.0.0.1", port: @pact_config.http_port)
+        end
+
+        private
+
+        def set_provider_info(pact_handle)
+          PactFfi::Verifier.set_provider_info(pact_handle, @pact_config.provider_name, "", "", @pact_config.http_port, "")
+        end
+
+        def add_provider_transport(pact_handle)
+          # The http transport is already added when the `set_provider_info` method is called,
+          # so we don't need to explicitly add the transport here
+        end
+
+        def set_filter_info(pact_handle)
+          PactFfi::Verifier.set_filter_info(pact_handle, "^http:.+", nil, 0)
+        end
+
+        def start_servers!
+          super
+          @http_server.start
+        end
+
+        def stop_servers
+          super
+          @http_server.stop
+        end
+      end
+    end
+  end
+end

data/lib/sbmt/pact/provider/message_provider_servlet.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "webrick"
+
+module Sbmt
+  module Pact
+    module Provider
+      class MessageProviderServlet < WEBrick::HTTPServlet::ProcHandler
+        attr_reader :logger
+
+        CONTENT_TYPE_JSON = "application/json"
+        CONTENT_TYPE_PROTO = "application/protobuf"
+        METADATA_HEADER = "pact-message-metadata"
+
+        def initialize(logger: Logger.new($stdout))
+          super(build_proc)
+
+          @message_handlers = {}
+
+          @logger = logger
+        end
+
+        def add_message_handler(name, &block)
+          raise "message handler for #{name} already configured" if @message_handlers[name].present?
+
+          @message_handlers[name] = {proc: block}
+        end
+
+        private
+
+        def build_proc
+          proc do |request, response|
+            # {"description":"message: ","providerStates":[{"name":"pet exists","params":{"pet_id":1}}]}
+            data = JSON.parse(request.body)
+
+            description = data["description"]
+            provider_states = data["providerStates"]
+
+            body, metadata = handle(description, provider_states)
+
+            response.status = 200
+            if body.is_a?(String)
+              # protobuf-serialized body
+              response.body = body
+              response.content_type = metadata[:content_type] || CONTENT_TYPE_PROTO
+            else
+              response.body = body.to_json
+              response.content_type = CONTENT_TYPE_JSON
+            end
+            response[METADATA_HEADER] = Base64.urlsafe_encode64(metadata.to_json)
+          rescue JSON::ParserError => ex
+            logger.error("cannot parse request: #{ex.message}")
+            response.status = 500
+          rescue => ex
+            logger.error("cannot handle message request: #{ex.message}")
+            response.status = 500
+          end
+        end
+
+        def handle(description, provider_states)
+          handler = find_handler_for(description)
+          return {}, {} unless handler
+
+          body, metadata = handler[:proc].call(provider_states&.first || {})
+          unless metadata[:content_type]
+            # try to find content-type in provider states
+            content_type = provider_states&.filter_map { |state| state.dig("params", "contentType") }&.first
+            metadata[:content_type] = content_type if content_type
+          end
+          [body, metadata]
+        end
+
+        def find_handler_for(description)
+          desc_no_prefix = description.sub(/^(async|sync): /, "")
+          @message_handlers[description] || @message_handlers[desc_no_prefix]
+        end
+      end
+    end
+  end
+end