[PC-1315] Gson + preferences datastore => proto datastore로 개선 (#172)

* [PC-1315] proto datastore 버전 카탈로그에 추가

* [PC-1315] proto datastore를 사용하기 위한 의존성 가

* [PC-1315] .profile_preferences, term_preferences .proto 파일 생성

* [PC-1315] term, profile를 proto datastore를 사용하기 위한 파일 생성

- LocalProfileDataSourceProtoImpl
- LocalTermDataSourceProtoImpl
- ProfileMapper
- TermMapper
- ProfileDataSerializer
- TermDataSerializer

* [PC-1315] 테스트를 위해 LocalTermDataSource, LocalProfileDataSource provides로 변경

* [PC-1315] .proto package 변경 및 mapper 가시성 변경

* [PC-1315] benchmarkMacroJunit4 -> benchmark

* [PC-1315] benchmark-micro 모듈 생성

* [PC-1315] ProfileDataStoreCompareBenchmark 구현

- 1000번 테스트

* [PC-1315] TermDataStoreCompareBenchmark 구현

- 1000번 테스트

* Revert "[PC-1315] TermDataStoreCompareBenchmark 구현"

This reverts commit ebc447c.

* Revert "[PC-1315] ProfileDataStoreCompareBenchmark 구현"

This reverts commit b2efc9f.

* Revert "[PC-1315] benchmark-micro 모듈 생성"

This reverts commit 169143e.

* [PC-1315] gson + preferences datastore -> proto datastore

* [PC-1315] 미사용 코드 및 의존성 제거

* [PC-1315] 로컬 데이터가 비어있을 때 API fallback 및 로컬 저장 테스트 추가 (Profile)

* [PC-1315] 로컬 데이터가 비어있을 때 API fallback 및 로컬 저장 테스트 추가 (Term)

* [PC-1315] Fallback 테스트 주석 가독성 있게 변경

Author: comst19

core/data/src/main/java/com/puzzle/data/repository/ProfileRepositoryImpl.kt

@@ -26,6 +26,7 @@ import kotlinx.coroutines.flow.firstOrNull
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.launch
 import javax.inject.Inject
+import javax.inject.Named
 
 class ProfileRepositoryImpl @Inject constructor(
     private val imageResizer: ImageResizeProcessor,

core/data/src/main/java/com/puzzle/data/repository/TermsRepositoryImpl.kt

@@ -7,6 +7,7 @@ import com.puzzle.network.model.UNKNOWN_INT
 import com.puzzle.network.source.term.TermDataSource
 import kotlinx.coroutines.flow.firstOrNull
 import javax.inject.Inject
+import javax.inject.Named
 
 class TermsRepositoryImpl @Inject constructor(
     private val termDataSource: TermDataSource,

core/data/src/test/java/com/puzzle/data/repository/ProfileRepositoryImplTest.kt

@@ -4,6 +4,10 @@ import com.puzzle.data.FakeSseClient
 import com.puzzle.data.image.SpyImageResizeProcessor
 import com.puzzle.data.source.profile.FakeLocalProfileDataSource
 import com.puzzle.data.source.profile.FakeProfileDataSource
+import com.puzzle.data.source.profile.FakeProfileDataSource.Companion.DUMMY_MY_VALUE_PICK_RESPONSE
+import com.puzzle.data.source.profile.FakeProfileDataSource.Companion.DUMMY_MY_VALUE_TALK_RESPONSE
+import com.puzzle.data.source.profile.FakeProfileDataSource.Companion.DUMMY_VALUE_PICK_RESPONSE
+import com.puzzle.data.source.profile.FakeProfileDataSource.Companion.DUMMY_VALUE_TALK_RESPONSE
 import com.puzzle.data.source.token.FakeLocalTokenDataSource
 import com.puzzle.data.source.user.FakeLocalUserDataSource
 import com.puzzle.domain.model.profile.Contact
@@ -284,4 +288,81 @@ class ProfileRepositoryImplTest {
         assertEquals(originValueTalks.map { it.id }, storedValueTalks.map { it.id })
         assertEquals(storedValueTalks.first { it.id == 1 }.summary, "변경된 요약")
     }
+
+    @Test
+    fun `로컬이 비어있을 때 MyValueTalk API fallback이 발생한다`() = runTest {
+        // given
+        // localProfileDataSource 현재 비어있음 (FakeLocalProfileDataSource 초기 상태, API Fallback 유도 조건)
+        profileDataSource.setMyValueTalks(listOf(DUMMY_MY_VALUE_TALK_RESPONSE))
+
+        // when
+        val result = profileRepository.getMyValueTalks()
+
+        // then
+        assertEquals(1, profileDataSource.getMyValueTalksCallCount)
+
+        assertEquals(1, result.size)
+
+        val saved = localProfileDataSource.myValueTalks.first()
+        assertEquals(1, saved?.size)
+        assertEquals(result.first(), saved?.first())
+    }
+
+    @Test
+    fun `로컬이 비어있을 때 MyValuePick API fallback이 발생한다`() = runTest {
+        // given
+        // localProfileDataSource 현재 비어있음 (FakeLocalProfileDataSource 초기 상태, API Fallback 유도 조건)
+        profileDataSource.setMyValuePicks(listOf(DUMMY_MY_VALUE_PICK_RESPONSE))
+
+        // when
+        val result = profileRepository.getMyValuePicks()
+
+        // then
+        assertEquals(1, profileDataSource.getMyValuePicksCallCount)
+
+        assertEquals(1, result.size)
+
+        val saved = localProfileDataSource.myValuePicks.first()
+        assertEquals(1, saved?.size)
+        assertEquals(result.first(), saved?.first())
+    }
+
+    @Test
+    fun `로컬이 비어있을 때 ValuePickQuestions API fallback이 발생한다`() = runTest {
+        // given
+        // localProfileDataSource 현재 비어있음 (FakeLocalProfileDataSource 초기 상태, API Fallback 유도 조건)
+        profileDataSource.setValuePicks(listOf(DUMMY_VALUE_PICK_RESPONSE))
+
+        // when
+        val result = profileRepository.getValuePickQuestions()
+
+        // then
+        assertEquals(1, profileDataSource.loadValuePickQuestionsCallCount)
+
+        assertEquals(1, result.size)
+
+        val saved = localProfileDataSource.valuePickQuestions.first()
+        assertEquals(1, saved?.size)
+        assertEquals(result.first(), saved?.first())
+    }
+
+    @Test
+    fun `로컬이 비어있을 때 ValueTalkQuestions API fallback이 발생한다`() = runTest {
+        // given
+        // localProfileDataSource 현재 비어있음 (FakeLocalProfileDataSource 초기 상태, API Fallback 유도 조건)
+        profileDataSource.setValueTalks(listOf(DUMMY_VALUE_TALK_RESPONSE))
+
+        // when
+        val result = profileRepository.getValueTalkQuestions()
+
+        // then
+        assertEquals(1, profileDataSource.loadValueTalkQuestionsCallCount)
+
+        assertEquals(1, result.size)
+
+        val saved = localProfileDataSource.valueTalkQuestions.first()
+        assertEquals(1, saved?.size)
+        assertEquals(result.first(), saved?.first())
+    }
+
 }

core/data/src/test/java/com/puzzle/data/repository/TermsRepositoryImplTest.kt

@@ -2,13 +2,16 @@ package com.puzzle.data.repository
 
 import com.puzzle.data.source.term.FakeLocalTermDataSource
 import com.puzzle.data.source.term.FakeTermDataSource
+import com.puzzle.data.source.term.FakeTermDataSource.Companion.DUMMY_TERM_RESPONSE
 import com.puzzle.network.model.UNKNOWN_INT
 import com.puzzle.network.model.terms.TermResponse
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.test.runTest
+import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
+import kotlin.collections.first
 
 class TermsRepositoryImplTest {
     private lateinit var termDataSource: FakeTermDataSource
@@ -87,4 +90,23 @@ class TermsRepositoryImplTest {
             }
         )
     }
+
+    @Test
+    fun `로컬이 비어있을 때 Terms API fallback이 발생한다`() = runTest {
+        // given
+        // localTermDataSource 현재 비어있음 (FakeLocalTermDataSource 초기 상태, API Fallback 유도 조건)
+        termDataSource.setTerms(listOf(DUMMY_TERM_RESPONSE))
+
+        // when
+        val result = termsRepository.getTerms()
+
+        // then
+        assertEquals(1, termDataSource.loadTermsCallCount)
+
+        assertEquals(1, result.size)
+
+        val saved = localTermDataSource.terms.first()
+        assertEquals(1, saved?.size)
+        assertEquals(result.first(), saved?.first())
+    }
 }

