From 7d85cf6e333d571ad22228cc05c8de01fe5e9431 Mon Sep 17 00:00:00 2001 From: Adam Brown Date: Fri, 20 Nov 2026 12:09:44 +0100 Subject: [PATCH] test(nav3): Verify serial name mappers under R8 --- .../workflows/integration-tests-nav3-r8.yml | 131 ++++++++++++ Makefile | 7 +- .../test-nav3-backstack-entry-mapper-r8.sh | 124 +++++++++++ scripts/update-nav3-kotlinx-serialization.sh | 24 +++ .../README.md | 22 ++ .../build.gradle.kts | 81 +++++++ .../proguard-rules.pro | 20 ++ .../src/main/AndroidManifest.xml | 11 + .../nav3/r8/BackStackEntryMapperActivity.kt | 121 +++++++++++ .../sentry/tests/nav3/r8/SerializableKeys.kt | 202 ++++++++++++++++++ .../settings.gradle.kts | 2 + 11 files changed, 744 insertions(+), 1 deletion(-) create mode 100644 .github/workflows/integration-tests-nav3-r8.yml create mode 100755 scripts/test-nav3-backstack-entry-mapper-r8.sh create mode 100755 scripts/update-nav3-kotlinx-serialization.sh create mode 100644 sentry-android-integration-tests/nav3-backstack-entry-mapper-r8-check/README.md create mode 100644 sentry-android-integration-tests/nav3-backstack-entry-mapper-r8-check/build.gradle.kts create mode 100644 sentry-android-integration-tests/nav3-backstack-entry-mapper-r8-check/proguard-rules.pro create mode 100644 sentry-android-integration-tests/nav3-backstack-entry-mapper-r8-check/src/main/AndroidManifest.xml create mode 100644 sentry-android-integration-tests/nav3-backstack-entry-mapper-r8-check/src/main/kotlin/io/sentry/tests/nav3/r8/BackStackEntryMapperActivity.kt create mode 100644 sentry-android-integration-tests/nav3-backstack-entry-mapper-r8-check/src/main/kotlin/io/sentry/tests/nav3/r8/SerializableKeys.kt diff --git a/.github/workflows/integration-tests-nav3-r8.yml b/.github/workflows/integration-tests-nav3-r8.yml new file mode 100644 index 0000000000..3e7eecba37 --- /dev/null +++ b/.github/workflows/integration-tests-nav3-r8.yml @@ -0,0 +1,131 @@ +name: Nav3 BackStackEntryMapper R8 Check + +# Verifies behavior of BackStackEntryMapper.SerialName and SerialNameAndProperties +# from sentry-android-navigation3 in R8-minified builds on an emulator (full and compat mode, +# with the compile floor + latest versions of kotlinx.serialization). See +# sentry-android-integration-tests/nav3-backstack-entry-mapper-r8-check/README.md. + +on: + push: + branches: + - main + paths: + - "sentry-android-navigation3/**" + - "sentry-android-integration-tests/nav3-backstack-entry-mapper-r8-check/**" + - "sentry-android-integration-tests/*.gradle.kts" + - "scripts/test-nav3-backstack-entry-mapper-r8.sh" + - "scripts/update-nav3-kotlinx-serialization.sh" + - "gradle/libs.versions.toml" + - "gradle/nav3.versions.toml" + - ".github/workflows/integration-tests-nav3-r8.yml" + # Omit PRs that only change gradle/libs.versions.toml so we don't trigger R8 tests on unrelated + # dependency bumps. (Those changes are checked once they reach main.) The kotlinx.serialization + # floor lives in gradle/nav3.versions.toml so that PRs changing it are still checked. + pull_request: + paths: + - "sentry-android-navigation3/**" + - "sentry-android-integration-tests/nav3-backstack-entry-mapper-r8-check/**" + - "sentry-android-integration-tests/*.gradle.kts" + - "scripts/test-nav3-backstack-entry-mapper-r8.sh" + - "scripts/update-nav3-kotlinx-serialization.sh" + - "gradle/nav3.versions.toml" + - ".github/workflows/integration-tests-nav3-r8.yml" + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +env: + APK_DIR: "nav3-r8-check-apks" + APK_ARTIFACT_NAME: "nav3-r8-check-apks" + +jobs: + build: + name: Build + runs-on: ubuntu-latest + + steps: + - name: Checkout code + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + + - name: Set up Java + uses: actions/setup-java@b843ebf9b913146b38da2eaa7aeddf76074ae1ad # v6.1.0 + with: + distribution: 'temurin' + java-version: '21' + + - name: Setup Gradle + uses: gradle/actions/setup-gradle@8da46b539cd8fe6ab27ca75128919a18d757604c # v6.4.1 + + # Apps may ship a newer kotlinx.serialization than sentry-android-navigation3 compiles + # against, and the properties encoder relies on its experimental AbstractEncoder. + - name: Run unit tests against the latest kotlinx.serialization + run: | + tag="$(./scripts/update-nav3-kotlinx-serialization.sh get-version)" + version="${tag#v}" + ./gradlew :sentry-android-navigation3:testReleaseUnitTest -Pnav3TestKotlinxVersion="$version" + + - name: Build APKs + run: ./scripts/test-nav3-backstack-entry-mapper-r8.sh build "${{ env.APK_DIR }}" + + - name: Upload APK artifact + uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7 + with: + name: ${{ env.APK_ARTIFACT_NAME }} + path: ${{ env.APK_DIR }} + retention-days: 1 + + run: + name: Run on API Level ${{ matrix.api-level }} + needs: build + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + # Tests against API 37.0 on every run. Also tests against API 23 (Nav3's minSdkVersion) when changes reach main. + # The latter lets us catch issues present on the oldest Nav3 app runtime without slowing down PRs. + api-level: ${{ fromJSON(github.event_name == 'push' && '[23, "37.0"]' || '["37.0"]') }} + steps: + - name: Checkout code + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + + - 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 + + - name: Download APK artifact + uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8 + with: + name: ${{ env.APK_ARTIFACT_NAME }} + path: ${{ env.APK_DIR }} + + # The runner ships an outdated avdmanager that writes target=android-0 into the + # AVD config for minor-versioned packages (android-37.x), so the emulator clamps + # to API 3 and boots misconfigured. Update cmdline-tools so avdmanager parses it. + # See https://github.com/ReactiveCircus/android-emulator-runner/issues/482 + - name: Update SDK cmdline-tools + if: matrix.api-level == '37.0' + run: | + SDK="${ANDROID_HOME:-${ANDROID_SDK_ROOT:-/usr/local/lib/android/sdk}}" + yes | "$SDK/cmdline-tools/latest/bin/sdkmanager" --install "cmdline-tools;latest" > /dev/null + # sdkmanager won't overwrite the preinstalled dir, so it installs to latest-2. + if [ -d "$SDK/cmdline-tools/latest-2" ]; then + rm -rf "$SDK/cmdline-tools/latest" + mv "$SDK/cmdline-tools/latest-2" "$SDK/cmdline-tools/latest" + fi + + - name: Run check + uses: reactivecircus/android-emulator-runner@a421e43855164a8197daf9d8d40fe71c6996bb0d # pin@v2.38.0 + with: + api-level: ${{ matrix.api-level }} + # API 37 has no plain google_apis image. + target: ${{ matrix.api-level == 23 && 'google_apis' || 'google_apis_ps16k' }} + # Use canary for API 37, matching the critical UI tests. + channel: ${{ matrix.api-level == 23 && 'stable' || 'canary' }} + arch: x86_64 + disable-animations: true + disable-spellchecker: true + emulator-options: -memory 4096 -no-window -gpu auto -noaudio -no-boot-anim -camera-back none -no-snapshot-save + script: ./scripts/test-nav3-backstack-entry-mapper-r8.sh run "${{ env.APK_DIR }}" diff --git a/Makefile b/Makefile index 17d5326ffa..b15d6d01dc 100644 --- a/Makefile +++ b/Makefile @@ -1,4 +1,4 @@ -.PHONY: all clean compile javadocs dryRelease update format checkFormat api assembleUiTestRelease assembleUiTestCriticalRelease runUiTestCritical check preMerge publish +.PHONY: all clean compile javadocs dryRelease update format checkFormat api assembleUiTestRelease assembleUiTestCriticalRelease runUiTestCritical runNav3BackStackEntryMapperR8Test check preMerge publish all: stop clean javadocs compile assembleUiTests: assembleUiTestRelease @@ -53,6 +53,11 @@ assembleUiTestCriticalRelease: runUiTestCritical: ./scripts/test-ui-critical.sh +# Build and run the R8 check for BackStackEntryMapper.SerialName and +# SerialNameAndProperties on a booted emulator +runNav3BackStackEntryMapperR8Test: + ./scripts/test-nav3-backstack-entry-mapper-r8.sh + # Run tests and lint check: ./gradlew check diff --git a/scripts/test-nav3-backstack-entry-mapper-r8.sh b/scripts/test-nav3-backstack-entry-mapper-r8.sh new file mode 100755 index 0000000000..6ebc26a8e4 --- /dev/null +++ b/scripts/test-nav3-backstack-entry-mapper-r8.sh @@ -0,0 +1,124 @@ +#!/usr/bin/env bash +# Verifies the behavior of BackStackEntryMapper.SerialName and SerialNameAndProperties +# in R8-minified builds on a booted emulator or device. See +# sentry-android-integration-tests/nav3-backstack-entry-mapper-r8-check/README.md. +# +# The app is built against the kotlinxSerializationFloor in gradle/nav3.versions.toml +# plus each version in NAV3_EXTRA_KOTLINX_VERSIONS (default: defaultLatestKotlinx below), +# each in R8 full and compat modes. +# +# Usage: +# test-nav3-backstack-entry-mapper-r8.sh Build all APKs, then run them. +# test-nav3-backstack-entry-mapper-r8.sh build DIR Build all APKs into DIR. +# test-nav3-backstack-entry-mapper-r8.sh run DIR Install and run every APK in DIR. +set -euo pipefail + +module="nav3-backstack-entry-mapper-r8-check" +moduleDir="sentry-android-integration-tests/nav3-backstack-entry-mapper-r8-check" +appId="io.sentry.tests.nav3.r8" +tag="NAV3_R8_CHECK" + +# Newer kotlinx.serialization versions to also build the app against, on top of the +# kotlinxSerializationFloor. Lets us prevent regressions should host apps ship a newer +# kotlinx.serialization version than we compile against. Also protects us against changes +# to the experimental kotlinx.serialization APIs used by the arguments encoder. Override +# with, e.g., NAV3_EXTRA_KOTLINX_VERSIONS="1.10.0 1.12.0" to test the compile floor, +# 1.10.0, and 1.12.0. (Provide an empty string to test the floor only.) +# +# The latest kotlinx-serialization-core release. Bumped by a weekly PR from +# scripts/update-nav3-kotlinx-serialization.sh (.github/workflows/update-deps.yml). +defaultLatestKotlinx="1.13.0" +extraKotlinxVersions=(${NAV3_EXTRA_KOTLINX_VERSIONS-$defaultLatestKotlinx}) + +copyApk() { + cp "${moduleDir}/build/outputs/apk/release/nav3-backstack-entry-mapper-r8-check-release.apk" "$1" +} + +build() { + local outDir="$1" + mkdir -p "$outDir" + for mode in full compat; do + local fullMode=true + [[ "$mode" == "compat" ]] && fullMode=false + echo "Building R8 $mode mode APK (kotlinx floor)..." + ./gradlew -p sentry-android-integration-tests ":${module}:assembleRelease" "-Pandroid.enableR8.fullMode=${fullMode}" + copyApk "${outDir}/${mode}.apk" + + # Apps may ship a newer kotlinx than our compile floor, so rebuild against each. + for version in ${extraKotlinxVersions[@]+"${extraKotlinxVersions[@]}"}; do + echo "Building R8 $mode mode APK (kotlinx ${version})..." + ./gradlew -p sentry-android-integration-tests ":${module}:assembleRelease" \ + "-Pandroid.enableR8.fullMode=${fullMode}" "-Pnav3CheckKotlinxVersion=${version}" + copyApk "${outDir}/${mode}-kotlinx-${version}.apk" + done + done +} + +run() { + local apkDir="$1" + local failed=0 + shopt -s nullglob + local apks=("$apkDir"/*.apk) + if [[ ${#apks[@]} -eq 0 ]]; then + echo "No APKs found in $apkDir" + exit 1 + fi + + for apk in "${apks[@]}"; do + local name + name="$(basename "$apk" .apk)" + echo "=== $name" + adb uninstall "$appId" > /dev/null 2>&1 || true + adb install -r -d "$apk" > /dev/null + # Only read lines logged from this launch on, so a stale RESULT=PASS from the previous APK can't + # hide this one's failure. Doesn't clear the log, which would also discard unrelated logs on a + # development device. The timestamp is truncated to the second, so wait a second for it to + # postdate earlier lines. + local since + sleep 1 + since="$(adb shell "date +'%m-%d %H:%M:%S.000'" | tr -d '\r')" + adb shell am start -W -n "${appId}/.BackStackEntryMapperActivity" > /dev/null + + local output="" + for _ in $(seq 1 60); do + output="$(adb logcat -d -T "$since" -s "${tag}:I" | grep "${tag}" || true)" + if grep -q "RESULT=" <<< "$output"; then + break + fi + if adb logcat -d -T "$since" -b crash | grep -q "$appId"; then + break + fi + sleep 1 + done + + if [[ -n "$output" ]]; then + sed -E "s/^.*${tag}: //" <<< "$output" + fi + if ! grep -q "RESULT=PASS" <<< "$output"; then + echo "FAILED: $name" + adb logcat -d -T "$since" -b crash | grep -A 20 "$appId" || true + failed=1 + fi + done + + if [[ $failed -ne 0 ]]; then + echo "Nav3 BackStackEntryMapper R8 check failed." + exit 1 + fi + echo "Nav3 BackStackEntryMapper R8 check passed." +} + +case "${1:-}" in + build) build "${2:?Usage: $0 build DIR}" ;; + run) run "${2:?Usage: $0 run DIR}" ;; + "") + apkDir="${moduleDir}/build/r8-check-apks" + rm -rf "$apkDir" + build "$apkDir" + run "$apkDir" + ;; + *) + echo "Usage: $0 [build DIR | run DIR]" + exit 1 + ;; +esac diff --git a/scripts/update-nav3-kotlinx-serialization.sh b/scripts/update-nav3-kotlinx-serialization.sh new file mode 100755 index 0000000000..717f3492f9 --- /dev/null +++ b/scripts/update-nav3-kotlinx-serialization.sh @@ -0,0 +1,24 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Script for keeping the Nav3 R8 test up-to-date with new kotlinx.serialization releases. +# Updates defaultLatestKotlinx in scripts/test-nav3-backstack-entry-mapper-r8.sh, which +# adds that version to the test matrix alongside the SDK's pinned compile version. +# +# Run weekly by update-deps.yml. Does not change kotlinxSerializationFloor in +# gradle/nav3.versions.toml. + +cd "$(dirname "$0")/../" +SCRIPT_FILEPATH=scripts/test-nav3-backstack-entry-mapper-r8.sh + +case $1 in +get-version) + # Printed as the release's tag (e.g. v1.13.0), which the updater uses as the old ref when it + # compares upstream changelogs. + perl -ne 'print "v$1\n" if ( m/^defaultLatestKotlinx="([0-9.]+)"/ )' "$SCRIPT_FILEPATH" + ;; +*) + echo "Unknown argument $1" + exit 1 + ;; +esac diff --git a/sentry-android-integration-tests/nav3-backstack-entry-mapper-r8-check/README.md b/sentry-android-integration-tests/nav3-backstack-entry-mapper-r8-check/README.md new file mode 100644 index 0000000000..864e7142b9 --- /dev/null +++ b/sentry-android-integration-tests/nav3-backstack-entry-mapper-r8-check/README.md @@ -0,0 +1,22 @@ +# nav3-backstack-entry-mapper-r8-check + +Verifies that `BackStackEntryMapper.SerialName` and +`BackStackEntryMapper.SerialNameAndProperties` from `sentry-android-navigation3` return expected Sentry names and arguments despite +R8 obfuscation. `sentry-android-navigation3` ships no kotlinx.serialization R8 rules, so the check relies on kotlinx.serialization's own +consumer rules, plus the per-class rules in this app's `proguard-rules.pro` file. + +The tests check serialization names, argument encoding, and sensitive-value filtering. They also verify that R8 actually renamed +representative classes and fields. + +## How to run it + +Run the tests against a booted emulator or device: + +```bash +./scripts/test-nav3-backstack-entry-mapper-r8.sh +``` + + +The script builds and runs four APKs: R8 full and compat modes, each with the pinned and latest kotlinx.serialization versions. Every APK +must report `RESULT=PASS` in order to pass. Set `NAV3_EXTRA_KOTLINX_VERSIONS` to override the extra versions tested (i.e., the versions +besides the compile floor, which is always tested). diff --git a/sentry-android-integration-tests/nav3-backstack-entry-mapper-r8-check/build.gradle.kts b/sentry-android-integration-tests/nav3-backstack-entry-mapper-r8-check/build.gradle.kts new file mode 100644 index 0000000000..1bcb6292de --- /dev/null +++ b/sentry-android-integration-tests/nav3-backstack-entry-mapper-r8-check/build.gradle.kts @@ -0,0 +1,81 @@ +// Checks BackStackEntryMapper.SerialName and SerialNameAndProperties in R8-minified +// release builds. See README.md. +plugins { + id("com.android.application") + alias(libs.plugins.kotlin.android) + alias(libs.plugins.kotlin.serialization) + id("io.sentry.spotless") + id("io.sentry.jdk-target") +} + +val sentryVersion = libs.versions.sentry.get() + +// Defaults to the min version sentry-android-navigation3 supports, whose R8 rules are the most +// limited. Override with -Pnav3CheckKotlinxVersion=. +val kotlinxVersionOverride = providers.gradleProperty("nav3CheckKotlinxVersion").orNull +val kotlinxVersion = kotlinxVersionOverride ?: nav3Libs.versions.kotlinxSerializationFloor.get() + +// kotlinx.serialization's own R8 rules keep what its lookup of named companion objects needs from +// 1.10.0 on. With older versions, whether the lookup survives without the app's own rules depends +// on the version and R8 (e.g., 1.9.x's succeeds in R8 compat mode only), so either outcome is +// accepted. +val kotlinxKeepsNamedCompanions = + kotlinxVersion.split(".").let { (major, minor) -> + major.toInt() > 1 || (major.toInt() == 1 && minor.toInt() >= 10) + } + +android { + namespace = "io.sentry.tests.nav3.r8" + compileSdk = libs.versions.compileSdk.get().toInt() + compileSdkMinor = libs.versions.compileSdkMinor.get().toInt() + + defaultConfig { + applicationId = "io.sentry.tests.nav3.r8" + minSdk = libs.versions.minSdk.get().toInt() + targetSdk = libs.versions.targetSdk.get().toInt() + versionCode = 1 + versionName = "1.0" + buildConfigField( + "boolean", + "KOTLINX_KEEPS_NAMED_COMPANIONS", + kotlinxKeepsNamedCompanions.toString(), + ) + } + + signingConfigs { + getByName("debug") { + storeFile = file("../../debug.keystore") + storePassword = "android" + keyAlias = "androiddebugkey" + keyPassword = "android" + } + } + + buildTypes { + release { + isMinifyEnabled = true + proguardFiles( + getDefaultProguardFile("proguard-android-optimize.txt"), + "proguard-rules.pro", + ) + signingConfig = signingConfigs.getByName("debug") + } + } + + buildFeatures { buildConfig = true } + + androidComponents.beforeVariants { it.enable = it.buildType == "release" } +} + +dependencies { + implementation("io.sentry:sentry-android-navigation3:$sentryVersion") + // compileOnly in sentry-android-navigation3; always available for apps that use Nav3. + implementation(libs.androidx.compose.runtime) + + implementation(nav3Libs.kotlinx.serialization.core) { + version { + require(kotlinxVersion) + kotlinxVersionOverride?.let { strictly(it) } + } + } +} diff --git a/sentry-android-integration-tests/nav3-backstack-entry-mapper-r8-check/proguard-rules.pro b/sentry-android-integration-tests/nav3-backstack-entry-mapper-r8-check/proguard-rules.pro new file mode 100644 index 0000000000..b941e916c1 --- /dev/null +++ b/sentry-android-integration-tests/nav3-backstack-entry-mapper-r8-check/proguard-rules.pro @@ -0,0 +1,20 @@ +# kotlinx.serialization's named-companion rules for R8 full mode, which also work in compat mode. +# Needed for the serialization floor (1.7.3); kotlinx.serialization 1.10.0+ supplies its own. +# See https://docs.sentry.io/platforms/android/integrations/navigation/#troubleshooting-kotlinxserialization-mappers +# https://github.com/Kotlin/kotlinx.serialization#android +-keepattributes InnerClasses + +-if @kotlinx.serialization.Serializable class +io.sentry.tests.nav3.r8.NamedCompanionKeyWithRules +{ + static **$* *; +} +-keepnames class <1>$$serializer { + static <1>$$serializer INSTANCE; +} + +-keepclasseswithmembers, allowshrinking, allowobfuscation, allowaccessmodification class +io.sentry.tests.nav3.r8.NamedCompanionKeyWithRules +{ + *; +} diff --git a/sentry-android-integration-tests/nav3-backstack-entry-mapper-r8-check/src/main/AndroidManifest.xml b/sentry-android-integration-tests/nav3-backstack-entry-mapper-r8-check/src/main/AndroidManifest.xml new file mode 100644 index 0000000000..424a3ff27f --- /dev/null +++ b/sentry-android-integration-tests/nav3-backstack-entry-mapper-r8-check/src/main/AndroidManifest.xml @@ -0,0 +1,11 @@ + + + + + + + + + + + diff --git a/sentry-android-integration-tests/nav3-backstack-entry-mapper-r8-check/src/main/kotlin/io/sentry/tests/nav3/r8/BackStackEntryMapperActivity.kt b/sentry-android-integration-tests/nav3-backstack-entry-mapper-r8-check/src/main/kotlin/io/sentry/tests/nav3/r8/BackStackEntryMapperActivity.kt new file mode 100644 index 0000000000..29d71a66ed --- /dev/null +++ b/sentry-android-integration-tests/nav3-backstack-entry-mapper-r8-check/src/main/kotlin/io/sentry/tests/nav3/r8/BackStackEntryMapperActivity.kt @@ -0,0 +1,121 @@ +package io.sentry.tests.nav3.r8 + +import android.app.Activity +import android.os.Bundle +import android.util.Log +import android.widget.ScrollView +import android.widget.TextView +import io.sentry.compose.navigation3.BackStackEntryMapper +import io.sentry.compose.navigation3.SentryBackStackEntry + +/** + * Maps every [Expectation] with `BackStackEntryMapper.SerialName` and + * `BackStackEntryMapper.SerialNameAndProperties`, and reports the results. + * + * An exception crashes the Activity, which the runner script reports as a failure. + */ +class BackStackEntryMapperActivity : Activity() { + + override fun onCreate(savedInstanceState: Bundle?) { + super.onCreate(savedInstanceState) + + val nameMapper = BackStackEntryMapper.SerialName + val propertiesMapper = BackStackEntryMapper.SerialNameAndProperties + val expectations = + listOf( + Expectation("string", "home", null), + Expectation("non-serializable class", NotSerializable("1"), null), + Expectation("unannotated enum", UnannotatedEnum.A, null), + ) + serializableExpectations() + + val lines = mutableListOf() + var failures = 0 + + for (expectation in expectations) { + val named = nameMapper.map(expectation.key) + val withProperties = propertiesMapper.map(expectation.key) + val matched = + named?.name == expectation.expected && + named?.arguments == null && + withProperties?.name == expectation.expected && + withProperties?.arguments == expectation.expectedArguments + val fellBack = expectation.alsoAcceptsUnnamed && named == null && withProperties == null + val passed = matched || fellBack + + if (!passed) failures++ + + lines += + "${if (passed) "PASS" else "FAIL"} ${expectation.label} " + + "(runtime class ${expectation.key.javaClass.name}): " + + "expected=${expectation.expected} actual=${named?.name}" + + describeArguments(expectation, named?.arguments, withProperties) + + if (fellBack) " (INFO: fell back to /unknown, also accepted)" else "" + } + + for (check in minificationChecks()) { + if (!check.passed) failures++ + lines += "${if (check.passed) "PASS" else "FAIL"} ${check.description}" + } + + lines += "RESULT=${if (failures == 0) "PASS" else "FAIL ($failures)"}" + + lines.forEach { Log.i(TAG, it) } + setContentView( + ScrollView(this).apply { + addView(TextView(context).apply { text = lines.joinToString(separator = "\n") }) + }, + ) + } + + private fun describeArguments( + expectation: Expectation, + nameMapperArguments: Map?, + withProperties: SentryBackStackEntry?, + ): String { + val parts = mutableListOf() + + if (nameMapperArguments != null) { + parts += "SerialName arguments=$nameMapperArguments" + } + + if (withProperties?.name != expectation.expected) { + parts += "withProperties name=${withProperties?.name}" + } + + if (expectation.expectedArguments != null || withProperties?.arguments != null) { + parts += + "expectedArguments=${expectation.expectedArguments} " + + "actualArguments=${withProperties?.arguments}" + } + + return if (parts.isEmpty()) "" else " " + parts.joinToString(separator = " ") + } + + private companion object { + const val TAG = "NAV3_R8_CHECK" + } +} + +/** A check that the build was minified, so passing names prove something. */ +class MinificationCheck(val description: String, val passed: Boolean) + +/** + * A back stack key, the name [BackStackEntryMapper.SerialName] should produce for it, and the + * arguments [BackStackEntryMapper.SerialNameAndProperties] should record for it. + * + * If [alsoAcceptsUnnamed], both mappers may instead return `null` for the key in cases where + * neither kotlinx.serialization nor R8 guarantees whether it can be named. + */ +class Expectation( + val label: String, + val key: Any, + val expected: String?, + val expectedArguments: Map? = null, + val alsoAcceptsUnnamed: Boolean = false, +) + +data class NotSerializable(val id: String) + +enum class UnannotatedEnum { + A, +} diff --git a/sentry-android-integration-tests/nav3-backstack-entry-mapper-r8-check/src/main/kotlin/io/sentry/tests/nav3/r8/SerializableKeys.kt b/sentry-android-integration-tests/nav3-backstack-entry-mapper-r8-check/src/main/kotlin/io/sentry/tests/nav3/r8/SerializableKeys.kt new file mode 100644 index 0000000000..1908ff27b2 --- /dev/null +++ b/sentry-android-integration-tests/nav3-backstack-entry-mapper-r8-check/src/main/kotlin/io/sentry/tests/nav3/r8/SerializableKeys.kt @@ -0,0 +1,202 @@ +package io.sentry.tests.nav3.r8 + +import kotlinx.serialization.SerialName +import kotlinx.serialization.Serializable +import kotlinx.serialization.Transient + +@Serializable data object PublicObject + +@Serializable @SerialName("Named") data class NamedClass(val id: String) + +@Serializable data class DefaultNamedClass(val id: String) + +@Serializable +sealed interface Sealed { + @Serializable data object Child : Sealed + + @Serializable data class Leaf(val id: String) : Sealed +} + +@Serializable +enum class SerializableEnum { + A, +} + +@Serializable data class Generic(val value: T) + +@Serializable private data object PrivateTopLevelObject + +@Serializable private data class PrivateTopLevelClass(val id: String) + +@Serializable +enum class SortOrder { + @SerialName("ascending") ASC, +} + +@Serializable @JvmInline value class Price(val cents: Int) + +@Serializable data class Filter(val sessionId: String, val query: String) + +@Serializable +sealed interface Origin { + @Serializable @SerialName("search") data class Search(val term: String) : Origin + + @Serializable @SerialName("deeplink") data object DeepLink : Origin +} + +/** + * Has a named companion object but no named-companion R8 rules of the app's own. + * kotlinx.serialization 1.10.0+'s own rules keep what its reflective serializer lookup needs, so + * the mappers must name it. Before 1.10.0, minification may strip that (e.g., always with 1.7.3, + * and with 1.9.x in R8 full mode), so falling back to `/unknown` is also accepted. + */ +@Serializable +data class NamedCompanionKey(val id: String) { + companion object Factory { + fun of(id: String): NamedCompanionKey = NamedCompanionKey(id) + } +} + +/** + * Like [NamedCompanionKey], but covered by kotlinx.serialization's named-companion R8 rules + * (`proguard-rules.pro`), as the + * [troubleshooting docs](https://docs.sentry.io/platforms/android/integrations/navigation/#troubleshooting-kotlinxserialization-mappers) + * tell apps to add. + */ +@Serializable +data class NamedCompanionKeyWithRules(val id: String) { + companion object Factory { + fun of(id: String): NamedCompanionKeyWithRules = NamedCompanionKeyWithRules(id) + } +} + +/** Uses every encoding rule of [BackStackEntryMapper.SerialNameAndProperties], plus filtering. */ +@Serializable +data class ArgumentsKey( + val productId: Int, + val quantity: UInt, + val authToken: String, + val price: Price, + val sort: SortOrder, + val tags: List, + val sizes: Set, + val counts: Map, + val filter: Filter, + val filters: List, + val origin: Origin, + val fallbackOrigin: Origin, + val note: String?, + @Transient val cache: String = "not encoded", +) + +class Holder { + @Serializable private data object PrivateNestedObject + + @Serializable private data class PrivateNestedClass(val id: String) + + companion object { + fun keys(): List = + listOf( + Expectation( + "private nested object", + PrivateNestedObject, + "io.sentry.tests.nav3.r8.Holder.PrivateNestedObject", + ), + Expectation( + "private nested class", + PrivateNestedClass("1"), + "io.sentry.tests.nav3.r8.Holder.PrivateNestedClass", + mapOf("id" to "1"), + ), + ) + } +} + +private const val PKG = "io.sentry.tests.nav3.r8" + +private val ID_ARGUMENTS = mapOf("id" to "1") + +private val argumentsKey = + ArgumentsKey( + productId = 42, + quantity = UInt.MAX_VALUE, + authToken = "secret", + price = Price(999), + sort = SortOrder.ASC, + tags = listOf("a", "b"), + sizes = setOf(1, 2), + counts = mapOf("apiKey" to 1, "views" to 2), + filter = Filter(sessionId = "secret", query = "shoes"), + filters = listOf(Filter(sessionId = "secret", query = "hats")), + origin = Origin.Search("shoes"), + fallbackOrigin = Origin.DeepLink, + note = null, + ) + +private val argumentsKeyArguments = + mapOf( + "productId" to 42, + "quantity" to 4_294_967_295L, + "authToken" to "[Filtered]", + "price" to 999, + "sort" to "ascending", + "tags" to listOf("a", "b"), + "sizes" to listOf(1, 2), + "counts" to mapOf("apiKey" to "[Filtered]", "views" to 2), + "filter" to mapOf("sessionId" to "[Filtered]", "query" to "shoes"), + "filters" to listOf(mapOf("sessionId" to "[Filtered]", "query" to "hats")), + "origin" to mapOf("type" to "search", "value" to mapOf("term" to "shoes")), + "fallbackOrigin" to mapOf("type" to "deeplink", "value" to emptyMap()), + "note" to null, + ) + +fun serializableExpectations(): List = + listOf( + Expectation("public data object", PublicObject, "$PKG.PublicObject"), + Expectation("data class with @SerialName", NamedClass("1"), "Named", ID_ARGUMENTS), + Expectation("data class", DefaultNamedClass("1"), "$PKG.DefaultNamedClass", ID_ARGUMENTS), + Expectation("sealed child object", Sealed.Child, "$PKG.Sealed.Child"), + Expectation("sealed leaf class", Sealed.Leaf("1"), "$PKG.Sealed.Leaf", ID_ARGUMENTS), + Expectation( + "serializable enum", + SerializableEnum.A, + "$PKG.SerializableEnum", + mapOf("value" to "A"), + ), + Expectation("generic class", Generic("x"), null), + Expectation("private top-level object", PrivateTopLevelObject, "$PKG.PrivateTopLevelObject"), + Expectation( + "private top-level class", + PrivateTopLevelClass("1"), + "$PKG.PrivateTopLevelClass", + ID_ARGUMENTS, + ), + Expectation("arguments key", argumentsKey, "$PKG.ArgumentsKey", argumentsKeyArguments), + Expectation( + "named companion without rules", + NamedCompanionKey.of("1"), + "$PKG.NamedCompanionKey", + ID_ARGUMENTS, + alsoAcceptsUnnamed = !BuildConfig.KOTLINX_KEEPS_NAMED_COMPANIONS, + ), + Expectation( + "named companion with rules", + NamedCompanionKeyWithRules.of("1"), + "$PKG.NamedCompanionKeyWithRules", + ID_ARGUMENTS, + ), + ) + Holder.keys() + +fun minificationChecks(): List = + listOf( + MinificationCheck( + "PublicObject was renamed (runtime class ${PublicObject::class.java.name})", + PublicObject::class.java.name != "$PKG.PublicObject", + ), + // Argument names come from serializer descriptors, so they survive R8 renaming fields. + MinificationCheck( + "ArgumentsKey fields were renamed " + + "(fields ${ArgumentsKey::class.java.declaredFields.map { it.name }})", + ArgumentsKey::class.java.declaredFields.none { it.name == "productId" }, + ), + ) diff --git a/sentry-android-integration-tests/settings.gradle.kts b/sentry-android-integration-tests/settings.gradle.kts index 99bc456129..0d70fff0a1 100644 --- a/sentry-android-integration-tests/settings.gradle.kts +++ b/sentry-android-integration-tests/settings.gradle.kts @@ -51,6 +51,7 @@ dependencyResolutionManagement { // gradle.properties links to the SDK build's, so versionName is the SDK version. version("sentry", providers.gradleProperty("versionName").get()) } + create("nav3Libs") { from(files("../gradle/nav3.versions.toml")) } } } @@ -66,3 +67,4 @@ include("sentry-uitest-android") include("sentry-uitest-android-critical") include("sentry-uitest-android-macrobenchmark") include("test-app-size") +include("nav3-backstack-entry-mapper-r8-check")