From 9c58a8057364215348535ca09ed72f134bf532fa Mon Sep 17 00:00:00 2001 From: stylianosgakis Date: Wed, 18 Nov 2026 11:48:36 +0100 Subject: [PATCH 1/4] Add an Apollo client that never sends a token --- .../android/core/common/di/Qualifiers.kt | 5 ++ .../clients/di/NetworkMetroProviders.kt | 20 ++++++ .../clients/di/JvmNetworkBindingsTest.kt | 65 +++++++++++++++++++ .../com/hedvig/android/umbrella/IosGraph.kt | 10 +++ .../hedvig/android/umbrella/IosGraphTest.kt | 29 +++++++++ 5 files changed, 129 insertions(+) diff --git a/app/core/core-common-public/src/commonMain/kotlin/com/hedvig/android/core/common/di/Qualifiers.kt b/app/core/core-common-public/src/commonMain/kotlin/com/hedvig/android/core/common/di/Qualifiers.kt index c00a50c008..6fb2d909e1 100644 --- a/app/core/core-common-public/src/commonMain/kotlin/com/hedvig/android/core/common/di/Qualifiers.kt +++ b/app/core/core-common-public/src/commonMain/kotlin/com/hedvig/android/core/common/di/Qualifiers.kt @@ -17,6 +17,11 @@ annotation class IoDispatcher @Retention(AnnotationRetention.RUNTIME) annotation class BaseHttpClient +/** Apollo client that never sends an access token, for requests made before login. */ +@Qualifier +@Retention(AnnotationRetention.RUNTIME) +annotation class PublicApolloClient + /** Ktor engine for the auth client, carrying the app's network observability hooks. */ @Qualifier @Retention(AnnotationRetention.RUNTIME) diff --git a/app/network/network-clients/src/commonMain/kotlin/com/hedvig/android/network/clients/di/NetworkMetroProviders.kt b/app/network/network-clients/src/commonMain/kotlin/com/hedvig/android/network/clients/di/NetworkMetroProviders.kt index 6db3f1f612..8050513b0d 100644 --- a/app/network/network-clients/src/commonMain/kotlin/com/hedvig/android/network/clients/di/NetworkMetroProviders.kt +++ b/app/network/network-clients/src/commonMain/kotlin/com/hedvig/android/network/clients/di/NetworkMetroProviders.kt @@ -8,6 +8,7 @@ import com.apollographql.ktor.ktorClient import com.hedvig.android.core.buildconstants.HedvigBuildConstants import com.hedvig.android.core.common.di.AppScope import com.hedvig.android.core.common.di.BaseHttpClient +import com.hedvig.android.core.common.di.PublicApolloClient import com.hedvig.android.core.datastore.DeviceIdFetcher import com.hedvig.android.language.LanguageService import com.hedvig.android.logger.logcat @@ -68,6 +69,25 @@ interface NetworkMetroProviders { .config {} .apply { addAuthPlugin(accessTokenFetcher) } + /** + * Built on the token-free [BaseHttpClient], so a request never carries an `Authorization` header and never asks for a + * token. It has its own small cache and no platform interceptors, so a rejected request cannot log the member out. + */ + @Provides + @SingleIn(AppScope::class) + @PublicApolloClient + fun providePublicApolloClient( + @BaseHttpClient httpClient: HttpClient, + hedvigBuildConstants: HedvigBuildConstants, + networkLogPolicy: NetworkLogPolicy, + ): ApolloClient = buildHedvigApolloClient( + MemoryCacheFactory(maxSizeBytes = 1024 * 1024), + httpClient, + hedvigBuildConstants, + platformInterceptors = emptyList(), + networkLogPolicy = networkLogPolicy, + ) + @Provides @SingleIn(AppScope::class) fun provideNormalizedCacheFactory(): NormalizedCacheFactory = MemoryCacheFactory(maxSizeBytes = 10 * 1024 * 1024) diff --git a/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/di/JvmNetworkBindingsTest.kt b/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/di/JvmNetworkBindingsTest.kt index 26410d242e..52edfb9c4f 100644 --- a/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/di/JvmNetworkBindingsTest.kt +++ b/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/di/JvmNetworkBindingsTest.kt @@ -1,11 +1,22 @@ package com.hedvig.android.network.clients.di +import com.apollographql.apollo.ApolloClient +import com.apollographql.apollo.api.Adapter +import com.apollographql.apollo.api.CompiledField +import com.apollographql.apollo.api.CustomScalarAdapters +import com.apollographql.apollo.api.Query +import com.apollographql.apollo.api.json.JsonWriter +import com.apollographql.cache.normalized.FetchPolicy +import com.apollographql.cache.normalized.fetchPolicy import com.hedvig.android.auth.AccessTokenProvider import com.hedvig.android.core.buildconstants.AppBuildConfig import com.hedvig.android.core.buildconstants.Flavor import com.hedvig.android.core.common.di.AppScope import com.hedvig.android.core.common.di.AuthHttpClientEngine +import com.hedvig.android.core.common.di.BaseHttpClient import com.hedvig.android.core.common.di.DesktopDataDirectory +import com.hedvig.android.core.common.di.PublicApolloClient +import com.hedvig.android.logger.TestLogcatLoggingRule import com.hedvig.android.network.clients.AccessTokenFetcher import com.hedvig.android.network.clients.ExtraKtorClientConfiguration import com.hedvig.android.network.clients.NetworkLogPolicy @@ -14,8 +25,12 @@ import com.hedvig.android.network.clients.TlsDiagnostics import dev.zacsweers.metro.DependencyGraph import dev.zacsweers.metro.Provides import dev.zacsweers.metro.createGraphFactory +import io.ktor.client.HttpClient import io.ktor.client.engine.HttpClientEngine import io.ktor.client.engine.okhttp.OkHttpEngine +import io.ktor.client.plugins.HttpSend +import io.ktor.client.plugins.plugin +import io.ktor.http.Headers import java.io.File import javax.net.ssl.SSLHandshakeException import kotlin.io.path.createTempDirectory @@ -23,8 +38,10 @@ import kotlin.test.AfterTest import kotlin.test.Test import kotlin.test.assertEquals import kotlin.test.assertIs +import kotlin.test.assertNotNull import kotlin.test.assertNull import kotlinx.coroutines.test.runTest +import org.junit.Rule @DependencyGraph(AppScope::class) internal interface NetworkTestGraph { @@ -33,6 +50,12 @@ internal interface NetworkTestGraph { val tlsDiagnostics: TlsDiagnostics val networkLogPolicy: NetworkLogPolicy + @PublicApolloClient + val publicApolloClient: ApolloClient + + @BaseHttpClient + val baseHttpClient: HttpClient + @AuthHttpClientEngine val authHttpClientEngine: HttpClientEngine @@ -46,6 +69,9 @@ internal interface NetworkTestGraph { } class JvmNetworkBindingsTest { + @get:Rule + val testLogcatLogger = TestLogcatLoggingRule() + private val dataDirectory: File = createTempDirectory("network-bindings-test").toFile() private val graph = createGraphFactory().create(dataDirectory, TestAppBuildConfig) @@ -71,12 +97,51 @@ class JvmNetworkBindingsTest { assertIs(graph.authHttpClientEngine) } + @Test + fun `a query on the public Apollo client is sent without an Authorization header even when a token is available`() = + runTest { + val sent = mutableListOf() + graph.baseHttpClient.plugin(HttpSend).intercept { request -> + sent += request.headers.build() + throw RequestRecorded() + } + + graph.publicApolloClient.query(TestQuery).fetchPolicy(FetchPolicy.NetworkOnly).execute() + + assertEquals(1, sent.size) + assertNull(sent.single()["Authorization"]) + assertNotNull(sent.single()["Accept-Language"]) + } + @Test fun `the TLS diagnostics describe nothing, even for a trust failure`() = runTest { assertNull(graph.tlsDiagnostics.describe(SSLHandshakeException("Trust anchor for certification path not found."))) } } +private object TestQuery : Query { + object Data : Query.Data + + override fun document(): String = "query Test { __typename }" + + override fun name(): String = "Test" + + override fun id(): String = "Test" + + override fun adapter(): Adapter = error("The request is aborted before a response exists") + + override fun serializeVariables( + writer: JsonWriter, + customScalarAdapters: CustomScalarAdapters, + withDefaultValues: Boolean, + ) {} + + override fun rootField(): CompiledField = error("The request is aborted before the cache is read") +} + +/** Thrown by the test's last-stop interceptor so the request never leaves the machine. */ +private class RequestRecorded : RuntimeException() + private object TestAppBuildConfig : AppBuildConfig { override val debug: Boolean = true override val applicationId: String = "com.hedvig.dev.app" diff --git a/app/umbrella/src/nativeMain/kotlin/com/hedvig/android/umbrella/IosGraph.kt b/app/umbrella/src/nativeMain/kotlin/com/hedvig/android/umbrella/IosGraph.kt index e4baf8aeda..4988d82d45 100644 --- a/app/umbrella/src/nativeMain/kotlin/com/hedvig/android/umbrella/IosGraph.kt +++ b/app/umbrella/src/nativeMain/kotlin/com/hedvig/android/umbrella/IosGraph.kt @@ -6,6 +6,8 @@ import com.hedvig.android.auth.event.AuthEventStorage import com.hedvig.android.core.buildconstants.AppBuildConfig import com.hedvig.android.core.common.di.ActivityRetainedScope import com.hedvig.android.core.common.di.AppScope +import com.hedvig.android.core.common.di.BaseHttpClient +import com.hedvig.android.core.common.di.PublicApolloClient import com.hedvig.android.core.datastore.DeviceIdFetcher import com.hedvig.android.core.demomode.IosDemoMode import com.hedvig.android.initializable.Initializable @@ -15,6 +17,7 @@ import com.hedvig.android.network.clients.NetworkLogPolicy import dev.zacsweers.metro.DependencyGraph import dev.zacsweers.metro.Provides import dev.zacsweers.metrox.viewmodel.ViewModelGraph +import io.ktor.client.HttpClient /** * The iOS app's single graph. There is no Activity, so [ActivityRetainedScope] shares the graph's lifetime through @@ -30,6 +33,13 @@ internal interface IosGraph : ViewModelGraph { val apolloClient: ApolloClient + @PublicApolloClient + val publicApolloClient: ApolloClient + + /** The token-free client behind [publicApolloClient], reached by tests to observe what it sends. */ + @BaseHttpClient + val baseHttpClient: HttpClient + @DependencyGraph.Factory interface Factory { fun create( diff --git a/app/umbrella/src/nativeTest/kotlin/com/hedvig/android/umbrella/IosGraphTest.kt b/app/umbrella/src/nativeTest/kotlin/com/hedvig/android/umbrella/IosGraphTest.kt index f996836c53..2ad6f9fd04 100644 --- a/app/umbrella/src/nativeTest/kotlin/com/hedvig/android/umbrella/IosGraphTest.kt +++ b/app/umbrella/src/nativeTest/kotlin/com/hedvig/android/umbrella/IosGraphTest.kt @@ -14,6 +14,7 @@ import assertk.assertions.isInstanceOf import assertk.assertions.isNotNull import assertk.assertions.isNull import assertk.assertions.isTrue +import assertk.assertions.single import com.apollographql.apollo.ApolloClient import com.apollographql.apollo.exception.ApolloNetworkException import com.apollographql.cache.normalized.FetchPolicy @@ -48,7 +49,10 @@ import com.hedvig.android.network.clients.NetworkLogPolicy import io.ktor.client.HttpClient import io.ktor.client.engine.mock.MockEngine import io.ktor.client.engine.mock.respond +import io.ktor.client.plugins.HttpSend +import io.ktor.client.plugins.plugin import io.ktor.http.ContentType +import io.ktor.http.Headers import io.ktor.http.HttpHeaders import io.ktor.http.HttpStatusCode import io.ktor.http.headersOf @@ -381,6 +385,31 @@ class IosGraphTest { assertThat(inputs.accessTokenFetcher.calls.value).isEqualTo(2) } + @Test + fun `a query on the public Apollo client is sent without an Authorization header and without fetching a token`() { + val inputs = FakeInputs() + val holder = inputs.createHolder() + val sent = mutableListOf() + // The graph's Darwin engine cannot be replaced, so the request is recorded just before the engine and aborted + // there. The client's default headers are already on it by then. + holder.graph.baseHttpClient.plugin(HttpSend).intercept { request -> + sent += request.headers.build() + throw IllegalStateException("Request recorded, not sent") + } + + runBlocking { + holder.graph.publicApolloClient + .query(PayingMemberPhoneNumberQuery()) + .fetchPolicy(FetchPolicy.NetworkOnly) + .execute() + } + + assertThat(sent.size).isEqualTo(1) + assertThat(sent.single()["Authorization"]).isNull() + assertThat(sent.single()["Accept-Language"]).isNotNull() + assertThat(inputs.accessTokenFetcher.calls.value).isEqualTo(0) + } + @Test fun `an UNAUTHENTICATED response does not log out or change demo mode`() { val inputs = FakeInputs() From 6f91654f0c59cc0ab3f1fa45bdbf39db243802e8 Mon Sep 17 00:00:00 2001 From: stylianosgakis Date: Wed, 18 Nov 2026 11:51:56 +0100 Subject: [PATCH 2/4] Prove the public Apollo client never fetches a token on the JVM --- .../clients/di/JvmNetworkBindingsTest.kt | 76 +++++++++++++++---- .../hedvig/android/umbrella/IosGraphTest.kt | 3 +- 2 files changed, 64 insertions(+), 15 deletions(-) diff --git a/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/di/JvmNetworkBindingsTest.kt b/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/di/JvmNetworkBindingsTest.kt index 52edfb9c4f..bcbeadd57d 100644 --- a/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/di/JvmNetworkBindingsTest.kt +++ b/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/di/JvmNetworkBindingsTest.kt @@ -11,6 +11,7 @@ import com.apollographql.cache.normalized.fetchPolicy import com.hedvig.android.auth.AccessTokenProvider import com.hedvig.android.core.buildconstants.AppBuildConfig import com.hedvig.android.core.buildconstants.Flavor +import com.hedvig.android.core.buildconstants.HedvigBuildConstants import com.hedvig.android.core.common.di.AppScope import com.hedvig.android.core.common.di.AuthHttpClientEngine import com.hedvig.android.core.common.di.BaseHttpClient @@ -27,10 +28,14 @@ import dev.zacsweers.metro.Provides import dev.zacsweers.metro.createGraphFactory import io.ktor.client.HttpClient import io.ktor.client.engine.HttpClientEngine +import io.ktor.client.engine.mock.MockEngine +import io.ktor.client.engine.mock.respond import io.ktor.client.engine.okhttp.OkHttpEngine import io.ktor.client.plugins.HttpSend import io.ktor.client.plugins.plugin +import io.ktor.client.request.get import io.ktor.http.Headers +import io.ktor.http.HttpStatusCode import java.io.File import javax.net.ssl.SSLHandshakeException import kotlin.io.path.createTempDirectory @@ -40,6 +45,7 @@ import kotlin.test.assertEquals import kotlin.test.assertIs import kotlin.test.assertNotNull import kotlin.test.assertNull +import kotlin.test.assertTrue import kotlinx.coroutines.test.runTest import org.junit.Rule @@ -49,6 +55,7 @@ internal interface NetworkTestGraph { val extraKtorClientConfiguration: ExtraKtorClientConfiguration val tlsDiagnostics: TlsDiagnostics val networkLogPolicy: NetworkLogPolicy + val hedvigBuildConstants: HedvigBuildConstants @PublicApolloClient val publicApolloClient: ApolloClient @@ -98,21 +105,50 @@ class JvmNetworkBindingsTest { } @Test - fun `a query on the public Apollo client is sent without an Authorization header even when a token is available`() = - runTest { - val sent = mutableListOf() - graph.baseHttpClient.plugin(HttpSend).intercept { request -> - sent += request.headers.build() - throw RequestRecorded() - } - - graph.publicApolloClient.query(TestQuery).fetchPolicy(FetchPolicy.NetworkOnly).execute() - - assertEquals(1, sent.size) - assertNull(sent.single()["Authorization"]) - assertNotNull(sent.single()["Accept-Language"]) + fun `the public Apollo client sends through the graph's base HTTP client`() = runTest { + val sent = mutableListOf() + graph.baseHttpClient.plugin(HttpSend).intercept { request -> + sent += request.headers.build() + throw RequestRecorded() } + val response = graph.publicApolloClient.query(TestQuery).fetchPolicy(FetchPolicy.NetworkOnly).execute() + + assertEquals(REQUEST_RECORDED_MESSAGE, response.exception?.message) + assertEquals(1, sent.size) + assertNotNull(sent.single()["Accept-Language"]) + } + + @Test + fun `the public Apollo client never fetches a token while the member client does`() = runTest { + val fetcher = CountingAccessTokenFetcher() + val received = mutableListOf() + val engine = MockEngine { request -> + received += request.headers + respond("", HttpStatusCode.InternalServerError) + } + val baseClient = HttpClient(engine) { install(HttpSend) } + val providers = object : NetworkMetroProviders {} + val publicClient = providers.providePublicApolloClient( + baseClient, + graph.hedvigBuildConstants, + graph.networkLogPolicy, + ) + + publicClient.query(TestQuery).fetchPolicy(FetchPolicy.NetworkOnly).execute() + + assertEquals(1, received.size) + assertNull(received.single()["Authorization"]) + assertEquals(0, fetcher.calls) + + // Control: the member client over the same base client does fetch the token and send it. + providers.provideHttpClient(baseClient, fetcher).get("https://example.com") + + assertEquals(2, received.size) + assertEquals("Bearer token", received.last()["Authorization"]) + assertTrue(fetcher.calls > 0) + } + @Test fun `the TLS diagnostics describe nothing, even for a trust failure`() = runTest { assertNull(graph.tlsDiagnostics.describe(SSLHandshakeException("Trust anchor for certification path not found."))) @@ -140,7 +176,19 @@ private object TestQuery : Query { } /** Thrown by the test's last-stop interceptor so the request never leaves the machine. */ -private class RequestRecorded : RuntimeException() +private class RequestRecorded : RuntimeException(REQUEST_RECORDED_MESSAGE) + +private const val REQUEST_RECORDED_MESSAGE = "Request recorded, not sent" + +private class CountingAccessTokenFetcher : AccessTokenFetcher { + var calls = 0 + private set + + override suspend fun fetch(): String? { + calls++ + return "token" + } +} private object TestAppBuildConfig : AppBuildConfig { override val debug: Boolean = true diff --git a/app/umbrella/src/nativeTest/kotlin/com/hedvig/android/umbrella/IosGraphTest.kt b/app/umbrella/src/nativeTest/kotlin/com/hedvig/android/umbrella/IosGraphTest.kt index 2ad6f9fd04..3252b17722 100644 --- a/app/umbrella/src/nativeTest/kotlin/com/hedvig/android/umbrella/IosGraphTest.kt +++ b/app/umbrella/src/nativeTest/kotlin/com/hedvig/android/umbrella/IosGraphTest.kt @@ -397,13 +397,14 @@ class IosGraphTest { throw IllegalStateException("Request recorded, not sent") } - runBlocking { + val response = runBlocking { holder.graph.publicApolloClient .query(PayingMemberPhoneNumberQuery()) .fetchPolicy(FetchPolicy.NetworkOnly) .execute() } + assertThat(response.exception?.message).isEqualTo("Request recorded, not sent") assertThat(sent.size).isEqualTo(1) assertThat(sent.single()["Authorization"]).isNull() assertThat(sent.single()["Accept-Language"]).isNotNull() From 1f6ac944e46433ec8c772f8fa3fd828fbf3d3365 Mon Sep 17 00:00:00 2001 From: stylianosgakis Date: Wed, 18 Nov 2026 12:45:52 +0100 Subject: [PATCH 3/4] Check the public client stays token-free after the member client exists --- .../android/network/clients/di/JvmNetworkBindingsTest.kt | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/di/JvmNetworkBindingsTest.kt b/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/di/JvmNetworkBindingsTest.kt index bcbeadd57d..9952278754 100644 --- a/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/di/JvmNetworkBindingsTest.kt +++ b/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/di/JvmNetworkBindingsTest.kt @@ -147,6 +147,14 @@ class JvmNetworkBindingsTest { assertEquals(2, received.size) assertEquals("Bearer token", received.last()["Authorization"]) assertTrue(fetcher.calls > 0) + + // In the app the member client exists and has been used before the public query runs, so check that order too. + val callsAfterMemberClient = fetcher.calls + publicClient.query(TestQuery).fetchPolicy(FetchPolicy.NetworkOnly).execute() + + assertEquals(3, received.size) + assertNull(received.last()["Authorization"]) + assertEquals(callsAfterMemberClient, fetcher.calls) } @Test From 90874ec9dba2563270b9ee7343d767e86d39d111 Mon Sep 17 00:00:00 2001 From: stylianosgakis Date: Wed, 18 Nov 2026 14:34:19 +0100 Subject: [PATCH 4/4] Keep the network binding tests off shared DataStore files Building the base HTTP client starts the device id's first DataStore write on the application scope. The test's teardown deleted the data directory under that write, and the uncaught IOException then failed the next runTest in the class. Teardown now waits for the application scope's work before deleting the directory. --- .../android/network/clients/di/JvmNetworkBindingsTest.kt | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/di/JvmNetworkBindingsTest.kt b/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/di/JvmNetworkBindingsTest.kt index 9952278754..3afae59a2c 100644 --- a/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/di/JvmNetworkBindingsTest.kt +++ b/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/di/JvmNetworkBindingsTest.kt @@ -12,6 +12,7 @@ import com.hedvig.android.auth.AccessTokenProvider import com.hedvig.android.core.buildconstants.AppBuildConfig import com.hedvig.android.core.buildconstants.Flavor import com.hedvig.android.core.buildconstants.HedvigBuildConstants +import com.hedvig.android.core.common.ApplicationScope import com.hedvig.android.core.common.di.AppScope import com.hedvig.android.core.common.di.AuthHttpClientEngine import com.hedvig.android.core.common.di.BaseHttpClient @@ -46,6 +47,9 @@ import kotlin.test.assertIs import kotlin.test.assertNotNull import kotlin.test.assertNull import kotlin.test.assertTrue +import kotlinx.coroutines.job +import kotlinx.coroutines.joinAll +import kotlinx.coroutines.runBlocking import kotlinx.coroutines.test.runTest import org.junit.Rule @@ -56,6 +60,7 @@ internal interface NetworkTestGraph { val tlsDiagnostics: TlsDiagnostics val networkLogPolicy: NetworkLogPolicy val hedvigBuildConstants: HedvigBuildConstants + val applicationScope: ApplicationScope @PublicApolloClient val publicApolloClient: ApolloClient @@ -84,6 +89,9 @@ class JvmNetworkBindingsTest { @AfterTest fun tearDown() { + // Building the base HTTP client launches the device id's first DataStore write on the application scope. Deleting + // the directory under that write fails it, and the uncaught IOException then fails whichever runTest comes next. + runBlocking { graph.applicationScope.coroutineContext.job.children.toList().joinAll() } dataDirectory.deleteRecursively() }