Initial commit: LoChat v1.0.0 with Gradient module

src/test/java/com/loki/lochat/gradient/data/GradientPlayerDataTest.java

@@ -0,0 +1,110 @@
+package com.loki.lochat.gradient.data;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class GradientPlayerDataTest {
+
+    private GradientPlayerData data;
+    private UUID testUuid;
+
+    @BeforeEach
+    void setUp() {
+        testUuid = UUID.randomUUID();
+        data = new GradientPlayerData(testUuid);
+    }
+
+    @Test
+    void constructor_defaultValues() {
+        assertEquals(testUuid, data.getUuid());
+        assertNull(data.getPrefix());
+        assertNotNull(data.getColors());
+        assertTrue(data.getColors().isEmpty());
+        assertTrue(data.isColorEnabled());
+        assertTrue(data.isPrefixEnabled());
+        assertFalse(data.isPrefixPurchased());
+        assertEquals(0, data.getLastColorChange());
+        assertEquals(0, data.getLastPrefixChange());
+    }
+
+    @Test
+    void hasPrefix_false() {
+        assertFalse(data.hasPrefix());
+        data.setPrefix("");
+        assertFalse(data.hasPrefix());
+    }
+
+    @Test
+    void hasPrefix_true() {
+        data.setPrefix("VIP");
+        assertTrue(data.hasPrefix());
+    }
+
+    @Test
+    void hasColors_false() {
+        assertFalse(data.hasColors());
+    }
+
+    @Test
+    void hasColors_true() {
+        data.setColors(List.of("#FF0000", "#00FF00"));
+        assertTrue(data.hasColors());
+    }
+
+    @Test
+    void setColors_null() {
+        data.setColors(null);
+        assertNotNull(data.getColors());
+        assertTrue(data.getColors().isEmpty());
+    }
+
+    @Test
+    void setColors_copiesList() {
+        List<String> original = List.of("#FF0000");
+        data.setColors(original);
+        assertEquals(1, data.getColors().size());
+        assertEquals("#FF0000", data.getColors().get(0));
+    }
+
+    @Test
+    void colorEnabled_toggle() {
+        assertTrue(data.isColorEnabled());
+        data.setColorEnabled(false);
+        assertFalse(data.isColorEnabled());
+        data.setColorEnabled(true);
+        assertTrue(data.isColorEnabled());
+    }
+
+    @Test
+    void prefixEnabled_toggle() {
+        assertTrue(data.isPrefixEnabled());
+        data.setPrefixEnabled(false);
+        assertFalse(data.isPrefixEnabled());
+    }
+
+    @Test
+    void prefixPurchased() {
+        assertFalse(data.isPrefixPurchased());
+        data.setPrefixPurchased(true);
+        assertTrue(data.isPrefixPurchased());
+    }
+
+    @Test
+    void lastColorChange() {
+        long time = System.currentTimeMillis();
+        data.setLastColorChange(time);
+        assertEquals(time, data.getLastColorChange());
+    }
+
+    @Test
+    void lastPrefixChange() {
+        long time = System.currentTimeMillis();
+        data.setLastPrefixChange(time);
+        assertEquals(time, data.getLastPrefixChange());
+    }
+}

src/test/java/com/loki/lochat/gradient/util/GradientConstantsTest.java

@@ -0,0 +1,25 @@
+package com.loki.lochat.gradient.util;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class GradientConstantsTest {
+
+    @Test
+    void millisPerSecond() {
+        assertEquals(1000L, GradientConstants.MILLIS_PER_SECOND);
+    }
+
+    @Test
+    void guiSlots() {
+        assertEquals(11, GradientConstants.GUI_CONFIRM_SLOT);
+        assertEquals(15, GradientConstants.GUI_CANCEL_SLOT);
+        assertEquals(13, GradientConstants.GUI_PREVIEW_SLOT);
+    }
+
+    @Test
+    void luckPermsPriority() {
+        assertEquals(100, GradientConstants.LUCKPERMS_PREFIX_PRIORITY);
+    }
+}

src/test/java/com/loki/lochat/gradient/util/GradientUtilTest.java

