-- PostgreSQL DDL (production)
CREATE TYPE file_format_enum AS ENUM ('mp3', 'ogg', 'wav', 'm4b', 'aac', 'flac');

CREATE TABLE audiobook_files (
    id           UUID PRIMARY KEY,
    audiobook_id UUID NOT NULL,
    file_path    VARCHAR(2048) NOT NULL,
    format       file_format_enum NOT NULL,  -- ← PostgreSQL ENUM
    size         INTEGER
);

// Цей код працює на H2, але провалюється на PostgreSQL
String sql = "INSERT INTO audiobook_files (id, audiobook_id, file_path, format, size) " +
             "VALUES (?, ?, ?, ?, ?)";
stmt.setString(4, "mp3"); // H2: OK (VARCHAR)
                          // PostgreSQL: ERROR — потрібно CAST('mp3' AS file_format_enum)

// PostgreSQL вимагає явного приведення типу або використання setObject
stmt.setObject(4, "mp3", java.sql.Types.OTHER);
// або через PGobject (PostgreSQL JDBC driver)

-- PostgreSQL: пошук у JSON-полі
SELECT * FROM audiobooks 
WHERE metadata->>'language' = 'ukrainian'
  AND metadata->'tags' @> '["classic"]';

SELECT a.*, COUNT(ab.id) AS book_count
FROM authors a
LEFT JOIN audiobooks ab ON a.id = ab.author_id
GROUP BY a.id;

// Транзакція 1
UPDATE authors SET bio = 'Нова біографія' WHERE id = ?;
// Транзакція 2 (паралельно)
UPDATE authors SET image_path = '/new.jpg' WHERE id = ?; // той самий id

@Testcontainers // JUnit 5 extension
class AuthorRepositoryTest {

    @Container // керується Testcontainers
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:15-alpine")
        .withDatabaseName("test_db")
        .withUsername("test_user")
        .withPassword("test_pass");

    @Test
    void test1() { /* використовує той самий контейнер */ }

    @Test
    void test2() { /* використовує той самий контейнер */ }
}

@BeforeAll (JUnit)
  → Testcontainers запускає контейнер
  → Чекає на готовність PostgreSQL (health check)
  → Повертає JDBC URL з динамічним портом

test1() виконується
test2() виконується
...

@AfterAll (JUnit)
  → Testcontainers зупиняє контейнер
  → Видаляє контейнер (docker rm)

public abstract class AbstractIntegrationTest {

    private static final PostgreSQLContainer<?> POSTGRES;

    static {
        POSTGRES = new PostgreSQLContainer<>("postgres:15-alpine")
            .withDatabaseName("test_db")
            .withUsername("test")
            .withPassword("test")
            .withReuse(true); // ← дозволити повторне використання

        POSTGRES.start();
    }

    protected static String getJdbcUrl() {
        return POSTGRES.getJdbcUrl();
    }
}

class AuthorRepositoryTest {

    @Container // не static — новий контейнер для кожного тесту
    PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:15-alpine");

    @Test
    void test1() { /* власний контейнер */ }

    @Test
    void test2() { /* новий контейнер */ }
}

@BeforeEach
  → Запустити новий контейнер
  → Виконати DDL

test1()

@AfterEach
  → Зупинити контейнер

@BeforeEach
  → Запустити НОВИЙ контейнер
  → Виконати DDL

test2()

@AfterEach
  → Зупинити контейнер

# Через Homebrew
brew install --cask docker

# Або завантажити Docker Desktop з docker.com
# Docker Desktop включає Docker Engine + GUI

# Встановити Docker Engine
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io

# Додати поточного користувача до групи docker (щоб не потрібен sudo)
sudo usermod -aG docker $USER
newgrp docker

# Перевірити встановлення
docker run hello-world

# Завантажити Docker Desktop для Windows з docker.com
# Вимагає WSL 2 (Windows Subsystem for Linux)

<dependencies>
    <!-- JUnit 5 (вже є з попередньої статті) -->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter</artifactId>
        <version>5.10.2</version>
        <scope>test</scope>
    </dependency>

    <!-- Testcontainers Core -->
    <dependency>
        <groupId>org.testcontainers</groupId>
        <artifactId>testcontainers</artifactId>
        <version>1.19.7</version>
        <scope>test</scope>
    </dependency>

    <!-- Testcontainers JUnit 5 Integration -->
    <dependency>
        <groupId>org.testcontainers</groupId>
        <artifactId>junit-jupiter</artifactId>
        <version>1.19.7</version>
        <scope>test</scope>
    </dependency>

    <!-- Testcontainers PostgreSQL Module -->
    <dependency>
        <groupId>org.testcontainers</groupId>
        <artifactId>postgresql</artifactId>
        <version>1.19.7</version>
        <scope>test</scope>
    </dependency>

    <!-- PostgreSQL JDBC Driver (для production і тестів) -->
    <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <version>42.7.3</version>
    </dependency>

    <!-- AssertJ (вже є з попередньої статті) -->
    <dependency>
        <groupId>org.assertj</groupId>
        <artifactId>assertj-core</artifactId>
        <version>3.25.3</version>
        <scope>test</scope>
    </dependency>
