Добавленны юнит тесты для всех сервисов

src/test/kotlin/com/project/movienight/application/services/FilmServiceTest.kt

@@ -0,0 +1,181 @@
+package com.project.movienight.application.services
+
+import com.project.movienight.application.ports.input.CreateFilmCommand
+import com.project.movienight.application.ports.input.EditFilmCommand
+import com.project.movienight.application.ports.output.FilmRepositoryPort
+import com.project.movienight.application.ports.output.IdGenerator
+import com.project.movienight.config.FilmServiceProperties
+import com.project.movienight.domain.exception.BlockedValueException
+import com.project.movienight.domain.exception.EntityNotFoundException
+import com.project.movienight.domain.model.Film
+import io.mockk.every
+import io.mockk.justRun
+import io.mockk.mockk
+import io.mockk.verify
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertNotNull
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+import java.util.UUID
+
+class FilmServiceTest {
+    private lateinit var filmRepository: FilmRepositoryPort
+    private lateinit var idGenerator: IdGenerator
+    private lateinit var filmConfig: FilmServiceProperties
+    private lateinit var filmService: FilmService
+
+    @BeforeEach
+    fun setup() {
+        filmRepository = mockk()
+        idGenerator = mockk()
+        filmConfig = mockk()
+        filmService = FilmService(filmRepository, idGenerator, filmConfig)
+    }
+
+    @Test
+    fun `should create film successfully`() {
+        val command = CreateFilmCommand(title = "Inception", description = "A mind-bending thriller")
+        val filmId = UUID.randomUUID()
+        val expectedFilm = Film(id = filmId, title = "Inception", description = "A mind-bending thriller")
+
+        every { filmConfig.isBlocked("Inception") } returns false
+        every { filmConfig.isBlocked("A mind-bending thriller") } returns false
+        every { idGenerator.generateId() } returns filmId
+        every { filmRepository.save(any()) } returns expectedFilm
+
+        val result = filmService.create(command)
+
+        assertNotNull(result)
+        assertEquals(filmId, result.id)
+        assertEquals("Inception", result.title)
+        assertEquals("A mind-bending thriller", result.description)
+
+        verify(exactly = 1) { filmConfig.isBlocked("Inception") }
+        verify(exactly = 1) { filmConfig.isBlocked("A mind-bending thriller") }
+        verify(exactly = 1) { idGenerator.generateId() }
+        verify(exactly = 1) { filmRepository.save(any()) }
+    }
+
+    @Test
+    fun `should throw BlockedValueException when creating film with blocked title`() {
+        val command = CreateFilmCommand(title = "censored", description = "Some description")
+
+        every { filmConfig.isBlocked("censored") } returns true
+        every { filmConfig.isBlocked("Some description") } returns false
+
+        assertThrows<BlockedValueException> {
+            filmService.create(command)
+        }
+
+        verify(exactly = 1) { filmConfig.isBlocked("censored") }
+        verify(exactly = 0) { filmConfig.isBlocked("Some description") }
+        verify(exactly = 0) { idGenerator.generateId() }
+        verify(exactly = 0) { filmRepository.save(any()) }
+    }
+
+    @Test
+    fun `should throw BlockedValueException when creating film with blocked description`() {
+        val command = CreateFilmCommand(title = "Good Film", description = "python")
+
+        every { filmConfig.isBlocked("Good Film") } returns false
+        every { filmConfig.isBlocked("python") } returns true
+
+        assertThrows<BlockedValueException> {
+            filmService.create(command)
+        }
+
+        verify(exactly = 1) { filmConfig.isBlocked("Good Film") }
+        verify(exactly = 1) { filmConfig.isBlocked("python") }
+        verify(exactly = 0) { idGenerator.generateId() }
+        verify(exactly = 0) { filmRepository.save(any()) }
+    }
+
+    @Test
+    fun `should edit film successfully`() {
+        val filmId = UUID.randomUUID()
+        val command = EditFilmCommand(title = "Inception 2", description = "The sequel")
+        val existingFilm = Film(id = filmId, title = "Inception", description = "A mind-bending thriller")
+        val updatedFilm = Film(id = filmId, title = "Inception 2", description = "The sequel")
+
+        every { filmConfig.isBlocked("Inception 2") } returns false
+        every { filmConfig.isBlocked("The sequel") } returns false
+        every { filmRepository.findById(filmId) } returns existingFilm
+        every { filmRepository.save(any()) } returns updatedFilm
+
+        val result = filmService.edit(filmId, command)
+
+        assertNotNull(result)
+        assertEquals(filmId, result.id)
+        assertEquals("Inception 2", result.title)
+        assertEquals("The sequel", result.description)
+
+        verify(exactly = 1) { filmConfig.isBlocked("Inception 2") }
+        verify(exactly = 1) { filmConfig.isBlocked("The sequel") }
+        verify(exactly = 1) { filmRepository.findById(filmId) }
+        verify(exactly = 1) { filmRepository.save(any()) }
+    }
+
+    @Test
+    fun `should throw BlockedValueException when editing film with blocked title`() {
+        val filmId = UUID.randomUUID()
+        val command = EditFilmCommand(title = "epstein", description = "Some description")
+
+        every { filmConfig.isBlocked("epstein") } returns true
+
+        assertThrows<BlockedValueException> {
+            filmService.edit(filmId, command)
+        }
+
+        verify(exactly = 1) { filmConfig.isBlocked("epstein") }
+        verify(exactly = 0) { filmRepository.findById(any()) }
+        verify(exactly = 0) { filmRepository.save(any()) }
+    }
+
+    @Test
+    fun `should throw EntityNotFoundException when editing non-existent film`() {
+        val filmId = UUID.randomUUID()
+        val command = EditFilmCommand(title = "New Title", description = "New Description")
+
+        every { filmConfig.isBlocked("New Title") } returns false
+        every { filmConfig.isBlocked("New Description") } returns false
+        every { filmRepository.findById(filmId) } returns null
+
+        assertThrows<EntityNotFoundException> {
+            filmService.edit(filmId, command)
+        }
+
+        verify(exactly = 1) { filmConfig.isBlocked("New Title") }
+        verify(exactly = 1) { filmConfig.isBlocked("New Description") }
+        verify(exactly = 1) { filmRepository.findById(filmId) }
+        verify(exactly = 0) { filmRepository.save(any()) }
+    }
+
+    @Test
+    fun `should delete film successfully`() {
+        val filmId = UUID.randomUUID()
+        val existingFilm = Film(id = filmId, title = "Inception", description = "A mind-bending thriller")
+
+        every { filmRepository.findById(filmId) } returns existingFilm
+        justRun { filmRepository.deleteById(filmId) }
+
+        filmService.delete(filmId)
+
+        verify(exactly = 1) { filmRepository.findById(filmId) }
+        verify(exactly = 1) { filmRepository.deleteById(filmId) }
+    }
+
+    @Test
+    fun `should throw EntityNotFoundException when deleting non-existent film`() {
+        val filmId = UUID.randomUUID()
+
+        every { filmRepository.findById(filmId) } returns null
+
+        assertThrows<EntityNotFoundException> {
+            filmService.delete(filmId)
+        }
+
+        verify(exactly = 1) { filmRepository.findById(filmId) }
+        verify(exactly = 0) { filmRepository.deleteById(any()) }
+    }
+}