@@ -0,0 +1,134 @@
+package com.loki.lochat.gradient.util;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class GradientUtilTest {
+
+    @Test
+    void isValidHex_valid() {
+        assertTrue(GradientUtil.isValidHex("#FF0000"));
+        assertTrue(GradientUtil.isValidHex("#00ff00"));
+        assertTrue(GradientUtil.isValidHex("#3BA8FF"));
+        assertTrue(GradientUtil.isValidHex("#000000"));
+        assertTrue(GradientUtil.isValidHex("#FFFFFF"));
+    }
+
+    @Test
+    void isValidHex_invalid() {
+        assertFalse(GradientUtil.isValidHex("FF0000"));      // без #
+        assertFalse(GradientUtil.isValidHex("#FF00"));       // короткий
+        assertFalse(GradientUtil.isValidHex("#FF00000"));    // длинный
+        assertFalse(GradientUtil.isValidHex("#GGGGGG"));     // невалидные символы
+        assertFalse(GradientUtil.isValidHex(""));
+    }
+
+    @Test
+    void isValidHex_null() {
+        assertThrows(NullPointerException.class, () -> GradientUtil.isValidHex(null));
+    }
+
+    @Test
+    void applyGradient_singleColor_legacy() {
+        String result = GradientUtil.applyGradient("Hi", List.of("#FF0000"), true);
+        assertNotNull(result);
+        assertTrue(result.contains("&#ff0000"));
+        assertEquals("&#ff0000H&#ff0000i", result);
+    }
+
+    @Test
+    void applyGradient_singleColor_minimessage() {
+        String result = GradientUtil.applyGradient("Hi", List.of("#FF0000"), false);
+        assertNotNull(result);
+        assertTrue(result.contains("<#ff0000>"));
+    }
+
+    @Test
+    void applyGradient_twoColors() {
+        String result = GradientUtil.applyGradient("AB", List.of("#FF0000", "#0000FF"), true);
+        assertNotNull(result);
+        // Первый символ должен быть красным, последний синим
+        assertTrue(result.startsWith("&#ff0000A"));
+        assertTrue(result.contains("&#0000ffB"));
+    }
+
+    @Test
+    void applyGradient_emptyText() {
+        String result = GradientUtil.applyGradient("", List.of("#FF0000"), true);
+        assertEquals("", result);
+    }
+
+    @Test
+    void applyGradient_nullText() {
+        String result = GradientUtil.applyGradient(null, List.of("#FF0000"), true);
+        assertNull(result);
+    }
+
+    @Test
+    void applyGradient_emptyColors() {
+        String result = GradientUtil.applyGradient("Test", List.of(), true);
+        assertEquals("Test", result);
+    }
+
+    @Test
+    void applyGradient_nullColors() {
+        String result = GradientUtil.applyGradient("Test", null, true);
+        assertEquals("Test", result);
+    }
+
+    @Test
+    void applyGradient_multipleColors() {
+        String result = GradientUtil.applyGradient("ABC", List.of("#FF0000", "#00FF00", "#0000FF"), true);
+        assertNotNull(result);
+        // Должен содержать цветовые коды для каждого символа
+        assertTrue(result.contains("A"));
+        assertTrue(result.contains("B"));
+        assertTrue(result.contains("C"));
+    }
+
+    @Test
+    void buildDisplayName_noPrefix_noColors() {
+        String result = GradientUtil.buildDisplayName(null, "Player", null, true, true, "[{prefix}] ", true);
+        assertEquals("Player", result);
+    }
+
+    @Test
+    void buildDisplayName_withPrefix_noColors() {
+        String result = GradientUtil.buildDisplayName("VIP", "Player", null, true, true, "[{prefix}] ", true);
+        assertEquals("[VIP] Player", result);
+    }
+
+    @Test
+    void buildDisplayName_noPrefix_withColors() {
+        String result = GradientUtil.buildDisplayName(null, "AB", List.of("#FF0000", "#0000FF"), true, true, "[{prefix}] ", true);
+        assertNotNull(result);
+        assertTrue(result.contains("&#"));
+    }
+
+    @Test
+    void buildDisplayName_withPrefix_withColors_continuous() {
+        String result = GradientUtil.buildDisplayName("V", "AB", List.of("#FF0000", "#0000FF"), true, true, "[{prefix}] ", true);
+        assertNotNull(result);
+        // Единый градиент на всё
+        assertTrue(result.contains("&#"));
+    }
+
+    @Test
+    void buildDisplayName_withPrefix_withColors_separate() {
+        String result = GradientUtil.buildDisplayName("V", "AB", List.of("#FF0000", "#0000FF"), true, false, "[{prefix}] ", true);
+        assertNotNull(result);
+        // Отдельные градиенты
+        assertTrue(result.contains("&#"));
+    }
+
+    @Test
+    void buildDisplayName_gradientOnlyOnNick() {
+        String result = GradientUtil.buildDisplayName("VIP", "AB", List.of("#FF0000", "#0000FF"), false, false, "[{prefix}] ", true);
+        assertNotNull(result);
+        // Префикс без градиента
+        assertTrue(result.startsWith("[VIP] "));
+    }
+}