</dependencies>

package com.example.audiobook.repository;

import com.example.audiobook.db.ConnectionManager;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.testcontainers.containers.PostgreSQLContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;
import org.testcontainers.utility.DockerImageName;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.stream.Collectors;

/**
 * Базовий клас для інтеграційних тестів з Testcontainers + PostgreSQL.
 * <p>
 * <b>Архітектурні рішення:</b>
 * <ul>
 *   <li><b>Singleton Container Pattern:</b> Один контейнер PostgreSQL для всього
 *       тестового класу (static @Container). Це швидше за створення нового
 *       контейнера для кожного тесту.</li>
 *   <li><b>Ізоляція через TRUNCATE:</b> Кожен тест очищує всі таблиці у
 *       {@code @BeforeEach}, гарантуючи незалежність тестів.</li>
 *   <li><b>DDL виконується один раз:</b> Схема БД створюється у {@code @BeforeAll}
 *       і використовується всіма тестами.</li>
 * </ul>
 * <p>
 * <b>Lifecycle:</b>
 * <pre>
 * @BeforeAll (один раз для класу)
 *   → Testcontainers запускає PostgreSQL контейнер
 *   → Виконується DDL-скрипт (CREATE TABLE)
 *   → Створюється ConnectionManager
 *
 * @BeforeEach (перед кожним тестом)
 *   → TRUNCATE всіх таблиць (очищення даних)
 *
 * test1() → test2() → test3() ...
 *
 * @AfterEach (після кожного тесту)
 *   → Закрити з'єднання (опціонально)
 *
 * @AfterAll (один раз після всіх тестів)
 *   → Testcontainers зупиняє і видаляє контейнер
 * </pre>
 */
@Testcontainers // JUnit 5 extension для автоматичного управління контейнерами
public abstract class AbstractPostgresIntegrationTest {

    /**
     * PostgreSQL контейнер — спільний для всіх тестів у класі.
     * <p>
     * <b>static:</b> Контейнер запускається один раз для класу, а не для кожного тесту.
     * Це значно швидше (запуск контейнера займає 2–5 секунд).
     * <p>
     * <b>@Container:</b> Testcontainers автоматично керує lifecycle:
     * запускає перед {@code @BeforeAll}, зупиняє після {@code @AfterAll}.
     * <p>
     * <b>DockerImageName.parse():</b> Явно вказуємо Docker-образ з версією.
     * Це гарантує, що тести використовують ту саму версію PostgreSQL, що й production.
     */
    @Container
    protected static final PostgreSQLContainer<?> POSTGRES = 
        new PostgreSQLContainer<>(DockerImageName.parse("postgres:15-alpine"))
            .withDatabaseName("audiobook_test_db")
            .withUsername("test_user")
            .withPassword("test_password")
            .withReuse(false); // false = новий контейнер для кожного запуску тестів

    /**
     * ConnectionManager для тестової БД.
     * Створюється після запуску контейнера у {@code @BeforeAll}.
     */
    protected static ConnectionManager connectionManager;

    /**
     * Ініціалізує ConnectionManager та виконує DDL-скрипт.
     * <p>
     * Викликається один раз перед усіма тестами класу.
     * На цьому етапі PostgreSQL контейнер вже запущений (завдяки @Container).
     */
    @BeforeAll
    static void initializeDatabase() throws IOException, SQLException {
        // Отримати JDBC URL з динамічним портом
        // Приклад: jdbc:postgresql://localhost:32768/audiobook_test_db
        String jdbcUrl = POSTGRES.getJdbcUrl();
        String username = POSTGRES.getUsername();
        String password = POSTGRES.getPassword();

        // Створити ConnectionManager для тестової БД
        connectionManager = new ConnectionManager(jdbcUrl, username, password);

        // Виконати DDL-скрипт (створити таблиці)
        executeDdlScript("ddl_postgres.sql");
    }

