pact-v2 2.0.0.pre.preview2 → 2.0.0.pre.preview3

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

@@ -0,0 +1,180 @@
+# 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 PluginSyncMessageInteractionBuilder
+
+        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 || ""
+          @request = nil
+          @response = nil
+          @response_meta = nil
+          @provider_state_meta = nil
+        end
+
+        def with_plugin(plugin_name, plugin_version)
+          raise InteractionBuilderError.new("plugin_name is required") if plugin_name.blank?
+          raise InteractionBuilderError.new("plugin_version is required") if plugin_version.blank?
+
+          @plugin_name = plugin_name
+          @plugin_version = plugin_version
+          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 with_content_type(content_type)
+          @content_type = content_type
+          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 with_plugin_metadata(meta_hash)
+          @plugin_metadata = meta_hash
+          self
+        end
+
+        def with_transport(transport)
+          @transport = transport
+          self
+        end
+
+        def interaction_json
+          result = {
+            request: @request
+          }
+          result.merge!(@plugin_metadata) if @plugin_metadata.is_a?(Hash)
+
+          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("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, @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_transport!(pact: pact_handle, transport: @transport, host: @pact_config.mock_host, port: @pact_config.mock_port)
+
+          yield(message_pact, mock_server)
+
+        ensure
+          if mock_server.matched?
+            mock_server.write_pacts!(@pact_config.pact_dir)
+          else
+            msg = mismatches_error_msg(mock_server)
+            raise InteractionMismatchesError.new(msg)
+          end
+          @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 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, @plugin_name, @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 #{@plugin_name}/#{@plugin_version}", error[:reason], error[:status])
+        end
+      end
+    end
+  end
+end

data/lib/pact/v2/generators/base.rb

@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Generators
+      module Base
+        def as_basic
+          raise NotImplementedError, "Subclasses must implement the as_basic method"
+        end
+      end
+
+      class RandomIntGenerator
+        include Base
+
+        def initialize(min:, max:)
+          @min = min
+          @max = max
+        end
+
+        def as_basic
+          {
+            "pact:matcher:type" => "integer",
+            "pact:generator:type" => "RandomInt",
+            "min" => @min,
+            "max" => @max,
+            "value" => rand(@min..@max)
+          }
+        end
+      end
+
+      class RandomDecimalGenerator
+        include Base
+
+        def initialize(digits:)
+          @digits = digits
+        end
+
+        def as_basic
+          {
+            'pact:matcher:type' => 'decimal',
+            "pact:generator:type" => "RandomDecimal",
+            "digits" => @digits,
+            "value" => rand.round(@digits)
+          }
+        end
+      end
+
+      class RandomHexadecimalGenerator
+        include Base
+
+        def initialize(digits:)
+          @digits = digits
+        end
+
+        def as_basic
+          {
+            "pact:matcher:type" => "decimal",
+            "pact:generator:type" => "RandomHexadecimal",
+            "digits" => @digits,
+            "value" => SecureRandom.hex((@digits / 2.0).ceil)[0...@digits]
+          }
+        end
+      end
+
+      class RandomStringGenerator
+        include Base
+
+        def initialize(size:, example: nil)
+          @size = size
+          @example = example
+        end
+
+        def as_basic
+          {
+            "pact:matcher:type" => "type",
+            "pact:generator:type" => "RandomString",
+            "size" => @size,
+            "value" => @example || SecureRandom.alphanumeric(@size)
+          }
+        end
+      end
+
+      class UuidGenerator
+        include Base
+
+    
+        def initialize(example: nil)
+          @example = example
+          @regexStr = '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}';
+          if @example
+            regex = Regexp.new("^#{@regexStr}$")
+            unless @example.match?(regex)
+              raise ArgumentError, "regex: Example value '#{@example}' does not match the UUID regular expression '#{@regexStr}'"
+            end
+          end
+        end
+
+        def as_basic
+          {
+            "pact:matcher:type" => "regex",
+            "pact:generator:type" => "Uuid",
+            "regex" => @regexStr,
+            "value" => @example || SecureRandom.uuid
+          }
+        end
+      end
+
+      class DateGenerator
+        include Base
+
+        def initialize(format: nil, example: nil)
+          @format = format || default_format
+          @example = example || Time.now.strftime(convert_from_java_simple_date_format(@format))
+        end
+
+        def as_basic
+          h = { "pact:generator:type" => type }
+          h["pact:matcher:type"] = matcher_type
+          h["format"] = @format if @format
+          h["value"] = @example
+          h
+        end
+
+        def type
+          'Date'
+        end
+
+        def matcher_type
+          'date'
+        end
+
+        def default_format
+          'yyyy-MM-dd'
+        end
+
+        # Converts Java SimpleDateFormat to Ruby strftime format
+        def convert_from_java_simple_date_format(format)
+          f = format.dup
+          # Year
+          f.gsub!(/(?<!%)y{4,}/, '%Y')
+          f.gsub!(/(?<!%)y{1,3}/, '%y')
+          # Month
+          f.gsub!(/(?<!%)M{4,}/, '%B')
+          f.gsub!(/(?<!%)M{3}/, '%b')
+          f.gsub!(/(?<!%)M{1,2}/, '%m')
+          # Week
+          f.gsub!(/(?<!%)w{1,}/, '%W')
+          # Day
+          f.gsub!(/(?<!%)D{1,}/, '%j')
+          f.gsub!(/(?<!%)d{1,}/, '%d')
+          f.gsub!(/(?<!%)E{4,}/, '%A')
+          f.gsub!(/(?<!%)E{1,3}/, '%a')
+          f.gsub!(/(?<!%)u{1,}/, '%u')
+          # Time
+          f.gsub!(/(?<!%)a{1,}/, '%p')
+          f.gsub!(/(?<!%)k{1,}/, '%H')
+          f.gsub!(/(?<!%)n{1,}/, '%M')
+          f.gsub!(/(?<!%)s{1,}/, '%S')
+          f.gsub!(/(?<!%)S{1,}/, '%L')
+          # Timezone
+          f.gsub!(/(?<!%)z{1,}/, '%z')
+          f.gsub!(/(?<!%)Z{1,}/, '%z')
+          f.gsub!(/(?<!%)X{1,}/, '%Z')
+          # Java 'H' (hour in day, 0-23) to Ruby '%H'
+          f.gsub!(/(?<!%)H{2}/, '%H')
+          f.gsub!(/(?<!%)H{1}/, '%k')
+          # Java 'm' (minute in hour) to Ruby '%M'
+          f.gsub!(/(?<!%)m{2}/, '%M')
+          f.gsub!(/(?<!%)m{1}/, '%-M')
+          # Java 'h' (hour in am/pm, 1-12) to Ruby '%I'
+          f.gsub!(/(?<!%)h{2}/, '%I')
+          f.gsub!(/(?<!%)h{1}/, '%-I')
+          # Java 's' (second in minute) to Ruby '%S'
+          f.gsub!(/(?<!%)s{1,}/, '%S')
+          # Java 'a' (am/pm marker) to Ruby '%p'
+          f.gsub!(/(?<!%)a/, '%p')
+          # Java 'K' (hour in am/pm, 0-11) to Ruby '%l'
+          f.gsub!(/(?<!%)K{2}/, '%l')
+          f.gsub!(/(?<!%)K{1}/, '%-l')
+          # Java 'S' (fractional seconds, milliseconds) to Ruby '%L'
+          f.gsub!(/(?<!%)S{1,}/, '%L')
+          # Java 'z' (general time zone) to Ruby '%Z'
+          f.gsub!(/(?<!%)z{1,}/, '%Z')
+          # Java 'Z' (RFC 822 time zone) to Ruby '%z'
+          f.gsub!(/(?<!%)Z{1,}/, '%z')
+          # Java 'X' (ISO 8601 time zone) to Ruby '%z'
+          f.gsub!(/(?<!%)X{1,}/, '%z')
+          # Java 'G' (era designator) - no direct Ruby equivalent, remove or leave as is
+          f.gsub!(/(?<!%)G+/, '%G')
+          # Java 'Q' (quarter) - no direct Ruby equivalent, remove or leave as is
+          f.gsub!(/(?<!%)Q+/, '')
+          # Java 'F' (day of week in month) - no direct Ruby equivalent, remove or leave as is
+          f.gsub!(/(?<!%)F+/, '')
+          # Java 'c' (stand-alone day of week) - no direct Ruby equivalent, remove or leave as is
+          f.gsub!(/(?<!%)c+/, '')
+          # Java 'L' (stand-alone month) - treat as month
+          f.gsub!(/(?<!%)L{4,}/, '%B')
+          f.gsub!(/(?<!%)L{3}/, '%b')
+          f.gsub!(/(?<!%)L{1,2}/, '%m')
+          f
+        end
+      end
+
+      # Time provides the time generator which will give the current time in the defined format
+      class TimeGenerator < DateGenerator
+        def type
+          'Time'
+        end
+
+        def matcher_type
+          'time'
+        end
+
+        def default_format
+          'HH:mm'
+        end
+      end
+
+      class DateTimeGenerator < DateGenerator
+        def type
+          'DateTime'
+        end
+
+        def matcher_type
+          'datetime'
+        end
+
+        def default_format
+          'yyyy-MM-dd HH:mm'
+        end
+      end
+
+      class RandomBooleanGenerator
+        include Base
+
+        def initialize(example: nil)
+          @example = example
+        end
+
+        def as_basic
+          {
+            "pact:matcher:type" => "boolean",
+            "pact:generator:type" => "RandomBoolean",
+            "value" => @example.nil? ? [true, false].sample : @example
+          }
+        end
+      end
+
+      class ProviderStateGenerator
+        include Base
+
+        def initialize(expression:, example:)
+          @expression = expression
+          @value = example
+        end
+
+        def as_basic
+          {
+            'pact:matcher:type': 'type',
+            "pact:generator:type" => "ProviderState",
+            "expression" => @expression,
+            "value" => @value
+          }
+        end
+      end
+
+      class MockServerURLGenerator
+        include Base
+
+        def initialize(regex:, example:)
+          @regex = regex
+          @example = example
+        end
+
+        def as_basic
+          {
+            "pact:generator:type" => "MockServerURL",
+            "pact:matcher:type" => "regex",
+            "regex" => @regex,
+            "example" => @example,
+            "value" => @example
+          }
+        end
+      end
+    end
+  end
+end

data/lib/pact/v2/generators.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Generators
+
+      def generate_random_int(min:, max:)
+        Pact::V2::Generators::RandomIntGenerator.new(min: min, max: max)
+      end 
+      def generate_random_decimal(digits:)
+        Pact::V2::Generators::RandomDecimalGenerator.new(digits: digits)
+      end
+      def generate_random_hexadecimal(digits:)
+        Pact::V2::Generators::RandomHexadecimalGenerator.new(digits: digits)
+      end
+      def generate_random_string(size:)
+        Pact::V2::Generators::RandomStringGenerator.new(size: size)
+      end
+
+      def generate_uuid(example: nil)
+        Pact::V2::Generators::UuidGenerator.new(example: example)
+      end
+
+      def generate_date(format: nil, example: nil)
+        Pact::V2::Generators::DateGenerator.new(format: format, example: example)
+      end
+
+      def generate_time(format: nil)
+        Pact::V2::Generators::TimeGenerator.new(format: format)
+      end
+
+      def generate_datetime(format: nil)
+        Pact::V2::Generators::DateTimeGenerator.new(format: format)
+      end
+
+      def generate_random_boolean
+        Pact::V2::Generators::RandomBooleanGenerator.new
+      end
+
+      def generate_from_provider_state(expression:, example:)
+        Pact::V2::Generators::ProviderStateGenerator.new(expression: expression, example: example).as_basic
+      end
+
+      def generate_mock_server_url(regex: nil, example: nil)
+        Pact::V2::Generators::MockServerURLGenerator.new(regex: regex, example: example)
+      end
+    end
+  end
+end

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

@@ -9,7 +9,7 @@ module Pact
 
         class MatcherInitializationError < Pact::V2::Error; end
 
-        def initialize(spec_version:, kind:, template:, opts: {})
+        def initialize(spec_version:, kind:, template: nil, opts: {})
           @spec_version = spec_version
           @kind = kind
           @template = template
@@ -17,15 +17,22 @@ module Pact
         end
 
         def as_basic
-          {
-            "pact:matcher:type" => serialize!(@kind.deep_dup, :basic),
-            "value" => serialize!(@template.deep_dup, :basic)
-          }.merge(serialize!(@opts.deep_dup, :basic))
+          result = {
+            "pact:matcher:type" => serialize!(@kind.deep_dup, :basic)
+          }
+          result["status"] = serialize!(@opts[:status].deep_dup, :basic) if @opts[:status]
+          result["value"] = serialize!(@template.deep_dup, :basic) unless @template.nil?
+          result.merge!(serialize!(@opts.deep_dup, :basic))
+          result
         end
 
         def as_plugin
           params = @opts.values.map { |v| format_primitive(v) }.join(",")
-          value = format_primitive(@template)
+          value = format_primitive(@template) unless @template.nil?
+
+          if @template.nil?
+            return "matching(#{@kind}#{params.present? ? ", #{params}" : ""})"
+          end
 
           return "matching(#{@kind}, #{params}, #{value})" if params.present?
 

data/lib/pact/v2/matchers/v3/content_type.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V3
+        class ContentType < Pact::V2::Matchers::Base
+          def initialize(content_type, template: nil)
+            @content_type = content_type
+            @template = template
+            @opts = {}
+            @opts[:plugin_template] = template unless template.nil?
+            unless content_type.is_a?(String) && !content_type.empty?
+              raise MatcherInitializationError, "#{self.class}: content_type must be a non-empty String"
+            end
+
+            super(
+              spec_version: Pact::V2::Matchers::PACT_SPEC_V3,
+              kind: "contentType",
+              template: content_type,
+              opts: @opts
+            )
+          end
+
+          def as_plugin
+            "matching(contentType, '#{@content_type}', '#{@opts[:plugin_template]}')"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/v2/matchers/v3/null.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V3
+        class Null < Pact::V2::Matchers::Base
+          def initialize
+            super(spec_version: Pact::V2::Matchers::PACT_SPEC_V3, kind: "null", template: nil)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/pact/v2/matchers/v3/semver.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V3
+        class Semver < Pact::V2::Matchers::Base
+          def initialize(template = nil)
+            @template = template
+            super(spec_version: Pact::V2::Matchers::PACT_SPEC_V3, kind: "semver", template: template)
+          end
+
+          def as_plugin
+            if @template.nil? || @template.blank?
+              raise MatcherInitializationError, "#{self.class}: template must be provided when calling as_plugin"
+            end
+            "matching(semver, '#{@template}')"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/v2/matchers/v3/values.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V3
+        class Values < Pact::V2::Matchers::Base
+          def initialize
+            super(spec_version: Pact::V2::Matchers::PACT_SPEC_V3, kind: "values", template: nil)
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -5,10 +5,17 @@ module Pact
     module Matchers
       module V4
         class NotEmpty < Pact::V2::Matchers::Base
-          def initialize(template)
-            raise MatcherInitializationError, "#{self.class}: #{template} should not be empty" if template.blank?
+          def initialize(template = nil)
+            @template = template
+            super(spec_version: Pact::V2::Matchers::PACT_SPEC_V4, kind: 'notEmpty', template: @template)
+          end
+
+          def as_plugin
+            if @template.nil? || @template.blank?
+              raise MatcherInitializationError, "#{self.class}: template must be provided when calling as_plugin"
+            end
 
-            super(spec_version: Pact::V2::Matchers::PACT_SPEC_V4, kind: "time", template: template)
+            "notEmpty('#{@template}')"
           end
         end
       end

data/lib/pact/v2/matchers/v4/status_code.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V4
+        class StatusCode < Pact::V2::Matchers::Base
+          def initialize(template = nil)
+            super(spec_version: Pact::V2::Matchers::PACT_SPEC_V4, kind: 'statusCode', opts: {
+              'status' => template
+            })
+          end
+        end
+      end
+    end
+  end
+end