Reverse order of Transmission Risk Levels used for Diagnosis Keys Upload (closes #678) (#679)

* Reverse order of the "Transmission Risk Levels" profile for Diagnosis Keys upload
Also added test for ProtoFormatConverterExtensions.kt

* Reverse order of the "Transmission Risk Levels" profile for Diagnosis Keys upload
Small adjustments: 1) Use compareByDescending instead of compareBy and asReversed();
2) leave the list for upload in a reversed chronological order, just like in the iOS app;
3) add sorting to the test to keep the desired values in the test readable in chronological order

Co-authored-by: Hee Tatt Ooi <hee.tatt.ooi@sap.com>
Co-authored-by: Jakob Möller <jakob.moeller@sap.com>
Co-authored-by: harambasicluka <64483219+harambasicluka@users.noreply.github.com>

Corona-Warn-App/src/main/java/de/rki/coronawarnapp/util/ProtoFormatConverterExtensions.kt

@@ -30,12 +30,12 @@ object ProtoFormatConverterExtensions {
     private const val MAXIMUM_KEYS = 14
 
     fun List<TemporaryExposureKey>.limitKeyCount() =
-        this.sortedWith(compareBy { it.rollingStartIntervalNumber }).asReversed().take(MAXIMUM_KEYS)
+        this.sortedWith(compareByDescending { it.rollingStartIntervalNumber }).take(MAXIMUM_KEYS)
 
     fun List<TemporaryExposureKey>.transformKeyHistoryToExternalFormat() =
-        this.sortedWith(compareBy { it.rollingStartIntervalNumber })
+        this.sortedWith(compareByDescending { it.rollingStartIntervalNumber })
             .mapIndexed { index, it ->
-                // The earliest key we receive is from yesterday (i.e. 1 day ago),
+                // The latest key we receive is from yesterday (i.e. 1 day ago),
                 // thus we need use index+1
                 val riskValue =
                     if (index + 1 <= DEFAULT_TRANSMISSION_RISK_VECTOR.lastIndex)

Corona-Warn-App/src/test/java/de/rki/coronawarnapp/util/ProtoFormatConverterExtensionsTest.kt

+package de.rki.coronawarnapp.util
+
+import com.google.android.gms.nearby.exposurenotification.TemporaryExposureKey
+import de.rki.coronawarnapp.util.ProtoFormatConverterExtensions.transformKeyHistoryToExternalFormat
+import org.hamcrest.CoreMatchers
+import org.hamcrest.MatcherAssert
+import org.junit.Test
+
+private const val DEFAULT_TRANSMISSION_RISK_LEVEL = 1
+private const val TRANSMISSION_RISK_DAY_0 = 5
+private const val TRANSMISSION_RISK_DAY_1 = 6
+private const val TRANSMISSION_RISK_DAY_2 = 8
+private const val TRANSMISSION_RISK_DAY_3 = 8
+private const val TRANSMISSION_RISK_DAY_4 = 8
+private const val TRANSMISSION_RISK_DAY_5 = 5
+private const val TRANSMISSION_RISK_DAY_6 = 3
+private const val TRANSMISSION_RISK_DAY_7 = 1
+
+class ProtoFormatConverterExtensionsTest {
+
+    @Test
+    fun areTransmissionRiskLevelsCorrectlyAssigned() {
+
+        val key1 = byteArrayOf(
+            0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+            0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f
+        )
+
+        val diagnosisKeyList = mutableListOf<TemporaryExposureKey>()
+        val numKeys = 13
+        for (pos in 0 until numKeys) {
+            diagnosisKeyList.add(
+                TemporaryExposureKey.TemporaryExposureKeyBuilder()
+                    .setKeyData(key1)
+                    .setRollingStartIntervalNumber(pos * 144)
+                    .setRollingPeriod(144)
+                    .setTransmissionRiskLevel(0)
+                    .build()
+            )
+        }
+
+        val transformedKeyList = diagnosisKeyList.transformKeyHistoryToExternalFormat()
+            .sortedWith(compareBy { it.rollingStartIntervalNumber })
+
+        MatcherAssert.assertThat(
+            transformedKeyList.size,
+            CoreMatchers.equalTo(numKeys)
+        )
+
+        val correctRiskLevels = arrayOf(
+            DEFAULT_TRANSMISSION_RISK_LEVEL,
+            DEFAULT_TRANSMISSION_RISK_LEVEL,
+            DEFAULT_TRANSMISSION_RISK_LEVEL,
+            DEFAULT_TRANSMISSION_RISK_LEVEL,
+            DEFAULT_TRANSMISSION_RISK_LEVEL,
+            DEFAULT_TRANSMISSION_RISK_LEVEL,
+            TRANSMISSION_RISK_DAY_7,
+            TRANSMISSION_RISK_DAY_6,
+            TRANSMISSION_RISK_DAY_5,
+            TRANSMISSION_RISK_DAY_4,
+            TRANSMISSION_RISK_DAY_3,
+            TRANSMISSION_RISK_DAY_2,
+            TRANSMISSION_RISK_DAY_1
+        )
+
+        for (pos in 0 until numKeys) {
+            val key = transformedKeyList[pos]
+            MatcherAssert.assertThat(
+                key.transmissionRiskLevel,
+                CoreMatchers.equalTo(correctRiskLevels[pos])
+            )
+            MatcherAssert.assertThat(
+                key.rollingStartIntervalNumber,
+                CoreMatchers.equalTo(pos * 144)
+            )
+        }
+    }
+
+    @Test
+    fun areTransmissionRiskLevelsCorrectlyAssignedWithOnlyOneKey() {
+
+        val key1 = byteArrayOf(
+            0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+            0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f
+        )
+
+        val diagnosisKeyList = mutableListOf<TemporaryExposureKey>()
+        val numKeys = 1
+        for (pos in 0 until numKeys) {
+            diagnosisKeyList.add(
+                TemporaryExposureKey.TemporaryExposureKeyBuilder()
+                    .setKeyData(key1)
+                    .setRollingStartIntervalNumber(pos * 144)
+                    .setRollingPeriod(144)
+                    .setTransmissionRiskLevel(0)
+                    .build()
+            )
+        }
+
+        val transformedKeyList = diagnosisKeyList.transformKeyHistoryToExternalFormat()
+            .sortedWith(compareBy { it.rollingStartIntervalNumber })
+
+        MatcherAssert.assertThat(
+            transformedKeyList.size,
+            CoreMatchers.equalTo(numKeys)
+        )
+
+        val correctRiskLevels = arrayOf(
+            TRANSMISSION_RISK_DAY_1
+        )
+
+        for (pos in 0 until numKeys) {
+            val key = transformedKeyList[pos]
+            MatcherAssert.assertThat(
+                key.transmissionRiskLevel,
+                CoreMatchers.equalTo(correctRiskLevels[pos])
+            )
+            MatcherAssert.assertThat(
+                key.rollingStartIntervalNumber,
+                CoreMatchers.equalTo(pos * 144)
+            )
+        }
+    }
+}