    /**
     * Очищує всі таблиці перед кожним тестом.
     * <p>
     * Це гарантує ізоляцію тестів: кожен тест починає з порожньої БД.
     * Використовуємо {@code TRUNCATE} замість {@code DELETE}, оскільки:
     * <ul>
     *   <li>TRUNCATE швидший (не генерує WAL-записи для кожного рядка)</li>
     *   <li>TRUNCATE скидає AUTO_INCREMENT лічильники</li>
     *   <li>TRUNCATE ... CASCADE автоматично очищає пов'язані таблиці</li>
     * </ul>
     */
    @BeforeEach
    void cleanDatabase() throws SQLException {
        try (Connection conn = connectionManager.getConnection();
             Statement stmt = conn.createStatement()) {
            
            // TRUNCATE всі таблиці у правильному порядку (від дочірніх до батьківських)
            // CASCADE автоматично очистить пов'язані таблиці через FK
            stmt.execute("TRUNCATE TABLE audiobook_files CASCADE");
            stmt.execute("TRUNCATE TABLE listening_progresses CASCADE");
            stmt.execute("TRUNCATE TABLE audiobook_collection CASCADE");
            stmt.execute("TRUNCATE TABLE collections CASCADE");
            stmt.execute("TRUNCATE TABLE audiobooks CASCADE");
            stmt.execute("TRUNCATE TABLE authors CASCADE");
            stmt.execute("TRUNCATE TABLE genres CASCADE");
            stmt.execute("TRUNCATE TABLE users CASCADE");
        }
    }

    /**
     * Закриває ConnectionManager після всіх тестів.
     * Контейнер PostgreSQL автоматично зупиняється Testcontainers.
     */
    @AfterEach
    void tearDown() {
        // У цій реалізації нічого не робимо — ConnectionManager залишається відкритим
        // для наступних тестів. Закриття відбувається у @AfterAll (якщо потрібно).
    }

    // ═══════════════════════════════════════════════════════════════════════
    // Утилітні методи (аналогічні AbstractRepositoryTest з H2)
    // ═══════════════════════════════════════════════════════════════════════

    /**
     * Виконує DDL-скрипт з ресурсів.
     * <p>
     * Скрипт має бути PostgreSQL-сумісним (не H2!).
     * Розташування: {@code src/test/resources/ddl_postgres.sql}
     */
    protected static void executeDdlScript(String scriptPath) throws IOException, SQLException {
        String sql = loadResourceAsString(scriptPath);
        
        try (Connection conn = connectionManager.getConnection();
             Statement stmt = conn.createStatement()) {
            
            // PostgreSQL підтримує багаторядкові команди через ;
            String[] commands = sql.split(";");
            for (String command : commands) {
                String trimmed = command.trim();
                if (!trimmed.isEmpty() && !trimmed.startsWith("--")) {
                    stmt.execute(trimmed);
                }
            }
        }
    }

    /**
     * Завантажує файл з ресурсів як рядок.
     */
    protected static String loadResourceAsString(String resourcePath) throws IOException {
        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(
                    AbstractPostgresIntegrationTest.class
                        .getClassLoader()
                        .getResourceAsStream(resourcePath),
                    StandardCharsets.UTF_8))) {
            return reader.lines().collect(Collectors.joining("\n"));
        }
    }

    /**
     * Підраховує кількість рядків у таблиці.
     */
    protected long countRowsInTable(String tableName) throws SQLException {
        String sql = "SELECT COUNT(*) FROM " + tableName;
        try (Connection conn = connectionManager.getConnection();
             Statement stmt = conn.createStatement();
             var rs = stmt.executeQuery(sql)) {
            rs.next();
            return rs.getLong(1);
        }
    }

    /**
     * Виконує довільний SQL-запит (для підготовки тестових даних).
     */
    protected void executeSql(String sql) throws SQLException {
        try (Connection conn = connectionManager.getConnection();
             Statement stmt = conn.createStatement()) {
            stmt.execute(sql);
        }
    }
}

-- PostgreSQL 15 DDL для тестів
-- Використовує всі можливості PostgreSQL (ENUM, CHECK, CASCADE)

-- ENUM для форматів аудіофайлів
CREATE TYPE file_format_enum AS ENUM ('mp3', 'ogg', 'wav', 'm4b', 'aac', 'flac');

-- Таблиця авторів
CREATE TABLE authors (
    id          UUID         PRIMARY KEY,
    first_name  VARCHAR(64)  NOT NULL,
    last_name   VARCHAR(64)  NOT NULL,
    bio         TEXT,
    image_path  VARCHAR(2048)
);

-- Таблиця жанрів
CREATE TABLE genres (
    id          UUID         PRIMARY KEY,
    name        VARCHAR(64)  NOT NULL UNIQUE,
    description TEXT
);

