pact 1.66.2 → 1.67.0

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    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 < Pact::V2::Error; end
+
+        def initialize(spec_version:, kind:, template: nil, opts: {})
+          @spec_version = spec_version
+          @kind = kind
+          @template = template
+          @opts = opts
+        end
+
+        def as_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) unless @template.nil?
+
+          if @template.nil?
+            return "matching(#{@kind}#{params.present? ? ", #{params}" : ""})"
+          end
+
+          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 Pact::V2::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/pact/v2/matchers/v1/equality.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V1
+        class Equality < Pact::V2::Matchers::Base
+          def initialize(template)
+            super(spec_version: Pact::V2::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/pact/v2/matchers/v2/regex.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V2
+        class Regex < Pact::V2::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: Pact::V2::Matchers::PACT_SPEC_V2, kind: "regex", template: template, opts: {regex: regex.to_s})
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V2
+        class Type < Pact::V2::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) || template.is_a?(Array) || template.is_a?(Hash)
+
+            super(spec_version: Pact::V2::Matchers::PACT_SPEC_V2, kind: "type", template: template)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V3
+        class Boolean < Pact::V2::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: Pact::V2::Matchers::PACT_SPEC_V3, kind: "boolean", template: template)
+          end
+        end
+      end
+    end
+  end
+end

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/date.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V3
+        class Date < Pact::V2::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: Pact::V2::Matchers::PACT_SPEC_V3, kind: "date", template: template, opts: {format: format})
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V3
+        class DateTime < Pact::V2::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: Pact::V2::Matchers::PACT_SPEC_V3, kind: "datetime", template: template, opts: {format: format})
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V3
+        class Each < Pact::V2::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: Pact::V2::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/pact/v2/matchers/v3/include.rb

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

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V3
+        class Integer < Pact::V2::Matchers::Base
+          def initialize(template)
+            raise MatcherInitializationError, "#{self.class}: #{template} should be an instance of Integer" unless template.is_a?(::Integer)
+
+            super(spec_version: Pact::V2::Matchers::PACT_SPEC_V3, kind: "integer", template: 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/number.rb

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