feat: convert number type matchers to type matchers when spec version < 3 #958

Author: Ronald Holshausen

consumer/pact-jvm-consumer/src/test/groovy/au/com/dius/pact/consumer/dsl/PactDslJsonBodySpec.groovy

@@ -305,10 +305,10 @@ class PactDslJsonBodySpec extends Specification {
     pactDslJsonBody.matchers.toMap(PactSpecVersion.V2) == [
       '$.body.contactDetails.mobile.countryCode': [match: 'type'],
       '$.body.contactDetails.mobile.prefix': [match: 'type'],
-      '$.body.contactDetails.mobile.subscriberNumber': [match: 'number'],
+      '$.body.contactDetails.mobile.subscriberNumber': [match: 'type'],
       '$.body.contactDetails2.mobile.countryCode': [match: 'type'],
       '$.body.contactDetails2.mobile.prefix': [match: 'type'],
-      '$.body.contactDetails2.mobile.subscriberNumber': [match: 'number']
+      '$.body.contactDetails2.mobile.subscriberNumber': [match: 'type']
     ]
     pactDslJsonBody.generators.toMap(PactSpecVersion.V3) == [
       body: [

core/model/src/main/kotlin/au/com/dius/pact/core/model/matchingrules/MatchingRules.kt

@@ -15,49 +15,57 @@ enum class RuleLogic {
  * Matching rule
  */
 interface MatchingRule {
+  @Deprecated("Use version that takes a spec version")
   fun toMap(): Map<String, Any?>
+  fun toMap(spec: PactSpecVersion): Map<String, Any?>
 }
 
 /**
  * Matching Rule for dates
  */
 data class DateMatcher @JvmOverloads constructor(val format: String = "yyyy-MM-dd") : MatchingRule {
   override fun toMap() = mapOf("match" to "date", "date" to format)
+  override fun toMap(spec: PactSpecVersion) = toMap()
 }
 
 /**
  * Matching rule for equality
  */
 object EqualsMatcher : MatchingRule {
   override fun toMap() = mapOf("match" to "equality")
+  override fun toMap(spec: PactSpecVersion) = toMap()
 }
 
 /**
  * Matcher for a substring in a string
  */
 data class IncludeMatcher(val value: String) : MatchingRule {
   override fun toMap() = mapOf("match" to "include", "value" to value)
+  override fun toMap(spec: PactSpecVersion) = toMap()
 }
 
 /**
  * Type matching with a maximum size
  */
 data class MaxTypeMatcher(val max: Int) : MatchingRule {
   override fun toMap() = mapOf("match" to "type", "max" to max)
+  override fun toMap(spec: PactSpecVersion) = toMap()
 }
 
 /**
  * Type matcher with a minimum size and maximum size
  */
 data class MinMaxTypeMatcher(val min: Int, val max: Int) : MatchingRule {
   override fun toMap() = mapOf("match" to "type", "min" to min, "max" to max)
+  override fun toMap(spec: PactSpecVersion) = toMap()
 }
 
 /**
  * Type matcher with a minimum size
  */
 data class MinTypeMatcher(val min: Int) : MatchingRule {
   override fun toMap() = mapOf("match" to "type", "min" to min)
+  override fun toMap(spec: PactSpecVersion) = toMap()
 }
 
 /**
@@ -70,49 +78,60 @@ data class NumberTypeMatcher(val numberType: NumberType) : MatchingRule {
     DECIMAL
   }
 
-  override fun toMap() = mapOf("match" to numberType.name.toLowerCase())
+  override fun toMap() = toMap(PactSpecVersion.V3)
+  override fun toMap(spec: PactSpecVersion) = if (spec >= PactSpecVersion.V3) {
+    mapOf("match" to numberType.name.toLowerCase())
+  } else {
+    TypeMatcher.toMap(spec)
+  }
 }
 
 /**
  * Regular Expression Matcher
  */
 data class RegexMatcher @JvmOverloads constructor (val regex: String, val example: String? = null) : MatchingRule {
   override fun toMap() = mapOf("match" to "regex", "regex" to regex)
+  override fun toMap(spec: PactSpecVersion) = toMap()
 }
 
 /**
  * Matcher for time values
  */
 data class TimeMatcher @JvmOverloads constructor(val format: String = "HH:mm:ss") : MatchingRule {
   override fun toMap() = mapOf("match" to "time", "time" to format)
+  override fun toMap(spec: PactSpecVersion) = toMap()
 }
 
 /**
  * Matcher for time values
  */
 data class TimestampMatcher @JvmOverloads constructor(val format: String = "yyyy-MM-dd HH:mm:ssZZZ") : MatchingRule {
   override fun toMap() = mapOf("match" to "timestamp", "timestamp" to format)
+  override fun toMap(spec: PactSpecVersion) = toMap()
 }
 
 /**
  * Matcher for types
  */
 object TypeMatcher : MatchingRule {
   override fun toMap() = mapOf("match" to "type")
+  override fun toMap(spec: PactSpecVersion) = toMap()
 }
 
 /**
  * Matcher for null values
  */
 object NullMatcher : MatchingRule {
   override fun toMap() = mapOf("match" to "null")
+  override fun toMap(spec: PactSpecVersion) = toMap()
 }
 
 /**
  * Matcher for values in a map, ignoring the keys
  */
 object ValuesMatcher : MatchingRule {
   override fun toMap() = mapOf("match" to "values")
+  override fun toMap(spec: PactSpecVersion) = toMap()
 }
 
 data class MatchingRuleGroup @JvmOverloads constructor(
@@ -121,7 +140,7 @@ data class MatchingRuleGroup @JvmOverloads constructor(
 ) {
   fun toMap(pactSpecVersion: PactSpecVersion): Map<String, Any?> {
     return if (pactSpecVersion < PactSpecVersion.V3) {
-      rules.first().toMap()
+      rules.first().toMap(pactSpecVersion)
     } else {
       mapOf("matchers" to rules.map { it.toMap() }, "combine" to ruleLogic.name)
     }

core/model/src/test/groovy/au/com/dius/pact/core/model/matchingrules/MatchingRuleGroupSpec.groovy

@@ -1,8 +1,10 @@
 package au.com.dius.pact.core.model.matchingrules
 
+import au.com.dius.pact.core.model.PactSpecVersion
 import spock.lang.Specification
 import spock.lang.Unroll
 
+@SuppressWarnings('LineLength')
 class MatchingRuleGroupSpec extends Specification {
 
   @Unroll
@@ -44,4 +46,26 @@ class MatchingRuleGroupSpec extends Specification {
     expect:
     new MatchingRuleGroup().ruleLogic == RuleLogic.AND
   }
+
+  @Unroll
+  def 'Converts number matchers to type matchers when spec is < V3'() {
+    expect:
+    new MatchingRuleGroup([matcher]).toMap(PactSpecVersion.V2) == map
+
+    where:
+    matcher                                                     | map
+    EqualsMatcher.INSTANCE                                      | [match: 'equality']
+    new RegexMatcher('.*')                                      | [match: 'regex', regex: '.*']
+    TypeMatcher.INSTANCE                                        | [match: 'type']
+    new NumberTypeMatcher(NumberTypeMatcher.NumberType.DECIMAL) | [match: 'type']
+    new MinTypeMatcher(1)                                       | [match: 'type', min: 1]
+    new MaxTypeMatcher(1)                                       | [match: 'type', max: 1]
+    new MinMaxTypeMatcher(2, 3)                                 | [match: 'type', max: 3, min: 2]
+    new TimestampMatcher()                                      | [match: 'timestamp', timestamp: 'yyyy-MM-dd HH:mm:ssZZZ']
+    new TimeMatcher()                                           | [match: 'time', time: 'HH:mm:ss']
+    new DateMatcher()                                           | [match: 'date', date: 'yyyy-MM-dd']
+    new IncludeMatcher('A')                                     | [match: 'include', value: 'A']
+    ValuesMatcher.INSTANCE                                      | [match: 'values']
+    NullMatcher.INSTANCE                                        | [match: 'null']
+  }
 }