-- Таблиця аудіокниг
CREATE TABLE audiobooks (
    id               UUID         PRIMARY KEY,
    author_id        UUID         NOT NULL,
    genre_id         UUID         NOT NULL,
    title            VARCHAR(255) NOT NULL,
    duration         INTEGER      NOT NULL CHECK (duration > 0),
    release_year     INTEGER      NOT NULL 
                     CHECK (release_year >= 1900 AND release_year <= EXTRACT(YEAR FROM CURRENT_DATE) + 1),
    description      TEXT,
    cover_image_path VARCHAR(2048),
    
    CONSTRAINT audiobooks_author_fk 
        FOREIGN KEY (author_id) REFERENCES authors(id) ON DELETE CASCADE,
    CONSTRAINT audiobooks_genre_fk 
        FOREIGN KEY (genre_id) REFERENCES genres(id) ON DELETE CASCADE
);

CREATE INDEX audiobooks_author_id_idx ON audiobooks(author_id);
CREATE INDEX audiobooks_genre_id_idx  ON audiobooks(genre_id);

-- Таблиця користувачів
CREATE TABLE users (
    id            UUID         PRIMARY KEY,
    username      VARCHAR(64)  NOT NULL UNIQUE 
                  CHECK (LENGTH(TRIM(username)) > 0),
    password_hash VARCHAR(128) NOT NULL,
    email         VARCHAR(376),
    avatar_path   VARCHAR(2048)
);

CREATE INDEX users_email_idx ON users(email);

-- Таблиця колекцій користувачів
CREATE TABLE collections (
    id         UUID      PRIMARY KEY,
    user_id    UUID      NOT NULL,
    name       VARCHAR(128) NOT NULL CHECK (LENGTH(TRIM(name)) > 0),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    
    CONSTRAINT collections_user_fk 
        FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
);

-- Зв'язок багато-до-багатьох: колекції ↔ аудіокниги
CREATE TABLE audiobook_collection (
    collection_id UUID NOT NULL,
    audiobook_id  UUID NOT NULL,
    
    PRIMARY KEY (collection_id, audiobook_id),
    
    CONSTRAINT ac_collection_fk 
        FOREIGN KEY (collection_id) REFERENCES collections(id) ON DELETE CASCADE,
    CONSTRAINT ac_audiobook_fk 
        FOREIGN KEY (audiobook_id) REFERENCES audiobooks(id) ON DELETE CASCADE
);

-- Таблиця файлів аудіокниг (використовує ENUM)
CREATE TABLE audiobook_files (
    id           UUID             PRIMARY KEY,
    audiobook_id UUID             NOT NULL,
    file_path    VARCHAR(2048)    NOT NULL CHECK (LENGTH(TRIM(file_path)) > 0),
    format       file_format_enum NOT NULL,  -- ← PostgreSQL ENUM
    size         INTEGER          CHECK (size IS NULL OR size > 0),
    
    CONSTRAINT af_audiobook_fk 
        FOREIGN KEY (audiobook_id) REFERENCES audiobooks(id) ON DELETE CASCADE
);

CREATE INDEX audiobook_files_audiobook_id_idx ON audiobook_files(audiobook_id);

-- Таблиця прогресу прослуховування
CREATE TABLE listening_progresses (
    id            UUID      PRIMARY KEY,
    user_id       UUID      NOT NULL,
    audiobook_id  UUID      NOT NULL,
    position      INTEGER   NOT NULL CHECK (position >= 0),
    last_listened TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    
    CONSTRAINT lp_user_fk 
        FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
    CONSTRAINT lp_audiobook_fk 
        FOREIGN KEY (audiobook_id) REFERENCES audiobooks(id) ON DELETE CASCADE
);

CREATE INDEX listening_progresses_user_id_idx      ON listening_progresses(user_id);
CREATE INDEX listening_progresses_audiobook_id_idx ON listening_progresses(audiobook_id);

package com.example.audiobook.repository;

import com.example.audiobook.domain.Author;
import com.example.audiobook.repository.jdbc.JdbcAuthorRepository;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import java.util.List;
import java.util.Optional;
import java.util.UUID;

import static org.assertj.core.api.Assertions.*;

