From d733e6f26aed347e799fd3d1af5ce8405615d6ac Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 18 Sep 2026 09:34:48 +0000 Subject: [PATCH] Add unit tests for chain events and cascade types Cover QuestChainAbandonEvent, QuestChainExpireEvent, QuestChainFailEvent, QuestChainRestartEvent, QuestChainStepRetryEvent, CascadeStartEvent, CascadeFinalizeEvent, CascadeCompletedStep, CascadeOutcome, and ChainCompletionSource. Co-Authored-By: Claude Opus 4.6 Claude-Session: https://claude.ai/code/session_01J2oCBGibLnn5RLDajV3vyE --- .../event/quest/chain/CascadeEventTest.java | 230 ++++++++++++++++++ .../chain/QuestChainAbandonEventTest.java | 66 +++++ .../chain/QuestChainExpireEventTest.java | 100 ++++++++ .../quest/chain/QuestChainFailEventTest.java | 66 +++++ .../chain/QuestChainRestartEventTest.java | 90 +++++++ .../chain/QuestChainStepRetryEventTest.java | 89 +++++++ 6 files changed, 641 insertions(+) create mode 100644 src/test/java/us/eunoians/mcrpg/event/quest/chain/CascadeEventTest.java create mode 100644 src/test/java/us/eunoians/mcrpg/event/quest/chain/QuestChainAbandonEventTest.java create mode 100644 src/test/java/us/eunoians/mcrpg/event/quest/chain/QuestChainExpireEventTest.java create mode 100644 src/test/java/us/eunoians/mcrpg/event/quest/chain/QuestChainFailEventTest.java create mode 100644 src/test/java/us/eunoians/mcrpg/event/quest/chain/QuestChainRestartEventTest.java create mode 100644 src/test/java/us/eunoians/mcrpg/event/quest/chain/QuestChainStepRetryEventTest.java diff --git a/src/test/java/us/eunoians/mcrpg/event/quest/chain/CascadeEventTest.java b/src/test/java/us/eunoians/mcrpg/event/quest/chain/CascadeEventTest.java new file mode 100644 index 000000000..c5d72ded4 --- /dev/null +++ b/src/test/java/us/eunoians/mcrpg/event/quest/chain/CascadeEventTest.java @@ -0,0 +1,230 @@ +package us.eunoians.mcrpg.event.quest.chain; + +import org.bukkit.NamespacedKey; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.EnumSource; +import org.mockbukkit.mockbukkit.entity.PlayerMock; +import us.eunoians.mcrpg.McRPGBaseTest; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; +import java.util.UUID; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * Tests for the cascade event types: {@link CascadeStartEvent}, {@link CascadeFinalizeEvent}, + * {@link CascadeCompletedStep}, {@link CascadeOutcome}, and {@link ChainCompletionSource}. + */ +public class CascadeEventTest extends McRPGBaseTest { + + @Nested + @DisplayName("CascadeStartEvent") + class CascadeStartEventTests { + + @Test + @DisplayName("Given a cascade start event with an online player, when getters are called, then they return the constructor values") + void getters_returnConstructorValues() { + NamespacedKey chainKey = new NamespacedKey("mcrpg", "test_chain"); + PlayerMock player = server.addPlayer(); + + CascadeStartEvent event = new CascadeStartEvent(chainKey, player.getUniqueId(), player); + + assertEquals(chainKey, event.getChainKey()); + assertEquals(player.getUniqueId(), event.getPlayerUUID()); + assertSame(player, event.getPlayer()); + } + + @Test + @DisplayName("Given a cascade start event with a null player, when getPlayer() is called, then null is returned") + void getPlayer_returnsNull_whenPlayerOffline() { + NamespacedKey chainKey = new NamespacedKey("mcrpg", "test_chain"); + UUID offlineUUID = UUID.randomUUID(); + + CascadeStartEvent event = new CascadeStartEvent(chainKey, offlineUUID, null); + + assertNull(event.getPlayer()); + assertEquals(offlineUUID, event.getPlayerUUID()); + } + + @Test + @DisplayName("Given a cascade start event, when getHandlers() is called, then the static HandlerList is returned") + void getHandlers_returnsHandlerList() { + NamespacedKey chainKey = new NamespacedKey("mcrpg", "test_chain"); + + CascadeStartEvent event = new CascadeStartEvent(chainKey, UUID.randomUUID(), null); + + assertEquals(CascadeStartEvent.getHandlerList(), event.getHandlers()); + } + } + + @Nested + @DisplayName("CascadeFinalizeEvent") + class CascadeFinalizeEventTests { + + @Test + @DisplayName("Given a finalize event with auto-completed steps, when getters are called, then they return the constructor values") + void getters_returnConstructorValues() { + NamespacedKey chainKey = new NamespacedKey("mcrpg", "test_chain"); + PlayerMock player = server.addPlayer(); + NamespacedKey questKey = new NamespacedKey("mcrpg", "quest_one"); + List steps = List.of(new CascadeCompletedStep(questKey, "First Quest")); + NamespacedKey lastStarted = new NamespacedKey("mcrpg", "quest_two"); + + CascadeFinalizeEvent event = new CascadeFinalizeEvent(chainKey, player.getUniqueId(), player, + steps, lastStarted, CascadeOutcome.SUCCESS); + + assertEquals(chainKey, event.getChainKey()); + assertEquals(player.getUniqueId(), event.getPlayerUUID()); + assertSame(player, event.getPlayer()); + assertEquals(steps, event.getAutoCompletedSteps()); + assertEquals(Optional.of(lastStarted), event.getLastStartedQuestKey()); + assertEquals(CascadeOutcome.SUCCESS, event.getOutcome()); + } + + @Test + @DisplayName("Given a finalize event with auto-completed steps, when hadAutoCompletedSteps() is called, then true is returned") + void hadAutoCompletedSteps_returnsTrue_whenStepsExist() { + NamespacedKey chainKey = new NamespacedKey("mcrpg", "test_chain"); + NamespacedKey questKey = new NamespacedKey("mcrpg", "quest_one"); + List steps = List.of(new CascadeCompletedStep(questKey, "Quest")); + + CascadeFinalizeEvent event = new CascadeFinalizeEvent(chainKey, UUID.randomUUID(), null, + steps, null, CascadeOutcome.SUCCESS); + + assertTrue(event.hadAutoCompletedSteps()); + } + + @Test + @DisplayName("Given a finalize event with no auto-completed steps, when hadAutoCompletedSteps() is called, then false is returned") + void hadAutoCompletedSteps_returnsFalse_whenNoSteps() { + NamespacedKey chainKey = new NamespacedKey("mcrpg", "test_chain"); + + CascadeFinalizeEvent event = new CascadeFinalizeEvent(chainKey, UUID.randomUUID(), null, + List.of(), null, CascadeOutcome.SUCCESS); + + assertFalse(event.hadAutoCompletedSteps()); + } + + @Test + @DisplayName("Given a finalize event with a null lastStartedQuestKey, when getLastStartedQuestKey() is called, then empty Optional is returned") + void getLastStartedQuestKey_returnsEmpty_whenNull() { + NamespacedKey chainKey = new NamespacedKey("mcrpg", "test_chain"); + + CascadeFinalizeEvent event = new CascadeFinalizeEvent(chainKey, UUID.randomUUID(), null, + List.of(), null, CascadeOutcome.DEPTH_LIMIT_REACHED); + + assertEquals(Optional.empty(), event.getLastStartedQuestKey()); + } + + @Test + @DisplayName("Given a finalize event, when the auto-completed steps list is modified, then UnsupportedOperationException is thrown") + void autoCompletedSteps_isUnmodifiable() { + NamespacedKey chainKey = new NamespacedKey("mcrpg", "test_chain"); + NamespacedKey questKey = new NamespacedKey("mcrpg", "quest_one"); + List mutableSteps = new ArrayList<>(); + mutableSteps.add(new CascadeCompletedStep(questKey, "Quest")); + + CascadeFinalizeEvent event = new CascadeFinalizeEvent(chainKey, UUID.randomUUID(), null, + mutableSteps, null, CascadeOutcome.SUCCESS); + + assertThrows(UnsupportedOperationException.class, () -> + event.getAutoCompletedSteps().add(new CascadeCompletedStep(questKey, "Another"))); + } + + @Test + @DisplayName("Given a finalize event with a null player, when getPlayer() is called, then null is returned") + void getPlayer_returnsNull_whenPlayerOffline() { + NamespacedKey chainKey = new NamespacedKey("mcrpg", "test_chain"); + + CascadeFinalizeEvent event = new CascadeFinalizeEvent(chainKey, UUID.randomUUID(), null, + List.of(), null, CascadeOutcome.ERROR); + + assertNull(event.getPlayer()); + } + + @Test + @DisplayName("Given a finalize event, when getHandlers() is called, then the static HandlerList is returned") + void getHandlers_returnsHandlerList() { + NamespacedKey chainKey = new NamespacedKey("mcrpg", "test_chain"); + + CascadeFinalizeEvent event = new CascadeFinalizeEvent(chainKey, UUID.randomUUID(), null, + List.of(), null, CascadeOutcome.SUCCESS); + + assertEquals(CascadeFinalizeEvent.getHandlerList(), event.getHandlers()); + } + } + + @Nested + @DisplayName("CascadeCompletedStep") + class CascadeCompletedStepTests { + + @Test + @DisplayName("Given a CascadeCompletedStep record, when accessors are called, then they return the constructor values") + void accessors_returnConstructorValues() { + NamespacedKey questKey = new NamespacedKey("mcrpg", "quest_one"); + String displayName = "First Quest"; + + CascadeCompletedStep step = new CascadeCompletedStep(questKey, displayName); + + assertEquals(questKey, step.questKey()); + assertEquals(displayName, step.displayName()); + } + + @Test + @DisplayName("Given two CascadeCompletedStep records with the same values, when equals is called, then they are equal") + void equals_returnsTrue_forSameValues() { + NamespacedKey questKey = new NamespacedKey("mcrpg", "quest_one"); + CascadeCompletedStep step1 = new CascadeCompletedStep(questKey, "Quest"); + CascadeCompletedStep step2 = new CascadeCompletedStep(questKey, "Quest"); + + assertEquals(step1, step2); + assertEquals(step1.hashCode(), step2.hashCode()); + } + } + + @Nested + @DisplayName("CascadeOutcome") + class CascadeOutcomeTests { + + @Test + @DisplayName("CascadeOutcome enum has exactly three values") + void hasThreeValues() { + assertEquals(3, CascadeOutcome.values().length); + } + + @ParameterizedTest + @EnumSource(CascadeOutcome.class) + @DisplayName("Given each CascadeOutcome, when valueOf is called with its name, then the same constant is returned") + void valueOf_roundTrips(CascadeOutcome outcome) { + assertEquals(outcome, CascadeOutcome.valueOf(outcome.name())); + } + } + + @Nested + @DisplayName("ChainCompletionSource") + class ChainCompletionSourceTests { + + @Test + @DisplayName("ChainCompletionSource enum has exactly three values") + void hasThreeValues() { + assertEquals(3, ChainCompletionSource.values().length); + } + + @ParameterizedTest + @EnumSource(ChainCompletionSource.class) + @DisplayName("Given each ChainCompletionSource, when valueOf is called with its name, then the same constant is returned") + void valueOf_roundTrips(ChainCompletionSource source) { + assertEquals(source, ChainCompletionSource.valueOf(source.name())); + } + } +} diff --git a/src/test/java/us/eunoians/mcrpg/event/quest/chain/QuestChainAbandonEventTest.java b/src/test/java/us/eunoians/mcrpg/event/quest/chain/QuestChainAbandonEventTest.java new file mode 100644 index 000000000..020af4896 --- /dev/null +++ b/src/test/java/us/eunoians/mcrpg/event/quest/chain/QuestChainAbandonEventTest.java @@ -0,0 +1,66 @@ +package us.eunoians.mcrpg.event.quest.chain; + +import org.bukkit.NamespacedKey; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.mockbukkit.mockbukkit.entity.PlayerMock; +import us.eunoians.mcrpg.McRPGBaseTest; +import us.eunoians.mcrpg.quest.chain.QuestChainDefinition; +import us.eunoians.mcrpg.quest.chain.QuestChainStep; + +import java.util.List; +import java.util.UUID; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; + +/** + * Tests for {@link QuestChainAbandonEvent}. + */ +public class QuestChainAbandonEventTest extends McRPGBaseTest { + + private static QuestChainDefinition buildDefinition() { + NamespacedKey chainKey = new NamespacedKey("mcrpg", "test_chain"); + NamespacedKey sourceKey = new NamespacedKey("mcrpg", "manual"); + NamespacedKey triggerKey = new NamespacedKey("mcrpg", "manual"); + List steps = List.of(QuestChainStep.simple(new NamespacedKey("mcrpg", "quest_one"))); + return new QuestChainDefinition.Builder(chainKey, sourceKey, triggerKey, steps).build(); + } + + @Test + @DisplayName("Given an abandon event with an online player, when getters are called, then they return the constructor values") + void getters_returnConstructorValues() { + QuestChainDefinition definition = buildDefinition(); + PlayerMock player = server.addPlayer(); + + QuestChainAbandonEvent event = new QuestChainAbandonEvent(definition, player, player.getUniqueId()); + + assertSame(definition, event.getChainDefinition()); + assertSame(player, event.getPlayer()); + assertEquals(player.getUniqueId(), event.getPlayerUUID()); + } + + @Test + @DisplayName("Given an abandon event with a null player, when getPlayer() is called, then null is returned") + void getPlayer_returnsNull_whenPlayerOffline() { + QuestChainDefinition definition = buildDefinition(); + UUID offlineUUID = UUID.randomUUID(); + + QuestChainAbandonEvent event = new QuestChainAbandonEvent(definition, null, offlineUUID); + + assertNull(event.getPlayer()); + assertEquals(offlineUUID, event.getPlayerUUID()); + } + + @Test + @DisplayName("Given an abandon event, when getHandlers() is called, then the static HandlerList is returned") + void getHandlers_returnsHandlerList() { + QuestChainDefinition definition = buildDefinition(); + UUID uuid = UUID.randomUUID(); + + QuestChainAbandonEvent event = new QuestChainAbandonEvent(definition, null, uuid); + + assertEquals(QuestChainAbandonEvent.getHandlerList(), event.getHandlers()); + } +} diff --git a/src/test/java/us/eunoians/mcrpg/event/quest/chain/QuestChainExpireEventTest.java b/src/test/java/us/eunoians/mcrpg/event/quest/chain/QuestChainExpireEventTest.java new file mode 100644 index 000000000..36dead3eb --- /dev/null +++ b/src/test/java/us/eunoians/mcrpg/event/quest/chain/QuestChainExpireEventTest.java @@ -0,0 +1,100 @@ +package us.eunoians.mcrpg.event.quest.chain; + +import org.bukkit.NamespacedKey; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.mockbukkit.mockbukkit.entity.PlayerMock; +import us.eunoians.mcrpg.McRPGBaseTest; +import us.eunoians.mcrpg.quest.chain.QuestChainDefinition; +import us.eunoians.mcrpg.quest.chain.QuestChainStep; + +import java.util.List; +import java.util.Optional; +import java.util.UUID; + +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; + +/** + * Tests for {@link QuestChainExpireEvent}. + */ +public class QuestChainExpireEventTest extends McRPGBaseTest { + + private static QuestChainDefinition buildDefinition() { + NamespacedKey chainKey = new NamespacedKey("mcrpg", "test_chain"); + NamespacedKey sourceKey = new NamespacedKey("mcrpg", "manual"); + NamespacedKey triggerKey = new NamespacedKey("mcrpg", "manual"); + List steps = List.of(QuestChainStep.simple(new NamespacedKey("mcrpg", "quest_one"))); + return new QuestChainDefinition.Builder(chainKey, sourceKey, triggerKey, steps).build(); + } + + @Test + @DisplayName("Given an expire event with an online player, when getters are called, then they return the constructor values") + void getters_returnConstructorValues() { + QuestChainDefinition definition = buildDefinition(); + PlayerMock player = server.addPlayer(); + + QuestChainExpireEvent event = new QuestChainExpireEvent(definition, player.getUniqueId(), player); + + assertSame(definition, event.getChainDefinition()); + assertEquals(player.getUniqueId(), event.getPlayerUUID()); + assertEquals(Optional.of(player), event.getPlayer()); + } + + @Test + @DisplayName("Given an expire event with a null player, when getPlayer() is called, then empty Optional is returned") + void getPlayer_returnsEmpty_whenPlayerOffline() { + QuestChainDefinition definition = buildDefinition(); + UUID offlineUUID = UUID.randomUUID(); + + QuestChainExpireEvent event = new QuestChainExpireEvent(definition, offlineUUID, null); + + assertEquals(Optional.empty(), event.getPlayer()); + assertEquals(offlineUUID, event.getPlayerUUID()); + } + + @Test + @DisplayName("Given an expire event, when isCancelled() is called before setCancelled, then it returns false") + void isCancelled_defaultsFalse() { + QuestChainDefinition definition = buildDefinition(); + + QuestChainExpireEvent event = new QuestChainExpireEvent(definition, UUID.randomUUID(), null); + + assertFalse(event.isCancelled()); + } + + @Test + @DisplayName("Given an expire event, when setCancelled(true) is called, then isCancelled() returns true") + void setCancelled_true_makesIsCancelledReturnTrue() { + QuestChainDefinition definition = buildDefinition(); + + QuestChainExpireEvent event = new QuestChainExpireEvent(definition, UUID.randomUUID(), null); + event.setCancelled(true); + + assertTrue(event.isCancelled()); + } + + @Test + @DisplayName("Given an expire event that was cancelled, when setCancelled(false) is called, then isCancelled() returns false") + void setCancelled_false_revertsCancel() { + QuestChainDefinition definition = buildDefinition(); + + QuestChainExpireEvent event = new QuestChainExpireEvent(definition, UUID.randomUUID(), null); + event.setCancelled(true); + event.setCancelled(false); + + assertFalse(event.isCancelled()); + } + + @Test + @DisplayName("Given an expire event, when getHandlers() is called, then the static HandlerList is returned") + void getHandlers_returnsHandlerList() { + QuestChainDefinition definition = buildDefinition(); + + QuestChainExpireEvent event = new QuestChainExpireEvent(definition, UUID.randomUUID(), null); + + assertEquals(QuestChainExpireEvent.getHandlerList(), event.getHandlers()); + } +} diff --git a/src/test/java/us/eunoians/mcrpg/event/quest/chain/QuestChainFailEventTest.java b/src/test/java/us/eunoians/mcrpg/event/quest/chain/QuestChainFailEventTest.java new file mode 100644 index 000000000..a65cda1f9 --- /dev/null +++ b/src/test/java/us/eunoians/mcrpg/event/quest/chain/QuestChainFailEventTest.java @@ -0,0 +1,66 @@ +package us.eunoians.mcrpg.event.quest.chain; + +import org.bukkit.NamespacedKey; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.mockbukkit.mockbukkit.entity.PlayerMock; +import us.eunoians.mcrpg.McRPGBaseTest; +import us.eunoians.mcrpg.quest.chain.QuestChainDefinition; +import us.eunoians.mcrpg.quest.chain.QuestChainStep; + +import java.util.List; +import java.util.UUID; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; + +/** + * Tests for {@link QuestChainFailEvent}. + */ +public class QuestChainFailEventTest extends McRPGBaseTest { + + private static QuestChainDefinition buildDefinition() { + NamespacedKey chainKey = new NamespacedKey("mcrpg", "test_chain"); + NamespacedKey sourceKey = new NamespacedKey("mcrpg", "manual"); + NamespacedKey triggerKey = new NamespacedKey("mcrpg", "manual"); + List steps = List.of(QuestChainStep.simple(new NamespacedKey("mcrpg", "quest_one"))); + return new QuestChainDefinition.Builder(chainKey, sourceKey, triggerKey, steps).build(); + } + + @Test + @DisplayName("Given a fail event with an online player, when getters are called, then they return the constructor values") + void getters_returnConstructorValues() { + QuestChainDefinition definition = buildDefinition(); + PlayerMock player = server.addPlayer(); + + QuestChainFailEvent event = new QuestChainFailEvent(definition, player, player.getUniqueId()); + + assertSame(definition, event.getChainDefinition()); + assertSame(player, event.getPlayer()); + assertEquals(player.getUniqueId(), event.getPlayerUUID()); + } + + @Test + @DisplayName("Given a fail event with a null player, when getPlayer() is called, then null is returned") + void getPlayer_returnsNull_whenPlayerOffline() { + QuestChainDefinition definition = buildDefinition(); + UUID offlineUUID = UUID.randomUUID(); + + QuestChainFailEvent event = new QuestChainFailEvent(definition, null, offlineUUID); + + assertNull(event.getPlayer()); + assertEquals(offlineUUID, event.getPlayerUUID()); + } + + @Test + @DisplayName("Given a fail event, when getHandlers() is called, then the static HandlerList is returned") + void getHandlers_returnsHandlerList() { + QuestChainDefinition definition = buildDefinition(); + UUID uuid = UUID.randomUUID(); + + QuestChainFailEvent event = new QuestChainFailEvent(definition, null, uuid); + + assertEquals(QuestChainFailEvent.getHandlerList(), event.getHandlers()); + } +} diff --git a/src/test/java/us/eunoians/mcrpg/event/quest/chain/QuestChainRestartEventTest.java b/src/test/java/us/eunoians/mcrpg/event/quest/chain/QuestChainRestartEventTest.java new file mode 100644 index 000000000..33b6a8b35 --- /dev/null +++ b/src/test/java/us/eunoians/mcrpg/event/quest/chain/QuestChainRestartEventTest.java @@ -0,0 +1,90 @@ +package us.eunoians.mcrpg.event.quest.chain; + +import org.bukkit.NamespacedKey; +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 org.mockbukkit.mockbukkit.entity.PlayerMock; +import us.eunoians.mcrpg.McRPGBaseTest; +import us.eunoians.mcrpg.quest.chain.QuestChainDefinition; +import us.eunoians.mcrpg.quest.chain.QuestChainStep; + +import java.util.List; +import java.util.UUID; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; + +/** + * Tests for {@link QuestChainRestartEvent} and {@link QuestChainRestartEvent.RestartReason}. + */ +public class QuestChainRestartEventTest extends McRPGBaseTest { + + private static QuestChainDefinition buildDefinition() { + NamespacedKey chainKey = new NamespacedKey("mcrpg", "test_chain"); + NamespacedKey sourceKey = new NamespacedKey("mcrpg", "manual"); + NamespacedKey triggerKey = new NamespacedKey("mcrpg", "manual"); + List steps = List.of(QuestChainStep.simple(new NamespacedKey("mcrpg", "quest_one"))); + return new QuestChainDefinition.Builder(chainKey, sourceKey, triggerKey, steps).build(); + } + + @Test + @DisplayName("Given a restart event with an online player, when getters are called, then they return the constructor values") + void getters_returnConstructorValues() { + QuestChainDefinition definition = buildDefinition(); + PlayerMock player = server.addPlayer(); + + QuestChainRestartEvent event = new QuestChainRestartEvent(definition, player, player.getUniqueId(), + QuestChainRestartEvent.RestartReason.REPEAT_MODE); + + assertSame(definition, event.getChainDefinition()); + assertSame(player, event.getPlayer()); + assertEquals(player.getUniqueId(), event.getPlayerUUID()); + assertEquals(QuestChainRestartEvent.RestartReason.REPEAT_MODE, event.getReason()); + } + + @Test + @DisplayName("Given a restart event with a null player, when getPlayer() is called, then null is returned") + void getPlayer_returnsNull_whenPlayerOffline() { + QuestChainDefinition definition = buildDefinition(); + UUID offlineUUID = UUID.randomUUID(); + + QuestChainRestartEvent event = new QuestChainRestartEvent(definition, null, offlineUUID, + QuestChainRestartEvent.RestartReason.QUEST_EXPIRE_RESTART_CHAIN); + + assertNull(event.getPlayer()); + assertEquals(offlineUUID, event.getPlayerUUID()); + } + + @ParameterizedTest + @EnumSource(QuestChainRestartEvent.RestartReason.class) + @DisplayName("Given each RestartReason, when passed to constructor and retrieved, then the same reason is returned") + void getReason_returnsProvidedReason(QuestChainRestartEvent.RestartReason reason) { + QuestChainDefinition definition = buildDefinition(); + UUID uuid = UUID.randomUUID(); + + QuestChainRestartEvent event = new QuestChainRestartEvent(definition, null, uuid, reason); + + assertEquals(reason, event.getReason()); + } + + @Test + @DisplayName("Given a restart event, when getHandlers() is called, then the static HandlerList is returned") + void getHandlers_returnsHandlerList() { + QuestChainDefinition definition = buildDefinition(); + UUID uuid = UUID.randomUUID(); + + QuestChainRestartEvent event = new QuestChainRestartEvent(definition, null, uuid, + QuestChainRestartEvent.RestartReason.REPEAT_MODE); + + assertEquals(QuestChainRestartEvent.getHandlerList(), event.getHandlers()); + } + + @Test + @DisplayName("RestartReason enum has exactly two values") + void restartReason_hasTwoValues() { + assertEquals(2, QuestChainRestartEvent.RestartReason.values().length); + } +} diff --git a/src/test/java/us/eunoians/mcrpg/event/quest/chain/QuestChainStepRetryEventTest.java b/src/test/java/us/eunoians/mcrpg/event/quest/chain/QuestChainStepRetryEventTest.java new file mode 100644 index 000000000..c69ee486f --- /dev/null +++ b/src/test/java/us/eunoians/mcrpg/event/quest/chain/QuestChainStepRetryEventTest.java @@ -0,0 +1,89 @@ +package us.eunoians.mcrpg.event.quest.chain; + +import org.bukkit.NamespacedKey; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.mockbukkit.mockbukkit.entity.PlayerMock; +import us.eunoians.mcrpg.McRPGBaseTest; +import us.eunoians.mcrpg.quest.chain.QuestChainDefinition; +import us.eunoians.mcrpg.quest.chain.QuestChainStep; + +import java.util.List; +import java.util.UUID; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; + +/** + * Tests for {@link QuestChainStepRetryEvent}. + */ +public class QuestChainStepRetryEventTest extends McRPGBaseTest { + + private static QuestChainDefinition buildDefinition() { + NamespacedKey chainKey = new NamespacedKey("mcrpg", "test_chain"); + NamespacedKey sourceKey = new NamespacedKey("mcrpg", "manual"); + NamespacedKey triggerKey = new NamespacedKey("mcrpg", "manual"); + NamespacedKey questKey = new NamespacedKey("mcrpg", "quest_one"); + List steps = List.of(QuestChainStep.simple(questKey)); + return new QuestChainDefinition.Builder(chainKey, sourceKey, triggerKey, steps).build(); + } + + @Test + @DisplayName("Given a step-retry event with an online player, when getters are called, then they return the constructor values") + void getters_returnConstructorValues() { + QuestChainDefinition definition = buildDefinition(); + PlayerMock player = server.addPlayer(); + QuestChainStep step = definition.getSteps().get(0); + + QuestChainStepRetryEvent event = new QuestChainStepRetryEvent(definition, player, player.getUniqueId(), + step, 2, 5); + + assertSame(definition, event.getChainDefinition()); + assertSame(player, event.getPlayer()); + assertEquals(player.getUniqueId(), event.getPlayerUUID()); + assertSame(step, event.getStep()); + assertEquals(2, event.getRetryNumber()); + assertEquals(5, event.getMaxRetries()); + } + + @Test + @DisplayName("Given a step-retry event with a null player, when getPlayer() is called, then null is returned") + void getPlayer_returnsNull_whenPlayerOffline() { + QuestChainDefinition definition = buildDefinition(); + UUID offlineUUID = UUID.randomUUID(); + QuestChainStep step = definition.getSteps().get(0); + + QuestChainStepRetryEvent event = new QuestChainStepRetryEvent(definition, null, offlineUUID, + step, 1, 3); + + assertNull(event.getPlayer()); + assertEquals(offlineUUID, event.getPlayerUUID()); + } + + @Test + @DisplayName("Given a step-retry event with unlimited retries, when getMaxRetries() is called, then -1 is returned") + void getMaxRetries_returnsNegativeOne_whenUnlimited() { + QuestChainDefinition definition = buildDefinition(); + UUID uuid = UUID.randomUUID(); + QuestChainStep step = definition.getSteps().get(0); + + QuestChainStepRetryEvent event = new QuestChainStepRetryEvent(definition, null, uuid, + step, 1, -1); + + assertEquals(-1, event.getMaxRetries()); + } + + @Test + @DisplayName("Given a step-retry event, when getHandlers() is called, then the static HandlerList is returned") + void getHandlers_returnsHandlerList() { + QuestChainDefinition definition = buildDefinition(); + UUID uuid = UUID.randomUUID(); + QuestChainStep step = definition.getSteps().get(0); + + QuestChainStepRetryEvent event = new QuestChainStepRetryEvent(definition, null, uuid, + step, 1, 3); + + assertEquals(QuestChainStepRetryEvent.getHandlerList(), event.getHandlers()); + } +}