pact 1.67.5 → 2.0.0

data/lib/pact/generators/base.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+module Pact
+  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

data/lib/pact/generators.rb

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

data/lib/pact/matchers/base.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+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 < Pact::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::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

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

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

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

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

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pact
+  module Matchers
+    module V2
+      class Type < Pact::Matchers::Base
+        def initialize(template)
+          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) # rubocop:disable Layout/LineLength
+            raise MatcherInitializationError,
+                  "#{self.class}: template is not a primitive"
+          end
+
+          super(spec_version: Pact::Matchers::PACT_SPEC_V2, kind: 'type', template: template)
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Pact
+  module Matchers
+    module V3
+      class ContentType < Pact::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::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

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

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

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

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

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

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

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Pact
+  module Matchers
+    module V3
+      class Each < Pact::Matchers::Base
+        def initialize(template, min)
+          if min.present? && min < 1
+            raise MatcherInitializationError,
+                  "#{self.class}: #{min} should be greater than 0"
+          end
+
+          min_array_size = min.presence || 1
+          val = template.is_a?(Array) ? template : [template] * min_array_size
+
+          if min_array_size != val.size
+            raise MatcherInitializationError,
+                  "#{self.class}: #{min} is invalid: template size is #{val.size}"
+          end
+
+          super(
+            spec_version: 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

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

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

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

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

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

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