feat: implemented content type matcher

core/matchers/src/main/kotlin/au/com/dius/pact/core/matchers/MatcherExecutor.kt

@@ -1,5 +1,8 @@
 package au.com.dius.pact.core.matchers
 
+import au.com.dius.pact.core.model.ContentType
+import au.com.dius.pact.core.model.OptionalBody
+import au.com.dius.pact.core.model.matchingrules.ContentTypeMatcher
 import au.com.dius.pact.core.model.matchingrules.DateMatcher
 import au.com.dius.pact.core.model.matchingrules.IncludeMatcher
 import au.com.dius.pact.core.model.matchingrules.MatchingRule
@@ -17,6 +20,9 @@ import au.com.dius.pact.core.model.matchingrules.TypeMatcher
 import au.com.dius.pact.core.support.json.JsonValue
 import mu.KotlinLogging
 import org.apache.commons.lang3.time.DateUtils
+import org.apache.tika.config.TikaConfig
+import org.apache.tika.io.TikaInputStream
+import org.apache.tika.metadata.Metadata
 import org.w3c.dom.Element
 import org.w3c.dom.Text
 import java.math.BigDecimal
@@ -120,6 +126,7 @@ fun <M : Mismatch> domatch(
             matchMaxType(matcher.max, path, expected, actual, mismatchFn)
     is IncludeMatcher -> matchInclude(matcher.value, path, expected, actual, mismatchFn)
     is NullMatcher -> matchNull(path, actual, mismatchFn)
+    is ContentTypeMatcher -> matchContentType(path, ContentType.fromString(matcher.contentType), actual, mismatchFn)
     else -> matchEquality(path, expected, actual, mismatchFn)
   }
 }
@@ -414,3 +421,32 @@ fun <M : Mismatch> matchNull(path: List<String>, actual: Any?, mismatchFactory:
     listOf(mismatchFactory.create(null, actual, "Expected ${valueOf(actual)} to be null", path))
   }
 }
+
+private val tika = TikaConfig()
+
+fun <M : Mismatch> matchContentType(
+  path: List<String>,
+  contentType: ContentType,
+  actual: Any?,
+  mismatchFactory: MismatchFactory<M>
+): List<M> {
+  val binaryData = when (actual) {
+    is ByteArray -> actual
+    else -> actual.toString().toByteArray(contentType.asCharset())
+  }
+  val metadata = Metadata()
+  val stream = TikaInputStream.get(binaryData)
+  val detectedContentType = stream.use { stream ->
+    tika.detector.detect(stream, metadata)
+  }
+  val matches = contentType.equals(detectedContentType)
+  logger.debug { "Matching binary contents by content type: " +
+    "expected '$contentType', detected '$detectedContentType' -> $matches" }
+  return if (matches) {
+    emptyList()
+  } else {
+    listOf(mismatchFactory.create(contentType.toString(), actual,
+      "Expected binary contents to have content type '$contentType' " +
+        "but detected contents was '$detectedContentType'", path))
+  }
+}

core/matchers/src/test/groovy/au/com/dius/pact/core/matchers/ContentTypeMatcherSpec.groovy

@@ -0,0 +1,40 @@
+package au.com.dius.pact.core.matchers
+
+import spock.lang.Specification
+import au.com.dius.pact.core.model.ContentType
+
+class ContentTypeMatcherSpec extends Specification {
+  def 'matching binary data where content type matches'() {
+    given:
+    def path = []
+    def contentType = ContentType.fromString('application/pdf')
+    def actual = ContentTypeMatcherSpec.getResourceAsStream('/sample.pdf').bytes
+    def mismatchFactory = [create: { p1, p2, message, p3 ->
+      new BodyMismatch(p1, p2, message, 'path')
+    }] as MismatchFactory
+
+    when:
+    def result = MatcherExecutorKt.matchContentType(path, contentType, actual, mismatchFactory)
+
+    then:
+    result.empty
+  }
+
+  def 'matching binary data where content type does not match'() {
+    given:
+    def path = []
+    def contentType = ContentType.fromString('application/pdf')
+    def actual = '"I\'m a PDF!"'.bytes
+    def mismatchFactory = [create: { p1, p2, message, p3 ->
+      new BodyMismatch(p1, p2, message, 'path')
+    }] as MismatchFactory
+
+    when:
+    def result = MatcherExecutorKt.matchContentType(path, contentType, actual, mismatchFactory)
+
+    then:
+    !result.empty
+    result*.mismatch == [
+      'Expected binary contents to have content type \'application/pdf\' but detected contents was \'text/plain\'']
+  }
+}

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

@@ -9,7 +9,7 @@ import java.nio.charset.Charset
 private val jsonRegex = Regex(".*json")
 private val xmlRegex = Regex(".*xml")
 
-data class ContentType(val contentType: MediaType?) {
+class ContentType(val contentType: MediaType?) {
 
   constructor(contentType: String) : this(MediaType.parse(contentType))
 
@@ -74,6 +74,19 @@ data class ContentType(val contentType: MediaType?) {
     contentType.baseType.type == "multipart"
     else false
 
+  override fun equals(other: Any?): Boolean {
+    return when {
+      this === other -> true
+      other is MediaType -> contentType == other
+      other !is ContentType -> false
+      else -> contentType == other.contentType
+    }
+  }
+
+  override fun hashCode(): Int {
+    return contentType?.hashCode() ?: 0
+  }
+
   companion object : KLogging() {
     @JvmStatic
     fun fromString(contentType: String?) = if (contentType.isNullOrEmpty()) {

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

@@ -119,6 +119,13 @@ object ValuesMatcher : MatchingRule {
   override fun toMap(spec: PactSpecVersion) = mapOf("match" to "values")
 }
 
+/**
+ * Content type matcher. Matches the content type of binary data
+ */
+data class ContentTypeMatcher @JvmOverloads constructor (val contentType: String) : MatchingRule {
+  override fun toMap(spec: PactSpecVersion) = mapOf("match" to "contentType", "value" to contentType)
+}
+
 data class MatchingRuleGroup @JvmOverloads constructor(
   val rules: MutableList<MatchingRule> = mutableListOf(),
   val ruleLogic: RuleLogic = RuleLogic.AND
@@ -209,6 +216,7 @@ data class MatchingRuleGroup @JvmOverloads constructor(
             if (map.containsKey(DATE)) DateMatcher(map[DATE].toString())
             else DateMatcher()
           "values" -> ValuesMatcher
+          "contentType" -> ContentTypeMatcher(map["value"].toString())
           else -> {
             logger.warn { "Unrecognised matcher ${map[MATCH]}, defaulting to equality matching" }
             EqualsMatcher