spigot-base/src/test/java/games/dmg/spigotbase/PocketBaseControllerTest.java

package games.dmg.spigotbase;

import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.time.Instant;
import java.util.HashSet;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.UUID;
import java.util.logging.Logger;
import org.bukkit.Material;
import org.bukkit.Server;
import org.bukkit.World;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.event.block.Action;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.inventory.ItemStack;
import org.junit.jupiter.api.Test;

final class PocketBaseControllerTest {
    @Test
    void ownerCanActivateCompleteFrameInsideNormalBase() throws Exception {
        UUID ownerId = UUID.randomUUID();
        UUID worldId = UUID.randomUUID();
        PocketPortalLocation portal = new PocketPortalLocation(
            worldId, "world", -2, 64, 0, PocketPortalAxis.X
        );
        Set<BlockPosition> frame = new HashSet<>(PocketPortalGeometry.frameBlocks(portal));
        Player owner = mock(Player.class);
        World world = mock(World.class);
        Block clicked = block(world, -2, 66, 0, Material.DIAMOND_BLOCK);
        PlayerInteractEvent event = mock(PlayerInteractEvent.class);
        BaseStateManager baseStates = mock(BaseStateManager.class);
        PocketBaseManager pocketBases = mock(PocketBaseManager.class);
        PluginSettings settings = PluginSettings.from(Map.of());
        PlayerState ownerState = PlayerState.newPlayer(ownerId, "Owner")
            .withAdministrativeLevels(4, 0, 0, 0, 0, false, false, true)
            .withBase(new BaseLocation(worldId, "world", 0, 64, 0, 0, 0), Instant.EPOCH);

        when(owner.getUniqueId()).thenReturn(ownerId);
        when(owner.getName()).thenReturn("Owner");
        when(event.getPlayer()).thenReturn(owner);
        when(event.getAction()).thenReturn(Action.RIGHT_CLICK_BLOCK);
        when(event.getClickedBlock()).thenReturn(clicked);
        when(event.getItem()).thenReturn(new ItemStack(Material.FLINT_AND_STEEL));
        when(world.getUID()).thenReturn(worldId);
        when(world.getName()).thenReturn("world");
        when(world.getBlockAt(anyInt(), anyInt(), anyInt())).thenAnswer(invocation -> {
            BlockPosition position = new BlockPosition(
                invocation.getArgument(0), invocation.getArgument(1), invocation.getArgument(2)
            );
            return block(
                world,
                position.x(),
                position.y(),
                position.z(),
                frame.contains(position) ? Material.DIAMOND_BLOCK : Material.AIR
            );
        });
        when(baseStates.player(ownerId, "Owner")).thenReturn(ownerState);
        when(pocketBases.state(ownerId)).thenReturn(
            new PocketBaseState(ownerId, 1, Optional.empty())
        );
        when(pocketBases.activateEntrance(ownerId, portal)).thenReturn(
            new PocketBaseState(ownerId, 1, Optional.of(portal))
        );
        PocketBaseController controller = new PocketBaseController(
            mock(Server.class),
            baseStates,
            new BaseBoundsService(settings),
            pocketBases,
            new PluginSettingsProvider(settings),
            Logger.getAnonymousLogger()
        );

        controller.onActivate(event);

        verify(pocketBases).activateEntrance(ownerId, portal);
        verify(event).setCancelled(true);
    }

    @Test
    void placementOutsideUnlockedPocketBoundaryIsCancelled() {
        UUID ownerId = UUID.randomUUID();
        UUID worldId = UUID.randomUUID();
        World world = mock(World.class);
        Block placed = block(world, 32, 65, 0, Material.STONE);
        Player player = mock(Player.class);
        BlockPlaceEvent event = mock(BlockPlaceEvent.class);
        PocketBaseManager pocketBases = mock(PocketBaseManager.class);
        PluginSettings settings = PluginSettings.from(Map.of());

        when(world.getUID()).thenReturn(worldId);
        when(event.getBlockPlaced()).thenReturn(placed);
        when(event.getPlayer()).thenReturn(player);
        when(pocketBases.ownerForPocketWorld(worldId)).thenReturn(Optional.of(ownerId));
        when(pocketBases.state(ownerId)).thenReturn(
            new PocketBaseState(ownerId, 1, Optional.empty())
        );
        when(pocketBases.policy()).thenReturn(new PocketBasePolicy(settings));
        PocketBaseController controller = new PocketBaseController(
            mock(Server.class),
            mock(BaseStateManager.class),
            new BaseBoundsService(settings),
            pocketBases,
            new PluginSettingsProvider(settings),
            Logger.getAnonymousLogger()
        );

        controller.onPlace(event);

        verify(event).setCancelled(true);
    }

    private static Block block(
        World world,
        int x,
        int y,
        int z,
        Material material
    ) {
        Block block = mock(Block.class);
        when(block.getWorld()).thenReturn(world);
        when(block.getX()).thenReturn(x);
        when(block.getY()).thenReturn(y);
        when(block.getZ()).thenReturn(z);
        when(block.getType()).thenReturn(material);
        return block;
    }
}