core/data/src/test/java/com/puzzle/data/source/profile/FakeProfileDataSource.kt

@@ -21,22 +21,52 @@ import com.puzzle.network.source.profile.ProfileDataSource
 import java.io.InputStream
 
 class FakeProfileDataSource : ProfileDataSource {
+
+    private var myValuePicks = listOf<MyValuePickResponse>()
+    private var myValueTalks = listOf<MyValueTalkResponse>()
     private var valuePicks = listOf<ValuePickResponse>()
     private var valueTalks = listOf<ValueTalkResponse>()
 
-    fun setValuePicks(picks: List<ValuePickResponse>) {
+    internal var getMyValuePicksCallCount = 0
+    internal var getMyValueTalksCallCount = 0
+
+    internal var loadValuePickQuestionsCallCount = 0
+    internal var loadValueTalkQuestionsCallCount = 0
+
+    internal fun setMyValuePicks(picks: List<MyValuePickResponse>) {
+        myValuePicks = picks
+    }
+
+    internal fun setMyValueTalks(talks: List<MyValueTalkResponse>) {
+        myValueTalks = talks
+    }
+    internal fun setValuePicks(picks: List<ValuePickResponse>) {
         valuePicks = picks
     }
 
-    fun setValueTalks(talks: List<ValueTalkResponse>) {
+    internal fun setValueTalks(talks: List<ValueTalkResponse>) {
         valueTalks = talks
     }
 
-    override suspend fun loadValuePickQuestions(): LoadValuePickQuestionsResponse =
-        LoadValuePickQuestionsResponse(responses = valuePicks)
+    override suspend fun getMyValuePicks(): GetMyValuePicksResponse {
+        getMyValuePicksCallCount++
+        return GetMyValuePicksResponse(responses = myValuePicks)
+    }
+
+    override suspend fun getMyValueTalks(): GetMyValueTalksResponse {
+        getMyValueTalksCallCount++
+        return GetMyValueTalksResponse(responses = myValueTalks)
+    }
+
+    override suspend fun loadValuePickQuestions(): LoadValuePickQuestionsResponse {
+        loadValuePickQuestionsCallCount++
+        return LoadValuePickQuestionsResponse(responses = valuePicks)
+    }
 
-    override suspend fun loadValueTalkQuestions(): LoadValueTalkQuestionsResponse =
-        LoadValueTalkQuestionsResponse(responses = valueTalks)
+    override suspend fun loadValueTalkQuestions(): LoadValueTalkQuestionsResponse {
+        loadValueTalkQuestionsCallCount++
+        return LoadValueTalkQuestionsResponse(responses = valueTalks)
+    }
 
     override suspend fun updateMyValueTalks(valueTalks: List<MyValueTalk>): GetMyValueTalksResponse {
         val responses = valueTalks.map { valueTalk ->
@@ -132,10 +162,10 @@ class FakeProfileDataSource : ProfileDataSource {
         valuePicks: List<ValuePickAnswer>,
         valueTalks: List<ValueTalkAnswer>
     ): UploadProfileResponse = UploadProfileResponse(
-            role = "PENDING",
-            accessToken = "accessToken",
-            refreshToken = "refreshToken",
-        )
+        role = "PENDING",
+        accessToken = "accessToken",
+        refreshToken = "refreshToken",
+    )
 
     override suspend fun updateProfile(
         birthdate: String,
@@ -155,6 +185,41 @@ class FakeProfileDataSource : ProfileDataSource {
 
     override suspend fun disconnectSSE() {}
     override suspend fun getMyProfileBasic(): GetMyProfileBasicResponse = throw NotImplementedError()
-    override suspend fun getMyValueTalks(): GetMyValueTalksResponse = throw NotImplementedError()
-    override suspend fun getMyValuePicks(): GetMyValuePicksResponse = throw NotImplementedError()
+
+    companion object {
+        val DUMMY_MY_VALUE_TALK_RESPONSE = MyValueTalkResponse(
+            id = 1,
+            questionId = 1,
+            title = "ㅂㅈㄷㄱ",
+            category = "ㅂㅈㄷㄱ",
+            answer = "ㅂㅈㄷㄱ",
+            summary = "ㅂㅈㄷㄱ",
+            guides = emptyList(),
+            placeholder = "ㅂㅈㄷㄱ"
+
+        )
+
+        val DUMMY_MY_VALUE_PICK_RESPONSE = MyValuePickResponse(
+            id = 1,
+            questionId = 1,
+            category = "ㅁㄴㅇㄹ",
+            question = "ㅁㄴㅇㄹ",
+            answerOptions = emptyList(),
+            selectedAnswer = 1
+        )
+        val DUMMY_VALUE_TALK_RESPONSE = ValueTalkResponse(
+            id = 1,
+            category = "ㅁㄴㅇㄹ",
+            title = "ㅁㄴㅇㄹ",
+            placeholder = "ㅁㄴㅇㄹ",
+            guides = emptyList()
+        )
+
+        val DUMMY_VALUE_PICK_RESPONSE = ValuePickResponse(
+            id = 1,
+            category = "ㅋㅌㅊㅍ",
+            question = "ㅋㅌㅊㅍ",
+            answers = emptyList()
+        )
+    }
 }

core/data/src/test/java/com/puzzle/data/source/term/FakeTermDataSource.kt

@@ -7,13 +7,26 @@ import com.puzzle.network.source.term.TermDataSource
 class FakeTermDataSource : TermDataSource {
     private var terms = listOf<TermResponse>()
 
-    fun setTerms(newTerms: List<TermResponse>) {
+    internal var loadTermsCallCount = 0
+
+    internal fun setTerms(newTerms: List<TermResponse>) {
         terms = newTerms
     }
 
     override suspend fun loadTerms(): LoadTermsResponse {
+        loadTermsCallCount++
         return LoadTermsResponse(responses = terms)
     }
 
     override suspend fun agreeTerms(agreeTermsId: List<Int>) {}
-}
+
+    companion object {
+        val DUMMY_TERM_RESPONSE = TermResponse(
+            termId = 1,
+            title = "ㅁㄴㅇㄹ",
+            content = "ㅁㄴㅇㄹ",
+            required = false,
+            startDate = ""
+        )
+    }
+}

core/datastore/build.gradle.kts

@@ -1,6 +1,7 @@
 plugins {
     id("piece.android.library")
     id("piece.android.hilt")
+    alias(libs.plugins.protobuf)
 }
 
 android {
@@ -12,9 +13,28 @@ android {
     }
 }
 
+protobuf {
+    protoc {
+        artifact = libs.protobuf.protoc.get().toString()
+    }
+    generateProtoTasks {
+        all().forEach { task ->
+            task.builtins {
+                task.builtins {
+                    create("java") {
+                        option("lite")
+                    }
+                    create("kotlin")
+                }
+            }
+        }
+    }
+}
+
 dependencies {
     implementation(projects.core.domain)
 
-    implementation(libs.androidx.datastore)
-    implementation(libs.gson)
+    implementation(libs.androidx.datastore.preferences)
+    implementation(libs.androidx.datastore.core)
+    implementation(libs.protobuf.kotlin.lite)
 }