feat(gift): 선물함 목록 상태를 추가한다

This commit is contained in:
2026-10-01 21:17:49 +09:00
parent 4bb922b1f9
commit aa314822b4
2 changed files with 355 additions and 0 deletions
@@ -0,0 +1,133 @@
package kr.co.vividnext.sodalive.v2.gift
import android.content.Intent
import android.net.Uri
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
import io.reactivex.rxjava3.disposables.SerialDisposable
import io.reactivex.rxjava3.schedulers.Schedulers
import kr.co.vividnext.sodalive.R
import kr.co.vividnext.sodalive.base.BaseViewModel
import kr.co.vividnext.sodalive.common.SharedPreferenceManager
import kr.co.vividnext.sodalive.common.ToastMessage
import kr.co.vividnext.sodalive.v2.gift.data.GiftInboxItemResponse
import kr.co.vividnext.sodalive.v2.gift.data.GiftRepository
sealed interface GiftInboxUiState {
data object Loading : GiftInboxUiState
data object Empty : GiftInboxUiState
data class Error(val message: String?) : GiftInboxUiState
data class Content(
val items: List<GiftInboxItemResponse>,
val isAppending: Boolean = false,
val isRefreshing: Boolean = false,
val appendError: Boolean = false,
val refreshError: Boolean = false
) : GiftInboxUiState
}
class GiftInboxViewModel(private val repository: GiftRepository) : BaseViewModel() {
private val mutableState = MutableLiveData<GiftInboxUiState>()
val state: LiveData<GiftInboxUiState> = mutableState
private val mutableToast = MutableLiveData<ToastMessage?>()
val toastLiveData: LiveData<ToastMessage?> = mutableToast
private val mutableInquiry = MutableLiveData(false)
val inquiryLiveData: LiveData<Boolean> = mutableInquiry
private val request = SerialDisposable()
private var loading = false
private var currentPage = 0
private var hasNext = false
private var failedPage: Int? = null
init {
compositeDisposable.add(request)
}
fun loadFirstPage() {
if (mutableState.value != null) return
load(0)
}
fun loadNextPage() {
if (loading || !hasNext || failedPage != null) return
load(currentPage + 1)
}
fun refresh() {
val current = mutableState.value
if (current == GiftInboxUiState.Loading || (current as? GiftInboxUiState.Content)?.isRefreshing == true) return
request.set(null)
loading = false
load(0)
}
fun retry() {
if (loading) return
load(failedPage ?: 0)
}
fun onCardClick(card: GiftInboxCardUiModel) {
mutableToast.value = card.status
}
fun consumeToast(): ToastMessage? = mutableToast.value.also { mutableToast.value = null }
fun onInquiryClick() {
mutableInquiry.value = true
}
fun consumeInquiryIntent(): Intent? {
if (mutableInquiry.value != true) return null
mutableInquiry.value = false
return Intent(Intent.ACTION_VIEW, Uri.parse("http://pf.kakao.com/_lkxgxhG/chat"))
}
private fun load(page: Int) {
val previous = mutableState.value as? GiftInboxUiState.Content
loading = true
failedPage = null
mutableState.value = previous?.copy(
isAppending = page > 0,
isRefreshing = page == 0,
appendError = false,
refreshError = false
) ?: GiftInboxUiState.Loading
request.set(
repository.getGiftInbox(page, "Bearer ${SharedPreferenceManager.token}")
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(
{ response ->
val data = response.data
if (response.success && data != null) {
loading = false
currentPage = page
hasNext = data.hasNext
val items = if (page == 0) data.items else previous?.items.orEmpty() + data.items
mutableState.value = if (items.isEmpty()) GiftInboxUiState.Empty else GiftInboxUiState.Content(items)
} else {
fail(page, previous, response.message)
}
},
{ fail(page, previous, it.message) }
)
)
}
private fun fail(page: Int, previous: GiftInboxUiState.Content?, message: String?) {
loading = false
failedPage = page
mutableState.value = previous?.copy(
isAppending = false,
isRefreshing = false,
appendError = page > 0,
refreshError = page == 0
) ?: GiftInboxUiState.Error(message)
mutableToast.value = if (message.isNullOrBlank()) {
ToastMessage(resId = R.string.common_error_unknown)
} else {
ToastMessage(message = message)
}
}
}
@@ -0,0 +1,222 @@
package kr.co.vividnext.sodalive.v2.gift
import android.app.Application
import android.content.Intent
import androidx.test.core.app.ApplicationProvider
import io.reactivex.rxjava3.android.plugins.RxAndroidPlugins
import io.reactivex.rxjava3.core.Single
import io.reactivex.rxjava3.plugins.RxJavaPlugins
import io.reactivex.rxjava3.schedulers.Schedulers
import io.reactivex.rxjava3.subjects.SingleSubject
import kr.co.vividnext.sodalive.R
import kr.co.vividnext.sodalive.common.ApiResponse
import kr.co.vividnext.sodalive.common.SharedPreferenceManager
import kr.co.vividnext.sodalive.v2.gift.data.GiftApi
import kr.co.vividnext.sodalive.v2.gift.data.GiftCreateRequest
import kr.co.vividnext.sodalive.v2.gift.data.GiftFormOptionsResponse
import kr.co.vividnext.sodalive.v2.gift.data.GiftInboxResponse
import kr.co.vividnext.sodalive.v2.gift.data.GiftInboxItemResponse
import kr.co.vividnext.sodalive.v2.gift.data.GiftRepository
import org.junit.After
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertNull
import org.junit.Assert.assertTrue
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.annotation.Config
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [28], application = Application::class)
class GiftInboxViewModelTest {
private lateinit var api: InboxFakeApi
private lateinit var viewModel: GiftInboxViewModel
@Before
fun setUp() {
RxJavaPlugins.setIoSchedulerHandler { Schedulers.trampoline() }
RxAndroidPlugins.setInitMainThreadSchedulerHandler { Schedulers.trampoline() }
RxAndroidPlugins.setMainThreadSchedulerHandler { Schedulers.trampoline() }
SharedPreferenceManager.resetForTest()
SharedPreferenceManager.init(ApplicationProvider.getApplicationContext())
SharedPreferenceManager.token = "test-token"
api = InboxFakeApi()
viewModel = GiftInboxViewModel(GiftRepository(api))
}
@After
fun tearDown() {
viewModel.compositeDisposable.clear()
RxJavaPlugins.reset()
RxAndroidPlugins.reset()
SharedPreferenceManager.resetForTest()
}
@Test
fun `목록 repository는 ALL과 페이지 크기 인증을 전달한다`() {
val api = InboxFakeApi()
api.responses.add(Single.just(ApiResponse(true, GiftInboxResponse(0, emptyList(), 0, 20, false), null)))
GiftRepository(api).getGiftInbox(page = 0, token = "Bearer test-token").test().assertComplete()
assertEquals(listOf(InboxRequest("ALL", 0, 20, "Bearer test-token")), api.requests)
}
@Test
fun `첫 조회는 로딩 뒤 ALL 0 20 콘텐츠를 제공하고 재진입 시 중복하지 않는다`() {
val pending = SingleSubject.create<ApiResponse<GiftInboxResponse>>()
api.responses.add(pending)
viewModel.loadFirstPage()
viewModel.loadFirstPage()
assertTrue(viewModel.state.value is GiftInboxUiState.Loading)
pending.onSuccess(response(listOf(inboxItem()), hasNext = true))
viewModel.loadFirstPage()
assertEquals(listOf(InboxRequest("ALL", 0, 20, "Bearer test-token")), api.requests)
assertEquals(listOf("test-gift"), content().items.map { it.applicationNo })
}
@Test
fun `빈 응답은 Empty 상태이며 재조회 없이 유지된다`() {
enqueue(emptyList())
viewModel.loadFirstPage()
assertTrue(viewModel.state.value is GiftInboxUiState.Empty)
viewModel.loadFirstPage()
assertEquals(1, api.requests.size)
}
@Test
fun `다음 페이지를 서버 순서로 추가하고 로딩 중 중복과 마지막 페이지 요청을 막는다`() {
enqueue(listOf(inboxItem("z")), hasNext = true)
viewModel.loadFirstPage()
val pending = SingleSubject.create<ApiResponse<GiftInboxResponse>>()
api.responses.add(pending)
viewModel.loadNextPage()
viewModel.loadNextPage()
assertTrue(content().isAppending)
assertEquals(listOf(0, 1), api.requests.map { it.page })
pending.onSuccess(response(listOf(inboxItem("a")), page = 1))
assertEquals(listOf("z", "a"), content().items.map { it.applicationNo })
viewModel.loadNextPage()
assertEquals(2, api.requests.size)
}
@Test
fun `새로고침은 기존 콘텐츠를 유지하며 페이지 0으로 교체한다`() {
enqueue(listOf(inboxItem("old")), hasNext = true)
viewModel.loadFirstPage()
enqueue(listOf(inboxItem("append")), page = 1)
viewModel.loadNextPage()
val pending = SingleSubject.create<ApiResponse<GiftInboxResponse>>()
api.responses.add(pending)
viewModel.refresh()
assertTrue(content().isRefreshing)
assertEquals(2, content().items.size)
pending.onSuccess(response(listOf(inboxItem("fresh"))))
assertEquals(listOf(0, 1, 0), api.requests.map { it.page })
assertEquals(listOf("fresh"), content().items.map { it.applicationNo })
assertFalse(content().isRefreshing)
}
@Test
fun `첫 페이지 실패는 오류와 재시도를 제공한다`() {
api.responses.add(Single.just(ApiResponse(false, null, "조회 실패")))
viewModel.loadFirstPage()
assertTrue(viewModel.state.value is GiftInboxUiState.Error)
assertEquals("조회 실패", viewModel.consumeToast()?.message)
enqueue(listOf(inboxItem()))
viewModel.retry()
assertEquals(1, content().items.size)
assertEquals(listOf(0, 0), api.requests.map { it.page })
}
@Test
fun `추가 조회 실패는 콘텐츠를 보존하고 명시적인 재시도로 같은 페이지를 요청한다`() {
enqueue(listOf(inboxItem()), hasNext = true)
viewModel.loadFirstPage()
api.responses.add(Single.error(IllegalStateException("추가 실패")))
viewModel.loadNextPage()
assertEquals(1, content().items.size)
assertTrue(content().appendError)
assertEquals("추가 실패", viewModel.consumeToast()?.message)
assertNull(viewModel.consumeToast())
viewModel.loadNextPage()
assertEquals(2, api.requests.size)
enqueue(listOf(inboxItem("next")), page = 1)
viewModel.retry()
assertEquals(listOf(0, 1, 1), api.requests.map { it.page })
assertEquals(2, content().items.size)
}
@Test
fun `새로고침 실패도 기존 콘텐츠를 유지하고 재시도는 페이지 0을 요청한다`() {
enqueue(listOf(inboxItem()), hasNext = true)
viewModel.loadFirstPage()
api.responses.add(Single.error(IllegalStateException("새로고침 실패")))
viewModel.refresh()
assertEquals(1, content().items.size)
assertFalse(content().isRefreshing)
enqueue(listOf(inboxItem("fresh")))
viewModel.retry()
assertEquals(listOf(0, 0, 0), api.requests.map { it.page })
assertEquals("fresh", content().items.single().applicationNo)
}
@Test
fun `추가 조회 중 새로고침하면 이전 응답이 새 목록을 덮어쓰지 않는다`() {
enqueue(listOf(inboxItem()), hasNext = true)
viewModel.loadFirstPage()
val stale = SingleSubject.create<ApiResponse<GiftInboxResponse>>()
api.responses.add(stale)
viewModel.loadNextPage()
enqueue(listOf(inboxItem("fresh")))
viewModel.refresh()
stale.onSuccess(response(listOf(inboxItem("stale")), page = 1))
assertEquals(listOf("fresh"), content().items.map { it.applicationNo })
}
@Test
fun `카드와 배송지 배너는 같은 상태 토스트를 한 번 소비한다`() {
val card = GiftInboxPresenter.toCard(inboxItem(direction = "RECEIVED", status = "TRACKING_REGISTERED"))
repeat(2) {
viewModel.onCardClick(card)
assertEquals(R.string.gift_inbox_address_required, viewModel.consumeToast()?.resId)
assertNull(viewModel.consumeToast())
}
}
@Test
fun `문의 이벤트는 기존 카카오 ACTION_VIEW 주소로 한 번 소비된다`() {
viewModel.onInquiryClick()
val intent = viewModel.consumeInquiryIntent()
assertEquals(Intent.ACTION_VIEW, intent?.action)
assertEquals("http://pf.kakao.com/_lkxgxhG/chat", intent?.data.toString())
assertNull(viewModel.consumeInquiryIntent())
}
private fun content() = viewModel.state.value as GiftInboxUiState.Content
private fun response(items: List<GiftInboxItemResponse>, page: Int = 0, hasNext: Boolean = false) =
ApiResponse(true, GiftInboxResponse(items.size, items, page, 20, hasNext), null)
private fun enqueue(items: List<GiftInboxItemResponse>, page: Int = 0, hasNext: Boolean = false) {
api.responses.add(Single.just(response(items, page, hasNext)))
}
}
internal data class InboxRequest(val type: String, val page: Int, val size: Int, val auth: String)
internal class InboxFakeApi : GiftApi {
val requests = mutableListOf<InboxRequest>()
val responses = ArrayDeque<Single<ApiResponse<GiftInboxResponse>>>()
override fun getGiftInbox(type: String, page: Int, size: Int, authHeader: String): Single<ApiResponse<GiftInboxResponse>> {
requests.add(InboxRequest(type, page, size, authHeader))
return responses.removeFirst()
}
override fun getFormOptions(authHeader: String): Single<ApiResponse<GiftFormOptionsResponse>> =
Single.error(UnsupportedOperationException())
override fun createGift(request: GiftCreateRequest, authHeader: String): Single<ApiResponse<Any>> =
Single.error(UnsupportedOperationException())
}