pact 1.67.5 → 2.0.1

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

@@ -1,288 +0,0 @@
-# frozen_string_literal: true
-
-require "pact/ffi/message_consumer"
-require "pact/ffi/plugin_consumer"
-require "pact/ffi/logger"
-
-module Pact
-  module V2
-    module Consumer
-      class MessageInteractionBuilder
-        META_CONTENT_TYPE_HEADER = "contentType"
-
-        JSON_CONTENT_TYPE = "application/json"
-        PROTO_CONTENT_TYPE = "application/protobuf"
-
-        PROTOBUF_PLUGIN_NAME = "protobuf"
-        PROTOBUF_PLUGIN_VERSION = "0.6.5"
-
-        # https://docs.rs/pact_ffi/latest/pact_ffi/mock_server/handles/fn.pactffi_write_message_pact_file.html
-        WRITE_PACT_FILE_ERRORS = {
-          1 => {reason: :file_not_accessible, status: 1, description: "The pact file was not able to be written"},
-          2 => {reason: :internal_error, status: 2, description: "The message pact for the given handle was not found"}
-        }.freeze
-
-        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
-
-          @json_contents = nil
-          @proto_contents = nil
-          @proto_path = nil
-          @proto_message_class = nil
-          @proto_include_dirs = []
-          @meta = {}
-          @headers = {}
-          @provider_state_meta = nil
-        end
-
-        def given(provider_state, metadata = {})
-          @provider_state_meta = {provider_state => metadata}
-          self
-        end
-
-        def upon_receiving(description)
-          @description = description
-          self
-        end
-
-        def with_json_contents(contents_hash)
-          @json_contents = InteractionContents.basic(contents_hash)
-          self
-        end
-
-        def with_proto_class(proto_path, message_class_name, include_dirs = [])
-          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
-          @proto_message_class = message_class_name
-          @proto_include_dirs = include_dirs.map { |dir| File.expand_path(dir) }
-          self
-        end
-
-        def with_pact_protobuf_plugin_version(version)
-          raise InteractionBuilderError.new("version is required") if version.blank?
-
-          @proto_plugin_version = version
-          self
-        end
-
-        def with_proto_contents(contents_hash)
-          @proto_contents = InteractionContents.plugin(contents_hash)
-          self
-        end
-
-        def with_metadata(meta_hash)
-          @meta = InteractionContents.basic(meta_hash)
-          self
-        end
-
-        def with_headers(headers_hash)
-          @headers = InteractionContents.basic(headers_hash)
-          self
-        end
-
-        def with_header(key, value)
-          @headers[key] = value
-          self
-        end
-
-        def validate!
-          if proto_interaction?
-            raise InteractionBuilderError.new("proto_path / proto_message are not defined, please set ones with #with_proto_message") if @proto_contents.blank? || @proto_message_class.blank?
-            raise InteractionBuilderError.new("invalid request format, should be a hash") unless @proto_contents.is_a?(Hash)
-          else
-            raise InteractionBuilderError.new("invalid request format, should be a hash") unless @json_contents.is_a?(Hash)
-          end
-          raise InteractionBuilderError.new("description is required for message interactions, please set one with #upon_receiving") if @description.blank?
-        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) if proto_interaction?
-
-          message_pact = PactFfi::MessageConsumer.new_message_interaction(pact_handle, @description)
-
-          configure_interaction!(message_pact)
-
-          # strip out matchers and get raw payload/metadata
-          payload, metadata = fetch_reified_message(pact_handle)
-          configure_provider_state(message_pact, metadata)
-
-          yield(payload, metadata)
-
-          write_pacts!(pact_handle, @pact_config.pact_dir)
-        ensure
-          @used = true
-          PactFfi::MessageConsumer.free_handle(message_pact)
-          PactFfi::PluginConsumer.cleanup_plugins(pact_handle)
-          PactFfi.free_pact_handle(pact_handle)
-        end
-
-        def build_interaction_json
-          return JSON.dump(@json_contents) unless proto_interaction?
-
-          contents = {
-            "pact:proto": @proto_path,
-            "pact:message-type": @proto_message_class,
-            "pact:content-type": PROTO_CONTENT_TYPE
-          }.merge(@proto_contents)
-
-          contents["pact:protobuf-config"] = {additionalIncludes: @proto_include_dirs} if @proto_include_dirs.present?
-
-          JSON.dump(contents)
-        end
-
-        private
-
-        def write_pacts!(handle, dir)
-          result = PactFfi.write_message_pact_file(handle, @pact_config.pact_dir, false)
-          return result if WRITE_PACT_FILE_ERRORS[result].blank?
-
-          error = WRITE_PACT_FILE_ERRORS[result]
-          raise WritePactsError.new("There was an error while trying to write pact file to #{dir}", error[:reason], error[:status])
-        end
-
-        def init_pact
-          handle = PactFfi::MessageConsumer.new_message_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 fetch_reified_message(pact_handle)
-          iterator = PactFfi::MessageConsumer.pact_handle_get_message_iter(pact_handle)
-          raise InteractionBuilderError.new("cannot get message iterator: internal error") if iterator.blank?
-
-          message_handle = PactFfi.pact_message_iter_next(iterator)
-          raise InteractionBuilderError.new("cannot get message from iterator: no messages") if message_handle.blank?
-
-          contents = fetch_reified_message_body(message_handle)
-          meta = fetch_reified_message_headers(message_handle)
-
-          [contents, meta.compact]
-        ensure
-          PactFfi.pact_message_iter_delete(iterator) if iterator.present?
-        end
-
-        def fetch_reified_message_headers(message_handle)
-          meta = {"headers" => {}}
-
-          meta[META_CONTENT_TYPE_HEADER] = PactFfi.message_find_metadata(message_handle, META_CONTENT_TYPE_HEADER)
-
-          @meta.each_key do |key|
-            meta[key.to_s] = PactFfi.message_find_metadata(message_handle, key.to_s)
-          end
-
-          @headers.each_key do |key|
-            meta["headers"][key.to_s] = PactFfi.message_find_metadata(message_handle, key.to_s)
-          end
-
-          meta
-        end
-
-        def configure_provider_state(message_pact, reified_metadata)
-          content_type = reified_metadata[META_CONTENT_TYPE_HEADER]
-          @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) }
-              PactFfi.given_with_param(message_pact, provider_state, META_CONTENT_TYPE_HEADER, content_type.to_s) if content_type
-            elsif content_type.present?
-              PactFfi.given_with_param(message_pact, provider_state, META_CONTENT_TYPE_HEADER, content_type.to_s)
-            else
-              PactFfi.given(message_pact, provider_state)
-            end
-          end
-        end
-
-        def fetch_reified_message_body(message_handle)
-          if proto_interaction?
-            len = PactFfi::MessageConsumer.get_contents_length(message_handle)
-            ptr = PactFfi::MessageConsumer.get_contents_bin(message_handle)
-            return nil if ptr.blank? || len == 0
-
-            return String.new(ptr.read_string_length(len))
-          end
-
-          contents = PactFfi::MessageConsumer.get_contents(message_handle)
-          return nil if contents.blank?
-
-          JSON.parse(contents)
-        end
-
-        def configure_interaction!(message_pact)
-          interaction_json = build_interaction_json
-
-          if proto_interaction?
-            result = PactFfi::PluginConsumer.interaction_contents(message_pact, 0, PROTO_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
-          else
-            result = PactFfi.with_body(message_pact, 0, JSON_CONTENT_TYPE, interaction_json)
-            unless result
-              raise InteractionMismatchesError.new("There was an error while trying to add message interaction contents \"#{@description}\"")
-            end
-          end
-
-          # meta should be configured last to avoid resetting after body is set
-          InteractionContents.basic(@meta.merge(@headers)).each_pair do |key, value|
-            PactFfi::MessageConsumer.with_metadata_v2(message_pact, key.to_s, JSON.dump(value))
-          end
-        end
-
-        def init_plugin!(pact_handle)
-          result = PactFfi::PluginConsumer.using_plugin(pact_handle, PROTOBUF_PLUGIN_NAME, @proto_plugin_version || 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}/#{@proto_plugin_version || PROTOBUF_PLUGIN_VERSION}", error[:reason], error[:status])
-        end
-
-        def serialize_metadata(metadata_hash)
-          metadata = metadata_hash.deep_dup
-          serialize_as!(metadata, :basic)
-
-          metadata
-        end
-
-        def proto_interaction?
-          @proto_contents.present?
-        end
-      end
-    end
-  end
-end

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

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-require "pact/ffi/mock_server"
-
-module Pact
-  module V2
-    module Consumer
-      class MockServer
-        attr_reader :host, :port, :transport, :handle, :url
-
-        TRANSPORT_HTTP = "http"
-        TRANSPORT_GRPC = "grpc"
-
-        class MockServerCreateError < Pact::V2::FfiError; end
-
-        class WritePactsError < Pact::V2::FfiError; end
-
-        # https://docs.rs/pact_ffi/0.4.17/pact_ffi/mock_server/fn.pactffi_create_mock_server_for_transport.html
-        CREATE_TRANSPORT_ERRORS = {
-          -1 => {reason: :invalid_handle, status: -1, description: "An invalid handle was received. Handles should be created with pactffi_new_pact"},
-          -2 => {reason: :invalid_transport_json, status: -2, description: "Transport_config is not valid JSON"},
-          -3 => {reason: :mock_server_not_started, status: -3, description: "The mock server could not be started"},
-          -4 => {reason: :internal_error, status: -4, description: "The method panicked"},
-          -5 => {reason: :invalid_host, status: -5, description: "The address is not valid"}
-        }.freeze
-
-        # https://docs.rs/pact_ffi/0.4.17/pact_ffi/mock_server/fn.pactffi_write_pact_file.html
-        WRITE_PACT_FILE_ERRORS = {
-          1 => {reason: :internal_error, status: 1, description: "A general panic was caught"},
-          2 => {reason: :file_not_accessible, status: 2, description: "The pact file was not able to be written"},
-          3 => {reason: :mock_server_not_found, status: 3, description: "A mock server with the provided port was not found"}
-        }.freeze
-
-        def self.create_for_grpc!(pact:, host: "127.0.0.1", port: 0)
-          new(pact: pact, transport: TRANSPORT_GRPC, host: host, port: port)
-        end
-
-        def self.create_for_http!(pact:, host: "127.0.0.1", port: 0)
-          new(pact: pact, transport: TRANSPORT_HTTP, host: host, port: port)
-        end
-
-        def self.create_for_transport!(pact:, transport:, host: "127.0.0.1", port: 0)
-          new(pact: pact, transport: transport, host: host, port: port)
-        end
-
-        def initialize(pact:, transport:, host:, port:)
-
-          @pact = pact
-          @transport = transport
-          @host = host
-          @port = port
-
-          @handle = init_transport!
-          # the returned handle is the port number
-          # we set it here, so we can consume a port number of 0
-          # and allow pact to assign a random available port
-          @port = @handle
-          # construct the url for the mock server
-          # as a convenience for the user
-          @url = "#{transport}://#{host}:#{@handle}"
-          # TODO: handle auto-GC of native memory
-          # ObjectSpace.define_finalizer(self, proc do
-          #   cleanup
-          # end)
-        end
-
-        def write_pacts!(dir)
-          result = PactFfi::MockServer.write_pact_file(@handle, dir, false)
-          return result if WRITE_PACT_FILE_ERRORS[result].blank?
-
-          error = WRITE_PACT_FILE_ERRORS[result]
-          raise WritePactsError.new("There was an error while trying to write pact file to #{dir}", error[:reason], error[:status])
-        end
-
-        def matched?
-          PactFfi::MockServer.matched(@handle)
-        end
-
-        def mismatches
-          PactFfi::MockServer.mismatches(@handle)
-        end
-
-        def cleanup
-          PactFfi::MockServer.cleanup(@handle)
-        end
-
-        def cleanup_plugins
-          PactFfi::PluginConsumer.cleanup_plugins(@handle)
-        end
-
-        def free_pact_handle
-          PactFfi.free_pact_handle(@handle)
-        end
-
-        private
-
-        def init_transport!
-          handle = PactFfi::MockServer.create_for_transport(@pact, @host, @port, @transport, nil)
-          # the returned handle is the port number
-          return handle if CREATE_TRANSPORT_ERRORS[handle].blank?
-
-          error = CREATE_TRANSPORT_ERRORS[handle]
-          raise MockServerCreateError.new("There was an error while trying to create mock server for transport:#{@transport}", error[:reason], error[:status])
-        end
-      end
-    end
-  end
-end

data/lib/pact/v2/consumer/pact_config/base.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Pact
-  module V2
-    module Consumer
-      module PactConfig
-        class Base
-          attr_reader :consumer_name, :provider_name, :pact_dir, :log_level
-
-          def initialize(consumer_name:, provider_name:, opts: {})
-            @consumer_name = consumer_name
-            @provider_name = provider_name
-            @pact_dir = opts[:pact_dir] || (defined?(Rails) ? Rails.root.join("../pacts").to_s : "pacts")
-            @log_level = opts[:log_level] || :info
-          end
-
-          def new_interaction(description = nil)
-            raise Pact::V2::ImplementationRequired, "#new_interaction should be implemented"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/pact/v2/consumer/pact_config/grpc.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base"
-
-module Pact
-  module V2
-    module Consumer
-      module PactConfig
-        class Grpc < Base
-          attr_reader :mock_host, :mock_port
-
-          def initialize(consumer_name:, provider_name:, opts: {})
-            super
-
-            @mock_host = opts[:mock_host] || "127.0.0.1"
-            @mock_port = opts[:mock_port] || 3009
-          end
-
-          def new_interaction(description = nil)
-            GrpcInteractionBuilder.new(self, description: description)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/pact/v2/consumer/pact_config/http.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base"
-
-module Pact
-  module V2
-    module Consumer
-      module PactConfig
-        class Http < Base
-          attr_reader :mock_host, :mock_port, :pact_handle
-
-          def initialize(consumer_name:, provider_name:, opts: {})
-            super
-
-            @mock_host = opts[:mock_host] || "127.0.0.1"
-            @mock_port = opts[:mock_port] || 0
-            @log_level = opts[:log_level] || :info
-            @pact_specification = get_pact_specification(opts)
-            @pact_handle = init_pact
-          end
-
-          def new_interaction(description = nil)
-            HttpInteractionBuilder.new(self, description: description)
-          end
-
-          def reset_pact
-            @pact_handle = init_pact
-          end
-
-          def get_pact_specification(opts)
-            pact_spec_version = opts[:pact_specification] || "V4"
-            unless pact_spec_version.match?(/^v?[1-4](\.\d+){0,2}$/i)
-              raise ArgumentError, "Invalid pact specification version format \n Valid versions are 1, 1.1, 2, 3, 4. Default is V4 \n V prefix is optional, and case insensitive"
-            end
-            pact_spec_version = pact_spec_version.upcase
-            pact_spec_version = "V#{pact_spec_version}" unless pact_spec_version.start_with?("V")
-            pact_spec_version = pact_spec_version.sub(/(\.0+)+$/, "")
-            pact_spec_version = pact_spec_version.tr(".", "_")
-            PactFfi::FfiSpecificationVersion["SPECIFICATION_VERSION_#{pact_spec_version.upcase}"]
-          end
-
-          def init_pact
-            handle = PactFfi.new_pact(consumer_name, provider_name)
-            PactFfi.with_specification(handle, @pact_specification)
-            PactFfi.with_pact_metadata(handle, "pact-ruby-v2", "pact-ffi", PactFfi.version)
-
-            Pact::V2::Native::Logger.log_to_stdout(@log_level)
-
-            handle
-          end
-        end
-      end
-    end
-  end
-end

data/lib/pact/v2/consumer/pact_config/message.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base"
-
-module Pact
-  module V2
-    module Consumer
-      module PactConfig
-        class Message < Base
-          def new_interaction(description = nil)
-            MessageInteractionBuilder.new(self, description: description)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/pact/v2/consumer/pact_config/plugin_async_message.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base"
-
-module Pact
-  module V2
-    module Consumer
-      module PactConfig
-        class PluginAsyncMessage < Base
-          attr_reader :mock_host, :mock_port
-
-          def initialize(consumer_name:, provider_name:, opts: {})
-            super
-
-            @mock_host = opts[:mock_host] || "127.0.0.1"
-            @mock_port = opts[:mock_port] || 0
-          end
-
-          def new_interaction(description = nil)
-            PluginAsyncMessageInteractionBuilder.new(self, description: description)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/pact/v2/consumer/pact_config/plugin_http.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base"
-
-module Pact
-  module V2
-    module Consumer
-      module PactConfig
-        class PluginHttp < Base
-          attr_reader :mock_host, :mock_port
-
-          def initialize(consumer_name:, provider_name:, opts: {})
-            super
-
-            @mock_host = opts[:mock_host] || "127.0.0.1"
-            @mock_port = opts[:mock_port] || 0
-          end
-
-          def new_interaction(description = nil)
-            PluginHttpInteractionBuilder.new(self, description: description)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/pact/v2/consumer/pact_config/plugin_sync_message.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base"
-
-module Pact
-  module V2
-    module Consumer
-      module PactConfig
-        class PluginSyncMessage < Base
-          attr_reader :mock_host, :mock_port
-
-          def initialize(consumer_name:, provider_name:, opts: {})
-            super
-
-            @mock_host = opts[:mock_host] || "127.0.0.1"
-            @mock_port = opts[:mock_port] || 0
-          end
-
-          def new_interaction(description = nil)
-            PluginSyncMessageInteractionBuilder.new(self, description: description)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "pact_config/grpc"
-
-module Pact
-  module V2
-    module Consumer
-      module PactConfig
-        def self.new(transport_type, consumer_name:, provider_name:, opts: {})
-          case transport_type
-          when :http
-            Http.new(consumer_name: consumer_name, provider_name: provider_name, opts: opts)
-          when :grpc
-            Grpc.new(consumer_name: consumer_name, provider_name: provider_name, opts: opts)
-          when :message
-            Message.new(consumer_name: consumer_name, provider_name: provider_name, opts: opts)
-          when :plugin_sync_message
-            PluginSyncMessage.new(consumer_name: consumer_name, provider_name: provider_name, opts: opts)
-          when :plugin_async_message
-            PluginAsyncMessage.new(consumer_name: consumer_name, provider_name: provider_name, opts: opts)
-          when :plugin_http
-            PluginHttp.new(consumer_name: consumer_name, provider_name: provider_name, opts: opts)
-          else
-            raise ArgumentError, "unknown transport_type: #{transport_type}"
-          end
-        end
-      end
-    end
-  end
-end