Cover both MediaStore save paths with a fake provider

DefaultFileSave had no test at all and AndroidLocalMediaActions only exercised the
failing path, so neither the uniquifying retry nor the new IOException on a null
insert was ever executed.

FakeMediaStoreContentProvider stands in for the media authority: it records the
display names an insert is attempted with, keeps whatever is copied into it, and can
either collide a name the way MediaStore does past 32 files or refuse to create
anything. Both call sites now go through it for the plain save, the retry and the
rejected insert.

Its name cannot follow the Fake<Interface> convention because it extends the
framework ContentProvider, so it joins the existing exceptions in
KonsistClassNameTest next to FakeFileSystem and FakeKeyStore.

features/viewfolder/impl/src/test/kotlin/io/element/android/features/viewfolder/impl/file/DefaultFileSaveTest.kt

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2026 Element Creations Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.features.viewfolder.impl.file
+
+import com.google.common.truth.Truth.assertThat
+import io.element.android.tests.testutils.fake.registerFakeMediaStoreContentProvider
+import io.element.android.tests.testutils.robolectric.RobolectricTest
+import io.element.android.tests.testutils.testCoroutineDispatchers
+import kotlinx.coroutines.test.TestScope
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+import org.robolectric.RuntimeEnvironment
+import java.io.File
+
+class DefaultFileSaveTest : RobolectricTest() {
+    @Test
+    fun `save inserts the file in the Downloads collection under its own name`() = runTest {
+        val mediaStore = registerFakeMediaStoreContentProvider()
+        createFileSave().save(aFileToSave().path)
+        assertThat(mediaStore.insertedDisplayNames).containsExactly("a-file.txt")
+        assertThat(mediaStore.savedContent("a-file.txt")).isEqualTo("Some content")
+    }
+
+    @Test
+    fun `save retries with a suffixed name when the name cannot be made unique`() = runTest {
+        val mediaStore = registerFakeMediaStoreContentProvider().apply {
+            conflictingDisplayNames = setOf("a-file.txt")
+        }
+        createFileSave().save(aFileToSave().path)
+        assertThat(mediaStore.insertedDisplayNames).hasSize(2)
+        assertThat(mediaStore.insertedDisplayNames.last()).matches("a-file_\\d+\\.txt")
+        assertThat(mediaStore.savedContent(mediaStore.insertedDisplayNames.last())).isEqualTo("Some content")
+    }
+
+    @Test
+    fun `save writes nothing when the destination cannot be created`() = runTest {
+        val mediaStore = registerFakeMediaStoreContentProvider().apply {
+            returnsNoUriOnInsert = true
+        }
+        createFileSave().save(aFileToSave().path)
+        assertThat(mediaStore.insertedDisplayNames).containsExactly("a-file.txt")
+        assertThat(mediaStore.savedFileNames()).isEmpty()
+    }
+
+    private fun aFileToSave(): File {
+        return File(RuntimeEnvironment.getApplication().cacheDir, "a-file.txt").apply {
+            writeText("Some content")
+        }
+    }
+
+    private fun TestScope.createFileSave() = DefaultFileSave(
+        context = RuntimeEnvironment.getApplication(),
+        dispatchers = testCoroutineDispatchers(),
+    )
+}

libraries/mediaviewer/impl/src/test/kotlin/io/element/android/libraries/mediaviewer/impl/local/AndroidLocalMediaActionsTest.kt

@@ -12,18 +12,22 @@ import android.net.Uri
 import androidx.activity.compose.LocalActivityResultRegistryOwner
 import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.ui.platform.LocalContext
+import androidx.core.net.toUri
 import app.cash.molecule.RecompositionMode
 import app.cash.molecule.moleculeFlow
 import app.cash.turbine.test
 import com.google.common.truth.Truth.assertThat
 import io.element.android.libraries.matrix.test.core.aBuildMeta
 import io.element.android.libraries.mediaviewer.test.viewer.aLocalMedia
+import io.element.android.tests.testutils.fake.registerFakeMediaStoreContentProvider
 import io.element.android.tests.testutils.robolectric.RobolectricTest
 import io.element.android.tests.testutils.testCoroutineDispatchers
 import kotlinx.coroutines.test.TestScope
 import kotlinx.coroutines.test.runTest
 import org.junit.Test
 import org.robolectric.RuntimeEnvironment
