test: cobertura unitaria (18 -> 81) y smoke test de UI en CI (#1)

* test: cubrir versionado OTA, mapeo WMO y back-off del MCU

La lógica pura estaba atrapada como private dentro de clases que arrastran
Android (AndroidViewModel, Context), lo que obligaba a Robolectric para
probar un par de funciones sin dependencias. Se extraen a funciones
top-level internal en su propio módulo; ningún call site cambia.

- isNewer: de OtaViewModel a OtaInfo.kt
- wmoToCondition: de OpenMeteoWeatherDataSource a WeatherCondition.kt
- reconnectDelayMs: de TwUtilMcuDataSource (estaba inline en el retryWhen)

De paso corrige el back-off: attempt es Long y se narrowaba a Int antes de
recortar, así que Long.MAX_VALUE.toInt() daba -1 y shl solo lee los 6 bits
bajos del contador, produciendo un delay negativo que convertía la
reconexión en un busy loop sobre el UART. Ahora se recorta como Long antes
de bajar a Int.

63 tests nuevos: 18 -> 81.

* test: smoke test de UI por adb y job de CI

Conduce la app sobre adb y asierta contra el árbol de accesibilidad que
Compose ya expone (uiautomator ve cada nodo Text con sus bounds), así que
no hace falta tocar el código de la app ni añadir dependencias.

Localiza por texto y saca el centro de los bounds en vez de usar
coordenadas fijas, espera con polling hasta 15 s antes de rendirse, y al
fallar imprime todo el texto visible más un screenshot en build/smoke/.

La aserción del BACK va invertida a propósito: no existe ningún
BackHandler en el proyecto, así que el botón del sistema cierra la
Activity desde cualquier pantalla en vez de volver a la anterior. El
script pasa mientras el bug siga ahí y avisa el día que se arregle, en
lugar de quedarse en rojo permanente y que todos aprendan a ignorarlo.

En CI corre sobre API 29 a 768x1024, el mismo layout que el head unit.

* fix(smoke): esperar a que la Activity esté resumed en vez de dormir fijo

El arranque en frío en el emulador de CI tarda bastante más que en uno
local ya caliente, así que el sleep 3 tras am start convertía la primera
aserción en un fallo intermitente: el volcado del propio fallo mostraba
km/h presente 5 s después de que wait_for_text se rindiera.

Ahora espera a mResumedActivity hasta 60 s, y sube el timeout de las
aserciones a 30 s — cada poll cuesta un ui_dump completo (~2 s en CI),
así que 15 s eran apenas unos pocos intentos.

* fix(smoke): no usar grep -q en tuberías bajo pipefail

grep -q sale en cuanto encuentra la primera coincidencia, lo que manda
SIGPIPE al adb que sigue escribiendo. Con set -o pipefail el estado de la
tubería pasa a ser ese 141, así que la aserción fallaba justo cuando el
texto SÍ estaba presente — de ahí que el volcado del propio fallo lo
mostrara.

Localmente no se reproducía porque el dump es pequeño y adb termina de
escribir antes de que grep cierre la tubería; en CI el volcado tarda más
y el SIGPIPE sí ocurre. Verificado aparte:

  yes 'x' | head -200000 | grep -qF x   ->  PIPESTATUS = 141 141 0

Se sustituye por case sobre la captura, en wait_for_text/sees_now y en la
espera de mResumedActivity de launch().

---------

Co-authored-by: Daniel Noé Núñez López <daniel.nunez@stjsonora.gob.mx>

Author: danielnuld

.github/workflows/ci.yml

@@ -44,3 +44,46 @@ jobs:
           name: helm-debug
           path: app/build/outputs/apk/debug/app-debug.apk
           retention-days: 14
+
+  smoke:
+    name: UI smoke test
+    runs-on: ubuntu-latest
+    needs: build
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Download debug APK
+        uses: actions/download-artifact@v4
+        with:
+          name: helm-debug
+          path: app/build/outputs/apk/debug
+
+      # The emulator needs KVM, and the runner does not grant it by default.
+      - name: Enable KVM
+        run: |
+          echo 'KERNEL=="kvm", GROUP="kvm", MODE="0666", OPTIONS+="static_node=kvm"' \
+            | sudo tee /etc/udev/rules.d/99-kvm4all.rules
+          sudo udevadm control --reload-rules
+          sudo udevadm trigger --name-match=kvm
+
+      # API 29 + 768x1024 portrait mirrors the real head unit, so the smoke run
+      # exercises the same layout the car does.
+      - name: Run smoke test
+        uses: reactivecircus/android-emulator-runner@v2
+        with:
+          api-level: 29
+          target: google_apis
+          arch: x86_64
+          emulator-options: >-
+            -no-window -gpu swiftshader_indirect -noaudio -no-boot-anim
+            -camera-back emulated -skin 768x1024
+          script: bash tools/smoke.sh
+
+      - name: Upload smoke screenshots
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: smoke-screenshots
+          path: build/smoke/
+          retention-days: 14

ota/build.gradle.kts

@@ -12,10 +12,17 @@ android {
         targetCompatibility = JavaVersion.VERSION_17
     }
     kotlinOptions { jvmTarget = "17" }
+    testOptions {
+        unitTests.all { it.useJUnitPlatform() }
+    }
 }
 
 dependencies {
     implementation(libs.androidx.core.ktx)
     implementation(libs.kotlinx.coroutines.android)
     implementation(libs.androidx.lifecycle.viewmodel.ktx)
+
+    testImplementation(libs.junit5.api)
+    testImplementation(libs.junit5.params)
+    testRuntimeOnly(libs.junit5.engine)
 }