/**
 * Інтеграційні тести {@link JdbcAuthorRepository} з реальною PostgreSQL.
 * <p>
 * <b>Відмінності від H2-версії:</b>
 * <ul>
 *   <li>Базовий клас: {@link AbstractPostgresIntegrationTest} замість
 *       {@code AbstractRepositoryTest}</li>
 *   <li>БД: Реальна PostgreSQL у Docker-контейнері замість in-memory H2</li>
 *   <li>Швидкість: Повільніше (~50ms на тест замість ~5ms), але точніше</li>
 * </ul>
 * <p>
 * <b>Що тестується:</b>
 * <ul>
 *   <li>CRUD-операції (save, findById, update, delete)</li>
 *   <li>Пошукові методи (findByLastName, findByFullName)</li>
 *   <li>Граничні випадки (null-значення, порожні результати)</li>
 *   <li>Constraints (PRIMARY KEY, NOT NULL)</li>
 * </ul>
 */
class JdbcAuthorRepositoryPostgresTest extends AbstractPostgresIntegrationTest {

    private AuthorRepository repository;

    @BeforeEach
    void setUpRepository() {
        // connectionManager вже ініціалізований у AbstractPostgresIntegrationTest
        repository = new JdbcAuthorRepository(connectionManager);
    }

    // ═══════════════════════════════════════════════════════════════════════
    // Тести save() — ідентичні H2-версії
    // ═══════════════════════════════════════════════════════════════════════

    @Test
    void save_shouldInsertNewAuthor_whenValidData() {
        // ═══ Arrange ═══
        Author author = new Author("Іван", "Франко");
        author.setBio("Український письменник, поет, публіцист, політичний діяч");
        author.setImagePath("/images/franko.jpg");

        // ═══ Act ═══
        repository.save(author);

        // ═══ Assert ═══
        assertThat(author.getId()).isNotNull();
        
        Author loaded = repository.findById(author.getId()).orElseThrow();
        assertThat(loaded.getFirstName()).isEqualTo("Іван");
        assertThat(loaded.getLastName()).isEqualTo("Франко");
        assertThat(loaded.getBio()).isEqualTo("Український письменник, поет, публіцист, політичний діяч");
        assertThat(loaded.getImagePath()).isEqualTo("/images/franko.jpg");
        
        assertThat(countRowsInTable("authors")).isEqualTo(1);
    }

    @Test
    void save_shouldHandleNullBio_whenBioNotProvided() {
        // ═══ Arrange ═══
        Author author = new Author("Леся", "Українка");
        // bio та imagePath залишаються null

        // ═══ Act ═══
        repository.save(author);

        // ═══ Assert ═══
        Author loaded = repository.findById(author.getId()).orElseThrow();
        assertThat(loaded.getBio()).isNull();
        assertThat(loaded.getImagePath()).isNull();
    }

    @Test
    void save_shouldThrowException_whenDuplicateId() {
        // ═══ Arrange ═══
        UUID sharedId = UUID.randomUUID();
        
        Author author1 = new Author("Тарас", "Шевченко");
        author1.setId(sharedId);
        
        Author author2 = new Author("Іван", "Франко");
        author2.setId(sharedId);

        repository.save(author1);

        // ═══ Act & Assert ═══
        assertThatThrownBy(() -> repository.save(author2))
            .isInstanceOf(com.example.audiobook.db.DatabaseException.class)
            .hasMessageContaining("duplicate key"); // PostgreSQL повідомлення
    }

    // ═══════════════════════════════════════════════════════════════════════
    // Тести findById() — ідентичні H2-версії
    // ═══════════════════════════════════════════════════════════════════════

    @Test
    void findById_shouldReturnAuthor_whenExists() {
        // ═══ Arrange ═══
        Author author = new Author("Михайло", "Коцюбинський");
        repository.save(author);

        // ═══ Act ═══
        Optional<Author> result = repository.findById(author.getId());

        // ═══ Assert ═══
        assertThat(result).isPresent();
        assertThat(result.get().getFirstName()).isEqualTo("Михайло");
        assertThat(result.get().getLastName()).isEqualTo("Коцюбинський");
    }

    @Test
    void findById_shouldReturnEmpty_whenNotExists() {
        // ═══ Arrange ═══
        UUID nonExistentId = UUID.randomUUID();

        // ═══ Act ═══
        Optional<Author> result = repository.findById(nonExistentId);

        // ═══ Assert ═══
        assertThat(result).isEmpty();
    }

    // ═══════════════════════════════════════════════════════════════════════
    // Тести update() та delete() — ідентичні H2-версії
    // ═══════════════════════════════════════════════════════════════════════