+import java.io.File
+import java.io.IOException
 
 class AndroidLocalMediaActionsTest : RobolectricTest() {
     @Test
@@ -62,6 +66,43 @@ class AndroidLocalMediaActionsTest : RobolectricTest() {
         assertThat(result.exceptionOrNull()).isNotNull()
     }
 
+    @Test
+    fun `test AndroidLocalMediaAction save on disk inserts the media under its own name`() = runTest {
+        val mediaStore = registerFakeMediaStoreContentProvider()
+        val sut = createAndroidLocalMediaActions()
+        val result = sut.saveOnDisk(aLocalMedia(aMediaFile().toUri()))
+        assertThat(result.exceptionOrNull()).isNull()
+        assertThat(mediaStore.insertedDisplayNames).containsExactly("an image file.jpg")
+    }
+
+    @Test
+    fun `test AndroidLocalMediaAction save on disk retries with a suffixed name when the name cannot be made unique`() = runTest {
+        val mediaStore = registerFakeMediaStoreContentProvider().apply {
+            conflictingDisplayNames = setOf("an image file.jpg")
+        }
+        val sut = createAndroidLocalMediaActions()
+        val result = sut.saveOnDisk(aLocalMedia(aMediaFile().toUri()))
+        assertThat(result.exceptionOrNull()).isNull()
+        assertThat(mediaStore.insertedDisplayNames).hasSize(2)
+        assertThat(mediaStore.insertedDisplayNames.last()).matches("an image file_\\d+\\.jpg")
+    }
+
+    @Test
+    fun `test AndroidLocalMediaAction save on disk fails when the destination cannot be created`() = runTest {
+        registerFakeMediaStoreContentProvider().apply {
+            returnsNoUriOnInsert = true
+        }
+        val sut = createAndroidLocalMediaActions()
+        val result = sut.saveOnDisk(aLocalMedia(aMediaFile().toUri()))
+        assertThat(result.exceptionOrNull()).isInstanceOf(IOException::class.java)
+    }
+
+    private fun aMediaFile(): File {
+        return File(RuntimeEnvironment.getApplication().cacheDir, "an image file.jpg").apply {
+            writeText("Some content")
+        }
+    }
+
     private fun TestScope.createAndroidLocalMediaActions() = AndroidLocalMediaActions(
         RuntimeEnvironment.getApplication(),
         testCoroutineDispatchers(),

tests/konsist/src/test/kotlin/io/element/android/tests/konsist/KonsistClassNameTest.kt

@@ -104,6 +104,7 @@ class KonsistClassNameTest {
                 "FakeImageLoader",
                 "FakeKeyStore",
                 "FakeListenableFuture",
+                "FakeMediaStoreContentProvider",
             )
             .assertTrue {
                 val interfaceName = it.name

tests/testutils/src/main/kotlin/io/element/android/tests/testutils/fake/FakeMediaStoreContentProvider.kt

@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2026 Element Creations Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.tests.testutils.fake
+
+import android.content.ContentProvider
+import android.content.ContentValues
+import android.content.pm.ProviderInfo
+import android.database.Cursor
+import android.net.Uri
+import android.os.ParcelFileDescriptor
+import android.provider.MediaStore
+import androidx.test.core.app.ApplicationProvider
+import org.robolectric.shadows.ShadowContentResolver
+import java.io.File
+import java.nio.file.Files
+
+/**
+ * Stands in for the MediaStore provider: it records the display names an insert is attempted with,
+ * writes what is copied into it to a temporary directory, and can make any display name collide the
+ * way MediaStore does once a directory already holds 32 files with the same name.
+ */
+class FakeMediaStoreContentProvider : ContentProvider() {
+    private val directory: File = Files.createTempDirectory("fake-media-store").toFile()
+
+    val insertedDisplayNames = mutableListOf<String>()
+
+    var conflictingDisplayNames: Set<String> = emptySet()
+
+    /** When true, an insert reports that it created nothing, the way a rejected insert does. */
+    var returnsNoUriOnInsert: Boolean = false
+
+    fun savedFileNames(): List<String> = directory.list().orEmpty().toList()
+
+    fun savedContent(displayName: String): String = File(directory, displayName).readText()
+
+    override fun onCreate() = true
+
+    override fun insert(uri: Uri, values: ContentValues?): Uri? {
+        val displayName = values?.getAsString(MediaStore.MediaColumns.DISPLAY_NAME).orEmpty()
+        insertedDisplayNames += displayName
+        check(displayName !in conflictingDisplayNames) { "Failed to build unique file" }
+        return if (returnsNoUriOnInsert) null else uri.buildUpon().appendPath(displayName).build()
+    }
+
+    override fun openFile(uri: Uri, mode: String): ParcelFileDescriptor {
+        val file = File(directory, uri.lastPathSegment.orEmpty())
+        return ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_CREATE or ParcelFileDescriptor.MODE_READ_WRITE)
+    }
+
+    override fun query(uri: Uri, projection: Array<out String>?, selection: String?, selectionArgs: Array<out String>?, sortOrder: String?): Cursor? = null
+
+    override fun getType(uri: Uri): String? = null
+
+    override fun update(uri: Uri, values: ContentValues?, selection: String?, selectionArgs: Array<out String>?) = 0
+
+    override fun delete(uri: Uri, selection: String?, selectionArgs: Array<out String>?) = 0
+}
+
+fun registerFakeMediaStoreContentProvider(): FakeMediaStoreContentProvider {
+    return FakeMediaStoreContentProvider().apply {
+        attachInfo(
+            ApplicationProvider.getApplicationContext(),
+            ProviderInfo().apply { authority = MediaStore.AUTHORITY }
+        )
+        ShadowContentResolver.registerProviderInternal(MediaStore.AUTHORITY, this)
+    }
+}