Feat: AuthTokenSerializer 추가 및 테스트 코드 작성

- AuthTokenSerializer 클래스 추가
- TokenSerializer 인터페이스 추가
- AuthTokenSerializer 테스트 코드 작성

Author: wjdrjs00

core/datastore/build.gradle.kts

@@ -9,6 +9,11 @@ android {
 }
 
 dependencies {
+    implementation(projects.core.security)
+
     implementation(libs.androidx.datastore.preferences)
     implementation(libs.kotlinx.serialization.json)
+
+    testImplementation(libs.androidx.junit)
+    testImplementation(libs.kotlin.coroutines.test)
 }

core/datastore/src/main/java/com/threegap/bitnagil/datastore/serializer/AuthTokenSerializer.kt

@@ -0,0 +1,50 @@
+package com.threegap.bitnagil.datastore.serializer
+
+import com.threegap.bitnagil.datastore.model.AuthToken
+import com.threegap.bitnagil.security.crypto.Crypto
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import kotlinx.serialization.json.Json
+import java.io.InputStream
+import java.io.OutputStream
+import java.util.Base64
+import javax.inject.Inject
+
+internal class AuthTokenSerializer
+    @Inject
+    constructor(
+        private val crypto: Crypto,
+    ) : TokenSerializer {
+        override val defaultValue: AuthToken
+            get() = AuthToken()
+
+        override suspend fun readFrom(input: InputStream): AuthToken {
+            return try {
+                val encryptedBytes =
+                    withContext(Dispatchers.IO) {
+                        input.use { it.readBytes() }
+                    }
+                val decodedBytes = Base64.getDecoder().decode(encryptedBytes)
+                val decryptedBytes = crypto.decrypt(decodedBytes)
+                val decodedJsonString = decryptedBytes.decodeToString()
+                Json.decodeFromString(decodedJsonString)
+            } catch (e: Exception) {
+                AuthToken()
+            }
+        }
+
+        override suspend fun writeTo(
+            t: AuthToken,
+            output: OutputStream,
+        ) {
+            val json = Json.encodeToString(t)
+            val bytes = json.toByteArray()
+            val encryptedBytes = crypto.encrypt(bytes)
+            val encryptedBytesBase64 = Base64.getEncoder().encode(encryptedBytes)
+            withContext(Dispatchers.IO) {
+                output.use {
+                    it.write(encryptedBytesBase64)
+                }
+            }
+        }
+    }

core/datastore/src/main/java/com/threegap/bitnagil/datastore/serializer/TokenSerializer.kt

@@ -0,0 +1,6 @@
+package com.threegap.bitnagil.datastore.serializer
+
+import androidx.datastore.core.Serializer
+import com.threegap.bitnagil.datastore.model.AuthToken
+
+interface TokenSerializer : Serializer<AuthToken>

core/datastore/src/test/java/com/threegap/bitnagil/datastore/serializer/AuthTokenSerializerTest.kt

@@ -0,0 +1,96 @@
+package com.threegap.bitnagil.datastore.serializer
+
+import com.threegap.bitnagil.datastore.model.AuthToken
+import com.threegap.bitnagil.security.crypto.Crypto
+import kotlinx.coroutines.test.runTest
+import kotlinx.serialization.json.Json
+import org.junit.Assert.assertEquals
+import org.junit.Before
+import org.junit.Test
+import java.io.ByteArrayInputStream
+import java.io.ByteArrayOutputStream
+import java.util.Base64
+
+class AuthTokenSerializerTest {
+    private lateinit var serializer: AuthTokenSerializer
+    private lateinit var crypto: FakeCrypto
+    private lateinit var fakeToken: AuthToken
+    private lateinit var encrypted: ByteArray
+    private lateinit var json: String
+
+    class FakeCrypto(
+        private val encryptResult: ByteArray,
+        private val decryptResult: ByteArray,
+        private val shouldFailDecrypt: Boolean = false,
+    ) : Crypto {
+        override fun encrypt(bytes: ByteArray): ByteArray = encryptResult
+
+        override fun decrypt(bytes: ByteArray): ByteArray {
+            if (shouldFailDecrypt) throw RuntimeException("복호화 실패")
+            return decryptResult
+        }
+    }
+
+    @Before
+    fun setUp() {
+        fakeToken = AuthToken("access", "refresh")
+        json = Json.encodeToString(fakeToken)
+        encrypted = "암호화된값".toByteArray()
+
+        crypto =
+            FakeCrypto(
+                encryptResult = encrypted,
+                decryptResult = json.toByteArray(),
+            )
+
+        serializer = AuthTokenSerializer(crypto)
+    }
+
+    @Test
+    fun `writeTo는 토큰을 암호화해서 저장한다`() =
+        runTest {
+            // given
+            val outputStream = ByteArrayOutputStream()
+
+            // when
+            serializer.writeTo(fakeToken, outputStream)
+
+            // then
+            val expected = Base64.getEncoder().encode(encrypted)
+            assertEquals(expected.toList(), outputStream.toByteArray().toList())
+        }
+
+    @Test
+    fun `readFrom은 암호화된 데이터를 복호화하여 토큰으로 변환한다`() =
+        runTest {
+            // given
+            val input = Base64.getEncoder().encode(encrypted)
+            val inputStream = ByteArrayInputStream(input)
+
+            // when
+            val result = serializer.readFrom(inputStream)
+
+            // then
+            assertEquals(fakeToken, result)
+        }
+
+    @Test
+    fun `readFrom에서 예외 발생시 기본값을 반환한다`() =
+        runTest {
+            // given
+            val brokenCrypto =
+                FakeCrypto(
+                    encryptResult = byteArrayOf(),
+                    decryptResult = byteArrayOf(),
+                    shouldFailDecrypt = true,
+                )
+            val brokenSerializer = AuthTokenSerializer(brokenCrypto)
+            val inputStream = ByteArrayInputStream(Base64.getEncoder().encode(encrypted))
+
+            // when
+            val result = brokenSerializer.readFrom(inputStream)
+
+            // then
+            assertEquals(AuthToken(), result)
+        }
+}