ota/src/main/kotlin/dev/helm/ota/OtaInfo.kt

@@ -5,3 +5,23 @@ data class OtaInfo(
     val apkUrl: String,
     val changelog: String,
 )
+
+// Semantic-ish version compare. Tolerates a leading "v", ignores pre-release ("-rc1")
+// and build metadata ("+42") suffixes, and pads missing components with 0 so
+// "1.2" and "1.2.0" compare equal.
+internal fun isNewer(server: String, installed: String): Boolean {
+    fun String.components(): List<Int> {
+        val core = substringBefore('+').substringBefore('-').trimStart('v')
+        val parts = core.split('.').mapNotNull { it.toIntOrNull() }
+        return parts.ifEmpty { listOf(0) }
+    }
+    val s = server.components()
+    val c = installed.components()
+    for (i in 0 until maxOf(s.size, c.size)) {
+        val sv = s.getOrElse(i) { 0 }
+        val cv = c.getOrElse(i) { 0 }
+        if (sv > cv) return true
+        if (sv < cv) return false
+    }
+    return false
+}

ota/src/main/kotlin/dev/helm/ota/OtaViewModel.kt

@@ -85,22 +85,4 @@ class OtaViewModel(application: Application) : AndroidViewModel(application) {
     fun reset() {
         _state.value = OtaState.Idle
     }
-
-    private fun isNewer(server: String, installed: String): Boolean {
-        fun String.components(): List<Int> {
-            val core = substringBefore('+').substringBefore('-').trimStart('v')
-            val parts = core.split('.').mapNotNull { it.toIntOrNull() }
-            return parts.ifEmpty { listOf(0) }
-        }
-        val s = server.components()
-        val c = installed.components()
-        val len = maxOf(s.size, c.size)
-        for (i in 0 until len) {
-            val sv = s.getOrElse(i) { 0 }
-            val cv = c.getOrElse(i) { 0 }
-            if (sv > cv) return true
-            if (sv < cv) return false
-        }
-        return false
-    }
 }

ota/src/test/kotlin/dev/helm/ota/OtaVersionTest.kt

