purpur-base/src/test/java/games/dmg/spigotbase/BaseTeleportManagerTest.java

package games.dmg.spigotbase;

import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;

import java.time.Clock;
import java.time.Duration;
import java.time.Instant;
import java.util.Optional;
import java.util.UUID;
import org.bukkit.ChatColor;
import org.bukkit.World;
import org.bukkit.entity.Player;
import org.bukkit.plugin.Plugin;
import org.junit.jupiter.api.Test;

final class BaseTeleportManagerTest {
    @org.junit.jupiter.params.ParameterizedTest
    @org.junit.jupiter.params.provider.CsvSource({
        "false,true,false", "true,true,false", "false,false,false", "true,false,false",
        "false,false,true", "true,false,true"
    })
    void particlesFollowHomeAndVisitorTeleportOutcome(boolean visit, boolean succeeds, boolean cancelled) {
        UUID id = UUID.randomUUID();
        UUID worldId = UUID.randomUUID();
        World world = mock(World.class);
        when(world.getUID()).thenReturn(worldId);
        org.bukkit.Location origin = new org.bukkit.Location(world, 0, 64, 0);
        org.bukkit.Location target = new org.bukkit.Location(world, 20, 64, 20);
        Player player = mock(Player.class);
        when(player.getUniqueId()).thenReturn(id);
        when(player.getName()).thenReturn("Player");
        when(player.getWorld()).thenReturn(world);
        when(player.getLocation()).thenReturn(origin);
        when(player.isOnline()).thenReturn(true);
        when(player.teleport(eq(target), any(org.bukkit.event.player.PlayerTeleportEvent.TeleportCause.class)))
            .thenReturn(succeeds);
        PlayerState owner = PlayerState.newPlayer(visit ? UUID.randomUUID() : id, "Owner")
            .withGrassAndDirtProgress(500, 4)
            .withBase(new BaseLocation(worldId, "world", 20, 64, 20, 0, 0), Instant.EPOCH)
            .withVisitorsEnabled(true);
        BaseStateManager states = mock(BaseStateManager.class);
        when(states.player(id, "Player")).thenReturn(owner);
        TeleportPolicy policy = mock(TeleportPolicy.class);
        when(policy.warmup(owner)).thenReturn(Duration.ofSeconds(1));
        when(policy.visitorWarmup(owner)).thenReturn(Duration.ofSeconds(1));
        when(policy.cooldown(owner)).thenReturn(Duration.ZERO);
        VisitorPolicy visitors = mock(VisitorPolicy.class);
        SafeBaseDestination finder = mock(SafeBaseDestination.class);
        when(finder.find(world, owner.base().orElseThrow())).thenReturn(Optional.of(target));
        TeleportParticles particles = mock(TeleportParticles.class);
        Plugin plugin = mock(Plugin.class);
        org.bukkit.scheduler.BukkitScheduler scheduler = mock(org.bukkit.scheduler.BukkitScheduler.class);
        when(scheduler.runTaskTimer(eq(plugin), any(Runnable.class), eq(0L), eq(20L)))
            .thenReturn(mock(org.bukkit.scheduler.BukkitTask.class));
        try (org.mockito.MockedStatic<org.bukkit.Bukkit> bukkit = org.mockito.Mockito.mockStatic(org.bukkit.Bukkit.class)) {
            bukkit.when(org.bukkit.Bukkit::getScheduler).thenReturn(scheduler);
            bukkit.when(() -> org.bukkit.Bukkit.getWorld(worldId)).thenReturn(world);
            BaseTeleportManager manager = new BaseTeleportManager(plugin, states, policy,
                visitors, finder, Clock.systemUTC(), particles);
            if (visit) manager.startVisit(player, owner); else manager.start(player);
            verify(particles).start(id, origin, 1);
            org.mockito.ArgumentCaptor<Runnable> tick = org.mockito.ArgumentCaptor.forClass(Runnable.class);
            verify(scheduler).runTaskTimer(eq(plugin), tick.capture(), eq(0L), eq(20L));
            tick.getValue().run();
            org.mockito.Mockito.verify(player, org.mockito.Mockito.never()).teleport(eq(target),
                any(org.bukkit.event.player.PlayerTeleportEvent.TeleportCause.class));
            if (cancelled) {
                org.bukkit.event.player.PlayerQuitEvent quit = mock(org.bukkit.event.player.PlayerQuitEvent.class);
                when(quit.getPlayer()).thenReturn(player);
                manager.onQuit(quit);
                verify(particles).cancel(id);
                org.mockito.Mockito.verify(particles, org.mockito.Mockito.never()).complete(id);
                org.mockito.Mockito.verify(states, org.mockito.Mockito.never()).saveIfDirty();
                manager.cancelAll();
                verify(particles).clear();
                return;
            }
            tick.getValue().run();
            if (succeeds) {
                verify(particles).complete(id);
                org.mockito.Mockito.verify(particles, org.mockito.Mockito.never()).cancel(id);
                verify(states).saveIfDirty();
            } else {
                verify(particles).cancel(id);
                org.mockito.Mockito.verify(particles, org.mockito.Mockito.never()).complete(id);
                org.mockito.Mockito.verify(states, org.mockito.Mockito.never()).saveIfDirty();
            }
            manager.cancelAll();
            verify(particles).clear();
        }
    }

    @Test
    void visitFromAnotherWorldIsRejectedBeforeWarmupAndCooldownChecks() {
        UUID visitorId = UUID.randomUUID();
        UUID ownerId = UUID.randomUUID();
        UUID baseWorldId = UUID.randomUUID();
        BaseStateManager stateManager = mock(BaseStateManager.class);
        TeleportPolicy teleportPolicy = mock(TeleportPolicy.class);
        VisitorPolicy visitorPolicy = mock(VisitorPolicy.class);
        Player visitor = mock(Player.class);
        World visitorWorld = mock(World.class);
        PlayerState owner = PlayerState.newPlayer(ownerId, "Owner")
            .withGrassAndDirtProgress(500, 4)
            .withBase(
                new BaseLocation(baseWorldId, "world", 0, 64, 0, 0, 0),
                Instant.EPOCH
            )
            .withVisitorsEnabled(true);
        PlayerState visitorState = PlayerState.newPlayer(visitorId, "Visitor");
        BaseTeleportManager manager = new BaseTeleportManager(
            mock(Plugin.class),
            stateManager,
            teleportPolicy,
            visitorPolicy,
            mock(SafeBaseDestination.class),
            Clock.systemUTC()
        );

        when(visitor.getUniqueId()).thenReturn(visitorId);
        when(visitor.getName()).thenReturn("Visitor");
        when(visitor.getWorld()).thenReturn(visitorWorld);
        when(visitorWorld.getUID()).thenReturn(UUID.randomUUID());
        when(stateManager.player(visitorId, "Visitor")).thenReturn(visitorState);
        when(visitorPolicy.remaining(eq(visitorState), eq(ownerId), any()))
            .thenReturn(Optional.of(Duration.ofSeconds(1)));

        manager.startVisit(visitor, owner);

        verify(visitor).sendMessage(
            ChatColor.RED + "You must be in the same dimension as that base to visit it."
        );
        verifyNoInteractions(stateManager, teleportPolicy, visitorPolicy);
    }
}