feat(auth): 인증 요청에 콘텐츠 설정을 포함한다

This commit is contained in:
2026-10-13 11:29:17 +09:00
parent e7c7e2cb4a
commit de220019cc
5 changed files with 815 additions and 0 deletions
@@ -0,0 +1,16 @@
package kr.co.vividnext.sodalive.v2.auth
import io.reactivex.rxjava3.core.Single
import kr.co.vividnext.sodalive.common.ApiResponse
import kr.co.vividnext.sodalive.mypage.auth.AuthResponse
import retrofit2.http.Body
import retrofit2.http.Header
import retrofit2.http.POST
interface V2AuthApi {
@POST("/auth")
fun verify(
@Body request: V2AuthVerifyRequest,
@Header("Authorization") authHeader: String
): Single<ApiResponse<AuthResponse>>
}
@@ -0,0 +1,12 @@
package kr.co.vividnext.sodalive.v2.auth
import androidx.annotation.Keep
import com.google.gson.annotations.SerializedName
import kr.co.vividnext.sodalive.settings.ContentType
@Keep
data class V2AuthVerifyRequest(
@SerializedName("receipt_id") val receiptId: String,
@SerializedName("isAdultContentVisible") val isAdultContentVisible: Boolean,
@SerializedName("contentType") val contentType: ContentType
)
@@ -0,0 +1,160 @@
package kr.co.vividnext.sodalive.v2.auth
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
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.settings.ContentType
import kr.co.vividnext.sodalive.user.UserRepository
enum class V2AuthPhase {
Idle, Choosing, Submitting, Syncing, Failed, Completed
}
data class V2AuthState(
val phase: V2AuthPhase = V2AuthPhase.Idle,
val isAdultContentVisible: Boolean = true,
val contentType: ContentType = ContentType.ALL,
val selectionLocked: Boolean = false,
val error: ToastMessage? = null,
val completionPending: Boolean = false
)
class V2AuthViewModel(
private val api: V2AuthApi,
private val userRepository: UserRepository
) : BaseViewModel() {
private val mutableState = MutableLiveData(V2AuthState())
val stateLiveData: LiveData<V2AuthState> = mutableState
private val state: V2AuthState
get() = requireNotNull(mutableState.value)
private var receiptId: String? = null
private var syncMemberInfo = false
private var acceptedSubmission: V2AuthVerifyRequest? = null
fun begin(receiptId: String, syncMemberInfo: Boolean = false) {
if (this.receiptId != null || receiptId.isBlank()) return
this.receiptId = receiptId
this.syncMemberInfo = syncMemberInfo
mutableState.value = V2AuthState(phase = V2AuthPhase.Choosing)
}
fun toggleVisibility() {
if (!canEditSelection()) return
mutableState.value = state.copy(
phase = V2AuthPhase.Choosing,
isAdultContentVisible = !state.isAdultContentVisible,
contentType = ContentType.ALL,
error = null
)
}
fun selectContentType(contentType: ContentType) {
if (!canEditSelection()) return
mutableState.value = state.copy(
phase = V2AuthPhase.Choosing,
contentType = if (state.isAdultContentVisible) contentType else ContentType.ALL,
error = null
)
}
fun confirm() {
val receipt = receiptId ?: return
if (state.phase != V2AuthPhase.Choosing && state.phase != V2AuthPhase.Failed) return
val accepted = acceptedSubmission
if (accepted != null) {
syncMember(accepted)
return
}
val request = V2AuthVerifyRequest(receipt, state.isAdultContentVisible, state.contentType)
mutableState.value = state.copy(phase = V2AuthPhase.Submitting, selectionLocked = true, error = null)
compositeDisposable.add(
api.verify(request, authToken())
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe({ response ->
if (response.success) {
acceptedSubmission = request
if (syncMemberInfo) {
syncMember(request)
} else {
savePreferences(request.isAdultContentVisible, request.contentType)
complete()
}
} else {
fail(response.message)
}
}, {
fail(null)
})
)
}
fun consumeError(): ToastMessage? {
val error = state.error ?: return null
mutableState.value = state.copy(error = null)
return error
}
fun consumeCompletion(): Boolean {
if (!state.completionPending) return false
mutableState.value = state.copy(completionPending = false)
return true
}
private fun canEditSelection(): Boolean = !state.selectionLocked &&
(state.phase == V2AuthPhase.Choosing || state.phase == V2AuthPhase.Failed)
private fun syncMember(submitted: V2AuthVerifyRequest) {
mutableState.value = state.copy(phase = V2AuthPhase.Syncing, selectionLocked = true, error = null)
compositeDisposable.add(
userRepository.getMemberInfo(authToken())
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe({ response ->
val member = response.data
if (response.success && member != null) {
SharedPreferenceManager.isAuth = member.isAuth
savePreferences(
member.isAdultContentVisible ?: submitted.isAdultContentVisible,
member.contentType ?: submitted.contentType
)
complete()
} else {
fail(response.message)
}
}, {
fail(null)
})
)
}
private fun savePreferences(visible: Boolean, contentType: ContentType) {
SharedPreferenceManager.isAdultContentVisible = visible
SharedPreferenceManager.contentPreference = contentType.ordinal
}
private fun complete() {
mutableState.value = state.copy(phase = V2AuthPhase.Completed, error = null, completionPending = true)
}
private fun fail(message: String?) {
mutableState.value = state.copy(
phase = V2AuthPhase.Failed,
selectionLocked = acceptedSubmission != null,
error = if (message.isNullOrBlank()) {
ToastMessage(resId = R.string.common_error_unknown)
} else {
ToastMessage(message = message)
}
)
}
private fun authToken(): String = "Bearer ${SharedPreferenceManager.token}"
}
@@ -0,0 +1,93 @@
package kr.co.vividnext.sodalive.v2.auth
import android.app.Application
import com.google.gson.Gson
import com.google.gson.JsonParser
import kr.co.vividnext.sodalive.settings.ContentType
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Protocol
import okhttp3.Request
import okhttp3.Response
import okhttp3.ResponseBody.Companion.toResponseBody
import okio.Buffer
import org.junit.Assert.assertEquals
import org.junit.Assert.assertTrue
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.annotation.Config
import retrofit2.Retrofit
import retrofit2.adapter.rxjava3.RxJava3CallAdapterFactory
import retrofit2.converter.gson.GsonConverterFactory
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [28], application = Application::class)
class V2AuthVerifyRequestTest {
@Test
fun `ON ALL 요청은 영수증과 Boolean과 enum 이름을 정확한 키로 직렬화한다`() {
assertJson(true, ContentType.ALL, """{"receipt_id":"test-receipt","isAdultContentVisible":true,"contentType":"ALL"}""")
}
@Test
fun `ON MALE 요청은 enum 이름을 직렬화한다`() {
assertJson(true, ContentType.MALE, """{"receipt_id":"test-receipt","isAdultContentVisible":true,"contentType":"MALE"}""")
}
@Test
fun `ON FEMALE 요청은 enum 이름을 직렬화한다`() {
assertJson(
true,
ContentType.FEMALE,
"""{"receipt_id":"test-receipt","isAdultContentVisible":true,"contentType":"FEMALE"}"""
)
}
@Test
fun `OFF 요청에도 false와 ALL을 누락하지 않는다`() {
assertJson(false, ContentType.ALL, """{"receipt_id":"test-receipt","isAdultContentVisible":false,"contentType":"ALL"}""")
}
@Test
fun `v2 API는 인증 헤더와 본문을 auth에 POST하고 기존 응답을 사용한다`() {
val requests = mutableListOf<Request>()
val client = OkHttpClient.Builder().addInterceptor { chain ->
requests.add(chain.request())
Response.Builder()
.request(chain.request())
.protocol(Protocol.HTTP_1_1)
.code(200)
.message("OK")
.body("""{"success":true,"data":{"gender":2}}""".toResponseBody("application/json".toMediaType()))
.build()
}.build()
val api = Retrofit.Builder()
.baseUrl("https://example.invalid/")
.client(client)
.addConverterFactory(GsonConverterFactory.create())
.addCallAdapterFactory(RxJava3CallAdapterFactory.createSynchronous())
.build()
.create(V2AuthApi::class.java)
val response = api.verify(V2AuthVerifyRequest("test-receipt", false, ContentType.ALL), "Bearer test-token")
.blockingGet()
val request = requests.single()
assertEquals("POST", request.method)
assertEquals("/auth", request.url.encodedPath)
assertEquals("Bearer test-token", request.header("Authorization"))
val buffer = Buffer()
requireNotNull(request.body).writeTo(buffer)
assertEquals(
JsonParser.parseString("""{"receipt_id":"test-receipt","isAdultContentVisible":false,"contentType":"ALL"}"""),
JsonParser.parseString(buffer.readUtf8())
)
assertTrue(response.success)
assertEquals(2, response.data?.gender)
}
private fun assertJson(visible: Boolean, type: ContentType, expected: String) {
val json = Gson().toJson(V2AuthVerifyRequest("test-receipt", visible, type))
assertEquals(JsonParser.parseString(expected), JsonParser.parseString(json))
}
}
@@ -0,0 +1,534 @@
package kr.co.vividnext.sodalive.v2.auth
import android.app.Application
import androidx.lifecycle.Observer
import androidx.lifecycle.ViewModelStore
import io.mockk.every
import io.mockk.mockk
import io.mockk.mockkObject
import io.mockk.unmockkObject
import io.mockk.verify
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.common.ToastMessage
import kr.co.vividnext.sodalive.mypage.auth.AuthResponse
import kr.co.vividnext.sodalive.settings.ContentType
import kr.co.vividnext.sodalive.settings.notification.GetMemberInfoResponse
import kr.co.vividnext.sodalive.settings.notification.MemberRole
import kr.co.vividnext.sodalive.user.UserApi
import kr.co.vividnext.sodalive.user.UserRepository
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 V2AuthViewModelTest {
private val calls = mutableListOf<String>()
private val memberHeaders = mutableListOf<String>()
private var memberResponse = SingleSubject.create<ApiResponse<GetMemberInfoResponse>>()
private var savedVisible = false
private var savedPreference = ContentType.FEMALE.ordinal
private var savedAuth = false
private lateinit var api: FakeAuthApi
private lateinit var viewModel: V2AuthViewModel
private val store = ViewModelStore()
@Before
fun setUp() {
RxJavaPlugins.setIoSchedulerHandler { Schedulers.trampoline() }
RxAndroidPlugins.setInitMainThreadSchedulerHandler { Schedulers.trampoline() }
RxAndroidPlugins.setMainThreadSchedulerHandler { Schedulers.trampoline() }
mockkObject(SharedPreferenceManager)
every { SharedPreferenceManager.token } returns "test-token"
every { SharedPreferenceManager.isAdultContentVisible } answers { savedVisible }
every { SharedPreferenceManager.contentPreference } answers { savedPreference }
every { SharedPreferenceManager.isAuth } answers { savedAuth }
every { SharedPreferenceManager.isAdultContentVisible = any() } answers {
savedVisible = firstArg()
calls.add("save-visible:$savedVisible")
Unit
}
every { SharedPreferenceManager.contentPreference = any() } answers {
savedPreference = firstArg()
calls.add("save-preference:$savedPreference")
Unit
}
every { SharedPreferenceManager.isAuth = any() } answers {
savedAuth = firstArg()
calls.add("save-auth:$savedAuth")
Unit
}
val userApi = mockk<UserApi>()
every { userApi.getMemberInfo(any()) } answers {
val header = firstArg<String>()
Single.defer {
memberHeaders.add(header)
calls.add("GET")
memberResponse
}
}
api = FakeAuthApi(calls)
viewModel = V2AuthViewModel(api, UserRepository(userApi))
store.put("auth", viewModel)
}
@After
fun tearDown() {
store.clear()
unmockkObject(SharedPreferenceManager)
RxJavaPlugins.reset()
RxAndroidPlugins.reset()
}
@Test
fun `초기 상태와 시작은 기존 선호도를 읽지 않고 ON ALL이며 제출과 저장이 없다`() {
assertEquals(V2AuthPhase.Idle, state().phase)
viewModel.begin("test-receipt", false)
assertEquals(V2AuthPhase.Choosing, state().phase)
assertTrue(state().isAdultContentVisible)
assertEquals(ContentType.ALL, state().contentType)
assertFalse(state().selectionLocked)
assertTrue(calls.isEmpty())
verify(exactly = 0) { SharedPreferenceManager.isAdultContentVisible }
verify(exactly = 0) { SharedPreferenceManager.contentPreference }
verify(exactly = 0) { SharedPreferenceManager.isAuth }
}
@Test
fun `시작 전 확인과 빈 영수증은 요청하지 않으며 유효한 시작은 가능하다`() {
viewModel.confirm()
listOf("", " \n\t ").forEach { viewModel.begin(it, true) }
viewModel.confirm()
assertEquals(V2AuthPhase.Idle, state().phase)
assertTrue(calls.isEmpty())
viewModel.begin("test-receipt", false)
assertEquals(V2AuthPhase.Choosing, state().phase)
}
@Test
fun `ON 선택은 모든 enum을 허용하고 확인 전에는 요청이나 저장을 하지 않는다`() {
viewModel.begin("test-receipt", false)
listOf(ContentType.MALE, ContentType.FEMALE, ContentType.ALL).forEach { type ->
viewModel.selectContentType(type)
assertEquals(type, state().contentType)
}
assertTrue(calls.isEmpty())
}
@Test
fun `OFF 전환과 OFF 중 선택은 ALL을 유지하고 다시 ON도 ALL이다`() {
viewModel.begin("test-receipt", false)
viewModel.selectContentType(ContentType.FEMALE)
viewModel.toggleVisibility()
assertFalse(state().isAdultContentVisible)
assertEquals(ContentType.ALL, state().contentType)
viewModel.selectContentType(ContentType.MALE)
assertEquals(ContentType.ALL, state().contentType)
viewModel.toggleVisibility()
assertTrue(state().isAdultContentVisible)
assertEquals(ContentType.ALL, state().contentType)
assertTrue(calls.isEmpty())
}
@Test
fun `진행 중 같은 영수증과 다른 영수증의 시작은 선택과 경로를 초기화하지 않는다`() {
viewModel.begin("test-receipt", false)
viewModel.selectContentType(ContentType.FEMALE)
viewModel.begin("test-receipt", true)
viewModel.begin("other-receipt", true)
assertEquals(ContentType.FEMALE, state().contentType)
viewModel.confirm()
viewModel.begin("test-receipt", true)
viewModel.begin("other-receipt", true)
api.response.onSuccess(ApiResponse(true))
assertEquals("test-receipt", api.requests.single().first.receiptId)
assertEquals(V2AuthPhase.Completed, state().phase)
assertTrue(memberHeaders.isEmpty())
}
@Test
fun `확인은 현재 토큰과 선택을 제출하고 응답 대기 중 중복 확인과 편집을 막는다`() {
viewModel.begin("test-receipt", false)
viewModel.selectContentType(ContentType.MALE)
every { SharedPreferenceManager.token } returns "updated-test-token"
viewModel.confirm()
viewModel.confirm()
viewModel.toggleVisibility()
viewModel.selectContentType(ContentType.FEMALE)
assertEquals(V2AuthPhase.Submitting, state().phase)
assertTrue(state().selectionLocked)
assertEquals(ContentType.MALE, state().contentType)
assertEquals(
listOf(V2AuthVerifyRequest("test-receipt", true, ContentType.MALE) to "Bearer updated-test-token"),
api.requests
)
assertEquals(listOf("POST"), calls)
assertFalse(viewModel.consumeCompletion())
}
@Test
fun `OFF 확인은 false ALL을 제출하고 성공 후에만 저장한다`() {
viewModel.begin("test-receipt", false)
viewModel.selectContentType(ContentType.MALE)
viewModel.toggleVisibility()
viewModel.confirm()
assertEquals(V2AuthVerifyRequest("test-receipt", false, ContentType.ALL), api.requests.single().first)
assertEquals(listOf("POST"), calls)
api.response.onSuccess(ApiResponse(true))
assertEquals(listOf("POST", "save-visible:false", "save-preference:0"), calls)
assertEquals(V2AuthPhase.Completed, state().phase)
}
@Test
fun `일반 성공은 성별과 무관하게 제출 선호도를 먼저 저장하고 인증 상태를 추정하지 않는다`() {
viewModel.begin("test-receipt", false)
viewModel.selectContentType(ContentType.FEMALE)
val observer = Observer<V2AuthState> {
if (it.phase == V2AuthPhase.Completed) {
assertTrue(savedVisible)
assertEquals(2, savedPreference)
assertFalse(savedAuth)
calls.add("completed")
}
}
viewModel.stateLiveData.observeForever(observer)
try {
viewModel.confirm()
api.response.onSuccess(ApiResponse(true, AuthResponse(gender = 1)))
assertEquals(listOf("POST", "save-visible:true", "save-preference:2", "completed"), calls)
assertEquals(ContentType.FEMALE, state().contentType)
verify(exactly = 0) { SharedPreferenceManager.isAuth = any() }
} finally {
viewModel.stateLiveData.removeObserver(observer)
}
}
@Test
fun `성공 data와 성별이 없어도 success만으로 완료하고 완료는 한 번만 소비된다`() {
viewModel.begin("test-receipt", false)
viewModel.confirm()
api.response.onSuccess(ApiResponse(true))
assertEquals(V2AuthPhase.Completed, state().phase)
assertTrue(state().completionPending)
assertTrue(viewModel.consumeCompletion())
assertFalse(state().completionPending)
assertFalse(viewModel.consumeCompletion())
viewModel.confirm()
viewModel.begin("test-receipt", false)
viewModel.begin("other-receipt", false)
viewModel.toggleVisibility()
viewModel.selectContentType(ContentType.MALE)
viewModel.confirm()
assertEquals(1, api.requests.size)
assertEquals(V2AuthPhase.Completed, state().phase)
assertFalse(viewModel.consumeCompletion())
}
@Test
fun `POST 실패는 서버 안내와 선택을 유지하고 편집 후 재제출할 수 있다`() {
viewModel.begin("test-receipt", false)
viewModel.selectContentType(ContentType.FEMALE)
viewModel.confirm()
api.response.onSuccess(ApiResponse(false, AuthResponse(1), "인증 실패", "receipt_id"))
assertEquals(V2AuthPhase.Failed, state().phase)
assertEquals(ContentType.FEMALE, state().contentType)
assertFalse(state().selectionLocked)
assertEquals(ToastMessage(message = "인증 실패"), state().error)
assertEquals(listOf("POST"), calls)
assertFalse(viewModel.consumeCompletion())
viewModel.selectContentType(ContentType.MALE)
assertEquals(V2AuthPhase.Choosing, state().phase)
assertNull(state().error)
api.response = SingleSubject.create()
viewModel.confirm()
assertEquals(ContentType.MALE, api.requests.last().first.contentType)
api.response.onSuccess(ApiResponse(true))
assertEquals(1, savedPreference)
assertTrue(viewModel.consumeCompletion())
}
@Test
fun `POST 실패 안내는 한 번 소비되며 재시도는 같은 초안을 전송한다`() {
viewModel.begin("test-receipt", false)
viewModel.selectContentType(ContentType.MALE)
viewModel.confirm()
api.response.onSuccess(ApiResponse(false, null, "인증 실패"))
assertEquals(ToastMessage(message = "인증 실패"), viewModel.consumeError())
assertNull(state().error)
assertNull(viewModel.consumeError())
viewModel.begin("test-receipt", true)
assertEquals(ContentType.MALE, state().contentType)
api.response = SingleSubject.create()
viewModel.confirm()
assertNull(state().error)
assertEquals(List(2) { V2AuthVerifyRequest("test-receipt", true, ContentType.MALE) to "Bearer test-token" }, api.requests)
api.response.onSuccess(ApiResponse(false, null, "다음 실패"))
assertEquals(ToastMessage(message = "다음 실패"), viewModel.consumeError())
assertNull(viewModel.consumeError())
}
@Test
fun `POST 실패 메시지가 없거나 공백이면 공통 오류를 사용한다`() {
viewModel.begin("test-receipt", false)
listOf(null, " \t").forEach { message ->
api.response = SingleSubject.create()
viewModel.confirm()
api.response.onSuccess(ApiResponse(false, null, message))
assertEquals(ToastMessage(resId = R.string.common_error_unknown), viewModel.consumeError())
}
assertEquals(listOf("POST", "POST"), calls)
}
@Test
fun `POST 전송 오류는 요청 정보를 노출하지 않고 공통 오류와 편집 가능한 초안을 유지한다`() {
viewModel.begin("test-receipt", false)
viewModel.selectContentType(ContentType.FEMALE)
viewModel.confirm()
api.response.onError(IllegalStateException("private receipt and token transport detail"))
assertEquals(ToastMessage(resId = R.string.common_error_unknown), state().error)
assertEquals(V2AuthPhase.Failed, state().phase)
assertFalse(state().selectionLocked)
assertEquals(ContentType.FEMALE, state().contentType)
assertEquals(listOf("POST"), calls)
viewModel.toggleVisibility()
assertNull(state().error)
assertFalse(state().isAdultContentVisible)
assertEquals(ContentType.ALL, state().contentType)
}
@Test
fun `오디오는 POST 성공 후 회원 조회하며 조회 전에는 저장이나 완료가 없다`() {
beginAudio()
viewModel.confirm()
assertEquals(listOf("POST"), calls)
api.response.onSuccess(ApiResponse(true, AuthResponse(1)))
assertEquals(listOf("POST", "GET"), calls)
assertEquals(listOf("Bearer test-token"), memberHeaders)
assertEquals(V2AuthPhase.Syncing, state().phase)
assertTrue(state().selectionLocked)
assertFalse(viewModel.consumeCompletion())
viewModel.confirm()
viewModel.selectContentType(ContentType.MALE)
viewModel.toggleVisibility()
viewModel.begin("other-receipt", false)
assertEquals(ContentType.FEMALE, state().contentType)
assertTrue(state().isAdultContentVisible)
assertEquals(listOf("POST", "GET"), calls)
}
@Test
fun `오디오 회원 성공은 서버 false와 선호도를 그대로 저장한 뒤 완료를 알린다`() {
savedAuth = true
beginAudio()
viewModel.confirm()
api.response.onSuccess(ApiResponse(true, AuthResponse(2)))
val observer = Observer<V2AuthState> {
if (it.completionPending) {
assertFalse(savedAuth)
assertFalse(savedVisible)
assertEquals(1, savedPreference)
calls.add("completed")
}
}
viewModel.stateLiveData.observeForever(observer)
try {
memberResponse.onSuccess(ApiResponse(true, member(false, false, ContentType.MALE)))
assertEquals(
listOf("POST", "GET", "save-auth:false", "save-visible:false", "save-preference:1", "completed"),
calls
)
assertTrue(viewModel.consumeCompletion())
assertFalse(viewModel.consumeCompletion())
} finally {
viewModel.stateLiveData.removeObserver(observer)
}
}
@Test
fun `오디오 nullable 선호도는 기존 로컬값이나 성별 대신 제출값을 사용한다`() {
beginAudio()
viewModel.confirm()
api.response.onSuccess(ApiResponse(true, AuthResponse(1)))
memberResponse.onSuccess(ApiResponse(true, member(true, null, null)))
assertEquals(listOf("POST", "GET", "save-auth:true", "save-visible:true", "save-preference:2"), calls)
assertTrue(viewModel.consumeCompletion())
}
@Test
fun `오디오 nullable enum만 제출값으로 대체하고 서버 false 표시값은 보존한다`() {
beginAudio()
viewModel.confirm()
api.response.onSuccess(ApiResponse(true))
memberResponse.onSuccess(ApiResponse(true, member(false, false, null)))
assertFalse(savedVisible)
assertEquals(2, savedPreference)
assertFalse(savedAuth)
assertTrue(viewModel.consumeCompletion())
}
@Test
fun `오디오 nullable 표시값만 제출값으로 대체하고 서버 enum은 보존한다`() {
viewModel.begin("test-receipt", true)
viewModel.toggleVisibility()
viewModel.confirm()
api.response.onSuccess(ApiResponse(true))
memberResponse.onSuccess(ApiResponse(true, member(true, null, ContentType.MALE)))
assertFalse(savedVisible)
assertEquals(1, savedPreference)
assertTrue(savedAuth)
assertTrue(viewModel.consumeCompletion())
}
@Test
fun `오디오 POST 실패는 GET 없이 초안을 유지하고 POST만 재시도한다`() {
beginAudio()
viewModel.confirm()
api.response.onSuccess(ApiResponse(false, null, "인증 실패"))
assertEquals(listOf("POST"), calls)
assertFalse(state().selectionLocked)
api.response = SingleSubject.create()
viewModel.confirm()
assertEquals(listOf("POST", "POST"), calls)
api.response.onSuccess(ApiResponse(true))
assertEquals(listOf("POST", "POST", "GET"), calls)
}
@Test
fun `회원 조회 실패는 저장 없이 안내를 한 번 소비하고 잠긴 제출값으로 GET만 재시도한다`() {
beginAudio()
viewModel.confirm()
api.response.onSuccess(ApiResponse(true))
memberResponse.onSuccess(ApiResponse(false, member(true, true, ContentType.MALE), "회원 조회 실패"))
assertEquals(V2AuthPhase.Failed, state().phase)
assertTrue(state().selectionLocked)
assertEquals(ToastMessage(message = "회원 조회 실패"), viewModel.consumeError())
assertNull(viewModel.consumeError())
assertFalse(viewModel.consumeCompletion())
assertEquals(listOf("POST", "GET"), calls)
viewModel.toggleVisibility()
viewModel.selectContentType(ContentType.MALE)
viewModel.begin("other-receipt", false)
assertTrue(state().isAdultContentVisible)
assertEquals(ContentType.FEMALE, state().contentType)
memberResponse = SingleSubject.create()
every { SharedPreferenceManager.token } returns "retry-test-token"
viewModel.confirm()
viewModel.confirm()
assertEquals(V2AuthPhase.Syncing, state().phase)
assertNull(state().error)
assertEquals(listOf("POST", "GET", "GET"), calls)
assertEquals(listOf("Bearer test-token", "Bearer retry-test-token"), memberHeaders)
assertEquals(1, api.requests.size)
memberResponse.onSuccess(ApiResponse(true, member(false, null, null)))
assertEquals(listOf("POST", "GET", "GET", "save-auth:false", "save-visible:true", "save-preference:2"), calls)
assertTrue(viewModel.consumeCompletion())
viewModel.confirm()
assertEquals(1, api.requests.size)
assertEquals(2, memberHeaders.size)
}
@Test
fun `회원 조회 전송 오류는 공통 오류를 사용하고 잠금을 유지하며 다음 확인에서 오류를 지운다`() {
beginAudio()
viewModel.confirm()
api.response.onSuccess(ApiResponse(true))
memberResponse.onError(IllegalStateException("private member request detail"))
assertEquals(ToastMessage(resId = R.string.common_error_unknown), state().error)
assertTrue(state().selectionLocked)
assertEquals(listOf("POST", "GET"), calls)
memberResponse = SingleSubject.create()
viewModel.confirm()
assertNull(state().error)
assertEquals(listOf("POST", "GET", "GET"), calls)
}
@Test
fun `회원 조회 성공 데이터 누락은 완료하지 않고 저장 없이 공통 오류로 실패한다`() {
beginAudio()
viewModel.confirm()
api.response.onSuccess(ApiResponse(true))
memberResponse.onSuccess(ApiResponse(true))
assertEquals(V2AuthPhase.Failed, state().phase)
assertTrue(state().selectionLocked)
assertEquals(ToastMessage(resId = R.string.common_error_unknown), state().error)
assertEquals(listOf("POST", "GET"), calls)
assertFalse(viewModel.consumeCompletion())
}
@Test
fun `ViewModel 해제는 대기 중 POST를 구독 해제하고 늦은 성공을 저장하거나 완료하지 않는다`() {
viewModel.begin("test-receipt", false)
viewModel.confirm()
assertTrue(api.response.hasObservers())
store.clear()
assertTrue(viewModel.compositeDisposable.isDisposed)
assertFalse(api.response.hasObservers())
api.response.onSuccess(ApiResponse(true))
assertEquals(listOf("POST"), calls)
assertFalse(viewModel.consumeCompletion())
assertNull(viewModel.consumeError())
}
@Test
fun `ViewModel 해제는 대기 중 GET을 구독 해제하고 늦은 성공을 저장하거나 완료하지 않는다`() {
beginAudio()
viewModel.confirm()
api.response.onSuccess(ApiResponse(true))
assertTrue(memberResponse.hasObservers())
store.clear()
assertFalse(memberResponse.hasObservers())
memberResponse.onSuccess(ApiResponse(true, member(true, true, ContentType.MALE)))
assertEquals(listOf("POST", "GET"), calls)
assertFalse(viewModel.consumeCompletion())
assertNull(viewModel.consumeError())
}
private fun state(): V2AuthState = requireNotNull(viewModel.stateLiveData.value)
private fun beginAudio() {
viewModel.begin("test-receipt", true)
viewModel.selectContentType(ContentType.FEMALE)
}
private fun member(isAuth: Boolean, visible: Boolean?, type: ContentType?) = GetMemberInfoResponse(
can = 10,
point = 20,
isAuth = isAuth,
gender = "MALE",
signupDate = "2026-10-12",
chargeCount = 0,
role = MemberRole.USER,
messageNotice = true,
followingChannelLiveNotice = true,
followingChannelUploadContentNotice = true,
auditionNotice = false,
countryCode = "KR",
isAdultContentVisible = visible,
contentType = type
)
private class FakeAuthApi(private val calls: MutableList<String>) : V2AuthApi {
val requests = mutableListOf<Pair<V2AuthVerifyRequest, String>>()
var response = SingleSubject.create<ApiResponse<AuthResponse>>()
override fun verify(request: V2AuthVerifyRequest, authHeader: String): Single<ApiResponse<AuthResponse>> = Single.defer {
requests.add(request to authHeader)
calls.add("POST")
response
}
}
}