@@ -0,0 +1,61 @@
+package dev.helm.ota
+
+import org.junit.jupiter.api.Assertions.assertFalse
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.CsvSource
+
+class OtaVersionTest {
+
+    @ParameterizedTest(name = "server {0} is newer than installed {1}")
+    @CsvSource(
+        "0.2.0, 0.1.0",
+        "1.0.0, 0.9.9",
+        "0.1.1, 0.1.0",
+        "0.10.0, 0.9.0",   // numeric compare, not lexicographic
+        "1.1, 1.0.9",      // missing component pads to 0, compared left to right
+    )
+    fun `newer server version triggers update`(server: String, installed: String) {
+        assertTrue(isNewer(server, installed))
+    }
+
+    @ParameterizedTest(name = "server {0} is NOT newer than installed {1}")
+    @CsvSource(
+        "0.1.0, 0.1.0",
+        "0.1.0, 0.2.0",
+        "0.9.0, 0.10.0",
+        "1.0, 1.0.0",      // equal once padded
+        "0.1.0, 1.0.0",    // downgrade must never be offered
+    )
+    fun `same or older server version does not trigger update`(server: String, installed: String) {
+        assertFalse(isNewer(server, installed))
+    }
+
+    @Test
+    fun `leading v is stripped from the release tag`() {
+        assertTrue(isNewer("v0.2.0", "0.1.0"))
+        assertFalse(isNewer("v0.1.0", "0.1.0"))
+    }
+
+    @Test
+    fun `pre-release and build metadata suffixes are ignored`() {
+        assertFalse(isNewer("0.1.0-rc1", "0.1.0"))
+        assertFalse(isNewer("0.1.0+42", "0.1.0"))
+        assertTrue(isNewer("0.2.0-rc1", "0.1.0"))
+    }
+
+    @Test
+    fun `unparseable versions never trigger an update`() {
+        // A garbage tag_name must not push an APK onto the head unit.
+        assertFalse(isNewer("", "0.1.0"))
+        assertFalse(isNewer("latest", "0.1.0"))
+        assertFalse(isNewer("nightly", "0.1.0"))
+    }
+
+    @Test
+    fun `unparseable installed version accepts any real release`() {
+        // versionName came back empty from PackageManager — treated as 0.
+        assertTrue(isNewer("0.1.0", ""))
+    }
+}

sdk/src/main/kotlin/dev/helm/sdk/OpenMeteoWeatherDataSource.kt

@@ -110,16 +110,4 @@ class OpenMeteoWeatherDataSource(
             }
         }
     }
-
-    private fun wmoToCondition(code: Int): WeatherCondition = when (code) {
-        0 -> WeatherCondition.CLEAR
-        in 1..3 -> WeatherCondition.CLOUDY
-        45, 48 -> WeatherCondition.HAZE
-        in 51..67 -> WeatherCondition.RAIN
-        in 71..77 -> WeatherCondition.SNOW
-        in 80..82 -> WeatherCondition.RAIN
-        85, 86 -> WeatherCondition.SNOW
-        in 95..99 -> WeatherCondition.THUNDERSTORM
-        else -> WeatherCondition.CLOUDY
-    }
 }

sdk/src/main/kotlin/dev/helm/sdk/TwUtilMcuDataSource.kt

@@ -12,10 +12,17 @@ internal class TwUtilMcuDataSource : McuDataSource {
 
     override fun events(): Flow<McuEvent> = adapter.events()
         .retryWhen { _, attempt ->
-            delay(minOf(500L shl attempt.toInt().coerceAtMost(6), 30_000L))
+            delay(reconnectDelayMs(attempt))
             true
         }
 
     override suspend fun send(code: Int, arg1: Int, arg2: Int, data: ByteArray): Result<Unit> =
         adapter.send(code, arg1, arg2, data)
 }
+
+// Exponential back-off for MCU reconnection: 500 ms, 1 s, 2 s, 4 s, 8 s, 16 s, then 30 s
+// forever. Clamp the attempt as a Long *before* narrowing to Int: Long.MAX_VALUE.toInt()
+// is -1, and `shl` only reads the low 6 bits of the count, so narrowing first turns a very
+// long outage into a negative delay and busy-loops the UART.
+internal fun reconnectDelayMs(attempt: Long): Long =
+    minOf(500L shl attempt.coerceIn(0L, 6L).toInt(), 30_000L)

sdk/src/main/kotlin/dev/helm/sdk/WeatherCondition.kt

@@ -8,3 +8,18 @@ enum class WeatherCondition(val label: String) {
     SNOW("Snow"),
     HAZE("Haze"),
 }
+
+// WMO weather interpretation codes → Helm's 6 icon buckets.
+// https://open-meteo.com/en/docs — unknown codes fall back to CLOUDY so the
+// widget always renders something rather than blanking out.
+internal fun wmoToCondition(code: Int): WeatherCondition = when (code) {
+    0 -> WeatherCondition.CLEAR
+    in 1..3 -> WeatherCondition.CLOUDY
+    45, 48 -> WeatherCondition.HAZE
+    in 51..67 -> WeatherCondition.RAIN
+    in 71..77 -> WeatherCondition.SNOW
+    in 80..82 -> WeatherCondition.RAIN
+    85, 86 -> WeatherCondition.SNOW
+    in 95..99 -> WeatherCondition.THUNDERSTORM
+    else -> WeatherCondition.CLOUDY
+}

