HomeRepository의 반환값을 Flow에서 Result<data>로 변경

core/data/src/main/java/com/youthtalk/di/ApiModule.kt

@@ -8,12 +8,10 @@ import com.youthtalk.data.LoginService
 import com.youthtalk.data.PolicyService
 import com.youthtalk.data.ReportService
 import com.youthtalk.data.UserService
-import com.youthtalk.sse.SseClient
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
 import dagger.hilt.components.SingletonComponent
-import java.util.concurrent.TimeUnit
 import javax.inject.Qualifier
 import javax.inject.Singleton
 import kotlinx.coroutines.CoroutineScope
@@ -41,57 +39,19 @@ object ApiModule {
     @Retention(AnnotationRetention.RUNTIME)
     annotation class Main
 
-    @Qualifier
-    @Retention(AnnotationRetention.RUNTIME)
-    annotation class Sse
-
     @Provides
     @Singleton
     fun provideJson(): Json = Json {
         ignoreUnknownKeys = true
         coerceInputValues = true
     }
 
-    @Provides
-    @Singleton
-    @Sse
-    fun provideOkHttpClient(dataStoreDataSource: DataStoreDataSource): OkHttpClient {
-        val interceptor =
-            Interceptor { chain ->
-                val request = chain.request().newBuilder()
-                    .addHeader("Content-Type", "application/json")
-                    .build()
-
-                val response = chain.proceed(request)
-                val token = response.headers["Authorization"]
-                val refreshToken = response.headers["Authorization-refresh"]
-                if (token != null && refreshToken != null) {
-                    CoroutineScope(Dispatchers.IO).launch {
-                        dataStoreDataSource.saveAccessToken(token)
-                        dataStoreDataSource.saveRefreshToken(refreshToken)
-                    }
-                }
-                response
-            }
-
-        return OkHttpClient.Builder()
-            .addInterceptor(interceptor)
-            .readTimeout(0, TimeUnit.MILLISECONDS)
-            .build()
-    }
-
     @Provides
     @Singleton
     fun provideConverterFactory(json: Json): Factory {
         return json.asConverterFactory("application/json".toMediaType())
     }
 
-    @Provides
-    @Singleton
-    fun provideSseClient(@Sse okHttpClient: OkHttpClient): SseClient {
-        return SseClient(okHttpClient)
-    }
-
     @Singleton
     @Provides
     @Login

core/data/src/main/java/com/youthtalk/di/DataModule.kt

@@ -8,7 +8,6 @@ import com.core.dataapi.repository.PolicyRepository
 import com.core.dataapi.repository.ReportRepository
 import com.core.dataapi.repository.SearchRepository
 import com.core.dataapi.repository.SpecPolicyRepository
-import com.core.dataapi.repository.SseRepository
 import com.core.dataapi.repository.UserRepository
 import com.core.datastore.datasource.DataSource
 import com.core.datastore.datasource.DataStoreDataSource
@@ -20,7 +19,6 @@ import com.youthtalk.repository.PolicyRepositoryImpl
 import com.youthtalk.repository.ReportRepositoryImpl
 import com.youthtalk.repository.SearchRepositoryImpl
 import com.youthtalk.repository.SpecPolicyRepositoryImpl
-import com.youthtalk.repository.SseRepositoryImpl
 import com.youthtalk.repository.UserRepositoryImpl
 import dagger.Binds
 import dagger.Module
@@ -60,7 +58,4 @@ abstract class DataModule {
 
     @Binds
     abstract fun bindsReportRepository(repository: ReportRepositoryImpl): ReportRepository
-
-    @Binds
-    abstract fun bindsSseRepository(repository: SseRepositoryImpl): SseRepository
 }

core/data/src/main/java/com/youthtalk/repository/HomeRepositoryImpl.kt

@@ -7,42 +7,17 @@ import com.youthtalk.mapper.toDomain
 import com.youthtalk.model.home.HomeData
 import com.youthtalk.model.home.NewPolicies
 import com.youthtalk.model.typeenum.SortType
-import com.youthtalk.utils.ErrorUtils.throwableError
+import com.youthtalk.utils.ErrorUtils.createResult
 import javax.inject.Inject
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.flow
-import timber.log.Timber
 
 class HomeRepositoryImpl @Inject constructor(
     private val policyService: PolicyService
 ) : HomeRepository {
-    override fun getHome(): Flow<HomeData> = flow {
-        Timber.e("HomeRepositoryImpl getHome start")
-        runCatching { policyService.getHome() }
-            .onSuccess { homeData ->
-                Timber.e("HomeRepositoryImpl getHome Success $homeData")
-                homeData.data?.let { data ->
-                    emit(data.toDomain())
-                } ?: throw NoDataException()
-            }
-            .onFailure { error ->
-                Timber.e("HomeRepositoryImpl getHome  error : $error")
-                throwableError<HomeData>(error)
-            }
+    override suspend fun getHome(): Result<HomeData> = createResult {
+        policyService.getHome().data?.toDomain() ?: throw NoDataException()
     }
 
-    override fun getNewPolicies(sortType: SortType): Flow<NewPolicies> = flow {
-        Timber.e("HomeRepositoryImpl getHome start")
-        runCatching { policyService.getNewPolicies(sortType) }
-            .onSuccess { homeData ->
-                Timber.e("HomeRepositoryImpl getNewPolicies Success $homeData")
-                homeData.data?.let { data ->
-                    emit(data.toDomain())
-                } ?: throw NoDataException()
-            }
-            .onFailure { error ->
-                Timber.e("HomeRepositoryImpl getNewPolicies  error : $error")
-                throwableError<HomeData>(error)
-            }
+    override suspend fun getNewPolicies(sortType: SortType): Result<NewPolicies> = createResult {
+        policyService.getNewPolicies(sortType).data?.toDomain() ?: throw NoDataException()
     }
 }

core/data/src/test/java/com/youthtalk/repository/HomeRepositoryTest.kt

@@ -0,0 +1,64 @@
+package com.youthtalk.repository
+
+import com.core.dataapi.repository.HomeRepository
+import com.youthtalk.data.PolicyService
+import com.youthtalk.dto.CommonResponse
+import com.youthtalk.dto.home.HomeDataResponse
+import com.youthtalk.dto.home.NewPoliciesResponse
+import com.youthtalk.mapper.toDomain
+import com.youthtalk.model.typeenum.SortType
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.Mock
+import org.mockito.junit.MockitoJUnitRunner
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+
+@RunWith(MockitoJUnitRunner::class)
+class HomeRepositoryTest {
+
+    private lateinit var sut: HomeRepository
+
+    @Mock
+    private lateinit var policyService: PolicyService
+
+    @Before
+    fun setUp() {
+        sut = HomeRepositoryImpl(policyService)
+    }
+
+    @Test
+    fun given_whenGetHomeData_whenReturnsHomeData() {
+        runTest {
+            // given
+            val homeDataResponse = HomeDataResponse(listOf(), listOf(), listOf())
+            whenever(policyService.getHome()).thenReturn(CommonResponse(200, "요청에 성공하였습니다", "S01", homeDataResponse))
+
+            // when
+            val result = sut.getHome().getOrThrow()
+
+            // then
+            assertEquals(homeDataResponse.toDomain(), result)
+            verify(policyService).getHome()
+        }
+    }
+
+    @Test
+    fun givenSortType_whenGetNewPolicies_whenReturnsPolicies() {
+        runTest {
+            // given
+            val newPoliciesResponse = NewPoliciesResponse(listOf(), listOf(), listOf(), listOf(), listOf(), listOf())
+            whenever(policyService.getNewPolicies()).thenReturn(CommonResponse(200, "요창에 성공하였습니다.", "S01", newPoliciesResponse))
+
+            // when
+            val result = sut.getNewPolicies(SortType.RECENT).getOrThrow()
+
+            // then
+            assertEquals(newPoliciesResponse.toDomain(), result)
+            verify(policyService).getNewPolicies()
+        }
+    }
+}

core/dataApi/src/main/java/com/core/dataapi/repository/HomeRepository.kt

@@ -3,9 +3,8 @@ package com.core.dataapi.repository
 import com.youthtalk.model.home.HomeData
 import com.youthtalk.model.home.NewPolicies
 import com.youthtalk.model.typeenum.SortType
-import kotlinx.coroutines.flow.Flow
 
 interface HomeRepository {
-    fun getHome(): Flow<HomeData>
-    fun getNewPolicies(sortType: SortType): Flow<NewPolicies>
+    suspend fun getHome(): Result<HomeData>
+    suspend fun getNewPolicies(sortType: SortType): Result<NewPolicies>
 }

core/domain/src/main/java/com/core/domain/usercase/home/GetHomeDataUseCase.kt

@@ -6,5 +6,5 @@ import javax.inject.Inject
 class GetHomeDataUseCase @Inject constructor(
     private val homeRepository: HomeRepository
 ) {
-    operator fun invoke() = homeRepository.getHome()
+    suspend operator fun invoke() = homeRepository.getHome()
 }

core/domain/src/main/java/com/core/domain/usercase/home/GetNewPolicesUseCase.kt

@@ -7,5 +7,5 @@ import javax.inject.Inject
 class GetNewPolicesUseCase @Inject constructor(
     private val homeRepository: HomeRepository
 ) {
-    operator fun invoke(sortType: SortType = SortType.RECENT) = homeRepository.getNewPolicies(sortType)
+    suspend operator fun invoke(sortType: SortType = SortType.RECENT) = homeRepository.getNewPolicies(sortType)
 }