Initial commit

2026-07-12 14:34:52 +04:00
commit 3abf6bd9c2
557 changed files with 68706 additions and 0 deletions
@@ -0,0 +1,6 @@
+#include <gtest/gtest.h>
+
+int main(int argc, char **argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
@@ -0,0 +1,380 @@
+#include "sqlite_database.h"
+#include "sqlite_file_executor.h"
+#include "gtest/gtest.h"
+
+// WARNING: Foreign keys are off
+// WARNING: Triggers are off
+
+const std::string TEST_DB = "test.db";
+
+// Test fixture for SQLiteDatabase
+class SQLiteDatabaseCRUDTest : public ::testing::Test {
+protected:
+  SQLiteDatabase *db_;
+
+  void SetUp() override {
+    db_ = new SQLiteDatabase(TEST_DB);
+    SQLiteFileExecutor executor(TEST_DB);
+    executor.executeSQLFile("sql/cinema_db_drop_table.sql");
+    executor.executeSQLFile("sql/cinema_db_create_table.sql");
+
+    // Not necessarily, since the default setting
+    std::string sql;
+    FileReaderInterface *reader = &executor;
+    reader->read("sql/cinema_db_foreign_key_off.sql", sql);
+    db_->executeNonQuery(sql);
+  }
+
+  void TearDown() override {
+    delete db_;
+    remove(TEST_DB.c_str());
+  }
+};
+
+// INFO: ----- GENERAL -----
+
+// Check that the test fixture is working
+class SimpleClass : public ::testing::Test {
+protected:
+  void SetUp() override {}
+  void TearDown() override {}
+};
+// Simle test
+TEST_F(SimpleClass, SimpleTest) { EXPECT_EQ(1, 1); }
+
+// INFO: ----- GENERAL -----
+
+// Test checking if the database is available
+TEST_F(SQLiteDatabaseCRUDTest, IsDatabaseAvailable) {
+  EXPECT_TRUE(db_->isDatabaseAvailable());
+}
+
+// INFO: ----- GENRE -----
+
+// Test adding a genre
+TEST_F(SQLiteDatabaseCRUDTest, AddGenre) {
+  NewGenre genre{"Action"};
+  EXPECT_TRUE(db_->addGenre(genre));
+
+  auto genres = db_->getAllGenres();
+  ASSERT_EQ(genres.size(), 1);
+  EXPECT_EQ(genres[0].genre_name, "Action");
+}
+
+// Test getting a genre by ID
+TEST_F(SQLiteDatabaseCRUDTest, GetGenreById) {
+  NewGenre genre{"Drama"};
+  db_->addGenre(genre);
+
+  Genre retrieved_genre = db_->getGenre(1);
+  EXPECT_EQ(retrieved_genre.genre_id, 1);
+  EXPECT_EQ(retrieved_genre.genre_name, "Drama");
+}
+
+// Test updating a genre
+TEST_F(SQLiteDatabaseCRUDTest, UpdateGenre) {
+  NewGenre genre{"Drama"};
+  db_->addGenre(genre);
+
+  Genre updated_genre = db_->getGenre(1);
+  updated_genre.genre_name = "Horror";
+  EXPECT_TRUE(db_->updateGenre(updated_genre));
+
+  Genre retrieved_genre = db_->getGenre(1);
+  EXPECT_EQ(retrieved_genre.genre_id, 1);
+  EXPECT_EQ(retrieved_genre.genre_name, "Horror");
+}
+
+// Test removing a genre
+TEST_F(SQLiteDatabaseCRUDTest, RemoveGenre) {
+  NewGenre genre{"Horror"};
+  db_->addGenre(genre);
+  EXPECT_TRUE(db_->removeGenre(1));
+
+  auto genres = db_->getAllGenres();
+  EXPECT_TRUE(genres.empty());
+}
+
+// Test getting all genres
+TEST_F(SQLiteDatabaseCRUDTest, GetAllGenres) {
+  db_->addGenre({"Comedy"});
+  db_->addGenre({"Thriller"});
+
+  auto genres = db_->getAllGenres();
+  ASSERT_EQ(genres.size(), 2);
+  EXPECT_EQ(genres[0].genre_name, "Comedy");
+  EXPECT_EQ(genres[1].genre_name, "Thriller");
+}
+
+// INFO: ----- MOVIE -----
+
+// Test adding a movie
+TEST_F(SQLiteDatabaseCRUDTest, AddMovie) {
+  NewMovie movie{"The Shawshank Redemption", 1, 142};
+  EXPECT_TRUE(db_->addMovie(movie));
+
+  auto movies = db_->getAllMovies();
+  ASSERT_EQ(movies.size(), 1);
+  EXPECT_EQ(movies[0].title, "The Shawshank Redemption");
+  EXPECT_EQ(movies[0].genre_id, 1);
+  EXPECT_EQ(movies[0].duration, 142);
+}
+
+// Test getting a movie by ID
+TEST_F(SQLiteDatabaseCRUDTest, GetMovieById) {
+  NewMovie movie{"The Godfather", 2, 175};
+  db_->addMovie(movie);
+
+  Movie retrieved_movie = db_->getMovie(1);
+  EXPECT_EQ(retrieved_movie.movie_id, 1);
+  EXPECT_EQ(retrieved_movie.title, "The Godfather");
+  EXPECT_EQ(retrieved_movie.genre_id, 2);
+  EXPECT_EQ(retrieved_movie.duration, 175);
+}
+
+// Test removing a movie
+TEST_F(SQLiteDatabaseCRUDTest, RemoveMovie) {
+  NewMovie movie{"The Dark Knight", 3, 152};
+  db_->addMovie(movie);
+  EXPECT_TRUE(db_->removeMovie(1));
+
+  auto movies = db_->getAllMovies();
+  EXPECT_TRUE(movies.empty());
+}
+
+// Test updating a movie
+TEST_F(SQLiteDatabaseCRUDTest, UpdateMovie) {
+  NewMovie movie{"The Shawshank Redemption", 1, 142};
+  db_->addMovie(movie);
+
+  Movie updated_movie = db_->getMovie(1);
+  updated_movie.title = "The Godfather";
+  updated_movie.duration = 155;
+  EXPECT_TRUE(db_->updateMovie(updated_movie));
+
+  Movie retrieved_movie = db_->getMovie(1);
+  EXPECT_EQ(retrieved_movie.movie_id, 1);
+  EXPECT_EQ(retrieved_movie.title, "The Godfather");
+  EXPECT_EQ(retrieved_movie.genre_id, 1);
+  EXPECT_EQ(retrieved_movie.duration, 155);
+}
+
+// Test getting all movies
+TEST_F(SQLiteDatabaseCRUDTest, GetAllMovies) {
+  db_->addMovie({"The Shawshank Redemption", 1, 142});
+  db_->addMovie({"The Godfather", 2, 175});
+
+  auto movies = db_->getAllMovies();
+  ASSERT_EQ(movies.size(), 2);
+  EXPECT_EQ(movies[0].title, "The Shawshank Redemption");
+  EXPECT_EQ(movies[0].genre_id, 1);
+  EXPECT_EQ(movies[0].duration, 142);
+  EXPECT_EQ(movies[1].title, "The Godfather");
+  EXPECT_EQ(movies[1].genre_id, 2);
+  EXPECT_EQ(movies[1].duration, 175);
+}
+
+// INFO: ----- HALL -----
+
+// Test adding a hall
+TEST_F(SQLiteDatabaseCRUDTest, AddHall) {
+  NewHall hall{"Hall 1", 132};
+  EXPECT_TRUE(db_->addHall(hall));
+
+  auto halls = db_->getAllHalls();
+  ASSERT_EQ(halls.size(), 1);
+  EXPECT_EQ(halls[0].hall_id, 1);
+  EXPECT_EQ(halls[0].hall_name, "Hall 1");
+  EXPECT_EQ(halls[0].capacity, 132);
+}
+
+// Test getting a hall by ID
+TEST_F(SQLiteDatabaseCRUDTest, GetHallById) {
+  NewHall hall{"Hall 2", 142};
+  db_->addHall(hall);
+
+  Hall retrieved_hall = db_->getHall(1);
+  EXPECT_EQ(retrieved_hall.hall_id, 1);
+  EXPECT_EQ(retrieved_hall.hall_name, "Hall 2");
+  EXPECT_EQ(retrieved_hall.capacity, 142);
+}
+
+// Test removing a hall
+TEST_F(SQLiteDatabaseCRUDTest, RemoveHall) {
+  NewHall hall{"Hall 3", 152};
+  db_->addHall(hall);
+  EXPECT_TRUE(db_->removeHall(1));
+
+  auto halls = db_->getAllHalls();
+  EXPECT_TRUE(halls.empty());
+}
+
+// Test updating a hall
+TEST_F(SQLiteDatabaseCRUDTest, UpdateHall) {
+  NewHall hall{"Hall 4", 162};
+  db_->addHall(hall);
+
+  Hall updated_hall = db_->getHall(1);
+  updated_hall.hall_name = "Hall 5";
+  updated_hall.capacity = 172;
+  EXPECT_TRUE(db_->updateHall(updated_hall));
+
+  Hall retrieved_hall = db_->getHall(1);
+  EXPECT_EQ(retrieved_hall.hall_id, 1);
+  EXPECT_EQ(retrieved_hall.hall_name, "Hall 5");
+  EXPECT_EQ(retrieved_hall.capacity, 172);
+}
+
+// Test getting all halls
+TEST_F(SQLiteDatabaseCRUDTest, GetAllHalls) {
+  db_->addHall({"Hall 6", 172});
+  db_->addHall({"Hall 7", 182});
+
+  auto halls = db_->getAllHalls();
+  ASSERT_EQ(halls.size(), 2);
+  EXPECT_EQ(halls[0].hall_id, 1);
+  EXPECT_EQ(halls[0].hall_name, "Hall 6");
+  EXPECT_EQ(halls[0].capacity, 172);
+  EXPECT_EQ(halls[1].hall_id, 2);
+  EXPECT_EQ(halls[1].hall_name, "Hall 7");
+  EXPECT_EQ(halls[1].capacity, 182);
+}
+
+// INFO: ----- SESSION -----
+
+// Test adding a session
+TEST_F(SQLiteDatabaseCRUDTest, AddSession) {
+  NewSession session{1, 1, "2025-01-01 12:00:00", 10};
+  EXPECT_TRUE(db_->addSession(session));
+
+  auto sessions = db_->getAllSessions();
+  ASSERT_EQ(sessions.size(), 1);
+  EXPECT_EQ(sessions[0].movie_id, 1);
+  EXPECT_EQ(sessions[0].hall_id, 1);
+  EXPECT_EQ(sessions[0].begin_at, "2025-01-01 12:00:00");
+  EXPECT_EQ(sessions[0].ticket_price, 10);
+}
+
+// Test getting a session by ID
+TEST_F(SQLiteDatabaseCRUDTest, GetSessionById) {
+  NewSession session{2, 2, "2025-01-01 12:00:00", 10};
+  db_->addSession(session);
+
+  Session retrieved_session = db_->getSession(1);
+  EXPECT_EQ(retrieved_session.session_id, 1);
+  EXPECT_EQ(retrieved_session.movie_id, 2);
+  EXPECT_EQ(retrieved_session.hall_id, 2);
+  EXPECT_EQ(retrieved_session.begin_at, "2025-01-01 12:00:00");
+  EXPECT_EQ(retrieved_session.ticket_price, 10);
+}
+
+// Test removing a session
+TEST_F(SQLiteDatabaseCRUDTest, RemoveSession) {
+  NewSession session{3, 3, "2025-01-01 12:00:00", 10};
+  db_->addSession(session);
+  EXPECT_TRUE(db_->removeSession(1));
+
+  auto sessions = db_->getAllSessions();
+  EXPECT_TRUE(sessions.empty());
+}
+
+// Test updating a session
+TEST_F(SQLiteDatabaseCRUDTest, UpdateSession) {
+  NewSession session{4, 4, "2025-01-01 12:00:00", 10};
+  db_->addSession(session);
+
+  Session updated_session = db_->getSession(1);
+  updated_session.begin_at = "2025-01-01 13:00:00";
+  EXPECT_TRUE(db_->updateSession(updated_session));
+
+  Session retrieved_session = db_->getSession(1);
+  EXPECT_EQ(retrieved_session.session_id, 1);
+  EXPECT_EQ(retrieved_session.movie_id, 4);
+  EXPECT_EQ(retrieved_session.hall_id, 4);
+  EXPECT_EQ(retrieved_session.begin_at, "2025-01-01 13:00:00");
+  EXPECT_EQ(retrieved_session.ticket_price, 10);
+}
+
+// Test getting all sessions
+TEST_F(SQLiteDatabaseCRUDTest, GetAllSessions) {
+  db_->addSession({5, 5, "2025-01-01 12:00:00", 10});
+  db_->addSession({6, 6, "2025-01-01 13:00:00", 10});
+
+  auto sessions = db_->getAllSessions();
+  ASSERT_EQ(sessions.size(), 2);
+  EXPECT_EQ(sessions[0].movie_id, 5);
+  EXPECT_EQ(sessions[0].hall_id, 5);
+  EXPECT_EQ(sessions[0].begin_at, "2025-01-01 12:00:00");
+  EXPECT_EQ(sessions[0].ticket_price, 10);
+  EXPECT_EQ(sessions[1].movie_id, 6);
+  EXPECT_EQ(sessions[1].hall_id, 6);
+  EXPECT_EQ(sessions[1].begin_at, "2025-01-01 13:00:00");
+  EXPECT_EQ(sessions[1].ticket_price, 10);
+}
+
+// INFO: ----- TICKET -----
+
+// Test adding a ticket
+TEST_F(SQLiteDatabaseCRUDTest, AddTicket) {
+  NewTicket ticket{1, 1, "2025-01-01 12:00:00"};
+  EXPECT_TRUE(db_->addTicket(ticket));
+
+  auto tickets = db_->getAllTickets();
+  ASSERT_EQ(tickets.size(), 1);
+  EXPECT_EQ(tickets[0].session_id, 1);
+  EXPECT_EQ(tickets[0].seat_number, 1);
+  EXPECT_EQ(tickets[0].sold_at, "2025-01-01 12:00:00");
+}
+
+// Test getting a ticket by ID
+TEST_F(SQLiteDatabaseCRUDTest, GetTicketById) {
+  NewTicket ticket{2, 2, "2025-01-01 12:00:00"};
+  db_->addTicket(ticket);
+
+  Ticket retrieved_ticket = db_->getTicket(1);
+  EXPECT_EQ(retrieved_ticket.ticket_id, 1);
+  EXPECT_EQ(retrieved_ticket.session_id, 2);
+  EXPECT_EQ(retrieved_ticket.seat_number, 2);
+  EXPECT_EQ(retrieved_ticket.sold_at, "2025-01-01 12:00:00");
+}
+
+// Test removing a ticket
+TEST_F(SQLiteDatabaseCRUDTest, RemoveTicket) {
+  NewTicket ticket{3, 3, "2025-01-01 12:00:00"};
+  db_->addTicket(ticket);
+  EXPECT_TRUE(db_->removeTicket(1));
+
+  auto tickets = db_->getAllTickets();
+  EXPECT_TRUE(tickets.empty());
+}
+
+// Test updating a ticket
+TEST_F(SQLiteDatabaseCRUDTest, UpdateTicket) {
+  NewTicket ticket{4, 4, "2025-01-01 12:00:00"};
+  db_->addTicket(ticket);
+
+  Ticket updated_ticket = db_->getTicket(1);
+  updated_ticket.seat_number = 5;
+  EXPECT_TRUE(db_->updateTicket(updated_ticket));
+
+  Ticket retrieved_ticket = db_->getTicket(1);
+  EXPECT_EQ(retrieved_ticket.ticket_id, 1);
+  EXPECT_EQ(retrieved_ticket.session_id, 4);
+  EXPECT_EQ(retrieved_ticket.seat_number, 5);
+  EXPECT_EQ(retrieved_ticket.sold_at, "2025-01-01 12:00:00");
+}
+
+// Test getting all tickets
+TEST_F(SQLiteDatabaseCRUDTest, GetAllTickets) {
+  db_->addTicket({5, 5, "2025-01-01 12:00:00"});
+  db_->addTicket({6, 6, "2025-01-01 13:00:00"});
+
+  auto tickets = db_->getAllTickets();
+  ASSERT_EQ(tickets.size(), 2);
+  EXPECT_EQ(tickets[0].session_id, 5);
+  EXPECT_EQ(tickets[0].seat_number, 5);
+  EXPECT_EQ(tickets[0].sold_at, "2025-01-01 12:00:00");
+  EXPECT_EQ(tickets[1].session_id, 6);
+  EXPECT_EQ(tickets[1].seat_number, 6);
+  EXPECT_EQ(tickets[1].sold_at, "2025-01-01 13:00:00");
+}
@@ -0,0 +1,103 @@
+#include "sqlite_database.h"
+#include "sqlite_file_executor.h"
+#include "gtest/gtest.h"
+
+// WARNING: Triggers are off
+
+const std::string TEST_DB = "test.db";
+
+// Test fixture for SQLiteDatabase
+class SQLiteDatabaseForeignKeyTest : public ::testing::Test {
+
+protected:
+  SQLiteDatabase *db_;
+
+public:
+  // void pragmaForeignKeysOn() {
+  //   const std::string query = "PRAGMA foreign_keys = ON;";
+  //   db_->executeNonQuery(query);
+  // }
+
+  std::vector<std::vector<std::string>> pragmaForeignKeys() {
+    const std::string query = "PRAGMA foreign_keys;";
+    auto results = db_->executeSelectQuery(query);
+    return results;
+  }
+
+protected:
+  void SetUp() override {
+    db_ = new SQLiteDatabase(TEST_DB);
+    SQLiteFileExecutor executor(TEST_DB);
+    executor.executeSQLFile("sql/cinema_db_drop_table.sql");
+    executor.executeSQLFile("sql/cinema_db_create_table.sql");
+
+    // pragmaForeignKeysOn();
+
+    std::string sql;
+    FileReaderInterface *reader = &executor;
+    reader->read("sql/cinema_db_foreign_key_on.sql", sql);
+    db_->executeNonQuery(sql);
+  }
+
+  void TearDown() override {
+    delete db_;
+    remove(TEST_DB.c_str());
+  }
+};
+
+// INFO: ----- GENERAL -----
+
+// Check pragma foreign_keys is true
+TEST_F(SQLiteDatabaseForeignKeyTest, PragmaForeignKeys) {
+  auto results = pragmaForeignKeys();
+  ASSERT_FALSE(results.empty());
+  ASSERT_EQ(results[0][0], "1");
+}
+
+// Test adding a movie
+TEST_F(SQLiteDatabaseForeignKeyTest, AddMovie) {
+  NewMovie movie{"The Shawshank Redemption", 1, 142};
+  EXPECT_FALSE(db_->addMovie(movie));
+
+  auto movies = db_->getAllMovies();
+  ASSERT_TRUE(movies.empty());
+
+  NewGenre genre{"Drama"};
+  EXPECT_TRUE(db_->addGenre(genre));
+  EXPECT_TRUE(db_->addMovie(movie));
+  movies = db_->getAllMovies();
+  ASSERT_FALSE(movies.empty());
+}
+
+// Test adding session
+TEST_F(SQLiteDatabaseForeignKeyTest, AddSession) {
+  NewSession session{1, 1, "2025-01-01 12:00:00", 10};
+  EXPECT_FALSE(db_->addSession(session));
+
+  NewHall hall{"Hall 1", 100};
+  db_->addHall(hall);
+  EXPECT_FALSE(db_->addSession(session));
+
+  NewGenre genre{"Drama"};
+  db_->addGenre(genre);
+  NewMovie movie{"The Shawshank Redemption", 1, 142};
+  db_->addMovie(movie);
+  EXPECT_TRUE(db_->addSession(session));
+}
+
+// Test adding ticket
+TEST_F(SQLiteDatabaseForeignKeyTest, AddTicket) {
+  NewTicket ticket{1, 1, "2025-01-01 12:00:00"};
+  EXPECT_FALSE(db_->addTicket(ticket));
+
+  NewHall hall{"Hall 1", 100};
+  db_->addHall(hall);
+  NewGenre genre{"Drama"};
+  db_->addGenre(genre);
+  NewMovie movie{"The Shawshank Redemption", 1, 142};
+  db_->addMovie(movie);
+  NewSession session{1, 1, "2025-01-01 12:00:00", 10};
+  db_->addSession(session);
+
+  EXPECT_TRUE(db_->addTicket(ticket));
+}
@@ -0,0 +1,144 @@
+#include "sqlite_database.h"
+#include "sqlite_file_executor.h"
+#include "gtest/gtest.h"
+
+// WARNING: Foreign keys are off
+
+const std::string TEST_DB = "test.db";
+
+// Test fixture for SQLiteDatabase
+class SQLiteDatabaseTriggerTest : public ::testing::Test {
+protected:
+  SQLiteDatabase *db_;
+
+  void SetUp() override {
+    db_ = new SQLiteDatabase(TEST_DB);
+    SQLiteFileExecutor executor(TEST_DB);
+    executor.executeSQLFile("sql/cinema_db_drop_table.sql");
+    executor.executeSQLFile("sql/cinema_db_create_table.sql");
+    executor.executeSQLFile("sql/cinema_db_drop_trigger.sql");
+    executor.executeSQLFile("sql/cinema_db_create_trigger.sql");
+
+    // Not necessarily, since the default setting
+    std::string sql;
+    FileReaderInterface *reader = &executor;
+    reader->read("sql/cinema_db_foreign_key_off.sql", sql);
+    db_->executeNonQuery(sql);
+  }
+
+  void TearDown() override {
+    delete db_;
+    remove(TEST_DB.c_str());
+  }
+};
+
+// INFO: ----- TICKET -----
+
+// Test trigger check_seat_number
+TEST_F(SQLiteDatabaseTriggerTest, CheckSeatNumber) {
+  db_->addHall({"Hall 1", 100});
+  db_->addSession({1, 1, "2025-01-01 12:00:00", 10});
+
+  NewTicket ticket;
+  ticket.session_id = 1;
+  ticket.sold_at = "2025-01-01 12:00:00";
+
+  ticket.seat_number = 101;
+  EXPECT_FALSE(db_->addTicket(ticket));
+
+  ticket.seat_number = 100;
+  EXPECT_TRUE(db_->addTicket(ticket));
+
+  ticket.seat_number = 1;
+  EXPECT_TRUE(db_->addTicket(ticket));
+}
+
+// Test trigger check_session_not_started
+TEST_F(SQLiteDatabaseTriggerTest, CheckSessionNotStarted) {
+  db_->addSession({1, 1, "2025-01-01 12:00:00", 10});
+
+  NewTicket ticket;
+  ticket.session_id = 1;
+  ticket.seat_number = 1;
+
+  ticket.sold_at = "2025-01-01 13:00:00";
+  EXPECT_FALSE(db_->addTicket(ticket));
+
+  ticket.sold_at = "2025-01-01 11:00:00";
+  EXPECT_TRUE(db_->addTicket(ticket));
+
+  ticket.seat_number = 2;
+  ticket.sold_at = "2025-01-01 12:00:00";
+  EXPECT_TRUE(db_->addTicket(ticket));
+}
+
+// Test trigger prevent_late_ticket_purchase
+TEST_F(SQLiteDatabaseTriggerTest, PreventLateTicketPurchase) {
+  db_->addHall({"Hall 1", 100});
+  db_->addSession({1, 1, "2025-01-01 12:00:00", 10});
+
+  NewTicket ticket;
+  ticket.session_id = 1;
+  ticket.seat_number = 1;
+
+  ticket.sold_at = "2025-01-01 13:00:00";
+  EXPECT_FALSE(db_->addTicket(ticket));
+
+  ticket.sold_at = "2025-01-01 12:00:00";
+  EXPECT_TRUE(db_->addTicket(ticket));
+
+  ticket.seat_number = 2;
+  ticket.sold_at = "2025-01-01 11:00:00";
+  EXPECT_TRUE(db_->addTicket(ticket));
+}
+
+// INFO: ----- REFUND -----
+
+// Test trigger validate_refund_amount
+TEST_F(SQLiteDatabaseTriggerTest, ValidateRefundAmount) {
+  db_->addHall({"Hall 1", 100});
+  db_->addSession({1, 1, "2025-01-01 12:00:00", 10});
+
+  // ID 1
+  db_->addTicket({1, 1, "2025-01-01 10:00:00"});
+  // ID 2
+  db_->addTicket({1, 2, "2025-01-01 10:00:00"});
+
+  NewRefund refund;
+  refund.ticket_id = 1;
+  refund.refund_at = "2025-01-01 11:00:00";
+
+  refund.refund_amount = 11;
+  EXPECT_FALSE(db_->addRefund(refund));
+
+  refund.refund_amount = 10;
+  EXPECT_TRUE(db_->addRefund(refund));
+
+  refund.ticket_id = 2;
+  refund.refund_amount = 9;
+  EXPECT_TRUE(db_->addRefund(refund));
+}
+
+// Test trigger validate_refund_date
+TEST_F(SQLiteDatabaseTriggerTest, ValidateRefundDate) {
+  db_->addHall({"Hall 1", 100});
+  db_->addSession({1, 1, "2025-01-01 12:00:00", 10});
+
+  // ID 1
+  db_->addTicket({1, 1, "2025-01-01 10:00:00"});
+  // ID 2
+  db_->addTicket({1, 2, "2025-01-01 10:00:00"});
+
+  NewRefund refund;
+  refund.ticket_id = 1;
+  refund.refund_amount = 10;
+
+  refund.refund_at = "2025-01-01 09:00:00";
+  EXPECT_FALSE(db_->addRefund(refund));
+
+  refund.refund_at = "2025-01-01 11:00:00";
+  EXPECT_TRUE(db_->addRefund(refund));
+
+  refund.refund_at = "2025-01-01 12:00:00";
+  EXPECT_FALSE(db_->addRefund(refund));
+}