    @Test
    void update_shouldModifyAllFields_whenAuthorExists() {
        // ═══ Arrange ═══
        Author author = new Author("Іван", "Франко");
        author.setBio("Стара біографія");
        repository.save(author);

        author.setFirstName("Іван Якович");
        author.setLastName("Франко-Захарченко");
        author.setBio("Нова біографія");
        author.setImagePath("/images/new.jpg");

        // ═══ Act ═══
        repository.update(author);

        // ═══ Assert ═══
        Author loaded = repository.findById(author.getId()).orElseThrow();
        assertThat(loaded.getFirstName()).isEqualTo("Іван Якович");
        assertThat(loaded.getLastName()).isEqualTo("Франко-Захарченко");
        assertThat(loaded.getBio()).isEqualTo("Нова біографія");
        assertThat(loaded.getImagePath()).isEqualTo("/images/new.jpg");
    }

    @Test
    void deleteById_shouldRemoveAuthor_whenExists() {
        // ═══ Arrange ═══
        Author author = new Author("Панас", "Мирний");
        repository.save(author);
        UUID authorId = author.getId();

        // ═══ Act ═══
        boolean deleted = repository.deleteById(authorId);

        // ═══ Assert ═══
        assertThat(deleted).isTrue();
        assertThat(repository.findById(authorId)).isEmpty();
        assertThat(countRowsInTable("authors")).isEqualTo(0);
    }

    // ═══════════════════════════════════════════════════════════════════════
    // Тести findByLastName() — ідентичні H2-версії
    // ═══════════════════════════════════════════════════════════════════════

    @Test
    void findByLastName_shouldReturnMatchingAuthors_whenPartialMatch() {
        // ═══ Arrange ═══
        repository.save(new Author("Тарас", "Шевченко"));
        repository.save(new Author("Іван", "Франко"));
        repository.save(new Author("Леся", "Українка"));
        repository.save(new Author("Григорій", "Сковорода"));

        // ═══ Act ═══
        List<Author> result = repository.findByLastName("ко");

        // ═══ Assert ═══
        assertThat(result).hasSize(2);
        assertThat(result)
            .extracting(Author::getLastName)
            .containsExactlyInAnyOrder("Франко", "Сковорода");
    }

    @Test
    void findByLastName_shouldBeCaseInsensitive_whenSearching() {
        // ═══ Arrange ═══
        repository.save(new Author("Тарас", "Шевченко"));

        // ═══ Act ═══
        List<Author> result1 = repository.findByLastName("шевч");
        List<Author> result2 = repository.findByLastName("ШЕВЧ");
        List<Author> result3 = repository.findByLastName("ШеВч");

        // ═══ Assert ═══
        assertThat(result1).hasSize(1);
        assertThat(result2).hasSize(1);
        assertThat(result3).hasSize(1);
    }
}

package com.example.audiobook.repository;

import com.example.audiobook.domain.Author;
import com.example.audiobook.domain.Audiobook;
import com.example.audiobook.domain.AudiobookFile;
import com.example.audiobook.domain.Genre;
import com.example.audiobook.repository.jdbc.*;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.UUID;

import static org.assertj.core.api.Assertions.*;

/**
 * Тести для PostgreSQL ENUM-типів.
 * <p>
 * <b>Що тестується:</b>
 * <ul>
 *   <li>Вставка валідних ENUM-значень</li>
 *   <li>Відхилення невалідних ENUM-значень на рівні БД</li>
 *   <li>Маппінг ENUM → Java enum (якщо використовується)</li>
 * </ul>
 * <p>
 * <b>Чому це неможливо на H2:</b>
 * H2 не має справжніх ENUM — лише VARCHAR з CHECK constraint.
 * CHECK constraint перевіряє значення на рівні рядка, а не типу.
 */
class AudiobookFileEnumTest extends AbstractPostgresIntegrationTest {

    private AudiobookFileRepository fileRepo;
    private AudiobookRepository audiobookRepo;
    private AuthorRepository authorRepo;
    private GenreRepository genreRepo;

    @BeforeEach
    void setUpRepositories() {
        fileRepo = new JdbcAudiobookFileRepository(connectionManager);
        audiobookRepo = new JdbcAudiobookRepository(connectionManager);
        authorRepo = new JdbcAuthorRepository(connectionManager);
        genreRepo = new JdbcGenreRepository(connectionManager);
    }

