diff --git a/app/src/main/java/kr/co/vividnext/sodalive/v2/auth/V2AuthApi.kt b/app/src/main/java/kr/co/vividnext/sodalive/v2/auth/V2AuthApi.kt new file mode 100644 index 00000000..b666d023 --- /dev/null +++ b/app/src/main/java/kr/co/vividnext/sodalive/v2/auth/V2AuthApi.kt @@ -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> +} diff --git a/app/src/main/java/kr/co/vividnext/sodalive/v2/auth/V2AuthVerifyRequest.kt b/app/src/main/java/kr/co/vividnext/sodalive/v2/auth/V2AuthVerifyRequest.kt new file mode 100644 index 00000000..c59a508a --- /dev/null +++ b/app/src/main/java/kr/co/vividnext/sodalive/v2/auth/V2AuthVerifyRequest.kt @@ -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 +) diff --git a/app/src/main/java/kr/co/vividnext/sodalive/v2/auth/V2AuthViewModel.kt b/app/src/main/java/kr/co/vividnext/sodalive/v2/auth/V2AuthViewModel.kt new file mode 100644 index 00000000..e20e943a --- /dev/null +++ b/app/src/main/java/kr/co/vividnext/sodalive/v2/auth/V2AuthViewModel.kt @@ -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 = 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}" +} diff --git a/app/src/test/java/kr/co/vividnext/sodalive/v2/auth/V2AuthVerifyRequestTest.kt b/app/src/test/java/kr/co/vividnext/sodalive/v2/auth/V2AuthVerifyRequestTest.kt new file mode 100644 index 00000000..db855d8b --- /dev/null +++ b/app/src/test/java/kr/co/vividnext/sodalive/v2/auth/V2AuthVerifyRequestTest.kt @@ -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() + 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)) + } +} diff --git a/app/src/test/java/kr/co/vividnext/sodalive/v2/auth/V2AuthViewModelTest.kt b/app/src/test/java/kr/co/vividnext/sodalive/v2/auth/V2AuthViewModelTest.kt new file mode 100644 index 00000000..73500143 --- /dev/null +++ b/app/src/test/java/kr/co/vividnext/sodalive/v2/auth/V2AuthViewModelTest.kt @@ -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() + private val memberHeaders = mutableListOf() + private var memberResponse = SingleSubject.create>() + 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() + every { userApi.getMemberInfo(any()) } answers { + val header = firstArg() + 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 { + 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 { + 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) : V2AuthApi { + val requests = mutableListOf>() + var response = SingleSubject.create>() + + override fun verify(request: V2AuthVerifyRequest, authHeader: String): Single> = Single.defer { + requests.add(request to authHeader) + calls.add("POST") + response + } + } +}