Merge branch 'develop' into feat/spring-tests
This commit is contained in:
glashark
+81
@@ -0,0 +1,81 @@
|
||||
package com.project.movienight.adapters.persistence.entity
|
||||
|
||||
import com.project.movienight.domain.model.AuthProvider
|
||||
import com.project.movienight.domain.model.User
|
||||
import org.junit.jupiter.api.Test
|
||||
import java.time.LocalDateTime
|
||||
import java.util.UUID
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertNull
|
||||
|
||||
class UserEntityMappingTest {
|
||||
|
||||
@Test
|
||||
fun `toDomain maps UserEntity correctly`() {
|
||||
val entity = UserEntity(
|
||||
id = UUID.randomUUID(),
|
||||
name = "John Pork",
|
||||
email = "john@email.com",
|
||||
provider = "GOOGLE",
|
||||
providerId = "google1234",
|
||||
createdAt = LocalDateTime.now(),
|
||||
)
|
||||
val user = entity.toDomain()
|
||||
|
||||
assertEquals(entity.id, user.id)
|
||||
assertEquals(entity.name, user.name)
|
||||
assertEquals(entity.email, user.email)
|
||||
assertNull(user.library)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `toEntity maps User with OAuth provider`() {
|
||||
val user = User(
|
||||
id = UUID.randomUUID(),
|
||||
name = "Jane",
|
||||
email = "jane@mail.com",
|
||||
library = null
|
||||
)
|
||||
|
||||
val entity = user.toEntity(AuthProvider.YANDEX, "yandex456")
|
||||
|
||||
assertEquals(user.id, entity.id)
|
||||
assertEquals(user.name, entity.name)
|
||||
assertEquals(user.email, entity.email)
|
||||
assertEquals("YANDEX", entity.provider)
|
||||
assertEquals("yandex456", entity.providerId)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `toEntity maps User without OAuth provider`() {
|
||||
val user = User(
|
||||
id = UUID.randomUUID(),
|
||||
name = "Bob",
|
||||
email = "bob@mail.com",
|
||||
library = null
|
||||
)
|
||||
|
||||
val entity = user.toEntity()
|
||||
|
||||
assertNull(entity.provider)
|
||||
assertNull(entity.providerId)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `mapping is reversible for basic fields`() {
|
||||
val original = User(
|
||||
id = UUID.randomUUID(),
|
||||
name = "Alice",
|
||||
email = "alice@email.com",
|
||||
library = null
|
||||
)
|
||||
|
||||
val mapped = original.toEntity().toDomain()
|
||||
|
||||
assertEquals(original.id, mapped.id)
|
||||
assertEquals(original.name, mapped.name)
|
||||
assertEquals(original.email, mapped.email)
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
+220
@@ -0,0 +1,220 @@
|
||||
package com.project.movienight.adapters.persistence.jdbc
|
||||
|
||||
import com.project.movienight.domain.model.Film
|
||||
import com.project.movienight.domain.model.FilmLibrary
|
||||
import com.project.movienight.domain.model.User
|
||||
import org.junit.jupiter.api.AfterEach
|
||||
import org.junit.jupiter.api.Assertions.assertEquals
|
||||
import org.junit.jupiter.api.Assertions.assertFalse
|
||||
import org.junit.jupiter.api.Assertions.assertNotNull
|
||||
import org.junit.jupiter.api.Assertions.assertNull
|
||||
import org.junit.jupiter.api.Assertions.assertTrue
|
||||
import org.junit.jupiter.api.BeforeEach
|
||||
import org.junit.jupiter.api.Test
|
||||
import org.springframework.beans.factory.annotation.Autowired
|
||||
import org.springframework.boot.test.context.SpringBootTest
|
||||
import org.springframework.jdbc.core.JdbcTemplate
|
||||
import org.springframework.test.context.ActiveProfiles
|
||||
import java.util.UUID
|
||||
|
||||
@SpringBootTest
|
||||
@ActiveProfiles("test")
|
||||
class FilmLibraryRepositoryIntegrationTest {
|
||||
@Autowired
|
||||
private lateinit var filmLibraryRepository: FilmLibraryRepository
|
||||
|
||||
@Autowired
|
||||
private lateinit var userRepository: UserRepository
|
||||
|
||||
@Autowired
|
||||
private lateinit var filmRepository: FilmRepository
|
||||
|
||||
@Autowired
|
||||
private lateinit var jdbcTemplate: JdbcTemplate
|
||||
|
||||
private lateinit var testUser: User
|
||||
private lateinit var testFilm: Film
|
||||
|
||||
@BeforeEach
|
||||
fun setup() {
|
||||
cleanDatabase()
|
||||
createTestData()
|
||||
}
|
||||
|
||||
@AfterEach
|
||||
fun cleanup() {
|
||||
cleanDatabase()
|
||||
}
|
||||
|
||||
private fun cleanDatabase() {
|
||||
jdbcTemplate.execute("DELETE FROM favorites")
|
||||
jdbcTemplate.execute("DELETE FROM films")
|
||||
jdbcTemplate.execute("DELETE FROM users")
|
||||
}
|
||||
|
||||
private fun createTestData() {
|
||||
testUser = User(UUID.randomUUID(), "Иван Иванов", "ivan@example.com", null)
|
||||
testFilm = Film(UUID.randomUUID(), "Начало", "Захватывающий триллер")
|
||||
userRepository.save(testUser)
|
||||
filmRepository.save(testFilm)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should save new film library entry and return saved entry`() {
|
||||
val entry =
|
||||
FilmLibrary(
|
||||
id = UUID.randomUUID(),
|
||||
userId = testUser.id,
|
||||
filmId = testFilm.id,
|
||||
comment = "Отличный фильм!",
|
||||
isViewed = false,
|
||||
)
|
||||
|
||||
val savedEntry = filmLibraryRepository.save(entry)
|
||||
|
||||
assertNotNull(savedEntry)
|
||||
assertEquals(entry.id, savedEntry.id)
|
||||
assertEquals(entry.userId, savedEntry.userId)
|
||||
assertEquals(entry.filmId, savedEntry.filmId)
|
||||
assertEquals(entry.comment, savedEntry.comment)
|
||||
assertEquals(entry.isViewed, savedEntry.isViewed)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should update existing film library entry`() {
|
||||
val entryId = UUID.randomUUID()
|
||||
val originalEntry = FilmLibrary(entryId, testUser.id, testFilm.id, "Хочу посмотреть", false)
|
||||
filmLibraryRepository.save(originalEntry)
|
||||
|
||||
val updatedEntry = FilmLibrary(entryId, testUser.id, testFilm.id, "Уже посмотрел, потрясающе!", true)
|
||||
val result = filmLibraryRepository.save(updatedEntry)
|
||||
|
||||
assertEquals(entryId, result.id)
|
||||
assertEquals("Уже посмотрел, потрясающе!", result.comment)
|
||||
assertTrue(result.isViewed)
|
||||
|
||||
val foundEntry = filmLibraryRepository.findById(entryId)
|
||||
assertNotNull(foundEntry)
|
||||
assertEquals("Уже посмотрел, потрясающе!", foundEntry?.comment)
|
||||
assertTrue(foundEntry?.isViewed ?: false)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should find film library entry by id`() {
|
||||
val entry = FilmLibrary(UUID.randomUUID(), testUser.id, testFilm.id, "Обязательно посмотреть", false)
|
||||
filmLibraryRepository.save(entry)
|
||||
|
||||
val foundEntry = filmLibraryRepository.findById(entry.id)
|
||||
|
||||
assertNotNull(foundEntry)
|
||||
assertEquals(entry.id, foundEntry?.id)
|
||||
assertEquals(entry.userId, foundEntry?.userId)
|
||||
assertEquals(entry.filmId, foundEntry?.filmId)
|
||||
assertEquals(entry.comment, foundEntry?.comment)
|
||||
assertEquals(entry.isViewed, foundEntry?.isViewed)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should return null when film library entry not found by id`() {
|
||||
val nonExistentId = UUID.randomUUID()
|
||||
|
||||
val foundEntry = filmLibraryRepository.findById(nonExistentId)
|
||||
|
||||
assertNull(foundEntry)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should find all film library entries`() {
|
||||
val entry1 = FilmLibrary(UUID.randomUUID(), testUser.id, testFilm.id, "Комментарий 1", false)
|
||||
val entry2 = FilmLibrary(UUID.randomUUID(), testUser.id, testFilm.id, "Комментарий 2", true)
|
||||
val entry3 = FilmLibrary(UUID.randomUUID(), testUser.id, testFilm.id, null, false)
|
||||
|
||||
filmLibraryRepository.save(entry1)
|
||||
filmLibraryRepository.save(entry2)
|
||||
filmLibraryRepository.save(entry3)
|
||||
|
||||
val allEntries = filmLibraryRepository.findAll()
|
||||
|
||||
assertEquals(3, allEntries.size)
|
||||
assertTrue(allEntries.any { it.id == entry1.id })
|
||||
assertTrue(allEntries.any { it.id == entry2.id })
|
||||
assertTrue(allEntries.any { it.id == entry3.id })
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should return empty list when no film library entries exist`() {
|
||||
val allEntries = filmLibraryRepository.findAll()
|
||||
|
||||
assertTrue(allEntries.isEmpty())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should delete film library entry by id`() {
|
||||
val entry = FilmLibrary(UUID.randomUUID(), testUser.id, testFilm.id, "Для удаления", false)
|
||||
filmLibraryRepository.save(entry)
|
||||
|
||||
filmLibraryRepository.deleteById(entry.id)
|
||||
|
||||
val foundEntry = filmLibraryRepository.findById(entry.id)
|
||||
assertNull(foundEntry)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should not throw exception when deleting non-existent entry`() {
|
||||
val nonExistentId = UUID.randomUUID()
|
||||
|
||||
filmLibraryRepository.deleteById(nonExistentId)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should save entry with null comment`() {
|
||||
val entry = FilmLibrary(UUID.randomUUID(), testUser.id, testFilm.id, null, false)
|
||||
|
||||
val savedEntry = filmLibraryRepository.save(entry)
|
||||
|
||||
assertNotNull(savedEntry)
|
||||
assertNull(savedEntry.comment)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should save entry with isViewed true`() {
|
||||
val entry = FilmLibrary(UUID.randomUUID(), testUser.id, testFilm.id, "Посмотрел", true)
|
||||
|
||||
val savedEntry = filmLibraryRepository.save(entry)
|
||||
|
||||
assertNotNull(savedEntry)
|
||||
assertTrue(savedEntry.isViewed)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should save entry with isViewed false`() {
|
||||
val entry = FilmLibrary(UUID.randomUUID(), testUser.id, testFilm.id, "Еще не смотрел", false)
|
||||
|
||||
val savedEntry = filmLibraryRepository.save(entry)
|
||||
|
||||
assertNotNull(savedEntry)
|
||||
assertFalse(savedEntry.isViewed)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should cascade delete entries when user is deleted`() {
|
||||
val entry = FilmLibrary(UUID.randomUUID(), testUser.id, testFilm.id, "Любимый фильм пользователя", false)
|
||||
filmLibraryRepository.save(entry)
|
||||
|
||||
userRepository.deleteById(testUser.id)
|
||||
|
||||
val foundEntry = filmLibraryRepository.findById(entry.id)
|
||||
assertNull(foundEntry)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should cascade delete entries when film is deleted`() {
|
||||
val entry = FilmLibrary(UUID.randomUUID(), testUser.id, testFilm.id, "Запись о фильме", false)
|
||||
filmLibraryRepository.save(entry)
|
||||
|
||||
filmRepository.deleteById(testFilm.id)
|
||||
|
||||
val foundEntry = filmLibraryRepository.findById(entry.id)
|
||||
assertNull(foundEntry)
|
||||
}
|
||||
}
|
||||
+153
@@ -0,0 +1,153 @@
|
||||
package com.project.movienight.adapters.persistence.jdbc
|
||||
|
||||
import com.project.movienight.domain.model.Film
|
||||
import org.junit.jupiter.api.AfterEach
|
||||
import org.junit.jupiter.api.Assertions.assertEquals
|
||||
import org.junit.jupiter.api.Assertions.assertNotNull
|
||||
import org.junit.jupiter.api.Assertions.assertNull
|
||||
import org.junit.jupiter.api.Assertions.assertTrue
|
||||
import org.junit.jupiter.api.BeforeEach
|
||||
import org.junit.jupiter.api.Test
|
||||
import org.springframework.beans.factory.annotation.Autowired
|
||||
import org.springframework.boot.test.context.SpringBootTest
|
||||
import org.springframework.jdbc.core.JdbcTemplate
|
||||
import org.springframework.test.context.ActiveProfiles
|
||||
import java.util.UUID
|
||||
|
||||
@SpringBootTest
|
||||
@ActiveProfiles("test")
|
||||
class FilmRepositoryIntegrationTest {
|
||||
@Autowired
|
||||
private lateinit var filmRepository: FilmRepository
|
||||
|
||||
@Autowired
|
||||
private lateinit var jdbcTemplate: JdbcTemplate
|
||||
|
||||
@BeforeEach
|
||||
fun setup() {
|
||||
cleanDatabase()
|
||||
}
|
||||
|
||||
@AfterEach
|
||||
fun cleanup() {
|
||||
cleanDatabase()
|
||||
}
|
||||
|
||||
private fun cleanDatabase() {
|
||||
jdbcTemplate.execute("DELETE FROM favorites")
|
||||
jdbcTemplate.execute("DELETE FROM films")
|
||||
jdbcTemplate.execute("DELETE FROM users")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should save new film and return saved film`() {
|
||||
val film =
|
||||
Film(
|
||||
id = UUID.randomUUID(),
|
||||
title = "Начало",
|
||||
description = "Захватывающий триллер о снах внутри снов",
|
||||
)
|
||||
|
||||
val savedFilm = filmRepository.save(film)
|
||||
|
||||
assertNotNull(savedFilm)
|
||||
assertEquals(film.id, savedFilm.id)
|
||||
assertEquals(film.title, savedFilm.title)
|
||||
assertEquals(film.description, savedFilm.description)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should update existing film`() {
|
||||
val filmId = UUID.randomUUID()
|
||||
val originalFilm = Film(filmId, "Начало", "Оригинальное описание")
|
||||
filmRepository.save(originalFilm)
|
||||
|
||||
val updatedFilm = Film(filmId, "Начало (Обновлено)", "Обновленное описание с дополнительными деталями")
|
||||
val result = filmRepository.save(updatedFilm)
|
||||
|
||||
assertEquals(filmId, result.id)
|
||||
assertEquals("Начало (Обновлено)", result.title)
|
||||
assertEquals("Обновленное описание с дополнительными деталями", result.description)
|
||||
|
||||
val foundFilm = filmRepository.findById(filmId)
|
||||
assertNotNull(foundFilm)
|
||||
assertEquals("Начало (Обновлено)", foundFilm?.title)
|
||||
assertEquals("Обновленное описание с дополнительными деталями", foundFilm?.description)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should find film by id`() {
|
||||
val film = Film(UUID.randomUUID(), "Матрица", "Хакер узнает правду о реальности")
|
||||
filmRepository.save(film)
|
||||
|
||||
val foundFilm = filmRepository.findById(film.id)
|
||||
|
||||
assertNotNull(foundFilm)
|
||||
assertEquals(film.id, foundFilm?.id)
|
||||
assertEquals(film.title, foundFilm?.title)
|
||||
assertEquals(film.description, foundFilm?.description)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should return null when film not found by id`() {
|
||||
val nonExistentId = UUID.randomUUID()
|
||||
|
||||
val foundFilm = filmRepository.findById(nonExistentId)
|
||||
|
||||
assertNull(foundFilm)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should find all films`() {
|
||||
val film1 = Film(UUID.randomUUID(), "Начало", "Сны внутри снов")
|
||||
val film2 = Film(UUID.randomUUID(), "Матрица", "Реальность не то, чем кажется")
|
||||
val film3 = Film(UUID.randomUUID(), "Интерстеллар", "Путешествие сквозь пространство и время")
|
||||
|
||||
filmRepository.save(film1)
|
||||
filmRepository.save(film2)
|
||||
filmRepository.save(film3)
|
||||
|
||||
val allFilms = filmRepository.findAll()
|
||||
|
||||
assertEquals(3, allFilms.size)
|
||||
assertTrue(allFilms.any { it.id == film1.id })
|
||||
assertTrue(allFilms.any { it.id == film2.id })
|
||||
assertTrue(allFilms.any { it.id == film3.id })
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should return empty list when no films exist`() {
|
||||
val allFilms = filmRepository.findAll()
|
||||
|
||||
assertTrue(allFilms.isEmpty())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should delete film by id`() {
|
||||
val film = Film(UUID.randomUUID(), "Начало", "Сны внутри снов")
|
||||
filmRepository.save(film)
|
||||
|
||||
filmRepository.deleteById(film.id)
|
||||
|
||||
val foundFilm = filmRepository.findById(film.id)
|
||||
assertNull(foundFilm)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should not throw exception when deleting non-existent film`() {
|
||||
val nonExistentId = UUID.randomUUID()
|
||||
|
||||
filmRepository.deleteById(nonExistentId)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should save film with long description`() {
|
||||
val longDescription = "А".repeat(1000)
|
||||
val film = Film(UUID.randomUUID(), "Тестовый фильм", longDescription)
|
||||
|
||||
val savedFilm = filmRepository.save(film)
|
||||
|
||||
assertNotNull(savedFilm)
|
||||
assertEquals(longDescription, savedFilm.description)
|
||||
}
|
||||
}
|
||||
+160
@@ -0,0 +1,160 @@
|
||||
package com.project.movienight.adapters.persistence.jdbc
|
||||
|
||||
import com.project.movienight.domain.model.User
|
||||
import org.junit.jupiter.api.AfterEach
|
||||
import org.junit.jupiter.api.Assertions.assertEquals
|
||||
import org.junit.jupiter.api.Assertions.assertNotNull
|
||||
import org.junit.jupiter.api.Assertions.assertNull
|
||||
import org.junit.jupiter.api.Assertions.assertTrue
|
||||
import org.junit.jupiter.api.BeforeEach
|
||||
import org.junit.jupiter.api.Test
|
||||
import org.springframework.beans.factory.annotation.Autowired
|
||||
import org.springframework.boot.test.context.SpringBootTest
|
||||
import org.springframework.jdbc.core.JdbcTemplate
|
||||
import org.springframework.test.context.ActiveProfiles
|
||||
import java.util.UUID
|
||||
|
||||
@SpringBootTest
|
||||
@ActiveProfiles("test")
|
||||
class UserRepositoryIntegrationTest {
|
||||
@Autowired
|
||||
private lateinit var userRepository: UserRepository
|
||||
|
||||
@Autowired
|
||||
private lateinit var jdbcTemplate: JdbcTemplate
|
||||
|
||||
@BeforeEach
|
||||
fun setup() {
|
||||
cleanDatabase()
|
||||
}
|
||||
|
||||
@AfterEach
|
||||
fun cleanup() {
|
||||
cleanDatabase()
|
||||
}
|
||||
|
||||
private fun cleanDatabase() {
|
||||
jdbcTemplate.execute("DELETE FROM favorites")
|
||||
jdbcTemplate.execute("DELETE FROM films")
|
||||
jdbcTemplate.execute("DELETE FROM users")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should save new user and return saved user`() {
|
||||
val user =
|
||||
User(
|
||||
id = UUID.randomUUID(),
|
||||
name = "John Doe",
|
||||
email = "john@example.com",
|
||||
library = null,
|
||||
)
|
||||
|
||||
val savedUser = userRepository.save(user)
|
||||
|
||||
assertNotNull(savedUser)
|
||||
assertEquals(user.id, savedUser.id)
|
||||
assertEquals(user.name, savedUser.name)
|
||||
assertEquals(user.email, savedUser.email)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should update existing user`() {
|
||||
// given
|
||||
val userId = UUID.randomUUID()
|
||||
val originalUser = User(userId, "John Doe", "john@example.com", null)
|
||||
userRepository.save(originalUser)
|
||||
|
||||
val updatedUser = User(userId, "Jane Doe", "jane@example.com", null)
|
||||
val result = userRepository.save(updatedUser)
|
||||
|
||||
assertEquals(userId, result.id)
|
||||
assertEquals("Jane Doe", result.name)
|
||||
assertEquals("jane@example.com", result.email)
|
||||
|
||||
val foundUser = userRepository.findById(userId)
|
||||
assertNotNull(foundUser)
|
||||
assertEquals("Jane Doe", foundUser?.name)
|
||||
assertEquals("jane@example.com", foundUser?.email)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should find user by id`() {
|
||||
// given
|
||||
val user = User(UUID.randomUUID(), "John Doe", "john@example.com", null)
|
||||
userRepository.save(user)
|
||||
|
||||
// when
|
||||
val foundUser = userRepository.findById(user.id)
|
||||
|
||||
// then
|
||||
assertNotNull(foundUser)
|
||||
assertEquals(user.id, foundUser?.id)
|
||||
assertEquals(user.name, foundUser?.name)
|
||||
assertEquals(user.email, foundUser?.email)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should return null when user not found by id`() {
|
||||
// given
|
||||
val nonExistentId = UUID.randomUUID()
|
||||
|
||||
// when
|
||||
val foundUser = userRepository.findById(nonExistentId)
|
||||
|
||||
// then
|
||||
assertNull(foundUser)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should find all users`() {
|
||||
// given
|
||||
val user1 = User(UUID.randomUUID(), "John Doe", "john@example.com", null)
|
||||
val user2 = User(UUID.randomUUID(), "Jane Smith", "jane@example.com", null)
|
||||
val user3 = User(UUID.randomUUID(), "Bob Johnson", "bob@example.com", null)
|
||||
|
||||
userRepository.save(user1)
|
||||
userRepository.save(user2)
|
||||
userRepository.save(user3)
|
||||
|
||||
// when
|
||||
val allUsers = userRepository.findAll()
|
||||
|
||||
// then
|
||||
assertEquals(3, allUsers.size)
|
||||
assertTrue(allUsers.any { it.id == user1.id })
|
||||
assertTrue(allUsers.any { it.id == user2.id })
|
||||
assertTrue(allUsers.any { it.id == user3.id })
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should return empty list when no users exist`() {
|
||||
// when
|
||||
val allUsers = userRepository.findAll()
|
||||
|
||||
// then
|
||||
assertTrue(allUsers.isEmpty())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should delete user by id`() {
|
||||
// given
|
||||
val user = User(UUID.randomUUID(), "John Doe", "john@example.com", null)
|
||||
userRepository.save(user)
|
||||
|
||||
// when
|
||||
userRepository.deleteById(user.id)
|
||||
|
||||
// then
|
||||
val foundUser = userRepository.findById(user.id)
|
||||
assertNull(foundUser)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should not throw exception when deleting non-existent user`() {
|
||||
// given
|
||||
val nonExistentId = UUID.randomUUID()
|
||||
|
||||
// when & then (no exception should be thrown)
|
||||
userRepository.deleteById(nonExistentId)
|
||||
}
|
||||
}
|
||||
+301
@@ -0,0 +1,301 @@
|
||||
package com.project.movienight.application.services
|
||||
|
||||
import com.project.movienight.application.ports.input.AddFilmToLibraryCommand
|
||||
import com.project.movienight.application.ports.input.CreateFilmLibraryCommand
|
||||
import com.project.movienight.application.ports.input.GetFilmLibraryQuery
|
||||
import com.project.movienight.application.ports.input.RemoveFilmFromLibraryCommand
|
||||
import com.project.movienight.application.ports.output.FilmLibraryRepositoryPort
|
||||
import com.project.movienight.application.ports.output.IdGenerator
|
||||
import com.project.movienight.domain.exception.DomainException
|
||||
import com.project.movienight.domain.exception.EntityNotFoundException
|
||||
import com.project.movienight.domain.model.FilmLibrary
|
||||
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 FilmLibraryServiceTest {
|
||||
private lateinit var filmLibraryRepository: FilmLibraryRepositoryPort
|
||||
private lateinit var idGenerator: IdGenerator
|
||||
private lateinit var filmLibraryService: FilmLibraryService
|
||||
|
||||
@BeforeEach
|
||||
fun setup() {
|
||||
filmLibraryRepository = mockk()
|
||||
idGenerator = mockk()
|
||||
filmLibraryService = FilmLibraryService(filmLibraryRepository, idGenerator)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should create new film library when user has no library`() {
|
||||
val userId = UUID.randomUUID()
|
||||
val libraryId = UUID.randomUUID()
|
||||
val filmId = UUID.randomUUID()
|
||||
val command = CreateFilmLibraryCommand(userId = userId, name = "My Films")
|
||||
val expectedLibrary =
|
||||
FilmLibrary(
|
||||
id = libraryId,
|
||||
userId = userId,
|
||||
filmId = filmId,
|
||||
comment = "My Films",
|
||||
isViewed = false,
|
||||
)
|
||||
|
||||
every { filmLibraryRepository.findAll() } returns emptyList()
|
||||
every { idGenerator.generateId() } returnsMany listOf(libraryId, filmId)
|
||||
every {
|
||||
filmLibraryRepository.save(
|
||||
match {
|
||||
it.userId == userId && it.comment == "My Films" && it.isViewed == false
|
||||
},
|
||||
)
|
||||
} returns expectedLibrary
|
||||
|
||||
val result = filmLibraryService.create(command)
|
||||
|
||||
assertNotNull(result)
|
||||
assertEquals(libraryId, result.id)
|
||||
assertEquals(userId, result.userId)
|
||||
assertEquals(filmId, result.filmId)
|
||||
assertEquals("My Films", result.comment)
|
||||
|
||||
verify(exactly = 1) { filmLibraryRepository.findAll() }
|
||||
verify(exactly = 2) { idGenerator.generateId() }
|
||||
verify(exactly = 1) { filmLibraryRepository.save(any()) }
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should return existing library when user already has one`() {
|
||||
val userId = UUID.randomUUID()
|
||||
val existingLibrary =
|
||||
FilmLibrary(
|
||||
id = UUID.randomUUID(),
|
||||
userId = userId,
|
||||
filmId = UUID.randomUUID(),
|
||||
comment = "Existing Library",
|
||||
isViewed = false,
|
||||
)
|
||||
val command = CreateFilmLibraryCommand(userId = userId, name = "New Library")
|
||||
|
||||
every { filmLibraryRepository.findAll() } returns listOf(existingLibrary)
|
||||
|
||||
val result = filmLibraryService.create(command)
|
||||
|
||||
assertEquals(existingLibrary, result)
|
||||
|
||||
verify(exactly = 1) { filmLibraryRepository.findAll() }
|
||||
verify(exactly = 0) { idGenerator.generateId() }
|
||||
verify(exactly = 0) { filmLibraryRepository.save(any()) }
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should add film to new library when user has no library`() {
|
||||
val userId = UUID.randomUUID()
|
||||
val filmId = UUID.randomUUID()
|
||||
val libraryId = UUID.randomUUID()
|
||||
val command = AddFilmToLibraryCommand(userId = userId, filmId = filmId)
|
||||
val expectedLibrary =
|
||||
FilmLibrary(
|
||||
id = libraryId,
|
||||
userId = userId,
|
||||
filmId = filmId,
|
||||
comment = null,
|
||||
isViewed = false,
|
||||
)
|
||||
|
||||
every { filmLibraryRepository.findAll() } returns emptyList()
|
||||
every { idGenerator.generateId() } returns libraryId
|
||||
every {
|
||||
filmLibraryRepository.save(
|
||||
match {
|
||||
it.userId == userId && it.filmId == filmId && it.comment == null && it.isViewed == false
|
||||
},
|
||||
)
|
||||
} returns expectedLibrary
|
||||
|
||||
val result = filmLibraryService.addFilm(command)
|
||||
|
||||
assertNotNull(result)
|
||||
assertEquals(filmId, result.filmId)
|
||||
assertEquals(userId, result.userId)
|
||||
|
||||
verify(exactly = 1) { filmLibraryRepository.findAll() }
|
||||
verify(exactly = 1) { idGenerator.generateId() }
|
||||
verify(exactly = 1) { filmLibraryRepository.save(any()) }
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should add film to existing library`() {
|
||||
val userId = UUID.randomUUID()
|
||||
val oldFilmId = UUID.randomUUID()
|
||||
val newFilmId = UUID.randomUUID()
|
||||
val existingLibrary =
|
||||
FilmLibrary(
|
||||
id = UUID.randomUUID(),
|
||||
userId = userId,
|
||||
filmId = oldFilmId,
|
||||
comment = "My Library",
|
||||
isViewed = true,
|
||||
)
|
||||
val command = AddFilmToLibraryCommand(userId = userId, filmId = newFilmId)
|
||||
val updatedLibrary = existingLibrary.copy(filmId = newFilmId, isViewed = false)
|
||||
|
||||
every { filmLibraryRepository.findAll() } returns listOf(existingLibrary)
|
||||
every {
|
||||
filmLibraryRepository.save(
|
||||
match {
|
||||
it.filmId == newFilmId && it.isViewed == false
|
||||
},
|
||||
)
|
||||
} returns updatedLibrary
|
||||
|
||||
val result = filmLibraryService.addFilm(command)
|
||||
|
||||
assertEquals(newFilmId, result.filmId)
|
||||
assertEquals(false, result.isViewed)
|
||||
|
||||
verify(exactly = 1) { filmLibraryRepository.findAll() }
|
||||
verify(exactly = 0) { idGenerator.generateId() }
|
||||
verify(exactly = 1) { filmLibraryRepository.save(any()) }
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should remove film from library successfully`() {
|
||||
val userId = UUID.randomUUID()
|
||||
val filmId = UUID.randomUUID()
|
||||
val libraryId = UUID.randomUUID()
|
||||
val existingLibrary =
|
||||
FilmLibrary(
|
||||
id = libraryId,
|
||||
userId = userId,
|
||||
filmId = filmId,
|
||||
comment = "My Library",
|
||||
isViewed = false,
|
||||
)
|
||||
val command = RemoveFilmFromLibraryCommand(userId = userId, filmId = filmId)
|
||||
|
||||
every { filmLibraryRepository.findAll() } returns listOf(existingLibrary)
|
||||
justRun { filmLibraryRepository.deleteById(libraryId) }
|
||||
|
||||
val result = filmLibraryService.removeFilm(command)
|
||||
|
||||
assertEquals(existingLibrary, result)
|
||||
|
||||
verify(exactly = 1) { filmLibraryRepository.findAll() }
|
||||
verify(exactly = 1) { filmLibraryRepository.deleteById(libraryId) }
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should throw EntityNotFoundException when removing film from non-existent library`() {
|
||||
val userId = UUID.randomUUID()
|
||||
val filmId = UUID.randomUUID()
|
||||
val command = RemoveFilmFromLibraryCommand(userId = userId, filmId = filmId)
|
||||
|
||||
every { filmLibraryRepository.findAll() } returns emptyList()
|
||||
|
||||
assertThrows<EntityNotFoundException> {
|
||||
filmLibraryService.removeFilm(command)
|
||||
}
|
||||
|
||||
verify(exactly = 1) { filmLibraryRepository.findAll() }
|
||||
verify(exactly = 0) { filmLibraryRepository.deleteById(any()) }
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should throw DomainException when removing film that is not in library`() {
|
||||
val userId = UUID.randomUUID()
|
||||
val libraryFilmId = UUID.randomUUID()
|
||||
val differentFilmId = UUID.randomUUID()
|
||||
val existingLibrary =
|
||||
FilmLibrary(
|
||||
id = UUID.randomUUID(),
|
||||
userId = userId,
|
||||
filmId = libraryFilmId,
|
||||
comment = "My Library",
|
||||
isViewed = false,
|
||||
)
|
||||
val command = RemoveFilmFromLibraryCommand(userId = userId, filmId = differentFilmId)
|
||||
|
||||
every { filmLibraryRepository.findAll() } returns listOf(existingLibrary)
|
||||
|
||||
assertThrows<DomainException> {
|
||||
filmLibraryService.removeFilm(command)
|
||||
}
|
||||
|
||||
verify(exactly = 1) { filmLibraryRepository.findAll() }
|
||||
verify(exactly = 0) { filmLibraryRepository.deleteById(any()) }
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should throw EntityNotFoundException when libraryId does not match`() {
|
||||
val userId = UUID.randomUUID()
|
||||
val filmId = UUID.randomUUID()
|
||||
val actualLibraryId = UUID.randomUUID()
|
||||
val wrongLibraryId = UUID.randomUUID()
|
||||
val existingLibrary =
|
||||
FilmLibrary(
|
||||
id = actualLibraryId,
|
||||
userId = userId,
|
||||
filmId = filmId,
|
||||
comment = "My Library",
|
||||
isViewed = false,
|
||||
)
|
||||
val command =
|
||||
RemoveFilmFromLibraryCommand(
|
||||
userId = userId,
|
||||
filmId = filmId,
|
||||
libraryId = wrongLibraryId,
|
||||
)
|
||||
|
||||
every { filmLibraryRepository.findAll() } returns listOf(existingLibrary)
|
||||
|
||||
assertThrows<EntityNotFoundException> {
|
||||
filmLibraryService.removeFilm(command)
|
||||
}
|
||||
|
||||
verify(exactly = 1) { filmLibraryRepository.findAll() }
|
||||
verify(exactly = 0) { filmLibraryRepository.deleteById(any()) }
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should get library successfully`() {
|
||||
val userId = UUID.randomUUID()
|
||||
val existingLibrary =
|
||||
FilmLibrary(
|
||||
id = UUID.randomUUID(),
|
||||
userId = userId,
|
||||
filmId = UUID.randomUUID(),
|
||||
comment = "My Library",
|
||||
isViewed = false,
|
||||
)
|
||||
val query = GetFilmLibraryQuery(userId = userId)
|
||||
|
||||
every { filmLibraryRepository.findAll() } returns listOf(existingLibrary)
|
||||
|
||||
val result = filmLibraryService.getLibrary(query)
|
||||
|
||||
assertEquals(existingLibrary, result)
|
||||
|
||||
verify(exactly = 1) { filmLibraryRepository.findAll() }
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should throw EntityNotFoundException when getting non-existent library`() {
|
||||
val userId = UUID.randomUUID()
|
||||
val query = GetFilmLibraryQuery(userId = userId)
|
||||
|
||||
every { filmLibraryRepository.findAll() } returns emptyList()
|
||||
|
||||
assertThrows<EntityNotFoundException> {
|
||||
filmLibraryService.getLibrary(query)
|
||||
}
|
||||
|
||||
verify(exactly = 1) { filmLibraryRepository.findAll() }
|
||||
}
|
||||
}
|
||||
@@ -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()) }
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,155 @@
|
||||
package com.project.movienight.application.services
|
||||
|
||||
import com.project.movienight.application.ports.input.CreateUserCommand
|
||||
import com.project.movienight.application.ports.input.EditUserCommand
|
||||
import com.project.movienight.application.ports.output.IdGenerator
|
||||
import com.project.movienight.application.ports.output.UserRepositoryPort
|
||||
import com.project.movienight.config.UserServiceProperties
|
||||
import com.project.movienight.domain.exception.BlockedValueException
|
||||
import com.project.movienight.domain.exception.EntityNotFoundException
|
||||
import com.project.movienight.domain.model.User
|
||||
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 UserServiceTest {
|
||||
private lateinit var userRepository: UserRepositoryPort
|
||||
private lateinit var idGenerator: IdGenerator
|
||||
private lateinit var userConfig: UserServiceProperties
|
||||
private lateinit var userService: UserService
|
||||
|
||||
@BeforeEach
|
||||
fun setup() {
|
||||
userRepository = mockk()
|
||||
idGenerator = mockk()
|
||||
userConfig = mockk()
|
||||
userService = UserService(userRepository, idGenerator, userConfig)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should create user successfully`() {
|
||||
val command = CreateUserCommand(name = "John Doe", email = "john@example.com")
|
||||
val userId = UUID.randomUUID()
|
||||
val expectedUser = User(id = userId, name = "John Doe", email = "john@example.com", library = null)
|
||||
|
||||
every { userConfig.isBlocked("John Doe") } returns false
|
||||
every { idGenerator.generateId() } returns userId
|
||||
every { userRepository.save(any()) } returns expectedUser
|
||||
|
||||
val result = userService.create(command)
|
||||
|
||||
assertNotNull(result)
|
||||
assertEquals(userId, result.id)
|
||||
assertEquals("John Doe", result.name)
|
||||
assertEquals("john@example.com", result.email)
|
||||
|
||||
verify(exactly = 1) { userConfig.isBlocked("John Doe") }
|
||||
verify(exactly = 1) { idGenerator.generateId() }
|
||||
verify(exactly = 1) { userRepository.save(any()) }
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should throw BlockedValueException when creating user with blocked name`() {
|
||||
val command = CreateUserCommand(name = "admin", email = "admin@example.com")
|
||||
|
||||
every { userConfig.isBlocked("admin") } returns true
|
||||
|
||||
assertThrows<BlockedValueException> {
|
||||
userService.create(command)
|
||||
}
|
||||
|
||||
verify(exactly = 1) { userConfig.isBlocked("admin") }
|
||||
verify(exactly = 0) { idGenerator.generateId() }
|
||||
verify(exactly = 0) { userRepository.save(any()) }
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should edit user successfully`() {
|
||||
val userId = UUID.randomUUID()
|
||||
val command = EditUserCommand(name = "Jane Doe")
|
||||
val existingUser = User(id = userId, name = "John Doe", email = "john@example.com", library = null)
|
||||
val updatedUser = User(id = userId, name = "Jane Doe", email = "john@example.com", library = null)
|
||||
|
||||
every { userConfig.isBlocked("Jane Doe") } returns false
|
||||
every { userRepository.findById(userId) } returns existingUser
|
||||
every { userRepository.save(any()) } returns updatedUser
|
||||
|
||||
val result = userService.edit(userId, command)
|
||||
|
||||
assertNotNull(result)
|
||||
assertEquals(userId, result.id)
|
||||
assertEquals("Jane Doe", result.name)
|
||||
|
||||
verify(exactly = 1) { userConfig.isBlocked("Jane Doe") }
|
||||
verify(exactly = 1) { userRepository.findById(userId) }
|
||||
verify(exactly = 1) { userRepository.save(any()) }
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should throw BlockedValueException when editing user with blocked name`() {
|
||||
val userId = UUID.randomUUID()
|
||||
val command = EditUserCommand(name = "root")
|
||||
|
||||
every { userConfig.isBlocked("root") } returns true
|
||||
|
||||
assertThrows<BlockedValueException> {
|
||||
userService.edit(userId, command)
|
||||
}
|
||||
|
||||
verify(exactly = 1) { userConfig.isBlocked("root") }
|
||||
verify(exactly = 0) { userRepository.findById(any()) }
|
||||
verify(exactly = 0) { userRepository.save(any()) }
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should throw EntityNotFoundException when editing non-existent user`() {
|
||||
val userId = UUID.randomUUID()
|
||||
val command = EditUserCommand(name = "Jane Doe")
|
||||
|
||||
every { userConfig.isBlocked("Jane Doe") } returns false
|
||||
every { userRepository.findById(userId) } returns null
|
||||
|
||||
assertThrows<EntityNotFoundException> {
|
||||
userService.edit(userId, command)
|
||||
}
|
||||
|
||||
verify(exactly = 1) { userConfig.isBlocked("Jane Doe") }
|
||||
verify(exactly = 1) { userRepository.findById(userId) }
|
||||
verify(exactly = 0) { userRepository.save(any()) }
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should delete user successfully`() {
|
||||
val userId = UUID.randomUUID()
|
||||
val existingUser = User(id = userId, name = "John Doe", email = "john@example.com", library = null)
|
||||
|
||||
every { userRepository.findById(userId) } returns existingUser
|
||||
justRun { userRepository.deleteById(userId) }
|
||||
|
||||
userService.delete(userId)
|
||||
|
||||
verify(exactly = 1) { userRepository.findById(userId) }
|
||||
verify(exactly = 1) { userRepository.deleteById(userId) }
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `should throw EntityNotFoundException when deleting non-existent user`() {
|
||||
val userId = UUID.randomUUID()
|
||||
|
||||
every { userRepository.findById(userId) } returns null
|
||||
|
||||
assertThrows<EntityNotFoundException> {
|
||||
userService.delete(userId)
|
||||
}
|
||||
|
||||
verify(exactly = 1) { userRepository.findById(userId) }
|
||||
verify(exactly = 0) { userRepository.deleteById(any()) }
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user