Remove unfinished AOE repair recipe

libraries/name-api/build.gradle.kts

@@ -10,4 +10,11 @@ dependencies {
     api(libs.configurate.yaml)
     api("org.mariadb.jdbc:mariadb-java-client:3.5.6")
     implementation(libs.slf4j.api)
+
+    testImplementation(libs.bundles.junit)
+    testImplementation("org.mockito:mockito-core:5.11.0")
+}
+
+tasks.withType<Test> {
+    useJUnitPlatform()
 }

libraries/name-api/src/main/java/net/civmc/nameapi/Migrator.java

@@ -5,6 +5,7 @@
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.sql.Statement;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.NavigableMap;
@@ -32,33 +33,40 @@ public void registerMigration(String namespace, int id, @Language("mariadb") Str
 
     public void migrate(Connection connection) throws SQLException {
         connection.setAutoCommit(false);
-        connection.createStatement().executeUpdate("CREATE TABLE IF NOT EXISTS migrations (" +
-            "namespace VARCHAR(64) PRIMARY KEY," +
-            "id INT NOT NULL)");
+        try (Statement createTable = connection.createStatement()) {
+            createTable.executeUpdate("CREATE TABLE IF NOT EXISTS migrations (" +
+                "namespace VARCHAR(64) PRIMARY KEY," +
+                "id INT NOT NULL)");
+        }
 
         for (Map.Entry<String, NavigableMap<Integer, String[]>> entry : migrations.entrySet()) {
-            PreparedStatement getMigrationId = connection.prepareStatement("SELECT id FROM migrations WHERE namespace = ? FOR UPDATE");
-            getMigrationId.setString(1, entry.getKey());
-            ResultSet resultSet = getMigrationId.executeQuery();
             int minId;
-            if (resultSet.next()) {
-                minId = resultSet.getInt("id");
-            } else {
-                minId = -1;
+            try (PreparedStatement getMigrationId = connection.prepareStatement("SELECT id FROM migrations WHERE namespace = ? FOR UPDATE")) {
+                getMigrationId.setString(1, entry.getKey());
+                ResultSet resultSet = getMigrationId.executeQuery();
+                if (resultSet.next()) {
+                    minId = resultSet.getInt("id");
+                } else {
+                    minId = -1;
+                }
             }
 
             NavigableMap<Integer, String[]> value = entry.getValue().tailMap(minId, false);
             int maxId = entry.getValue().lastKey();
             for (String[] migration : value.sequencedValues()) {
                 for (String sql : migration) {
-                    connection.createStatement().executeUpdate(sql);
+                    try (Statement statement = connection.createStatement()) {
+                        statement.executeUpdate(sql);
+                    }
                 }
             }
 
             if (maxId != minId) {
-                PreparedStatement setMigrationId = connection.prepareStatement("REPLACE INTO migrations (namespace, id) VALUES (?, ?)");
-                setMigrationId.setString(1, entry.getKey());
-                setMigrationId.setInt(2, maxId);
+                try (PreparedStatement setMigrationId = connection.prepareStatement("REPLACE INTO migrations (namespace, id) VALUES (?, ?)")) {
+                    setMigrationId.setString(1, entry.getKey());
+                    setMigrationId.setInt(2, maxId);
+                    setMigrationId.executeUpdate();
+                }
             }
         }
         connection.setAutoCommit(true);

libraries/name-api/src/test/java/net/civmc/nameapi/MigratorTest.java

@@ -0,0 +1,41 @@
+package net.civmc.nameapi;
+
+import org.junit.jupiter.api.Test;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+class MigratorTest {
+
+    @Test
+    void persistsAppliedMigrationId() throws SQLException {
+        Connection connection = mock(Connection.class);
+        when(connection.createStatement()).thenReturn(mock(Statement.class));
+
+        ResultSet emptyResult = mock(ResultSet.class);
+        when(emptyResult.next()).thenReturn(false);
+
+        PreparedStatement selectStatement = mock(PreparedStatement.class);
+        when(selectStatement.executeQuery()).thenReturn(emptyResult);
+        when(connection.prepareStatement("SELECT id FROM migrations WHERE namespace = ? FOR UPDATE"))
+            .thenReturn(selectStatement);
+
+        PreparedStatement replaceStatement = mock(PreparedStatement.class);
+        when(connection.prepareStatement("REPLACE INTO migrations (namespace, id) VALUES (?, ?)"))
+            .thenReturn(replaceStatement);
+
+        Migrator migrator = new Migrator();
+        migrator.registerMigration("test", 0, "SELECT 1");
+        migrator.migrate(connection);
+
+        verify(replaceStatement).setInt(2, 0);
+        verify(replaceStatement).executeUpdate();
+    }
+}

plugins/bastion-paper/src/main/java/isaac/bastion/BastionBlock.java

@@ -463,15 +463,14 @@ public String getStrengthText() {
         return formatter.format(rein.getHealth()) + "/" + formatter.format(rein.getType().getHealth());
     }
 
-    // TODO: Test world-aware comparison
     @Override
     public int compareTo(BastionBlock other) {
         UUID thisWorld = location.getWorld().getUID();
         int thisX = location.getBlockX();
         int thisY = location.getBlockY();
         int thisZ = location.getBlockZ();
 
-        UUID otherWorld = location.getWorld().getUID();
+        UUID otherWorld = other.location.getWorld().getUID();
         int otherX = other.location.getBlockX();
         int otherY = other.location.getBlockY();
         int otherZ = other.location.getBlockZ();

plugins/bastion-paper/src/test/java/isaac/bastion/BastionBlockCompareToTest.java

@@ -0,0 +1,116 @@
+package isaac.bastion;
+
+import isaac.bastion.storage.BastionBlockStorage;
+import java.util.UUID;
+import org.bukkit.Chunk;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+import vg.civcraft.mc.citadel.Citadel;
+import vg.civcraft.mc.citadel.ReinforcementManager;
+import vg.civcraft.mc.citadel.model.Reinforcement;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+class BastionBlockCompareToTest {
+
+    private MockedStatic<Citadel> citadelStatic;
+    private MockedStatic<Bastion> bastionStatic;
+    private BastionType type;
+
+    // Locations hold their World via WeakReference; keep strong refs so getWorld() stays valid.
+    private final UUID worldUidLow = new UUID(0L, 1L);
+    private final UUID worldUidHigh = new UUID(0L, 2L);
+    private World worldLow;
+    private World worldHigh;
+
+    @BeforeEach
+    void setUp() {
+        worldLow = mockWorld(worldUidLow);
+        worldHigh = mockWorld(worldUidHigh);
+
+        type = mock(BastionType.class);
+        when(type.getWarmupTime()).thenReturn(0L);
+
+        Citadel citadel = mock(Citadel.class);
+        ReinforcementManager reinforcementManager = mock(ReinforcementManager.class);
+        Reinforcement reinforcement = mock(Reinforcement.class);
+        when(reinforcement.getGroupId()).thenReturn(1);
+        when(reinforcementManager.getReinforcement(any(Location.class))).thenReturn(reinforcement);
+        when(citadel.getReinforcementManager()).thenReturn(reinforcementManager);
+
+        citadelStatic = Mockito.mockStatic(Citadel.class);
+        citadelStatic.when(Citadel::getInstance).thenReturn(citadel);
+
+        Bastion plugin = mock(Bastion.class);
+        BastionBlockStorage storage = mock(BastionBlockStorage.class);
+        bastionStatic = Mockito.mockStatic(Bastion.class);
+        bastionStatic.when(Bastion::getPlugin).thenReturn(plugin);
+        bastionStatic.when(Bastion::getBastionStorage).thenReturn(storage);
+    }
+
+    @AfterEach
+    void tearDown() {
+        try {
+            citadelStatic.close();
+        } finally {
+            bastionStatic.close();
+        }
+    }
+
+    private World mockWorld(UUID uid) {
+        World world = mock(World.class);
+        Chunk chunk = mock(Chunk.class);
+        when(world.getChunkAt(any(Location.class))).thenReturn(chunk);
+        when(world.getUID()).thenReturn(uid);
+        return world;
+    }
+
+    private BastionBlock block(World world, int x, int y, int z) {
+        return new BastionBlock(new Location(world, x, y, z), 0L, 1, type);
+    }
+
+    @Test
+    void ordersBlocksByWorldUidWhenCoordsAreIdentical() {
+        BastionBlock low = block(worldLow, 10, 64, 20);
+        BastionBlock high = block(worldHigh, 10, 64, 20);
+
+        Assertions.assertTrue(low.compareTo(high) < 0,
+            "block in lower world UID must sort before identical coords in higher world UID");
+        Assertions.assertTrue(high.compareTo(low) > 0,
+            "block in higher world UID must sort after identical coords in lower world UID");
+        Assertions.assertNotEquals(0, low.compareTo(high),
+            "blocks in different worlds with identical coords must not compare equal");
+        Assertions.assertNotEquals(low, high,
+            "blocks in different worlds are distinct instances and not equal");
+    }
+
+    @Test
+    void compareToIsAntisymmetricAcrossWorldsAndCoords() {
+        BastionBlock[] blocks = {
+            block(worldLow, 0, 0, 0),
+            block(worldLow, 0, 0, 5),
+            block(worldLow, 0, 7, 0),
+            block(worldLow, 3, 0, 0),
+            block(worldHigh, 0, 0, 0),
+            block(worldHigh, 3, 7, 5),
+            block(worldHigh, -4, -2, -8),
+        };
+
+        for (BastionBlock a : blocks) {
+            for (BastionBlock b : blocks) {
+                Assertions.assertEquals(
+                    Integer.signum(a.compareTo(b)),
+                    -Integer.signum(b.compareTo(a)),
+                    "compareTo must be antisymmetric for every pair");
+            }
+        }
+    }
+}

plugins/civspy-api/build.gradle.kts

@@ -3,4 +3,7 @@ version = "2.0.1"
 dependencies {
     implementation("com.zaxxer:HikariCP:3.4.2")
     implementation("org.postgresql:postgresql:42.3.5")
+
+    testImplementation(libs.bundles.junit)
+    testImplementation("org.mockito:mockito-core:5.11.0")
 }

plugins/civspy-api/src/main/java/com/programmerdan/minecraft/civspy/database/Database.java

@@ -228,40 +228,40 @@ public int insertData(String key, UUID uuid, String sValue, Number nValue, Long
     }
 
     public int insertData(String key, String server, String world, Integer chunk_x, Integer chunk_z) {
-        return insertData(key, world, server, chunk_x, chunk_z, null, null, null, null, null);
+        return insertData(key, server, world, chunk_x, chunk_z, null, null, null, null, null);
     }
 
     public int insertData(String key, String server, String world, Integer chunk_x, Integer chunk_z, String value) {
-        return insertData(key, world, server, chunk_x, chunk_z, null, value, null, null, null);
+        return insertData(key, server, world, chunk_x, chunk_z, null, value, null, null, null);
     }
 
     public int insertData(String key, String server, String world, Integer chunk_x, Integer chunk_z, Number value) {
-        return insertData(key, world, server, chunk_x, chunk_z, null, null, value, null, null);
+        return insertData(key, server, world, chunk_x, chunk_z, null, null, value, null, null);
     }
 
     public int insertData(String key, String server, String world, Integer chunk_x, Integer chunk_z, String sValue, Number nValue) {
-        return insertData(key, world, server, chunk_x, chunk_z, null, sValue, nValue, null, null);
+        return insertData(key, server, world, chunk_x, chunk_z, null, sValue, nValue, null, null);
     }
 
     public int insertData(String key, String server, String world, Integer chunk_x, Integer chunk_z, String sValue, Number nValue,
                           Long time, Connection connection) {
-        return insertData(key, world, server, chunk_x, chunk_z, null, sValue, nValue, time, connection);
+        return insertData(key, server, world, chunk_x, chunk_z, null, sValue, nValue, time, connection);
     }
 
     public int insertData(String key, String server, String world, Integer chunk_x, Integer chunk_z, UUID uuid) {
-        return insertData(key, world, server, chunk_x, chunk_z, uuid, null, null, null, null);
+        return insertData(key, server, world, chunk_x, chunk_z, uuid, null, null, null, null);
     }
 
     public int insertData(String key, String server, String world, Integer chunk_x, Integer chunk_z, UUID uuid, String value) {
-        return insertData(key, world, server, chunk_x, chunk_z, uuid, value, null, null, null);
+        return insertData(key, server, world, chunk_x, chunk_z, uuid, value, null, null, null);
     }
 
     public int insertData(String key, String server, String world, Integer chunk_x, Integer chunk_z, UUID uuid, Number value) {
-        return insertData(key, world, server, chunk_x, chunk_z, uuid, null, value, null, null);
+        return insertData(key, server, world, chunk_x, chunk_z, uuid, null, value, null, null);
     }
 
     public int insertData(String key, String server, String world, Integer chunk_x, Integer chunk_z, UUID uuid, String sValue, Number nValue) {
-        return insertData(key, world, server, chunk_x, chunk_z, uuid, sValue, nValue, null, null);
+        return insertData(key, server, world, chunk_x, chunk_z, uuid, sValue, nValue, null, null);
     }
 
     /**

plugins/civspy-api/src/test/java/com/programmerdan/minecraft/civspy/database/DatabaseInsertDataTest.java

@@ -0,0 +1,53 @@
+package com.programmerdan.minecraft.civspy.database;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Logger;
+
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mockito;
+
+public class DatabaseInsertDataTest {
+
+    /**
+     * INSERT_STRING binds (stat_time, stat_key, string_value, server, world, ...), so with a string value
+     * present the server column is parameter 4 and the world column is parameter 5.
+     */
+    private static final int SERVER_INDEX = 4;
+    private static final int WORLD_INDEX = 5;
+
+    @Test
+    public void convenienceOverloadBindsServerAndWorldToCorrectColumns() throws Exception {
+        Connection connection = Mockito.mock(Connection.class);
+        PreparedStatement statement = Mockito.mock(PreparedStatement.class);
+        when(connection.prepareStatement(Database.INSERT_STRING)).thenReturn(statement);
+        when(statement.executeUpdate()).thenReturn(1);
+
+        Database db = new Database(Logger.getLogger("test"), null, null, null, 0, null, 0, 0L, 0L, 0L);
+
+        db.insertData("test.key", "the-server", "the-world", 7, 9, "string-value", null, 123L, connection);
+
+        ArgumentCaptor<Integer> indexCaptor = ArgumentCaptor.forClass(Integer.class);
+        ArgumentCaptor<String> valueCaptor = ArgumentCaptor.forClass(String.class);
+        verify(statement, atLeastOnce()).setString(indexCaptor.capture(), valueCaptor.capture());
+
+        Map<Integer, String> boundStrings = new HashMap<>();
+        List<Integer> indices = indexCaptor.getAllValues();
+        List<String> values = valueCaptor.getAllValues();
+        for (int i = 0; i < indices.size(); i++) {
+            boundStrings.put(indices.get(i), values.get(i));
+        }
+
+        assertEquals("the-server", boundStrings.get(SERVER_INDEX), "server must bind to the server column");
+        assertEquals("the-world", boundStrings.get(WORLD_INDEX), "world must bind to the world column");
+    }
+}

plugins/combattagplus-paper/build.gradle.kts

@@ -11,4 +11,5 @@ dependencies {
     }
 
     compileOnly(libs.barapi)
+    compileOnly(files("./libs/GSit-3.3.1.jar"))
 }

plugins/combattagplus-paper/src/main/java/net/minelink/ctplus/CombatTagPlus.java

@@ -10,6 +10,7 @@
 import net.minelink.ctplus.hook.Hook;
 import net.minelink.ctplus.hook.HookManager;
 import net.minelink.ctplus.listener.ForceFieldListener;
+import net.minelink.ctplus.listener.GSitListener;
 import net.minelink.ctplus.listener.InstakillListener;
 import net.minelink.ctplus.listener.NpcListener;
 import net.minelink.ctplus.listener.PlayerListener;
@@ -112,6 +113,8 @@ public void onEnable() {
         Bukkit.getPluginManager().registerEvents(new PlayerListener(this), this);
         Bukkit.getPluginManager().registerEvents(new TagListener(this), this);
 
+        Bukkit.getPluginManager().registerEvents(new GSitListener(this), this);
+
         // Anti-SafeZone task
         ForceFieldTask.run(this);