    @Test
    void save_shouldInsertFile_whenValidEnumFormat() throws SQLException {
        // ═══ Arrange ═══
        // Створити батьківські сутності
        Author author = new Author("Автор", "Тест");
        Genre genre = new Genre("Жанр");
        authorRepo.save(author);
        genreRepo.save(genre);

        Audiobook book = new Audiobook("Книга", author, genre);
        book.setDuration(3600);
        book.setReleaseYear(2020);
        audiobookRepo.save(book);

        // Створити файл з валідним ENUM-форматом
        AudiobookFile file = new AudiobookFile();
        file.setId(UUID.randomUUID());
        file.setAudiobookId(book.getId());
        file.setFilePath("/files/book.mp3");
        file.setFormat("mp3"); // ← валідне значення з file_format_enum
        file.setSize(10485760); // 10 MB

        // ═══ Act ═══
        fileRepo.save(file);

        // ═══ Assert ═══
        AudiobookFile loaded = fileRepo.findById(file.getId()).orElseThrow();
        assertThat(loaded.getFormat()).isEqualTo("mp3");
        assertThat(loaded.getFilePath()).isEqualTo("/files/book.mp3");
    }

    @Test
    void save_shouldThrowException_whenInvalidEnumFormat() throws SQLException {
        // ═══ Arrange ═══
        Author author = new Author("Автор", "Тест");
        Genre genre = new Genre("Жанр");
        authorRepo.save(author);
        genreRepo.save(genre);

        Audiobook book = new Audiobook("Книга", author, genre);
        book.setDuration(3600);
        book.setReleaseYear(2020);
        audiobookRepo.save(book);

        // ═══ Act & Assert ═══
        // Спроба вставити невалідне значення ENUM через сирий SQL
        // (обходимо Java-валідацію, щоб протестувати БД-рівень)
        String sql = "INSERT INTO audiobook_files (id, audiobook_id, file_path, format, size) " +
                     "VALUES (?, ?, ?, ?::file_format_enum, ?)";

        assertThatThrownBy(() -> {
            try (Connection conn = connectionManager.getConnection();
                 PreparedStatement stmt = conn.prepareStatement(sql)) {
                stmt.setObject(1, UUID.randomUUID());
                stmt.setObject(2, book.getId());
                stmt.setString(3, "/files/book.xyz");
                stmt.setString(4, "xyz"); // ← НЕВАЛІДНЕ значення (не у ENUM)
                stmt.setInt(5, 1000);
                stmt.executeUpdate();
            }
        })
        .isInstanceOf(SQLException.class)
        .hasMessageContaining("invalid input value for enum file_format_enum");
        // PostgreSQL чітко повідомляє, що значення не входить до ENUM
    }

    @Test
    void save_shouldAcceptAllValidEnumValues_whenIteratingFormats() throws SQLException {
        // ═══ Arrange ═══
        Author author = new Author("Автор", "Тест");
        Genre genre = new Genre("Жанр");
        authorRepo.save(author);
        genreRepo.save(genre);

        Audiobook book = new Audiobook("Книга", author, genre);
        book.setDuration(3600);
        book.setReleaseYear(2020);
        audiobookRepo.save(book);

        // Всі валідні значення з ENUM
        String[] validFormats = {"mp3", "ogg", "wav", "m4b", "aac", "flac"};

        // ═══ Act & Assert ═══
        for (String format : validFormats) {
            AudiobookFile file = new AudiobookFile();
            file.setId(UUID.randomUUID());
            file.setAudiobookId(book.getId());
            file.setFilePath("/files/book." + format);
            file.setFormat(format);
            file.setSize(1000);

            // Має пройти без виключень
            assertThatCode(() -> fileRepo.save(file))
                .doesNotThrowAnyException();
        }

        // Перевірка: у БД має бути 6 файлів
        assertThat(countRowsInTable("audiobook_files")).isEqualTo(6);
    }
}

Author → Audiobook → AudiobookFile
       → Audiobook → AudiobookCollection → Collection

