Upstream/AuthMeReloaded
1
0
Fork 0
mirror of https://github.com/AuthMe/AuthMeReloaded.git synced 2024-12-18 14:47:47 +01:00
Code Issues Projects Releases Wiki Activity

Merge pull request #1477 from AuthMe/1035-handle-alt-accounts-in-commandsYml

Browse Source 
1035 handle alt accounts in commands yml
This commit is contained in:
ljacqu 2018-01-17 21:49:29 +01:00 committed by GitHub
commit 1e16f251ef
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
15 changed files with 213 additions and 320 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
pom.xml
View File

@ -709,7 +709,7 @@
<dependency>
<groupId>ch.jalu</groupId>
<artifactId>configme</artifactId>
<version>0.4</version>
<version>0.4.1</version>
<scope>compile</scope>
<optional>true</optional>
<exclusions>

4
src/main/java/fr/xephi/authme/process/login/ProcessSyncPlayerLogin.java
View File

@ -107,9 +107,9 @@ public class ProcessSyncPlayerLogin implements SynchronousProcess {
// Login is now finished; we can force all commands
if (isFirstLogin) {
commandManager.runCommandsOnFirstLogin(player);
commandManager.runCommandsOnFirstLogin(player, authsWithSameIp);
}
commandManager.runCommandsOnLogin(player);
commandManager.runCommandsOnLogin(player, authsWithSameIp);
// Send Bungee stuff. The service will check if it is enabled or not.
bungeeSender.connectPlayerOnLogin(player);

42
src/main/java/fr/xephi/authme/settings/SettingsMigrationService.java
View File

@ -2,7 +2,6 @@ package fr.xephi.authme.settings;
import ch.jalu.configme.migration.PlainMigrationService;
import ch.jalu.configme.properties.Property;
import ch.jalu.configme.properties.StringListProperty;
import ch.jalu.configme.resource.PropertyResource;
import com.google.common.base.MoreObjects;
import fr.xephi.authme.ConsoleLogger;
@ -19,7 +18,6 @@ import javax.inject.Inject;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Collections;
import java.util.List;
import java.util.Set;
@ -39,15 +37,6 @@ public class SettingsMigrationService extends PlainMigrationService {
private final File pluginFolder;
// Stores old commands that need to be migrated to the new commands configuration
// We need to store it in here for retrieval when we build the CommandConfig. Retrieving it from the config.yml is
// not possible since this migration service may trigger config.yml to be resaved. As the old command settings
// don't exist in the code anymore, as soon as config.yml is resaved we lose this information.
private List<String> onLoginCommands = Collections.emptyList();
private List<String> onLoginConsoleCommands = Collections.emptyList();
private List<String> onRegisterCommands = Collections.emptyList();
private List<String> onRegisterConsoleCommands = Collections.emptyList();
@Inject
SettingsMigrationService(@DataFolder File pluginFolder) {
this.pluginFolder = pluginFolder;
@ -62,8 +51,6 @@ public class SettingsMigrationService extends PlainMigrationService {
changes = true;
}
gatherOldCommandSettings(resource);
// Note ljacqu 20160211: Concatenating migration methods with | instead of the usual ||
// ensures that all migrations will be performed
return changes
@ -97,35 +84,6 @@ public class SettingsMigrationService extends PlainMigrationService {
return false;
}
// ----------------
// Forced commands relocation (from config.yml to commands.yml)
// ----------------
private void gatherOldCommandSettings(PropertyResource resource) {
onLoginCommands = getStringList(resource, "settings.forceCommands");
onLoginConsoleCommands = getStringList(resource, "settings.forceCommandsAsConsole");
onRegisterCommands = getStringList(resource, "settings.forceRegisterCommands");
onRegisterConsoleCommands = getStringList(resource, "settings.forceRegisterCommandsAsConsole");
}
private List<String> getStringList(PropertyResource resource, String path) {
return new StringListProperty(path).getValue(resource);
}
public List<String> getOnLoginCommands() {
return onLoginCommands;
}
public List<String> getOnLoginConsoleCommands() {
return onLoginConsoleCommands;
}
public List<String> getOnRegisterCommands() {
return onRegisterCommands;
}
public List<String> getOnRegisterConsoleCommands() {
return onRegisterConsoleCommands;
}
// --------
// Specific migrations

12
src/main/java/fr/xephi/authme/settings/commandconfig/CommandConfig.java
View File

@ -11,9 +11,9 @@ import java.util.Map;
public class CommandConfig {
private Map<String, Command> onJoin = new LinkedHashMap<>();
private Map<String, Command> onLogin = new LinkedHashMap<>();
private Map<String, OnLoginCommand> onLogin = new LinkedHashMap<>();
private Map<String, Command> onSessionLogin = new LinkedHashMap<>();
private Map<String, Command> onFirstLogin = new LinkedHashMap<>();
private Map<String, OnLoginCommand> onFirstLogin = new LinkedHashMap<>();
private Map<String, Command> onRegister = new LinkedHashMap<>();
private Map<String, Command> onUnregister = new LinkedHashMap<>();
private Map<String, Command> onLogout = new LinkedHashMap<>();
@ -26,11 +26,11 @@ public class CommandConfig {
this.onJoin = onJoin;
}
public Map<String, Command> getOnLogin() {
public Map<String, OnLoginCommand> getOnLogin() {
return onLogin;
}
public void setOnLogin(Map<String, Command> onLogin) {
public void setOnLogin(Map<String, OnLoginCommand> onLogin) {
this.onLogin = onLogin;
}
@ -42,11 +42,11 @@ public class CommandConfig {
this.onSessionLogin = onSessionLogin;
}
public Map<String, Command> getOnFirstLogin() {
public Map<String, OnLoginCommand> getOnFirstLogin() {
return onFirstLogin;
}
public void setOnFirstLogin(Map<String, Command> onFirstLogin) {
public void setOnFirstLogin(Map<String, OnLoginCommand> onFirstLogin) {
this.onFirstLogin = onFirstLogin;
}

56
src/main/java/fr/xephi/authme/settings/commandconfig/CommandManager.java
View File

@ -17,6 +17,7 @@ import java.io.File;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.function.Predicate;
import static fr.xephi.authme.util.lazytags.TagBuilder.createTag;
@ -32,9 +33,9 @@ public class CommandManager implements Reloadable {
private final List<Tag<Player>> availableTags = buildAvailableTags();
private WrappedTagReplacer<Command, Player> onJoinCommands;
private WrappedTagReplacer<Command, Player> onLoginCommands;
private WrappedTagReplacer<OnLoginCommand, Player> onLoginCommands;
private WrappedTagReplacer<Command, Player> onSessionLoginCommands;
private WrappedTagReplacer<Command, Player> onFirstLoginCommands;
private WrappedTagReplacer<OnLoginCommand, Player> onFirstLoginCommands;
private WrappedTagReplacer<Command, Player> onRegisterCommands;
private WrappedTagReplacer<Command, Player> onUnregisterCommands;
private WrappedTagReplacer<Command, Player> onLogoutCommands;
@ -71,9 +72,12 @@ public class CommandManager implements Reloadable {
* Runs the configured commands for when a player has logged in successfully.
*
* @param player the player that logged in
* @param otherAccounts account names whose IP is the same as the player's
*/
public void runCommandsOnLogin(Player player) {
executeCommands(player, onLoginCommands.getAdaptedItems(player));
public void runCommandsOnLogin(Player player, List<String> otherAccounts) {
final int numberOfOtherAccounts = otherAccounts.size();
executeCommands(player, onLoginCommands.getAdaptedItems(player),
cmd -> shouldCommandBeRun(cmd, numberOfOtherAccounts));
}
/**
@ -89,9 +93,12 @@ public class CommandManager implements Reloadable {
* Runs the configured commands for when a player logs in the first time.
*
* @param player the player that has logged in for the first time
* @param otherAccounts account names whose IP is the same as the player's
*/
public void runCommandsOnFirstLogin(Player player) {
executeCommands(player, onFirstLoginCommands.getAdaptedItems(player));
public void runCommandsOnFirstLogin(Player player, List<String> otherAccounts) {
final int numberOfOtherAccounts = otherAccounts.size();
executeCommands(player, onFirstLoginCommands.getAdaptedItems(player),
cmd -> shouldCommandBeRun(cmd, numberOfOtherAccounts));
}
/**
@ -113,16 +120,29 @@ public class CommandManager implements Reloadable {
}
private void executeCommands(Player player, List<Command> commands) {
for (Command command : commands) {
final String execution = command.getCommand();
if (Executor.CONSOLE.equals(command.getExecutor())) {
bukkitService.dispatchConsoleCommand(execution);
} else {
bukkitService.dispatchCommand(player, execution);
executeCommands(player, commands, c -> true);
}
private <T extends Command> void executeCommands(Player player, List<T> commands, Predicate<T> predicate) {
for (T command : commands) {
if (predicate.test(command)) {
final String execution = command.getCommand();
if (Executor.CONSOLE.equals(command.getExecutor())) {
bukkitService.dispatchConsoleCommand(execution);
} else {
bukkitService.dispatchCommand(player, execution);
}
}
}
}
private static boolean shouldCommandBeRun(OnLoginCommand command, int numberOfOtherAccounts) {
return (!command.getIfNumberOfAccountsAtLeast().isPresent()
|| command.getIfNumberOfAccountsAtLeast().get() <= numberOfOtherAccounts)
&& (!command.getIfNumberOfAccountsLessThan().isPresent()
|| command.getIfNumberOfAccountsLessThan().get() > numberOfOtherAccounts);
}
@Override
public void reload() {
File file = new File(dataFolder, "commands.yml");
@ -132,8 +152,8 @@ public class CommandManager implements Reloadable {
new YamlFileResource(file), commandMigrationService, CommandSettingsHolder.class);
CommandConfig commandConfig = settingsManager.getProperty(CommandSettingsHolder.COMMANDS);
onJoinCommands = newReplacer(commandConfig.getOnJoin());
onLoginCommands = newReplacer(commandConfig.getOnLogin());
onFirstLoginCommands = newReplacer(commandConfig.getOnFirstLogin());
onLoginCommands = newOnLoginCmdReplacer(commandConfig.getOnLogin());
onFirstLoginCommands = newOnLoginCmdReplacer(commandConfig.getOnFirstLogin());
onSessionLoginCommands = newReplacer(commandConfig.getOnSessionLogin());
onRegisterCommands = newReplacer(commandConfig.getOnRegister());
onUnregisterCommands = newReplacer(commandConfig.getOnUnregister());
@ -145,6 +165,14 @@ public class CommandManager implements Reloadable {
(cmd, text) -> new Command(text, cmd.getExecutor()));
}
private WrappedTagReplacer<OnLoginCommand, Player> newOnLoginCmdReplacer(
Map<String, OnLoginCommand> commands) {
return new WrappedTagReplacer<>(availableTags, commands.values(), Command::getCommand,
(cmd, text) -> new OnLoginCommand(text, cmd.getExecutor(), cmd.getIfNumberOfAccountsAtLeast(),
cmd.getIfNumberOfAccountsLessThan()));
}
private List<Tag<Player>> buildAvailableTags() {
return Arrays.asList(
createTag("%p", pl -> pl.getName()),

99
src/main/java/fr/xephi/authme/settings/commandconfig/CommandMigrationService.java
View File

@ -5,15 +5,8 @@ import ch.jalu.configme.properties.Property;
import ch.jalu.configme.resource.PropertyResource;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.ImmutableList;
import fr.xephi.authme.ConsoleLogger;
import fr.xephi.authme.settings.SettingsMigrationService;
import fr.xephi.authme.util.RandomStringUtils;
import javax.inject.Inject;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* Migrates the commands from their old location, in config.yml, to the dedicated commands configuration file.
@ -25,108 +18,20 @@ class CommandMigrationService implements MigrationService {
static final List<String> COMMAND_CONFIG_PROPERTIES = ImmutableList.of(
"onJoin", "onLogin", "onSessionLogin", "onFirstLogin", "onRegister", "onUnregister", "onLogout");
@Inject
private SettingsMigrationService settingsMigrationService;
CommandMigrationService() {
}
@Override
public boolean checkAndMigrate(PropertyResource resource, List<Property<?>> properties) {
final CommandConfig commandConfig = CommandSettingsHolder.COMMANDS.getValue(resource);
final boolean didMoveCommands = transformOldCommands(commandConfig);
if (didMoveCommands || isFileEmpty(resource)) {
if (isFileEmpty(resource)) {
resource.setValue("", commandConfig);
return true;
}
return false;
}
private boolean isFileEmpty(PropertyResource resource) {
private static boolean isFileEmpty(PropertyResource resource) {
return COMMAND_CONFIG_PROPERTIES.stream().anyMatch(property -> resource.getObject(property) == null);
}
/**
* Adds command settings from their old location (in config.yml) to the given command configuration object.
*
* @param commandConfig the command config object to move old commands to
* @return true if commands have been moved, false if no migration was necessary
*/
@VisibleForTesting
boolean transformOldCommands(CommandConfig commandConfig) {
boolean didMoveCommands = false;
for (MigratableCommandSection section : MigratableCommandSection.values()) {
didMoveCommands |= section.convertCommands(settingsMigrationService, commandConfig);
}
return didMoveCommands;
}
/**
* Enum defining the forced command settings that should be moved from config.yml to the new commands.yml file.
*/
private enum MigratableCommandSection {
ON_JOIN(
SettingsMigrationService::getOnLoginCommands,
Executor.PLAYER,
CommandConfig::getOnLogin),
ON_JOIN_CONSOLE(
SettingsMigrationService::getOnLoginConsoleCommands,
Executor.CONSOLE,
CommandConfig::getOnLogin),
ON_REGISTER(
SettingsMigrationService::getOnRegisterCommands,
Executor.PLAYER,
CommandConfig::getOnRegister),
ON_REGISTER_CONSOLE(
SettingsMigrationService::getOnRegisterConsoleCommands,
Executor.CONSOLE,
CommandConfig::getOnRegister);
private final Function<SettingsMigrationService, List<String>> legacyCommandsGetter;
private final Executor executor;
private final Function<CommandConfig, Map<String, Command>> commandMapGetter;
/**
* Constructor.
*
* @param legacyCommandsGetter getter on MigrationService to get the deprecated command entries
* @param executor the executor of the commands
* @param commandMapGetter the getter for the commands map in the new settings structure to add the old
* settings to after conversion
*/
MigratableCommandSection(Function<SettingsMigrationService, List<String>> legacyCommandsGetter,
Executor executor,
Function<CommandConfig, Map<String, Command>> commandMapGetter) {
this.legacyCommandsGetter = legacyCommandsGetter;
this.executor = executor;
this.commandMapGetter = commandMapGetter;
}
/**
* Adds the commands from the sections' settings migration service to the appropriate place in the new
* command config object.
*
* @param settingsMigrationService settings migration service to read old commands from
* @param commandConfig command config object to add converted commands to
* @return true if there were commands to migrate, false otherwise
*/
boolean convertCommands(SettingsMigrationService settingsMigrationService, CommandConfig commandConfig) {
List<Command> commands = legacyCommandsGetter.apply(settingsMigrationService).stream()
.map(cmd -> new Command(cmd, executor)).collect(Collectors.toList());
if (commands.isEmpty()) {
return false;
}
Map<String, Command> commandMap = commandMapGetter.apply(commandConfig);
commands.forEach(cmd -> commandMap.put(RandomStringUtils.generate(10), cmd));
ConsoleLogger.info("Moving " + commands.size() + " commands of type " + this
+ " from config.yml to commands.yml");
return true;
}
}
}

11
src/main/java/fr/xephi/authme/settings/commandconfig/CommandSettingsHolder.java
View File

@ -49,8 +49,17 @@ public final class CommandSettingsHolder implements SettingsHolder {
" executor: CONSOLE",
"",
"Supported command events: onLogin, onSessionLogin, onFirstLogin, onJoin, onLogout, onRegister, "
+ "onUnregister"
+ "onUnregister",
"",
"For onLogin and onFirstLogin, you can use 'ifNumberOfAccountsLessThan' and 'ifNumberOfAccountsAtLeast'",
"to specify limits to how many accounts a player can have (matched by IP) for a command to be run:",
"onLogin:",
" warnOnManyAccounts:",
" command: 'say Uh oh! %p has many alt accounts!'",
" executor: CONSOLE",
" ifNumberOfAccountsAtLeast: 5"
};
Map<String, String[]> commentMap = new HashMap<>();
commentMap.put("", rootComments);
commentMap.put("onFirstLogin", new String[]{

59
src/main/java/fr/xephi/authme/settings/commandconfig/OnLoginCommand.java Normal file
View File

@ -0,0 +1,59 @@
package fr.xephi.authme.settings.commandconfig;
import java.util.Optional;
/**
* Configurable command for when a player logs in.
*/
public class OnLoginCommand extends Command {
private Optional<Integer> ifNumberOfAccountsAtLeast;
private Optional<Integer> ifNumberOfAccountsLessThan;
/**
* Default constructor (for bean mapping).
*/
public OnLoginCommand() {
}
/**
* Constructor.
*
* @param command the command to execute
* @param executor the executor of the command
*/
public OnLoginCommand(String command, Executor executor) {
super(command, executor);
}
/**
* Constructor.
*
* @param command the command to execute
* @param executor the executor of the command
* @param ifNumberOfAccountsAtLeast required number of accounts for the command to run
* @param ifNumberOfAccountsLessThan max threshold of accounts, from which the command will not be run
*/
public OnLoginCommand(String command, Executor executor, Optional<Integer> ifNumberOfAccountsAtLeast,
Optional<Integer> ifNumberOfAccountsLessThan) {
super(command, executor);
this.ifNumberOfAccountsAtLeast = ifNumberOfAccountsAtLeast;
this.ifNumberOfAccountsLessThan = ifNumberOfAccountsLessThan;
}
public Optional<Integer> getIfNumberOfAccountsAtLeast() {
return ifNumberOfAccountsAtLeast;
}
public void setIfNumberOfAccountsAtLeast(Optional<Integer> ifNumberOfAccountsAtLeast) {
this.ifNumberOfAccountsAtLeast = ifNumberOfAccountsAtLeast;
}
public Optional<Integer> getIfNumberOfAccountsLessThan() {
return ifNumberOfAccountsLessThan;
}
public void setIfNumberOfAccountsLessThan(Optional<Integer> ifNumberOfAccountsLessThan) {
this.ifNumberOfAccountsLessThan = ifNumberOfAccountsLessThan;
}
}

8
src/main/resources/commands.yml
View File

@ -25,6 +25,14 @@
# executor: CONSOLE
#
# Supported command events: onLogin, onSessionLogin, onFirstLogin, onJoin, onLogout, onRegister, onUnregister
#
# For onLogin and onFirstLogin, you can use 'ifNumberOfAccountsLessThan' and 'ifNumberOfAccountsAtLeast'
# to specify limits to how many accounts a player can have (matched by IP) for a command to be run:
# onLogin:
# warnOnManyAccounts:
# command: 'say Uh oh! %p has many alt accounts!'
# executor: CONSOLE
# ifNumberOfAccountsAtLeast: 5
# Commands to run for players logging in whose 'last login date' was empty
onFirstLogin: {}
onJoin: {}

19
src/test/java/fr/xephi/authme/settings/SettingsMigrationServiceTest.java
View File

@ -97,25 +97,6 @@ public class SettingsMigrationServiceTest {
assertThat(migrationService.returnedValues, contains(true, false));
}
@Test
public void shouldKeepOldForceCommandSettings() throws IOException {
// given
File dataFolder = temporaryFolder.newFolder();
File configFile = new File(dataFolder, "config.yml");
Files.copy(getJarFile(OLD_CONFIG_FILE), configFile);
PropertyResource resource = new YamlFileResource(configFile);
SettingsMigrationService migrationService = new SettingsMigrationService(dataFolder);
// when
migrationService.performMigrations(resource, AuthMeSettingsRetriever.buildConfigurationData().getProperties());
// then
assertThat(migrationService.getOnLoginCommands(), contains("spawn"));
assertThat(migrationService.getOnLoginConsoleCommands(), contains("sethome %p:lastloc", "msg %p Welcome back"));
assertThat(migrationService.getOnRegisterCommands(), contains("me registers", "msg CONSOLE hi"));
assertThat(migrationService.getOnRegisterConsoleCommands(), contains("sethome %p:regloc"));
}
private void verifyHasUpToDateSettings(Settings settings, File dataFolder) throws IOException {
assertThat(settings.getProperty(ALLOWED_NICKNAME_CHARACTERS), equalTo(ALLOWED_NICKNAME_CHARACTERS.getDefaultValue()));
assertThat(settings.getProperty(DELAY_JOIN_MESSAGE), equalTo(true));

35
src/test/java/fr/xephi/authme/settings/commandconfig/CommandConfigTestHelper.java
View File

@ -1,35 +0,0 @@
package fr.xephi.authme.settings.commandconfig;
import org.hamcrest.Description;
import org.hamcrest.Matcher;
import org.hamcrest.TypeSafeMatcher;
/**
* Helper class for tests around the command configuration.
*/
final class CommandConfigTestHelper {
private CommandConfigTestHelper() {
}
/**
* Returns a matcher for verifying a {@link Command} object.
*
* @param cmd the expected command line
* @param executor the expected executor
* @return the matcher
*/
static Matcher<Command> isCommand(String cmd, Executor executor) {
return new TypeSafeMatcher<Command>() {
@Override
protected boolean matchesSafely(Command item) {
return executor.equals(item.getExecutor()) && cmd.equals(item.getCommand());
}
@Override
public void describeTo(Description description) {
description.appendText("Command '" + cmd + "' run by '" + executor + "'");
}
};
}
}

76
src/test/java/fr/xephi/authme/settings/commandconfig/CommandManagerTest.java
View File

@ -17,6 +17,8 @@ import org.mockito.junit.MockitoJUnitRunner;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
@ -66,7 +68,7 @@ public class CommandManagerTest {
initManager();
// when
manager.runCommandsOnLogin(player);
manager.runCommandsOnLogin(player, Collections.emptyList());
// then
verify(bukkitService).dispatchConsoleCommand("msg Bobby Welcome back");
@ -76,6 +78,61 @@ public class CommandManagerTest {
verifyZeroInteractions(geoIpService);
}
@Test
public void shouldExecuteCommandsOnLoginWithTwoAlts() {
// given
copyJarFileAsCommandsYml(TEST_FILES_FOLDER + "commands.complete.yml");
initManager();
// when
manager.runCommandsOnLogin(player, Arrays.asList("willy", "nilly", "billy", "silly"));
// then
verify(bukkitService).dispatchConsoleCommand("msg Bobby Welcome back");
verify(bukkitService).dispatchCommand(player, "motd");
verify(bukkitService).dispatchCommand(player, "list");
verify(bukkitService).dispatchConsoleCommand("helpop Player Bobby has more than 1 account");
verifyNoMoreInteractions(bukkitService);
verifyZeroInteractions(geoIpService);
}
@Test
public void shouldExecuteCommandsOnLoginWithFifteenAlts() {
// given
copyJarFileAsCommandsYml(TEST_FILES_FOLDER + "commands.complete.yml");
initManager();
// when
manager.runCommandsOnLogin(player, Collections.nCopies(15, "swag"));
// then
verify(bukkitService).dispatchConsoleCommand("msg Bobby Welcome back");
verify(bukkitService).dispatchCommand(player, "motd");
verify(bukkitService).dispatchCommand(player, "list");
verify(bukkitService).dispatchConsoleCommand("helpop Player Bobby has more than 1 account");
verify(bukkitService).dispatchConsoleCommand("log Bobby 127.0.0.3 many accounts");
verifyNoMoreInteractions(bukkitService);
verifyZeroInteractions(geoIpService);
}
@Test
public void shouldExecuteCommandsOnLoginWithTwentyFiveAlts() {
// given
copyJarFileAsCommandsYml(TEST_FILES_FOLDER + "commands.complete.yml");
initManager();
// when
manager.runCommandsOnLogin(player, Collections.nCopies(25, "yolo"));
// then
verify(bukkitService).dispatchConsoleCommand("msg Bobby Welcome back");
verify(bukkitService).dispatchCommand(player, "motd");
verify(bukkitService).dispatchCommand(player, "list");
verify(bukkitService).dispatchConsoleCommand("helpop Player Bobby has more than 1 account");
verifyNoMoreInteractions(bukkitService);
verifyZeroInteractions(geoIpService);
}
@Test
public void shouldExecuteCommandsOnLoginWithIncompleteConfig() {
// given
@ -83,7 +140,7 @@ public class CommandManagerTest {
initManager();
// when
manager.runCommandsOnLogin(player);
manager.runCommandsOnLogin(player, Collections.emptyList());
// then
verify(bukkitService).dispatchConsoleCommand("msg Bobby Welcome back, bob");
@ -114,7 +171,7 @@ public class CommandManagerTest {
initManager();
// when
manager.runCommandsOnFirstLogin(player);
manager.runCommandsOnFirstLogin(player, Collections.emptyList());
// then
verify(bukkitService).dispatchConsoleCommand("pay Bobby 30");
@ -122,6 +179,19 @@ public class CommandManagerTest {
verifyZeroInteractions(geoIpService);
}
@Test
public void shouldNotExecuteFirstLoginCommandWhoseThresholdIsNotMet() {
// given
copyJarFileAsCommandsYml(TEST_FILES_FOLDER + "commands.complete.yml");
initManager();
// when
manager.runCommandsOnFirstLogin(player, Arrays.asList("u", "wot", "m8"));
// then
verifyZeroInteractions(bukkitService, geoIpService);
}
@Test
public void shouldExecuteCommandsOnJoin() {
// given

84
src/test/java/fr/xephi/authme/settings/commandconfig/CommandMigrationServiceTest.java
View File

@ -6,33 +6,17 @@ import ch.jalu.configme.configurationdata.ConfigurationDataBuilder;
import ch.jalu.configme.resource.PropertyResource;
import ch.jalu.configme.resource.YamlFileResource;
import fr.xephi.authme.TestHelper;
import fr.xephi.authme.settings.SettingsMigrationService;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import java.io.File;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import static fr.xephi.authme.settings.commandconfig.CommandConfigTestHelper.isCommand;
import static java.util.Collections.emptyList;
import static org.hamcrest.Matchers.anEmptyMap;
import static org.hamcrest.Matchers.contains;
import static org.hamcrest.Matchers.containsInAnyOrder;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.sameInstance;
import static org.junit.Assert.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verifyZeroInteractions;
/**
* Test for {@link CommandMigrationService}.
@ -43,79 +27,11 @@ public class CommandMigrationServiceTest {
@InjectMocks
private CommandMigrationService commandMigrationService;
@Mock
private SettingsMigrationService settingsMigrationService;
private CommandConfig commandConfig = new CommandConfig();
@BeforeClass
public static void setUpLogger() {
TestHelper.setupLogger();
}
@Test
public void shouldNotPerformAnyMigration() {
// given
given(settingsMigrationService.getOnLoginCommands()).willReturn(emptyList());
given(settingsMigrationService.getOnLoginConsoleCommands()).willReturn(emptyList());
given(settingsMigrationService.getOnRegisterCommands()).willReturn(emptyList());
given(settingsMigrationService.getOnRegisterConsoleCommands()).willReturn(emptyList());
commandConfig.getOnRegister().put("existing", new Command("existing cmd", Executor.PLAYER));
CommandConfig configSpy = spy(commandConfig);
// when
boolean result = commandMigrationService.transformOldCommands(configSpy);
// then
assertThat(result, equalTo(false));
verifyZeroInteractions(configSpy);
assertThat(configSpy.getOnRegister().keySet(), contains("existing"));
assertThat(configSpy.getOnLogin(), anEmptyMap());
}
@Test
@SuppressWarnings("unchecked")
public void shouldPerformMigration() {
// given
List<String> onLogin = Collections.singletonList("on login command");
given(settingsMigrationService.getOnLoginCommands()).willReturn(onLogin);
List<String> onLoginConsole = Arrays.asList("cmd1", "cmd2 %p", "cmd3");
given(settingsMigrationService.getOnLoginConsoleCommands()).willReturn(onLoginConsole);
given(settingsMigrationService.getOnRegisterCommands()).willReturn(emptyList());
List<String> onRegisterConsole = Arrays.asList("log %p registered", "whois %p");
given(settingsMigrationService.getOnRegisterConsoleCommands()).willReturn(onRegisterConsole);
Map<String, Command> onLoginCommands = new LinkedHashMap<>();
onLoginCommands.put("bcast", new Command("bcast %p returned", Executor.CONSOLE));
commandConfig.setOnLogin(onLoginCommands);
Map<String, Command> onRegisterCommands = new LinkedHashMap<>();
onRegisterCommands.put("ex_cmd", new Command("existing", Executor.CONSOLE));
onRegisterCommands.put("ex_cmd2", new Command("existing2", Executor.PLAYER));
commandConfig.setOnRegister(onRegisterCommands);
// when
boolean result = commandMigrationService.transformOldCommands(commandConfig);
// then
assertThat(result, equalTo(true));
assertThat(commandConfig.getOnLogin(), sameInstance(onLoginCommands));
Collection<Command> loginCmdList = onLoginCommands.values();
assertThat(loginCmdList, contains(
equalTo(onLoginCommands.get("bcast")),
isCommand("on login command", Executor.PLAYER),
isCommand("cmd1", Executor.CONSOLE),
isCommand("cmd2 %p", Executor.CONSOLE),
isCommand("cmd3", Executor.CONSOLE)));
assertThat(commandConfig.getOnRegister(), sameInstance(onRegisterCommands));
Collection<Command> registerCmdList = onRegisterCommands.values();
assertThat(registerCmdList, contains(
isCommand("existing", Executor.CONSOLE),
isCommand("existing2", Executor.PLAYER),
isCommand("log %p registered", Executor.CONSOLE),
isCommand("whois %p", Executor.CONSOLE)));
}
@Test
public void shouldRewriteForEmptyFile() {
// given

16
src/test/java/fr/xephi/authme/settings/commandconfig/CommandYmlConsistencyTest.java
View File

@ -4,22 +4,17 @@ import ch.jalu.configme.configurationdata.ConfigurationDataBuilder;
import ch.jalu.configme.resource.PropertyResource;
import ch.jalu.configme.resource.YamlFileResource;
import fr.xephi.authme.TestHelper;
import fr.xephi.authme.settings.SettingsMigrationService;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import java.io.File;
import java.util.Collections;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.mockito.BDDMockito.given;
/**
* Tests that commands.yml is well-formed.
@ -30,20 +25,9 @@ public class CommandYmlConsistencyTest {
@InjectMocks
private CommandMigrationService commandMigrationService;
@Mock
private SettingsMigrationService settingsMigrationService;
@Rule
public TemporaryFolder temporaryFolder = new TemporaryFolder();
@Before
public void setUpSettingsMigrationService() {
given(settingsMigrationService.getOnLoginCommands()).willReturn(Collections.emptyList());
given(settingsMigrationService.getOnLoginConsoleCommands()).willReturn(Collections.emptyList());
given(settingsMigrationService.getOnRegisterCommands()).willReturn(Collections.emptyList());
given(settingsMigrationService.getOnRegisterConsoleCommands()).willReturn(Collections.emptyList());
}
@Test
public void shouldLoadWithNoMigrations() {
// given

10
src/test/resources/fr/xephi/authme/settings/commandconfig/commands.complete.yml
View File

@ -21,6 +21,15 @@ onLogin:
display_list:
command: 'list'
executor: PLAYER
warn_for_alts:
command: 'helpop Player %p has more than 1 account'
executor: CONSOLE
ifNumberOfAccountsAtLeast: 2
log_suspicious_user:
command: 'log %p %ip many accounts'
executor: CONSOLE
ifNumberOfAccountsAtLeast: 5
ifNumberOfAccountsLessThan: 20
onSessionLogin:
welcome:
command: 'msg %p Session login!'
@ -29,6 +38,7 @@ onFirstLogin:
give_money:
command: 'pay %p 30'
executor: CONSOLE
ifNumberOfAccountsLessThan: 3
onUnregister: {}
onLogout:
announce: