GH-127 Add integration tests for each repository

build.gradle.kts

@@ -23,7 +23,7 @@ repositories {
 
 dependencies {
     // minecraft development api
-    compileOnly("org.spigotmc:spigot-api:1.21.7-R0.1-SNAPSHOT")
+    compileOnly("org.spigotmc:spigot-api:1.21.8-R0.1-SNAPSHOT")
     implementation("net.kyori:adventure-platform-bukkit:4.4.0")
     implementation("net.kyori:adventure-text-minimessage:4.23.0")
     implementation("dev.rollczi:litecommands-bukkit:3.10.2")
@@ -80,6 +80,7 @@ dependencies {
 
     testImplementation("org.junit.jupiter:junit-jupiter-api:5.13.3")
     testImplementation("org.junit.jupiter:junit-jupiter-params:5.13.3")
+    testCompileOnly("org.spigotmc:spigot-api:1.21.8-R0.1-SNAPSHOT")
     testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.13.3")
     testRuntimeOnly("org.junit.platform:junit-platform-launcher")
 

src/test/java/com/eternalcode/parcellockers/database/DeliveryRepositoryIntegrationTest.java

@@ -0,0 +1,65 @@
+package com.eternalcode.parcellockers.database;
+
+import com.eternalcode.parcellockers.TestScheduler;
+import com.eternalcode.parcellockers.configuration.ConfigurationManager;
+import com.eternalcode.parcellockers.configuration.implementation.PluginConfiguration;
+import com.eternalcode.parcellockers.delivery.Delivery;
+import com.eternalcode.parcellockers.delivery.repository.DeliveryRepository;
+import com.eternalcode.parcellockers.delivery.repository.DeliveryRepositoryOrmLite;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.testcontainers.containers.MySQLContainer;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+import org.testcontainers.utility.DockerImageName;
+
+import java.io.File;
+import java.nio.file.Path;
+import java.time.Instant;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.logging.Logger;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@Testcontainers
+class DeliveryRepositoryIntegrationTest extends IntegrationTestSpec{
+
+    @Container
+    private static final MySQLContainer mySQLContainer = new MySQLContainer(DockerImageName.parse("mysql:latest"));
+
+    @TempDir
+    private Path tempDir;
+
+    private DatabaseManager databaseManager;
+
+    @Test
+    void test() {
+        File dataFolder = tempDir.resolve("ParcelLockers").toFile();
+        PluginConfiguration config = new ConfigurationManager(dataFolder).load(new PluginConfiguration());
+        DatabaseManager databaseManager = new DatabaseManager(config, Logger.getLogger("ParcelLockers"), dataFolder);
+        this.databaseManager = databaseManager;
+        DeliveryRepository deliveryRepository = new DeliveryRepositoryOrmLite(databaseManager, new TestScheduler());
+
+        Delivery delivery = new Delivery(UUID.randomUUID(), Instant.now());
+        deliveryRepository.save(delivery);
+
+        Optional<Delivery> deliveryOptional = await(deliveryRepository.find(delivery.parcel()));
+        assertTrue(deliveryOptional.isPresent(), "Delivery should be present");
+        assertEquals(delivery.parcel(), deliveryOptional.get().parcel());
+
+        deliveryRepository.remove(delivery.parcel());
+        Optional<Delivery> removedDelivery = await(deliveryRepository.find(delivery.parcel()));
+        assertTrue(removedDelivery.isEmpty(), "Delivery should be removed");
+    }
+
+    @AfterEach
+    void tearDown() {
+        if (this.databaseManager != null) {
+            this.databaseManager.disconnect();
+        }
+    }
+
+}

src/test/java/com/eternalcode/parcellockers/database/ItemStorageRepositoryIntegrationTest.java

@@ -0,0 +1,64 @@
+package com.eternalcode.parcellockers.database;
+
+import com.eternalcode.parcellockers.TestScheduler;
+import com.eternalcode.parcellockers.configuration.ConfigurationManager;
+import com.eternalcode.parcellockers.configuration.implementation.PluginConfiguration;
+import com.eternalcode.parcellockers.itemstorage.ItemStorage;
+import com.eternalcode.parcellockers.itemstorage.repository.ItemStorageRepository;
+import com.eternalcode.parcellockers.itemstorage.repository.ItemStorageRepositoryOrmLite;
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.testcontainers.containers.MySQLContainer;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.utility.DockerImageName;
+
+import java.io.File;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.logging.Logger;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class ItemStorageRepositoryIntegrationTest extends IntegrationTestSpec {
+
+    @Container
+    private static final MySQLContainer mySQLContainer = new MySQLContainer(DockerImageName.parse("mysql:latest"));
+
+    @TempDir
+    private Path tempDir;
+
+    private DatabaseManager databaseManager;
+
+    @Test
+    void test() {
+        File dataFolder = tempDir.resolve("ParcelLockers").toFile();
+        PluginConfiguration config = new ConfigurationManager(dataFolder).load(new PluginConfiguration());
+        this.databaseManager = new DatabaseManager(config, Logger.getLogger("ParcelLockers"), dataFolder);
+        ItemStorageRepository itemStorageRepository = new ItemStorageRepositoryOrmLite(databaseManager, new TestScheduler());
+
+        ItemStorage itemStorage = new ItemStorage(UUID.randomUUID(), List.of(new ItemStack(Material.GOLD_BLOCK, 64)));
+        itemStorageRepository.save(itemStorage);
+        Optional<ItemStorage> retrievedItemStorage = await(itemStorageRepository.find(itemStorage.owner()));
+        assertTrue(retrievedItemStorage.isPresent(), "ItemStorage should be present");
+        assertTrue(retrievedItemStorage.get().items().contains(new ItemStack(Material.GOLD_BLOCK, 64)),
+            "ItemStorage should contain the saved item");
+
+        itemStorageRepository.remove(itemStorage.owner());
+        Optional<ItemStorage> removedItemStorage = await(itemStorageRepository.find(itemStorage.owner()));
+        assertTrue(removedItemStorage.isEmpty(), "ItemStorage should be removed");
+    }
+
+
+    @AfterEach
+    void tearDown() {
+        if (this.databaseManager != null) {
+            this.databaseManager.disconnect();
+        }
+    }
+
+}

src/test/java/com/eternalcode/parcellockers/database/LockerRepositoryIntegrationTest.java

@@ -52,7 +52,6 @@ void test() {
         String description = "Parcel locker description.";
         Position position = new Position(1, 2, 3, "world");
 
-
         parcelLockerRepository.save(new Locker(uuid, description, position));
 
         Optional<Locker> parcelLocker = await(parcelLockerRepository.findByUUID(uuid));

src/test/java/com/eternalcode/parcellockers/database/ParcelContentRepositoryIntegrationTest.java

@@ -0,0 +1,57 @@
+package com.eternalcode.parcellockers.database;
+
+import com.eternalcode.parcellockers.TestScheduler;
+import com.eternalcode.parcellockers.configuration.ConfigurationManager;
+import com.eternalcode.parcellockers.configuration.implementation.PluginConfiguration;
+import com.eternalcode.parcellockers.content.ParcelContent;
+import com.eternalcode.parcellockers.content.repository.ParcelContentRepository;
+import com.eternalcode.parcellockers.content.repository.ParcelContentRepositoryOrmLite;
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.io.File;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.logging.Logger;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class ParcelContentRepositoryIntegrationTest extends IntegrationTestSpec {
+
+    @TempDir
+    private Path tempDir;
+
+    private DatabaseManager databaseManager;
+
+    @Test
+    void test() {
+        File dataFolder = tempDir.resolve("ParcelLockers").toFile();
+        PluginConfiguration config = new ConfigurationManager(dataFolder).load(new PluginConfiguration());
+        this.databaseManager = new DatabaseManager(config, Logger.getLogger("ParcelLockers"), dataFolder);
+
+        ParcelContentRepository parcelContentRepository = new ParcelContentRepositoryOrmLite(databaseManager, new TestScheduler());
+
+        ParcelContent parcelContent = new ParcelContent(UUID.randomUUID(), List.of(new ItemStack(Material.GOLD_BLOCK, 64)));
+        parcelContentRepository.save(parcelContent);
+        Optional<ParcelContent> retrievedParcelContent = await(parcelContentRepository.findByUUID(parcelContent.uniqueId()));
+        assertTrue(retrievedParcelContent.isPresent(), "ParcelContent should be present");
+
+        parcelContentRepository.remove(parcelContent.uniqueId());
+        Optional<ParcelContent> removedParcelContent = await(parcelContentRepository.findByUUID(parcelContent.uniqueId()));
+        assertFalse(removedParcelContent.isPresent(), "ParcelContent should be removed");
+    }
+
+    @AfterEach
+    void tearDown() {
+        if (this.databaseManager != null) {
+            this.databaseManager.disconnect();
+        }
+    }
+
+}

src/test/java/com/eternalcode/parcellockers/database/UserRepositoryIntegrationTest.java

@@ -0,0 +1,67 @@
+package com.eternalcode.parcellockers.database;
+
+import com.eternalcode.parcellockers.TestScheduler;
+import com.eternalcode.parcellockers.configuration.ConfigurationManager;
+import com.eternalcode.parcellockers.configuration.implementation.PluginConfiguration;
+import com.eternalcode.parcellockers.shared.Page;
+import com.eternalcode.parcellockers.user.User;
+import com.eternalcode.parcellockers.user.repository.UserRepository;
+import com.eternalcode.parcellockers.user.repository.UserRepositoryOrmLite;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.testcontainers.containers.MySQLContainer;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.io.File;
+import java.nio.file.Path;
+import java.util.Optional;
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@Testcontainers
+class UserRepositoryIntegrationTest extends IntegrationTestSpec {
+
+    @Container
+    private static final MySQLContainer container = new MySQLContainer();
+
+    @TempDir
+    private Path tempDir;
+
+    private DatabaseManager databaseManager;
+
+    @Test
+    void test() {
+        File dataFolder = tempDir.resolve("ParcelLockers").toFile();
+        PluginConfiguration config = new ConfigurationManager(dataFolder).load(new PluginConfiguration());
+        DatabaseManager databaseManager = new DatabaseManager(config, null, dataFolder);
+        this.databaseManager = databaseManager;
+
+        UserRepository userRepository = new UserRepositoryOrmLite(databaseManager, new TestScheduler());
+
+        UUID userUuid = UUID.randomUUID();
+        String username = "testUser";
+        User user = new User(userUuid, username);
+
+        userRepository.save(user);
+
+        Optional<User> userOptional = await(userRepository.getUser(userUuid));
+        assertTrue(userOptional.isPresent());
+        User retrievedUser = userOptional.get();
+        assertEquals(retrievedUser.uuid(), userUuid);
+
+        userRepository.getPage(new Page(0, 10))
+            .thenAccept(userPageResult -> assertTrue(userPageResult.users().stream().anyMatch(u -> u.uuid().equals(userUuid))));
+    }
+
+    @AfterEach
+    void tearDown() {
+        if (this.databaseManager != null) {
+            this.databaseManager.disconnect();
+        }
+    }
+
+}