[Tests] Improve branch coverage for CorePlayer, BaseGui, and GuiManager

src/test/java/com/diamonddagger590/mccore/gui/BaseGuiTest.java

@@ -61,6 +61,7 @@ public boolean useMutex() {
     private static class TestGui extends BaseGui<TestCorePlayer> {
 
         private final Inventory mockInventory;
+        private boolean bottomClickAllowed = false;
 
         public TestGui(@NotNull TestCorePlayer creatingPlayer, @NotNull Inventory mockInventory) {
             super(creatingPlayer);
@@ -83,6 +84,15 @@ public void registerListeners() {
         @Override
         public void unregisterListeners() {
         }
+
+        @Override
+        public boolean allowBottomInventoryClick() {
+            return bottomClickAllowed;
+        }
+
+        public void setBottomClickAllowed(boolean allowed) {
+            this.bottomClickAllowed = allowed;
+        }
     }
 
     private static class RestrictedSlot implements Slot<TestCorePlayer> {
@@ -513,6 +523,62 @@ void handleClickEvent_doesNotCancel_whenCanProcessEventReturnsFalse() {
             verify(event, never()).setCancelled(false);
         }
 
+        @SuppressWarnings("unchecked")
+        @Test
+        @DisplayName("Given bottom inventory clicked and bottom click allowed, when handleClickEvent, then does not cancel event")
+        void handleClickEvent_doesNotCancel_whenBottomInventoryClickedAndAllowed() {
+            gui.getInventory();
+            gui.setBottomClickAllowed(true);
+            Player mockBukkitPlayer = mock(Player.class);
+            when(mockBukkitPlayer.getUniqueId()).thenReturn(player.getUUID());
+            when(mockGuiManager.getOpenedGui(mockBukkitPlayer)).thenReturn(Optional.of(gui));
+            when(mockPlayerManager.getPlayer(player.getUUID())).thenReturn(Optional.of(player));
+
+            InventoryClickEvent event = mock(InventoryClickEvent.class);
+            when(event.getSlot()).thenReturn(0);
+            when(event.getWhoClicked()).thenReturn(mockBukkitPlayer);
+
+            InventoryView mockView = mock(InventoryView.class);
+            when(event.getView()).thenReturn(mockView);
+            when(mockView.getTopInventory()).thenReturn(mockInventory);
+
+            Inventory bottomInventory = mock(Inventory.class);
+            when(mockView.getBottomInventory()).thenReturn(bottomInventory);
+            when(event.getClickedInventory()).thenReturn(bottomInventory);
+
+            gui.handleClickEvent(event);
+
+            verify(event, never()).setCancelled(true);
+            verify(event, never()).setCancelled(false);
+            verify(event, never()).getClick();
+        }
+
+        @SuppressWarnings("unchecked")
+        @Test
+        @DisplayName("Given top inventory clicked but CorePlayer not found, when handleClickEvent, then does not call setCancelled")
+        void handleClickEvent_doesNotCallSetCancelled_whenCorePlayerNotFound() {
+            gui.getInventory();
+            Player mockBukkitPlayer = mock(Player.class);
+            when(mockBukkitPlayer.getUniqueId()).thenReturn(player.getUUID());
+            when(mockGuiManager.getOpenedGui(mockBukkitPlayer)).thenReturn(Optional.of(gui));
+            when(mockPlayerManager.getPlayer(player.getUUID())).thenReturn(Optional.empty());
+
+            InventoryClickEvent event = mock(InventoryClickEvent.class);
+            when(event.getSlot()).thenReturn(0);
+            when(event.getWhoClicked()).thenReturn(mockBukkitPlayer);
+
+            InventoryView mockView = mock(InventoryView.class);
+            when(event.getView()).thenReturn(mockView);
+            when(mockView.getTopInventory()).thenReturn(mockInventory);
+            when(mockView.getBottomInventory()).thenReturn(mock(Inventory.class));
+            when(event.getClickedInventory()).thenReturn(mockInventory);
+
+            gui.handleClickEvent(event);
+
+            verify(event, never()).setCancelled(true);
+            verify(event, never()).setCancelled(false);
+        }
+
         @SuppressWarnings("unchecked")
         @Test
         @DisplayName("Given top inventory clicked with valid player, when handleClickEvent, then delegates to slot onClick")

src/test/java/com/diamonddagger590/mccore/gui/GuiManagerTest.java

@@ -1,15 +1,18 @@
 package com.diamonddagger590.mccore.gui;
 
 import com.diamonddagger590.mccore.CorePlugin;
+import com.diamonddagger590.mccore.event.gui.CoreGuiOpenEvent;
 import com.diamonddagger590.mccore.player.CorePlayer;
 import org.bukkit.Bukkit;
+import org.bukkit.NamespacedKey;
 import org.bukkit.Server;
 import org.bukkit.entity.Player;
 import org.bukkit.plugin.PluginManager;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
 
 import java.lang.reflect.Field;
 import java.util.Optional;
@@ -321,13 +324,61 @@ void refreshGui_doesNotThrow_whenPlayerIsOffline() {
     }
 
     @Test
-    @DisplayName("Given a keyed gui, when trackPlayerGui, then fires CoreGuiOpenEvent")
-    void trackPlayerGui_firesEvent_always() {
+    @DisplayName("Given a non-keyed gui, when trackPlayerGui, then fires CoreGuiOpenEvent with empty guiKey")
+    void trackPlayerGui_firesEventWithNullKey_whenGuiIsNotKeyed() {
         UUID playerUUID = UUID.randomUUID();
         Gui<CorePlayer> gui = createMockGui();
 
         guiManager.trackPlayerGui(playerUUID, gui);
 
-        verify(mockPluginManager).callEvent(any());
+        ArgumentCaptor<CoreGuiOpenEvent> captor = ArgumentCaptor.forClass(CoreGuiOpenEvent.class);
+        verify(mockPluginManager).callEvent(captor.capture());
+        CoreGuiOpenEvent event = captor.getValue();
+        assertEquals(playerUUID, event.getPlayerUUID());
+        assertEquals(gui, event.getGui());
+        assertFalse(event.getGuiKey().isPresent());
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    @DisplayName("Given a KeyedGui with a NamespacedKey, when trackPlayerGui, then fires CoreGuiOpenEvent with that key")
+    void trackPlayerGui_firesEventWithKey_whenGuiIsKeyed() {
+        UUID playerUUID = UUID.randomUUID();
+        NamespacedKey expectedKey = new NamespacedKey("test", "my_gui");
+
+        Gui<CorePlayer> keyedGui = mock(KeyedGuiImpl.class);
+        when(keyedGui.getUUID()).thenReturn(UUID.randomUUID());
+        when(((KeyedGui) keyedGui).getGuiKey()).thenReturn(Optional.of(expectedKey));
+
+        guiManager.trackPlayerGui(playerUUID, keyedGui);
+
+        ArgumentCaptor<CoreGuiOpenEvent> captor = ArgumentCaptor.forClass(CoreGuiOpenEvent.class);
+        verify(mockPluginManager).callEvent(captor.capture());
+        CoreGuiOpenEvent event = captor.getValue();
+        assertEquals(playerUUID, event.getPlayerUUID());
+        assertEquals(keyedGui, event.getGui());
+        assertTrue(event.getGuiKey().isPresent());
+        assertEquals(expectedKey, event.getGuiKey().get());
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    @DisplayName("Given a KeyedGui returning empty key, when trackPlayerGui, then fires CoreGuiOpenEvent with empty guiKey")
+    void trackPlayerGui_firesEventWithEmptyKey_whenKeyedGuiReturnsEmpty() {
+        UUID playerUUID = UUID.randomUUID();
+
+        Gui<CorePlayer> keyedGui = mock(KeyedGuiImpl.class);
+        when(keyedGui.getUUID()).thenReturn(UUID.randomUUID());
+        when(((KeyedGui) keyedGui).getGuiKey()).thenReturn(Optional.empty());
+
+        guiManager.trackPlayerGui(playerUUID, keyedGui);
+
+        ArgumentCaptor<CoreGuiOpenEvent> captor = ArgumentCaptor.forClass(CoreGuiOpenEvent.class);
+        verify(mockPluginManager).callEvent(captor.capture());
+        CoreGuiOpenEvent event = captor.getValue();
+        assertFalse(event.getGuiKey().isPresent());
+    }
+
+    private interface KeyedGuiImpl extends Gui<CorePlayer>, KeyedGui {
     }
 }

src/test/java/com/diamonddagger590/mccore/player/CorePlayerTest.java

@@ -1,24 +1,44 @@
 package com.diamonddagger590.mccore.player;
 
 import com.diamonddagger590.mccore.CorePlugin;
+import com.diamonddagger590.mccore.event.setting.setting.PlayerSettingChangeEvent;
 import com.diamonddagger590.mccore.external.common.AfkPluginHook;
 import com.diamonddagger590.mccore.registry.RegistryAccess;
 import com.diamonddagger590.mccore.registry.RegistryKey;
 import com.diamonddagger590.mccore.registry.plugin.PluginHook;
+import com.diamonddagger590.mccore.setting.PlayerSetting;
 import com.diamonddagger590.mccore.testing.RegistryResetExtension;
+import com.diamonddagger590.mccore.util.LinkedNode;
+import org.bukkit.Bukkit;
+import org.bukkit.NamespacedKey;
+import org.bukkit.Server;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.PluginManager;
+import org.jetbrains.annotations.NotNull;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
 
+import java.lang.reflect.Field;
+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.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNotEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
 class CorePlayerTest {
 
@@ -206,4 +226,156 @@ void toString_matchesExpectedFormat() {
         String expected = "CorePlayer - [uuid=" + testUUID + "]";
         assertEquals(expected, player.toString());
     }
+
+    // --- setPlayerSetting, getPlayerSettings, getAsBukkitPlayer ---
+
+    @Nested
+    @DisplayName("Bukkit-dependent methods")
+    class BukkitDependentMethods {
+
+        private PluginManager mockPluginManager;
+
+        @BeforeEach
+        void setUpBukkitServer() throws Exception {
+            Server mockServer = mock(Server.class);
+            mockPluginManager = mock(PluginManager.class);
+            when(mockServer.getPluginManager()).thenReturn(mockPluginManager);
+            when(mockServer.getLogger()).thenReturn(Logger.getLogger("TestServer"));
+            when(mockServer.isPrimaryThread()).thenReturn(true);
+            when(mockServer.getPlayer(testUUID)).thenReturn(null);
+            doNothing().when(mockPluginManager).callEvent(any());
+
+            Field serverField = Bukkit.class.getDeclaredField("server");
+            serverField.setAccessible(true);
+            serverField.set(null, mockServer);
+        }
+
+        @AfterEach
+        void tearDownBukkitServer() throws Exception {
+            Field serverField = Bukkit.class.getDeclaredField("server");
+            serverField.setAccessible(true);
+            serverField.set(null, null);
+        }
+
+        @Test
+        @DisplayName("Given a PlayerSetting, when setPlayerSetting, then getPlayerSetting returns the setting")
+        void setPlayerSetting_storesSetting_whenCalled() {
+            NamespacedKey settingKey = new NamespacedKey("test", "my_setting");
+            PlayerSetting setting = createTestSetting(settingKey, "VALUE_A");
+
+            player.setPlayerSetting(setting);
+
+            Optional<? extends PlayerSetting> result = player.getPlayerSetting(settingKey);
+            assertTrue(result.isPresent());
+            assertEquals(setting, result.get());
+        }
+
+        @Test
+        @DisplayName("Given a PlayerSetting, when setPlayerSetting, then fires PlayerSettingChangeEvent with null old setting and correct player")
+        void setPlayerSetting_firesEventWithNullOldSetting_whenNoExistingSetting() {
+            NamespacedKey settingKey = new NamespacedKey("test", "my_setting");
+            PlayerSetting setting = createTestSetting(settingKey, "VALUE_A");
+
+            player.setPlayerSetting(setting);
+
+            ArgumentCaptor<PlayerSettingChangeEvent> captor = ArgumentCaptor.forClass(PlayerSettingChangeEvent.class);
+            verify(mockPluginManager).callEvent(captor.capture());
+            PlayerSettingChangeEvent event = captor.getValue();
+            assertFalse(event.getOldSetting().isPresent());
+            assertEquals(setting, event.getNewSetting());
+            assertEquals(player, event.getCorePlayer());
+        }
+
+        @Test
+        @DisplayName("Given an existing PlayerSetting, when setPlayerSetting with same key, then fires event with old setting and correct player")
+        void setPlayerSetting_firesEventWithOldSetting_whenReplacingExistingSetting() {
+            NamespacedKey settingKey = new NamespacedKey("test", "my_setting");
+            PlayerSetting oldSetting = createTestSetting(settingKey, "VALUE_A");
+            PlayerSetting newSetting = createTestSetting(settingKey, "VALUE_B");
+
+            player.setPlayerSetting(oldSetting);
+            player.setPlayerSetting(newSetting);
+
+            ArgumentCaptor<PlayerSettingChangeEvent> captor = ArgumentCaptor.forClass(PlayerSettingChangeEvent.class);
+            verify(mockPluginManager, times(2)).callEvent(captor.capture());
+            PlayerSettingChangeEvent secondEvent = captor.getAllValues().get(1);
+            assertTrue(secondEvent.getOldSetting().isPresent());
+            assertEquals(oldSetting, secondEvent.getOldSetting().get());
+            assertEquals(newSetting, secondEvent.getNewSetting());
+            assertEquals(player, secondEvent.getCorePlayer());
+        }
+
+        @Test
+        @DisplayName("Given multiple PlayerSettings set, when getPlayerSettings, then returns all settings")
+        void getPlayerSettings_returnsAllSettings_whenMultipleSettingsSet() {
+            NamespacedKey key1 = new NamespacedKey("test", "setting_one");
+            NamespacedKey key2 = new NamespacedKey("test", "setting_two");
+            PlayerSetting setting1 = createTestSetting(key1, "VALUE_1");
+            PlayerSetting setting2 = createTestSetting(key2, "VALUE_2");
+
+            player.setPlayerSetting(setting1);
+            player.setPlayerSetting(setting2);
+
+            assertEquals(2, player.getPlayerSettings().size());
+            assertTrue(player.getPlayerSettings().contains(setting1));
+            assertTrue(player.getPlayerSettings().contains(setting2));
+        }
+
+        @Test
+        @DisplayName("Given player is online, when getAsBukkitPlayer, then returns present Optional with the Player")
+        void getAsBukkitPlayer_returnsPlayer_whenOnline() throws Exception {
+            Player mockBukkitPlayer = mock(Player.class);
+            Server server = Bukkit.getServer();
+            when(server.getPlayer(testUUID)).thenReturn(mockBukkitPlayer);
+
+            Optional<Player> result = player.getAsBukkitPlayer();
+            assertTrue(result.isPresent());
+            assertEquals(mockBukkitPlayer, result.get());
+        }
+
+        @Test
+        @DisplayName("Given player is offline, when getAsBukkitPlayer, then returns empty Optional")
+        void getAsBukkitPlayer_returnsEmpty_whenOffline() {
+            Optional<Player> result = player.getAsBukkitPlayer();
+            assertFalse(result.isPresent());
+        }
+    }
+
+    private static PlayerSetting createTestSetting(NamespacedKey key, String name) {
+        return new PlayerSetting() {
+            @Override
+            @NotNull
+            public NamespacedKey getSettingKey() {
+                return key;
+            }
+
+            @Override
+            @NotNull
+            public LinkedNode<? extends PlayerSetting> getFirstSetting() {
+                return new LinkedNode<>(this);
+            }
+
+            @Override
+            @NotNull
+            public LinkedNode<? extends PlayerSetting> getNextSetting() {
+                return new LinkedNode<>(this);
+            }
+
+            @Override
+            public void onSettingChange(@NotNull CorePlayer player, @NotNull Optional<PlayerSetting> oldSetting) {
+            }
+
+            @Override
+            @NotNull
+            public Optional<? extends PlayerSetting> fromString(@NotNull String setting) {
+                return Optional.empty();
+            }
+
+            @Override
+            @NotNull
+            public String name() {
+                return name;
+            }
+        };
+    }
 }