sdk/src/test/kotlin/dev/helm/sdk/ReconnectBackoffTest.kt

@@ -0,0 +1,46 @@
+package dev.helm.sdk
+
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.CsvSource
+import org.junit.jupiter.params.provider.ValueSource
+
+class ReconnectBackoffTest {
+
+    @ParameterizedTest(name = "attempt {0} waits {1} ms")
+    @CsvSource(
+        "0, 500",
+        "1, 1000",
+        "2, 2000",
+        "3, 4000",
+        "4, 8000",
+        "5, 16000",
+        "6, 30000",   // 32000 clamped to the 30 s ceiling
+    )
+    fun `back-off follows the documented schedule`(attempt: Long, expectedMs: Long) {
+        assertEquals(expectedMs, reconnectDelayMs(attempt))
+    }
+
+    @ParameterizedTest(name = "attempt {0} stays at the 30 s ceiling")
+    @ValueSource(longs = [7, 8, 20, 63, 64, 1_000, Int.MAX_VALUE.toLong(), Long.MAX_VALUE])
+    fun `long outages stay at the ceiling`(attempt: Long) {
+        assertEquals(30_000L, reconnectDelayMs(attempt))
+    }
+
+    @Test
+    fun `delay is never zero or negative`() {
+        // A non-positive delay would turn reconnection into a busy loop on the UART.
+        listOf(0L, 6L, 7L, 64L, Long.MAX_VALUE).forEach {
+            assertTrue(reconnectDelayMs(it) > 0, "attempt $it produced a non-positive delay")
+        }
+    }
+
+    @Test
+    fun `back-off is monotonic up to the ceiling`() {
+        val delays = (0L..10L).map { reconnectDelayMs(it) }
+        delays.zipWithNext { a, b -> assertTrue(b >= a, "delay decreased: $a then $b") }
+        assertEquals(30_000L, delays.last())
+    }
+}

sdk/src/test/kotlin/dev/helm/sdk/WmoConditionTest.kt

@@ -0,0 +1,45 @@
+package dev.helm.sdk
+
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.CsvSource
+import org.junit.jupiter.params.provider.ValueSource
+
+class WmoConditionTest {
+
+    @ParameterizedTest(name = "WMO {0} maps to {1}")
+    @CsvSource(
+        "0,  CLEAR",
+        "1,  CLOUDY", "2, CLOUDY", "3, CLOUDY",
+        "45, HAZE", "48, HAZE",
+        "51, RAIN", "61, RAIN", "67, RAIN",
+        "71, SNOW", "77, SNOW",
+        "80, RAIN", "82, RAIN",
+        "85, SNOW", "86, SNOW",
+        "95, THUNDERSTORM", "99, THUNDERSTORM",
+    )
+    fun `documented WMO codes map to the right icon`(code: Int, expected: WeatherCondition) {
+        assertEquals(expected, wmoToCondition(code))
+    }
+
+    @ParameterizedTest(name = "gap code {0} falls back to CLOUDY")
+    @ValueSource(ints = [4, 44, 49, 50, 68, 70, 78, 79, 83, 84, 87, 94, 100])
+    fun `codes in the gaps fall back to CLOUDY`(code: Int) {
+        assertEquals(WeatherCondition.CLOUDY, wmoToCondition(code))
+    }
+
+    @Test
+    fun `nonsense codes never crash the widget`() {
+        // A malformed API response must degrade to an icon, not blank the home screen.
+        assertEquals(WeatherCondition.CLOUDY, wmoToCondition(-1))
+        assertEquals(WeatherCondition.CLOUDY, wmoToCondition(9999))
+        assertEquals(WeatherCondition.CLOUDY, wmoToCondition(Int.MAX_VALUE))
+        assertEquals(WeatherCondition.CLOUDY, wmoToCondition(Int.MIN_VALUE))
+    }
+
+    @Test
+    fun `every condition has a non-empty label for the widget`() {
+        WeatherCondition.entries.forEach { assertEquals(it.label, it.label.trim().ifEmpty { null }) }
+    }
+}