Refactor: 펜딩 변경사항 동기화 및 동시성 제어 개선

Author: wjdrjs00

data/src/main/java/com/threegap/bitnagil/data/routine/repositoryImpl/RoutineRepositoryImpl.kt

@@ -25,6 +25,8 @@ import kotlinx.coroutines.flow.filterNotNull
 import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 import javax.inject.Inject
 import javax.inject.Singleton
 
@@ -36,9 +38,10 @@ class RoutineRepositoryImpl @Inject constructor(
 ) : RoutineRepository {
 
     private val repositoryScope = CoroutineScope(SupervisorJob() + dispatcher)
+    private val mutex = Mutex()
     private val pendingChangesByDate = mutableMapOf<String, MutableMap<String, RoutineCompletionInfo>>()
     private val originalStatesByDate = mutableMapOf<String, MutableMap<String, RoutineCompletionInfo>>()
-    private val syncTrigger = MutableSharedFlow<String>(
+    private val syncTrigger = MutableSharedFlow<Unit>(
         extraBufferCapacity = 1,
         onBufferOverflow = BufferOverflow.DROP_OLDEST,
     )
@@ -48,7 +51,7 @@ class RoutineRepositoryImpl @Inject constructor(
         repositoryScope.launch {
             syncTrigger
                 .debounce(500L)
-                .collect { dateKey -> flushPendingChanges(dateKey) }
+                .collect { flushAllPendingChanges() }
         }
     }
 
@@ -71,28 +74,41 @@ class RoutineRepositoryImpl @Inject constructor(
     }
 
     override suspend fun applyRoutineToggle(dateKey: String, routineId: String, completionInfo: RoutineCompletionInfo) {
-        if (originalStatesByDate[dateKey]?.containsKey(routineId) != true) {
-            routineLocalDataSource.getCompletionInfo(dateKey, routineId)?.let {
-                originalStatesByDate.getOrPut(dateKey) { mutableMapOf() }[routineId] = it
+        mutex.withLock {
+            if (originalStatesByDate[dateKey]?.containsKey(routineId) != true) {
+                routineLocalDataSource.getCompletionInfo(dateKey, routineId)?.let {
+                    originalStatesByDate.getOrPut(dateKey) { mutableMapOf() }[routineId] = it
+                }
             }
+            pendingChangesByDate.getOrPut(dateKey) { mutableMapOf() }[routineId] = completionInfo
         }
         routineLocalDataSource.applyOptimisticToggle(dateKey, routineId, completionInfo)
-        pendingChangesByDate.getOrPut(dateKey) { mutableMapOf() }[routineId] = completionInfo
-        syncTrigger.emit(dateKey)
+        syncTrigger.emit(Unit)
     }
 
-    private suspend fun flushPendingChanges(dateKey: String) {
-        val snapshot = pendingChangesByDate.remove(dateKey)
-        val originals = originalStatesByDate.remove(dateKey)
-        val actualChanges = snapshot?.filter { (routineId, pending) -> originals?.get(routineId) != pending }
-        if (actualChanges.isNullOrEmpty()) return
-
-        val syncRequest = RoutineCompletionInfos(routineCompletionInfos = actualChanges.values.toList())
-        routineRemoteDataSource.syncRoutineCompletion(syncRequest.toDto())
-            .onFailure {
-                val range = routineLocalDataSource.lastFetchRange ?: return
-                fetchAndSave(range.first, range.second)
+    private suspend fun flushAllPendingChanges() {
+        val snapshot: Map<String, Map<String, RoutineCompletionInfo>>
+        val originals: Map<String, Map<String, RoutineCompletionInfo>>
+        mutex.withLock {
+            snapshot = pendingChangesByDate.mapValues { it.value.toMap() }
+            originals = originalStatesByDate.mapValues { it.value.toMap() }
+            pendingChangesByDate.clear()
+            originalStatesByDate.clear()
+        }
+
+        for ((dateKey, pendingForDate) in snapshot) {
+            val actualChanges = pendingForDate.filter { (routineId, pending) ->
+                originals[dateKey]?.get(routineId) != pending
             }
+            if (actualChanges.isEmpty()) continue
+
+            val syncRequest = RoutineCompletionInfos(routineCompletionInfos = actualChanges.values.toList())
+            routineRemoteDataSource.syncRoutineCompletion(syncRequest.toDto())
+                .onFailure {
+                    val range = routineLocalDataSource.lastFetchRange ?: return@onFailure
+                    fetchAndSave(range.first, range.second)
+                }
+        }
     }
 
     private suspend fun refreshCache() {

data/src/test/java/com/threegap/bitnagil/data/routine/repositoryImpl/RoutineRepositoryImplTest.kt

@@ -114,6 +114,20 @@ class RoutineRepositoryImplTest {
         assertEquals(1, remoteDataSource.syncCount.get())
     }
 
+    @Test
+    fun `서로 다른 날짜에 토글 시 debounce 후 두 날짜 모두 sync되어야 한다`() = runTest {
+        repository = createRepository(testScheduler)
+        runCurrent()
+        val (dateKey1, routineId1) = setupCacheWithRoutineOnDate("2024-01-01", "routine1", isCompleted = false)
+        val (dateKey2, routineId2) = setupCacheWithRoutineOnDate("2024-01-02", "routine2", isCompleted = false)
+
+        repository.applyRoutineToggle(dateKey1, routineId1, RoutineCompletionInfo(routineId1, routineCompleteYn = true, subRoutineCompleteYn = emptyList()))
+        repository.applyRoutineToggle(dateKey2, routineId2, RoutineCompletionInfo(routineId2, routineCompleteYn = true, subRoutineCompleteYn = emptyList()))
+
+        advanceTimeBy(501L)
+        assertEquals(2, remoteDataSource.syncCount.get())
+    }
+
     @Test
     fun `A→B→A 토글 시 최종 상태가 원래와 동일하면 API를 호출하지 않아야 한다`() = runTest {
         repository = createRepository(testScheduler)
@@ -175,33 +189,33 @@ class RoutineRepositoryImplTest {
 
     // --- Helpers ---
 
-    private fun setupCacheWithRoutine(isCompleted: Boolean): Pair<String, String> {
-        val dateKey = "2024-01-01"
-        val routineId = "routine1"
-        val schedule = RoutineSchedule(
-            dailyRoutines = mapOf(
-                dateKey to DailyRoutines(
-                    routines = listOf(
-                        Routine(
-                            id = routineId,
-                            name = "테스트 루틴",
-                            repeatDays = listOf(DayOfWeek.MONDAY),
-                            executionTime = "08:00",
-                            startDate = dateKey,
-                            endDate = dateKey,
-                            routineDate = dateKey,
-                            isCompleted = isCompleted,
-                            isDeleted = false,
-                            subRoutineNames = emptyList(),
-                            subRoutineCompletionStates = emptyList(),
-                            recommendedRoutineType = null,
-                        ),
+    private fun setupCacheWithRoutine(isCompleted: Boolean): Pair<String, String> =
+        setupCacheWithRoutineOnDate("2024-01-01", "routine1", isCompleted)
+
+    private fun setupCacheWithRoutineOnDate(dateKey: String, routineId: String, isCompleted: Boolean): Pair<String, String> {
+        val existing = localDataSource.routineSchedule.value?.dailyRoutines ?: emptyMap()
+        val newDailyRoutines = existing + mapOf(
+            dateKey to DailyRoutines(
+                routines = listOf(
+                    Routine(
+                        id = routineId,
+                        name = "테스트 루틴",
+                        repeatDays = listOf(DayOfWeek.MONDAY),
+                        executionTime = "08:00",
+                        startDate = dateKey,
+                        endDate = dateKey,
+                        routineDate = dateKey,
+                        isCompleted = isCompleted,
+                        isDeleted = false,
+                        subRoutineNames = emptyList(),
+                        subRoutineCompletionStates = emptyList(),
+                        recommendedRoutineType = null,
                     ),
-                    isAllCompleted = isCompleted,
                 ),
+                isAllCompleted = isCompleted,
             ),
         )
-        localDataSource.saveSchedule(schedule, dateKey, dateKey)
+        localDataSource.saveSchedule(RoutineSchedule(newDailyRoutines), dateKey, dateKey)
         return dateKey to routineId
     }