sbmt-pact 0.12.0

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "pact/ffi/mock_server"
+
+module Sbmt
+  module Pact
+    module Consumer
+      class MockServer
+        attr_reader :host, :port, :transport, :handle
+
+        TRANSPORT_HTTP = "http"
+        TRANSPORT_GRPC = "grpc"
+
+        TRANSPORTS = [TRANSPORT_HTTP, TRANSPORT_GRPC].freeze
+
+        class MockServerCreateError < Sbmt::Pact::FfiError; end
+
+        class WritePactsError < Sbmt::Pact::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 initialize(pact:, transport:, host:, port:)
+          raise "Transport #{transport} is not supported yet, available transports are: #{TRANSPORTS.join(",")}" unless TRANSPORTS.include?(transport)
+
+          @pact = pact
+          @transport = transport
+          @host = host
+          @port = port
+
+          @handle = init_transport!
+
+          # 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
+
+        private
+
+        def init_transport!
+          handle = PactFfi::MockServer.create_for_transport(@pact, @host, @port, @transport, nil)
+          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/sbmt/pact/consumer/pact_config/base.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Pact
+    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] || Rails.root.join("pacts").to_s
+            @log_level = opts[:log_level] || :info
+          end
+
+          def new_interaction(description = nil)
+            raise Sbmt::Pact::ImplementationRequired, "#new_interaction should be implemented"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Sbmt
+  module Pact
+    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/sbmt/pact/consumer/pact_config/http.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Sbmt
+  module Pact
+    module Consumer
+      module PactConfig
+        class Http < 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] || 3000
+          end
+
+          def new_interaction(description = nil)
+            HttpInteractionBuilder.new(self, description: description)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Sbmt
+  module Pact
+    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/sbmt/pact/consumer/pact_config.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "pact_config/grpc"
+
+module Sbmt
+  module Pact
+    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)
+          else
+            raise ArgumentError, "unknown transport_type: #{transport_type}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sbmt/pact/consumer.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Pact
+    module Consumer
+    end
+  end
+end

