From 3c639788dfe9c31817df19ffe495133821e7a238 Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 23 Sep 2026 09:52:52 +0000 Subject: [PATCH] Add unit tests for DisableTutorialSetting, StateTypeWarningLog, TitleRewardType, SoundRewardType Add 42 new unit tests across 4 previously untested classes: - DisableTutorialSettingTest (14 tests): setting key consistency, LinkedNode cycling, fromString round-trip and case-insensitivity, isDisabled predicate, onSettingChange no-op, expansion key - StateTypeWarningLogTest (5 tests): first-call logging, deduplication on same key, independent logging for different keys, null/non-null cause handling - TitleRewardTypeTest (11 tests): key/expansion key, default serialization, round-trip, missing/null key defaults, Number type coercion, non-numeric fallback, scalability contract - SoundRewardTypeTest (12 tests): key/expansion key, null-sound empty map, round-trip, missing volume/pitch defaults, invalid/missing sound no-op, case-insensitive parsing, Number coercion, non-numeric fallback, scalability contract Co-Authored-By: Claude Opus 4.6 Claude-Session: https://claude.ai/code/session_01PLcgCkNo7G6qmpoz6H16U2 --- .../combat/state/StateTypeWarningLogTest.java | 86 +++++++++ .../reward/builtin/SoundRewardTypeTest.java | 174 ++++++++++++++++++ .../reward/builtin/TitleRewardTypeTest.java | 169 +++++++++++++++++ .../impl/DisableTutorialSettingTest.java | 125 +++++++++++++ 4 files changed, 554 insertions(+) create mode 100644 src/test/java/us/eunoians/mcrpg/combat/state/StateTypeWarningLogTest.java create mode 100644 src/test/java/us/eunoians/mcrpg/quest/reward/builtin/SoundRewardTypeTest.java create mode 100644 src/test/java/us/eunoians/mcrpg/quest/reward/builtin/TitleRewardTypeTest.java create mode 100644 src/test/java/us/eunoians/mcrpg/setting/impl/DisableTutorialSettingTest.java diff --git a/src/test/java/us/eunoians/mcrpg/combat/state/StateTypeWarningLogTest.java b/src/test/java/us/eunoians/mcrpg/combat/state/StateTypeWarningLogTest.java new file mode 100644 index 000000000..f2b6fd6d8 --- /dev/null +++ b/src/test/java/us/eunoians/mcrpg/combat/state/StateTypeWarningLogTest.java @@ -0,0 +1,86 @@ +package us.eunoians.mcrpg.combat.state; + +import org.bukkit.NamespacedKey; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import us.eunoians.mcrpg.McRPGBaseTest; + +import java.util.logging.Level; +import java.util.logging.Logger; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; + +class StateTypeWarningLogTest extends McRPGBaseTest { + + private Logger logger; + private StateTypeWarningLog warningLog; + + @BeforeEach + void setup() { + logger = mock(Logger.class); + warningLog = new StateTypeWarningLog(logger); + } + + @DisplayName("First call to warnOnce logs the warning") + @Test + void warnOnce_firstCall_logsWarning() { + NamespacedKey key = new NamespacedKey(mcRPG, "test_state"); + RuntimeException cause = new RuntimeException("test error"); + + warningLog.warnOnce(key, "Something went wrong", cause); + + verify(logger).log(Level.WARNING, "Something went wrong", cause); + } + + @DisplayName("Second call to warnOnce with the same key does not log") + @Test + void warnOnce_sameKeyTwice_logsOnlyOnce() { + NamespacedKey key = new NamespacedKey(mcRPG, "duplicate_state"); + RuntimeException cause = new RuntimeException("first"); + + warningLog.warnOnce(key, "First warning", cause); + warningLog.warnOnce(key, "Second warning", new RuntimeException("second")); + + verify(logger).log(Level.WARNING, "First warning", cause); + verify(logger, never()).log(eq(Level.WARNING), eq("Second warning"), any(Throwable.class)); + } + + @DisplayName("Calls with different keys each log independently") + @Test + void warnOnce_differentKeys_logBoth() { + NamespacedKey key1 = new NamespacedKey(mcRPG, "state_one"); + NamespacedKey key2 = new NamespacedKey(mcRPG, "state_two"); + + warningLog.warnOnce(key1, "Warning one", null); + warningLog.warnOnce(key2, "Warning two", null); + + verify(logger).log(Level.WARNING, "Warning one", (Throwable) null); + verify(logger).log(Level.WARNING, "Warning two", (Throwable) null); + } + + @DisplayName("Null cause is passed to the logger without NPE") + @Test + void warnOnce_nullCause_logsWithoutError() { + NamespacedKey key = new NamespacedKey(mcRPG, "null_cause_state"); + + warningLog.warnOnce(key, "No cause", null); + + verify(logger).log(Level.WARNING, "No cause", (Throwable) null); + } + + @DisplayName("Non-null cause is passed to the logger") + @Test + void warnOnce_nonNullCause_passedToLogger() { + NamespacedKey key = new NamespacedKey(mcRPG, "cause_state"); + IllegalArgumentException cause = new IllegalArgumentException("bad value"); + + warningLog.warnOnce(key, "Bad resolver", cause); + + verify(logger).log(Level.WARNING, "Bad resolver", cause); + } +} diff --git a/src/test/java/us/eunoians/mcrpg/quest/reward/builtin/SoundRewardTypeTest.java b/src/test/java/us/eunoians/mcrpg/quest/reward/builtin/SoundRewardTypeTest.java new file mode 100644 index 000000000..241e81920 --- /dev/null +++ b/src/test/java/us/eunoians/mcrpg/quest/reward/builtin/SoundRewardTypeTest.java @@ -0,0 +1,174 @@ +package us.eunoians.mcrpg.quest.reward.builtin; + +import org.bukkit.Sound; +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 us.eunoians.mcrpg.McRPGBaseTest; +import us.eunoians.mcrpg.expansion.McRPGExpansion; + +import java.util.HashMap; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class SoundRewardTypeTest extends McRPGBaseTest { + + private SoundRewardType type; + + @BeforeEach + void setup() { + type = new SoundRewardType(); + } + + @DisplayName("getKey returns mcrpg:sound") + @Test + void getKey_returnsExpectedKey() { + assertEquals(SoundRewardType.KEY, type.getKey()); + assertEquals("mcrpg:sound", type.getKey().toString()); + } + + @DisplayName("getExpansionKey returns McRPGExpansion key") + @Test + void getExpansionKey_returnsMcRPGExpansionKey() { + assertTrue(type.getExpansionKey().isPresent()); + assertEquals(McRPGExpansion.EXPANSION_KEY, type.getExpansionKey().get()); + } + + @DisplayName("describeForDisplay returns empty string") + @Test + void describeForDisplay_returnsEmptyString() { + assertEquals("", type.describeForDisplay()); + } + + @Nested + @DisplayName("Default constructor") + class DefaultConstructorTests { + + @DisplayName("serializeConfig returns empty map when sound is null") + @Test + void serializeConfig_defaultInstance_returnsEmptyMap() { + Map config = type.serializeConfig(); + assertTrue(config.isEmpty()); + } + } + + @Nested + @DisplayName("Serialization round-trip") + class SerializationTests { + + @DisplayName("round-trip preserves sound, volume, and pitch") + @Test + void fromSerializedConfig_roundTrip_preservesAllFields() { + Map config = new HashMap<>(); + config.put("sound", "UI_TOAST_CHALLENGE_COMPLETE"); + config.put("volume", 0.8); + config.put("pitch", 1.5); + + SoundRewardType configured = type.fromSerializedConfig(config); + Map serialized = configured.serializeConfig(); + + assertEquals(Sound.valueOf("UI_TOAST_CHALLENGE_COMPLETE").name(), serialized.get("sound")); + assertEquals(0.8f, ((Number) serialized.get("volume")).floatValue(), 0.01f); + assertEquals(1.5f, ((Number) serialized.get("pitch")).floatValue(), 0.01f); + } + + @DisplayName("missing volume and pitch use defaults of 1.0") + @Test + void fromSerializedConfig_missingVolumeAndPitch_usesDefaults() { + Map config = Map.of("sound", "ENTITY_PLAYER_LEVELUP"); + + SoundRewardType configured = type.fromSerializedConfig(config); + Map serialized = configured.serializeConfig(); + + assertEquals(Sound.valueOf("ENTITY_PLAYER_LEVELUP").name(), serialized.get("sound")); + assertEquals(1.0f, ((Number) serialized.get("volume")).floatValue(), 0.01f); + assertEquals(1.0f, ((Number) serialized.get("pitch")).floatValue(), 0.01f); + } + + @DisplayName("missing sound key returns no-op instance with empty map") + @Test + void fromSerializedConfig_missingSound_returnsNoOpInstance() { + SoundRewardType configured = type.fromSerializedConfig(Map.of()); + Map serialized = configured.serializeConfig(); + + assertTrue(serialized.isEmpty()); + } + + @DisplayName("invalid sound name returns no-op instance with empty map") + @Test + void fromSerializedConfig_invalidSound_returnsNoOpInstance() { + Map config = Map.of("sound", "NOT_A_REAL_SOUND"); + + SoundRewardType configured = type.fromSerializedConfig(config); + Map serialized = configured.serializeConfig(); + + assertTrue(serialized.isEmpty()); + } + + @DisplayName("sound name parsing is case-insensitive") + @Test + void fromSerializedConfig_caseInsensitive_parsesCorrectly() { + Map config = Map.of("sound", "entity_player_levelup"); + + SoundRewardType configured = type.fromSerializedConfig(config); + Map serialized = configured.serializeConfig(); + + assertFalse(serialized.isEmpty()); + assertEquals(Sound.valueOf("ENTITY_PLAYER_LEVELUP").name(), serialized.get("sound")); + } + + @DisplayName("Number values in config are parsed as floats") + @Test + void fromSerializedConfig_numberValues_parsedCorrectly() { + Map config = new HashMap<>(); + config.put("sound", "ENTITY_PLAYER_LEVELUP"); + config.put("volume", 2L); + config.put("pitch", (short) 3); + + SoundRewardType configured = type.fromSerializedConfig(config); + Map serialized = configured.serializeConfig(); + + assertEquals(2.0f, ((Number) serialized.get("volume")).floatValue(), 0.01f); + assertEquals(3.0f, ((Number) serialized.get("pitch")).floatValue(), 0.01f); + } + + @DisplayName("non-numeric values fall back to defaults") + @Test + void fromSerializedConfig_nonNumericValues_fallsBackToDefaults() { + Map config = new HashMap<>(); + config.put("sound", "ENTITY_PLAYER_LEVELUP"); + config.put("volume", "not_a_number"); + config.put("pitch", "invalid"); + + SoundRewardType configured = type.fromSerializedConfig(config); + Map serialized = configured.serializeConfig(); + + assertEquals(1.0f, ((Number) serialized.get("volume")).floatValue(), 0.01f); + assertEquals(1.0f, ((Number) serialized.get("pitch")).floatValue(), 0.01f); + } + } + + @Nested + @DisplayName("Scalability") + class ScalabilityTests { + + @DisplayName("getNumericAmount returns empty for sound rewards") + @Test + void getNumericAmount_returnsEmpty() { + assertTrue(type.getNumericAmount().isEmpty()); + } + + @DisplayName("withAmountMultiplier returns same instance") + @Test + void withAmountMultiplier_returnsSelf() { + SoundRewardType configured = type.fromSerializedConfig( + Map.of("sound", "ENTITY_PLAYER_LEVELUP")); + assertSame(configured, configured.withAmountMultiplier(2.0)); + } + } +} diff --git a/src/test/java/us/eunoians/mcrpg/quest/reward/builtin/TitleRewardTypeTest.java b/src/test/java/us/eunoians/mcrpg/quest/reward/builtin/TitleRewardTypeTest.java new file mode 100644 index 000000000..4544cc574 --- /dev/null +++ b/src/test/java/us/eunoians/mcrpg/quest/reward/builtin/TitleRewardTypeTest.java @@ -0,0 +1,169 @@ +package us.eunoians.mcrpg.quest.reward.builtin; + +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 us.eunoians.mcrpg.McRPGBaseTest; +import us.eunoians.mcrpg.expansion.McRPGExpansion; + +import java.util.HashMap; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class TitleRewardTypeTest extends McRPGBaseTest { + + private TitleRewardType type; + + @BeforeEach + void setup() { + type = new TitleRewardType(); + } + + @DisplayName("getKey returns mcrpg:title_message") + @Test + void getKey_returnsExpectedKey() { + assertEquals(TitleRewardType.KEY, type.getKey()); + assertEquals("mcrpg:title_message", type.getKey().toString()); + } + + @DisplayName("getExpansionKey returns McRPGExpansion key") + @Test + void getExpansionKey_returnsMcRPGExpansionKey() { + assertTrue(type.getExpansionKey().isPresent()); + assertEquals(McRPGExpansion.EXPANSION_KEY, type.getExpansionKey().get()); + } + + @DisplayName("describeForDisplay returns empty string") + @Test + void describeForDisplay_returnsEmptyString() { + assertEquals("", type.describeForDisplay()); + } + + @Nested + @DisplayName("Default constructor") + class DefaultConstructorTests { + + @DisplayName("serializeConfig returns empty strings and default tick values") + @Test + void serializeConfig_defaultInstance_returnsDefaults() { + Map config = type.serializeConfig(); + assertEquals("", config.get("title")); + assertEquals("", config.get("subtitle")); + assertEquals(10, config.get("fade-in")); + assertEquals(70, config.get("stay")); + assertEquals(20, config.get("fade-out")); + } + } + + @Nested + @DisplayName("Serialization round-trip") + class SerializationTests { + + @DisplayName("round-trip preserves all fields") + @Test + void fromSerializedConfig_roundTrip_preservesAllFields() { + Map config = new HashMap<>(); + config.put("title", "Quest Complete!"); + config.put("subtitle", "Well done."); + config.put("fade-in", 5); + config.put("stay", 100); + config.put("fade-out", 30); + + TitleRewardType configured = type.fromSerializedConfig(config); + Map serialized = configured.serializeConfig(); + + assertEquals("Quest Complete!", serialized.get("title")); + assertEquals("Well done.", serialized.get("subtitle")); + assertEquals(5, serialized.get("fade-in")); + assertEquals(100, serialized.get("stay")); + assertEquals(30, serialized.get("fade-out")); + } + + @DisplayName("missing keys use empty string and default ticks") + @Test + void fromSerializedConfig_missingKeys_usesDefaults() { + TitleRewardType configured = type.fromSerializedConfig(Map.of()); + Map serialized = configured.serializeConfig(); + + assertEquals("", serialized.get("title")); + assertEquals("", serialized.get("subtitle")); + assertEquals(10, serialized.get("fade-in")); + assertEquals(70, serialized.get("stay")); + assertEquals(20, serialized.get("fade-out")); + } + + @DisplayName("Number values in config are parsed as ints") + @Test + void fromSerializedConfig_numberValues_parsedCorrectly() { + Map config = new HashMap<>(); + config.put("title", "Title"); + config.put("subtitle", "Sub"); + config.put("fade-in", 15L); + config.put("stay", 80.0); + config.put("fade-out", (short) 25); + + TitleRewardType configured = type.fromSerializedConfig(config); + Map serialized = configured.serializeConfig(); + + assertEquals(15, serialized.get("fade-in")); + assertEquals(80, serialized.get("stay")); + assertEquals(25, serialized.get("fade-out")); + } + + @DisplayName("non-numeric values fall back to defaults") + @Test + void fromSerializedConfig_nonNumericValues_fallsBackToDefaults() { + Map config = new HashMap<>(); + config.put("title", "Title"); + config.put("subtitle", "Sub"); + config.put("fade-in", "not_a_number"); + config.put("stay", "invalid"); + config.put("fade-out", "bad"); + + TitleRewardType configured = type.fromSerializedConfig(config); + Map serialized = configured.serializeConfig(); + + assertEquals(10, serialized.get("fade-in")); + assertEquals(70, serialized.get("stay")); + assertEquals(20, serialized.get("fade-out")); + } + + @DisplayName("null values fall back to defaults") + @Test + void fromSerializedConfig_nullValues_fallsBackToDefaults() { + Map config = new HashMap<>(); + config.put("title", "Title"); + config.put("subtitle", "Sub"); + + TitleRewardType configured = type.fromSerializedConfig(config); + Map serialized = configured.serializeConfig(); + + assertEquals(10, serialized.get("fade-in")); + assertEquals(70, serialized.get("stay")); + assertEquals(20, serialized.get("fade-out")); + } + } + + @Nested + @DisplayName("Scalability") + class ScalabilityTests { + + @DisplayName("getNumericAmount returns empty for title rewards") + @Test + void getNumericAmount_returnsEmpty() { + assertTrue(type.getNumericAmount().isEmpty()); + } + + @DisplayName("withAmountMultiplier returns same instance") + @Test + void withAmountMultiplier_returnsSelf() { + TitleRewardType configured = type.fromSerializedConfig( + Map.of("title", "Test", "subtitle", "Sub")); + assertSame(configured, configured.withAmountMultiplier(2.0)); + } + } +} diff --git a/src/test/java/us/eunoians/mcrpg/setting/impl/DisableTutorialSettingTest.java b/src/test/java/us/eunoians/mcrpg/setting/impl/DisableTutorialSettingTest.java new file mode 100644 index 000000000..d00faaab0 --- /dev/null +++ b/src/test/java/us/eunoians/mcrpg/setting/impl/DisableTutorialSettingTest.java @@ -0,0 +1,125 @@ +package us.eunoians.mcrpg.setting.impl; + +import com.diamonddagger590.mccore.player.CorePlayer; +import com.diamonddagger590.mccore.setting.PlayerSetting; +import com.diamonddagger590.mccore.util.LinkedNode; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.EnumSource; +import us.eunoians.mcrpg.expansion.McRPGExpansion; + +import java.util.Optional; + +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.Mockito.mock; + +class DisableTutorialSettingTest { + + @DisplayName("getSettingKey returns mcrpg:disable-tutorial-setting") + @Test + void getSettingKey_returnsExpectedKey() { + assertEquals("mcrpg:disable-tutorial-setting", + DisableTutorialSetting.ENABLED.getSettingKey().toString()); + } + + @DisplayName("getSettingKey is consistent across all variants") + @ParameterizedTest + @EnumSource(DisableTutorialSetting.class) + void getSettingKey_consistentAcrossVariants(DisableTutorialSetting setting) { + assertEquals(DisableTutorialSetting.SETTING_KEY, setting.getSettingKey()); + } + + @DisplayName("getFirstSetting returns ENABLED node") + @Test + void getFirstSetting_returnsEnabled() { + assertEquals(DisableTutorialSetting.ENABLED, + DisableTutorialSetting.ENABLED.getFirstSetting().getNodeValue()); + } + + @DisplayName("getFirstSetting is consistent across all variants") + @ParameterizedTest + @EnumSource(DisableTutorialSetting.class) + void getFirstSetting_consistentAcrossVariants(DisableTutorialSetting setting) { + assertEquals(DisableTutorialSetting.ENABLED, setting.getFirstSetting().getNodeValue()); + } + + @DisplayName("getNextSetting from ENABLED returns DISABLED node") + @Test + void getNextSetting_fromEnabled_returnsDisabled() { + LinkedNode next = DisableTutorialSetting.ENABLED.getNextSetting(); + assertEquals(DisableTutorialSetting.DISABLED, next.getNodeValue()); + } + + @DisplayName("getNextSetting from DISABLED cycles back to ENABLED node") + @Test + void getNextSetting_fromDisabled_cyclesToEnabled() { + LinkedNode next = DisableTutorialSetting.DISABLED.getNextSetting(); + assertEquals(DisableTutorialSetting.ENABLED, next.getNodeValue()); + } + + @DisplayName("Full cycle through all variants returns to start") + @Test + void fullCycle_returnsToStart() { + DisableTutorialSetting[] allValues = DisableTutorialSetting.values(); + DisableTutorialSetting current = DisableTutorialSetting.ENABLED; + for (int i = 0; i < allValues.length; i++) { + current = (DisableTutorialSetting) current.getNextSetting().getNodeValue(); + } + assertEquals(DisableTutorialSetting.ENABLED, current); + } + + @DisplayName("fromString round-trips for all variants") + @ParameterizedTest + @EnumSource(DisableTutorialSetting.class) + void fromString_roundTrip_allVariants(DisableTutorialSetting setting) { + assertEquals(setting, setting.fromString(setting.name()).orElseThrow()); + } + + @DisplayName("fromString is case-insensitive") + @Test + void fromString_caseInsensitive() { + assertEquals(DisableTutorialSetting.ENABLED, + DisableTutorialSetting.ENABLED.fromString("enabled").orElseThrow()); + assertEquals(DisableTutorialSetting.DISABLED, + DisableTutorialSetting.DISABLED.fromString("Disabled").orElseThrow()); + } + + @DisplayName("fromString returns empty for unknown value") + @Test + void fromString_unknownValue_returnsEmpty() { + assertTrue(DisableTutorialSetting.ENABLED.fromString("UNKNOWN").isEmpty()); + } + + @DisplayName("isDisabled returns true for DISABLED") + @Test + void isDisabled_disabled_returnsTrue() { + assertTrue(DisableTutorialSetting.DISABLED.isDisabled()); + } + + @DisplayName("isDisabled returns false for ENABLED") + @Test + void isDisabled_enabled_returnsFalse() { + assertFalse(DisableTutorialSetting.ENABLED.isDisabled()); + } + + @DisplayName("onSettingChange is a no-op (does not throw)") + @Test + void onSettingChange_doesNotThrow() { + CorePlayer mockPlayer = mock(CorePlayer.class); + assertDoesNotThrow(() -> { + DisableTutorialSetting.ENABLED.onSettingChange(mockPlayer, Optional.empty()); + DisableTutorialSetting.DISABLED.onSettingChange(mockPlayer, Optional.of(DisableTutorialSetting.ENABLED)); + }); + } + + @DisplayName("getExpansionKey returns McRPGExpansion key") + @Test + void getExpansionKey_returnsMcRPGExpansionKey() { + assertTrue(DisableTutorialSetting.ENABLED.getExpansionKey().isPresent()); + assertEquals(McRPGExpansion.EXPANSION_KEY, DisableTutorialSetting.ENABLED.getExpansionKey().get()); + } +}