Merge pull request #45 from f-lab-edu/feature/recent-repository-test

Feature/recent repository test

core/data/src/test/kotlin/kr/co/data/repository/BookmarkRepositoryImplTest.kt

@@ -4,8 +4,10 @@ import io.mockk.MockKAnnotations
 import io.mockk.Runs
 import io.mockk.coEvery
 import io.mockk.coVerify
+import io.mockk.every
 import io.mockk.impl.annotations.MockK
 import io.mockk.just
+import io.mockk.verify
 import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.test.runTest
 import kr.co.data.mapper.BookmarkMapper
@@ -44,7 +46,7 @@ internal class BookmarkRepositoryImplTest {
         val file = PDF_DUMMY
         val bookmarkFile = BOOKMARK_DUMMY
 
-        coEvery { toBookmark(file) } returns bookmarkFile
+        every { toBookmark(file) } returns bookmarkFile
         coEvery { dao.insert(bookmarkFile) } just Runs
 
         repository.insert(file)
@@ -57,22 +59,22 @@ internal class BookmarkRepositoryImplTest {
         val bookmarkFiles = listOf(BOOKMARK_DUMMY)
         val files = listOf(PDF_DUMMY)
 
-        coEvery { dao.get() } returns flowOf(bookmarkFiles)
-        coEvery { toFileInfo(BOOKMARK_DUMMY) } returns PDF_DUMMY
+        every { dao.get() } returns flowOf(bookmarkFiles)
+        every { toFileInfo(BOOKMARK_DUMMY) } returns PDF_DUMMY
 
         repository.get().testWithItem {
             assertEquals(files, this)
         }
 
-        coVerify { dao.get() }
+        verify { dao.get() }
     }
 
     @Test
     fun `Given a file when delete is called then dao delete is called`() = runTest {
         val file = PDF_DUMMY
         val bookmarkFile = BOOKMARK_DUMMY
 
-        coEvery { toBookmark(file) } returns bookmarkFile
+        every { toBookmark(file) } returns bookmarkFile
         coEvery { dao.delete(bookmarkFile) } just Runs
 
         repository.delete(file)

core/data/src/test/kotlin/kr/co/data/repository/RecentRepositoryImplTest.kt

@@ -0,0 +1,104 @@
+package kr.co.data.repository
+
+import io.mockk.MockKAnnotations
+import io.mockk.coEvery
+import io.mockk.coVerify
+import io.mockk.every
+import io.mockk.impl.annotations.MockK
+import io.mockk.verify
+import junit.framework.TestCase.assertEquals
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.test.runTest
+import kr.co.data.mapper.FileInfoMapper
+import kr.co.data.mapper.RecentFileMapper
+import kr.co.database.dao.RecentFileDao
+import kr.co.database.model.FileType
+import kr.co.database.model.RecentFile
+import kr.co.model.FileInfo
+import kr.co.testing.util.testWithItem
+import org.junit.Before
+import org.junit.Test
+import java.time.LocalDateTime
+
+internal class RecentRepositoryImplTest {
+
+    @MockK
+    private lateinit var dao: RecentFileDao
+
+    @MockK
+    private lateinit var toRecent: RecentFileMapper
+
+    @MockK
+    private lateinit var toFileInfo: FileInfoMapper
+
+    private lateinit var repository: RecentRepository
+
+    @Before
+    fun setup() {
+        MockKAnnotations.init(this)
+        repository = RecentRepositoryImpl(dao, toRecent, toFileInfo)
+    }
+
+    @Test
+    fun `Given a file when insert is called then dao insert is called`() = runTest {
+        val file = PDF_DUMMY
+        val recentFile = RECENT_DUMMY
+
+        every { toRecent(file) } returns recentFile
+        coEvery { dao.insert(recentFile) } returns Unit
+
+        repository.insert(file)
+
+        coVerify { dao.insert(recentFile) }
+    }
+
+    @Test
+    fun `Given a unit when get is called then dao get is called`() = runTest {
+        val recentFiles = listOf(RECENT_DUMMY)
+        val files = listOf(PDF_DUMMY)
+
+        every { toFileInfo(RECENT_DUMMY) } returns PDF_DUMMY
+        every { dao.get() } returns flowOf(recentFiles)
+
+        repository.get().testWithItem {
+            assertEquals(files, this)
+        }
+
+        verify { dao.get() }
+    }
+
+    @Test
+    fun `Given a file when delete is called then dao delete is called`() = runTest {
+        val file = PDF_DUMMY
+        val recentFile = RECENT_DUMMY
+
+        every { toRecent(file) } returns recentFile
+        coEvery { dao.delete(recentFile) } returns Unit
+
+        repository.delete(file)
+
+        coVerify { dao.delete(recentFile) }
+    }
+
+    private companion object {
+        val PDF_DUMMY = FileInfo(
+            name = "DUMMY.pdf",
+            path = "",
+            type = FileInfo.Type.PDF,
+            isDirectory = false,
+            isHidden = false,
+            size = 0,
+            createdAt = LocalDateTime.of(2024,6,2,2,0),
+            lastModified = LocalDateTime.of(2024,6,2,2,0)
+        )
+
+        val RECENT_DUMMY = RecentFile(
+            name = "DUMMY.pdf",
+            path = "",
+            type = FileType.PDF,
+            size = 0,
+            createdAt = LocalDateTime.of(2024,6,2,2,0),
+            lastModified = LocalDateTime.of(2024,6,2,2,0)
+        )
+    }
+}