521 lines
15 KiB
Java
521 lines
15 KiB
Java
package fr.xephi.authme.api.v3;
|
|
|
|
import fr.xephi.authme.AuthMe;
|
|
import fr.xephi.authme.ReflectionTestUtils;
|
|
import fr.xephi.authme.data.auth.PlayerAuth;
|
|
import fr.xephi.authme.data.auth.PlayerCache;
|
|
import fr.xephi.authme.datasource.DataSource;
|
|
import fr.xephi.authme.process.Management;
|
|
import fr.xephi.authme.process.register.executors.ApiPasswordRegisterParams;
|
|
import fr.xephi.authme.process.register.executors.RegistrationMethod;
|
|
import fr.xephi.authme.security.PasswordSecurity;
|
|
import fr.xephi.authme.security.crypts.HashedPassword;
|
|
import fr.xephi.authme.service.GeoIpService;
|
|
import fr.xephi.authme.service.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.ArgumentCaptor;
|
|
import org.mockito.InjectMocks;
|
|
import org.mockito.Mock;
|
|
import org.mockito.junit.MockitoJUnitRunner;
|
|
|
|
import java.util.Arrays;
|
|
import java.util.Date;
|
|
import java.util.List;
|
|
import java.util.stream.Collectors;
|
|
import java.time.Instant;
|
|
|
|
import static fr.xephi.authme.IsEqualByReflectionMatcher.isEqualTo;
|
|
import static org.hamcrest.Matchers.contains;
|
|
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.ArgumentMatchers.any;
|
|
import static org.mockito.ArgumentMatchers.eq;
|
|
import static org.mockito.BDDMockito.given;
|
|
import static org.mockito.Mockito.mock;
|
|
import static org.mockito.Mockito.only;
|
|
import static org.mockito.Mockito.verify;
|
|
import static org.mockito.Mockito.verifyZeroInteractions;
|
|
import static org.mockito.hamcrest.MockitoHamcrest.argThat;
|
|
|
|
/**
|
|
* Test for {@link AuthMeApi}.
|
|
*/
|
|
@RunWith(MockitoJUnitRunner.class)
|
|
public class AuthMeApiTest {
|
|
|
|
@InjectMocks
|
|
private AuthMeApi api;
|
|
|
|
@Mock
|
|
private ValidationService validationService;
|
|
@Mock
|
|
private DataSource dataSource;
|
|
@Mock
|
|
private Management management;
|
|
@Mock
|
|
private PasswordSecurity passwordSecurity;
|
|
@Mock
|
|
private PlayerCache playerCache;
|
|
@Mock
|
|
private AuthMe authMe;
|
|
@Mock
|
|
private GeoIpService geoIpService;
|
|
|
|
@Test
|
|
public void shouldReturnInstanceOrNull() {
|
|
AuthMeApi result = AuthMeApi.getInstance();
|
|
assertThat(result, sameInstance(api));
|
|
|
|
ReflectionTestUtils.setField(AuthMeApi.class, null, "singleton", null);
|
|
assertThat(AuthMeApi.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(player.hasMetadata("NPC")).willReturn(true);
|
|
|
|
// when
|
|
boolean result = api.isNpc(player);
|
|
|
|
// then
|
|
assertThat(result, equalTo(true));
|
|
verify(player).hasMetadata("NPC");
|
|
}
|
|
|
|
@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)
|
|
.locYaw(3.41f)
|
|
.locPitch(0.29f)
|
|
.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));
|
|
assertThat(result.getYaw(), equalTo(auth.getYaw()));
|
|
assertThat(result.getPitch(), equalTo(auth.getPitch()));
|
|
}
|
|
|
|
@Test
|
|
public void shouldGetLastIp() {
|
|
// given
|
|
String name = "Gabriel";
|
|
Player player = mockPlayerWithName(name);
|
|
PlayerAuth auth = PlayerAuth.builder().name(name)
|
|
.lastIp("93.23.44.55")
|
|
.build();
|
|
given(playerCache.getAuth(name)).willReturn(auth);
|
|
|
|
// when
|
|
String result = api.getLastIp(player.getName());
|
|
|
|
// then
|
|
assertThat(result, not(nullValue()));
|
|
assertThat(result, equalTo("93.23.44.55"));
|
|
}
|
|
|
|
@Test
|
|
public void shouldReturnNullAsLastIpForUnknownUser() {
|
|
// given
|
|
String name = "Harrison";
|
|
given(playerCache.getAuth(name)).willReturn(null);
|
|
given(dataSource.getAuth(name)).willReturn(null);
|
|
|
|
// when
|
|
String result = api.getLastIp(name);
|
|
|
|
// then
|
|
assertThat(result, nullValue());
|
|
verify(playerCache).getAuth(name);
|
|
verify(dataSource).getAuth(name);
|
|
}
|
|
|
|
@Test
|
|
public void shouldGetLastLogin() {
|
|
// given
|
|
String name = "David";
|
|
PlayerAuth auth = PlayerAuth.builder().name(name)
|
|
.lastLogin(1501597979L)
|
|
.build();
|
|
given(playerCache.getAuth(name)).willReturn(auth);
|
|
|
|
// when
|
|
Date result = api.getLastLogin(name);
|
|
|
|
// then
|
|
assertThat(result, not(nullValue()));
|
|
assertThat(result, equalTo(new Date(1501597979L)));
|
|
}
|
|
|
|
@Test
|
|
public void shouldHandleNullLastLogin() {
|
|
// given
|
|
String name = "John";
|
|
PlayerAuth auth = PlayerAuth.builder().name(name)
|
|
.lastLogin(null)
|
|
.build();
|
|
given(dataSource.getAuth(name)).willReturn(auth);
|
|
|
|
// when
|
|
Date result = api.getLastLogin(name);
|
|
|
|
// then
|
|
assertThat(result, nullValue());
|
|
verify(dataSource).getAuth(name);
|
|
}
|
|
|
|
@Test
|
|
public void shouldGetLastLoginTime() {
|
|
// given
|
|
String name = "David";
|
|
PlayerAuth auth = PlayerAuth.builder().name(name)
|
|
.lastLogin(1501597979L)
|
|
.build();
|
|
given(playerCache.getAuth(name)).willReturn(auth);
|
|
|
|
// when
|
|
Instant result = api.getLastLoginTime(name);
|
|
|
|
// then
|
|
assertThat(result, not(nullValue()));
|
|
assertThat(result, equalTo(Instant.ofEpochMilli(1501597979L)));
|
|
}
|
|
|
|
@Test
|
|
public void shouldHandleNullLastLoginTime() {
|
|
// given
|
|
String name = "John";
|
|
PlayerAuth auth = PlayerAuth.builder().name(name)
|
|
.lastLogin(null)
|
|
.build();
|
|
given(dataSource.getAuth(name)).willReturn(auth);
|
|
|
|
// when
|
|
Instant result = api.getLastLoginTime(name);
|
|
|
|
// then
|
|
assertThat(result, nullValue());
|
|
verify(dataSource).getAuth(name);
|
|
}
|
|
|
|
@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));
|
|
}
|
|
|
|
@Test
|
|
public void shouldReturnAuthNames() {
|
|
// given
|
|
String[] names = {"bobby", "peter", "elisabeth", "craig"};
|
|
List<PlayerAuth> auths = Arrays.stream(names)
|
|
.map(name -> PlayerAuth.builder().name(name).build())
|
|
.collect(Collectors.toList());
|
|
given(dataSource.getAllAuths()).willReturn(auths);
|
|
|
|
// when
|
|
List<String> result = api.getRegisteredNames();
|
|
|
|
// then
|
|
assertThat(result, contains(names));
|
|
}
|
|
|
|
@Test
|
|
public void shouldReturnAuthRealNames() {
|
|
// given
|
|
String[] names = {"Bobby", "peter", "Elisabeth", "CRAIG"};
|
|
List<PlayerAuth> auths = Arrays.stream(names)
|
|
.map(name -> PlayerAuth.builder().name(name).realName(name).build())
|
|
.collect(Collectors.toList());
|
|
given(dataSource.getAllAuths()).willReturn(auths);
|
|
|
|
// when
|
|
List<String> result = api.getRegisteredRealNames();
|
|
|
|
// then
|
|
assertThat(result, contains(names));
|
|
}
|
|
|
|
@Test
|
|
public void shouldUnregisterPlayer() {
|
|
// given
|
|
Player player = mock(Player.class);
|
|
String name = "Donald";
|
|
given(player.getName()).willReturn(name);
|
|
|
|
// when
|
|
api.forceUnregister(player);
|
|
|
|
// then
|
|
verify(management).performUnregisterByAdmin(null, name, player);
|
|
}
|
|
|
|
@Test
|
|
public void shouldUnregisterPlayerByName() {
|
|
// given
|
|
Server server = mock(Server.class);
|
|
ReflectionTestUtils.setField(Bukkit.class, null, "server", server);
|
|
String name = "tristan";
|
|
Player player = mock(Player.class);
|
|
given(server.getPlayer(name)).willReturn(player);
|
|
|
|
// when
|
|
api.forceUnregister(name);
|
|
|
|
// then
|
|
verify(management).performUnregisterByAdmin(null, name, player);
|
|
}
|
|
|
|
@Test
|
|
public void shouldChangePassword() {
|
|
// given
|
|
String name = "Bobby12";
|
|
String password = "resetPw!";
|
|
|
|
// when
|
|
api.changePassword(name, password);
|
|
|
|
// then
|
|
verify(management).performPasswordChangeAsAdmin(null, name, password);
|
|
}
|
|
|
|
@Test
|
|
public void shouldReturnAuthMeInstance() {
|
|
// given / when
|
|
AuthMe result = api.getPlugin();
|
|
|
|
// then
|
|
assertThat(result, equalTo(authMe));
|
|
}
|
|
|
|
@Test
|
|
public void shouldReturnVersion() {
|
|
// given / when
|
|
String result = api.getPluginVersion();
|
|
|
|
// then
|
|
assertThat(result, equalTo(AuthMe.getPluginVersion()));
|
|
}
|
|
|
|
@Test
|
|
public void shouldForceLogin() {
|
|
// given
|
|
Player player = mock(Player.class);
|
|
|
|
// when
|
|
api.forceLogin(player);
|
|
|
|
// then
|
|
verify(management).forceLogin(player);
|
|
}
|
|
|
|
@Test
|
|
public void shouldForceLogout() {
|
|
// given
|
|
Player player = mock(Player.class);
|
|
|
|
// when
|
|
api.forceLogout(player);
|
|
|
|
// then
|
|
verify(management).performLogout(player);
|
|
}
|
|
|
|
@Test
|
|
public void shouldForceRegister() {
|
|
// given
|
|
Player player = mock(Player.class);
|
|
String pass = "test235";
|
|
|
|
// when
|
|
api.forceRegister(player, pass);
|
|
|
|
// then
|
|
verify(management).performRegister(eq(RegistrationMethod.API_REGISTRATION),
|
|
argThat(isEqualTo(ApiPasswordRegisterParams.of(player, pass, true))));
|
|
}
|
|
|
|
@Test
|
|
public void shouldForceRegisterAndNotAutoLogin() {
|
|
// given
|
|
Player player = mock(Player.class);
|
|
String pass = "test235";
|
|
|
|
// when
|
|
api.forceRegister(player, pass, false);
|
|
|
|
// then
|
|
verify(management).performRegister(eq(RegistrationMethod.API_REGISTRATION),
|
|
argThat(isEqualTo(ApiPasswordRegisterParams.of(player, pass, false))));
|
|
}
|
|
|
|
@Test
|
|
public void shouldRegisterPlayer() {
|
|
// given
|
|
String name = "Marco";
|
|
String password = "myP4ss";
|
|
HashedPassword hashedPassword = new HashedPassword("0395872SLKDFJOWEIUTEJSD");
|
|
given(passwordSecurity.computeHash(password, name.toLowerCase())).willReturn(hashedPassword);
|
|
given(dataSource.saveAuth(any(PlayerAuth.class))).willReturn(true);
|
|
|
|
// when
|
|
boolean result = api.registerPlayer(name, password);
|
|
|
|
// then
|
|
assertThat(result, equalTo(true));
|
|
verify(passwordSecurity).computeHash(password, name.toLowerCase());
|
|
ArgumentCaptor<PlayerAuth> authCaptor = ArgumentCaptor.forClass(PlayerAuth.class);
|
|
verify(dataSource).saveAuth(authCaptor.capture());
|
|
assertThat(authCaptor.getValue().getNickname(), equalTo(name.toLowerCase()));
|
|
assertThat(authCaptor.getValue().getRealName(), equalTo(name));
|
|
assertThat(authCaptor.getValue().getPassword(), equalTo(hashedPassword));
|
|
}
|
|
|
|
@Test
|
|
public void shouldNotRegisterAlreadyRegisteredPlayer() {
|
|
// given
|
|
String name = "jonah";
|
|
given(dataSource.isAuthAvailable(name)).willReturn(true);
|
|
|
|
// when
|
|
boolean result = api.registerPlayer(name, "pass");
|
|
|
|
// then
|
|
assertThat(result, equalTo(false));
|
|
verify(dataSource, only()).isAuthAvailable(name);
|
|
verifyZeroInteractions(management, passwordSecurity);
|
|
}
|
|
|
|
@Test
|
|
public void shouldGetNamesByIp() {
|
|
// given
|
|
String ip = "123.123.123.123";
|
|
List<String> names = Arrays.asList("Morgan", "Batista", "QUINN");
|
|
given(dataSource.getAllAuthsByIp(ip)).willReturn(names);
|
|
|
|
// when
|
|
List<String> result = api.getNamesByIp(ip);
|
|
|
|
// then
|
|
assertThat(result, equalTo(names));
|
|
verify(dataSource).getAllAuthsByIp(ip);
|
|
}
|
|
|
|
@Test
|
|
public void shouldReturnGeoIpInfo() {
|
|
// given
|
|
String ip = "127.127.12.1";
|
|
given(geoIpService.getCountryCode(ip)).willReturn("XA");
|
|
given(geoIpService.getCountryName(ip)).willReturn("Syldavia");
|
|
|
|
// when
|
|
String countryCode = api.getCountryCode(ip);
|
|
String countryName = api.getCountryName(ip);
|
|
|
|
// then
|
|
assertThat(countryCode, equalTo("XA"));
|
|
assertThat(countryName, equalTo("Syldavia"));
|
|
}
|
|
|
|
private static Player mockPlayerWithName(String name) {
|
|
Player player = mock(Player.class);
|
|
given(player.getName()).willReturn(name);
|
|
return player;
|
|
}
|
|
}
|