Merge pull request #33 from openapi-processor/mapping-check-format

check on primitive could ignore the format

Author: hauner

openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/MappingFinder.kt

@@ -284,24 +284,31 @@ class IoMatcher(schema: MappingSchema): BaseVisitor(schema) {
 class TypeMatcher(schema: MappingSchema): BaseVisitor(schema) {
 
     override fun match(mapping: TypeMapping): Boolean {
-        if (mapping.sourceTypeName == schema.getName()) {
+        // try to match by name first, the format must match to avoid matching primitive
+        // and primitive with format e.g. string should not match string:binary
+        if (matchesName(mapping) && matchesFormat(mapping)) {
             return true
         }
 
         return when {
             schema.isPrimitive() -> {
-                mapping.sourceTypeName == schema.getType()
-             && mapping.sourceTypeFormat == schema.getFormat()
+                matchesType(mapping) && matchesFormat(mapping)
             }
             schema.isArray() -> {
-                mapping.sourceTypeName == "array"
+                matchesArray(mapping)
             }
             else -> {
+                // nop
                 false
             }
         }
     }
 
+    private fun matchesName(mapping: TypeMapping): Boolean = mapping.sourceTypeName == schema.getName()
+    private fun matchesType(mapping: TypeMapping): Boolean = mapping.sourceTypeName == schema.getType()
+    private fun matchesArray(mapping: TypeMapping): Boolean = mapping.sourceTypeName == "array"
+    private fun matchesFormat(mapping: TypeMapping): Boolean = mapping.sourceTypeFormat == schema.getFormat()
+
 }
 
 class ResultTypeMatcher(schema: MappingSchema): BaseVisitor(schema) {

openapi-processor-core/src/test/groovy/com/github/hauner/openapi/core/converter/DataTypeConverterPrimitiveTypeMappingSpec.groovy

@@ -76,6 +76,56 @@ paths:
         parameter.dataType.name == 'ZonedDateTime'
     }
 
+    void "primitive type dose not match primitive global type mapping with format" () {
+        def openApi = parse ("""\
+openapi: 3.0.2
+
+info:
+  title: API
+  version: 1.0.0
+
+paths:
+  /foo:
+    get:
+      parameters:
+        - in: query
+          name: foo
+          schema:
+            type: array
+            items:
+              type: string
+      responses:
+        200:
+          description: response
+          content:
+            application/*:
+              schema:
+                type: string
+                format: binary
+
+""")
+
+        when:
+        def options = new ApiOptions(
+            packageName: 'pkg',
+            typeMappings: [
+                new TypeMapping (
+                    'string',
+                    'binary',
+                    'io.openapiprocessor.Bar')
+            ])
+
+        Api api = new ApiConverter (options, new FrameworkBase ())
+            .convert (openApi)
+
+        then:
+        def itf = api.interfaces.first ()
+        def ep = itf.endpoints.first ()
+        def parameter = ep.parameters.first ()
+        parameter.dataType.packageName == 'java.lang'
+        parameter.dataType.name == 'String[]'
+    }
+
     void "converts named primitive type to java type via global type mapping" () {
         def openApi = parse ("""\
 openapi: 3.0.2