diff --git a/src/main/java/fr/xephi/authme/api/NewAPI.java b/src/main/java/fr/xephi/authme/api/NewAPI.java index 7acff0996..dea31c90f 100644 --- a/src/main/java/fr/xephi/authme/api/NewAPI.java +++ b/src/main/java/fr/xephi/authme/api/NewAPI.java @@ -30,19 +30,21 @@ public class NewAPI { private final PasswordSecurity passwordSecurity; private final Management management; private final ValidationService validationService; + private final PlayerCache playerCache; /* * Constructor for NewAPI. */ @Inject NewAPI(AuthMe plugin, PluginHooks pluginHooks, DataSource dataSource, PasswordSecurity passwordSecurity, - Management management, ValidationService validationService) { + Management management, ValidationService validationService, PlayerCache playerCache) { this.plugin = plugin; this.pluginHooks = pluginHooks; this.dataSource = dataSource; this.passwordSecurity = passwordSecurity; this.management = management; this.validationService = validationService; + this.playerCache = playerCache; NewAPI.singleton = this; } @@ -86,7 +88,7 @@ public class NewAPI { * @return true if the player is authenticated */ public boolean isAuthenticated(Player player) { - return PlayerCache.getInstance().isAuthenticated(player.getName()); + return playerCache.isAuthenticated(player.getName()); } /** @@ -112,13 +114,13 @@ public class NewAPI { } /** - * Get the last location of a player. + * Get the last location of an online player. * * @param player The player to process * @return Location The location of the player */ public Location getLastLocation(Player player) { - PlayerAuth auth = PlayerCache.getInstance().getAuth(player.getName()); + PlayerAuth auth = playerCache.getAuth(player.getName()); if (auth != null) { return new Location(Bukkit.getWorld(auth.getWorld()), auth.getQuitLocX(), auth.getQuitLocY(), auth.getQuitLocZ()); } @@ -144,7 +146,7 @@ public class NewAPI { * @return true if the password is correct, false otherwise */ public boolean checkPassword(String playerName, String passwordToCheck) { - return isRegistered(playerName) && passwordSecurity.comparePassword(passwordToCheck, playerName); + return passwordSecurity.comparePassword(passwordToCheck, playerName); } /** diff --git a/src/test/java/fr/xephi/authme/api/NewAPITest.java b/src/test/java/fr/xephi/authme/api/NewAPITest.java new file mode 100644 index 000000000..6ef096a2b --- /dev/null +++ b/src/test/java/fr/xephi/authme/api/NewAPITest.java @@ -0,0 +1,183 @@ +package fr.xephi.authme.api; + +import fr.xephi.authme.AuthMe; +import fr.xephi.authme.ReflectionTestUtils; +import fr.xephi.authme.cache.auth.PlayerAuth; +import fr.xephi.authme.cache.auth.PlayerCache; +import fr.xephi.authme.datasource.DataSource; +import fr.xephi.authme.hooks.PluginHooks; +import fr.xephi.authme.process.Management; +import fr.xephi.authme.security.PasswordSecurity; +import fr.xephi.authme.util.ValidationService; +import org.bukkit.Bukkit; +import org.bukkit.Location; +import org.bukkit.Server; +import org.bukkit.World; +import org.bukkit.entity.Player; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.runners.MockitoJUnitRunner; + +import static org.hamcrest.Matchers.equalTo; +import static org.hamcrest.Matchers.not; +import static org.hamcrest.Matchers.nullValue; +import static org.hamcrest.Matchers.sameInstance; +import static org.junit.Assert.assertThat; +import static org.mockito.BDDMockito.given; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; + +/** + * Test for {@link NewAPI}. + */ +@RunWith(MockitoJUnitRunner.class) +public class NewAPITest { + + @InjectMocks + private NewAPI api; + + @Mock + private AuthMe authMe; + @Mock + private PluginHooks pluginHooks; + @Mock + private ValidationService validationService; + @Mock + private DataSource dataSource; + @Mock + private Management management; + @Mock + private PasswordSecurity passwordSecurity; + @Mock + private PlayerCache playerCache; + + @Test + public void shouldReturnInstanceOrNull() { + NewAPI result = NewAPI.getInstance(); + assertThat(result, sameInstance(api)); + + ReflectionTestUtils.setField(NewAPI.class, null, "singleton", null); + assertThat(NewAPI.getInstance(), nullValue()); + } + + @Test + public void shouldReturnIfPlayerIsAuthenticated() { + // given + String name = "Bobby"; + Player player = mockPlayerWithName(name); + given(playerCache.isAuthenticated(name)).willReturn(true); + + // when + boolean result = api.isAuthenticated(player); + + // then + verify(playerCache).isAuthenticated(name); + assertThat(result, equalTo(true)); + } + + @Test + public void shouldReturnIfPlayerIsNpc() { + // given + Player player = mock(Player.class); + given(pluginHooks.isNpc(player)).willReturn(true); + + // when + boolean result = api.isNPC(player); + + // then + assertThat(result, equalTo(true)); + } + + @Test + public void shouldReturnIfPlayerIsUnrestricted() { + // given + String name = "Tester"; + Player player = mockPlayerWithName(name); + given(validationService.isUnrestricted(name)).willReturn(true); + + // when + boolean result = api.isUnrestricted(player); + + // then + verify(validationService).isUnrestricted(name); + assertThat(result, equalTo(true)); + } + + @Test + public void shouldGetLastLocation() { + // given + String name = "Gary"; + Player player = mockPlayerWithName(name); + PlayerAuth auth = PlayerAuth.builder().name(name) + .locWorld("world") + .locX(12.4) + .locY(24.6) + .locZ(-438.2) + .build(); + given(playerCache.getAuth(name)).willReturn(auth); + Server server = mock(Server.class); + ReflectionTestUtils.setField(Bukkit.class, null, "server", server); + World world = mock(World.class); + given(server.getWorld(auth.getWorld())).willReturn(world); + + // when + Location result = api.getLastLocation(player); + + // then + assertThat(result, not(nullValue())); + assertThat(result.getX(), equalTo(auth.getQuitLocX())); + assertThat(result.getY(), equalTo(auth.getQuitLocY())); + assertThat(result.getZ(), equalTo(auth.getQuitLocZ())); + assertThat(result.getWorld(), equalTo(world)); + } + + @Test + public void shouldReturnNullForUnavailablePlayer() { + // given + String name = "Numan"; + Player player = mockPlayerWithName(name); + given(playerCache.getAuth(name)).willReturn(null); + + // when + Location result = api.getLastLocation(player); + + // then + assertThat(result, nullValue()); + } + + @Test + public void shouldCheckForRegisteredName() { + // given + String name = "toaster"; + given(dataSource.isAuthAvailable(name)).willReturn(true); + + // when + boolean result = api.isRegistered(name); + + // then + assertThat(result, equalTo(true)); + } + + @Test + public void shouldCheckPassword() { + // given + String playerName = "Robert"; + String password = "someSecretPhrase2983"; + given(passwordSecurity.comparePassword(password, playerName)).willReturn(true); + + // when + boolean result = api.checkPassword(playerName, password); + + // then + verify(passwordSecurity).comparePassword(password, playerName); + assertThat(result, equalTo(true)); + } + + private static Player mockPlayerWithName(String name) { + Player player = mock(Player.class); + given(player.getName()).willReturn(name); + return player; + } +}