@Test
void deleteAuthor_shouldCascadeDeleteAudiobooksAndFiles_whenAuthorHasComplexRelations() 
        throws SQLException {
    // ═══ Arrange ═══
    // Створити автора
    Author author = new Author("Тарас", "Шевченко");
    authorRepo.save(author);

    // Створити жанр
    Genre genre = new Genre("Поезія");
    genreRepo.save(genre);

    // Створити 2 аудіокниги цього автора
    Audiobook book1 = new Audiobook("Кобзар", author, genre);
    book1.setDuration(10000);
    book1.setReleaseYear(1840);
    audiobookRepo.save(book1);

    Audiobook book2 = new Audiobook("Гайдамаки", author, genre);
    book2.setDuration(8000);
    book2.setReleaseYear(1841);
    audiobookRepo.save(book2);

    // Створити файли для кожної книги
    AudiobookFile file1 = new AudiobookFile();
    file1.setId(UUID.randomUUID());
    file1.setAudiobookId(book1.getId());
    file1.setFilePath("/files/kobzar.mp3");
    file1.setFormat("mp3");
    fileRepo.save(file1);

    AudiobookFile file2 = new AudiobookFile();
    file2.setId(UUID.randomUUID());
    file2.setAudiobookId(book2.getId());
    file2.setFilePath("/files/haidamaky.mp3");
    file2.setFormat("mp3");
    fileRepo.save(file2);

    // Створити користувача та колекцію
    User user = new User("testuser", "hash");
    userRepo.save(user);

    Collection collection = new Collection(user, "Українська класика");
    collectionRepo.save(collection);

    // Додати книги до колекції
    collectionRepo.addAudiobook(collection.getId(), book1.getId());
    collectionRepo.addAudiobook(collection.getId(), book2.getId());

    // Перевірка початкового стану
    assertThat(countRowsInTable("authors")).isEqualTo(1);
    assertThat(countRowsInTable("audiobooks")).isEqualTo(2);
    assertThat(countRowsInTable("audiobook_files")).isEqualTo(2);
    assertThat(countRowsInTable("audiobook_collection")).isEqualTo(2);

    // ═══ Act ═══
    // Видалити автора → має каскадно видалити ВСЕ
    authorRepo.deleteById(author.getId());

    // ═══ Assert ═══
    // Автор видалений
    assertThat(authorRepo.findById(author.getId())).isEmpty();
    
    // Аудіокниги видалені (ON DELETE CASCADE з authors)
    assertThat(audiobookRepo.findById(book1.getId())).isEmpty();
    assertThat(audiobookRepo.findById(book2.getId())).isEmpty();
    assertThat(countRowsInTable("audiobooks")).isEqualTo(0);
    
    // Файли видалені (ON DELETE CASCADE з audiobooks)
    assertThat(fileRepo.findById(file1.getId())).isEmpty();
    assertThat(fileRepo.findById(file2.getId())).isEmpty();
    assertThat(countRowsInTable("audiobook_files")).isEqualTo(0);
    
    // Зв'язки з колекціями видалені (ON DELETE CASCADE з audiobooks)
    assertThat(countRowsInTable("audiobook_collection")).isEqualTo(0);
    
    // Але колекція та користувач залишилися (немає FK на автора)
    assertThat(collectionRepo.findById(collection.getId())).isPresent();
    assertThat(userRepo.findById(user.getId())).isPresent();
}

# .github/workflows/test.yml
name: Integration Tests

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest  # Ubuntu має Docker за замовчуванням

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Set up JDK 17
        uses: actions/setup-java@v4
        with:
          java-version: '17'
          distribution: 'temurin'
          cache: 'maven'

      - name: Run integration tests
        run: mvn verify -P integration-tests

      - name: Upload test reports
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: test-reports
          path: target/surefire-reports/

# .gitlab-ci.yml
stages:
  - test

integration-tests:
  stage: test
  image: maven:3.9-eclipse-temurin-17  # Maven + JDK 17
  
  services:
    - docker:24-dind  # Docker-in-Docker

  variables:
    DOCKER_HOST: tcp://docker:2375
    DOCKER_TLS_CERTDIR: ""
    MAVEN_OPTS: "-Dmaven.repo.local=.m2/repository"

  script:
    - mvn verify -P integration-tests

  artifacts:
    when: always
    reports:
      junit: target/surefire-reports/TEST-*.xml
    paths:
      - target/surefire-reports/

  cache:
    paths:
      - .m2/repository

// Jenkinsfile
pipeline {
    agent {
        docker {
            image 'maven:3.9-eclipse-temurin-17'
            args '-v /var/run/docker.sock:/var/run/docker.sock'
            // Монтуємо Docker socket з host-машини
        }
    }

    stages {
        stage('Test') {
            steps {
                sh 'mvn verify -P integration-tests'
            }
        }
    }

    post {
        always {
            junit 'target/surefire-reports/*.xml'
        }
    }
}

┌─────────────────────────────────────────────────────────┐
│  Швидкі тести (H2)                                      │
│  • CRUD-операції                                        │
│  • Базові constraints                                   │
│  • Прості запити                                        │
│  • Виконуються при кожному збереженні файлу             │
│  Час: 0.5–1s для 20 тестів                              │
└─────────────────────────────────────────────────────────┘
                          ↓
┌─────────────────────────────────────────────────────────┐
│  Повні тести (Testcontainers)                           │
│  • PostgreSQL-специфічні функції                        │
│  • Складні JOIN та транзакції                           │
│  • Тести продуктивності                                 │
│  • Виконуються перед commit та у CI/CD                  │
│  Час: 2–3s для 20 тестів + 3s запуск контейнера         │
└─────────────────────────────────────────────────────────┘