Merge pull request #193 from ProjectMapK/github-722

Fixed `JacksonInject` to take precedence over default arguments.

Author: k163377

src/main/kotlin/io/github/projectmapk/jackson/module/kogera/deser/valueInstantiator/KotlinValueInstantiator.kt

@@ -66,21 +66,17 @@ internal class KotlinValueInstantiator(
             val jsonProp = props[idx]
             val isMissing = !buffer.hasParameter(jsonProp)
 
-            if (isMissing && paramDef.isOptional) {
-                return@forEachIndexed
-            }
-
             var paramVal = if (!isMissing || jsonProp.hasInjectableValueId()) {
                 buffer.getParameter(jsonProp).apply {
                     if (this == null && jsonProp.skipNulls() && paramDef.isOptional) return@forEachIndexed
                 }
             } else {
-                if (paramDef.isNullable) {
+                when {
+                    paramDef.isOptional -> return@forEachIndexed
                     // do not try to create any object if it is nullable and the value is missing
-                    null
-                } else {
+                    paramDef.isNullable -> null
                     // to get suitable "missing" value provided by deserializer
-                    jsonProp.valueDeserializer?.getAbsentValue(ctxt)
+                    else -> jsonProp.valueDeserializer?.getAbsentValue(ctxt)
                 }
             }
 

src/test/kotlin/io/github/projectmapk/jackson/module/kogera/zPorted/test/github/Github722.kt

@@ -0,0 +1,67 @@
+package io.github.projectmapk.jackson.module.kogera.zPorted.test.github
+
+import com.fasterxml.jackson.annotation.JacksonInject
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.fasterxml.jackson.databind.InjectableValues
+import com.fasterxml.jackson.databind.ObjectMapper
+import io.github.projectmapk.jackson.module.kogera.jacksonObjectMapper
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+private class Github722 {
+    data class FailingDto @JsonCreator constructor(
+        @JacksonInject("foo")
+        @JsonProperty("foo")
+        val foo: Int = 100,
+        @JacksonInject("bar")
+        @JsonProperty("bar")
+        val bar: Int? = 200
+    )
+
+    val injectValues = mapOf("foo" to 1, "bar" to 2)
+    val expected = FailingDto(1, 2)
+
+    @Test
+    fun onPlainMapper() {
+        // Succeeds in plain mapper
+        val plainMapper = ObjectMapper()
+        assertEquals(
+            expected,
+            plainMapper.readerFor(FailingDto::class.java)
+                .with(InjectableValues.Std(injectValues))
+                .readValue("{}")
+        )
+    }
+
+    @Test
+    fun failing() {
+        // The kotlin mapper uses the Kotlin default value instead of the Inject value.
+        val kotlinMapper = jacksonObjectMapper()
+        val result = kotlinMapper.readerFor(FailingDto::class.java)
+            .with(InjectableValues.Std(injectValues))
+            .readValue<FailingDto>("{}")
+
+        // fixed
+        // assertNotEquals(result, expected, "GitHubXXX fixed.")
+        assertEquals(expected, result)
+    }
+
+    data class WithoutDefaultValue(
+        @JacksonInject("foo")
+        val foo: Int,
+        @JacksonInject("bar")
+        val bar: Int?
+    )
+
+    @Test
+    fun withoutDefaultValue() {
+        val kotlinMapper = jacksonObjectMapper()
+        val result = kotlinMapper.readerFor(WithoutDefaultValue::class.java)
+            .with(InjectableValues.Std(injectValues))
+            .readValue<WithoutDefaultValue>("{}")
+
+        // If there is no default value, the problem does not occur.
+        assertEquals(WithoutDefaultValue(1, 2), result)
+    }
+}