src/test/java/com/loki/lochat/managers/CooldownManagerTest.java

@@ -0,0 +1,50 @@
+package com.loki.lochat.managers;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class CooldownManagerTest {
+
+    private CooldownManager cooldownManager;
+    private UUID testPlayer;
+
+    @BeforeEach
+    void setUp() {
+        cooldownManager = new CooldownManager();
+        testPlayer = UUID.randomUUID();
+    }
+
+    @Test
+    void isOnCooldown_noCooldown() {
+        assertFalse(cooldownManager.isOnCooldown(testPlayer, "global", 5));
+    }
+
+    @Test
+    void isOnCooldown_afterSet() {
+        cooldownManager.setCooldown(testPlayer, "global");
+        assertTrue(cooldownManager.isOnCooldown(testPlayer, "global", 5));
+    }
+
+    @Test
+    void getRemainingCooldown_noCooldown() {
+        assertEquals(0, cooldownManager.getRemainingCooldown(testPlayer, "global", 5));
+    }
+
+    @Test
+    void removeCooldown() {
+        cooldownManager.setCooldown(testPlayer, "global");
+        cooldownManager.removeCooldown(testPlayer);
+        assertFalse(cooldownManager.isOnCooldown(testPlayer, "global", 5));
+    }
+
+    @Test
+    void separateCooldowns() {
+        cooldownManager.setCooldown(testPlayer, "global");
+        assertTrue(cooldownManager.isOnCooldown(testPlayer, "global", 5));
+        assertFalse(cooldownManager.isOnCooldown(testPlayer, "local", 5));
+    }
+}

src/test/java/com/loki/lochat/managers/MuteManagerTest.java

@@ -0,0 +1,39 @@
+package com.loki.lochat.managers;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+class MuteManagerTest {
+
+    @Test
+    void parseTime_seconds() {
+        assertEquals(30, MuteManager.parseTime("30s"));
+    }
+
+    @Test
+    void parseTime_minutes() {
+        assertEquals(300, MuteManager.parseTime("5m"));
+    }
+
+    @Test
+    void parseTime_hours() {
+        assertEquals(3600, MuteManager.parseTime("1h"));
+    }
+
+    @Test
+    void parseTime_days() {
+        assertEquals(86400, MuteManager.parseTime("1d"));
+    }
+
+    @Test
+    void parseTime_invalid() {
+        assertEquals(-1, MuteManager.parseTime("abc"));
+        assertEquals(-1, MuteManager.parseTime(""));
+        assertEquals(-1, MuteManager.parseTime(null));
+    }
+
+    @Test
+    void parseTime_numberOnly() {
+        assertEquals(60, MuteManager.parseTime("60"));
+    }
+}

src/test/java/com/loki/lochat/managers/PMManagerTest.java

@@ -0,0 +1,47 @@
+package com.loki.lochat.managers;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class PMManagerTest {
+
+    private PMManager pmManager;
+    private UUID player1;
+    private UUID player2;
+
+    @BeforeEach
+    void setUp() {
+        pmManager = new PMManager();
+        player1 = UUID.randomUUID();
+        player2 = UUID.randomUUID();
+    }
+
+    @Test
+    void setAndGetLastConversation() {
+        pmManager.setLastConversation(player1, player2);
+        assertEquals(player2, pmManager.getLastConversation(player1));
+    }
+
+    @Test
+    void getLastConversation_noConversation() {
+        assertNull(pmManager.getLastConversation(player1));
+    }
+
+    @Test
+    void hasConversation() {
+        assertFalse(pmManager.hasConversation(player1));
+        pmManager.setLastConversation(player1, player2);
+        assertTrue(pmManager.hasConversation(player1));
+    }
+
+    @Test
+    void removeConversation() {
+        pmManager.setLastConversation(player1, player2);
+        pmManager.removeConversation(player1);
+        assertFalse(pmManager.hasConversation(player1));
+    }
+}