Draft: feat(commands): Add IPSame command to check if players share the same IP address

build.gradle.kts

@@ -5,6 +5,7 @@ plugins {
     alias(libs.plugins.runServer)
     `maven-publish`
 }
+
 dependencies {
 
     compileOnly(libs.paper)
@@ -18,8 +19,11 @@ dependencies {
     implementation(libs.apacheCommons)
 
     // Testing
-    testImplementation(libs.junitApi)
-    testRuntimeOnly(libs.junitEngine)
+    testImplementation(platform(libs.mycelium.bom))
+    testImplementation(libs.junit.jupiter)
+    testImplementation(libs.junit.platform.launcher)
+    testRuntimeOnly(libs.junit.jupiter.engine)
+    testImplementation(libs.mockbukkit)
 }
 
 java {
@@ -42,6 +46,9 @@ tasks {
     }
     test {
         useJUnitPlatform()
+        testLogging {
+            events("passed", "skipped", "failed")
+        }
     }
     runServer {
         minecraftVersion("1.21.4")

settings.gradle.kts

@@ -36,12 +36,15 @@ dependencyResolutionManagement {
             version("postgresql", "42.7.3")
             version("apacheCommons", "3.17.0")
             version("junitApi", "5.11.0")
+            version("bom", "1.4.2")
+            version("mockbukit", "4.72.2")
 
             plugin("pluginYaml", "net.minecrell.plugin-yml.paper").version("0.6.0")
             plugin("shadow", "com.github.johnrengelman.shadow").version("8.1.1")
             plugin("runServer", "xyz.jpenilla.run-paper").version("2.3.1")
 
 
+            library("mycelium.bom", "net.onelitefeather", "mycelium-bom").versionRef("bom")
             library("paper", "io.papermc.paper", "paper-api").versionRef("paper")
             library("luckperms", "net.luckperms", "api").versionRef("luckperms")
             library("protocolLib", "com.comphenix.protocol", "ProtocolLib").versionRef("protocolLib")
@@ -58,8 +61,10 @@ dependencyResolutionManagement {
 
             library("apacheCommons", "org.apache.commons", "commons-lang3").versionRef("apacheCommons")
 
-            library("junitApi", "org.junit.jupiter", "junit-jupiter-api").versionRef("junitApi")
-            library("junitEngine", "org.junit.jupiter", "junit-jupiter-engine").withoutVersion()
+            library("junit-jupiter", "org.junit.jupiter", "junit-jupiter").withoutVersion()
+            library("junit-jupiter-engine", "org.junit.jupiter", "junit-jupiter-engine").withoutVersion()
+            library("junit.platform.launcher", "org.junit.platform", "junit-platform-launcher").withoutVersion()
+            library("mockbukkit", "org.mockbukkit.mockbukkit", "mockbukkit-v1.21").versionRef("mockbukit")
 
             bundle("cloud", listOf("cloudPaper", "cloudAnnotations", "cloudExtras"))
             bundle("hibernate", listOf("hibernateCore", "hibernateHikariCP"))

src/main/java/net/onelitefeather/stardust/StardustPlugin.java

@@ -13,14 +13,25 @@
 import net.onelitefeather.stardust.translation.PluginTranslationRegistry;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
+import org.bukkit.plugin.PluginDescriptionFile;
 import org.bukkit.plugin.java.JavaPlugin;
+import org.bukkit.plugin.java.JavaPluginLoader;
 
+import java.io.File;
 import java.util.List;
 import java.util.Locale;
 import java.util.ResourceBundle;
 
+@SuppressWarnings("removal")
 public class StardustPlugin extends JavaPlugin {
 
+    public StardustPlugin() {
+    }
+
+    public StardustPlugin(JavaPluginLoader loader, PluginDescriptionFile description, File dataFolder, File file) {
+        super(loader, description, dataFolder, file);
+    }
+
     private final List<Locale> supportedLocals = List.of(Locale.US, Locale.GERMANY);
 
     private SyncFrogService syncFrogService;

src/main/java/net/onelitefeather/stardust/command/commands/IPSameCommand.java

@@ -0,0 +1,44 @@
+package net.onelitefeather.stardust.command.commands;
+
+import net.kyori.adventure.text.Component;
+import net.onelitefeather.stardust.StardustPlugin;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.incendo.cloud.annotations.Argument;
+import org.incendo.cloud.annotations.Command;
+import org.incendo.cloud.annotations.CommandDescription;
+import org.incendo.cloud.annotations.Permission;
+
+public final class IPSameCommand {
+
+
+    private final StardustPlugin plugin;
+
+    public IPSameCommand(StardustPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    @Command("ipsame <player>")
+    @Permission(value = {
+            "stardust.command.ipsame",
+            "psittaciforms.command.ipsame"
+    })
+    @CommandDescription("Check if the player is on the same IP as another player.")
+    public void isPlayerIPSame(Player player, @Argument("player") Player target) {
+        if (target.getAddress() == null || player == target) return;
+        player.sendMessage(Component.translatable("commands.ipsame.target-ip").arguments(plugin.getPrefix(), target.displayName(), Component.text(target.getAddress().getHostString())));
+        for (Player onlinePlayer : Bukkit.getOnlinePlayers()) {
+            if (onlinePlayer == target) {
+                continue;
+            }
+            if (onlinePlayer.getAddress() == null) {
+                continue;
+            }
+            if (!onlinePlayer.getAddress().getHostString().equals(target.getAddress().getHostString())) {
+                continue;
+            }
+            player.sendMessage(Component.translatable("commands.ipsame.show").arguments(plugin.getPrefix(), target.displayName(), onlinePlayer.displayName()));
+        }
+    }
+
+}

src/main/java/net/onelitefeather/stardust/service/PaperCommandService.java

@@ -60,6 +60,7 @@ public void registerCommands() {
         annotationParser.parse(new GodmodeCommand(plugin));
         annotationParser.parse(new HealCommand(plugin));
         annotationParser.parse(new RenameCommand(plugin));
+        annotationParser.parse(new IPSameCommand(plugin));
         annotationParser.parse(new RepairCommand(plugin));
         annotationParser.parse(new SignCommand(plugin));
         annotationParser.parse(new SkullCommand(plugin));

src/main/resources/stardust_en_US.properties

@@ -33,6 +33,8 @@ commands.repair.success={0} <gray>The item in your <yellow>hand</yellow> has bee
 commands.repair.all.success={0} <hover:show_text:"<gold>Repaired:</gold> <red>{1}</red>"><gray>All items in your <yellow>inventory</yellow> have been repaired.</gray></hover>
 commands.repair.invalid-item={0}<gray>This <yellow>item</yellow> can <red>not</red> be repaired.</gray>
 commands.repair.repaired-items.separator=<gold>,</gold> <red></red>
+commands.ipsame.show={0} Player <gold>{1}</gold> has the same IP as following player: <gold>{2}</gold>
+commands.ipsame.target-ip={0} <gray>Player <gold>{1}</gold> following IP: <click:COPY_TO_CLIPBOARD:'{2}'><gold>{2}</gold>
 commands.sign.signed={0} <gray>Item has been <green>successfully</green> signed.</gray>
 commands.sign.already-signed={0} <gray>This <yellow>item</yellow> had already been signed.</gray>
 commands.sign.no-item-in-hand={0} <gray>You do not have an <yellow>item</yellow> held in your hand.</gray>

src/test/java/net/onelitefeather/stardust/command/commands/IPSameCommandTest.java

@@ -0,0 +1,194 @@
+package net.onelitefeather.stardust.command.commands;
+
+import net.kyori.adventure.text.Component;
+import net.onelitefeather.stardust.StardustPlugin;
+import org.bukkit.plugin.PluginDescriptionFile;
+import org.bukkit.plugin.java.JavaPluginLoader;
+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.mockbukkit.mockbukkit.MockBukkit;
+import org.mockbukkit.mockbukkit.ServerMock;
+
+import java.io.File;
+import java.net.InetSocketAddress;
+
+class IPSameCommandTest {
+
+    private ServerMock server;
+
+    private StardustPlugin plugin;
+
+    private IPSameCommand ipSameCommand;
+
+    @SuppressWarnings("removal")
+    public static class MockStardustPlugin extends StardustPlugin {
+
+        public MockStardustPlugin() {
+        }
+
+        public MockStardustPlugin(JavaPluginLoader loader, PluginDescriptionFile description, File dataFolder, File file) {
+            super(loader, description, dataFolder, file);
+        }
+
+        @Override
+        public void onEnable() {
+            // Mock enable logic if needed
+        }
+
+        @Override
+        public void onDisable() {
+
+        }
+
+        @Override
+        public Component getPrefix() {
+            return Component.text("[Stardust]");
+        }
+    }
+
+    @BeforeEach
+    void setUp() {
+        // Initialize MockBukkit
+        server = MockBukkit.mock();
+        plugin = MockBukkit.load(MockStardustPlugin.class);
+
+        // Create the command instance
+        ipSameCommand = new IPSameCommand(plugin);
+    }
+
+    @AfterEach
+    void tearDown() {
+        // Unmock MockBukkit
+        MockBukkit.unmock();
+    }
+
+    @Test
+    void testIsPlayerIPSame_WithMatchingIP() {
+
+        // Create test players
+        var sender = server.addPlayer("CommandSender");
+        var targetPlayer = server.addPlayer("TargetPlayer");
+        var playerWithSameIP = server.addPlayer("PlayerWithSameIP");
+        var playerWithDifferentIP = server.addPlayer("PlayerWithDifferentIP");
+
+        // Set up IP addresses
+        InetSocketAddress targetAddress = new InetSocketAddress("192.168.1.1", 12345);
+        InetSocketAddress sameAddress = new InetSocketAddress("192.168.1.1", 54321);
+        InetSocketAddress differentAddress = new InetSocketAddress("192.168.1.2", 12345);
+
+        // Use reflection to set the addresses since MockBukkit doesn't provide a direct way
+        targetPlayer.setAddress(targetAddress);
+        playerWithSameIP.setAddress(sameAddress);
+        playerWithDifferentIP.setAddress(differentAddress);
+        // Act
+        ipSameCommand.isPlayerIPSame(sender, targetPlayer);
+
+        // Assert
+        // Verify that sender received the target IP message
+        Assertions.assertEquals(sender.nextComponentMessage(), Component.translatable("commands.ipsame.target-ip")
+                .arguments(plugin.getPrefix(), targetPlayer.displayName(), Component.text("192.168.1.1")));
+
+        // Verify that sender received a message about playerWithSameIP having the same IP
+        Assertions.assertEquals(sender.nextComponentMessage(), Component.translatable("commands.ipsame.show")
+                .arguments(plugin.getPrefix(), targetPlayer.displayName(), playerWithSameIP.displayName()));
+
+        // Verify that sender did not receive a message about playerWithDifferentIP
+        Assertions.assertNotEquals(sender.nextComponentMessage(), Component.translatable("commands.ipsame.show")
+                .arguments(plugin.getPrefix(), targetPlayer.displayName(), playerWithDifferentIP.displayName()));
+    }
+
+    @Test
+    void testIsPlayerIPSame_NoMatchingIP() {
+        // Create test players
+        var sender = server.addPlayer("CommandSender");
+        var targetPlayer = server.addPlayer("TargetPlayer");
+        var playerWithDifferentIP = server.addPlayer("PlayerWithDifferentIP");
+
+        // Set up IP addresses
+        InetSocketAddress targetAddress = new InetSocketAddress("192.168.1.1", 12345);
+        InetSocketAddress differentAddress = new InetSocketAddress("192.168.1.2", 12345);
+
+        // Use reflection to set the addresses since MockBukkit doesn't provide a direct way
+        targetPlayer.setAddress(targetAddress);
+        playerWithDifferentIP.setAddress(differentAddress);
+        // Act
+        ipSameCommand.isPlayerIPSame(sender, targetPlayer);
+
+        // Assert
+        // Verify that sender received the target IP message
+        Assertions.assertEquals(sender.nextComponentMessage(), Component.translatable("commands.ipsame.target-ip")
+                .arguments(plugin.getPrefix(), targetPlayer.displayName(), Component.text("192.168.1.1")));
+
+        // Verify that sender did not receive any message about other players having the same IP
+        Assertions.assertNull(sender.nextComponentMessage());
+
+    }
+
+    @Test
+    void testIsPlayerIPSame_TargetIsCommandSender() {
+        // Create test players
+        var sender = server.addPlayer("CommandSender");
+        // Act
+        ipSameCommand.isPlayerIPSame(sender, sender);
+
+        // Assert
+        // Verify that no messages were sent
+        Assertions.assertNull(sender.nextComponentMessage(), "Expected no messages to be sent when target is the command sender");
+    }
+
+    @Test
+    void testIsPlayerIPSame_NullAddress() {
+        // Create test players
+        var sender = server.addPlayer("CommandSender");
+        var targetPlayer = server.addPlayer("TargetPlayer");
+
+        // Set up IP addresses
+        InetSocketAddress targetAddress = new InetSocketAddress("192.168.1.1", 12345);
+
+        // Use reflection to set the addresses since MockBukkit doesn't provide a direct way
+        targetPlayer.setAddress(targetAddress);
+        // Arrange
+        // Set target player's address to null
+        targetPlayer.setAddress(null);
+
+        // Act
+        ipSameCommand.isPlayerIPSame(sender, targetPlayer);
+
+        // Assert
+        // Verify that no messages were sent
+        Assertions.assertNull(sender.nextComponentMessage(), "Expected no messages to be sent when target player's address is null");
+    }
+
+    @Test
+    void testIsPlayerIPSame_OtherPlayerNullAddress() {
+
+        // Create test players
+        var sender = server.addPlayer("CommandSender");
+        var targetPlayer = server.addPlayer("TargetPlayer");
+        var playerWithSameIP = server.addPlayer("PlayerWithSameIP");
+        var playerWithDifferentIP = server.addPlayer("PlayerWithDifferentIP");
+
+        // Set up IP addresses
+        InetSocketAddress targetAddress = new InetSocketAddress("192.168.1.1", 12345);
+        InetSocketAddress differentAddress = new InetSocketAddress("192.168.1.2", 12345);
+
+        // Use reflection to set the addresses since MockBukkit doesn't provide a direct way
+        targetPlayer.setAddress(targetAddress);
+        playerWithSameIP.setAddress(null);
+        playerWithDifferentIP.setAddress(differentAddress);
+
+        // Act
+        ipSameCommand.isPlayerIPSame(sender, targetPlayer);
+
+        // Assert
+        // Verify that sender received the target IP message
+        Assertions.assertEquals(sender.nextComponentMessage(), Component.translatable("commands.ipsame.target-ip")
+                .arguments(plugin.getPrefix(), targetPlayer.displayName(), Component.text("192.168.1.1")));
+
+        // Verify that no message was sent about playerWithSameIP (which has a null address)
+        Assertions.assertNotEquals(sender.nextComponentMessage(), Component.translatable("commands.ipsame.show")
+                .arguments(plugin.getPrefix(), targetPlayer.displayName(), playerWithSameIP.displayName()));
+    }
+}