test: improve test code in DiaryUnitTest and create new test code for File

src/test/kotlin/me/daegyeo/maru/DiaryUnitTest.kt

@@ -1,6 +1,7 @@
 package me.daegyeo.maru
 
 import me.daegyeo.maru.diary.application.domain.Diary
+import me.daegyeo.maru.diary.application.domain.DiaryFile
 import me.daegyeo.maru.diary.application.domain.DiaryWithUserId
 import me.daegyeo.maru.diary.application.error.DiaryError
 import me.daegyeo.maru.diary.application.port.`in`.DecryptDiaryUseCase
@@ -10,9 +11,12 @@ import me.daegyeo.maru.diary.application.port.`in`.GetImagePathInContentUseCase
 import me.daegyeo.maru.diary.application.port.`in`.command.CreateDiaryCommand
 import me.daegyeo.maru.diary.application.port.`in`.command.UpdateDiaryCommand
 import me.daegyeo.maru.diary.application.port.out.*
+import me.daegyeo.maru.diary.application.port.out.dto.CreateDiaryFileDto
 import me.daegyeo.maru.diary.application.service.*
+import me.daegyeo.maru.file.application.domain.File
 import me.daegyeo.maru.file.application.port.out.ReadFilePort
 import me.daegyeo.maru.file.application.port.out.UpdateFilePort
+import me.daegyeo.maru.file.constant.FileStatus
 import me.daegyeo.maru.shared.constant.Vendor
 import me.daegyeo.maru.shared.exception.ServiceException
 import me.daegyeo.maru.user.application.domain.User
@@ -71,6 +75,7 @@ class DiaryUnitTest {
             getImagePathInContentUseCase,
         )
     private val deleteDiaryService = DeleteDiaryService(deleteDiaryPort, getDiaryUseCase)