data/lib/sbmt/pact/matchers/base.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Pact
+    module Matchers
+      # see https://github.com/pact-foundation/pact-reference/blob/master/rust/pact_ffi/IntegrationJson.md
+      class Base
+        attr_reader :spec_version, :kind, :template, :opts
+
+        class MatcherInitializationError < Sbmt::Pact::Error; end
+
+        def initialize(spec_version:, kind:, template:, opts: {})
+          @spec_version = spec_version
+          @kind = kind
+          @template = template
+          @opts = opts
+        end
+
+        def as_basic
+          {
+            "pact:matcher:type" => serialize!(@kind.deep_dup, :basic),
+            "value" => serialize!(@template.deep_dup, :basic)
+          }.merge(serialize!(@opts.deep_dup, :basic))
+        end
+
+        def as_plugin
+          params = @opts.values.map { |v| format_primitive(v) }.join(",")
+          value = format_primitive(@template)
+
+          return "matching(#{@kind}, #{params}, #{value})" if params.present?
+
+          "matching(#{@kind}, #{value})"
+        end
+
+        private
+
+        def serialize!(data, format)
+          # serialize complex types recursively
+          case data
+          when TrueClass, FalseClass, Numeric, String
+            data
+          when Array
+            data.map { |v| serialize!(v, format) }
+          when Hash
+            data.transform_values { |v| serialize!(v, format) }
+          when Sbmt::Pact::Matchers::Base
+            return data.as_basic if format == :basic
+            data.as_plugin if format == :plugin
+          else
+            data
+          end
+        end
+
+        def format_primitive(arg)
+          case arg
+          when TrueClass, FalseClass, Numeric
+            arg.to_s
+          when String
+            "'#{arg}'"
+          else
+            raise "#{arg.class} is not a primitive"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sbmt/pact/matchers/v1/equality.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Pact
+    module Matchers
+      module V1
+        class Equality < Sbmt::Pact::Matchers::Base
+          def initialize(template)
+            super(spec_version: Sbmt::Pact::Matchers::PACT_SPEC_V1, kind: "equality", template: template)
+          end
+
+          def as_plugin
+            "matching(equalTo, #{format_primitive(@template)})"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sbmt/pact/matchers/v2/regex.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Pact
+    module Matchers
+      module V2
+        class Regex < Sbmt::Pact::Matchers::Base
+          def initialize(regex, template)
+            raise MatcherInitializationError, "#{self.class}: #{regex} should be an instance of Regexp" unless regex.is_a?(Regexp)
+            raise MatcherInitializationError, "#{self.class}: #{template} should be an instance of String or Array" unless template.is_a?(String) || template.is_a?(Array)
+            raise MatcherInitializationError, "#{self.class}: #{template} array values should be strings" if template.is_a?(Array) && !template.all?(String)
+
+            super(spec_version: Sbmt::Pact::Matchers::PACT_SPEC_V2, kind: "regex", template: template, opts: {regex: regex.to_s})
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sbmt/pact/matchers/v2/type.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Pact
+    module Matchers
+      module V2
+        class Type < Sbmt::Pact::Matchers::Base
+          def initialize(template)
+            raise MatcherInitializationError, "#{self.class}: template is not a primitive" unless template.is_a?(TrueClass) || template.is_a?(FalseClass) || template.is_a?(Numeric) || template.is_a?(String)
+
+            super(spec_version: Sbmt::Pact::Matchers::PACT_SPEC_V2, kind: "type", template: template)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sbmt/pact/matchers/v3/boolean.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Pact
+    module Matchers
+      module V3
+        class Boolean < Sbmt::Pact::Matchers::Base
+          def initialize(template)
+            raise MatcherInitializationError, "#{self.class}: #{template} should be an instance of Boolean" unless template.is_a?(TrueClass) || template.is_a?(FalseClass)
+
+            super(spec_version: Sbmt::Pact::Matchers::PACT_SPEC_V3, kind: "boolean", template: template)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sbmt/pact/matchers/v3/date.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Pact
+    module Matchers
+      module V3
+        class Date < Sbmt::Pact::Matchers::Base
+          def initialize(format, template)
+            raise MatcherInitializationError, "#{self.class}: #{format} should be an instance of String" unless template.is_a?(String)
+            raise MatcherInitializationError, "#{self.class}: #{template} should be an instance of String" unless template.is_a?(String)
+
+            super(spec_version: Sbmt::Pact::Matchers::PACT_SPEC_V3, kind: "date", template: template, opts: {format: format})
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sbmt/pact/matchers/v3/date_time.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Pact
+    module Matchers
+      module V3
+        class DateTime < Sbmt::Pact::Matchers::Base
+          def initialize(format, template)
+            raise MatcherInitializationError, "#{self.class}: #{format} should be an instance of String" unless template.is_a?(String)
+            raise MatcherInitializationError, "#{self.class}: #{template} should be an instance of String" unless template.is_a?(String)
+
+            super(spec_version: Sbmt::Pact::Matchers::PACT_SPEC_V3, kind: "datetime", template: template, opts: {format: format})
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sbmt/pact/matchers/v3/decimal.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Pact
+    module Matchers
+      module V3
+        class Decimal < Sbmt::Pact::Matchers::Base
+          def initialize(template)
+            raise MatcherInitializationError, "#{self.class}: #{template} should be an instance of Float" unless template.is_a?(Float)
+
+            super(spec_version: Sbmt::Pact::Matchers::PACT_SPEC_V3, kind: "decimal", template: template)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sbmt/pact/matchers/v3/each.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Pact
+    module Matchers
+      module V3
+        class Each < Sbmt::Pact::Matchers::Base
+          def initialize(template, min)
+            raise MatcherInitializationError, "#{self.class}: #{min} should be greater than 0" if min.present? && min < 1
+
+            min_array_size = min.presence || 1
+            val = template.is_a?(Array) ? template : [template] * min_array_size
+
+            raise MatcherInitializationError, "#{self.class}: #{min} is invalid: template size is #{val.size}" if min_array_size != val.size
+
+            super(
+              spec_version: Sbmt::Pact::Matchers::PACT_SPEC_V3,
+              kind: "type",
+              template: val,
+              opts: {min: min_array_size})
+          end
+
+          def as_plugin
+            if @template.first.is_a?(Hash)
+              return {
+                "pact:match" => "eachValue(matching($'SAMPLE'))",
+                "SAMPLE" => serialize!(@template.first.deep_dup, :plugin)
+              }
+            end
+
+            params = @opts.except(:min).values.map { |v| format_primitive(v) }.join(",")
+            value = format_primitive(@template.first)
+
+            return "eachValue(matching(#{@kind}, #{params}, #{value}))" if params.present?
+
+            "eachValue(matching(#{@kind}, #{value}))"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sbmt/pact/matchers/v3/include.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Pact
+    module Matchers
+      module V3
+        class Include < Sbmt::Pact::Matchers::Base
+          def initialize(template)
+            raise MatcherInitializationError, "#{self.class}: #{template} should be an instance of String" unless template.is_a?(String)
+
+            super(spec_version: Sbmt::Pact::Matchers::PACT_SPEC_V3, kind: "include", template: template)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sbmt/pact/matchers/v3/integer.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Pact
+    module Matchers
+      module V3
+        class Integer < Sbmt::Pact::Matchers::Base
+          def initialize(template)
+            raise MatcherInitializationError, "#{self.class}: #{template} should be an instance of Integer" unless template.is_a?(::Integer)
+
+            super(spec_version: Sbmt::Pact::Matchers::PACT_SPEC_V3, kind: "integer", template: template)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sbmt/pact/matchers/v3/number.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Pact
+    module Matchers
+      module V3
+        class Number < Sbmt::Pact::Matchers::Base
+          def initialize(template)
+            raise MatcherInitializationError, "#{self.class}: #{template} should be an instance of Numeric" unless template.is_a?(Numeric)
+
+            super(spec_version: Sbmt::Pact::Matchers::PACT_SPEC_V3, kind: "number", template: template)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sbmt/pact/matchers/v3/time.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Pact
+    module Matchers
+      module V3
+        class Time < Sbmt::Pact::Matchers::Base
+          def initialize(format, template)
+            raise MatcherInitializationError, "#{self.class}: #{format} should be an instance of String" unless template.is_a?(String)
+            raise MatcherInitializationError, "#{self.class}: #{template} should be an instance of String" unless template.is_a?(String)
+
+            super(spec_version: Sbmt::Pact::Matchers::PACT_SPEC_V3, kind: "time", template: template, opts: {format: format})
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sbmt/pact/matchers/v4/each_key.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Pact
+    module Matchers
+      module V4
+        class EachKey < Sbmt::Pact::Matchers::Base
+          def initialize(key_matchers, template)
+            raise MatcherInitializationError, "#{self.class}: #{template} should be a Hash" unless template.is_a?(Hash)
+            raise MatcherInitializationError, "#{self.class}: #{key_matchers} should be an Array" unless key_matchers.is_a?(Array)
+            raise MatcherInitializationError, "#{self.class}: #{key_matchers} should be instances of Sbmt::Pact::Matchers::Base" unless key_matchers.all?(Sbmt::Pact::Matchers::Base)
+            raise MatcherInitializationError, "#{self.class}: #{key_matchers} size should be greater than 0" unless key_matchers.size > 0
+
+            super(spec_version: Sbmt::Pact::Matchers::PACT_SPEC_V4, kind: "each-key", template: template, opts: {rules: key_matchers})
+          end
+
+          def as_plugin
+            @opts[:rules].map do |matcher|
+              "eachKey(#{matcher.as_plugin})"
+            end.join(", ")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sbmt/pact/matchers/v4/each_key_value.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Pact
+    module Matchers
+      module V4
+        class EachKeyValue < Sbmt::Pact::Matchers::Base
+          def initialize(key_matchers, template)
+            raise MatcherInitializationError, "#{self.class}: #{template} should be a Hash" unless template.is_a?(Hash)
+            raise MatcherInitializationError, "#{self.class}: #{key_matchers} should be an Array" unless key_matchers.is_a?(Array)
+            raise MatcherInitializationError, "#{self.class}: #{key_matchers} should be instances of Sbmt::Pact::Matchers::Base" unless key_matchers.all?(Sbmt::Pact::Matchers::Base)
+
+            super(
+              spec_version: Sbmt::Pact::Matchers::PACT_SPEC_V4,
+              kind: [
+                EachKey.new(key_matchers, {}),
+                EachValue.new([Sbmt::Pact::Matchers::V2::Type.new("")], {})
+              ],
+              template: template
+            )
+
+            @key_matchers = key_matchers
+          end
+
+          def as_plugin
+            raise MatcherInitializationError, "#{self.class}: each-key-value is not supported in plugin syntax. Use each / each_key / each_value matchers instead"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sbmt/pact/matchers/v4/each_value.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Pact
+    module Matchers
+      module V4
+        class EachValue < Sbmt::Pact::Matchers::Base
+          def initialize(value_matchers, template)
+            # raise MatcherInitializationError, "#{self.class}: #{template} should be a Hash" unless template.is_a?(Hash)
+            raise MatcherInitializationError, "#{self.class}: #{value_matchers} should be an Array" unless value_matchers.is_a?(Array)
+            raise MatcherInitializationError, "#{self.class}: #{value_matchers} should be instances of Sbmt::Pact::Matchers::Base" unless value_matchers.all?(Sbmt::Pact::Matchers::Base)
+            raise MatcherInitializationError, "#{self.class}: #{value_matchers} size should be greater than 0" unless value_matchers.size > 0
+
+            super(spec_version: Sbmt::Pact::Matchers::PACT_SPEC_V4, kind: "each-value", template: template, opts: {rules: value_matchers})
+          end
+
+          def as_plugin
+            if @template.is_a?(Hash)
+              return {
+                "pact:match" => "eachValue(matching($'SAMPLE'))",
+                "SAMPLE" => serialize!(@template.deep_dup, :plugin)
+              }
+            end
+
+            @opts[:rules].map do |matcher|
+              "eachValue(#{matcher.as_plugin})"
+            end.join(", ")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sbmt/pact/matchers/v4/not_empty.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Pact
+    module Matchers
+      module V4
+        class NotEmpty < Sbmt::Pact::Matchers::Base
+          def initialize(template)
+            raise MatcherInitializationError, "#{self.class}: #{template} should not be empty" if template.blank?
+
+            super(spec_version: Sbmt::Pact::Matchers::PACT_SPEC_V4, kind: "time", template: template)
+          end
+        end
+      end
+    end
+  end
+end