Make JacksonAggregateMapper backwards and forward-compatible

Author: fmasa

app/build.gradle

@@ -139,4 +139,6 @@ dependencies {
     implementation "io.arrow-kt:arrow-core:0.10.4"
 
     implementation 'com.jakewharton.timber:timber:4.7.1'
+
+    testImplementation 'org.mockito:mockito-core:2.7.22'
 }

app/src/main/java/cz/muni/fi/rpg/model/firestore/jackson/JacksonAggregateMapper.kt

@@ -3,6 +3,7 @@ package cz.muni.fi.rpg.model.firestore.jackson
 import com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility
 import com.fasterxml.jackson.annotation.PropertyAccessor
 import com.fasterxml.jackson.core.type.TypeReference
+import com.fasterxml.jackson.databind.DeserializationFeature
 import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
 import com.google.firebase.firestore.DocumentSnapshot
 import cz.muni.fi.rpg.model.firestore.AggregateMapper
@@ -19,6 +20,7 @@ internal class JacksonAggregateMapper<T : Any>(
         .setVisibility(PropertyAccessor.GETTER, Visibility.NONE)
         .setVisibility(PropertyAccessor.FIELD, Visibility.ANY)
         .setVisibility(PropertyAccessor.IS_GETTER, Visibility.NONE)
+        .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
 
     override fun fromDocumentSnapshot(snapshot: DocumentSnapshot): T {
         Timber.d("Mapping document $snapshot to ${aggregateType.simpleName}")

app/src/test/java/cz/muni/fi/rpg/model/firestore/jackson/JacksonAggregateMapperTest.kt

@@ -0,0 +1,74 @@
+package cz.muni.fi.rpg.model.firestore.jackson
+
+import com.fasterxml.jackson.module.kotlin.jacksonTypeRef
+import com.google.firebase.firestore.DocumentSnapshot
+import junit.framework.TestCase
+import org.mockito.Mockito.`when`
+import org.mockito.Mockito.mock
+
+class JacksonAggregateMapperTest : TestCase("JacksonAggregateMapperTest") {
+    private class AggregateWithGetter {
+        val field = "foo"
+
+        fun getGetter() = field
+    }
+
+    private class AggregateWithIsGetter {
+        private val field = "foo"
+
+        fun isGetter() = false
+    }
+
+    private data class DataAggregate(val field: String)
+
+    private data class DataAggregateWithDefaultValue(
+        val field: String,
+        val fieldWithDefaultValue: String = "default_value"
+    )
+
+    fun testGettersAreIgnoredWhenMappingToDocumentData() {
+        val mapper = JacksonAggregateMapper(AggregateWithGetter::class, jacksonTypeRef())
+
+        assertEquals(
+            mapOf("field" to "foo"),
+            mapper.toDocumentData(AggregateWithGetter())
+        )
+    }
+
+    fun testIsGettersAreIgnoredWhenMappingToDocumentData() {
+        val mapper = JacksonAggregateMapper(AggregateWithIsGetter::class, jacksonTypeRef())
+
+        assertEquals(
+            mapOf("field" to "foo"),
+            mapper.toDocumentData(AggregateWithIsGetter())
+        )
+    }
+
+    fun testExtraFieldsAreIgnoredWhenHydratingAggregate() {
+        val mapper = JacksonAggregateMapper(DataAggregate::class, jacksonTypeRef())
+
+        val snapshot = mock(DocumentSnapshot::class.java)
+        `when`(snapshot.data).thenReturn(mapOf("field" to "foo", "extraField" to "bar"))
+
+        assertEquals(
+            DataAggregate("foo"),
+            mapper.fromDocumentSnapshot(snapshot)
+        )
+    }
+
+    fun testIfFieldWithDefaultValueIsMissingDefaultValueIsUsed() {
+        val mapper = JacksonAggregateMapper(DataAggregateWithDefaultValue::class, jacksonTypeRef())
+
+        val snapshot = mock(DocumentSnapshot::class.java)
+        `when`(snapshot.data)
+            .thenReturn(mapOf(
+                "field" to "foo",
+                "fieldWithDefaultValue" to "default_value"
+            ))
+
+        assertEquals(
+            DataAggregateWithDefaultValue("foo"),
+            mapper.fromDocumentSnapshot(snapshot)
+        )
+    }
+}