+    private val getImagePathInContentService = GetImagePathInContentService()
 
     @Test
     fun `일기를 성공적으로 가져옴`() {
@@ -149,7 +154,7 @@ class DiaryUnitTest {
     }
 
     @Test
-    fun `일기를 성공적으로 생성함`() {
+    fun `일기를 성공적으로 생성하고 이미지를 첨부함`() {
         val userId = UUID.randomUUID()
         val user =
             User(
@@ -172,21 +177,37 @@ class DiaryUnitTest {
                 createdAt = ZonedDateTime.now(),
                 updatedAt = ZonedDateTime.now(),
             )
+        val filePath = "foobar.png"
+        val file =
+            File(
+                fileId = 1,
+                userId = userId,
+                path = filePath,
+                originalPath = "original_foobar.png",
+                status = FileStatus.UPLOADED,
+                createdAt = ZonedDateTime.now(),
+                updatedAt = ZonedDateTime.now(),
+                deletedAt = null,
+            )
 
         `when`(getUserUseCase.getUser(userId)).thenReturn(user)
         `when`(encryptDiaryUseCase.encryptDiary(content)).thenReturn(encryptedContent)
         `when`(createDiaryPort.createDiary(any())).thenReturn(diary)
+        `when`(getImagePathInContentUseCase.getImagePathInContent(content)).thenReturn(listOf(filePath))
+        `when`(readFilePort.readFileByPathAndUserId(filePath, userId)).thenReturn(file)
 
         val result = createDiaryService.createDiary(CreateDiaryCommand(title, content, userId))
 
         verify(getUserUseCase).getUser(userId)
         verify(encryptDiaryUseCase).encryptDiary(content)
         verify(createDiaryPort).createDiary(any())
+        verify(updateFilePort).updateFileStatus(file.fileId, FileStatus.USED)
+        verify(createDiaryFilePort).createDiaryFile(CreateDiaryFileDto(diaryId = diary.diaryId, fileId = file.fileId))
         assert(result.title == title)
     }
 
     @Test
-    fun `일기를 성공적으로 수정함`() {
+    fun `일기를 성공적으로 수정하고 첨부된 이미지를 수정함`() {
         val userId = UUID.randomUUID()
         val diaryId = 1L
         val title = "FOO BAR"
@@ -200,15 +221,43 @@ class DiaryUnitTest {
                 createdAt = ZonedDateTime.now(),
                 updatedAt = ZonedDateTime.now(),
             )
+        val existsFile =
+            DiaryFile(
+                diaryFileId = 1,
+                diaryId = diaryId,
+                fileId = 1,
+                createdAt = ZonedDateTime.now(),
+                updatedAt = ZonedDateTime.now(),
+            )
+        val newFilePath = "new_foobar.png"
+        val newFile =
+            File(
+                fileId = 2,
+                userId = userId,
+                path = newFilePath,
+                originalPath = "new_original_foobar.png",
+                status = FileStatus.UPLOADED,
+                createdAt = ZonedDateTime.now(),
+                updatedAt = ZonedDateTime.now(),
+                deletedAt = null,
+            )
 
         `when`(getDiaryUseCase.getDiaryByDiaryId(diaryId, userId)).thenReturn(diary)
         `when`(encryptDiaryUseCase.encryptDiary(updateContent)).thenReturn(encryptedContent)
+        `when`(readAllDiaryFilePort.readAllDiaryFileByDiaryId(diaryId)).thenReturn(listOf(existsFile))
+        `when`(getImagePathInContentUseCase.getImagePathInContent(updateContent)).thenReturn(listOf(newFilePath))
+        `when`(readFilePort.readFileByPathAndUserId(newFilePath, userId)).thenReturn(newFile)
 
         val result = updateDiaryService.updateDiary(diaryId, userId, UpdateDiaryCommand(title, updateContent))
 
         verify(getDiaryUseCase).getDiaryByDiaryId(diaryId, userId)
         verify(encryptDiaryUseCase).encryptDiary(updateContent)
         verify(updateDiaryPort).updateDiary(diaryId, title, encryptedContent)
+        verify(deleteDiaryFilePort).deleteDiaryFile(existsFile.diaryId, existsFile.fileId)
+        verify(updateFilePort).updateFileStatus(existsFile.fileId, FileStatus.ORPHANED)
+        verify(updateFilePort).updateFileStatus(newFile.fileId, FileStatus.USED)
+        verify(createDiaryFilePort).createDiaryFile(CreateDiaryFileDto(diaryId = diaryId, fileId = newFile.fileId))
+
         assert(result)
     }
 
@@ -274,4 +323,11 @@ class DiaryUnitTest {
             }
         assert(exception.error == DiaryError.DIARY_IS_NOT_OWNED)
     }
+
+    @Test
+    fun `일기 내용에서 첨부된 이미지 링크만 가져옴`() {
+        val content = "<p>Hello, World</p>[image|foobar.png]<p>GoodBye</p>"
+        val result = getImagePathInContentService.getImagePathInContent(content)
+        assert(result == listOf("foobar.png"))
+    }
 }

src/test/kotlin/me/daegyeo/maru/FileUnitTest.kt

@@ -0,0 +1,125 @@
+package me.daegyeo.maru
+
+import io.minio.MinioClient
+import me.daegyeo.maru.file.application.domain.File
+import me.daegyeo.maru.file.application.error.FileError
+import me.daegyeo.maru.file.application.port.out.CreateFilePort
+import me.daegyeo.maru.file.application.port.out.ReadFilePort
+import me.daegyeo.maru.file.application.port.out.UpdateFilePort
+import me.daegyeo.maru.file.application.port.out.dto.CreateFileDto
+import me.daegyeo.maru.file.application.service.FileUploadSuccessService
+import me.daegyeo.maru.file.application.service.GetPresignedUrlService
+import me.daegyeo.maru.file.constant.FileStatus
+import me.daegyeo.maru.shared.exception.ServiceException
+import org.junit.jupiter.api.Assertions.assertThrows
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+import org.mockito.Mockito.*
+import org.mockito.junit.jupiter.MockitoExtension
+import org.mockito.kotlin.any
+import java.time.ZonedDateTime
+import java.util.UUID
+
+@Suppress("NonAsciiCharacters")
+@ExtendWith(MockitoExtension::class)
+class FileUnitTest {
+    private val minioClient = mock(MinioClient::class.java)
+    private val createFilePort = mock(CreateFilePort::class.java)
+    private val readFilePort = mock(ReadFilePort::class.java)
+    private val updateFilePort = mock(UpdateFilePort::class.java)
+
+    private val getPresignedUrlService = GetPresignedUrlService(minioClient, createFilePort, readFilePort)
+    private val fileUploadSuccessService = FileUploadSuccessService(readFilePort, updateFilePort)
+
+    @BeforeEach
+    fun setup() {
+        GetPresignedUrlService::class.java.getDeclaredField("bucket").apply {
+            isAccessible = true
+            set(getPresignedUrlService, "test-bucket")
+        }
+        GetPresignedUrlService::class.java.getDeclaredField("urlExpirySeconds").apply {
+            isAccessible = true
+            set(getPresignedUrlService, 3600)
+        }
+    }
+
+    @Test
+    fun `GET PresignedURL을 생성함`() {
+        val userId = UUID.randomUUID()
+        val file =
+            File(
+                fileId = 1,
+                path = "test.jpg",
+                originalPath = "test.jpg",
+                userId = userId,
+                status = FileStatus.UPLOADED,
+                createdAt = ZonedDateTime.now(),
+                updatedAt = ZonedDateTime.now(),
+                deletedAt = null,
+            )
+
+        `when`(readFilePort.readFileByPathAndUserId("test.jpg", userId)).thenReturn(file)
+        `when`(minioClient.getPresignedObjectUrl(any())).thenReturn("http://acme.com/get/test.jpg")
+
+        val presignedUrl = getPresignedUrlService.getPresignedGetUrl("test.jpg", userId)
+
+        assert(presignedUrl.url == "http://acme.com/get/test.jpg")
+        assert(presignedUrl.fileName == "test.jpg")
+    }
+
+    @Test
+    fun `존재하지 않는 파일에 대한 GET PresignedURL을 생성하면 오류를 반환함`() {
+        val userId = UUID.randomUUID()
+
+        `when`(readFilePort.readFileByPathAndUserId("test.jpg", userId)).thenReturn(null)
+
+        val exception =
+            assertThrows(ServiceException::class.java) {
+                getPresignedUrlService.getPresignedGetUrl("test.jpg", userId)
+            }
+        assert(exception.error == FileError.FILE_NOT_FOUND)
+    }
+
+    @Test
+    fun `PUT PresignedURL을 생성함`() {
+        val userId = UUID.randomUUID()
+
+        `when`(minioClient.getPresignedObjectUrl(any())).thenReturn("http://acme.com/put/random-uuid.jpg")
+
+        val presignedUrl = getPresignedUrlService.getPresignedPutUrl("original.jpg", userId)
+
+        verify(createFilePort).createFile(
+            CreateFileDto(
+                userId = userId,
+                path = presignedUrl.fileName,
+                originalPath = "original.jpg",
+                status = FileStatus.PENDING,
+            ),
+        )
+        assert(presignedUrl.url == "http://acme.com/put/random-uuid.jpg")
+    }
+
+    @Test
+    fun `Object Stroage에 파일이 업로드되면 성공 처리함`() {
+        val fileId = 1L
+        val file =
+            File(
+                fileId = fileId,
+                path = "test.jpg",
+                originalPath = "original_test.jpg",
+                userId = UUID.randomUUID(),
+                status = FileStatus.PENDING,
+                createdAt = ZonedDateTime.now(),
+                updatedAt = ZonedDateTime.now(),
+                deletedAt = null,
+            )
+
+        `when`(readFilePort.readFileByPath("test.jpg")).thenReturn(file)
+
+        val result = fileUploadSuccessService.fileUploadSuccess("test.jpg")
+
+        verify(updateFilePort).updateFileStatus(fileId, FileStatus.UPLOADED)
+        assert(result)
+    }
+}