From 35adab4b23d5d6ed6af6ac574cb9745d86448a62 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EC=9D=BC=ED=98=81?= Date: Thu, 28 May 2026 22:07:54 +0900 Subject: [PATCH 1/3] =?UTF-8?q?test:=20LoginUseCase=20=EB=8B=A8=EC=9C=84?= =?UTF-8?q?=20=ED=85=8C=EC=8A=A4=ED=8A=B8=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - `LoginUseCase`의 비즈니스 로직 검증을 위한 `LoginUseCaseTest` 클래스 추가 - 로그인 타입(Email, Kakao, Google)에 따른 올바른 Repository 메서드 호출 여부 검증 - 로그인 성공 시 반환된 토큰의 세션 저장 로직 및 신규 가입자 여부(`isNewUser`) 반환 확인 - 로그인 실패 시 세션 저장을 생략하고 에러를 즉시 반환하는 단락 평가(short-circuit) 로직 검증 - 외부 라이브러리(MockK 등) 없이 직접 구현한 `FakeAuthRepository`를 사용하여 테스트 수행 --- .../domain/usecase/auth/LoginUseCaseTest.kt | 176 ++++++++++++++++++ 1 file changed, 176 insertions(+) create mode 100644 core/domain/src/test/java/com/afternote/core/domain/usecase/auth/LoginUseCaseTest.kt diff --git a/core/domain/src/test/java/com/afternote/core/domain/usecase/auth/LoginUseCaseTest.kt b/core/domain/src/test/java/com/afternote/core/domain/usecase/auth/LoginUseCaseTest.kt new file mode 100644 index 00000000..ef08bfef --- /dev/null +++ b/core/domain/src/test/java/com/afternote/core/domain/usecase/auth/LoginUseCaseTest.kt @@ -0,0 +1,176 @@ +package com.afternote.core.domain.usecase.auth + +import com.afternote.core.domain.repository.auth.AuthRepository +import com.afternote.core.model.Session +import com.afternote.core.model.TokenBundle +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.flowOf +import kotlinx.coroutines.runBlocking +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNull +import org.junit.Assert.assertSame +import org.junit.Assert.assertTrue +import org.junit.Test + +/** + * [LoginUseCase] 비즈니스 로직 회귀 가드. + * + * 검증 핵심: + * 1. 로그인 타입(Email/Kakao/Google)에 맞는 [AuthRepository] 메서드로 분기하는지 + * 2. 로그인 성공 시 받은 세션 토큰을 그대로 [AuthRepository.saveSession]에 전달하는지 + * 3. 로그인 실패면 **saveSession을 호출하지 않고** 그 실패를 그대로 반환(short-circuit)하는지 + * 4. saveSession 실패면 그 실패를 반환하는지 + * 5. 반환값(신규 가입자 여부) — 소셜 `newUser=true` 만 true, 이메일·기존(false)·null 은 false + * + * 외부 라이브러리(mockk 등) 없이 호출 인자/횟수를 기록하는 직접 작성 fake를 사용한다. + */ +class LoginUseCaseTest { + @Test + fun `Email 로그인 성공 - defaultLogin 호출 후 세션 토큰으로 saveSession`() { + val repo = + FakeAuthRepository().apply { + defaultLoginResult = Result.success(Session.DefaultSession(accessToken = "AT", refreshToken = "RT")) + } + val result = runBlocking { LoginUseCase(repo)(LoginType.Email(email = "a@b.com", password = "pw")) } + + assertTrue(result.isSuccess) + assertFalse(result.getOrThrow()) // 이메일 로그인 = 기존 유저(false) + assertEquals("a@b.com" to "pw", repo.defaultLoginArgs) + assertEquals("AT" to "RT", repo.saveSessionArgs) + assertEquals(1, repo.saveSessionCallCount) + } + + @Test + fun `Kakao 로그인 성공 - kakaoLogin 호출 + saveSession`() { + val repo = + FakeAuthRepository().apply { + kakaoResult = + Result.success(Session.SocialSession(accessToken = "KAT", refreshToken = "KRT", isNewUser = true)) + } + val result = runBlocking { LoginUseCase(repo)(LoginType.Kakao(oauthToken = "kakao-token")) } + + assertTrue(result.isSuccess) + assertTrue(result.getOrThrow()) // isNewUser=true → 신규 + assertEquals("kakao-token", repo.kakaoArg) + assertEquals("KAT" to "KRT", repo.saveSessionArgs) + } + + @Test + fun `Google 로그인 성공 - googleLogin 호출 + saveSession`() { + val repo = + FakeAuthRepository().apply { + googleResult = + Result.success(Session.SocialSession(accessToken = "GAT", refreshToken = "GRT", isNewUser = false)) + } + val result = runBlocking { LoginUseCase(repo)(LoginType.Google(idToken = "google-id-token")) } + + assertTrue(result.isSuccess) + assertFalse(result.getOrThrow()) // isNewUser=false → 기존 + assertEquals("google-id-token", repo.googleArg) + assertEquals("GAT" to "GRT", repo.saveSessionArgs) + } + + @Test + fun `소셜 로그인 - isNewUser null 이면 false (기존 유저 취급)`() { + val repo = + FakeAuthRepository().apply { + kakaoResult = + Result.success(Session.SocialSession(accessToken = "KAT", refreshToken = "KRT", isNewUser = null)) + } + val result = runBlocking { LoginUseCase(repo)(LoginType.Kakao(oauthToken = "kakao-token")) } + + assertTrue(result.isSuccess) + assertFalse(result.getOrThrow()) // null → false (`== true` 가 null 흡수) + } + + @Test + fun `로그인 실패면 saveSession 호출하지 않고 실패를 그대로 반환`() { + val loginError = IllegalStateException("login failed") + val repo = + FakeAuthRepository().apply { + defaultLoginResult = Result.failure(loginError) + } + val result = runBlocking { LoginUseCase(repo)(LoginType.Email(email = "a@b.com", password = "pw")) } + + assertTrue(result.isFailure) + assertSame(loginError, result.exceptionOrNull()) + assertEquals(0, repo.saveSessionCallCount) + assertNull(repo.saveSessionArgs) + } + + @Test + fun `saveSession 실패면 그 실패를 반환`() { + val saveError = IllegalStateException("save failed") + val repo = + FakeAuthRepository().apply { + defaultLoginResult = Result.success(Session.DefaultSession(accessToken = "AT", refreshToken = "RT")) + saveSessionResult = Result.failure(saveError) + } + val result = runBlocking { LoginUseCase(repo)(LoginType.Email(email = "a@b.com", password = "pw")) } + + assertFalse(result.isSuccess) + assertSame(saveError, result.exceptionOrNull()) + assertEquals(1, repo.saveSessionCallCount) + } + + private class FakeAuthRepository : AuthRepository { + var defaultLoginArgs: Pair? = null + var kakaoArg: String? = null + var googleArg: String? = null + var saveSessionArgs: Pair? = null + var saveSessionCallCount = 0 + + var defaultLoginResult: Result = + Result.success(Session.DefaultSession(accessToken = "at", refreshToken = "rt")) + var kakaoResult: Result = + Result.success(Session.SocialSession(accessToken = "at", refreshToken = "rt", isNewUser = false)) + var googleResult: Result = + Result.success(Session.SocialSession(accessToken = "at", refreshToken = "rt", isNewUser = false)) + var saveSessionResult: Result = Result.success(Unit) + + override val isLoggedIn: Flow = flowOf(false) + + override suspend fun saveSession( + accessToken: String, + refreshToken: String, + ): Result { + saveSessionCallCount++ + saveSessionArgs = accessToken to refreshToken + return saveSessionResult + } + + override suspend fun updateTokens( + accessToken: String, + refreshToken: String, + ): Result = Result.success(Unit) + + override suspend fun clearSession(): Result = Result.success(Unit) + + override suspend fun getAccessToken(): Result = Result.success(null) + + override suspend fun getRefreshToken(): Result = Result.success(null) + + override suspend fun defaultLogin( + email: String, + password: String, + ): Result { + defaultLoginArgs = email to password + return defaultLoginResult + } + + override suspend fun kakaoLogin(oauthToken: String): Result { + kakaoArg = oauthToken + return kakaoResult + } + + override suspend fun googleLogin(idToken: String): Result { + googleArg = idToken + return googleResult + } + + override suspend fun rotateToken(): Result = Result.success(TokenBundle(accessToken = "at", refreshToken = "rt")) + + override suspend fun logout(): Result = Result.success(Unit) + } +} From be11b754cc6d6d748cac224a31459b04954ab375 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EC=9D=BC=ED=98=81?= Date: Wed, 3 Jun 2026 16:13:23 +0900 Subject: [PATCH 2/3] =?UTF-8?q?test:=20ResolveMemorialMediaForSaveUseCase?= =?UTF-8?q?=20=EB=8B=A8=EC=9C=84=20=ED=85=8C=EC=8A=A4=ED=8A=B8=20=EC=B6=94?= =?UTF-8?q?=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - `ResolveMemorialMediaForSaveUseCase`의 비즈니스 로직 및 예외 처리 시나리오 검증을 위한 테스트 클래스 생성 - 영상 및 사진의 업로드 결과(`VideoUploadOutcome`, `PhotoUploadOutcome`)에 따른 URL 매핑 로직(Empty, Existing, FreshlyUploaded) 확인 - 영상 처리 실패 시 `MemorialVideoSaveException`으로 래핑하고 사진 처리 로직을 실행하지 않는 Short-circuit 로직 검증 - 사진 처리 실패 시 `MemorialPhotoSaveException`으로 래핑 및 원본 예외(`cause`) 보존 여부 확인 - 외부 라이브러리(mockk 등) 없이 직접 구현한 Fake Repository를 사용하여 호출 인자 및 횟수 검증 --- .../ResolveMemorialMediaForSaveUseCaseTest.kt | 151 ++++++++++++++++++ 1 file changed, 151 insertions(+) create mode 100644 feature/afternote/domain/src/test/java/com/afternote/feature/afternote/domain/usecase/editor/ResolveMemorialMediaForSaveUseCaseTest.kt diff --git a/feature/afternote/domain/src/test/java/com/afternote/feature/afternote/domain/usecase/editor/ResolveMemorialMediaForSaveUseCaseTest.kt b/feature/afternote/domain/src/test/java/com/afternote/feature/afternote/domain/usecase/editor/ResolveMemorialMediaForSaveUseCaseTest.kt new file mode 100644 index 00000000..d6aee8c0 --- /dev/null +++ b/feature/afternote/domain/src/test/java/com/afternote/feature/afternote/domain/usecase/editor/ResolveMemorialMediaForSaveUseCaseTest.kt @@ -0,0 +1,151 @@ +package com.afternote.feature.afternote.domain.usecase.editor + +import com.afternote.feature.afternote.domain.repository.author.MemorialPhotoUploadRepository +import com.afternote.feature.afternote.domain.repository.author.MemorialVideoUploadRepository +import com.afternote.feature.afternote.domain.repository.author.PhotoUploadOutcome +import com.afternote.feature.afternote.domain.repository.author.VideoUploadOutcome +import kotlinx.coroutines.runBlocking +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull +import org.junit.Assert.assertSame +import org.junit.Assert.assertTrue +import org.junit.Test + +/** + * [ResolveMemorialMediaForSaveUseCase] 비즈니스 로직 회귀 가드. + * + * 검증 핵심: + * 1. 입력 인자를 각 Repository 에 그대로 전달하는지 (영상=URL 1개, 사진=existingUrl/pickedUri 2개) + * 2. sealed [VideoUploadOutcome]/[PhotoUploadOutcome] 분기를 저장 페이로드 URL 로 매핑하는지 + * (Empty→null, Existing→url, FreshlyUploaded→url) + * 3. 영상 resolve 실패면 [MemorialVideoSaveException] 으로 wrap 하고 **사진 Repository 는 호출하지 않은 채** + * short-circuit 하는지 (non-local return) + * 4. 사진 resolve 실패면 [MemorialPhotoSaveException] 으로 wrap 하고, 두 경우 모두 원본 예외를 cause 로 보존하는지 + * + * 외부 라이브러리(mockk 등) 없이 호출 인자/횟수를 기록하는 직접 작성 fake를 사용한다. + */ +class ResolveMemorialMediaForSaveUseCaseTest { + @Test + fun `영상-사진 모두 성공 - FreshlyUploaded 영상과 Existing 사진을 각 URL 로 매핑`() { + val videoRepo = FakeVideoUploadRepository().apply { result = Result.success(VideoUploadOutcome.FreshlyUploaded("v-url")) } + val photoRepo = FakePhotoUploadRepository().apply { result = Result.success(PhotoUploadOutcome.Existing("p-url")) } + + val result = + runBlocking { + ResolveMemorialMediaForSaveUseCase(videoRepo, photoRepo)( + funeralVideoUrl = "content://video", + memorialPhotoUrl = "https://cdn/photo.jpg", + pickedMemorialPhotoUri = null, + ) + } + + assertTrue(result.isSuccess) + assertEquals("v-url", result.getOrThrow().resolvedVideoUrl) + assertEquals("p-url", result.getOrThrow().resolvedMemorialPhotoUrl) + } + + @Test + fun `Empty Outcome 은 null 로 매핑 - 미첨부`() { + val videoRepo = FakeVideoUploadRepository().apply { result = Result.success(VideoUploadOutcome.Empty) } + val photoRepo = FakePhotoUploadRepository().apply { result = Result.success(PhotoUploadOutcome.Empty) } + + val resolved = + runBlocking { + ResolveMemorialMediaForSaveUseCase(videoRepo, photoRepo)(null, null, null) + }.getOrThrow() + + assertNull(resolved.resolvedVideoUrl) + assertNull(resolved.resolvedMemorialPhotoUrl) + } + + @Test + fun `Existing 영상과 FreshlyUploaded 사진도 각 URL 로 매핑`() { + val videoRepo = FakeVideoUploadRepository().apply { result = Result.success(VideoUploadOutcome.Existing("existing-v")) } + val photoRepo = FakePhotoUploadRepository().apply { result = Result.success(PhotoUploadOutcome.FreshlyUploaded("fresh-p")) } + + val resolved = + runBlocking { + ResolveMemorialMediaForSaveUseCase(videoRepo, photoRepo)(null, null, null) + }.getOrThrow() + + assertEquals("existing-v", resolved.resolvedVideoUrl) + assertEquals("fresh-p", resolved.resolvedMemorialPhotoUrl) + } + + @Test + fun `입력 인자를 각 Repository 에 그대로 전달`() { + val videoRepo = FakeVideoUploadRepository() + val photoRepo = FakePhotoUploadRepository() + + runBlocking { + ResolveMemorialMediaForSaveUseCase(videoRepo, photoRepo)( + funeralVideoUrl = "fv", + memorialPhotoUrl = "mp", + pickedMemorialPhotoUri = "pick", + ) + } + + assertEquals("fv", videoRepo.resolveVideoArg) + assertEquals("mp" to "pick", photoRepo.resolvePhotoArgs) + } + + @Test + fun `영상 resolve 실패면 MemorialVideoSaveException 으로 wrap 하고 사진 Repository 는 호출하지 않음`() { + val videoError = IllegalStateException("video resolve failed") + val videoRepo = FakeVideoUploadRepository().apply { result = Result.failure(videoError) } + val photoRepo = FakePhotoUploadRepository() + + val result = + runBlocking { + ResolveMemorialMediaForSaveUseCase(videoRepo, photoRepo)("v", "p", null) + } + + assertTrue(result.isFailure) + assertTrue(result.exceptionOrNull() is MemorialVideoSaveException) + assertSame(videoError, result.exceptionOrNull()?.cause) // 원본 예외를 cause 로 보존 + assertEquals(0, photoRepo.callCount) // short-circuit — 사진 Repository 미호출 + } + + @Test + fun `사진 resolve 실패면 MemorialPhotoSaveException 으로 wrap`() { + val photoError = IllegalStateException("photo resolve failed") + val videoRepo = FakeVideoUploadRepository().apply { result = Result.success(VideoUploadOutcome.Empty) } + val photoRepo = FakePhotoUploadRepository().apply { result = Result.failure(photoError) } + + val result = + runBlocking { + ResolveMemorialMediaForSaveUseCase(videoRepo, photoRepo)("v", "p", null) + } + + assertTrue(result.isFailure) + assertTrue(result.exceptionOrNull() is MemorialPhotoSaveException) + assertSame(photoError, result.exceptionOrNull()?.cause) + } + + private class FakeVideoUploadRepository : MemorialVideoUploadRepository { + var resolveVideoArg: String? = null + var callCount = 0 + var result: Result = Result.success(VideoUploadOutcome.Empty) + + override suspend fun resolveVideo(input: String?): Result { + callCount++ + resolveVideoArg = input + return result + } + } + + private class FakePhotoUploadRepository : MemorialPhotoUploadRepository { + var resolvePhotoArgs: Pair? = null + var callCount = 0 + var result: Result = Result.success(PhotoUploadOutcome.Empty) + + override suspend fun resolvePhoto( + existingUrl: String?, + pickedUri: String?, + ): Result { + callCount++ + resolvePhotoArgs = existingUrl to pickedUri + return result + } + } +} From e453fdf5fde2b66578c57f30bfcb575ae020c5bc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EC=9D=BC=ED=98=81?= Date: Wed, 3 Jun 2026 17:10:06 +0900 Subject: [PATCH 3/3] =?UTF-8?q?refactor:=20ResolveMemorialMediaForSaveUseC?= =?UTF-8?q?ase=20=EC=9E=85=EB=A0=A5=20=ED=8C=8C=EB=9D=BC=EB=AF=B8=ED=84=B0?= =?UTF-8?q?=20=EA=B5=AC=EC=A1=B0=20=EA=B0=9C=EC=84=A0=20=EB=B0=8F=20MediaI?= =?UTF-8?q?nput=20=EC=A0=81=EC=9A=A9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 기존 개별 URL 및 URI 파라미터를 `MediaInput`(Local, Remote, None) 타입으로 통합하여 UseCase 인터페이스 단순화 - `MemorialVideoUploadRepository` 및 `MemorialPhotoUploadRepository`가 `MediaInput`을 직접 수신하도록 변경 - 인터페이스 변경에 따라 테스트용 `Fake` 저장소 및 `ResolveMemorialMediaForSaveUseCaseTest` 코드 마이그레이션 - 미디어 소스(로컬/원격) 판별 책임 소재 변경에 따른 테스트 주석 및 검증 로직 업데이트 --- .../ResolveMemorialMediaForSaveUseCaseTest.kt | 46 +++++++++---------- 1 file changed, 22 insertions(+), 24 deletions(-) diff --git a/feature/afternote/domain/src/test/java/com/afternote/feature/afternote/domain/usecase/editor/ResolveMemorialMediaForSaveUseCaseTest.kt b/feature/afternote/domain/src/test/java/com/afternote/feature/afternote/domain/usecase/editor/ResolveMemorialMediaForSaveUseCaseTest.kt index d6aee8c0..306a07cf 100644 --- a/feature/afternote/domain/src/test/java/com/afternote/feature/afternote/domain/usecase/editor/ResolveMemorialMediaForSaveUseCaseTest.kt +++ b/feature/afternote/domain/src/test/java/com/afternote/feature/afternote/domain/usecase/editor/ResolveMemorialMediaForSaveUseCaseTest.kt @@ -1,5 +1,6 @@ package com.afternote.feature.afternote.domain.usecase.editor +import com.afternote.feature.afternote.domain.repository.author.MediaInput import com.afternote.feature.afternote.domain.repository.author.MemorialPhotoUploadRepository import com.afternote.feature.afternote.domain.repository.author.MemorialVideoUploadRepository import com.afternote.feature.afternote.domain.repository.author.PhotoUploadOutcome @@ -15,7 +16,7 @@ import org.junit.Test * [ResolveMemorialMediaForSaveUseCase] 비즈니스 로직 회귀 가드. * * 검증 핵심: - * 1. 입력 인자를 각 Repository 에 그대로 전달하는지 (영상=URL 1개, 사진=existingUrl/pickedUri 2개) + * 1. 입력 [MediaInput] 을 각 Repository 에 그대로 전달하는지 (로컬/원격 확정은 호출부 책임) * 2. sealed [VideoUploadOutcome]/[PhotoUploadOutcome] 분기를 저장 페이로드 URL 로 매핑하는지 * (Empty→null, Existing→url, FreshlyUploaded→url) * 3. 영상 resolve 실패면 [MemorialVideoSaveException] 으로 wrap 하고 **사진 Repository 는 호출하지 않은 채** @@ -33,9 +34,8 @@ class ResolveMemorialMediaForSaveUseCaseTest { val result = runBlocking { ResolveMemorialMediaForSaveUseCase(videoRepo, photoRepo)( - funeralVideoUrl = "content://video", - memorialPhotoUrl = "https://cdn/photo.jpg", - pickedMemorialPhotoUri = null, + video = MediaInput.Local("content://video"), + photo = MediaInput.Remote("https://cdn/photo.jpg"), ) } @@ -51,7 +51,7 @@ class ResolveMemorialMediaForSaveUseCaseTest { val resolved = runBlocking { - ResolveMemorialMediaForSaveUseCase(videoRepo, photoRepo)(null, null, null) + ResolveMemorialMediaForSaveUseCase(videoRepo, photoRepo)(MediaInput.None, MediaInput.None) }.getOrThrow() assertNull(resolved.resolvedVideoUrl) @@ -65,7 +65,10 @@ class ResolveMemorialMediaForSaveUseCaseTest { val resolved = runBlocking { - ResolveMemorialMediaForSaveUseCase(videoRepo, photoRepo)(null, null, null) + ResolveMemorialMediaForSaveUseCase(videoRepo, photoRepo)( + video = MediaInput.Remote("https://cdn/existing-v.mp4"), + photo = MediaInput.Local("content://fresh-photo"), + ) }.getOrThrow() assertEquals("existing-v", resolved.resolvedVideoUrl) @@ -73,20 +76,18 @@ class ResolveMemorialMediaForSaveUseCaseTest { } @Test - fun `입력 인자를 각 Repository 에 그대로 전달`() { + fun `입력 MediaInput 을 각 Repository 에 그대로 전달`() { val videoRepo = FakeVideoUploadRepository() val photoRepo = FakePhotoUploadRepository() + val videoInput = MediaInput.Local("content://fv") + val photoInput = MediaInput.Remote("https://cdn/mp.jpg") runBlocking { - ResolveMemorialMediaForSaveUseCase(videoRepo, photoRepo)( - funeralVideoUrl = "fv", - memorialPhotoUrl = "mp", - pickedMemorialPhotoUri = "pick", - ) + ResolveMemorialMediaForSaveUseCase(videoRepo, photoRepo)(videoInput, photoInput) } - assertEquals("fv", videoRepo.resolveVideoArg) - assertEquals("mp" to "pick", photoRepo.resolvePhotoArgs) + assertEquals(videoInput, videoRepo.resolveVideoArg) + assertEquals(photoInput, photoRepo.resolvePhotoArg) } @Test @@ -97,7 +98,7 @@ class ResolveMemorialMediaForSaveUseCaseTest { val result = runBlocking { - ResolveMemorialMediaForSaveUseCase(videoRepo, photoRepo)("v", "p", null) + ResolveMemorialMediaForSaveUseCase(videoRepo, photoRepo)(MediaInput.Local("content://v"), MediaInput.None) } assertTrue(result.isFailure) @@ -114,7 +115,7 @@ class ResolveMemorialMediaForSaveUseCaseTest { val result = runBlocking { - ResolveMemorialMediaForSaveUseCase(videoRepo, photoRepo)("v", "p", null) + ResolveMemorialMediaForSaveUseCase(videoRepo, photoRepo)(MediaInput.None, MediaInput.Remote("https://cdn/p.jpg")) } assertTrue(result.isFailure) @@ -123,11 +124,11 @@ class ResolveMemorialMediaForSaveUseCaseTest { } private class FakeVideoUploadRepository : MemorialVideoUploadRepository { - var resolveVideoArg: String? = null + var resolveVideoArg: MediaInput? = null var callCount = 0 var result: Result = Result.success(VideoUploadOutcome.Empty) - override suspend fun resolveVideo(input: String?): Result { + override suspend fun resolveVideo(input: MediaInput): Result { callCount++ resolveVideoArg = input return result @@ -135,16 +136,13 @@ class ResolveMemorialMediaForSaveUseCaseTest { } private class FakePhotoUploadRepository : MemorialPhotoUploadRepository { - var resolvePhotoArgs: Pair? = null + var resolvePhotoArg: MediaInput? = null var callCount = 0 var result: Result = Result.success(PhotoUploadOutcome.Empty) - override suspend fun resolvePhoto( - existingUrl: String?, - pickedUri: String?, - ): Result { + override suspend fun resolvePhoto(input: MediaInput): Result { callCount++ - resolvePhotoArgs = existingUrl to pickedUri + resolvePhotoArg = input return result } }