feat(gift): 선물 상세와 운송장 화면을 연결한다

This commit is contained in:
2026-10-02 18:32:15 +09:00
parent 851adc5541
commit 63b598b521
4 changed files with 869 additions and 0 deletions
+7
View File
@@ -118,6 +118,13 @@
<activity
android:name=".v2.gift.GiftInboxActivity"
android:exported="false" />
<activity
android:name=".v2.gift.GiftDetailActivity"
android:exported="false" />
<activity
android:name=".v2.gift.GiftTrackingActivity"
android:exported="false"
android:windowSoftInputMode="stateAlwaysHidden|adjustResize" />
<activity
android:name=".v2.gift.GiftSendRequestActivity"
android:exported="false"
@@ -0,0 +1,268 @@
package kr.co.vividnext.sodalive.v2.gift
import android.app.Activity
import android.content.Context
import android.content.Intent
import android.os.Bundle
import android.widget.LinearLayout
import android.widget.TextView
import androidx.activity.result.contract.ActivityResultContracts
import androidx.core.view.isVisible
import androidx.recyclerview.widget.GridLayoutManager
import kr.co.vividnext.sodalive.R
import kr.co.vividnext.sodalive.base.BaseActivity
import kr.co.vividnext.sodalive.databinding.ActivityGiftDetailBinding
import kr.co.vividnext.sodalive.v2.components.modal.V2ModalDialog
import kr.co.vividnext.sodalive.v2.gift.GiftDetailText.Key
import kr.co.vividnext.sodalive.v2.gift.ui.GiftInfoRows
import kr.co.vividnext.sodalive.v2.gift.ui.GiftStatusTimelineAdapter
import org.koin.androidx.viewmodel.ext.android.viewModel
class GiftDetailActivity : BaseActivity<ActivityGiftDetailBinding>(ActivityGiftDetailBinding::inflate) {
private val viewModel: GiftDetailViewModel by viewModel()
private val cancelViewModel: GiftCancelViewModel by viewModel()
private var cancelDialog: V2ModalDialog? = null
private var hasChanged = false
private val timelineAdapter = GiftStatusTimelineAdapter()
private val trackingLauncher = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
if (result.resultCode == Activity.RESULT_OK) {
markChanged()
val canceled = GiftCancelResult.fromIntent(result.data, intent.getStringExtra(EXTRA_APPLICATION_NO).orEmpty())
if (canceled != null) viewModel.applyCancellation(canceled) else reload()
}
}
override fun onCreate(savedInstanceState: Bundle?) {
hasChanged = savedInstanceState?.getBoolean(STATE_CHANGED) == true
super.onCreate(savedInstanceState)
if (hasChanged) setResult(Activity.RESULT_OK)
}
override fun onSaveInstanceState(outState: Bundle) {
outState.putBoolean(STATE_CHANGED, hasChanged)
super.onSaveInstanceState(outState)
}
override fun setupView() {
binding.btnBack.setOnClickListener { finish() }
binding.close.setOnClickListener { finish() }
binding.retry.setOnClickListener { viewModel.retry() }
binding.inquiry.setOnClickListener { viewModel.onInquiryClick() }
binding.undeliverableInquiry.setOnClickListener { viewModel.onInquiryClick() }
binding.timeline.layoutManager = GridLayoutManager(this, 4)
binding.timeline.adapter = timelineAdapter
binding.tracking.setOnClickListener {
trackingLauncher.launch(GiftTrackingActivity.newIntent(this, intent.getStringExtra(EXTRA_APPLICATION_NO).orEmpty()))
}
binding.cancel.setText(R.string.gift_cancel_title)
binding.cancel.setOnClickListener { showCancelDialog() }
observeCancellation()
observe()
viewModel.loadInitial(intent.getStringExtra(EXTRA_APPLICATION_NO).orEmpty())
}
private fun reload() = viewModel.retry()
private fun showCancelDialog() {
val detail = (viewModel.state.value as? GiftDetailUiState.Content)?.detail ?: return
if (detail.direction != "SENT" || detail.status != "RECEIVED" || cancelDialog != null) return
cancelDialog = giftCancelDialog(detail.giftInfo.recipientCreatorNickname, onConfirm = {
(viewModel.state.value as? GiftDetailUiState.Content)?.detail?.let(cancelViewModel::cancelGift)
}, onExit = { cancelDialog = null }).also { it.show(screenWidth) }
}
private fun observeCancellation() {
cancelViewModel.isSubmitting.observe(this) { submitting ->
cancelDialog?.dialogView?.tvConfirm?.isEnabled = !submitting
cancelDialog?.dialogView?.tvCancel?.isEnabled = !submitting
binding.cancel.isEnabled = !submitting
}
cancelViewModel.toastLiveData.observe(this) { toast ->
if (toast != null) {
cancelViewModel.consumeToast()?.let {
showToast(it.resId?.let(::getString) ?: it.message.orEmpty())
}
}
}
cancelViewModel.cancelSuccessLiveData.observe(this) { response ->
if (response != null) {
cancelViewModel.consumeCancelSuccessEvent()?.let {
cancelDialog?.dismiss()
cancelDialog = null
viewModel.applyCancellation(it)
markChanged()
showToast(getString(R.string.gift_cancel_success))
}
}
}
}
override fun onDestroy() {
cancelDialog?.dismiss()
super.onDestroy()
}
private fun observe() {
viewModel.state.observe(this, ::render)
viewModel.finishErrorLiveData.observe(this) { event ->
if (event != null) {
viewModel.consumeFinishError()?.let { error ->
showToast(error.resId?.let(::getString) ?: error.message.orEmpty())
finish()
}
}
}
viewModel.inquiryLiveData.observe(this) { requested ->
if (requested) viewModel.consumeInquiryIntent()?.let(::startActivity)
}
}
private fun render(state: GiftDetailUiState) {
binding.progress.isVisible = state == GiftDetailUiState.Loading
binding.error.isVisible = state is GiftDetailUiState.Error
binding.content.isVisible = state is GiftDetailUiState.Content || state is GiftDetailUiState.Canceled
binding.tracking.isVisible = GiftDetailPresenter.showsTrackingAction(state)
when (state) {
GiftDetailUiState.Loading -> Unit
is GiftDetailUiState.Error -> {
binding.errorMessage.text = state.message?.takeIf { it.isNotBlank() }
?: getString(R.string.common_error_unknown)
}
is GiftDetailUiState.Content -> bind(GiftDetailPresenter.present(state.detail))
is GiftDetailUiState.Canceled -> {
if (state.cancel != null) markChanged()
bind(GiftDetailPresenter.present(state.detail, state.cancel))
}
}
}
private fun markChanged() {
hasChanged = true
setResult(Activity.RESULT_OK)
}
private fun bind(model: GiftDetailUiModel) {
val canceled = model.cancellation != null
val received = model.status == "RECEIVED"
val undeliverable = model.undeliverable != null
binding.header.setText(if (canceled) R.string.gift_detail_canceled_header else R.string.gift_detail_title)
if (received) binding.header.text = ""
binding.btnBack.isVisible = !received
binding.close.isVisible = received
binding.heroChip.bindText(model.hero.chip)
binding.heroChip.setTextColor(
getColor(
when {
canceled -> R.color.gray_400
undeliverable -> R.color.red_400
else -> R.color.soda_400
}
)
)
binding.heroTitle.bindText(model.hero.title)
binding.heroBody.bindText(model.hero.body)
binding.heroIllustration.isVisible = model.showProgress
binding.timeline.isVisible = model.showProgress
timelineAdapter.submitList(model.progressSegments)
binding.cancel.isVisible = GiftDetailAction.CANCEL in model.actions
binding.inquiry.isVisible = !undeliverable && GiftDetailAction.INQUIRY in model.actions
binding.undeliverableInquiry.isVisible = undeliverable && GiftDetailAction.INQUIRY in model.actions
binding.normalSections.isVisible = !canceled
binding.canceledCompletion.root.isVisible = canceled
GiftInfoRows.bind(binding.giftInfo, giftInfoRows(model))
binding.senderSection.isVisible = model.senderInfo != null
binding.mailboxSection.isVisible = model.mailbox != null
binding.recipientSection.isVisible = model.recipientAddress != null
bindAddress(binding.senderInfo, model.senderInfo)
bindAddress(binding.mailbox, model.mailbox)
bindAddress(binding.recipientAddress, model.recipientAddress)
binding.normalSections.removeView(binding.mailboxSection)
binding.normalSections.addView(
binding.mailboxSection,
if (received) 1 else binding.normalSections.indexOfChild(binding.giftInfo) + 1
)
binding.registrationGuidance.isVisible = received && model.mailbox != null
binding.sectionSeparator.isVisible = received || undeliverable || model.showProgress
binding.undeliverable.isVisible = undeliverable
binding.undeliverableReason.bindText(model.undeliverable?.title)
binding.undeliverableGuidance.bindText(model.undeliverable?.guidance)
GiftInfoRows.bind(
binding.canceledCompletion.details,
model.cancellationRows.map {
it.label to resolveGiftDetailText(it.value)
}
)
}
private fun giftInfoRows(model: GiftDetailUiModel): List<Pair<Int, String?>> = with(model.giftInfo) {
listOf(
R.string.gift_detail_counterpart to counterpartNickname,
R.string.gift_send_size to sizeName,
R.string.gift_send_category to categoryName,
R.string.gift_detail_application_no to model.applicationNo,
R.string.gift_detail_paid_can to paidCan?.let { getString(R.string.gift_detail_can_amount, it) },
R.string.gift_detail_tracking to tracking,
R.string.gift_detail_shipping_date to shippingRequestedDate,
R.string.gift_detail_inspection_date to inspectionDate,
R.string.gift_detail_delivered_date to deliveredDate,
R.string.gift_detail_canceled_date to canceledDate
)
}
private fun bindAddress(view: LinearLayout, address: GiftDetailAddress?) {
GiftInfoRows.bind(
view,
listOf(
R.string.gift_send_name to address?.name,
R.string.gift_send_phone to address?.phoneNumber,
R.string.gift_send_address to address?.address
),
labelWidth = 72
)
}
private fun TextView.bindText(value: GiftDetailText?) {
isVisible = value != null
text = value?.let(::resolveGiftDetailText)
}
companion object {
const val EXTRA_APPLICATION_NO = "EXTRA_APPLICATION_NO"
private const val STATE_CHANGED = "STATE_CHANGED"
fun newIntent(context: Context, applicationNo: String): Intent =
Intent(context, GiftDetailActivity::class.java).putExtra(EXTRA_APPLICATION_NO, applicationNo)
}
}
internal fun Context.resolveGiftDetailText(text: GiftDetailText): String = when (text) {
is GiftDetailText.Raw -> text.value
is GiftDetailText.CanAmount -> getString(R.string.gift_detail_can_amount, text.amount)
is GiftDetailText.CancellationBody -> getString(
R.string.gift_detail_canceled_body,
text.creatorNickname?.takeIf { it.isNotBlank() } ?: getString(R.string.gift_detail_creator),
text.applicationNo
)
is Key -> getString(
when (text) {
Key.RECEIVED_LABEL -> R.string.gift_detail_received_label
Key.RECEIVED_TITLE -> R.string.gift_detail_received_title
Key.RECEIVED_BODY -> R.string.gift_detail_received_body
Key.TRACKING_REGISTERED_LABEL -> R.string.gift_inbox_sent_confirmed
Key.TRACKING_REGISTERED_TITLE -> R.string.gift_detail_tracking_title
Key.ARRIVED_AT_MAILBOX_LABEL -> R.string.gift_inbox_arrived
Key.ARRIVED_AT_MAILBOX_TITLE -> R.string.gift_detail_arrived_title
Key.INSPECTION_COMPLETED_LABEL -> R.string.gift_detail_inspected_label
Key.INSPECTION_COMPLETED_TITLE -> R.string.gift_detail_inspected_title
Key.DELIVERED_LABEL -> R.string.gift_inbox_delivered
Key.DELIVERED_TITLE -> R.string.gift_detail_delivered_title
Key.UNDELIVERABLE_LABEL -> R.string.gift_inbox_undeliverable
Key.UNDELIVERABLE_TITLE -> R.string.gift_detail_undeliverable_title
Key.UNDELIVERABLE_BODY -> R.string.gift_detail_undeliverable_body
Key.CANCELED_LABEL -> R.string.gift_inbox_canceled
Key.CANCELED_TITLE -> R.string.gift_detail_canceled_title
Key.CANCELED_BODY -> R.string.gift_detail_canceled_body
Key.DISPOSAL_NON_RETURN_GUIDANCE -> R.string.gift_detail_disposal_guidance
}
)
}
@@ -0,0 +1,218 @@
package kr.co.vividnext.sodalive.v2.gift
import android.app.Activity
import android.content.Context
import android.content.Intent
import android.view.View
import android.widget.AdapterView
import androidx.core.content.ContextCompat
import androidx.core.view.WindowCompat
import androidx.core.view.isVisible
import androidx.core.widget.addTextChangedListener
import kr.co.vividnext.sodalive.R
import kr.co.vividnext.sodalive.base.BaseActivity
import kr.co.vividnext.sodalive.common.LoadingDialog
import kr.co.vividnext.sodalive.databinding.ActivityGiftTrackingBinding
import kr.co.vividnext.sodalive.v2.components.modal.V2ModalDialog
import kr.co.vividnext.sodalive.v2.gift.ui.GiftInfoRows
import org.koin.androidx.viewmodel.ext.android.viewModel
class GiftTrackingActivity : BaseActivity<ActivityGiftTrackingBinding>(ActivityGiftTrackingBinding::inflate) {
private val viewModel: GiftTrackingViewModel by viewModel()
private val cancelViewModel: GiftCancelViewModel by viewModel()
private var cancelDialog: V2ModalDialog? = null
private val applicationNo: String by lazy { intent.getStringExtra(EXTRA_APPLICATION_NO).orEmpty() }
private var loadingDialog: LoadingDialog? = null
override fun setupView() {
WindowCompat.getInsetsController(window, binding.root).apply {
isAppearanceLightStatusBars = false
isAppearanceLightNavigationBars = false
}
binding.btnBack.setOnClickListener { finish() }
binding.retry.setOnClickListener { viewModel.retry() }
binding.cancel.setText(R.string.gift_cancel_title)
binding.cancel.setOnClickListener { showCancelDialog() }
binding.courier.adapter = GiftCategoryAdapter(
this,
listOf(getString(R.string.gift_tracking_courier_hint)) + giftCourierCompanyNames
).apply { setDropDownViewResource(R.layout.item_gift_send_category) }
binding.courier.onItemSelectedListener = object : AdapterView.OnItemSelectedListener {
override fun onItemSelected(parent: AdapterView<*>?, view: View?, position: Int, id: Long) {
updateCtaState()
}
override fun onNothingSelected(parent: AdapterView<*>?) {
updateCtaState()
}
}
binding.trackingNumber.addTextChangedListener { updateCtaState() }
binding.submit.setOnClickListener {
if (cancelViewModel.isSubmitting.value != true) {
viewModel.submitTracking(selectedCourier(), binding.trackingNumber.text.toString())
}
}
observeCancellation()
observe()
viewModel.loadInitial(applicationNo)
}
private fun showCancelDialog() {
val detail = viewModel.loadedDetail ?: return
if (
detail.direction != "SENT" || detail.status != "RECEIVED" || cancelDialog != null ||
viewModel.isSubmitting.value == true
) {
return
}
cancelDialog = giftCancelDialog(detail.giftInfo.recipientCreatorNickname, onConfirm = {
viewModel.loadedDetail?.let(cancelViewModel::cancelGift)
}, onExit = { cancelDialog = null }).also { it.show(screenWidth) }
}
private fun observeCancellation() {
cancelViewModel.isSubmitting.observe(this) { submitting ->
cancelDialog?.dialogView?.tvConfirm?.isEnabled = !submitting
cancelDialog?.dialogView?.tvCancel?.isEnabled = !submitting
updateCtaState()
}
cancelViewModel.toastLiveData.observe(this) { toast ->
if (toast != null) {
cancelViewModel.consumeToast()?.let {
showToast(it.resId?.let(::getString) ?: it.message.orEmpty())
}
}
}
cancelViewModel.cancelSuccessLiveData.observe(this) { response ->
if (response != null) {
cancelViewModel.consumeCancelSuccessEvent()?.let {
cancelDialog?.dismiss()
cancelDialog = null
showToast(getString(R.string.gift_cancel_success))
setResult(Activity.RESULT_OK, GiftCancelResult.toIntent(applicationNo, it))
finish()
}
}
}
}
private fun observe() {
viewModel.state.observe(this, ::render)
viewModel.isSubmitting.observe(this) { submitting ->
if (submitting) {
val dialog = loadingDialog ?: LoadingDialog(this, layoutInflater).also { loadingDialog = it }
dialog.show(screenWidth)
} else {
loadingDialog?.dismiss()
}
binding.courier.isEnabled = !submitting
binding.trackingNumber.isEnabled = !submitting
updateCtaState()
}
viewModel.toastLiveData.observe(this) { toast ->
if (toast != null) {
viewModel.consumeToast()?.let { showToast(it.resId?.let(::getString) ?: it.message.orEmpty()) }
}
}
viewModel.ineligibleLiveData.observe(this) { requested ->
if (requested && viewModel.consumeIneligibleEvent()) {
val detail = (viewModel.state.value as? GiftTrackingUiState.Content)?.detail
showToast(
getString(
if (detail != null && detail.mailbox == null) {
R.string.gift_tracking_missing_mailbox
} else {
R.string.gift_tracking_ineligible
}
)
)
finish()
}
}
viewModel.submitSuccessLiveData.observe(this) { success ->
if (success && viewModel.consumeSubmitSuccessEvent()) {
showToast(getString(R.string.gift_tracking_success))
setResult(Activity.RESULT_OK, Intent().putExtra(EXTRA_APPLICATION_NO, applicationNo))
finish()
}
}
}
private fun render(state: GiftTrackingUiState) {
binding.progress.isVisible = state == GiftTrackingUiState.Loading
binding.error.isVisible = state is GiftTrackingUiState.Error
binding.content.isVisible = state is GiftTrackingUiState.Content
binding.actions.isVisible = state is GiftTrackingUiState.Content
when (state) {
GiftTrackingUiState.Loading -> Unit
is GiftTrackingUiState.Error -> binding.errorMessage.text = state.message?.takeIf { it.isNotBlank() }
?: getString(R.string.common_error_unknown)
is GiftTrackingUiState.Content -> bind(state.detail)
}
updateCtaState()
}
private fun bind(model: GiftTrackingUiModel) {
GiftInfoRows.bind(
binding.summary,
listOf(
R.string.gift_send_recipient to model.recipientCreatorNickname,
R.string.gift_detail_application_no to model.applicationNo,
R.string.gift_send_size to model.sizeName,
R.string.gift_send_category to model.categoryName,
R.string.gift_detail_paid_can to model.paidCan?.let { getString(R.string.gift_detail_can_amount, it) },
R.string.gift_tracking_application_date to model.applicationDate
)
)
GiftInfoRows.bind(
binding.mailbox,
listOf(
R.string.gift_send_name to model.mailbox?.name,
R.string.gift_send_phone to model.mailbox?.phoneNumber,
R.string.gift_send_address to model.mailbox?.address
),
labelWidth = 72
)
}
private fun selectedCourier(): String? = giftCourierCompanyNames.getOrNull(binding.courier.selectedItemPosition - 1)
private fun updateCtaState() {
val trackingNumber = binding.trackingNumber.text.toString()
val hasError = GiftTrackingPresenter.hasTrackingNumberError(trackingNumber)
binding.trackingNumberError.isVisible = hasError
binding.trackingNumber.setBackgroundResource(
if (hasError) R.drawable.bg_gift_send_input_error else R.drawable.bg_creator_channel_fantalk_reply
)
val detail = viewModel.loadedDetail
val idle = viewModel.isSubmitting.value != true && cancelViewModel.isSubmitting.value != true
binding.cancel.isVisible = detail?.direction == "SENT" && detail.status == "RECEIVED"
binding.cancel.isEnabled = idle
binding.cancel.setTextColor(ContextCompat.getColor(this, if (idle) R.color.white else R.color.gray_500))
val eligible = (viewModel.state.value as? GiftTrackingUiState.Content)?.detail?.isEligible == true
val enabled = eligible && idle &&
GiftTrackingPresenter.isSubmitEnabled(selectedCourier(), trackingNumber)
binding.submit.isEnabled = enabled
binding.submit.setTextColor(ContextCompat.getColor(this, if (enabled) R.color.white else R.color.gray_500))
binding.submit.setBackgroundResource(
if (enabled) {
R.drawable.bg_creator_channel_fantalk_write_send_enabled
} else {
R.drawable.bg_creator_channel_fantalk_write_send_disabled
}
)
}
override fun onDestroy() {
cancelDialog?.dismiss()
loadingDialog?.dismiss()
super.onDestroy()
}
companion object {
const val EXTRA_APPLICATION_NO = GiftDetailActivity.EXTRA_APPLICATION_NO
fun newIntent(context: Context, applicationNo: String): Intent =
Intent(context, GiftTrackingActivity::class.java).putExtra(EXTRA_APPLICATION_NO, applicationNo)
}
}
@@ -0,0 +1,376 @@
package kr.co.vividnext.sodalive.v2.gift
import android.app.Activity
import android.app.Application
import android.content.Intent
import android.view.View
import androidx.lifecycle.ViewModelProvider
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.GiftCancelResponse
import kr.co.vividnext.sodalive.v2.gift.data.GiftAddressResponse
import kr.co.vividnext.sodalive.v2.gift.data.GiftDeliveryResponse
import kr.co.vividnext.sodalive.v2.gift.data.GiftDetailInfoResponse
import kr.co.vividnext.sodalive.v2.gift.data.GiftDetailResponse
import kr.co.vividnext.sodalive.v2.gift.data.GiftRepository
import kr.co.vividnext.sodalive.v2.gift.data.GiftTrackingRequest
import kr.co.vividnext.sodalive.v2.gift.data.GiftTrackingResponse
import org.junit.After
import org.junit.Before
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertTrue
import org.junit.Assert.assertNull
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.Robolectric
import org.robolectric.Shadows.shadowOf
import org.robolectric.annotation.Config
import org.robolectric.shadows.ShadowToast
import org.robolectric.shadows.ShadowDialog
import org.koin.core.context.startKoin
import org.koin.core.context.stopKoin
import org.koin.androidx.viewmodel.dsl.viewModel
import org.koin.dsl.module
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [28], application = Application::class)
class GiftNavigationTest {
private lateinit var api: NavigationFakeApi
@Before
fun setUp() {
RxJavaPlugins.setIoSchedulerHandler { Schedulers.trampoline() }
RxAndroidPlugins.setInitMainThreadSchedulerHandler { Schedulers.trampoline() }
RxAndroidPlugins.setMainThreadSchedulerHandler { Schedulers.trampoline() }
SharedPreferenceManager.resetForTest()
SharedPreferenceManager.init(ApplicationProvider.getApplicationContext())
api = NavigationFakeApi()
startKoin {
modules(
module {
viewModel { GiftDetailViewModel(GiftRepository(api)) }
viewModel { GiftTrackingViewModel(GiftRepository(api)) }
viewModel { GiftCancelViewModel(GiftRepository(api)) }
}
)
}
}
@After
fun tearDown() {
stopKoin()
RxJavaPlugins.reset()
RxAndroidPlugins.reset()
SharedPreferenceManager.resetForTest()
}
@Test
fun `양쪽 취소 dialog는 실패를 유지하고 성공만 닫아 취소 결과와 목록 갱신을 전달한다`() {
listOf(false, true).forEach { tracking ->
api.cancelRequests.clear()
api.cancelResponse = SingleSubject.create()
val parent = Robolectric.buildActivity(
GiftDetailActivity::class.java,
GiftDetailActivity.newIntent(ApplicationProvider.getApplicationContext(), "cancel-gift")
).setup()
val detail = parent.get()
var requestCode = 0
val child = if (tracking) {
detail.binding.tracking.performClick()
val launched = shadowOf(detail).nextStartedActivityForResult
requestCode = launched.requestCode
Robolectric.buildActivity(GiftTrackingActivity::class.java, launched.intent).setup()
} else {
null
}
val activity = child?.get() ?: detail
activity.findViewById<View>(R.id.cancel).performClick()
val exited = ShadowDialog.getLatestDialog()
assertTrue(exited != null && exited.isShowing)
assertTrue(api.cancelRequests.isEmpty())
exited.findViewById<View>(R.id.tv_cancel).performClick()
assertFalse(exited.isShowing)
assertTrue(api.cancelRequests.isEmpty())
activity.findViewById<View>(R.id.cancel).performClick()
val dialog = ShadowDialog.getLatestDialog()
val confirm = dialog.findViewById<View>(R.id.tv_confirm)
confirm.performClick()
assertTrue(dialog.isShowing)
assertFalse(confirm.isEnabled)
assertEquals(listOf("cancel-gift"), api.cancelRequests)
api.cancelResponse.onSuccess(ApiResponse(false, null, "취소 실패"))
assertTrue(dialog.isShowing)
assertTrue(confirm.isEnabled)
assertEquals("취소 실패", ShadowToast.getTextOfLatestToast())
assertNull(ViewModelProvider(activity)[GiftCancelViewModel::class.java].toastLiveData.value)
api.cancelResponse = SingleSubject.create()
confirm.performClick()
val cancel = GiftCancelResponse("cancel-gift", "CANCELED", "신청 취소", 77, "2026-10-02T00:00:00Z")
api.cancelResponse.onSuccess(ApiResponse(true, cancel, null))
assertFalse(dialog.isShowing)
assertEquals(Activity.RESULT_OK, shadowOf(activity).resultCode)
val requestsBeforeResult = api.requests.size
if (child != null) {
assertTrue(activity.isFinishing)
val result = shadowOf(activity).resultIntent
assertEquals("cancel-gift", result.getStringExtra(GiftDetailActivity.EXTRA_APPLICATION_NO))
assertEquals(cancel.canceledAt, result.getStringExtra("EXTRA_CANCELED_AT"))
assertEquals(77, result.getIntExtra("EXTRA_PRICE_CAN", -1))
detail.activityResultRegistry.dispatchResult(requestCode, Activity.RESULT_OK, result)
child.pause().stop().destroy()
}
val state = ViewModelProvider(detail)[GiftDetailViewModel::class.java].state.value as GiftDetailUiState.Canceled
assertEquals(cancel, state.cancel)
assertEquals(requestsBeforeResult, api.requests.size)
assertFalse(detail.isFinishing)
val requestsBeforeRecreate = api.requests.size
val cancelRequestsBeforeRecreate = api.cancelRequests.toList()
val recreatedDetail = parent.recreate().get()
assertEquals(requestsBeforeRecreate, api.requests.size)
assertEquals(cancelRequestsBeforeRecreate, api.cancelRequests)
if (tracking) {
recreatedDetail.binding.btnBack.performClick()
} else {
recreatedDetail.onBackPressedDispatcher.onBackPressed()
}
assertTrue(recreatedDetail.isFinishing)
assertTrue(shouldRefreshGiftInbox(shadowOf(recreatedDetail).resultCode))
parent.pause().stop().destroy()
}
}
@Test
fun `상세 TRACKING 액션은 같은 신청번호만 전달한다`() {
val intent = GiftDetailActivity.newIntent(ApplicationProvider.getApplicationContext(), " gift-001/신청 ")
val controller = Robolectric.buildActivity(GiftDetailActivity::class.java, intent).setup()
val activity = controller.get()
activity.binding.tracking.performClick()
val launched = shadowOf(activity).nextStartedActivityForResult.intent
assertEquals(GiftTrackingActivity::class.java.name, launched.component?.className)
assertEquals(" gift-001/신청 ", launched.getStringExtra(GiftTrackingActivity.EXTRA_APPLICATION_NO))
assertEquals(setOf(GiftTrackingActivity.EXTRA_APPLICATION_NO), launched.extras?.keySet())
controller.pause().stop().destroy()
}
@Test
fun `운송장 등록 성공은 같은 신청번호의 RESULT_OK로 종료한다`() {
val intent = GiftTrackingActivity.newIntent(ApplicationProvider.getApplicationContext(), " gift-001/신청 ")
val controller = Robolectric.buildActivity(GiftTrackingActivity::class.java, intent).setup()
val activity = controller.get()
activity.binding.courier.setSelection(1)
activity.binding.trackingNumber.setText("00123456789012")
shadowOf(android.os.Looper.getMainLooper()).idle()
activity.binding.submit.performClick()
assertTrue(activity.isFinishing)
assertEquals(activity.getString(R.string.gift_tracking_success), ShadowToast.getTextOfLatestToast())
assertEquals(Activity.RESULT_OK, shadowOf(activity).resultCode)
val result = shadowOf(activity).resultIntent
assertEquals(" gift-001/신청 ", result.getStringExtra(GiftTrackingActivity.EXTRA_APPLICATION_NO))
assertEquals(setOf(GiftTrackingActivity.EXTRA_APPLICATION_NO), result.extras?.keySet())
assertEquals(
listOf(" gift-001/신청 " to GiftTrackingRequest(giftCourierCompanyNames.first(), "00123456789012")),
api.submissions
)
controller.pause().stop().destroy()
}
@Test
fun `운송장 RESULT_OK만 원래 신청번호의 상세를 재조회한다`() {
val intent = GiftDetailActivity.newIntent(ApplicationProvider.getApplicationContext(), "original-gift")
val controller = Robolectric.buildActivity(GiftDetailActivity::class.java, intent).setup()
val activity = controller.get()
listOf(Activity.RESULT_CANCELED, Activity.RESULT_FIRST_USER, Activity.RESULT_OK).forEach { code ->
activity.binding.tracking.performClick()
val launched = shadowOf(activity).nextStartedActivityForResult
activity.activityResultRegistry.dispatchResult(
launched.requestCode,
code,
Intent().putExtra(GiftTrackingActivity.EXTRA_APPLICATION_NO, "other-gift")
)
assertEquals(if (code == Activity.RESULT_OK) 2 else 1, api.requests.size)
}
assertEquals(listOf("original-gift", "original-gift"), api.requests)
assertEquals(Activity.RESULT_OK, shadowOf(activity).resultCode)
controller.pause().stop().destroy()
}
@Test
fun `운송장 성공 후 재생성한 상세는 양쪽 뒤로가기에서 부모 성공 결과를 유지한다`() {
listOf(true, false).forEach { toolbarBack ->
val controller = Robolectric.buildActivity(
GiftDetailActivity::class.java,
GiftDetailActivity.newIntent(ApplicationProvider.getApplicationContext(), "tracking-gift")
).setup()
val activity = controller.get()
activity.binding.tracking.performClick()
val launched = shadowOf(activity).nextStartedActivityForResult
activity.activityResultRegistry.dispatchResult(
launched.requestCode,
Activity.RESULT_OK,
Intent().putExtra(GiftTrackingActivity.EXTRA_APPLICATION_NO, "tracking-gift")
)
val requestsBeforeRecreate = api.requests.size
val recreatedDetail = controller.recreate().get()
assertEquals(requestsBeforeRecreate, api.requests.size)
if (toolbarBack) {
recreatedDetail.binding.btnBack.performClick()
} else {
recreatedDetail.onBackPressedDispatcher.onBackPressed()
}
assertTrue(recreatedDetail.isFinishing)
assertEquals(Activity.RESULT_OK, shadowOf(recreatedDetail).resultCode)
controller.pause().stop().destroy()
}
}
@Test
fun `변경 없는 일반 상세는 재생성 뒤에도 성공 결과나 추가 요청을 만들지 않는다`() {
val controller = Robolectric.buildActivity(
GiftDetailActivity::class.java,
GiftDetailActivity.newIntent(ApplicationProvider.getApplicationContext(), "unchanged-gift")
).setup()
val requestsBeforeRecreate = api.requests.size
val recreatedDetail = controller.recreate().get()
assertEquals(requestsBeforeRecreate, api.requests.size)
assertTrue(api.cancelRequests.isEmpty())
assertTrue(api.submissions.isEmpty())
recreatedDetail.onBackPressedDispatcher.onBackPressed()
assertTrue(recreatedDetail.isFinishing)
assertEquals(Activity.RESULT_CANCELED, shadowOf(recreatedDetail).resultCode)
controller.pause().stop().destroy()
}
@Test
fun `서버 CANCELED 조회만으로는 재생성 뒤에도 성공 결과를 만들지 않는다`() {
api.detailStatus = "CANCELED"
val controller = Robolectric.buildActivity(
GiftDetailActivity::class.java,
GiftDetailActivity.newIntent(ApplicationProvider.getApplicationContext(), "canceled-gift")
).setup()
val requestsBeforeRecreate = api.requests.size
val recreatedDetail = controller.recreate().get()
assertEquals(requestsBeforeRecreate, api.requests.size)
assertTrue(api.cancelRequests.isEmpty())
assertTrue(api.submissions.isEmpty())
recreatedDetail.binding.btnBack.performClick()
assertTrue(recreatedDetail.isFinishing)
assertEquals(Activity.RESULT_CANCELED, shadowOf(recreatedDetail).resultCode)
controller.pause().stop().destroy()
}
@Test
fun `운송장 화면의 일반 뒤로가기는 성공 결과나 제출을 만들지 않는다`() {
val intent = GiftTrackingActivity.newIntent(ApplicationProvider.getApplicationContext(), "test-gift")
listOf(true, false).forEach { toolbarBack ->
val controller = Robolectric.buildActivity(GiftTrackingActivity::class.java, intent).setup()
val activity = controller.get()
if (toolbarBack) {
activity.binding.btnBack.performClick()
} else {
activity.onBackPressedDispatcher.onBackPressed()
}
assertTrue(activity.isFinishing)
assertEquals(Activity.RESULT_CANCELED, shadowOf(activity).resultCode)
assertNull(shadowOf(activity).resultIntent)
controller.pause().stop().destroy()
}
assertTrue(api.submissions.isEmpty())
}
@Test
fun `잘못된 진입과 사서함 없는 신청은 오류 후 성공 결과 없이 종료한다`() {
listOf("", "missing-mailbox").forEach { applicationNo ->
val intent = GiftTrackingActivity.newIntent(ApplicationProvider.getApplicationContext(), applicationNo)
val controller = Robolectric.buildActivity(GiftTrackingActivity::class.java, intent).setup()
val activity = controller.get()
assertTrue(activity.isFinishing)
assertEquals(Activity.RESULT_CANCELED, shadowOf(activity).resultCode)
assertNull(shadowOf(activity).resultIntent)
val error = if (applicationNo.isEmpty()) R.string.gift_tracking_ineligible else R.string.gift_tracking_missing_mailbox
assertEquals(activity.getString(error), ShadowToast.getTextOfLatestToast())
controller.pause().stop().destroy()
}
assertEquals(listOf("missing-mailbox"), api.requests)
assertTrue(api.submissions.isEmpty())
}
@Test
fun `상세에서 RESULT_OK로 돌아온 경우만 목록을 갱신한다`() = assertTrue(shouldRefreshGiftInbox(Activity.RESULT_OK))
@Test
fun `상세에서 취소하거나 다른 결과로 돌아오면 목록을 갱신하지 않는다`() {
assertFalse(shouldRefreshGiftInbox(Activity.RESULT_CANCELED))
assertFalse(shouldRefreshGiftInbox(Activity.RESULT_FIRST_USER))
}
@Test
fun `상세 Intent는 신청번호만 원본 그대로 전달한다`() {
val applicationNo = " gift-001/신청 "
val intent = GiftDetailActivity.newIntent(ApplicationProvider.getApplicationContext(), applicationNo)
assertEquals(GiftDetailActivity::class.java.name, intent.component?.className)
assertEquals(applicationNo, intent.getStringExtra(GiftDetailActivity.EXTRA_APPLICATION_NO))
assertEquals(setOf(GiftDetailActivity.EXTRA_APPLICATION_NO), intent.extras?.keySet())
}
private class NavigationFakeApi : GiftApi by InboxFakeApi() {
val cancelRequests = mutableListOf<String>()
var cancelResponse = SingleSubject.create<ApiResponse<GiftCancelResponse>>()
var detailStatus = "RECEIVED"
var nextDetailResponse: Single<ApiResponse<GiftDetailResponse>>? = null
override fun cancelGift(applicationNo: String, authHeader: String): Single<ApiResponse<GiftCancelResponse>> =
cancelResponse.also { cancelRequests.add(applicationNo) }
val requests = mutableListOf<String>()
val submissions = mutableListOf<Pair<String, GiftTrackingRequest>>()
override fun getGiftDetail(applicationNo: String, authHeader: String): Single<ApiResponse<GiftDetailResponse>> {
requests.add(applicationNo)
return nextDetailResponse?.also { nextDetailResponse = null } ?: Single.just(
ApiResponse(
true,
GiftDetailResponse(
applicationNo, "SENT", detailStatus, "접수 완료",
GiftDetailInfoResponse("테스트", null, "소형", "도서", applicationNo, 100, null, null),
null, null,
if (applicationNo == "missing-mailbox") null else GiftAddressResponse("테스트 사서함", "000", "테스트 주소"),
true, false, null, GiftDeliveryResponse(null, null, null), emptyList()
),
null
)
)
}
override fun registerGiftTracking(
applicationNo: String,
request: GiftTrackingRequest,
authHeader: String
): Single<ApiResponse<GiftTrackingResponse>> =
Single.just(
ApiResponse(
true,
GiftTrackingResponse(
applicationNo,
"TRACKING_REGISTERED",
"발송 확인",
request.courierCompanyName,
request.trackingNumber,
"2026-10-02T00:00:00Z",
"2026-10-09T00:00:00Z"
),
null
)
).also { submissions.add(applicationNo to request) }
}
}