Merge pull request #1617 from DimensionDev/bugfix/opml_import_crash

refactor: improve OPML import concurrency handling and add stress test

Author: Tlaster

shared/src/commonMain/kotlin/dev/dimension/flare/ui/presenter/home/rss/ImportOPMLPresenter.kt

@@ -18,8 +18,8 @@ import dev.dimension.flare.ui.model.mapper.render
 import dev.dimension.flare.ui.presenter.PresenterBase
 import kotlinx.collections.immutable.ImmutableList
 import kotlinx.collections.immutable.toImmutableList
-import kotlinx.coroutines.async
-import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.flow.channelFlow
+import kotlinx.coroutines.launch
 import org.koin.core.component.KoinComponent
 import org.koin.core.component.inject
 import kotlin.time.Clock
@@ -58,17 +58,17 @@ public class ImportOPMLPresenter(
 
                 totalCount = outlines.size
 
-                val sources =
+                channelFlow {
                     outlines
                         .filter { it.xmlUrl != null }
-                        .map { outline ->
-                            async {
-                                val url = outline.xmlUrl ?: return@async null
+                        .forEach { outline ->
+                            launch {
+                                val url = outline.xmlUrl ?: return@launch
 
                                 val existing = appDatabase.rssSourceDao().getByUrl(url)
                                 if (existing.isNotEmpty()) {
-                                    importedSources.add(existing.first().render())
-                                    return@async null
+                                    send(existing.first().render())
+                                    return@launch
                                 }
 
                                 val icon =
@@ -78,19 +78,22 @@ public class ImportOPMLPresenter(
                                         null
                                     }
 
-                                DbRssSources(
-                                    url = url,
-                                    title = outline.title ?: outline.text,
-                                    icon = icon,
-                                    lastUpdate = Clock.System.now().toEpochMilliseconds(),
-                                ).apply {
-                                    importedSources.add(this.render())
-                                }
-                            }
-                        }.awaitAll()
-                        .filterNotNull()
+                                val newSource =
+                                    DbRssSources(
+                                        url = url,
+                                        title = outline.title ?: outline.text,
+                                        icon = icon,
+                                        lastUpdate = Clock.System.now().toEpochMilliseconds(),
+                                    )
 
-                appDatabase.rssSourceDao().insertAll(sources)
+                                appDatabase.rssSourceDao().insert(newSource)
+
+                                send(newSource.render())
+                            }
+                        }
+                }.collect { source ->
+                    importedSources.add(source)
+                }
             } catch (e: Exception) {
                 error = e.message
             } finally {

shared/src/commonTest/kotlin/dev/dimension/flare/ui/presenter/home/rss/ImportOPMLPresenterTest.kt

@@ -86,10 +86,6 @@ class ImportOPMLPresenterTest {
 
             val finalState = states.last()
 
-            println(
-                "Final state: importing=${finalState.importing}, error=${finalState.error}, total=${finalState.totalCount}, imported=${finalState.importedCount}",
-            )
-
             assertFalse(finalState.importing)
             assertNull(finalState.error)
             assertEquals(2, finalState.totalCount)
@@ -166,4 +162,50 @@ class ImportOPMLPresenterTest {
             val df = sources.find { it.url == "https://daringfireball.net/feeds/main" }
             assertEquals("Daring Fireball", df?.title)
         }
+
+    @Test
+    fun testConcurrencyStressTest() =
+        runTest {
+            val feedCount = 1000
+            val sb = StringBuilder()
+            sb.append("""<opml version="2.0"><head><title>Stress Test</title></head><body>""")
+
+            repeat(feedCount) { i ->
+                sb.append(
+                    """
+                    <outline type="rss" text="Feed $i" title="Title $i" xmlUrl="https://stress.test/feed/$i.xml" />
+                    """.trimIndent(),
+                )
+            }
+            sb.append("</body></opml>")
+
+            val presenter =
+                ImportOPMLPresenter(sb.toString()) { url ->
+                    kotlinx.coroutines.delay((1..10).random().toLong())
+                    "https://icon.url/icon.png"
+                }
+
+            val states = mutableListOf<ImportOPMLPresenter.State>()
+
+            val job =
+                launch {
+                    moleculeFlow(mode = RecompositionMode.Immediate) {
+                        presenter.body()
+                    }.collect {
+                        states.add(it)
+                    }
+                }
+
+            advanceUntilIdle()
+            job.cancel()
+
+            val finalState = states.last()
+            assertNull(finalState.error, "Should verify concurrency without errors")
+            assertFalse(finalState.importing, "Should finish importing")
+            assertEquals(feedCount, finalState.totalCount, "Total count should match input")
+            assertEquals(feedCount, finalState.importedCount, "Imported count should match input")
+            assertEquals(feedCount, finalState.importedSources.size, "UiState list size should match input")
+            val dbSources = db.rssSourceDao().getAll().first()
+            assertEquals(feedCount, dbSources.size, "Database records should match input")
+        }
 }