Meishin/LoginSystem
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Listener optimizations (#1884)

Browse Source 
* Drop CraftBukkit support, listeners cleanup

* Codestyle

* Codestyle

* Remove useless player.saveData() calls

* Micro optimization on the join process

* Requested changes

* Fix unit test

* Test onPlayerHeldItem listener

* Requested changes

* Remove unused import
This commit is contained in:
Gabriele C
2019-08-11 23:47:50 +02:00
committed by GitHub
parent e2f2ff0763
commit d30580d5d4
24 changed files with 498 additions and 557 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/test/java/fr/xephi/authme/listener/EntityListenerTest.java
-3
View File
@@ -1,6 +1,5 @@
package fr.xephi.authme.listener;
import fr.xephi.authme.ReflectionTestUtils;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import org.bukkit.entity.Projectile;
@@ -200,8 +199,6 @@ public class EntityListenerTest {
@Test
public void shouldHandleOldShooterMethod() {
// given
ReflectionTestUtils.setField(listener, "shooterIsLivingEntity", true);
ReflectionTestUtils.setField(listener, "getShooter", null);
Projectile projectile = mock(Projectile.class);
Player shooter = mock(Player.class);
given(projectile.getShooter()).willReturn(shooter);
src/test/java/fr/xephi/authme/listener/ListenerConsistencyTest.java
+2 -9
View File
@@ -1,8 +1,8 @@
package fr.xephi.authme.listener;
import com.google.common.collect.Sets;
import fr.xephi.authme.ClassCollector;
import fr.xephi.authme.TestHelper;
import org.bukkit.event.Cancellable;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
@@ -27,13 +27,6 @@ public final class ListenerConsistencyTest {
private static List<Class<? extends Listener>> classes;
private static final Set<String> CANCELED_EXCEPTIONS = Sets.newHashSet(
"PlayerListener#onPlayerJoin", "PlayerListener#onPlayerLogin",
"PlayerListener#onPlayerQuit", "ServerListener#onPluginDisable",
"ServerListener#onServerPing", "ServerListener#onPluginEnable",
"PlayerListener#onJoinMessage", "PlayerListener#onAsyncPlayerPreLoginEvent",
"PlayerListener19Spigot#onPlayerSpawn");
@BeforeClass
public static void collectListenerClasses() {
ClassCollector collector = new ClassCollector(TestHelper.SOURCES_FOLDER, TestHelper.PROJECT_ROOT + "listener");
@@ -84,7 +77,7 @@ public final class ListenerConsistencyTest {
Method[] methods = listenerClass.getDeclaredMethods();
for (Method method : methods) {
if (isTestableMethod(method) && method.isAnnotationPresent(EventHandler.class)) {
if (CANCELED_EXCEPTIONS.contains(clazz + "#" + method.getName())) {
if (!method.getParameterTypes()[0].isAssignableFrom(Cancellable.class)) {
continue;
}
src/test/java/fr/xephi/authme/listener/OnJoinVerifierTest.java
+24 -24
View File
@@ -374,27 +374,27 @@ public class OnJoinVerifierTest {
@Test
public void shouldAllowUser() throws FailedVerificationException {
// given
JoiningPlayer joiningPlayer = JoiningPlayer.fromName("Bobby");
String name = "Bobby";
boolean isAuthAvailable = false;
given(permissionsManager.hasPermission(joiningPlayer, PlayerStatePermission.BYPASS_ANTIBOT)).willReturn(false);
given(permissionsManager.hasPermissionOffline(name, PlayerStatePermission.BYPASS_ANTIBOT)).willReturn(false);
given(antiBotService.shouldKick()).willReturn(false);
// when
onJoinVerifier.checkAntibot(joiningPlayer, isAuthAvailable);
onJoinVerifier.checkAntibot(name, isAuthAvailable);
// then
verify(permissionsManager).hasPermission(joiningPlayer, PlayerStatePermission.BYPASS_ANTIBOT);
verify(permissionsManager).hasPermissionOffline(name, PlayerStatePermission.BYPASS_ANTIBOT);
verify(antiBotService).shouldKick();
}
@Test
public void shouldAllowUserWithAuth() throws FailedVerificationException {
// given
JoiningPlayer joiningPlayer = JoiningPlayer.fromName("Lacey");
String name = "Lacey";
boolean isAuthAvailable = true;
// when
onJoinVerifier.checkAntibot(joiningPlayer, isAuthAvailable);
onJoinVerifier.checkAntibot(name, isAuthAvailable);
// then
verifyZeroInteractions(permissionsManager, antiBotService);
@@ -403,32 +403,32 @@ public class OnJoinVerifierTest {
@Test
public void shouldAllowUserWithBypassPermission() throws FailedVerificationException {
// given
JoiningPlayer joiningPlayer = JoiningPlayer.fromName("Steward");
String name = "Steward";
boolean isAuthAvailable = false;
given(permissionsManager.hasPermission(joiningPlayer, PlayerStatePermission.BYPASS_ANTIBOT)).willReturn(true);
given(permissionsManager.hasPermissionOffline(name, PlayerStatePermission.BYPASS_ANTIBOT)).willReturn(true);
// when
onJoinVerifier.checkAntibot(joiningPlayer, isAuthAvailable);
onJoinVerifier.checkAntibot(name, isAuthAvailable);
// then
verify(permissionsManager).hasPermission(joiningPlayer, PlayerStatePermission.BYPASS_ANTIBOT);
verify(permissionsManager).hasPermissionOffline(name, PlayerStatePermission.BYPASS_ANTIBOT);
verifyZeroInteractions(antiBotService);
}
@Test
public void shouldKickUserForFailedAntibotCheck() throws FailedVerificationException {
public void shouldKickUserForFailedAntibotCheck() {
// given
JoiningPlayer joiningPlayer = JoiningPlayer.fromName("D3");
String name = "D3";
boolean isAuthAvailable = false;
given(permissionsManager.hasPermission(joiningPlayer, PlayerStatePermission.BYPASS_ANTIBOT)).willReturn(false);
given(permissionsManager.hasPermissionOffline(name, PlayerStatePermission.BYPASS_ANTIBOT)).willReturn(false);
given(antiBotService.shouldKick()).willReturn(true);
// when / then
try {
onJoinVerifier.checkAntibot(joiningPlayer, isAuthAvailable);
onJoinVerifier.checkAntibot(name, isAuthAvailable);
fail("Expected exception to be thrown");
} catch (FailedVerificationException e) {
verify(permissionsManager).hasPermission(joiningPlayer, PlayerStatePermission.BYPASS_ANTIBOT);
verify(permissionsManager).hasPermissionOffline(name, PlayerStatePermission.BYPASS_ANTIBOT);
verify(antiBotService).shouldKick();
}
@@ -439,18 +439,18 @@ public class OnJoinVerifierTest {
*/
@Test
public void shouldNotCheckCountry() throws FailedVerificationException {
JoiningPlayer joiningPlayer = JoiningPlayer.fromName("david");
String name = "david";
String ip = "127.0.0.1";
// protection setting disabled
given(settings.getProperty(ProtectionSettings.ENABLE_PROTECTION)).willReturn(false);
given(settings.getProperty(ProtectionSettings.ENABLE_PROTECTION_REGISTERED)).willReturn(true);
onJoinVerifier.checkPlayerCountry(joiningPlayer, ip, false);
onJoinVerifier.checkPlayerCountry(name, ip, false);
verifyZeroInteractions(validationService);
// protection for registered players disabled
given(settings.getProperty(ProtectionSettings.ENABLE_PROTECTION_REGISTERED)).willReturn(false);
onJoinVerifier.checkPlayerCountry(joiningPlayer, ip, true);
onJoinVerifier.checkPlayerCountry(name, ip, true);
verifyZeroInteractions(validationService);
}
@@ -458,12 +458,12 @@ public class OnJoinVerifierTest {
public void shouldCheckAndAcceptUnregisteredPlayerCountry() throws FailedVerificationException {
// given
String ip = "192.168.0.1";
JoiningPlayer joiningPlayer = JoiningPlayer.fromName("lucas");
String name = "lucas";
given(settings.getProperty(ProtectionSettings.ENABLE_PROTECTION)).willReturn(true);
given(validationService.isCountryAdmitted(ip)).willReturn(true);
// when
onJoinVerifier.checkPlayerCountry(joiningPlayer, ip, false);
onJoinVerifier.checkPlayerCountry(name, ip, false);
// then
verify(validationService).isCountryAdmitted(ip);
@@ -473,13 +473,13 @@ public class OnJoinVerifierTest {
public void shouldCheckAndAcceptRegisteredPlayerCountry() throws FailedVerificationException {
// given
String ip = "192.168.10.24";
JoiningPlayer joiningPlayer = JoiningPlayer.fromName("gabriel");
String name = "gabriel";
given(settings.getProperty(ProtectionSettings.ENABLE_PROTECTION)).willReturn(true);
given(settings.getProperty(ProtectionSettings.ENABLE_PROTECTION_REGISTERED)).willReturn(true);
given(validationService.isCountryAdmitted(ip)).willReturn(true);
// when
onJoinVerifier.checkPlayerCountry(joiningPlayer, ip, true);
onJoinVerifier.checkPlayerCountry(name, ip, true);
// then
verify(validationService).isCountryAdmitted(ip);
@@ -489,7 +489,7 @@ public class OnJoinVerifierTest {
public void shouldThrowForBannedCountry() throws FailedVerificationException {
// given
String ip = "192.168.40.0";
JoiningPlayer joiningPlayer = JoiningPlayer.fromName("bob");
String name = "bob";
given(settings.getProperty(ProtectionSettings.ENABLE_PROTECTION)).willReturn(true);
given(validationService.isCountryAdmitted(ip)).willReturn(false);
@@ -497,7 +497,7 @@ public class OnJoinVerifierTest {
expectValidationExceptionWith(MessageKey.COUNTRY_BANNED_ERROR);
// when
onJoinVerifier.checkPlayerCountry(joiningPlayer, ip, false);
onJoinVerifier.checkPlayerCountry(name, ip, false);
}
private void expectValidationExceptionWith(MessageKey messageKey, String... args) {
src/test/java/fr/xephi/authme/listener/PlayerListenerTest.java
+181 -26
View File
@@ -1,6 +1,5 @@
package fr.xephi.authme.listener;
import fr.xephi.authme.TestHelper;
import fr.xephi.authme.data.QuickCommandsProtectionManager;
import fr.xephi.authme.data.auth.PlayerAuth;
import fr.xephi.authme.datasource.DataSource;
@@ -29,6 +28,7 @@ import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.event.inventory.InventoryOpenEvent;
import org.bukkit.event.player.AsyncPlayerChatEvent;
import org.bukkit.event.player.AsyncPlayerPreLoginEvent;
import org.bukkit.event.player.PlayerBedEnterEvent;
import org.bukkit.event.player.PlayerCommandPreprocessEvent;
import org.bukkit.event.player.PlayerDropItemEvent;
@@ -38,12 +38,14 @@ import org.bukkit.event.player.PlayerInteractAtEntityEvent;
import org.bukkit.event.player.PlayerInteractEntityEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.event.player.PlayerItemConsumeEvent;
import org.bukkit.event.player.PlayerItemHeldEvent;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerKickEvent;
import org.bukkit.event.player.PlayerLoginEvent;
import org.bukkit.event.player.PlayerMoveEvent;
import org.bukkit.event.player.PlayerPickupItemEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.event.player.PlayerRespawnEvent;
import org.bukkit.event.player.PlayerShearEntityEvent;
import org.bukkit.inventory.InventoryView;
import org.junit.Test;
@@ -58,6 +60,7 @@ import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.UUID;
import static com.google.common.collect.Sets.newHashSet;
import static fr.xephi.authme.listener.EventCancelVerifier.withServiceMock;
@@ -71,7 +74,6 @@ import static org.junit.Assert.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.atLeast;
import static org.mockito.Mockito.doThrow;
@@ -188,7 +190,8 @@ public class PlayerListenerTest {
.check(listener::onPlayerConsumeItem, PlayerItemConsumeEvent.class)
.check(listener::onPlayerInteract, PlayerInteractEvent.class)
.check(listener::onPlayerPickupItem, PlayerPickupItemEvent.class)
.check(listener::onPlayerInteractEntity, PlayerInteractEntityEvent.class);
.check(listener::onPlayerInteractEntity, PlayerInteractEntityEvent.class)
.check(listener::onPlayerHeldItem, PlayerItemHeldEvent.class);
}
@Test
@@ -536,6 +539,98 @@ public class PlayerListenerTest {
verifyNoModifyingCalls(event);
}
@Test
public void shouldIgnorePlayerRespawnWithNoTeleport() {
// given
Player player = mock(Player.class);
Location respawnLocation = mock(Location.class);
PlayerRespawnEvent event = spy(new PlayerRespawnEvent(player, respawnLocation, false));
given(settings.getProperty(RestrictionSettings.NO_TELEPORT)).willReturn(true);
// when
listener.onPlayerRespawn(event);
// then
verifyZeroInteractions(listenerService);
verify(event, never()).setRespawnLocation(any());
}
@Test
public void shouldIgnorePlayerRespawn() {
// given
Player player = mock(Player.class);
Location respawnLocation = mock(Location.class);
PlayerRespawnEvent event = spy(new PlayerRespawnEvent(player, respawnLocation, false));
given(settings.getProperty(RestrictionSettings.NO_TELEPORT)).willReturn(false);
given(listenerService.shouldCancelEvent(event)).willReturn(false);
// when
listener.onPlayerRespawn(event);
// then
verifyZeroInteractions(spawnLoader);
verify(event, never()).setRespawnLocation(any());
}
@Test
public void shouldHandlePlayerRespawn() {
// given
Player player = mock(Player.class);
Location originalLocation = mock(Location.class);
Location newLocation = mock(Location.class);
World world = mock(World.class);
given(newLocation.getWorld()).willReturn(world);
PlayerRespawnEvent event = spy(new PlayerRespawnEvent(player, originalLocation, false));
given(settings.getProperty(RestrictionSettings.NO_TELEPORT)).willReturn(false);
given(listenerService.shouldCancelEvent(event)).willReturn(true);
given(spawnLoader.getSpawnLocation(player)).willReturn(newLocation);
// when
listener.onPlayerRespawn(event);
// then
verify(spawnLoader).getSpawnLocation(player);
verify(event).setRespawnLocation(newLocation);
}
@Test
public void shouldIgnorePlayerRespawnUnloadedWorld() {
// given
Player player = mock(Player.class);
Location originalLocation = mock(Location.class);
Location newLocation = mock(Location.class);
given(newLocation.getWorld()).willReturn(null);
PlayerRespawnEvent event = spy(new PlayerRespawnEvent(player, originalLocation, false));
given(settings.getProperty(RestrictionSettings.NO_TELEPORT)).willReturn(false);
given(listenerService.shouldCancelEvent(event)).willReturn(true);
given(spawnLoader.getSpawnLocation(player)).willReturn(newLocation);
// when
listener.onPlayerRespawn(event);
// then
verify(spawnLoader).getSpawnLocation(player);
verify(event, never()).setRespawnLocation(any());
}
@Test
public void shouldHandlePlayerRespawnNoChanges() {
// given
Player player = mock(Player.class);
Location originalLocation = mock(Location.class);
PlayerRespawnEvent event = spy(new PlayerRespawnEvent(player, originalLocation, false));
given(settings.getProperty(RestrictionSettings.NO_TELEPORT)).willReturn(false);
given(listenerService.shouldCancelEvent(event)).willReturn(true);
given(spawnLoader.getSpawnLocation(player)).willReturn(null);
// when
listener.onPlayerRespawn(event);
// then
verify(spawnLoader).getSpawnLocation(player);
verify(event, never()).setRespawnLocation(any());
}
@Test
public void shouldHandlePlayerJoining() {
// given
@@ -606,60 +701,113 @@ public class PlayerListenerTest {
}
@Test
public void shouldPerformAllJoinVerificationsSuccessfully() throws FailedVerificationException {
public void shouldPerformAllJoinVerificationsSuccessfullyPreLoginLowest() throws FailedVerificationException {
// given
String name = "someone";
UUID uniqueId = UUID.fromString("753493c9-33ba-4a4a-bf61-1bce9d3c9a71");
String ip = "12.34.56.78";
AsyncPlayerPreLoginEvent preLoginEvent = spy(new AsyncPlayerPreLoginEvent(name, mockAddrWithIp(ip), uniqueId));
given(validationService.isUnrestricted(name)).willReturn(false);
// when
listener.onAsyncPlayerPreLoginEventLowest(preLoginEvent);
// then
verify(validationService).isUnrestricted(name);
verify(onJoinVerifier).checkSingleSession(name);
verify(onJoinVerifier).checkIsValidName(name);
verifyZeroInteractions(dataSource);
verifyNoModifyingCalls(preLoginEvent);
}
@Test
public void shouldKickPreLoginLowestUnresolvedHostname() throws FailedVerificationException {
// given
String name = "someone";
UUID uniqueId = UUID.fromString("753493c9-33ba-4a4a-bf61-1bce9d3c9a71");
@SuppressWarnings("ConstantConditions")
AsyncPlayerPreLoginEvent preLoginEvent = spy(new AsyncPlayerPreLoginEvent(name, null, uniqueId));
given(messages.retrieveSingle(name, MessageKey.KICK_UNRESOLVED_HOSTNAME)).willReturn("Unresolved hostname");
// when
listener.onAsyncPlayerPreLoginEventLowest(preLoginEvent);
// then
verify(preLoginEvent).disallow(AsyncPlayerPreLoginEvent.Result.KICK_OTHER, "Unresolved hostname");
verifyNoMoreInteractions(onJoinVerifier);
}
@Test
public void shouldPerformAllJoinVerificationsSuccessfullyPreLoginHighest() throws FailedVerificationException {
// given
String name = "someone";
UUID uniqueId = UUID.fromString("753493c9-33ba-4a4a-bf61-1bce9d3c9a71");
String ip = "12.34.56.78";
AsyncPlayerPreLoginEvent preLoginEvent = spy(new AsyncPlayerPreLoginEvent(name, mockAddrWithIp(ip), uniqueId));
given(validationService.isUnrestricted(name)).willReturn(false);
PlayerAuth auth = PlayerAuth.builder().name(name).build();
given(dataSource.getAuth(name)).willReturn(auth);
// when
listener.onAsyncPlayerPreLoginEventHighest(preLoginEvent);
// then
verify(validationService).isUnrestricted(name);
verify(onJoinVerifier).checkKickNonRegistered(true);
verify(onJoinVerifier).checkAntibot(name, true);
verify(onJoinVerifier).checkNameCasing(name, auth);
verify(onJoinVerifier).checkPlayerCountry(name, ip, true);
verifyNoModifyingCalls(preLoginEvent);
}
@Test
public void shouldPerformAllJoinVerificationsSuccessfullyLogin() {
// given
String name = "someone";
Player player = mockPlayerWithName(name);
String ip = "12.34.56.78";
PlayerLoginEvent event = spy(new PlayerLoginEvent(player, "", mockAddrWithIp(ip)));
PlayerLoginEvent loginEvent = spy(new PlayerLoginEvent(player, "", mockAddrWithIp(ip)));
given(validationService.isUnrestricted(name)).willReturn(false);
given(onJoinVerifier.refusePlayerForFullServer(event)).willReturn(false);
PlayerAuth auth = PlayerAuth.builder().name(name).build();
given(dataSource.getAuth(name)).willReturn(auth);
given(onJoinVerifier.refusePlayerForFullServer(loginEvent)).willReturn(false);
// when
listener.onPlayerLogin(event);
listener.onPlayerLogin(loginEvent);
// then
verify(validationService).isUnrestricted(name);
verify(onJoinVerifier).refusePlayerForFullServer(event);
verify(onJoinVerifier).checkSingleSession(name);
verify(onJoinVerifier).checkIsValidName(name);
verify(onJoinVerifier).checkAntibot(any(JoiningPlayer.class), eq(true));
verify(onJoinVerifier).checkKickNonRegistered(true);
verify(onJoinVerifier).checkNameCasing(name, auth);
verify(onJoinVerifier).checkPlayerCountry(any(JoiningPlayer.class), eq(ip), eq(true));
verifyNoModifyingCalls(event);
verify(onJoinVerifier).refusePlayerForFullServer(loginEvent);
verifyZeroInteractions(dataSource);
verifyNoModifyingCalls(loginEvent);
}
@Test
public void shouldAbortPlayerJoinForInvalidName() throws FailedVerificationException {
// given
String name = "inval!dName";
Player player = mockPlayerWithName(name);
TestHelper.mockPlayerIp(player, "33.32.33.33");
PlayerLoginEvent event = spy(new PlayerLoginEvent(player, "", player.getAddress().getAddress()));
UUID uniqueId = UUID.fromString("753493c9-33ba-4a4a-bf61-1bce9d3c9a71");
InetAddress ip = mockAddrWithIp("33.32.33.33");
AsyncPlayerPreLoginEvent event = spy(new AsyncPlayerPreLoginEvent(name, ip, uniqueId));
given(validationService.isUnrestricted(name)).willReturn(false);
given(onJoinVerifier.refusePlayerForFullServer(event)).willReturn(false);
FailedVerificationException exception = new FailedVerificationException(
MessageKey.INVALID_NAME_CHARACTERS, "[a-z]");
doThrow(exception).when(onJoinVerifier).checkIsValidName(name);
String message = "Invalid characters!";
given(messages.retrieveSingle(player, exception.getReason(), exception.getArgs())).willReturn(message);
given(messages.retrieveSingle(name, exception.getReason(), exception.getArgs())).willReturn(message);
// when
listener.onPlayerLogin(event);
listener.onAsyncPlayerPreLoginEventLowest(event);
// then
verify(validationService).isUnrestricted(name);
verify(onJoinVerifier).refusePlayerForFullServer(event);
verify(onJoinVerifier).checkSingleSession(name);
verify(onJoinVerifier).checkIsValidName(name);
// Check that we don't talk with the data source before performing checks that don't require it
verifyZeroInteractions(dataSource);
verify(event).setKickMessage(message);
verify(event).setResult(PlayerLoginEvent.Result.KICK_OTHER);
verify(event).setLoginResult(AsyncPlayerPreLoginEvent.Result.KICK_OTHER);
}
@Test
@@ -950,6 +1098,13 @@ public class PlayerListenerTest {
verifyNoMoreInteractions(event);
}
private static void verifyNoModifyingCalls(AsyncPlayerPreLoginEvent event) {
verify(event, atLeast(0)).getLoginResult();
verify(event, atLeast(0)).getAddress();
verify(event, atLeast(0)).getName();
verifyNoMoreInteractions(event);
}
private static InetAddress mockAddrWithIp(String ip) {
InetAddress addr = mock(InetAddress.class);
given(addr.getHostAddress()).willReturn(ip);
src/test/java/fr/xephi/authme/listener/ServerListenerTest.java
-13
View File
@@ -81,19 +81,6 @@ public class ServerListenerTest {
checkDisableHandling("UnknownPlugin", () -> verifyZeroInteractions(pluginHookService, spawnLoader));
}
@Test
public void shouldHandlePluginWithNullName() {
PluginEnableEvent enableEvent = mock(PluginEnableEvent.class);
given(enableEvent.getPlugin()).willReturn(null);
serverListener.onPluginEnable(enableEvent);
verifyNoMoreInteractionsAndReset();
PluginDisableEvent disableEvent = mock(PluginDisableEvent.class);
given(disableEvent.getPlugin()).willReturn(null);
serverListener.onPluginDisable(disableEvent);
verifyNoMoreInteractionsAndReset();
}
private void checkEnableHandling(String pluginName, Runnable verifier) {
PluginEnableEvent event = mockEventWithPluginName(PluginEnableEvent.class, pluginName);
serverListener.onPluginEnable(event);
src/test/java/fr/xephi/authme/permission/PermissionsManagerTest.java
-28
View File
@@ -1,6 +1,5 @@
package fr.xephi.authme.permission;
import fr.xephi.authme.listener.JoiningPlayer;
import org.bukkit.Server;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@@ -13,13 +12,8 @@ import org.mockito.junit.MockitoJUnitRunner;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
/**
* Test for {@link PermissionsManager}.
@@ -154,26 +148,4 @@ public class PermissionsManagerTest {
// then
assertThat(result, equalTo(true));
}
@Test
public void shouldHandleJoiningPlayerPermissionChecksWithProperMethod() {
// given
Player player = mock(Player.class);
JoiningPlayer fromPlayer = JoiningPlayer.fromPlayerObject(player);
JoiningPlayer fromName = JoiningPlayer.fromName("Chris");
PermissionsManager permManagerSpy = spy(permissionsManager);
given(permManagerSpy.hasPermission(any(Player.class), eq(PlayerPermission.LOGIN))).willReturn(true);
given(permManagerSpy.hasPermissionOffline(anyString(), eq(PlayerPermission.UNREGISTER))).willReturn(true);
// when
boolean resultFromPlayer = permManagerSpy.hasPermission(fromPlayer, PlayerPermission.LOGIN);
boolean resultFromName = permManagerSpy.hasPermission(fromName, PlayerPermission.UNREGISTER);
// then
assertThat(resultFromPlayer, equalTo(true));
assertThat(resultFromName, equalTo(true));
verify(permManagerSpy).hasPermission(player, PlayerPermission.LOGIN);
verify(permManagerSpy).hasPermissionOffline(fromName.getName(), PlayerPermission.UNREGISTER);
}
}