Package cleanup
- authme.cache to authme.data - Rename PlayerData to LimboPlayer to match with LimboCache - Move authme.converter to authme.datasource.converter - Split output package into output and message
This commit is contained in:
Gabriele C
@@ -0,0 +1,160 @@
|
||||
package fr.xephi.authme.data;
|
||||
|
||||
import fr.xephi.authme.ReflectionTestUtils;
|
||||
import fr.xephi.authme.settings.Settings;
|
||||
import fr.xephi.authme.settings.properties.SecuritySettings;
|
||||
import org.junit.Test;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
import static org.hamcrest.Matchers.equalTo;
|
||||
import static org.hamcrest.Matchers.nullValue;
|
||||
import static org.junit.Assert.assertThat;
|
||||
import static org.mockito.BDDMockito.given;
|
||||
import static org.mockito.Mockito.mock;
|
||||
|
||||
/**
|
||||
* Test for {@link CaptchaManager}.
|
||||
*/
|
||||
public class CaptchaManagerTest {
|
||||
|
||||
@Test
|
||||
public void shouldAddCounts() {
|
||||
// given
|
||||
Settings settings = mockSettings(3, 4);
|
||||
CaptchaManager manager = new CaptchaManager(settings);
|
||||
String player = "tester";
|
||||
|
||||
// when
|
||||
for (int i = 0; i < 2; ++i) {
|
||||
manager.increaseCount(player);
|
||||
}
|
||||
|
||||
// then
|
||||
assertThat(manager.isCaptchaRequired(player), equalTo(false));
|
||||
manager.increaseCount(player);
|
||||
assertThat(manager.isCaptchaRequired(player.toUpperCase()), equalTo(true));
|
||||
assertThat(manager.isCaptchaRequired("otherPlayer"), equalTo(false));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldCreateAndCheckCaptcha() {
|
||||
// given
|
||||
String player = "Miner";
|
||||
Settings settings = mockSettings(1, 4);
|
||||
CaptchaManager manager = new CaptchaManager(settings);
|
||||
String captchaCode = manager.getCaptchaCodeOrGenerateNew(player);
|
||||
|
||||
// when
|
||||
boolean badResult = manager.checkCode(player, "wrong_code");
|
||||
boolean goodResult = manager.checkCode(player, captchaCode);
|
||||
|
||||
// then
|
||||
assertThat(captchaCode.length(), equalTo(4));
|
||||
assertThat(badResult, equalTo(false));
|
||||
assertThat(goodResult, equalTo(true));
|
||||
// Supplying correct code should clear the entry, and any code should be valid if no entry is present
|
||||
assertThat(manager.checkCode(player, "bogus"), equalTo(true));
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests {@link CaptchaManager#getCaptchaCode} and {@link CaptchaManager#getCaptchaCodeOrGenerateNew}.
|
||||
* The former method should never change the code (and so return {@code null} for no code) while the latter should
|
||||
* generate a new code if no code is yet present. If a code is saved, it should never generate a new one.
|
||||
*/
|
||||
@Test
|
||||
public void shouldHaveSameCodeAfterGeneration() {
|
||||
// given
|
||||
String player = "Tester";
|
||||
Settings settings = mockSettings(1, 5);
|
||||
CaptchaManager manager = new CaptchaManager(settings);
|
||||
|
||||
// when
|
||||
String code1 = manager.getCaptchaCode(player);
|
||||
String code2 = manager.getCaptchaCodeOrGenerateNew(player);
|
||||
String code3 = manager.getCaptchaCode(player);
|
||||
String code4 = manager.getCaptchaCodeOrGenerateNew(player);
|
||||
String code5 = manager.getCaptchaCode(player);
|
||||
|
||||
// then
|
||||
assertThat(code1, nullValue());
|
||||
assertThat(code2.length(), equalTo(5));
|
||||
assertThat(code3, equalTo(code2));
|
||||
assertThat(code4, equalTo(code2));
|
||||
assertThat(code5, equalTo(code2));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldIncreaseAndResetCount() {
|
||||
// given
|
||||
String player = "plaYer";
|
||||
Settings settings = mockSettings(2, 3);
|
||||
CaptchaManager manager = new CaptchaManager(settings);
|
||||
|
||||
// when
|
||||
manager.increaseCount(player);
|
||||
manager.increaseCount(player);
|
||||
|
||||
// then
|
||||
assertThat(manager.isCaptchaRequired(player), equalTo(true));
|
||||
assertHasCount(manager, player, 2);
|
||||
|
||||
// when 2
|
||||
manager.resetCounts(player);
|
||||
|
||||
// then 2
|
||||
assertThat(manager.isCaptchaRequired(player), equalTo(false));
|
||||
assertHasCount(manager, player, null);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldNotIncreaseCountForDisabledCaptcha() {
|
||||
// given
|
||||
String player = "someone_";
|
||||
Settings settings = mockSettings(1, 3);
|
||||
given(settings.getProperty(SecuritySettings.USE_CAPTCHA)).willReturn(false);
|
||||
CaptchaManager manager = new CaptchaManager(settings);
|
||||
|
||||
// when
|
||||
manager.increaseCount(player);
|
||||
|
||||
// then
|
||||
assertThat(manager.isCaptchaRequired(player), equalTo(false));
|
||||
assertHasCount(manager, player, null);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldNotCheckCountIfCaptchaIsDisabled() {
|
||||
// given
|
||||
String player = "Robert001";
|
||||
Settings settings = mockSettings(1, 5);
|
||||
CaptchaManager manager = new CaptchaManager(settings);
|
||||
given(settings.getProperty(SecuritySettings.USE_CAPTCHA)).willReturn(false);
|
||||
|
||||
// when
|
||||
manager.increaseCount(player);
|
||||
// assumptions
|
||||
assertThat(manager.isCaptchaRequired(player), equalTo(true));
|
||||
assertHasCount(manager, player, 1);
|
||||
// end assumptions
|
||||
manager.reload(settings);
|
||||
boolean result = manager.isCaptchaRequired(player);
|
||||
|
||||
// then
|
||||
assertThat(result, equalTo(false));
|
||||
}
|
||||
|
||||
private static Settings mockSettings(int maxTries, int captchaLength) {
|
||||
Settings settings = mock(Settings.class);
|
||||
given(settings.getProperty(SecuritySettings.USE_CAPTCHA)).willReturn(true);
|
||||
given(settings.getProperty(SecuritySettings.MAX_LOGIN_TRIES_BEFORE_CAPTCHA)).willReturn(maxTries);
|
||||
given(settings.getProperty(SecuritySettings.CAPTCHA_LENGTH)).willReturn(captchaLength);
|
||||
return settings;
|
||||
}
|
||||
|
||||
private static void assertHasCount(CaptchaManager manager, String player, Integer count) {
|
||||
Map<String, Integer> playerCounts = ReflectionTestUtils
|
||||
.getFieldValue(CaptchaManager.class, manager, "playerCounts");
|
||||
assertThat(playerCounts.get(player.toLowerCase()), equalTo(count));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,175 @@
|
||||
package fr.xephi.authme.data;
|
||||
|
||||
import fr.xephi.authme.ReflectionTestUtils;
|
||||
import fr.xephi.authme.settings.Settings;
|
||||
import fr.xephi.authme.settings.properties.PluginSettings;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.runners.MockitoJUnitRunner;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
import static org.hamcrest.Matchers.aMapWithSize;
|
||||
import static org.hamcrest.Matchers.anEmptyMap;
|
||||
import static org.hamcrest.Matchers.containsInAnyOrder;
|
||||
import static org.hamcrest.Matchers.equalTo;
|
||||
import static org.junit.Assert.assertThat;
|
||||
import static org.mockito.BDDMockito.given;
|
||||
import static org.mockito.Mockito.mock;
|
||||
|
||||
/**
|
||||
* Test for {@link SessionManager}.
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class SessionManagerTest {
|
||||
|
||||
@Test
|
||||
public void shouldHaveSession() {
|
||||
// given
|
||||
Settings settings = mockSettings(true, 10);
|
||||
SessionManager manager = new SessionManager(settings);
|
||||
String player = "playah";
|
||||
|
||||
// when
|
||||
manager.addSession(player);
|
||||
|
||||
// then
|
||||
assertThat(manager.hasSession(player), equalTo(true));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldNotHaveSession() {
|
||||
// given
|
||||
Settings settings = mockSettings(true, 10);
|
||||
SessionManager manager = new SessionManager(settings);
|
||||
String player = "playah";
|
||||
|
||||
// when/then
|
||||
assertThat(manager.hasSession(player), equalTo(false));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldNotAddSessionBecauseDisabled() {
|
||||
// given
|
||||
Settings settings = mockSettings(false, 10);
|
||||
SessionManager manager = new SessionManager(settings);
|
||||
String player = "playah";
|
||||
|
||||
// when
|
||||
manager.addSession(player);
|
||||
|
||||
// then
|
||||
assertThat(manager.hasSession(player), equalTo(false));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldNotAddSessionBecauseTimeoutIsZero() {
|
||||
// given
|
||||
Settings settings = mockSettings(true, 0);
|
||||
SessionManager manager = new SessionManager(settings);
|
||||
String player = "playah";
|
||||
|
||||
// when
|
||||
manager.addSession(player);
|
||||
|
||||
// then
|
||||
assertThat(manager.hasSession(player), equalTo(false));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldRemoveSession() {
|
||||
// given
|
||||
Settings settings = mockSettings(true, 10);
|
||||
String player = "user";
|
||||
SessionManager manager = new SessionManager(settings);
|
||||
manager.addSession(player);
|
||||
|
||||
// when
|
||||
manager.removeSession(player);
|
||||
|
||||
// then
|
||||
assertThat(manager.hasSession(player), equalTo(false));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldDenySessionIfTimeoutHasExpired() {
|
||||
// given
|
||||
int timeout = 20;
|
||||
Settings settings = mockSettings(true, timeout);
|
||||
String player = "patrick";
|
||||
SessionManager manager = new SessionManager(settings);
|
||||
Map<String, Long> sessions = getSessionsMap(manager);
|
||||
// Add session entry for player that just has expired
|
||||
sessions.put(player, System.currentTimeMillis() - 1000);
|
||||
|
||||
// when
|
||||
boolean result = manager.hasSession(player);
|
||||
|
||||
// then
|
||||
assertThat(result, equalTo(false));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldClearAllSessionsAfterDisable() {
|
||||
// given
|
||||
Settings settings = mockSettings(true, 10);
|
||||
SessionManager manager = new SessionManager(settings);
|
||||
manager.addSession("player01");
|
||||
manager.addSession("player02");
|
||||
|
||||
// when
|
||||
manager.reload(mockSettings(false, 20));
|
||||
|
||||
// then
|
||||
assertThat(getSessionsMap(manager), anEmptyMap());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldPerformCleanup() {
|
||||
// given
|
||||
Settings settings = mockSettings(true, 1);
|
||||
SessionManager manager = new SessionManager(settings);
|
||||
Map<String, Long> sessions = getSessionsMap(manager);
|
||||
sessions.put("somebody", System.currentTimeMillis() - 123L);
|
||||
sessions.put("someone", System.currentTimeMillis() + 4040L);
|
||||
sessions.put("anyone", System.currentTimeMillis() - 1000L);
|
||||
sessions.put("everyone", System.currentTimeMillis() + 60000L);
|
||||
|
||||
// when
|
||||
manager.performCleanup();
|
||||
|
||||
// then
|
||||
assertThat(sessions, aMapWithSize(2));
|
||||
assertThat(sessions.keySet(), containsInAnyOrder("someone", "everyone"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldNotPerformCleanup() {
|
||||
// given
|
||||
Settings settings = mockSettings(false, 1);
|
||||
SessionManager manager = new SessionManager(settings);
|
||||
Map<String, Long> sessions = getSessionsMap(manager);
|
||||
sessions.put("somebody", System.currentTimeMillis() - 123L);
|
||||
sessions.put("someone", System.currentTimeMillis() + 4040L);
|
||||
sessions.put("anyone", System.currentTimeMillis() - 1000L);
|
||||
sessions.put("everyone", System.currentTimeMillis() + 60000L);
|
||||
|
||||
// when
|
||||
manager.performCleanup();
|
||||
|
||||
// then
|
||||
assertThat(sessions, aMapWithSize(4)); // map not changed -> no cleanup performed
|
||||
}
|
||||
|
||||
private static Map<String, Long> getSessionsMap(SessionManager manager) {
|
||||
return ReflectionTestUtils.getFieldValue(SessionManager.class, manager, "sessions");
|
||||
}
|
||||
|
||||
|
||||
private static Settings mockSettings(boolean isEnabled, int sessionTimeout) {
|
||||
Settings settings = mock(Settings.class);
|
||||
given(settings.getProperty(PluginSettings.SESSIONS_ENABLED)).willReturn(isEnabled);
|
||||
given(settings.getProperty(PluginSettings.SESSIONS_TIMEOUT)).willReturn(sessionTimeout);
|
||||
return settings;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,264 @@
|
||||
package fr.xephi.authme.data;
|
||||
|
||||
import fr.xephi.authme.ReflectionTestUtils;
|
||||
import fr.xephi.authme.TestHelper;
|
||||
import fr.xephi.authme.data.TempbanManager.TimedCounter;
|
||||
import fr.xephi.authme.message.MessageKey;
|
||||
import fr.xephi.authme.message.Messages;
|
||||
import fr.xephi.authme.settings.Settings;
|
||||
import fr.xephi.authme.settings.properties.SecuritySettings;
|
||||
import fr.xephi.authme.service.BukkitService;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.ArgumentCaptor;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.runners.MockitoJUnitRunner;
|
||||
|
||||
import java.util.Calendar;
|
||||
import java.util.Date;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
import static org.hamcrest.Matchers.aMapWithSize;
|
||||
import static org.hamcrest.Matchers.anEmptyMap;
|
||||
import static org.hamcrest.Matchers.equalTo;
|
||||
import static org.hamcrest.Matchers.lessThan;
|
||||
import static org.junit.Assert.assertThat;
|
||||
import static org.mockito.BDDMockito.given;
|
||||
import static org.mockito.Matchers.eq;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.verify;
|
||||
import static org.mockito.Mockito.verifyZeroInteractions;
|
||||
|
||||
/**
|
||||
* Test for {@link TempbanManager}.
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class TempbanManagerTest {
|
||||
|
||||
private static final long DATE_TOLERANCE_MILLISECONDS = 200L;
|
||||
private static final long TEST_EXPIRATION_THRESHOLD = 120_000L;
|
||||
|
||||
@Mock
|
||||
private BukkitService bukkitService;
|
||||
|
||||
@Mock
|
||||
private Messages messages;
|
||||
|
||||
@Test
|
||||
public void shouldAddCounts() {
|
||||
// given
|
||||
Settings settings = mockSettings(3, 60);
|
||||
TempbanManager manager = new TempbanManager(bukkitService, messages, settings);
|
||||
String address = "192.168.1.1";
|
||||
|
||||
// when
|
||||
manager.increaseCount(address, "Bob");
|
||||
manager.increaseCount(address, "Todd");
|
||||
|
||||
// then
|
||||
assertThat(manager.shouldTempban(address), equalTo(false));
|
||||
assertHasCount(manager, address, "Bob", 1);
|
||||
assertHasCount(manager, address, "Todd", 1);
|
||||
manager.increaseCount(address, "Bob");
|
||||
assertThat(manager.shouldTempban(address), equalTo(true));
|
||||
assertThat(manager.shouldTempban("10.0.0.1"), equalTo(false));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldIncreaseAndResetCount() {
|
||||
// given
|
||||
String address = "192.168.1.2";
|
||||
Settings settings = mockSettings(3, 60);
|
||||
TempbanManager manager = new TempbanManager(bukkitService, messages, settings);
|
||||
|
||||
// when
|
||||
manager.increaseCount(address, "test");
|
||||
manager.increaseCount(address, "test");
|
||||
manager.increaseCount(address, "test");
|
||||
|
||||
// then
|
||||
assertThat(manager.shouldTempban(address), equalTo(true));
|
||||
assertHasCount(manager, address, "test", 3);
|
||||
|
||||
// when 2
|
||||
manager.resetCount(address, "test");
|
||||
|
||||
// then 2
|
||||
assertThat(manager.shouldTempban(address), equalTo(false));
|
||||
assertHasNoEntries(manager, address);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldNotIncreaseCountForDisabledTempban() {
|
||||
// given
|
||||
String address = "192.168.1.3";
|
||||
Settings settings = mockSettings(1, 5);
|
||||
given(settings.getProperty(SecuritySettings.TEMPBAN_ON_MAX_LOGINS)).willReturn(false);
|
||||
TempbanManager manager = new TempbanManager(bukkitService, messages, settings);
|
||||
|
||||
// when
|
||||
manager.increaseCount(address, "username");
|
||||
|
||||
// then
|
||||
assertThat(manager.shouldTempban(address), equalTo(false));
|
||||
assertHasNoEntries(manager, address);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldNotCheckCountIfTempbanIsDisabled() {
|
||||
// given
|
||||
String address = "192.168.1.4";
|
||||
Settings settings = mockSettings(1, 5);
|
||||
TempbanManager manager = new TempbanManager(bukkitService, messages, settings);
|
||||
given(settings.getProperty(SecuritySettings.TEMPBAN_ON_MAX_LOGINS)).willReturn(false);
|
||||
|
||||
// when
|
||||
manager.increaseCount(address, "username");
|
||||
// assumptions
|
||||
assertThat(manager.shouldTempban(address), equalTo(true));
|
||||
assertHasCount(manager, address, "username", 1);
|
||||
// end assumptions
|
||||
manager.reload(settings);
|
||||
boolean result = manager.shouldTempban(address);
|
||||
|
||||
// then
|
||||
assertThat(result, equalTo(false));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldNotIssueBanIfDisabled() {
|
||||
// given
|
||||
Settings settings = mockSettings(0, 0);
|
||||
given(settings.getProperty(SecuritySettings.TEMPBAN_ON_MAX_LOGINS)).willReturn(false);
|
||||
Player player = mock(Player.class);
|
||||
TempbanManager manager = new TempbanManager(bukkitService, messages, settings);
|
||||
|
||||
// when
|
||||
manager.tempbanPlayer(player);
|
||||
|
||||
// then
|
||||
verifyZeroInteractions(player, bukkitService);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldBanPlayerIp() {
|
||||
// given
|
||||
Player player = mock(Player.class);
|
||||
String ip = "123.45.67.89";
|
||||
TestHelper.mockPlayerIp(player, ip);
|
||||
String banReason = "IP ban too many logins";
|
||||
given(messages.retrieveSingle(MessageKey.TEMPBAN_MAX_LOGINS)).willReturn(banReason);
|
||||
Settings settings = mockSettings(2, 100);
|
||||
TempbanManager manager = new TempbanManager(bukkitService, messages, settings);
|
||||
|
||||
// when
|
||||
manager.tempbanPlayer(player);
|
||||
TestHelper.runSyncDelayedTask(bukkitService);
|
||||
|
||||
// then
|
||||
verify(player).kickPlayer(banReason);
|
||||
ArgumentCaptor<Date> captor = ArgumentCaptor.forClass(Date.class);
|
||||
verify(bukkitService).banIp(eq(ip), eq(banReason), captor.capture(), eq("AuthMe"));
|
||||
|
||||
// Compute the expected expiration date and check that the actual date is within the difference tolerance
|
||||
Calendar cal = Calendar.getInstance();
|
||||
cal.add(Calendar.MINUTE, 100);
|
||||
long expectedExpiration = cal.getTime().getTime();
|
||||
assertThat(Math.abs(captor.getValue().getTime() - expectedExpiration), lessThan(DATE_TOLERANCE_MILLISECONDS));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldResetCountAfterBan() {
|
||||
// given
|
||||
Player player = mock(Player.class);
|
||||
String ip = "22.44.66.88";
|
||||
TestHelper.mockPlayerIp(player, ip);
|
||||
String banReason = "kick msg";
|
||||
given(messages.retrieveSingle(MessageKey.TEMPBAN_MAX_LOGINS)).willReturn(banReason);
|
||||
Settings settings = mockSettings(10, 60);
|
||||
TempbanManager manager = new TempbanManager(bukkitService, messages, settings);
|
||||
manager.increaseCount(ip, "user");
|
||||
manager.increaseCount(ip, "name2");
|
||||
manager.increaseCount(ip, "user");
|
||||
|
||||
// when
|
||||
manager.tempbanPlayer(player);
|
||||
TestHelper.runSyncDelayedTask(bukkitService);
|
||||
|
||||
// then
|
||||
verify(player).kickPlayer(banReason);
|
||||
assertHasNoEntries(manager, ip);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldPerformCleanup() {
|
||||
// given
|
||||
// `expirationPoint` is the approximate timestamp until which entries should be considered, so subtracting
|
||||
// from it will create expired entries, and adding a reasonably large number makes it still valid
|
||||
final long expirationPoint = System.currentTimeMillis() - TEST_EXPIRATION_THRESHOLD;
|
||||
// 2 current entries with total 6 failed tries
|
||||
Map<String, TimedCounter> map1 = new HashMap<>();
|
||||
map1.put("name", newTimedCounter(4, expirationPoint + 20_000));
|
||||
map1.put("other", newTimedCounter(2, expirationPoint + 40_000));
|
||||
// 0 current entries
|
||||
Map<String, TimedCounter> map2 = new HashMap<>();
|
||||
map2.put("someone", newTimedCounter(10, expirationPoint - 5_000));
|
||||
map2.put("somebody", newTimedCounter(10, expirationPoint - 8_000));
|
||||
// 1 current entry with total 4 failed tries
|
||||
Map<String, TimedCounter> map3 = new HashMap<>();
|
||||
map3.put("some", newTimedCounter(5, expirationPoint - 12_000));
|
||||
map3.put("test", newTimedCounter(4, expirationPoint + 8_000));
|
||||
map3.put("values", newTimedCounter(2, expirationPoint - 80_000));
|
||||
|
||||
String[] addresses = {"123.45.67.89", "127.0.0.1", "192.168.0.1"};
|
||||
Map<String, Map<String, TimedCounter>> counterMap = new HashMap<>();
|
||||
counterMap.put(addresses[0], map1);
|
||||
counterMap.put(addresses[1], map2);
|
||||
counterMap.put(addresses[2], map3);
|
||||
|
||||
TempbanManager manager = new TempbanManager(bukkitService, messages, mockSettings(5, 250));
|
||||
ReflectionTestUtils.setField(TempbanManager.class, manager, "ipLoginFailureCounts", counterMap);
|
||||
|
||||
// when
|
||||
manager.performCleanup();
|
||||
|
||||
// then
|
||||
assertThat(counterMap.get(addresses[0]), aMapWithSize(2));
|
||||
assertHasCount(manager, addresses[0], "name", 4);
|
||||
assertHasCount(manager, addresses[0], "other", 2);
|
||||
assertThat(counterMap.get(addresses[1]), anEmptyMap());
|
||||
assertThat(counterMap.get(addresses[2]), aMapWithSize(1));
|
||||
assertHasCount(manager, addresses[2], "test", 4);
|
||||
}
|
||||
|
||||
private static Settings mockSettings(int maxTries, int tempbanLength) {
|
||||
Settings settings = mock(Settings.class);
|
||||
given(settings.getProperty(SecuritySettings.TEMPBAN_ON_MAX_LOGINS)).willReturn(true);
|
||||
given(settings.getProperty(SecuritySettings.MAX_LOGIN_TEMPBAN)).willReturn(maxTries);
|
||||
given(settings.getProperty(SecuritySettings.TEMPBAN_LENGTH)).willReturn(tempbanLength);
|
||||
given(settings.getProperty(SecuritySettings.TEMPBAN_MINUTES_BEFORE_RESET))
|
||||
.willReturn((int) TEST_EXPIRATION_THRESHOLD / 60_000);
|
||||
return settings;
|
||||
}
|
||||
|
||||
private static void assertHasNoEntries(TempbanManager manager, String address) {
|
||||
Map<String, Map<String, TimedCounter>> playerCounts = ReflectionTestUtils
|
||||
.getFieldValue(TempbanManager.class, manager, "ipLoginFailureCounts");
|
||||
Map<String, TimedCounter> map = playerCounts.get(address);
|
||||
assertThat(map == null || map.isEmpty(), equalTo(true));
|
||||
}
|
||||
|
||||
private static void assertHasCount(TempbanManager manager, String address, String name, int count) {
|
||||
Map<String, Map<String, TimedCounter>> playerCounts = ReflectionTestUtils
|
||||
.getFieldValue(TempbanManager.class, manager, "ipLoginFailureCounts");
|
||||
assertThat(playerCounts.get(address).get(name).getCount(TEST_EXPIRATION_THRESHOLD), equalTo(count));
|
||||
}
|
||||
|
||||
private static TimedCounter newTimedCounter(int count, long timestamp) {
|
||||
TimedCounter counter = new TimedCounter(count);
|
||||
ReflectionTestUtils.setField(TimedCounter.class, counter, "lastIncrementTimestamp", timestamp);
|
||||
return counter;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,151 @@
|
||||
package fr.xephi.authme.data.backup;
|
||||
|
||||
import ch.jalu.injector.testing.BeforeInjecting;
|
||||
import ch.jalu.injector.testing.DelayedInjectionRunner;
|
||||
import ch.jalu.injector.testing.InjectDelayed;
|
||||
import fr.xephi.authme.TestHelper;
|
||||
import fr.xephi.authme.data.limbo.LimboPlayer;
|
||||
import fr.xephi.authme.initialization.DataFolder;
|
||||
import fr.xephi.authme.permission.PermissionsManager;
|
||||
import fr.xephi.authme.settings.SpawnLoader;
|
||||
import fr.xephi.authme.service.BukkitService;
|
||||
import fr.xephi.authme.util.FileUtils;
|
||||
import org.bukkit.Location;
|
||||
import org.bukkit.World;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.junit.Rule;
|
||||
import org.junit.Test;
|
||||
import org.junit.rules.TemporaryFolder;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.nio.file.Files;
|
||||
import java.util.UUID;
|
||||
|
||||
import static org.hamcrest.Matchers.equalTo;
|
||||
import static org.hamcrest.Matchers.not;
|
||||
import static org.hamcrest.Matchers.nullValue;
|
||||
import static org.junit.Assert.assertThat;
|
||||
import static org.mockito.BDDMockito.given;
|
||||
import static org.mockito.Mockito.mock;
|
||||
|
||||
/**
|
||||
* Test for {@link LimboPlayerStorage}.
|
||||
*/
|
||||
@RunWith(DelayedInjectionRunner.class)
|
||||
public class LimboPlayerStorageTest {
|
||||
|
||||
private static final UUID SAMPLE_UUID = UUID.nameUUIDFromBytes("PlayerDataStorageTest".getBytes());
|
||||
private static final String SOURCE_FOLDER = TestHelper.PROJECT_ROOT + "data/backup/";
|
||||
|
||||
@InjectDelayed
|
||||
private LimboPlayerStorage limboPlayerStorage;
|
||||
|
||||
@Mock
|
||||
private SpawnLoader spawnLoader;
|
||||
|
||||
@Mock
|
||||
private BukkitService bukkitService;
|
||||
|
||||
@Mock
|
||||
private PermissionsManager permissionsManager;
|
||||
|
||||
@DataFolder
|
||||
private File dataFolder;
|
||||
|
||||
@Rule
|
||||
public TemporaryFolder temporaryFolder = new TemporaryFolder();
|
||||
|
||||
@BeforeInjecting
|
||||
public void copyTestFiles() throws IOException {
|
||||
dataFolder = temporaryFolder.newFolder();
|
||||
File playerFolder = new File(dataFolder, FileUtils.makePath("playerdata", SAMPLE_UUID.toString()));
|
||||
if (!playerFolder.mkdirs()) {
|
||||
throw new IllegalStateException("Cannot create '" + playerFolder.getAbsolutePath() + "'");
|
||||
}
|
||||
Files.copy(TestHelper.getJarPath(FileUtils.makePath(SOURCE_FOLDER, "sample-folder", "data.json")),
|
||||
new File(playerFolder, "data.json").toPath());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldReadDataFromFile() {
|
||||
// given
|
||||
Player player = mock(Player.class);
|
||||
given(player.getUniqueId()).willReturn(SAMPLE_UUID);
|
||||
World world = mock(World.class);
|
||||
given(bukkitService.getWorld("nether")).willReturn(world);
|
||||
|
||||
// when
|
||||
LimboPlayer data = limboPlayerStorage.readData(player);
|
||||
|
||||
// then
|
||||
assertThat(data, not(nullValue()));
|
||||
assertThat(data.isOperator(), equalTo(true));
|
||||
assertThat(data.isCanFly(), equalTo(true));
|
||||
assertThat(data.getWalkSpeed(), equalTo(0.2f));
|
||||
assertThat(data.getFlySpeed(), equalTo(0.1f));
|
||||
assertThat(data.getGroup(), equalTo("players"));
|
||||
Location location = data.getLocation();
|
||||
assertThat(location.getX(), equalTo(-113.219));
|
||||
assertThat(location.getY(), equalTo(72.0));
|
||||
assertThat(location.getZ(), equalTo(130.637));
|
||||
assertThat(location.getWorld(), equalTo(world));
|
||||
assertThat(location.getPitch(), equalTo(24.15f));
|
||||
assertThat(location.getYaw(), equalTo(-292.484f));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldReturnNullForUnavailablePlayer() {
|
||||
// given
|
||||
Player player = mock(Player.class);
|
||||
given(player.getUniqueId()).willReturn(UUID.nameUUIDFromBytes("other-player".getBytes()));
|
||||
|
||||
// when
|
||||
LimboPlayer data = limboPlayerStorage.readData(player);
|
||||
|
||||
// then
|
||||
assertThat(data, nullValue());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldReturnIfHasData() {
|
||||
// given
|
||||
Player player1 = mock(Player.class);
|
||||
given(player1.getUniqueId()).willReturn(SAMPLE_UUID);
|
||||
Player player2 = mock(Player.class);
|
||||
given(player2.getUniqueId()).willReturn(UUID.nameUUIDFromBytes("not-stored".getBytes()));
|
||||
|
||||
// when / then
|
||||
assertThat(limboPlayerStorage.hasData(player1), equalTo(true));
|
||||
assertThat(limboPlayerStorage.hasData(player2), equalTo(false));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldSavePlayerData() {
|
||||
// given
|
||||
Player player = mock(Player.class);
|
||||
UUID uuid = UUID.nameUUIDFromBytes("New player".getBytes());
|
||||
given(player.getUniqueId()).willReturn(uuid);
|
||||
given(permissionsManager.getPrimaryGroup(player)).willReturn("primary-grp");
|
||||
given(player.isOp()).willReturn(true);
|
||||
given(player.getWalkSpeed()).willReturn(1.2f);
|
||||
given(player.getFlySpeed()).willReturn(0.8f);
|
||||
given(player.getAllowFlight()).willReturn(true);
|
||||
|
||||
World world = mock(World.class);
|
||||
given(world.getName()).willReturn("player-world");
|
||||
Location location = new Location(world, 0.2, 102.25, -89.28, 3.02f, 90.13f);
|
||||
given(spawnLoader.getPlayerLocationOrSpawn(player)).willReturn(location);
|
||||
|
||||
// when
|
||||
limboPlayerStorage.saveData(player);
|
||||
|
||||
// then
|
||||
File playerFile = new File(dataFolder, FileUtils.makePath("playerdata", uuid.toString(), "data.json"));
|
||||
assertThat(playerFile.exists(), equalTo(true));
|
||||
// TODO ljacqu 20160711: Check contents of file
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,230 @@
|
||||
package fr.xephi.authme.data.limbo;
|
||||
|
||||
import fr.xephi.authme.ReflectionTestUtils;
|
||||
import fr.xephi.authme.data.backup.LimboPlayerStorage;
|
||||
import fr.xephi.authme.permission.PermissionsManager;
|
||||
import fr.xephi.authme.settings.Settings;
|
||||
import fr.xephi.authme.settings.SpawnLoader;
|
||||
import fr.xephi.authme.settings.properties.PluginSettings;
|
||||
import org.bukkit.Location;
|
||||
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 java.util.Map;
|
||||
|
||||
import static org.hamcrest.Matchers.aMapWithSize;
|
||||
import static org.hamcrest.Matchers.anEmptyMap;
|
||||
import static org.hamcrest.Matchers.equalTo;
|
||||
import static org.junit.Assert.assertThat;
|
||||
import static org.mockito.BDDMockito.given;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.verify;
|
||||
import static org.mockito.Mockito.verifyNoMoreInteractions;
|
||||
|
||||
/**
|
||||
* Test for {@link LimboCache}.
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class LimboCacheTest {
|
||||
|
||||
@InjectMocks
|
||||
private LimboCache limboCache;
|
||||
|
||||
@Mock
|
||||
private Settings settings;
|
||||
|
||||
@Mock
|
||||
private PermissionsManager permissionsManager;
|
||||
|
||||
@Mock
|
||||
private SpawnLoader spawnLoader;
|
||||
|
||||
@Mock
|
||||
private LimboPlayerStorage limboPlayerStorage;
|
||||
|
||||
@Test
|
||||
public void shouldAddPlayerData() {
|
||||
// given
|
||||
Player player = mock(Player.class);
|
||||
String name = "Bobby";
|
||||
given(player.getName()).willReturn(name);
|
||||
Location location = mock(Location.class);
|
||||
given(spawnLoader.getPlayerLocationOrSpawn(player)).willReturn(location);
|
||||
given(player.isOp()).willReturn(true);
|
||||
float walkSpeed = 2.1f;
|
||||
given(player.getWalkSpeed()).willReturn(walkSpeed);
|
||||
given(player.getAllowFlight()).willReturn(true);
|
||||
float flySpeed = 3.0f;
|
||||
given(player.getFlySpeed()).willReturn(flySpeed);
|
||||
given(permissionsManager.hasGroupSupport()).willReturn(true);
|
||||
String group = "test-group";
|
||||
given(permissionsManager.getPrimaryGroup(player)).willReturn(group);
|
||||
given(limboPlayerStorage.hasData(player)).willReturn(false);
|
||||
|
||||
// when
|
||||
limboCache.addPlayerData(player);
|
||||
|
||||
// then
|
||||
LimboPlayer limboPlayer = limboCache.getPlayerData(name);
|
||||
assertThat(limboPlayer.getLocation(), equalTo(location));
|
||||
assertThat(limboPlayer.isOperator(), equalTo(true));
|
||||
assertThat(limboPlayer.getWalkSpeed(), equalTo(walkSpeed));
|
||||
assertThat(limboPlayer.isCanFly(), equalTo(true));
|
||||
assertThat(limboPlayer.getFlySpeed(), equalTo(flySpeed));
|
||||
assertThat(limboPlayer.getGroup(), equalTo(group));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldGetPlayerDataFromDisk() {
|
||||
// given
|
||||
String name = "player01";
|
||||
Player player = mock(Player.class);
|
||||
given(player.getName()).willReturn(name);
|
||||
given(limboPlayerStorage.hasData(player)).willReturn(true);
|
||||
LimboPlayer limboPlayer = mock(LimboPlayer.class);
|
||||
given(limboPlayerStorage.readData(player)).willReturn(limboPlayer);
|
||||
float walkSpeed = 2.4f;
|
||||
given(limboPlayer.getWalkSpeed()).willReturn(walkSpeed);
|
||||
given(limboPlayer.isCanFly()).willReturn(true);
|
||||
float flySpeed = 1.0f;
|
||||
given(limboPlayer.getFlySpeed()).willReturn(flySpeed);
|
||||
String group = "primary-group";
|
||||
given(limboPlayer.getGroup()).willReturn(group);
|
||||
|
||||
// when
|
||||
limboCache.addPlayerData(player);
|
||||
|
||||
// then
|
||||
LimboPlayer result = limboCache.getPlayerData(name);
|
||||
assertThat(result.getWalkSpeed(), equalTo(walkSpeed));
|
||||
assertThat(result.isCanFly(), equalTo(true));
|
||||
assertThat(result.getFlySpeed(), equalTo(flySpeed));
|
||||
assertThat(result.getGroup(), equalTo(group));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldRestorePlayerInfo() {
|
||||
// given
|
||||
String name = "Champ";
|
||||
Player player = mock(Player.class);
|
||||
given(player.getName()).willReturn(name);
|
||||
LimboPlayer limboPlayer = mock(LimboPlayer.class);
|
||||
given(limboPlayer.isOperator()).willReturn(true);
|
||||
float walkSpeed = 2.4f;
|
||||
given(limboPlayer.getWalkSpeed()).willReturn(walkSpeed);
|
||||
given(limboPlayer.isCanFly()).willReturn(true);
|
||||
float flySpeed = 1.0f;
|
||||
given(limboPlayer.getFlySpeed()).willReturn(flySpeed);
|
||||
String group = "primary-group";
|
||||
given(limboPlayer.getGroup()).willReturn(group);
|
||||
getCache().put(name.toLowerCase(), limboPlayer);
|
||||
given(settings.getProperty(PluginSettings.ENABLE_PERMISSION_CHECK)).willReturn(true);
|
||||
given(permissionsManager.hasGroupSupport()).willReturn(true);
|
||||
|
||||
// when
|
||||
limboCache.restoreData(player);
|
||||
|
||||
// then
|
||||
verify(player).setOp(true);
|
||||
verify(player).setWalkSpeed(walkSpeed);
|
||||
verify(player).setAllowFlight(true);
|
||||
verify(player).setFlySpeed(flySpeed);
|
||||
verify(permissionsManager).setGroup(player, group);
|
||||
verify(limboPlayer).clearTasks();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldResetPlayerSpeed() {
|
||||
// given
|
||||
String name = "Champ";
|
||||
Player player = mock(Player.class);
|
||||
given(player.getName()).willReturn(name);
|
||||
LimboPlayer limboPlayer = mock(LimboPlayer.class);
|
||||
given(limboPlayer.isOperator()).willReturn(true);
|
||||
given(limboPlayer.getWalkSpeed()).willReturn(0f);
|
||||
given(limboPlayer.isCanFly()).willReturn(true);
|
||||
given(limboPlayer.getFlySpeed()).willReturn(0f);
|
||||
String group = "primary-group";
|
||||
given(limboPlayer.getGroup()).willReturn(group);
|
||||
getCache().put(name.toLowerCase(), limboPlayer);
|
||||
given(settings.getProperty(PluginSettings.ENABLE_PERMISSION_CHECK)).willReturn(true);
|
||||
given(permissionsManager.hasGroupSupport()).willReturn(true);
|
||||
|
||||
// when
|
||||
limboCache.restoreData(player);
|
||||
|
||||
// then
|
||||
verify(player).setWalkSpeed(0.2f);
|
||||
verify(player).setFlySpeed(0.2f);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldNotInteractWithPlayerIfNoDataAvailable() {
|
||||
// given
|
||||
String name = "player";
|
||||
Player player = mock(Player.class);
|
||||
given(player.getName()).willReturn(name);
|
||||
|
||||
// when
|
||||
limboCache.restoreData(player);
|
||||
|
||||
// then
|
||||
verify(player).getName();
|
||||
verifyNoMoreInteractions(player);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldRemoveAndClearTasks() {
|
||||
// given
|
||||
LimboPlayer limboPlayer = mock(LimboPlayer.class);
|
||||
String name = "abcdef";
|
||||
getCache().put(name, limboPlayer);
|
||||
Player player = mock(Player.class);
|
||||
given(player.getName()).willReturn(name);
|
||||
|
||||
// when
|
||||
limboCache.removeFromCache(player);
|
||||
|
||||
// then
|
||||
assertThat(getCache(), anEmptyMap());
|
||||
verify(limboPlayer).clearTasks();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldDeleteFromCacheAndStorage() {
|
||||
// given
|
||||
LimboPlayer limboPlayer = mock(LimboPlayer.class);
|
||||
String name = "SomeName";
|
||||
getCache().put(name.toLowerCase(), limboPlayer);
|
||||
getCache().put("othername", mock(LimboPlayer.class));
|
||||
Player player = mock(Player.class);
|
||||
given(player.getName()).willReturn(name);
|
||||
|
||||
// when
|
||||
limboCache.deletePlayerData(player);
|
||||
|
||||
// then
|
||||
assertThat(getCache(), aMapWithSize(1));
|
||||
verify(limboPlayer).clearTasks();
|
||||
verify(limboPlayerStorage).removeData(player);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldReturnIfHasData() {
|
||||
// given
|
||||
String name = "tester";
|
||||
getCache().put(name, mock(LimboPlayer.class));
|
||||
|
||||
// when / then
|
||||
assertThat(limboCache.hasPlayerData(name), equalTo(true));
|
||||
assertThat(limboCache.hasPlayerData("someone_else"), equalTo(false));
|
||||
}
|
||||
|
||||
private Map<String, LimboPlayer> getCache() {
|
||||
return ReflectionTestUtils.getFieldValue(LimboCache.class, limboCache, "cache");
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user