src/test/kotlin/com/project/movienight/adapters/persistence/jdbc/FilmLibraryRepositoryIntegrationTest.kt

@@ -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)
+    }
+}

src/test/kotlin/com/project/movienight/adapters/persistence/jdbc/FilmRepositoryIntegrationTest.kt

@@ -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)
+    }
+}

src/test/kotlin/com/project/movienight/adapters/persistence/jdbc/UserRepositoryIntegrationTest.kt

@@ -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)
+    }
+}

src/test/resources/application-test.yaml

@@ -0,0 +1,28 @@
+spring:
+  application:
+    name: MovieNight-Test
+  datasource:
+    url: jdbc:h2:mem:testdb;MODE=PostgreSQL;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE
+    username: sa
+    password:
+    driver-class-name: org.h2.Driver
+  flyway:
+    enabled: true
+    url: jdbc:h2:mem:testdb;MODE=PostgreSQL;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE
+    locations: classpath:db/migration
+    baseline-on-migrate: true
+  h2:
+    console:
+      enabled: false
+
+services:
+  user:
+    blocked-names:
+      - admin
+      - root
+      - system
+  film:
+    blocked-patterns:
+      - censored
+      - epstein
+      - python