diff --git a/README.md b/README.md index 41be63e..1eedae1 100644 --- a/README.md +++ b/README.md @@ -29,6 +29,16 @@ Stick Either storage-block variant produces one Sorting Stick. +## Sorting inventories + +Hold an authentic Sorting Stick and right-click: + +- A chest or either half of a double chest to sort its complete inventory. +- A barrel to sort its inventory. +- Air or another block to sort player inventory slots 9–35. + +Player hotbar, armor, and off-hand slots remain unchanged during player sorting. Compatible stacks are consolidated first, then items are ordered alphabetically by Minecraft material. Dissimilar metadata variants of the same material retain their relative order. Locked containers and interactions cancelled by protection plugins are not sorted. + ## Releases Gitea Actions checks pushes and pull requests and stores a development JAR. Pull requests validate conventional commits. Main-branch conventional commits drive semantic releases when the repository defines a `RELEASE_TOKEN` with contents-write permission. diff --git a/design/log.md b/design/log.md index dc3507e..f404dfd 100644 --- a/design/log.md +++ b/design/log.md @@ -31,6 +31,13 @@ description: Chronological record of material decisions affecting the Spigot Inv - Registered equivalent chest and barrel recipe variants matching the approved center-column shape. - Verified recipe specification, registration, output, item appearance, identity, and renamed-stick rejection with automated tests and `./gradlew clean check jar`. +## 2026-09-04 — Inventory sorting completed + +- Added metadata-preserving stack consolidation and stable alphabetical ordering by Minecraft material. +- Added Sorting Stick interactions for single and double chests, barrels, and player main-storage slots while preserving hotbar, armor, and off-hand slots. +- Rejected locked containers, cancelled protection events, non-right-click interactions, and unauthenticated sticks without changing inventories. +- Added action-bar feedback, documented player behavior, and verified the complete feature with `./gradlew clean check jar`. + ## 2026-09-04 — Implementation started - Approved implementation begins with the tested Gradle and Purpur foundation, followed by the Sorting Stick, inventory sorting, and automatic tool replacement. diff --git a/design/user-stories/us-003-sort-inventories.md b/design/user-stories/us-003-sort-inventories.md index 8f3f40e..66dd92b 100644 --- a/design/user-stories/us-003-sort-inventories.md +++ b/design/user-stories/us-003-sort-inventories.md @@ -2,7 +2,7 @@ type: User Story title: "US-003: Sort containers and player inventory" description: Let players use a Sorting Stick to consolidate and organize supported storage or their main inventory. -status: in-progress +status: done --- # US-003: Sort containers and player inventory @@ -11,18 +11,18 @@ As a **player holding a Sorting Stick**, I want to sort storage containers or my ## Acceptance criteria -- [ ] Using the Sorting Stick on a chest sorts the complete chest inventory. -- [ ] Using it on either half of a double chest sorts the combined inventory. -- [ ] Using it on a barrel sorts that barrel. -- [ ] Using it without targeting a supported container sorts the player's main storage slots. -- [ ] Player hotbar, armor, and off-hand slots are not changed during player-inventory sorting. -- [ ] Compatible partial stacks are consolidated without exceeding item stack limits. -- [ ] Remaining stacks are placed in a deterministic, documented order. -- [ ] Sorting preserves item quantities and all item metadata exactly. -- [ ] Sorting respects cancelled interactions and normal container-access protections. -- [ ] Unsupported or inaccessible targets fail safely without changing an inventory. -- [ ] Sorting provides concise player feedback without opening the target container. -- [ ] Automated tests cover single chests, double chests, barrels, player inventory boundaries, stack consolidation, metadata preservation, and rejected interactions. +- [x] Using the Sorting Stick on a chest sorts the complete chest inventory. +- [x] Using it on either half of a double chest sorts the combined inventory. +- [x] Using it on a barrel sorts that barrel. +- [x] Using it without targeting a supported container sorts the player's main storage slots. +- [x] Player hotbar, armor, and off-hand slots are not changed during player-inventory sorting. +- [x] Compatible partial stacks are consolidated without exceeding item stack limits. +- [x] Remaining stacks are placed in a deterministic, documented order. +- [x] Sorting preserves item quantities and all item metadata exactly. +- [x] Sorting respects cancelled interactions and normal container-access protections. +- [x] Unsupported or inaccessible targets fail safely without changing an inventory. +- [x] Sorting provides concise player feedback without opening the target container. +- [x] Automated tests cover single chests, double chests, barrels, player inventory boundaries, stack consolidation, metadata preservation, and rejected interactions. ## Related diff --git a/src/main/java/games/dmg/spigotinventoryhelper/InventorySorter.java b/src/main/java/games/dmg/spigotinventoryhelper/InventorySorter.java new file mode 100644 index 0000000..8ee81c9 --- /dev/null +++ b/src/main/java/games/dmg/spigotinventoryhelper/InventorySorter.java @@ -0,0 +1,58 @@ +package games.dmg.spigotinventoryhelper; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Comparator; +import java.util.List; +import java.util.Objects; +import org.bukkit.Material; +import org.bukkit.inventory.ItemStack; + +public final class InventorySorter { + public ItemStack[] sort(ItemStack[] contents) { + Objects.requireNonNull(contents, "contents"); + List items = Arrays.stream(contents) + .filter(Objects::nonNull) + .filter(item -> item.getType() != Material.AIR) + .filter(item -> item.getAmount() > 0) + .map(ItemStack::clone) + .sorted(Comparator.comparing(item -> item.getType().name())) + .toList(); + + List packed = new ArrayList<>(); + for (ItemStack item : items) { + pack(item, packed); + } + + ItemStack[] sorted = new ItemStack[contents.length]; + for (int slot = 0; slot < packed.size(); slot++) { + sorted[slot] = packed.get(slot); + } + return sorted; + } + + private static void pack(ItemStack item, List packed) { + int remaining = item.getAmount(); + for (ItemStack existing : packed) { + if (!existing.isSimilar(item) || existing.getAmount() >= existing.getMaxStackSize()) { + continue; + } + int transferred = Math.min( + remaining, + existing.getMaxStackSize() - existing.getAmount() + ); + existing.setAmount(existing.getAmount() + transferred); + remaining -= transferred; + if (remaining == 0) { + return; + } + } + while (remaining > 0) { + ItemStack stack = item.clone(); + int amount = Math.min(remaining, stack.getMaxStackSize()); + stack.setAmount(amount); + packed.add(stack); + remaining -= amount; + } + } +} diff --git a/src/main/java/games/dmg/spigotinventoryhelper/InventorySortingService.java b/src/main/java/games/dmg/spigotinventoryhelper/InventorySortingService.java new file mode 100644 index 0000000..3776178 --- /dev/null +++ b/src/main/java/games/dmg/spigotinventoryhelper/InventorySortingService.java @@ -0,0 +1,39 @@ +package games.dmg.spigotinventoryhelper; + +import java.util.Arrays; +import java.util.Objects; +import org.bukkit.inventory.Inventory; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.PlayerInventory; + +public final class InventorySortingService { + private static final int HOTBAR_SIZE = 9; + private static final int PLAYER_STORAGE_SIZE = 36; + + private final InventorySorter sorter; + + public InventorySortingService(InventorySorter sorter) { + this.sorter = Objects.requireNonNull(sorter, "sorter"); + } + + public void sortPlayerMainStorage(PlayerInventory inventory) { + Objects.requireNonNull(inventory, "inventory"); + ItemStack[] storage = inventory.getStorageContents().clone(); + if (storage.length < PLAYER_STORAGE_SIZE) { + throw new IllegalArgumentException("Player storage must contain 36 slots"); + } + ItemStack[] mainStorage = Arrays.copyOfRange( + storage, + HOTBAR_SIZE, + PLAYER_STORAGE_SIZE + ); + ItemStack[] sorted = sorter.sort(mainStorage); + System.arraycopy(sorted, 0, storage, HOTBAR_SIZE, sorted.length); + inventory.setStorageContents(storage); + } + + public void sortContainer(Inventory inventory) { + Objects.requireNonNull(inventory, "inventory"); + inventory.setContents(sorter.sort(inventory.getContents())); + } +} diff --git a/src/main/java/games/dmg/spigotinventoryhelper/SortingStickListener.java b/src/main/java/games/dmg/spigotinventoryhelper/SortingStickListener.java new file mode 100644 index 0000000..44a2a92 --- /dev/null +++ b/src/main/java/games/dmg/spigotinventoryhelper/SortingStickListener.java @@ -0,0 +1,66 @@ +package games.dmg.spigotinventoryhelper; + +import java.util.Objects; +import net.kyori.adventure.text.Component; +import net.kyori.adventure.text.format.NamedTextColor; +import org.bukkit.block.Barrel; +import org.bukkit.block.Block; +import org.bukkit.block.Chest; +import org.bukkit.block.Container; +import org.bukkit.block.Lockable; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.EventPriority; +import org.bukkit.event.Listener; +import org.bukkit.event.block.Action; +import org.bukkit.event.player.PlayerInteractEvent; +import org.bukkit.inventory.EquipmentSlot; + +public final class SortingStickListener implements Listener { + private final SortingStickItemFactory sticks; + private final InventorySortingService sorting; + + public SortingStickListener( + SortingStickItemFactory sticks, + InventorySortingService sorting + ) { + this.sticks = Objects.requireNonNull(sticks, "sticks"); + this.sorting = Objects.requireNonNull(sorting, "sorting"); + } + + @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) + public void onInteract(PlayerInteractEvent event) { + if (event.isCancelled() + || event.getHand() != EquipmentSlot.HAND + || !isRightClick(event.getAction()) + || !sticks.isSortingStick(event.getItem())) { + return; + } + + event.setCancelled(true); + Player player = event.getPlayer(); + Block clicked = event.getClickedBlock(); + if (clicked != null) { + Object state = clicked.getState(); + if (state instanceof Chest || state instanceof Barrel) { + if (((Lockable) state).isLocked()) { + player.sendActionBar(Component.text( + "That container is locked.", + NamedTextColor.RED + )); + return; + } + sorting.sortContainer(((Container) state).getInventory()); + player.sendActionBar(Component.text("Container sorted.", NamedTextColor.GREEN)); + return; + } + } + + sorting.sortPlayerMainStorage(player.getInventory()); + player.sendActionBar(Component.text("Inventory sorted.", NamedTextColor.GREEN)); + } + + private static boolean isRightClick(Action action) { + return action == Action.RIGHT_CLICK_AIR || action == Action.RIGHT_CLICK_BLOCK; + } +} diff --git a/src/main/java/games/dmg/spigotinventoryhelper/SpigotInventoryHelperPlugin.java b/src/main/java/games/dmg/spigotinventoryhelper/SpigotInventoryHelperPlugin.java index 32ae873..d8791b0 100644 --- a/src/main/java/games/dmg/spigotinventoryhelper/SpigotInventoryHelperPlugin.java +++ b/src/main/java/games/dmg/spigotinventoryhelper/SpigotInventoryHelperPlugin.java @@ -17,6 +17,11 @@ public final class SpigotInventoryHelperPlugin extends JavaPlugin { if (!recipes.register(getServer())) { getLogger().warning("One or more Sorting Stick recipes could not be registered."); } + InventorySortingService sorting = new InventorySortingService(new InventorySorter()); + getServer().getPluginManager().registerEvents( + new SortingStickListener(sortingSticks, sorting), + this + ); getLogger().info("Spigot Inventory Helper enabled."); } diff --git a/src/test/java/games/dmg/spigotinventoryhelper/InventorySorterTest.java b/src/test/java/games/dmg/spigotinventoryhelper/InventorySorterTest.java new file mode 100644 index 0000000..dcac9d7 --- /dev/null +++ b/src/test/java/games/dmg/spigotinventoryhelper/InventorySorterTest.java @@ -0,0 +1,89 @@ +package games.dmg.spigotinventoryhelper; + +import static org.junit.jupiter.api.Assertions.assertAll; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyInt; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import java.util.concurrent.atomic.AtomicInteger; +import org.bukkit.Material; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.meta.ItemMeta; +import org.junit.jupiter.api.Test; + +final class InventorySorterTest { + @Test + void consolidatesStacksAndOrdersMaterialsAlphabetically() { + ItemStack[] contents = { + stack(Material.STONE, 5), + stack(Material.DIRT, 40), + stack(Material.DIRT, 30), + null + }; + + ItemStack[] sorted = new InventorySorter().sort(contents); + + assertAll( + () -> assertEquals(Material.DIRT, sorted[0].getType()), + () -> assertEquals(64, sorted[0].getAmount()), + () -> assertEquals(Material.DIRT, sorted[1].getType()), + () -> assertEquals(6, sorted[1].getAmount()), + () -> assertEquals(Material.STONE, sorted[2].getType()), + () -> assertEquals(5, sorted[2].getAmount()), + () -> assertNull(sorted[3]) + ); + } + + @Test + void preservesMetadataAndStableOrderForDissimilarVariants() { + ItemMeta named = mock(ItemMeta.class, "named"); + ItemMeta enchanted = mock(ItemMeta.class, "enchanted"); + ItemStack[] contents = { + stack(Material.STONE, 5, named), + stack(Material.STONE, 2, enchanted), + stack(Material.STONE, 4, named) + }; + + ItemStack[] sorted = new InventorySorter().sort(contents); + + assertAll( + () -> assertSame(named, sorted[0].getItemMeta()), + () -> assertEquals(9, sorted[0].getAmount()), + () -> assertSame(enchanted, sorted[1].getItemMeta()), + () -> assertEquals(2, sorted[1].getAmount()), + () -> assertNull(sorted[2]) + ); + } + + private static ItemStack stack(Material material, int initialAmount) { + return stack(material, initialAmount, null); + } + + private static ItemStack stack( + Material material, + int initialAmount, + ItemMeta metadata + ) { + AtomicInteger amount = new AtomicInteger(initialAmount); + ItemStack item = mock(ItemStack.class); + when(item.getType()).thenReturn(material); + when(item.getAmount()).thenAnswer(ignored -> amount.get()); + when(item.getItemMeta()).thenReturn(metadata); + doAnswer(invocation -> { + amount.set(invocation.getArgument(0)); + return null; + }).when(item).setAmount(anyInt()); + when(item.getMaxStackSize()).thenReturn(64); + when(item.isSimilar(any(ItemStack.class))).thenAnswer(invocation -> { + ItemStack other = invocation.getArgument(0); + return other.getType() == material && other.getItemMeta() == metadata; + }); + when(item.clone()).thenAnswer(ignored -> stack(material, amount.get(), metadata)); + return item; + } +} diff --git a/src/test/java/games/dmg/spigotinventoryhelper/InventorySortingServiceTest.java b/src/test/java/games/dmg/spigotinventoryhelper/InventorySortingServiceTest.java new file mode 100644 index 0000000..5672d5a --- /dev/null +++ b/src/test/java/games/dmg/spigotinventoryhelper/InventorySortingServiceTest.java @@ -0,0 +1,44 @@ +package games.dmg.spigotinventoryhelper; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import java.util.Arrays; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.PlayerInventory; +import org.junit.jupiter.api.Test; +import org.mockito.ArgumentCaptor; + +final class InventorySortingServiceTest { + @Test + void sortsOnlyPlayerMainStorageSlots() { + PlayerInventory inventory = mock(PlayerInventory.class); + InventorySorter sorter = mock(InventorySorter.class); + ItemStack[] storage = stacks(36); + ItemStack[] mainStorage = Arrays.copyOfRange(storage, 9, 36); + ItemStack[] sortedMain = mainStorage.clone(); + ItemStack first = sortedMain[0]; + sortedMain[0] = sortedMain[26]; + sortedMain[26] = first; + when(inventory.getStorageContents()).thenReturn(storage); + when(sorter.sort(mainStorage)).thenReturn(sortedMain); + + new InventorySortingService(sorter).sortPlayerMainStorage(inventory); + + ArgumentCaptor result = ArgumentCaptor.forClass(ItemStack[].class); + verify(inventory).setStorageContents(result.capture()); + assertArrayEquals(Arrays.copyOfRange(storage, 0, 9), + Arrays.copyOfRange(result.getValue(), 0, 9)); + assertArrayEquals(sortedMain, Arrays.copyOfRange(result.getValue(), 9, 36)); + } + + private static ItemStack[] stacks(int size) { + ItemStack[] stacks = new ItemStack[size]; + for (int slot = 0; slot < size; slot++) { + stacks[slot] = mock(ItemStack.class, "slot-" + slot); + } + return stacks; + } +} diff --git a/src/test/java/games/dmg/spigotinventoryhelper/SortingStickListenerTest.java b/src/test/java/games/dmg/spigotinventoryhelper/SortingStickListenerTest.java new file mode 100644 index 0000000..1f094d0 --- /dev/null +++ b/src/test/java/games/dmg/spigotinventoryhelper/SortingStickListenerTest.java @@ -0,0 +1,173 @@ +package games.dmg.spigotinventoryhelper; + +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoInteractions; +import static org.mockito.Mockito.when; + +import org.bukkit.block.Barrel; +import org.bukkit.block.Block; +import org.bukkit.block.Chest; +import org.bukkit.entity.Player; +import org.bukkit.event.block.Action; +import org.bukkit.event.player.PlayerInteractEvent; +import org.bukkit.inventory.DoubleChestInventory; +import org.bukkit.inventory.EquipmentSlot; +import org.bukkit.inventory.Inventory; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.PlayerInventory; +import org.junit.jupiter.api.Test; + +final class SortingStickListenerTest { + @Test + void sortsAChestWithoutOpeningIt() { + SortingStickItemFactory sticks = mock(SortingStickItemFactory.class); + InventorySortingService sorting = mock(InventorySortingService.class); + PlayerInteractEvent event = mock(PlayerInteractEvent.class); + Player player = mock(Player.class); + ItemStack stick = mock(ItemStack.class); + Block block = mock(Block.class); + Chest chest = mock(Chest.class); + Inventory inventory = mock(Inventory.class); + when(event.getHand()).thenReturn(EquipmentSlot.HAND); + when(event.getAction()).thenReturn(Action.RIGHT_CLICK_BLOCK); + when(event.getItem()).thenReturn(stick); + when(event.getPlayer()).thenReturn(player); + when(event.getClickedBlock()).thenReturn(block); + when(block.getState()).thenReturn(chest); + when(chest.getInventory()).thenReturn(inventory); + when(sticks.isSortingStick(stick)).thenReturn(true); + + new SortingStickListener(sticks, sorting).onInteract(event); + + verify(sorting).sortContainer(inventory); + verify(event).setCancelled(true); + } + + @Test + void sortsABarrelWithoutOpeningIt() { + SortingStickItemFactory sticks = mock(SortingStickItemFactory.class); + InventorySortingService sorting = mock(InventorySortingService.class); + PlayerInteractEvent event = mock(PlayerInteractEvent.class); + ItemStack stick = mock(ItemStack.class); + Block block = mock(Block.class); + Barrel barrel = mock(Barrel.class); + Inventory inventory = mock(Inventory.class); + when(event.getHand()).thenReturn(EquipmentSlot.HAND); + when(event.getAction()).thenReturn(Action.RIGHT_CLICK_BLOCK); + when(event.getItem()).thenReturn(stick); + when(event.getPlayer()).thenReturn(mock(Player.class)); + when(event.getClickedBlock()).thenReturn(block); + when(block.getState()).thenReturn(barrel); + when(barrel.getInventory()).thenReturn(inventory); + when(sticks.isSortingStick(stick)).thenReturn(true); + + new SortingStickListener(sticks, sorting).onInteract(event); + + verify(sorting).sortContainer(inventory); + verify(event).setCancelled(true); + } + + @Test + void refusesToSortALockedContainer() { + SortingStickItemFactory sticks = mock(SortingStickItemFactory.class); + InventorySortingService sorting = mock(InventorySortingService.class); + PlayerInteractEvent event = mock(PlayerInteractEvent.class); + ItemStack stick = mock(ItemStack.class); + Block block = mock(Block.class); + Chest chest = mock(Chest.class); + when(event.getHand()).thenReturn(EquipmentSlot.HAND); + when(event.getAction()).thenReturn(Action.RIGHT_CLICK_BLOCK); + when(event.getItem()).thenReturn(stick); + when(event.getPlayer()).thenReturn(mock(Player.class)); + when(event.getClickedBlock()).thenReturn(block); + when(block.getState()).thenReturn(chest); + when(chest.isLocked()).thenReturn(true); + when(sticks.isSortingStick(stick)).thenReturn(true); + + new SortingStickListener(sticks, sorting).onInteract(event); + + verifyNoInteractions(sorting); + verify(event).setCancelled(true); + } + + @Test + void sortsTheCombinedInventoryReturnedByEitherHalfOfADoubleChest() { + SortingStickItemFactory sticks = mock(SortingStickItemFactory.class); + InventorySortingService sorting = mock(InventorySortingService.class); + PlayerInteractEvent event = authenticBlockInteraction(sticks); + Block block = event.getClickedBlock(); + Chest chest = mock(Chest.class); + DoubleChestInventory combined = mock(DoubleChestInventory.class); + when(block.getState()).thenReturn(chest); + when(chest.getInventory()).thenReturn(combined); + + new SortingStickListener(sticks, sorting).onInteract(event); + + verify(sorting).sortContainer(combined); + } + + @Test + void rightClickingAirSortsOnlyThePlayerMainStorage() { + SortingStickItemFactory sticks = mock(SortingStickItemFactory.class); + InventorySortingService sorting = mock(InventorySortingService.class); + PlayerInteractEvent event = mock(PlayerInteractEvent.class); + Player player = mock(Player.class); + PlayerInventory inventory = mock(PlayerInventory.class); + ItemStack stick = mock(ItemStack.class); + when(event.getHand()).thenReturn(EquipmentSlot.HAND); + when(event.getAction()).thenReturn(Action.RIGHT_CLICK_AIR); + when(event.getItem()).thenReturn(stick); + when(event.getPlayer()).thenReturn(player); + when(player.getInventory()).thenReturn(inventory); + when(sticks.isSortingStick(stick)).thenReturn(true); + + new SortingStickListener(sticks, sorting).onInteract(event); + + verify(sorting).sortPlayerMainStorage(inventory); + verify(event).setCancelled(true); + } + + @Test + void respectsAnInteractionCancelledByAnotherPlugin() { + SortingStickItemFactory sticks = mock(SortingStickItemFactory.class); + InventorySortingService sorting = mock(InventorySortingService.class); + PlayerInteractEvent event = mock(PlayerInteractEvent.class); + when(event.isCancelled()).thenReturn(true); + + new SortingStickListener(sticks, sorting).onInteract(event); + + verifyNoInteractions(sticks, sorting); + verify(event, never()).setCancelled(true); + } + + @Test + void ignoresAnOrdinaryStick() { + SortingStickItemFactory sticks = mock(SortingStickItemFactory.class); + InventorySortingService sorting = mock(InventorySortingService.class); + PlayerInteractEvent event = mock(PlayerInteractEvent.class); + when(event.getHand()).thenReturn(EquipmentSlot.HAND); + when(event.getAction()).thenReturn(Action.RIGHT_CLICK_AIR); + when(event.getItem()).thenReturn(mock(ItemStack.class)); + + new SortingStickListener(sticks, sorting).onInteract(event); + + verifyNoInteractions(sorting); + verify(event, never()).setCancelled(true); + } + + private static PlayerInteractEvent authenticBlockInteraction( + SortingStickItemFactory sticks + ) { + PlayerInteractEvent event = mock(PlayerInteractEvent.class); + ItemStack stick = mock(ItemStack.class); + when(event.getHand()).thenReturn(EquipmentSlot.HAND); + when(event.getAction()).thenReturn(Action.RIGHT_CLICK_BLOCK); + when(event.getItem()).thenReturn(stick); + when(event.getPlayer()).thenReturn(mock(Player.class)); + when(event.getClickedBlock()).thenReturn(mock(Block.class)); + when(sticks.isSortingStick(stick)).thenReturn(true); + return event; + } +}