From 56dbd429edb33071a3b8b14004f9f0e9f25c288b Mon Sep 17 00:00:00 2001 From: DennisTurco Date: Fri, 13 Feb 2026 17:50:17 +0100 Subject: [PATCH 1/5] test database setup --- .gitignore | 2 +- src/main/java/backupmanager/MainApp.java | 6 +- .../database/DatabaseInitializer.java | 52 ++--- .../backupmanager/database/DatabasePaths.java | 7 +- .../ProductionDatabaseInitializer.java | 36 ++++ .../database/TestDatabaseInitializer.java | 40 ++++ .../test/ConfigurationsRepositoryTest.java | 96 ++++----- src/test/java/test/SqlHelperTest.java | 199 +++++++++--------- 8 files changed, 247 insertions(+), 191 deletions(-) create mode 100644 src/main/java/backupmanager/database/ProductionDatabaseInitializer.java create mode 100644 src/main/java/backupmanager/database/TestDatabaseInitializer.java diff --git a/.gitignore b/.gitignore index f6c26091..b345a512 100644 --- a/.gitignore +++ b/.gitignore @@ -10,4 +10,4 @@ BackupManager.exe config.enc config.txt -/TESTINGHER/ +/data/ diff --git a/src/main/java/backupmanager/MainApp.java b/src/main/java/backupmanager/MainApp.java index 0d2e2bde..aa247b62 100644 --- a/src/main/java/backupmanager/MainApp.java +++ b/src/main/java/backupmanager/MainApp.java @@ -13,8 +13,8 @@ import backupmanager.GUI.BackupManagerGUI; import backupmanager.Managers.ExceptionManager; import backupmanager.database.Database; -import backupmanager.database.DatabaseInitializer; import backupmanager.database.DatabasePaths; +import backupmanager.database.ProductionDatabaseInitializer; public class MainApp { private static final String CONFIG = "src/main/resources/res/config/config.json"; @@ -42,8 +42,8 @@ else if (!isBackgroundMode) { private static void databaseInitialization() { try { - Database.init(DatabasePaths.getDatabasePath()); - DatabaseInitializer.init(); + Database.init(DatabasePaths.getProductionDatabasePath()); + ProductionDatabaseInitializer.init(); } catch (Exception ex) { logger.error("Unable to init the database"); ExceptionManager.openExceptionMessage(ex.getMessage(), Arrays.toString(ex.getStackTrace())); diff --git a/src/main/java/backupmanager/database/DatabaseInitializer.java b/src/main/java/backupmanager/database/DatabaseInitializer.java index 0fa3a71c..180a52a7 100644 --- a/src/main/java/backupmanager/database/DatabaseInitializer.java +++ b/src/main/java/backupmanager/database/DatabaseInitializer.java @@ -1,54 +1,21 @@ package backupmanager.database; import java.io.InputStream; -import java.nio.file.Files; import java.nio.file.Path; import java.sql.Connection; import java.sql.DriverManager; import java.sql.Statement; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - public class DatabaseInitializer { - private static final Logger logger = LoggerFactory.getLogger(DatabaseInitializer.class); - - public static void init() throws Exception { - Path dbPath = DatabasePaths.getDatabasePath(); - Files.createDirectories(dbPath.getParent()); - - boolean isNewDatabase = !Files.exists(dbPath); - - try (Connection conn = DriverManager.getConnection("jdbc:sqlite:" + dbPath); - Statement st = conn.createStatement()) { - - st.execute("PRAGMA journal_mode=WAL;"); - st.execute("PRAGMA synchronous=NORMAL;"); - st.execute("PRAGMA temp_store=MEMORY;"); - st.execute("PRAGMA foreign_keys=ON;"); - - if (isNewDatabase) { - logger.info("Creating database: {}", dbPath); - - conn.setAutoCommit(false); - - runSql(conn, "/db/001_schema.sql"); - runSql(conn, "/db/002_seed.sql"); - // runSql(conn, "/db/003_enable_demo_version.sql"); Enable it only if you want to create a demo version of the program - conn.commit(); - } else { - logger.info("Database already exists: {}", dbPath); - } - } - } + public static void init() throws Exception {} - private static void runSql(Connection conn, String resource) throws Exception { + protected static void runSql(Connection conn, String resource) throws Exception { try (InputStream is = DatabaseInitializer.class.getResourceAsStream(resource)) { if (is == null) return; String sql = new String(is.readAllBytes()); - String[] statements = sql.split(";"); // split per ogni comando + String[] statements = sql.split(";"); // split for every command try (Statement st = conn.createStatement()) { for (String statement : statements) { @@ -60,4 +27,17 @@ private static void runSql(Connection conn, String resource) throws Exception { } } } + + protected static Connection createConnection(Path dbPath) throws Exception { + Connection conn = DriverManager.getConnection("jdbc:sqlite:" + dbPath); + + try (Statement st = conn.createStatement()) { + st.execute("PRAGMA journal_mode=WAL;"); + st.execute("PRAGMA synchronous=NORMAL;"); + st.execute("PRAGMA temp_store=MEMORY;"); + st.execute("PRAGMA foreign_keys=ON;"); + } + + return conn; + } } diff --git a/src/main/java/backupmanager/database/DatabasePaths.java b/src/main/java/backupmanager/database/DatabasePaths.java index c27ae485..d68405ca 100644 --- a/src/main/java/backupmanager/database/DatabasePaths.java +++ b/src/main/java/backupmanager/database/DatabasePaths.java @@ -4,10 +4,15 @@ import java.nio.file.Paths; public class DatabasePaths { - public static Path getDatabasePath() { + public static Path getProductionDatabasePath() { return Paths.get( System.getProperty("user.home"), "Documents", "Shard", "data", "BackupManager.db" ); } + + public static Path getTestDatabasePath() { + return Paths.get("data", "BackupManager.db"); + } + } diff --git a/src/main/java/backupmanager/database/ProductionDatabaseInitializer.java b/src/main/java/backupmanager/database/ProductionDatabaseInitializer.java new file mode 100644 index 00000000..8e99b007 --- /dev/null +++ b/src/main/java/backupmanager/database/ProductionDatabaseInitializer.java @@ -0,0 +1,36 @@ +package backupmanager.database; + +import java.nio.file.Files; +import java.nio.file.Path; +import java.sql.Connection; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class ProductionDatabaseInitializer extends DatabaseInitializer { + private static final Logger logger = LoggerFactory.getLogger(ProductionDatabaseInitializer.class); + + public static void init() throws Exception { + Path dbPath = DatabasePaths.getProductionDatabasePath(); + Files.createDirectories(dbPath.getParent()); + + boolean isNewDatabase = !Files.exists(dbPath); + + try (Connection conn = createConnection(dbPath)) { + + if (isNewDatabase) { + logger.info("Creating database: {}", dbPath); + + conn.setAutoCommit(false); + + runSql(conn, "/db/001_schema.sql"); + runSql(conn, "/db/002_seed.sql"); + // runSql(conn, "/db/003_enable_demo_version.sql"); Enable it only if you want to create a demo version of the program + + conn.commit(); + } else { + logger.info("Database already exists: {}", dbPath); + } + } + } +} diff --git a/src/main/java/backupmanager/database/TestDatabaseInitializer.java b/src/main/java/backupmanager/database/TestDatabaseInitializer.java new file mode 100644 index 00000000..3af413af --- /dev/null +++ b/src/main/java/backupmanager/database/TestDatabaseInitializer.java @@ -0,0 +1,40 @@ +package backupmanager.database; + +import java.io.IOException; +import java.nio.file.DirectoryStream; +import java.nio.file.Files; +import java.nio.file.Path; +import java.sql.Connection; + +public class TestDatabaseInitializer extends DatabaseInitializer { + + public static void init() throws Exception { + Path dbPath = DatabasePaths.getTestDatabasePath(); + Files.createDirectories(dbPath.getParent()); + + try (Connection conn = createConnection(dbPath)) { + + conn.setAutoCommit(false); + + runSql(conn, "/db/001_schema.sql"); + runSql(conn, "/db/002_seed.sql"); + runSql(conn, "/db/003_enable_demo_version.sql"); + + conn.commit(); + } + } + + public static void deleteDatabase() throws IOException { + + Path dbPath = DatabasePaths.getTestDatabasePath(); + Path folder = dbPath.getParent(); + String prefix = dbPath.getFileName().toString(); + + if (Files.exists(folder)) { + try (DirectoryStream stream = Files.newDirectoryStream(folder, prefix + "*")) { + for (Path file : stream) + Files.deleteIfExists(file); + } + } + } +} diff --git a/src/test/java/test/ConfigurationsRepositoryTest.java b/src/test/java/test/ConfigurationsRepositoryTest.java index 6977e0fc..a4145557 100644 --- a/src/test/java/test/ConfigurationsRepositoryTest.java +++ b/src/test/java/test/ConfigurationsRepositoryTest.java @@ -1,64 +1,58 @@ package test; +import java.io.IOException; + +import org.junit.jupiter.api.AfterEach; import static org.junit.jupiter.api.Assertions.assertEquals; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import backupmanager.Entities.Confingurations; import backupmanager.Enums.LanguagesEnum; import backupmanager.Enums.ThemesEnum; import backupmanager.database.Database; -import backupmanager.database.DatabaseInitializer; import backupmanager.database.DatabasePaths; -import java.io.IOException; -import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; +import backupmanager.database.TestDatabaseInitializer; public class ConfigurationsRepositoryTest { - private LanguagesEnum language; - private ThemesEnum theme; - - @BeforeEach - protected void initDbAndBuildConfigurations() throws Exception { - Database.init(DatabasePaths.getDatabasePath()); - DatabaseInitializer.init(); - - Confingurations.loadAllConfigurations(); - language = Confingurations.getLanguage(); - theme = Confingurations.getTheme(); - - buildAndReloadConfigurations(); - } - - @AfterEach - protected void resetValuesBeforeTest() { - Confingurations.setLanguage(language); - Confingurations.setTheme(theme.getThemeName()); - Confingurations.updateAllConfigurations(); - } - - @Test - protected void equals_shouldReturnTrue_forSameLanguage() throws IOException { - assertEquals(LanguagesEnum.DEU, Confingurations.getLanguage()); - } - - @Test - protected void equals_shouldReturnTrue_forSameTheme() throws IOException { - assertEquals(ThemesEnum.CARBON, Confingurations.getTheme()); - } - - private void buildAndReloadConfigurations() throws IOException { - buildValidConfigurationsObject(); - realodConfigurations(); - } - - private void buildValidConfigurationsObject() { - Confingurations.setLanguage(LanguagesEnum.DEU); - Confingurations.setTheme(ThemesEnum.CARBON.getThemeName()); - } - - private void realodConfigurations() { - Confingurations.updateAllConfigurations(); - Confingurations.loadAllConfigurations(); - } + @BeforeEach + protected void setup() throws Exception { + Database.init(DatabasePaths.getTestDatabasePath()); + TestDatabaseInitializer.init(); + + Confingurations.loadAllConfigurations(); + + buildAndReloadConfigurations(); + } + + @AfterEach + protected void clean() throws IOException { + TestDatabaseInitializer.deleteDatabase(); + } + + @Test + protected void equals_shouldReturnTrue_forSameLanguage() throws IOException { + assertEquals(LanguagesEnum.DEU, Confingurations.getLanguage()); + } + + @Test + protected void equals_shouldReturnTrue_forSameTheme() throws IOException { + assertEquals(ThemesEnum.CARBON, Confingurations.getTheme()); + } + + private void buildAndReloadConfigurations() throws IOException { + buildValidConfigurationsObject(); + realodConfigurations(); + } + + private void buildValidConfigurationsObject() { + Confingurations.setLanguage(LanguagesEnum.DEU); + Confingurations.setTheme(ThemesEnum.CARBON.getThemeName()); + } + + private void realodConfigurations() { + Confingurations.updateAllConfigurations(); + Confingurations.loadAllConfigurations(); + } } diff --git a/src/test/java/test/SqlHelperTest.java b/src/test/java/test/SqlHelperTest.java index 936680c0..48681d0b 100644 --- a/src/test/java/test/SqlHelperTest.java +++ b/src/test/java/test/SqlHelperTest.java @@ -1,111 +1,112 @@ package test; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.Month; + import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; +import org.junit.jupiter.api.Test; import backupmanager.Entities.TimeInterval; import backupmanager.Helpers.SqlHelper; -import java.time.LocalDate; -import java.time.LocalDateTime; -import java.time.Month; -import org.junit.jupiter.api.Test; public class SqlHelperTest { - private static final LocalDateTime TestDate = LocalDate.of(2026, Month.APRIL, 8).atStartOfDay(); - private static final long MILLISECONDS = 1_775_599_200_000L; - - @Test - void toMilliseconds_shouldBeEquals_forValidLocalDate() { - long mills = SqlHelper.toMilliseconds(TestDate); - assertEquals(mills, MILLISECONDS); - } - - @Test - void toMilliseconds_shouldReturnTrue_forNullLocalDate() { - long mills = SqlHelper.toMilliseconds(null); - assertTrue(mills == 0); - } - - @Test - void toMillisecondsWithFallback_shouldBeEquals_forValidLocalDate() { - long mills = SqlHelper.toMilliseconds(TestDate, LocalDateTime.now()); - assertEquals(mills, MILLISECONDS); - } - - @Test - void toMillisecondsWithFallback_shouldReturnTrue_forNullLocalDate() { - long mills = SqlHelper.toMilliseconds(null, LocalDateTime.now()); - assertTrue(mills > 0); - } - - @Test - public void toMillisecondsWithFallback_shouldThrowException_whenFallbackValueIsNull() { - IllegalArgumentException ex = - assertThrows(IllegalArgumentException.class, () -> SqlHelper.toMilliseconds(null, null)); - assertEquals("Cannot pass the fallback value as null", ex.getMessage()); - } - - @Test - void toLocalDateTime_shouldBeEquals_forValidMills() { - LocalDateTime dateTime = SqlHelper.toLocalDateTime(MILLISECONDS); - assertEquals(dateTime, TestDate); - } - - @Test - void toLocalDateTime_shouldReturnTrue_forNullOrNotValidMillsValue() { - LocalDateTime dateTime = SqlHelper.toLocalDateTime(null); - LocalDateTime dateTime2 = SqlHelper.toLocalDateTime(Long.getLong("-2")); - assertTrue(dateTime == null && dateTime2 == null); - } - - @Test - void toLocalDate_shouldBeEquals_forValidMills() { - LocalDate date = SqlHelper.toLocalDate(MILLISECONDS); - assertEquals(date, TestDate.toLocalDate()); - } - - @Test - void toLocalDate_shouldReturnTrue_forNullOrNotValidMillsValue() { - LocalDate date = SqlHelper.toLocalDate(null); - LocalDate date2 = SqlHelper.toLocalDate(Long.getLong("-2")); - assertTrue(date == null && date2 == null); - } - - @Test - void millisecondsAndDateConversion_equal_forSameLocalDate() { - LocalDateTime inputDate = LocalDate.of(2026, Month.APRIL, 8).atStartOfDay(); - - long mills = SqlHelper.toMilliseconds(inputDate); - LocalDateTime dateTime = SqlHelper.toLocalDateTime(mills); - - assertEquals(inputDate, dateTime); - } - - @Test - void toTimeInterval_equal_forSameTimeInterval() { - String time = "10.5:34"; - TimeInterval timeInterval = SqlHelper.toTimeInterval(time); - assertEquals(time, timeInterval.toString()); - } - - @Test - void toTimeInterval_shouldReturnTrue_forNullString() { - TimeInterval timeInterval = SqlHelper.toTimeInterval(null); - assertTrue(timeInterval == null); - } - - @Test - void toString_equal_forValidObject() { - TimeInterval timeInterval = new TimeInterval(5, 10, 5); - String timeIntervalStr = SqlHelper.toString(timeInterval); - assertEquals(timeInterval.toString(), timeIntervalStr); - } - - @Test - void toString_shouldReturnTrue_forNullString() { - String timeIntervalStr = SqlHelper.toString(null); - assertTrue(timeIntervalStr == null); - } + private static final LocalDateTime TestDate = LocalDate.of(2026, Month.APRIL, 8).atStartOfDay(); + private static final long MILLISECONDS = 1_775_599_200_000L; + + @Test + void toMilliseconds_shouldBeEquals_forValidLocalDate() { + long mills = SqlHelper.toMilliseconds(TestDate); + assertEquals(mills, MILLISECONDS); + } + + @Test + void toMilliseconds_shouldReturnTrue_forNullLocalDate() { + long mills = SqlHelper.toMilliseconds(null); + assertTrue(mills == 0); + } + + @Test + void toMillisecondsWithFallback_shouldBeEquals_forValidLocalDate() { + long mills = SqlHelper.toMilliseconds(TestDate, LocalDateTime.now()); + assertEquals(mills, MILLISECONDS); + } + + @Test + void toMillisecondsWithFallback_shouldReturnTrue_forNullLocalDate() { + long mills = SqlHelper.toMilliseconds(null, LocalDateTime.now()); + assertTrue(mills > 0); + } + + @Test + public void toMillisecondsWithFallback_shouldThrowException_whenFallbackValueIsNull() { + IllegalArgumentException ex = + assertThrows(IllegalArgumentException.class, () -> SqlHelper.toMilliseconds(null, null)); + assertEquals("Cannot pass the fallback value as null", ex.getMessage()); + } + + @Test + void toLocalDateTime_shouldBeEquals_forValidMills() { + LocalDateTime dateTime = SqlHelper.toLocalDateTime(MILLISECONDS); + assertEquals(dateTime, TestDate); + } + + @Test + void toLocalDateTime_shouldReturnTrue_forNullOrNotValidMillsValue() { + LocalDateTime dateTime = SqlHelper.toLocalDateTime(null); + LocalDateTime dateTime2 = SqlHelper.toLocalDateTime(Long.getLong("-2")); + assertTrue(dateTime == null && dateTime2 == null); + } + + @Test + void toLocalDate_shouldBeEquals_forValidMills() { + LocalDate date = SqlHelper.toLocalDate(MILLISECONDS); + assertEquals(date, TestDate.toLocalDate()); + } + + @Test + void toLocalDate_shouldReturnTrue_forNullOrNotValidMillsValue() { + LocalDate date = SqlHelper.toLocalDate(null); + LocalDate date2 = SqlHelper.toLocalDate(Long.getLong("-2")); + assertTrue(date == null && date2 == null); + } + + @Test + void millisecondsAndDateConversion_equal_forSameLocalDate() { + LocalDateTime inputDate = LocalDate.of(2026, Month.APRIL, 8).atStartOfDay(); + + long mills = SqlHelper.toMilliseconds(inputDate); + LocalDateTime dateTime = SqlHelper.toLocalDateTime(mills); + + assertEquals(inputDate, dateTime); + } + + @Test + void toTimeInterval_equal_forSameTimeInterval() { + String time = "10.5:34"; + TimeInterval timeInterval = SqlHelper.toTimeInterval(time); + assertEquals(time, timeInterval.toString()); + } + + @Test + void toTimeInterval_shouldReturnTrue_forNullString() { + TimeInterval timeInterval = SqlHelper.toTimeInterval(null); + assertTrue(timeInterval == null); + } + + @Test + void toString_equal_forValidObject() { + TimeInterval timeInterval = new TimeInterval(5, 10, 5); + String timeIntervalStr = SqlHelper.toString(timeInterval); + assertEquals(timeInterval.toString(), timeIntervalStr); + } + + @Test + void toString_shouldReturnTrue_forNullString() { + String timeIntervalStr = SqlHelper.toString(null); + assertTrue(timeIntervalStr == null); + } } From fd6a9d7cf3b5f546df220898bb995a232a26d6c7 Mon Sep 17 00:00:00 2001 From: DennisTurco Date: Fri, 13 Feb 2026 20:35:42 +0100 Subject: [PATCH 2/5] subscription test --- src/main/resources/db/001_schema.sql | 4 +-- .../resources/db/003_enable_demo_version.sql | 4 +-- .../BackupConfigurationRepositoryTest.java | 5 --- .../BackupConfigurationRepositoryTest.java | 23 +++++++++++++ .../ConfigurationsRepositoryTest.java | 2 +- .../SubscriptionRepositoryTest.java | 33 +++++++++++++++++++ 6 files changed, 61 insertions(+), 10 deletions(-) delete mode 100644 src/test/java/test/BackupConfigurationRepositoryTest.java create mode 100644 src/test/java/test/repositories/BackupConfigurationRepositoryTest.java rename src/test/java/test/{ => repositories}/ConfigurationsRepositoryTest.java (98%) create mode 100644 src/test/java/test/repositories/SubscriptionRepositoryTest.java diff --git a/src/main/resources/db/001_schema.sql b/src/main/resources/db/001_schema.sql index d4aa07e7..83453e6d 100644 --- a/src/main/resources/db/001_schema.sql +++ b/src/main/resources/db/001_schema.sql @@ -84,7 +84,7 @@ CREATE TABLE IF NOT EXISTS "Subscriptions" ( "InsertDate" INTEGER NOT NULL, "StartDate" INTEGER NOT NULL UNIQUE, "EndDate" INTEGER NOT NULL, - "CreatedBy" INTEGER NOT NULL, + "CreationType" INTEGER NOT NULL, CHECK("StartDate" <= "EndDate") ); @@ -95,7 +95,7 @@ SELECT datetime(InsertDate / 1000, 'unixepoch', 'localtime') AS InsertDate, datetime(StartDate / 1000, 'unixepoch', 'localtime') AS StartDate, datetime(EndDate / 1000, 'unixepoch', 'localtime') AS EndDate, - CreatedBy + CreationType FROM Subscriptions; diff --git a/src/main/resources/db/003_enable_demo_version.sql b/src/main/resources/db/003_enable_demo_version.sql index 7347a7b9..43d35a56 100644 --- a/src/main/resources/db/003_enable_demo_version.sql +++ b/src/main/resources/db/003_enable_demo_version.sql @@ -1,9 +1,9 @@ UPDATE Configurations SET Value = 'True' WHERE Code = 'SubscriptionNedded'; -- One month of free subscription -INSERT INTO Subscriptions (InsertDate, StartDate, EndDate, CreatedBy) +INSERT INTO Subscriptions (InsertDate, StartDate, EndDate, CreationType) SELECT unixepoch() * 1000, unixepoch() * 1000, unixepoch('now', '+1 month') * 1000, - 'MIGRATION'; \ No newline at end of file + 'MIGRATION'; diff --git a/src/test/java/test/BackupConfigurationRepositoryTest.java b/src/test/java/test/BackupConfigurationRepositoryTest.java deleted file mode 100644 index 708d4a4a..00000000 --- a/src/test/java/test/BackupConfigurationRepositoryTest.java +++ /dev/null @@ -1,5 +0,0 @@ -package test; - -public class BackupConfigurationRepositoryTest { - -} diff --git a/src/test/java/test/repositories/BackupConfigurationRepositoryTest.java b/src/test/java/test/repositories/BackupConfigurationRepositoryTest.java new file mode 100644 index 00000000..6b28742d --- /dev/null +++ b/src/test/java/test/repositories/BackupConfigurationRepositoryTest.java @@ -0,0 +1,23 @@ +package test.repositories; + +import java.io.IOException; + +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; + +import backupmanager.database.Database; +import backupmanager.database.DatabasePaths; +import backupmanager.database.TestDatabaseInitializer; + +public class BackupConfigurationRepositoryTest { + @BeforeEach + protected void setup() throws Exception { + Database.init(DatabasePaths.getTestDatabasePath()); + TestDatabaseInitializer.init(); + } + + @AfterEach + protected void clean() throws IOException { + TestDatabaseInitializer.deleteDatabase(); + } +} diff --git a/src/test/java/test/ConfigurationsRepositoryTest.java b/src/test/java/test/repositories/ConfigurationsRepositoryTest.java similarity index 98% rename from src/test/java/test/ConfigurationsRepositoryTest.java rename to src/test/java/test/repositories/ConfigurationsRepositoryTest.java index a4145557..5854007a 100644 --- a/src/test/java/test/ConfigurationsRepositoryTest.java +++ b/src/test/java/test/repositories/ConfigurationsRepositoryTest.java @@ -1,4 +1,4 @@ -package test; +package test.repositories; import java.io.IOException; diff --git a/src/test/java/test/repositories/SubscriptionRepositoryTest.java b/src/test/java/test/repositories/SubscriptionRepositoryTest.java new file mode 100644 index 00000000..66522fd5 --- /dev/null +++ b/src/test/java/test/repositories/SubscriptionRepositoryTest.java @@ -0,0 +1,33 @@ +package test.repositories; + +import java.io.IOException; + +import org.junit.jupiter.api.AfterEach; +import static org.junit.jupiter.api.Assertions.assertTrue; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import backupmanager.Entities.Subscription; +import backupmanager.database.Database; +import backupmanager.database.DatabasePaths; +import backupmanager.database.Repositories.SubscriptionRepository; +import backupmanager.database.TestDatabaseInitializer; + +public class SubscriptionRepositoryTest { + @BeforeEach + protected void setup() throws Exception { + Database.init(DatabasePaths.getTestDatabasePath()); + TestDatabaseInitializer.init(); + } + + @AfterEach + protected void clean() throws IOException { + TestDatabaseInitializer.deleteDatabase(); + } + + @Test + protected void getAnySubscriptionValid_shouldBeTrue_forDemoSubscription() { + Subscription demoSub = SubscriptionRepository.getAnySubscriptionValid(); + assertTrue(demoSub != null); + } +} From 6334b6321c4fc07217cba8b4be439aca001ce480 Mon Sep 17 00:00:00 2001 From: DennisTurco Date: Fri, 13 Feb 2026 21:53:45 +0100 Subject: [PATCH 3/5] configuration backup tests --- .../Entities/ConfigurationBackup.java | 4 +- .../database/DatabaseInitializer.java | 3 +- .../BackupConfigurationRepositoryTest.java | 54 +++++++++++++++++++ .../ConfigurationsRepositoryTest.java | 1 - 4 files changed, 58 insertions(+), 4 deletions(-) diff --git a/src/main/java/backupmanager/Entities/ConfigurationBackup.java b/src/main/java/backupmanager/Entities/ConfigurationBackup.java index 0f1a6b33..fffdff2a 100644 --- a/src/main/java/backupmanager/Entities/ConfigurationBackup.java +++ b/src/main/java/backupmanager/Entities/ConfigurationBackup.java @@ -34,8 +34,8 @@ public ConfigurationBackup() { nextBackupDate = null; timeIntervalBackup = null; notes = ""; - creationDate = null; - lastUpdateDate = null; + creationDate = LocalDateTime.now(); + lastUpdateDate = LocalDateTime.now(); count = 0; maxToKeep = configReader.getConfigValue("MaxCountForSameBackup", 1); } diff --git a/src/main/java/backupmanager/database/DatabaseInitializer.java b/src/main/java/backupmanager/database/DatabaseInitializer.java index 180a52a7..b0339159 100644 --- a/src/main/java/backupmanager/database/DatabaseInitializer.java +++ b/src/main/java/backupmanager/database/DatabaseInitializer.java @@ -1,6 +1,7 @@ package backupmanager.database; import java.io.InputStream; +import java.nio.charset.StandardCharsets; import java.nio.file.Path; import java.sql.Connection; import java.sql.DriverManager; @@ -14,7 +15,7 @@ protected static void runSql(Connection conn, String resource) throws Exception try (InputStream is = DatabaseInitializer.class.getResourceAsStream(resource)) { if (is == null) return; - String sql = new String(is.readAllBytes()); + String sql = new String(is.readAllBytes(), StandardCharsets.UTF_8); String[] statements = sql.split(";"); // split for every command try (Statement st = conn.createStatement()) { diff --git a/src/test/java/test/repositories/BackupConfigurationRepositoryTest.java b/src/test/java/test/repositories/BackupConfigurationRepositoryTest.java index 6b28742d..06815201 100644 --- a/src/test/java/test/repositories/BackupConfigurationRepositoryTest.java +++ b/src/test/java/test/repositories/BackupConfigurationRepositoryTest.java @@ -1,15 +1,26 @@ package test.repositories; import java.io.IOException; +import java.time.LocalDateTime; +import java.util.ArrayList; +import java.util.List; import org.junit.jupiter.api.AfterEach; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import backupmanager.Entities.ConfigurationBackup; import backupmanager.database.Database; import backupmanager.database.DatabasePaths; +import backupmanager.database.Repositories.BackupConfigurationRepository; import backupmanager.database.TestDatabaseInitializer; public class BackupConfigurationRepositoryTest { + + private List backups; + @BeforeEach protected void setup() throws Exception { Database.init(DatabasePaths.getTestDatabasePath()); @@ -20,4 +31,47 @@ protected void setup() throws Exception { protected void clean() throws IOException { TestDatabaseInitializer.deleteDatabase(); } + + @Test + protected void insertBackup_shuldBeEquals_fetchFromBackupName() { + setupTheBackupList(); + ConfigurationBackup backup = BackupConfigurationRepository.getBackupByName(backups.get(1).getName()); + assertEquals(backup.getName(), backups.get(1).getName()); + } + + @Test + protected void deleteBackup_shuldBeTrue_afterDelete() { + setupTheBackupList(); + ConfigurationBackup backup = BackupConfigurationRepository.getBackupByName(backups.get(1).getName()); + BackupConfigurationRepository.deleteBackup(backup.getId()); + ConfigurationBackup backupDeleted = BackupConfigurationRepository.getBackupById(backup.getId()); + assertTrue(backupDeleted == null); + } + + @Test + protected void getBackupList_shuldBeTrue_SameSizeForSameBackupList() { + setupTheBackupList(); + List backupList = BackupConfigurationRepository.getBackupList(); + assertTrue(backups.size() == backupList.size()); + } + + private void setupTheBackupList() { + ConfigurationBackup backup1 = createConfiguration("Test1"); + ConfigurationBackup backup2 = createConfiguration("Test2"); + ConfigurationBackup backup3 = createConfiguration("Test3"); + + backups = new ArrayList<>(); + + backups.add(backup1); + backups.add(backup2); + backups.add(backup3); + + for (ConfigurationBackup backup : backups) { + BackupConfigurationRepository.insertBackup(backup); + } + } + + private ConfigurationBackup createConfiguration(String name) { + return new ConfigurationBackup(0, name, "TargetPath", "DestinationPath", null, false, null, null, "", LocalDateTime.now(), LocalDateTime.now(), 0, 1); + } } diff --git a/src/test/java/test/repositories/ConfigurationsRepositoryTest.java b/src/test/java/test/repositories/ConfigurationsRepositoryTest.java index 5854007a..e5db56b4 100644 --- a/src/test/java/test/repositories/ConfigurationsRepositoryTest.java +++ b/src/test/java/test/repositories/ConfigurationsRepositoryTest.java @@ -15,7 +15,6 @@ import backupmanager.database.TestDatabaseInitializer; public class ConfigurationsRepositoryTest { - @BeforeEach protected void setup() throws Exception { Database.init(DatabasePaths.getTestDatabasePath()); From 0ac6682c311c11f0db5798ea2f9766cd29e7f070 Mon Sep 17 00:00:00 2001 From: DennisTurco Date: Mon, 16 Feb 2026 13:22:11 +0100 Subject: [PATCH 4/5] unit tests for repository classes --- .../java/backupmanager/Entities/Email.java | 4 +- .../java/backupmanager/Enums/EmailType.java | 25 ++++ .../Repositories/BackupRequestRepository.java | 60 +++++++++ .../Repositories/EmailRepository.java | 44 ++++++- .../database/Repositories/UserRepository.java | 18 --- .../BackupConfigurationRepositoryTest.java | 5 +- .../BackupRequestRepositoryTest.java | 118 ++++++++++++++++++ .../repositories/EmailRepositoryTest.java | 56 +++++++++ .../test/repositories/UserRepositoryTest.java | 55 ++++++++ 9 files changed, 362 insertions(+), 23 deletions(-) create mode 100644 src/main/java/backupmanager/Enums/EmailType.java create mode 100644 src/test/java/test/repositories/BackupRequestRepositoryTest.java create mode 100644 src/test/java/test/repositories/EmailRepositoryTest.java create mode 100644 src/test/java/test/repositories/UserRepositoryTest.java diff --git a/src/main/java/backupmanager/Entities/Email.java b/src/main/java/backupmanager/Entities/Email.java index a47dba40..23babd4d 100644 --- a/src/main/java/backupmanager/Entities/Email.java +++ b/src/main/java/backupmanager/Entities/Email.java @@ -2,9 +2,11 @@ import java.time.LocalDateTime; +import backupmanager.Enums.EmailType; + public record Email ( int emailId, - int type, + EmailType type, LocalDateTime insertDate, String appVersion, String payload diff --git a/src/main/java/backupmanager/Enums/EmailType.java b/src/main/java/backupmanager/Enums/EmailType.java new file mode 100644 index 00000000..6d4efbe2 --- /dev/null +++ b/src/main/java/backupmanager/Enums/EmailType.java @@ -0,0 +1,25 @@ +package backupmanager.Enums; + +public enum EmailType { + WELCOME(1), + CRITICAL_ERROR(2); + + private final int code; + + EmailType(int code) { + this.code = code; + } + + public int getCode() { + return code; + } + + public static EmailType fromCode(int code) { + for (EmailType status : values()) { + if (status.code == code) { + return status; + } + } + throw new IllegalArgumentException("Invalid EmailType code: " + code); + } +} diff --git a/src/main/java/backupmanager/database/Repositories/BackupRequestRepository.java b/src/main/java/backupmanager/database/Repositories/BackupRequestRepository.java index 294ed11f..89c2701d 100644 --- a/src/main/java/backupmanager/database/Repositories/BackupRequestRepository.java +++ b/src/main/java/backupmanager/database/Repositories/BackupRequestRepository.java @@ -114,6 +114,66 @@ public static List getRunningBackups() { return backups; } + public static List getRequestBackups() { + String sql = """ + SELECT + BackupRequestId, + BackupConfigurationId, + StartedDate, + CompletionDate, + Status, + Progress, + TriggeredBy, + DurationMs, + OutputPath, + UnzippedTargetSize, + ZippedTargetSize, + FilesCount, + ErrorMessage + FROM + BackupRequests + ORDER BY 1 + """; + + List backups = new ArrayList<>(); + + try ( + Connection conn = Database.getConnection(); + PreparedStatement stmt = conn.prepareStatement(sql)) { + + try (ResultSet rs = stmt.executeQuery()) { + while (rs.next()) { + int backupRequestId = rs.getInt("BackupRequestId"); + int backupConfigurationId = rs.getInt("BackupConfigurationId"); + Long startedDateMills = rs.getLong("StartedDate"); + Long completionDateStr = rs.getLong("CompletionDate"); + int statusInt = rs.getInt("Status"); + int progress = rs.getInt("Progress"); + int triggeredByInt = rs.getInt("TriggeredBy"); + Long durationMs = rs.getLong("DurationMs"); + String outputPath = rs.getString("OutputPath"); + long unzippedTargetSize = rs.getLong("UnzippedTargetSize"); + long zippedTargetSize = rs.getLong("ZippedTargetSize"); + int filesCount = rs.getInt("FilesCount"); + String errorMessage = rs.getString("ErrorMessage"); + + LocalDateTime startedDate = SqlHelper.toLocalDateTime(startedDateMills); + LocalDateTime completionDate = SqlHelper.toLocalDateTime(completionDateStr); + BackupTriggeredEnum triggeredBy = BackupTriggeredEnum.fromCode(triggeredByInt); + BackupStatusEnum status = BackupStatusEnum.fromCode(statusInt); + + backups.add(new BackupRequest(backupRequestId, backupConfigurationId, startedDate, completionDate, status, progress, triggeredBy, durationMs, outputPath, unzippedTargetSize, zippedTargetSize, filesCount, errorMessage)); + logger.debug("Loaded running backup: backupRequestId={} configurationId={}", backupRequestId, backupConfigurationId); + } + } + + } catch (SQLException e) { + logger.error("Error fetching backup requests list: " + e.getMessage(), e); + } + + return backups; + } + public static boolean isAnyBackupRunning() { String sql = """ SELECT 1 diff --git a/src/main/java/backupmanager/database/Repositories/EmailRepository.java b/src/main/java/backupmanager/database/Repositories/EmailRepository.java index 8ba56b12..4bbd87d7 100644 --- a/src/main/java/backupmanager/database/Repositories/EmailRepository.java +++ b/src/main/java/backupmanager/database/Repositories/EmailRepository.java @@ -2,12 +2,15 @@ import java.sql.Connection; import java.sql.PreparedStatement; +import java.sql.ResultSet; import java.sql.SQLException; +import java.time.LocalDateTime; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import backupmanager.Entities.Email; +import backupmanager.Enums.EmailType; import backupmanager.Helpers.SqlHelper; import backupmanager.database.Database; @@ -20,7 +23,7 @@ public static void insertEmail(Email email) { try (Connection conn = Database.getConnection(); PreparedStatement stmt = conn.prepareStatement(sql)) { - stmt.setInt(1, email.type()); + stmt.setInt(1, email.type().getCode()); stmt.setLong(2, SqlHelper.toMilliseconds(email.insertDate())); stmt.setString(3, email.appVersion()); stmt.setString(4, email.payload()); @@ -32,4 +35,43 @@ public static void insertEmail(Email email) { logger.error("Email inserting error: " + e.getMessage()); } } + + public static Email getLastEmail() { + String sql = """ + SELECT + EmailId, + Type, + InsertDate, + AppVersion, + Payload + FROM + Emails + ORDER BY InsertDate DESC + """; + + try (Connection conn = Database.getConnection(); + PreparedStatement stmt = conn.prepareStatement(sql)){ + + try (ResultSet rs = stmt.executeQuery()){ + if (rs.next()) { + int emailId = rs.getInt("EmailId"); + int typeInt = rs.getInt("Type"); + long insertDateLong = rs.getLong("InsertDate"); + String appVersion = rs.getString("AppVersion"); + String payload = rs.getString("Payload"); + + LocalDateTime startedDate = SqlHelper.toLocalDateTime(insertDateLong); + EmailType type = EmailType.fromCode(typeInt); + + return new Email(emailId, type, startedDate, appVersion, payload); + } else { + logger.debug("No email to obtain"); + } + } + } catch (SQLException e) { + logger.error("Failed to fetch last email", e); + } + + return null; + } } diff --git a/src/main/java/backupmanager/database/Repositories/UserRepository.java b/src/main/java/backupmanager/database/Repositories/UserRepository.java index 6ad89426..42f427cc 100644 --- a/src/main/java/backupmanager/database/Repositories/UserRepository.java +++ b/src/main/java/backupmanager/database/Repositories/UserRepository.java @@ -57,22 +57,4 @@ public static User getLastUser() { return null; } - - public static void updateUser(User user) { - String sql = "UPDATE Users SET Name = ?, Surname = ?, Email = ? WHERE UserId = ?"; - try (Connection conn = Database.getConnection(); - PreparedStatement stmt = conn.prepareStatement(sql)) { - - stmt.setString(1, user.name()); - stmt.setString(2, user.surname()); - stmt.setString(3, user.email()); - stmt.setInt(4, user.id()); - stmt.executeUpdate(); - - logger.info("User updated succesfully"); - - } catch (SQLException e) { - logger.error("User updating error: " + e.getMessage()); - } - } } diff --git a/src/test/java/test/repositories/BackupConfigurationRepositoryTest.java b/src/test/java/test/repositories/BackupConfigurationRepositoryTest.java index 06815201..fe5766d5 100644 --- a/src/test/java/test/repositories/BackupConfigurationRepositoryTest.java +++ b/src/test/java/test/repositories/BackupConfigurationRepositoryTest.java @@ -25,6 +25,8 @@ public class BackupConfigurationRepositoryTest { protected void setup() throws Exception { Database.init(DatabasePaths.getTestDatabasePath()); TestDatabaseInitializer.init(); + + setupTheBackupList(); } @AfterEach @@ -34,14 +36,12 @@ protected void clean() throws IOException { @Test protected void insertBackup_shuldBeEquals_fetchFromBackupName() { - setupTheBackupList(); ConfigurationBackup backup = BackupConfigurationRepository.getBackupByName(backups.get(1).getName()); assertEquals(backup.getName(), backups.get(1).getName()); } @Test protected void deleteBackup_shuldBeTrue_afterDelete() { - setupTheBackupList(); ConfigurationBackup backup = BackupConfigurationRepository.getBackupByName(backups.get(1).getName()); BackupConfigurationRepository.deleteBackup(backup.getId()); ConfigurationBackup backupDeleted = BackupConfigurationRepository.getBackupById(backup.getId()); @@ -50,7 +50,6 @@ protected void deleteBackup_shuldBeTrue_afterDelete() { @Test protected void getBackupList_shuldBeTrue_SameSizeForSameBackupList() { - setupTheBackupList(); List backupList = BackupConfigurationRepository.getBackupList(); assertTrue(backups.size() == backupList.size()); } diff --git a/src/test/java/test/repositories/BackupRequestRepositoryTest.java b/src/test/java/test/repositories/BackupRequestRepositoryTest.java new file mode 100644 index 00000000..1e47f1dd --- /dev/null +++ b/src/test/java/test/repositories/BackupRequestRepositoryTest.java @@ -0,0 +1,118 @@ +package test.repositories; + +import java.io.IOException; +import java.time.LocalDateTime; +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; + +import org.junit.jupiter.api.AfterEach; +import static org.junit.jupiter.api.Assertions.assertTrue; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import backupmanager.Entities.BackupRequest; +import backupmanager.Entities.ConfigurationBackup; +import backupmanager.Enums.BackupStatusEnum; +import backupmanager.Enums.BackupTriggeredEnum; +import backupmanager.database.Database; +import backupmanager.database.DatabasePaths; +import backupmanager.database.Repositories.BackupConfigurationRepository; +import backupmanager.database.Repositories.BackupRequestRepository; +import backupmanager.database.TestDatabaseInitializer; + +public class BackupRequestRepositoryTest { + private List backups; + private List requests; + + @BeforeEach + protected void setup() throws Exception { + Database.init(DatabasePaths.getTestDatabasePath()); + TestDatabaseInitializer.init(); + + setupBackupRequestList(); + } + + @AfterEach + protected void clean() throws IOException { + TestDatabaseInitializer.deleteDatabase(); + } + + @Test + protected void isAnyBackupRunning_shouldBeTrue_forRunningBackup() { + assertTrue(BackupRequestRepository.isAnyBackupRunning()); + } + + @Test + protected void updateRequestProgressByRequestId_shouldBeTrue_forDifferentProgressValueAfterUpdate() { + BackupRequestRepository.updateRequestProgressByRequestId(requests.get(2).backupRequestId(), 50); + BackupRequest runningRequest = BackupRequestRepository.getBackupRequestById(requests.get(2).backupRequestId()); + assertTrue(requests.get(2).progress() != runningRequest.progress()); + } + + @Test + protected void updateRequestFolderSizeZippedByRequestId_shouldBeTrue_forDifferentFolderSizeAfterUpdate() { + BackupRequestRepository.updateRequestFolderSizeZippedByRequestId(requests.get(2).backupRequestId(), 6773); + BackupRequest runningRequest = BackupRequestRepository.getBackupRequestById(requests.get(2).backupRequestId()); + assertTrue(!Objects.equals(requests.get(2).zippedTargetSize(), runningRequest.zippedTargetSize())); + } + + @Test + protected void updateRequestStatusByRequestId_shouldBeTrue_forDifferentStatusAfterUpdate() { + BackupRequestRepository.updateRequestStatusByRequestId(requests.get(2).backupRequestId(), BackupStatusEnum.FINISHED); + BackupRequest runningRequest = BackupRequestRepository.getBackupRequestById(requests.get(2).backupRequestId()); + assertTrue(requests.get(2).status() != runningRequest.status()); + } + + @Test + protected void getLastBackupInProgressByConfigurationId_shouldBeTrue_forExistingBackupRequest() { + BackupRequest request_in_progress = BackupRequestRepository.getLastBackupInProgressByConfigurationId(backups.get(1).getId()); + assertTrue(request_in_progress != null); + } + + private void setupBackupRequestList() { + createBackupConfigurations(); + + BackupRequest request1 = createFinishedRequest(backups.get(0).getId()); + BackupRequest request2 = createFinishedRequest(backups.get(1).getId()); + BackupRequest request3 = BackupRequest.createNewBackupRequest(backups.get(1).getId(), BackupTriggeredEnum.USER, "outputPath", 123412, 2); + BackupRequest request4 = createFinishedRequest(backups.get(1).getId()); + + requests = new ArrayList<>(); + requests.add(request1); + requests.add(request2); + requests.add(request3); + requests.add(request4); + + for (BackupRequest request : requests) { + BackupRequestRepository.insertBackupRequest(request); + } + + requests = BackupRequestRepository.getRequestBackups(); + } + + private void createBackupConfigurations() { + ConfigurationBackup backup1 = createConfiguration("Test1"); + ConfigurationBackup backup2 = createConfiguration("Test2"); + ConfigurationBackup backup3 = createConfiguration("Test3"); + + backups = new ArrayList<>(); + backups.add(backup1); + backups.add(backup2); + backups.add(backup3); + + for (ConfigurationBackup backup : backups) { + BackupConfigurationRepository.insertBackup(backup); + } + + backups = BackupConfigurationRepository.getBackupList(); + } + + private ConfigurationBackup createConfiguration(String name) { + return new ConfigurationBackup(0, name, "TargetPath", "DestinationPath", null, false, null, null, "", LocalDateTime.now(), LocalDateTime.now(), 0, 1); + } + + private BackupRequest createFinishedRequest(int configurationId) { + return new BackupRequest(0, configurationId, LocalDateTime.now(), LocalDateTime.now(), BackupStatusEnum.FINISHED, 100, BackupTriggeredEnum.SCHEDULER, Long.valueOf(10), "OutputPath", 1000, Long.valueOf(100), 2, ""); + } +} diff --git a/src/test/java/test/repositories/EmailRepositoryTest.java b/src/test/java/test/repositories/EmailRepositoryTest.java new file mode 100644 index 00000000..c7fad55c --- /dev/null +++ b/src/test/java/test/repositories/EmailRepositoryTest.java @@ -0,0 +1,56 @@ +package test.repositories; + +import java.io.IOException; +import java.time.LocalDateTime; +import java.util.ArrayList; +import java.util.List; + +import org.junit.jupiter.api.AfterEach; +import static org.junit.jupiter.api.Assertions.assertEquals; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import backupmanager.Entities.Email; +import backupmanager.Enums.EmailType; +import backupmanager.database.Database; +import backupmanager.database.DatabasePaths; +import backupmanager.database.Repositories.EmailRepository; +import backupmanager.database.TestDatabaseInitializer; + +public class EmailRepositoryTest { + + private List emails; + + @BeforeEach + protected void setup() throws Exception { + Database.init(DatabasePaths.getTestDatabasePath()); + TestDatabaseInitializer.init(); + createEmails(); + } + + @AfterEach + protected void clean() throws IOException { + TestDatabaseInitializer.deleteDatabase(); + } + + @Test + protected void getLastEmail_shouldBeTrue_forLastEmailRegistered() { + Email lastSent = EmailRepository.getLastEmail(); + assertEquals("a strange error", lastSent.payload()); + } + + private void createEmails() { + Email email1 = new Email(0, EmailType.WELCOME, LocalDateTime.now(), "2.0.1", null); + Email email2 = new Email(0, EmailType.CRITICAL_ERROR, LocalDateTime.now().plusHours(6), "2.1.0", "thread1 error"); + Email email3 = new Email(0, EmailType.CRITICAL_ERROR, LocalDateTime.now().plusDays(9), "2.2.1", "a strange error"); + + emails = new ArrayList<>(); + emails.add(email1); + emails.add(email2); + emails.add(email3); + + for (Email email : emails) { + EmailRepository.insertEmail(email); + } + } +} diff --git a/src/test/java/test/repositories/UserRepositoryTest.java b/src/test/java/test/repositories/UserRepositoryTest.java new file mode 100644 index 00000000..1c68680a --- /dev/null +++ b/src/test/java/test/repositories/UserRepositoryTest.java @@ -0,0 +1,55 @@ +package test.repositories; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; + +import org.junit.jupiter.api.AfterEach; +import static org.junit.jupiter.api.Assertions.assertEquals; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import backupmanager.Entities.User; +import backupmanager.database.Database; +import backupmanager.database.DatabasePaths; +import backupmanager.database.Repositories.UserRepository; +import backupmanager.database.TestDatabaseInitializer; + +public class UserRepositoryTest { + private List users; + + @BeforeEach + protected void setup() throws Exception { + Database.init(DatabasePaths.getTestDatabasePath()); + TestDatabaseInitializer.init(); + + setupUserList(); + } + + @AfterEach + protected void clean() throws IOException { + TestDatabaseInitializer.deleteDatabase(); + } + + @Test + protected void getLastUser_shouldBeEquals_forSameUser() { + User lastUser = UserRepository.getLastUser(); + assertEquals(users.getLast().email(), lastUser.email()); + } + + private void setupUserList() { + User user1 = new User("Username1", "Usersurname1", "username1@gmail.com"); + User user2 = new User("Username2", "Usersurname2", "username2@gmail.com"); + User user3 = new User("Username3", "Usersurname3", "username3@gmail.com"); + + users = new ArrayList<>(); + + users.add(user1); + users.add(user2); + users.add(user3); + + for (User user : users) { + UserRepository.insertUser(user); + } + } +} From 21877856b171ed9a1032954c1e7bfd42a0ac7465 Mon Sep 17 00:00:00 2001 From: DennisTurco Date: Mon, 16 Feb 2026 14:18:55 +0100 Subject: [PATCH 5/5] enum refactor --- .../backupmanager/Enums/BackupStatusEnum.java | 15 +++++++-------- .../backupmanager/Enums/BackupTriggeredEnum.java | 13 ++++++------- src/main/java/backupmanager/Enums/EmailType.java | 13 ++++++------- .../java/backupmanager/Enums/utils/CodeEnum.java | 5 +++++ .../java/backupmanager/Enums/utils/EnumUtil.java | 12 ++++++++++++ 5 files changed, 36 insertions(+), 22 deletions(-) create mode 100644 src/main/java/backupmanager/Enums/utils/CodeEnum.java create mode 100644 src/main/java/backupmanager/Enums/utils/EnumUtil.java diff --git a/src/main/java/backupmanager/Enums/BackupStatusEnum.java b/src/main/java/backupmanager/Enums/BackupStatusEnum.java index 5c0303b0..754491a9 100644 --- a/src/main/java/backupmanager/Enums/BackupStatusEnum.java +++ b/src/main/java/backupmanager/Enums/BackupStatusEnum.java @@ -1,6 +1,9 @@ package backupmanager.Enums; -public enum BackupStatusEnum { +import backupmanager.Enums.utils.CodeEnum; +import backupmanager.Enums.utils.EnumUtil; + +public enum BackupStatusEnum implements CodeEnum { IN_PROGRESS(1), QUEUE(2), FINISHED(3), @@ -12,16 +15,12 @@ public enum BackupStatusEnum { this.code = code; } + @Override public int getCode() { return code; } public static BackupStatusEnum fromCode(int code) { - for (BackupStatusEnum status : values()) { - if (status.code == code) { - return status; - } - } - throw new IllegalArgumentException("Invalid BackupStatusEnum code: " + code); + return EnumUtil.fromCode(BackupStatusEnum.class, code); } -} \ No newline at end of file +} diff --git a/src/main/java/backupmanager/Enums/BackupTriggeredEnum.java b/src/main/java/backupmanager/Enums/BackupTriggeredEnum.java index 6b5d1012..091813d9 100644 --- a/src/main/java/backupmanager/Enums/BackupTriggeredEnum.java +++ b/src/main/java/backupmanager/Enums/BackupTriggeredEnum.java @@ -1,6 +1,9 @@ package backupmanager.Enums; -public enum BackupTriggeredEnum { +import backupmanager.Enums.utils.CodeEnum; +import backupmanager.Enums.utils.EnumUtil; + +public enum BackupTriggeredEnum implements CodeEnum { USER(1), SCHEDULER(2); @@ -10,16 +13,12 @@ public enum BackupTriggeredEnum { this.code = code; } + @Override public int getCode() { return code; } public static BackupTriggeredEnum fromCode(int code) { - for (BackupTriggeredEnum status : values()) { - if (status.code == code) { - return status; - } - } - throw new IllegalArgumentException("Invalid BackupTriggeredEnum code: " + code); + return EnumUtil.fromCode(BackupTriggeredEnum.class, code); } } diff --git a/src/main/java/backupmanager/Enums/EmailType.java b/src/main/java/backupmanager/Enums/EmailType.java index 6d4efbe2..02418885 100644 --- a/src/main/java/backupmanager/Enums/EmailType.java +++ b/src/main/java/backupmanager/Enums/EmailType.java @@ -1,6 +1,9 @@ package backupmanager.Enums; -public enum EmailType { +import backupmanager.Enums.utils.CodeEnum; +import backupmanager.Enums.utils.EnumUtil; + +public enum EmailType implements CodeEnum { WELCOME(1), CRITICAL_ERROR(2); @@ -10,16 +13,12 @@ public enum EmailType { this.code = code; } + @Override public int getCode() { return code; } public static EmailType fromCode(int code) { - for (EmailType status : values()) { - if (status.code == code) { - return status; - } - } - throw new IllegalArgumentException("Invalid EmailType code: " + code); + return EnumUtil.fromCode(EmailType.class, code); } } diff --git a/src/main/java/backupmanager/Enums/utils/CodeEnum.java b/src/main/java/backupmanager/Enums/utils/CodeEnum.java new file mode 100644 index 00000000..1841b6dd --- /dev/null +++ b/src/main/java/backupmanager/Enums/utils/CodeEnum.java @@ -0,0 +1,5 @@ +package backupmanager.Enums.utils; + +public interface CodeEnum { + public int getCode(); +} diff --git a/src/main/java/backupmanager/Enums/utils/EnumUtil.java b/src/main/java/backupmanager/Enums/utils/EnumUtil.java new file mode 100644 index 00000000..a3cda052 --- /dev/null +++ b/src/main/java/backupmanager/Enums/utils/EnumUtil.java @@ -0,0 +1,12 @@ +package backupmanager.Enums.utils; + +public class EnumUtil { + public static & CodeEnum> Type fromCode(Class enumClass, int code) { + for (Type constants : enumClass.getEnumConstants()) { + if (constants.getCode() == code) { + return constants; + } + } + throw new IllegalArgumentException("Invalid code " + code + " for enum " + enumClass.getSimpleName()); + } +}