Android: introduce unit tests and Kotlin

Author: ofalvai

.github/workflows/ci-test.yml

@@ -21,8 +21,34 @@ jobs:
       - name: Check public API compatibility
         run: npm run check:api-compat
 
-  android-test:
+  android-unit-test:
     needs: lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+
+      - uses: jdx/mise-action@v4
+
+      - name: Cache npm packages
+        uses: actions/cache@v6
+        with:
+          path: ~/.npm
+          key: ${{ runner.os }}-npm-${{ hashFiles('package-lock.json', 'test/test.ts') }}
+          restore-keys: |
+            ${{ runner.os }}-npm-
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v6
+
+      - name: Run Android unit tests
+        working-directory: android
+        run: ./gradlew :app:test
+
+  android-test:
+    needs: [lint, android-unit-test]
     runs-on: bitrise-react-native-code-push-linux-runner
     strategy:
       matrix:
@@ -49,6 +75,16 @@ jobs:
       - name: Install dependencies
         run: npm install
 
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v6
+        with:
+          # This job's Gradle build lives in a test app generated at runtime by the test harness,
+          # not a project checked into this repo, so there's nothing meaningful for it to
+          # contribute back to the cache. Read-only avoids each matrix arm (bare/expo) writing
+          # its own redundant entry; it still reuses whatever android-unit-test wrote, since
+          # setup-gradle shares its cache across jobs in the same workflow run.
+          cache-read-only: true
+
       - name: Enable KVM
         run: |
           echo 'KERNEL=="kvm", GROUP="kvm", MODE="0666", OPTIONS+="static_node=kvm"' | sudo tee /etc/udev/rules.d/99-kvm4all.rules

android/app/build.gradle

@@ -1,4 +1,30 @@
+buildscript {
+    // Read the Kotlin version from the consuming app's rootProject.ext first (most RN apps
+    // already set this for reanimated/gesture-handler/screens/etc.), falling back to a bundled
+    // default only when nothing else in the build graph has declared one. We deliberately use
+    // the classic `buildscript { classpath ... } + apply plugin` form here instead of the
+    // `plugins { id(...) version(...) }` DSL: the latter hard-fails the whole consumer build with
+    // "plugin already on the classpath with a different version" if any other subproject (e.g.
+    // reanimated) applies a different Kotlin version, since it enforces exact version matches per
+    // plugin id across the whole multi-project build. The classpath form just resolves to a
+    // single version (highest wins) with no such conflict.
+    //
+    // Fallback version has no ecosystem anchor to track — it only applies when nothing else in
+    // the host build declared a Kotlin version at all, which is already rare in the RN ecosystem.
+    // Bump it opportunistically; nothing depends on it matching anything specific.
+    def kotlinVersion = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : "1.9.24"
+
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"
+    }
+}
+
 apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
 
 def isNewArchitectureEnabled() {
     // To opt-in for the New Architecture, you can either:
@@ -10,10 +36,16 @@ def isNewArchitectureEnabled() {
 
 def IS_NEW_ARCHITECTURE_ENABLED = isNewArchitectureEnabled()
 
-def DEFAULT_COMPILE_SDK_VERSION = 26
-def DEFAULT_BUILD_TOOLS_VERSION = "26.0.3"
-def DEFAULT_TARGET_SDK_VERSION = 26
-def DEFAULT_MIN_SDK_VERSION = 16
+// These are fallbacks only — real consumer apps set compileSdkVersion/buildToolsVersion/
+// targetSdkVersion/minSdkVersion on rootProject themselves (RN's own template always has),
+// so bumping these defaults doesn't change behavior for any app that already does. Keep them
+// aligned with RN's current app template (verified against Examples/CodePushDemo's root
+// build.gradle, generated from RN 0.87's template) so a consumer relying on the fallback still
+// gets a build that actually works with a current RN version.
+def DEFAULT_COMPILE_SDK_VERSION = 35 // RN template: compileSdkVersion
+def DEFAULT_BUILD_TOOLS_VERSION = "35.0.0" // RN template: buildToolsVersion
+def DEFAULT_TARGET_SDK_VERSION = 35 // RN template: targetSdkVersion
+def DEFAULT_MIN_SDK_VERSION = 24 // RN template: minSdkVersion (RN 0.74+'s own minimum)
 
 android {
     namespace "com.microsoft.codepush.react"
@@ -40,9 +72,25 @@ android {
     buildFeatures {
         buildConfig true
     }
+
+    // JVM 17 matches mise.toml's `java = "17"` pin (this repo's own toolchain) and RN 0.76+'s own
+    // minimum required JDK — not an arbitrary choice. Confirmed against Examples/CodePushDemo:
+    // its build resolves unit-test javac to JVM 17 regardless of what's set here, so this module
+    // must match it or Kotlin's build fails with "Inconsistent JVM Target Compatibility". Bump
+    // this in lockstep with mise.toml's java version, never independently.
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = JavaVersion.VERSION_17.toString()
+    }
 }
 
 dependencies {
     implementation 'com.facebook.react:react-android:0.82.1'
     implementation 'com.nimbusds:nimbus-jose-jwt:9.37.3'
+
+    testImplementation 'junit:junit:4.13.2'
 }

android/app/src/test/java/com/microsoft/codepush/react/CodePushUtilsTest.kt

@@ -0,0 +1,24 @@
+package com.microsoft.codepush.react
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import java.io.File
+
+class CodePushUtilsTest {
+
+    @Test
+    fun appendPathComponent_joinsBaseAndChildIntoAbsolutePath() {
+        val basePath = "/data/data/com.example.app/files"
+        val result = CodePushUtils.appendPathComponent(basePath, "CodePush")
+
+        assertEquals(File(basePath, "CodePush").absolutePath, result)
+    }
+
+    @Test
+    fun appendPathComponent_handlesNestedRelativeComponent() {
+        val basePath = "/data/data/com.example.app/files/CodePush"
+        val result = CodePushUtils.appendPathComponent(basePath, "20/CodePushLoader.android.bundle")
+
+        assertEquals(File(basePath, "20/CodePushLoader.android.bundle").absolutePath, result)
+    }
+}

android/gradle.properties

@@ -16,3 +16,9 @@
 # This option should only be used with decoupled projects. More details, visit
 # http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
 # org.gradle.parallel=true
+
+# This repo's own standalone build/test harness only — real consumer apps already set this
+# (RN's own template has for years), so it's never actually read by a downstream build. Needed
+# here because react-android pulls in AndroidX transitively, and Gradle's unit test task
+# resolves that classpath strictly.
+android.useAndroidX=true