Upstream/AuthMeReloaded
1
0
Fork 0
mirror of https://github.com/AuthMe/AuthMeReloaded.git synced 2025-03-02 10:41:43 +01:00
Code Issues Projects Releases Wiki Activity

Merge pull request #93 from AuthMe-Team/437-add-email

Browse Source 
437 add email
This commit is contained in:
ljacqu 2016-02-06 21:59:43 +01:00
commit 8d9a287315
17 changed files with 620 additions and 239 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/main/java/fr/xephi/authme/command/CommandInitializer.java
View File

@ -133,7 +133,7 @@ public final class CommandInitializer {
// Register the getemail command
CommandDescription.builder()
.parent(AUTHME_BASE)
.labels("getemail", "getmail", "email", "mail")
.labels("email", "mail", "getemail", "getmail")
.description("Display player's email")
.detailedDescription("Display the email address of the specified player if set.")
.withArgument("player", "Player name", true)
@ -144,7 +144,7 @@ public final class CommandInitializer {
// Register the setemail command
CommandDescription.builder()
.parent(AUTHME_BASE)
.labels("chgemail", "chgmail", "setemail", "setmail")
.labels("setemail", "setmail", "chgemail", "chgmail")
.description("Change player's email")
.detailedDescription("Change the email address of the specified player.")
.withArgument("player", "Player name", false)

3
src/main/java/fr/xephi/authme/command/executable/authme/SetEmailCommand.java
View File

@ -33,6 +33,9 @@ public class SetEmailCommand implements ExecutableCommand {
if (auth == null) {
commandService.send(sender, MessageKey.UNKNOWN_USER);
return;
} else if (commandService.getDataSource().isEmailStored(playerEmail)) {
commandService.send(sender, MessageKey.EMAIL_ALREADY_USED_ERROR);
return;
}
// Set the email address

14
src/main/java/fr/xephi/authme/command/executable/email/AddEmailCommand.java
View File

@ -2,6 +2,8 @@ package fr.xephi.authme.command.executable.email;
import fr.xephi.authme.command.CommandService;
import fr.xephi.authme.command.PlayerCommand;
import fr.xephi.authme.output.MessageKey;
import fr.xephi.authme.util.Utils;
import org.bukkit.entity.Player;
import java.util.List;
@ -10,9 +12,15 @@ public class AddEmailCommand extends PlayerCommand {
@Override
public void runCommand(Player player, List<String> arguments, CommandService commandService) {
String playerMail = arguments.get(0);
String playerMailVerify = arguments.get(1);
String email = arguments.get(0);
String emailConfirmation = arguments.get(1);
commandService.getManagement().performAddEmail(player, playerMail, playerMailVerify);
if (!Utils.isEmailCorrect(email, commandService.getSettings())) {
commandService.send(player, MessageKey.INVALID_EMAIL);
} else if (email.equals(emailConfirmation)) {
commandService.getManagement().performAddEmail(player, email);
} else {
commandService.send(player, MessageKey.CONFIRM_EMAIL_MESSAGE);
}
}
}

5
src/main/java/fr/xephi/authme/datasource/CacheDataSource.java
View File

@ -247,4 +247,9 @@ public class CacheDataSource implements DataSource {
public List<PlayerAuth> getLoggedPlayers() {
return new ArrayList<>(PlayerCache.getInstance().getCache().values());
}
@Override
public boolean isEmailStored(String email) {
return source.isEmailStored(email);
}
}

2
src/main/java/fr/xephi/authme/datasource/DataSource.java
View File

@ -218,6 +218,8 @@ public interface DataSource {
*/
List<PlayerAuth> getLoggedPlayers();
boolean isEmailStored(String email);
enum DataSourceType {
MYSQL,
FILE,

174
src/main/java/fr/xephi/authme/datasource/FlatFile.java
View File

@ -54,13 +54,6 @@ public class FlatFile implements DataSource {
}
}
/**
* Method isAuthAvailable.
*
* @param user String
*
* @return boolean * @see fr.xephi.authme.datasource.DataSource#isAuthAvailable(String)
*/
@Override
public synchronized boolean isAuthAvailable(String user) {
BufferedReader br = null;
@ -99,13 +92,6 @@ public class FlatFile implements DataSource {
return null;
}
/**
* Method saveAuth.
*
* @param auth PlayerAuth
*
* @return boolean * @see fr.xephi.authme.datasource.DataSource#saveAuth(PlayerAuth)
*/
@Override
public synchronized boolean saveAuth(PlayerAuth auth) {
if (isAuthAvailable(auth.getNickname())) {
@ -129,13 +115,6 @@ public class FlatFile implements DataSource {
return true;
}
/**
* Method updatePassword.
*
* @param auth PlayerAuth
*
* @return boolean * @see fr.xephi.authme.datasource.DataSource#updatePassword(PlayerAuth)
*/
@Override
public synchronized boolean updatePassword(PlayerAuth auth) {
return updatePassword(auth.getNickname(), auth.getPassword());
@ -202,13 +181,6 @@ public class FlatFile implements DataSource {
return true;
}
/**
* Method updateSession.
*
* @param auth PlayerAuth
*
* @return boolean * @see fr.xephi.authme.datasource.DataSource#updateSession(PlayerAuth)
*/
@Override
public boolean updateSession(PlayerAuth auth) {
if (!isAuthAvailable(auth.getNickname())) {
@ -268,13 +240,6 @@ public class FlatFile implements DataSource {
return true;
}
/**
* Method updateQuitLoc.
*
* @param auth PlayerAuth
*
* @return boolean * @see fr.xephi.authme.datasource.DataSource#updateQuitLoc(PlayerAuth)
*/
@Override
public boolean updateQuitLoc(PlayerAuth auth) {
if (!isAuthAvailable(auth.getNickname())) {
@ -313,13 +278,6 @@ public class FlatFile implements DataSource {
return true;
}
/**
* Method getIps.
*
* @param ip String
*
* @return int * @see fr.xephi.authme.datasource.DataSource#getIps(String)
*/
@Override
public int getIps(String ip) {
BufferedReader br = null;
@ -350,13 +308,6 @@ public class FlatFile implements DataSource {
}
}
/**
* Method purgeDatabase.
*
* @param until long
*
* @return int * @see fr.xephi.authme.datasource.DataSource#purgeDatabase(long)
*/
@Override
public int purgeDatabase(long until) {
BufferedReader br = null;
@ -403,13 +354,6 @@ public class FlatFile implements DataSource {
return cleared;
}
/**
* Method autoPurgeDatabase.
*
* @param until long
*
* @return List of String * @see fr.xephi.authme.datasource.DataSource#autoPurgeDatabase(long)
*/
@Override
public List<String> autoPurgeDatabase(long until) {
BufferedReader br = null;
@ -456,13 +400,6 @@ public class FlatFile implements DataSource {
return cleared;
}
/**
* Method removeAuth.
*
* @param user String
*
* @return boolean * @see fr.xephi.authme.datasource.DataSource#removeAuth(String)
*/
@Override
public synchronized boolean removeAuth(String user) {
if (!isAuthAvailable(user)) {
@ -507,13 +444,6 @@ public class FlatFile implements DataSource {
return true;
}
/**
* Method getAuth.
*
* @param user String
*
* @return PlayerAuth * @see fr.xephi.authme.datasource.DataSource#getAuth(String)
*/
@Override
public synchronized PlayerAuth getAuth(String user) {
BufferedReader br = null;
@ -556,31 +486,14 @@ public class FlatFile implements DataSource {
return null;
}
/**
* Method close.
*
* @see fr.xephi.authme.datasource.DataSource#close()
*/
@Override
public synchronized void close() {
}
/**
* Method reload.
*
* @see fr.xephi.authme.datasource.DataSource#reload()
*/
@Override
public void reload() {
}
/**
* Method updateEmail.
*
* @param auth PlayerAuth
*
* @return boolean * @see fr.xephi.authme.datasource.DataSource#updateEmail(PlayerAuth)
*/
@Override
public boolean updateEmail(PlayerAuth auth) {
if (!isAuthAvailable(auth.getNickname())) {
@ -619,13 +532,6 @@ public class FlatFile implements DataSource {
return true;
}
/**
* Method getAllAuthsByName.
*
* @param auth PlayerAuth
*
* @return List of String * @see fr.xephi.authme.datasource.DataSource#getAllAuthsByName(PlayerAuth)
*/
@Override
public List<String> getAllAuthsByName(PlayerAuth auth) {
BufferedReader br = null;
@ -656,13 +562,6 @@ public class FlatFile implements DataSource {
}
}
/**
* Method getAllAuthsByIp.
*
* @param ip String
*
* @return List of String * @see fr.xephi.authme.datasource.DataSource#getAllAuthsByIp(String)
*/
@Override
public List<String> getAllAuthsByIp(String ip) {
BufferedReader br = null;
@ -693,13 +592,6 @@ public class FlatFile implements DataSource {
}
}
/**
* Method getAllAuthsByEmail.
*
* @param email String
*
* @return List of String * @see fr.xephi.authme.datasource.DataSource#getAllAuthsByEmail(String)
*/
@Override
public List<String> getAllAuthsByEmail(String email) {
BufferedReader br = null;
@ -730,13 +622,6 @@ public class FlatFile implements DataSource {
}
}
/**
* Method purgeBanned.
*
* @param banned List of String
*
* @see fr.xephi.authme.datasource.DataSource#purgeBanned(List)
*/
@Override
public void purgeBanned(List<String> banned) {
BufferedReader br = null;
@ -778,64 +663,28 @@ public class FlatFile implements DataSource {
}
}
/**
* Method getType.
*
* @return DataSourceType * @see fr.xephi.authme.datasource.DataSource#getType()
*/
@Override
public DataSourceType getType() {
return DataSourceType.FILE;
}
/**
* Method isLogged.
*
* @param user String
*
* @return boolean * @see fr.xephi.authme.datasource.DataSource#isLogged(String)
*/
@Override
public boolean isLogged(String user) {
return PlayerCache.getInstance().isAuthenticated(user);
}
/**
* Method setLogged.
*
* @param user String
*
* @see fr.xephi.authme.datasource.DataSource#setLogged(String)
*/
@Override
public void setLogged(String user) {
}
/**
* Method setUnlogged.
*
* @param user String
*
* @see fr.xephi.authme.datasource.DataSource#setUnlogged(String)
*/
@Override
public void setUnlogged(String user) {
}
/**
* Method purgeLogged.
*
* @see fr.xephi.authme.datasource.DataSource#purgeLogged()
*/
@Override
public void purgeLogged() {
}
/**
* Method getAccountsRegistered.
*
* @return int * @see fr.xephi.authme.datasource.DataSource#getAccountsRegistered()
*/
@Override
public int getAccountsRegistered() {
BufferedReader br = null;
@ -859,14 +708,6 @@ public class FlatFile implements DataSource {
return result;
}
/**
* Method updateName.
*
* @param oldOne String
* @param newOne String
*
* @see fr.xephi.authme.datasource.DataSource#updateName(String, String)
*/
@Override
public void updateName(String oldOne, String newOne) {
PlayerAuth auth = this.getAuth(oldOne);
@ -875,11 +716,6 @@ public class FlatFile implements DataSource {
this.removeAuth(oldOne);
}
/**
* Method getAllAuths.
*
* @return List of PlayerAuth * @see fr.xephi.authme.datasource.DataSource#getAllAuths()
*/
@Override
public List<PlayerAuth> getAllAuths() {
BufferedReader br = null;
@ -927,13 +763,13 @@ public class FlatFile implements DataSource {
return auths;
}
/**
* Method getLoggedPlayers.
*
* @return List of PlayerAuth * @see fr.xephi.authme.datasource.DataSource#getLoggedPlayers()
*/
@Override
public List<PlayerAuth> getLoggedPlayers() {
return new ArrayList<>();
}
@Override
public boolean isEmailStored(String email) {
throw new UnsupportedOperationException("Flat file no longer supported");
}
}

14
src/main/java/fr/xephi/authme/datasource/MySQL.java
View File

@ -1004,6 +1004,20 @@ public class MySQL implements DataSource {
return auths;
}
@Override
public synchronized boolean isEmailStored(String email) {
String sql = "SELECT 1 FROM " + tableName + " WHERE " + columnEmail + " = ?";
try (Connection con = ds.getConnection()) {
PreparedStatement pst = con.prepareStatement(sql);
pst.setString(1, email);
ResultSet rs = pst.executeQuery();
return rs.next();
} catch (SQLException e) {
logSqlException(e);
}
return false;
}
private static void logSqlException(SQLException e) {
ConsoleLogger.logException("Error during SQL operation:", e);
}

27
src/main/java/fr/xephi/authme/datasource/SQLite.java
View File

@ -170,7 +170,7 @@ public class SQLite implements DataSource {
!columnSalt.isEmpty() ? rs.getString(columnSalt) : null);
}
} catch (SQLException ex) {
ConsoleLogger.logException("Error getting password:", ex);
logSqlException(ex);
} finally {
close(rs);
close(pst);
@ -461,7 +461,7 @@ public class SQLite implements DataSource {
}
return countIp;
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
logSqlException(ex);
return new ArrayList<>();
} catch (NullPointerException npe) {
return new ArrayList<>();
@ -529,7 +529,7 @@ public class SQLite implements DataSource {
pst.executeUpdate();
}
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
logSqlException(ex);
} finally {
close(pst);
}
@ -683,6 +683,27 @@ public class SQLite implements DataSource {
return auths;
}
@Override
public synchronized boolean isEmailStored(String email) {
String sql = "SELECT 1 FROM " + tableName + " WHERE " + columnEmail + " = ? COLLATE NOCASE;";
ResultSet rs = null;
try (PreparedStatement ps = con.prepareStatement(sql)) {
ps.setString(1, email);
rs = ps.executeQuery();
return rs.next();
} catch (SQLException e) {
logSqlException(e);
} finally {
close(rs);
}
return false;
}
private static void logSqlException(SQLException e) {
ConsoleLogger.showError("Error while executing SQL statement: " + StringUtils.formatException(e));
ConsoleLogger.writeStackTrace(e);
}
private PlayerAuth buildAuthFromResultSet(ResultSet row) throws SQLException {
String salt = !columnSalt.isEmpty() ? row.getString(columnSalt) : null;

4
src/main/java/fr/xephi/authme/output/MessageKey.java
View File

@ -121,7 +121,9 @@ public enum MessageKey {
ANTIBOT_AUTO_ENABLED_MESSAGE("antibot_auto_enabled"),
ANTIBOT_AUTO_DISABLED_MESSAGE("antibot_auto_disabled", "%m");
ANTIBOT_AUTO_DISABLED_MESSAGE("antibot_auto_disabled", "%m"),
EMAIL_ALREADY_USED_ERROR("email_already_used");
private String key;

9
src/main/java/fr/xephi/authme/process/Management.java
View File

@ -1,6 +1,8 @@
package fr.xephi.authme.process;
import fr.xephi.authme.AuthMe;
import fr.xephi.authme.cache.auth.PlayerCache;
import fr.xephi.authme.process.email.AsyncAddEmail;
import fr.xephi.authme.process.email.AsyncChangeEmail;
import fr.xephi.authme.process.join.AsynchronousJoin;
import fr.xephi.authme.process.login.AsynchronousLogin;
@ -94,11 +96,12 @@ public class Management {
});
}
public void performAddEmail(final Player player, final String newEmail, final String newEmailVerify) {
public void performAddEmail(final Player player, final String newEmail) {
sched.runTaskAsynchronously(plugin, new Runnable() {
@Override
public void run() {
new AsyncChangeEmail(player, plugin, null, newEmail, newEmailVerify, settings).process();
new AsyncAddEmail(player, plugin, newEmail, plugin.getDataSource(),
PlayerCache.getInstance(), settings).process();
}
});
}
@ -107,7 +110,7 @@ public class Management {
sched.runTaskAsynchronously(plugin, new Runnable() {
@Override
public void run() {
new AsyncChangeEmail(player, plugin, oldEmail, newEmail, settings).process();
new AsyncChangeEmail(player, plugin, oldEmail, newEmail, plugin.getDataSource(), PlayerCache.getInstance(), settings).process();
}
});
}

69
src/main/java/fr/xephi/authme/process/email/AsyncAddEmail.java Normal file
View File

@ -0,0 +1,69 @@
package fr.xephi.authme.process.email;
import fr.xephi.authme.AuthMe;
import fr.xephi.authme.cache.auth.PlayerAuth;
import fr.xephi.authme.cache.auth.PlayerCache;
import fr.xephi.authme.datasource.DataSource;
import fr.xephi.authme.output.MessageKey;
import fr.xephi.authme.output.Messages;
import fr.xephi.authme.settings.NewSetting;
import fr.xephi.authme.settings.Settings;
import fr.xephi.authme.util.Utils;
import org.bukkit.entity.Player;
/**
* Async task to add an email to an account.
*/
public class AsyncAddEmail {
private final Player player;
private final String email;
private final Messages messages;
private final DataSource dataSource;
private final PlayerCache playerCache;
private final NewSetting settings;
public AsyncAddEmail(Player player, AuthMe plugin, String email, DataSource dataSource,
PlayerCache playerCache, NewSetting settings) {
this.messages = plugin.getMessages();
this.player = player;
this.email = email;
this.dataSource = dataSource;
this.playerCache = playerCache;
this.settings = settings;
}
public void process() {
String playerName = player.getName().toLowerCase();
if (playerCache.isAuthenticated(playerName)) {
PlayerAuth auth = playerCache.getAuth(playerName);
final String currentEmail = auth.getEmail();
if (currentEmail != null && !"your@email.com".equals(currentEmail)) {
messages.send(player, MessageKey.USAGE_CHANGE_EMAIL);
} else if (!Utils.isEmailCorrect(email, settings)) {
messages.send(player, MessageKey.INVALID_EMAIL);
} else if (dataSource.isEmailStored(email)) {
messages.send(player, MessageKey.EMAIL_ALREADY_USED_ERROR);
} else {
auth.setEmail(email);
playerCache.updatePlayer(auth);
messages.send(player, MessageKey.EMAIL_ADDED_SUCCESS);
}
} else {
sendUnloggedMessage(dataSource);
}
}
private void sendUnloggedMessage(DataSource dataSource) {
if (dataSource.isAuthAvailable(player.getName())) {
messages.send(player, MessageKey.LOGIN_MESSAGE);
} else if (Settings.emailRegistration) {
messages.send(player, MessageKey.REGISTER_EMAIL_MESSAGE);
} else {
messages.send(player, MessageKey.REGISTER_MESSAGE);
}
}
}

97
src/main/java/fr/xephi/authme/process/email/AsyncChangeEmail.java
View File

@ -3,93 +3,78 @@ package fr.xephi.authme.process.email;
import fr.xephi.authme.AuthMe;
import fr.xephi.authme.cache.auth.PlayerAuth;
import fr.xephi.authme.cache.auth.PlayerCache;
import fr.xephi.authme.datasource.DataSource;
import fr.xephi.authme.output.MessageKey;
import fr.xephi.authme.output.Messages;
import fr.xephi.authme.settings.NewSetting;
import fr.xephi.authme.settings.Settings;
import fr.xephi.authme.util.StringUtils;
import fr.xephi.authme.util.Utils;
import org.bukkit.entity.Player;
/**
* Async task for changing the email.
*/
public class AsyncChangeEmail {
private final Player player;
private final AuthMe plugin;
private final String oldEmail;
private final String newEmail;
private final String newEmailVerify;
private final Messages m;
private final NewSetting settings;
private final PlayerCache playerCache;
private final DataSource dataSource;
public AsyncChangeEmail(Player player, AuthMe plugin, String oldEmail, String newEmail, String newEmailVerify,
NewSetting settings) {
public AsyncChangeEmail(Player player, AuthMe plugin, String oldEmail, String newEmail, DataSource dataSource,
PlayerCache playerCache, NewSetting settings) {
this.m = plugin.getMessages();
this.player = player;
this.plugin = plugin;
this.oldEmail = oldEmail;
this.newEmail = newEmail;
this.newEmailVerify = newEmailVerify;
this.playerCache = playerCache;
this.dataSource = dataSource;
this.settings = settings;
}
public AsyncChangeEmail(Player player, AuthMe plugin, String oldEmail, String newEmail, NewSetting settings) {
this(player, plugin, oldEmail, newEmail, newEmail, settings);
}
public void process() {
String playerName = player.getName().toLowerCase();
if (PlayerCache.getInstance().isAuthenticated(playerName)) {
if (!newEmail.equals(newEmailVerify)) {
m.send(player, MessageKey.CONFIRM_EMAIL_MESSAGE);
return;
}
PlayerAuth auth = PlayerCache.getInstance().getAuth(playerName);
String currentEmail = auth.getEmail();
if (oldEmail != null) {
if (StringUtils.isEmpty(currentEmail) || currentEmail.equals("your@email.com")) {
m.send(player, MessageKey.USAGE_ADD_EMAIL);
return;
}
if (!oldEmail.equals(currentEmail)) {
m.send(player, MessageKey.INVALID_OLD_EMAIL);
return;
}
} else {
if (!StringUtils.isEmpty(currentEmail) && !currentEmail.equals("your@email.com")) {
m.send(player, MessageKey.USAGE_CHANGE_EMAIL);
return;
}
}
if (!Utils.isEmailCorrect(newEmail, settings)) {
if (playerCache.isAuthenticated(playerName)) {
PlayerAuth auth = playerCache.getAuth(playerName);
final String currentEmail = auth.getEmail();
if (currentEmail == null) {
m.send(player, MessageKey.USAGE_ADD_EMAIL);
} else if (newEmail == null || !Utils.isEmailCorrect(newEmail, settings)) {
m.send(player, MessageKey.INVALID_NEW_EMAIL);
return;
}
auth.setEmail(newEmail);
if (!plugin.getDataSource().updateEmail(auth)) {
m.send(player, MessageKey.ERROR);
auth.setEmail(currentEmail);
return;
}
PlayerCache.getInstance().updatePlayer(auth);
if (oldEmail == null) {
m.send(player, MessageKey.EMAIL_ADDED_SUCCESS);
player.sendMessage(auth.getEmail());
return;
} else if (!oldEmail.equals(currentEmail)) {
m.send(player, MessageKey.INVALID_OLD_EMAIL);
} else if (dataSource.isEmailStored(newEmail)) {
m.send(player, MessageKey.EMAIL_ALREADY_USED_ERROR);
} else {
saveNewEmail(auth);
}
} else {
outputUnloggedMessage();
}
}
private void saveNewEmail(PlayerAuth auth) {
auth.setEmail(newEmail);
if (dataSource.updateEmail(auth)) {
playerCache.updatePlayer(auth);
m.send(player, MessageKey.EMAIL_CHANGED_SUCCESS);
} else {
if (plugin.getDataSource().isAuthAvailable(playerName)) {
m.send(player, MessageKey.LOGIN_MESSAGE);
} else {
if (Settings.emailRegistration) {
m.send(player, MessageKey.REGISTER_EMAIL_MESSAGE);
} else {
m.send(player, MessageKey.REGISTER_MESSAGE);
}
}
m.send(player, MessageKey.ERROR);
auth.setEmail(newEmail);
}
}
private void outputUnloggedMessage() {
if (dataSource.isAuthAvailable(player.getName())) {
m.send(player, MessageKey.LOGIN_MESSAGE);
} else if (Settings.emailRegistration) {
m.send(player, MessageKey.REGISTER_EMAIL_MESSAGE);
} else {
m.send(player, MessageKey.REGISTER_MESSAGE);
}
}
}

1
src/main/resources/messages/messages_en.yml
View File

@ -57,3 +57,4 @@ email_exists: '&cA recovery email was already sent! You can discard it and send
country_banned: '&4Your country is banned from this server!'
antibot_auto_enabled: '&4[AntiBotService] AntiBot enabled due to the huge number of connections!'
antibot_auto_disabled: '&2[AntiBotService] AntiBot disabled disabled after %m minutes!'
email_already_used: '&4The email address is already being used'

9
src/test/java/fr/xephi/authme/command/executable/email/AddEmailCommandTest.java
View File

@ -2,6 +2,8 @@ package fr.xephi.authme.command.executable.email;
import fr.xephi.authme.command.CommandService;
import fr.xephi.authme.process.Management;
import fr.xephi.authme.settings.NewSetting;
import fr.xephi.authme.util.WrapperMock;
import org.bukkit.command.BlockCommandSender;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@ -27,6 +29,7 @@ public class AddEmailCommandTest {
@Before
public void setUpMocks() {
commandService = mock(CommandService.class);
WrapperMock.createInstance();
}
@Test
@ -49,12 +52,14 @@ public class AddEmailCommandTest {
AddEmailCommand command = new AddEmailCommand();
Management management = mock(Management.class);
given(commandService.getManagement()).willReturn(management);
NewSetting settings = mock(NewSetting.class);
given(commandService.getSettings()).willReturn(settings);
// when
command.executeCommand(sender, Arrays.asList("mail@example", "other_example"), commandService);
command.executeCommand(sender, Arrays.asList("mail@example", "mail@example"), commandService);
// then
verify(management).performAddEmail(sender, "mail@example", "other_example");
verify(management).performAddEmail(sender, "mail@example");
}
}

193
src/test/java/fr/xephi/authme/process/email/AsyncAddEmailTest.java Normal file
View File

@ -0,0 +1,193 @@
package fr.xephi.authme.process.email;
import fr.xephi.authme.AuthMe;
import fr.xephi.authme.cache.auth.PlayerAuth;
import fr.xephi.authme.cache.auth.PlayerCache;
import fr.xephi.authme.datasource.DataSource;
import fr.xephi.authme.output.MessageKey;
import fr.xephi.authme.output.Messages;
import fr.xephi.authme.settings.NewSetting;
import fr.xephi.authme.settings.Settings;
import fr.xephi.authme.util.WrapperMock;
import org.bukkit.entity.Player;
import org.junit.After;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.mockito.BDDMockito.given;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* Test for {@link AsyncAddEmail}.
*/
public class AsyncAddEmailTest {
private Messages messages;
private Player player;
private DataSource dataSource;
private PlayerCache playerCache;
private NewSetting settings;
@BeforeClass
public static void setUp() {
WrapperMock.createInstance();
}
// Clean up the fields to ensure that no test uses elements of another test
@After
public void removeFieldValues() {
messages = null;
player = null;
dataSource = null;
playerCache = null;
}
@Test
public void shouldAddEmail() {
// given
AsyncAddEmail process = createProcess("my.mail@example.org");
given(player.getName()).willReturn("testEr");
given(playerCache.isAuthenticated("tester")).willReturn(true);
PlayerAuth auth = mock(PlayerAuth.class);
given(auth.getEmail()).willReturn(null);
given(playerCache.getAuth("tester")).willReturn(auth);
given(dataSource.isEmailStored("my.mail@example.org")).willReturn(false);
// when
process.process();
// then
verify(messages).send(player, MessageKey.EMAIL_ADDED_SUCCESS);
verify(auth).setEmail("my.mail@example.org");
verify(playerCache).updatePlayer(auth);
}
@Test
public void shouldNotAddMailIfPlayerAlreadyHasEmail() {
// given
AsyncAddEmail process = createProcess("some.mail@example.org");
given(player.getName()).willReturn("my_Player");
given(playerCache.isAuthenticated("my_player")).willReturn(true);
PlayerAuth auth = mock(PlayerAuth.class);
given(auth.getEmail()).willReturn("another@mail.tld");
given(playerCache.getAuth("my_player")).willReturn(auth);
given(dataSource.isEmailStored("some.mail@example.org")).willReturn(false);
// when
process.process();
// then
verify(messages).send(player, MessageKey.USAGE_CHANGE_EMAIL);
verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
}
@Test
public void shouldNotAddMailIfItIsInvalid() {
// given
AsyncAddEmail process = createProcess("invalid_mail");
given(player.getName()).willReturn("my_Player");
given(playerCache.isAuthenticated("my_player")).willReturn(true);
PlayerAuth auth = mock(PlayerAuth.class);
given(auth.getEmail()).willReturn(null);
given(playerCache.getAuth("my_player")).willReturn(auth);
given(dataSource.isEmailStored("invalid_mail")).willReturn(false);
// when
process.process();
// then
verify(messages).send(player, MessageKey.INVALID_EMAIL);
verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
}
@Test
public void shouldNotAddMailIfAlreadyUsed() {
// given
AsyncAddEmail process = createProcess("player@mail.tld");
given(player.getName()).willReturn("TestName");
given(playerCache.isAuthenticated("testname")).willReturn(true);
PlayerAuth auth = mock(PlayerAuth.class);
given(auth.getEmail()).willReturn(null);
given(playerCache.getAuth("testname")).willReturn(auth);
given(dataSource.isEmailStored("player@mail.tld")).willReturn(true);
// when
process.process();
// then
verify(messages).send(player, MessageKey.EMAIL_ALREADY_USED_ERROR);
verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
}
@Test
public void shouldShowLoginMessage() {
// given
AsyncAddEmail process = createProcess("test@mail.com");
given(player.getName()).willReturn("Username12");
given(playerCache.isAuthenticated("username12")).willReturn(false);
given(dataSource.isAuthAvailable("Username12")).willReturn(true);
// when
process.process();
// then
verify(messages).send(player, MessageKey.LOGIN_MESSAGE);
verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
}
@Test
public void shouldShowEmailRegisterMessage() {
// given
AsyncAddEmail process = createProcess("test@mail.com");
given(player.getName()).willReturn("user");
given(playerCache.isAuthenticated("user")).willReturn(false);
given(dataSource.isAuthAvailable("user")).willReturn(false);
Settings.emailRegistration = true;
// when
process.process();
// then
verify(messages).send(player, MessageKey.REGISTER_EMAIL_MESSAGE);
verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
}
@Test
public void shouldShowRegularRegisterMessage() {
// given
AsyncAddEmail process = createProcess("test@mail.com");
given(player.getName()).willReturn("user");
given(playerCache.isAuthenticated("user")).willReturn(false);
given(dataSource.isAuthAvailable("user")).willReturn(false);
Settings.emailRegistration = false;
// when
process.process();
// then
verify(messages).send(player, MessageKey.REGISTER_MESSAGE);
verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
}
/**
* Create an instance of {@link AsyncAddEmail} and save the mcoks to this class' fields.
*
* @param email The email to use
* @return The created process
*/
private AsyncAddEmail createProcess(String email) {
messages = mock(Messages.class);
AuthMe authMe = mock(AuthMe.class);
when(authMe.getMessages()).thenReturn(messages);
player = mock(Player.class);
dataSource = mock(DataSource.class);
playerCache = mock(PlayerCache.class);
settings = mock(NewSetting.class);
return new AsyncAddEmail(player, authMe, email, dataSource, playerCache, settings);
}
}

229
src/test/java/fr/xephi/authme/process/email/AsyncChangeEmailTest.java Normal file
View File

@ -0,0 +1,229 @@
package fr.xephi.authme.process.email;
import fr.xephi.authme.AuthMe;
import fr.xephi.authme.cache.auth.PlayerAuth;
import fr.xephi.authme.cache.auth.PlayerCache;
import fr.xephi.authme.datasource.DataSource;
import fr.xephi.authme.output.MessageKey;
import fr.xephi.authme.output.Messages;
import fr.xephi.authme.settings.NewSetting;
import fr.xephi.authme.settings.Settings;
import fr.xephi.authme.util.WrapperMock;
import org.bukkit.entity.Player;
import org.junit.After;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.mockito.BDDMockito.given;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* Test for {@link AsyncChangeEmail}.
*/
public class AsyncChangeEmailTest {
private Player player;
private Messages messages;
private PlayerCache playerCache;
private DataSource dataSource;
private NewSetting settings;
@BeforeClass
public static void setUp() {
WrapperMock.createInstance();
}
// Prevent the accidental re-use of a field in another test
@After
public void cleanFields() {
player = null;
messages = null;
playerCache = null;
dataSource = null;
}
@Test
public void shouldAddEmail() {
// given
AsyncChangeEmail process = createProcess("old@mail.tld", "new@mail.tld");
given(player.getName()).willReturn("Bobby");
given(playerCache.isAuthenticated("bobby")).willReturn(true);
PlayerAuth auth = authWithMail("old@mail.tld");
given(playerCache.getAuth("bobby")).willReturn(auth);
given(dataSource.updateEmail(auth)).willReturn(true);
// when
process.process();
// then
verify(dataSource).updateEmail(auth);
verify(playerCache).updatePlayer(auth);
verify(messages).send(player, MessageKey.EMAIL_CHANGED_SUCCESS);
}
@Test
public void shouldShowErrorIfSaveFails() {
// given
AsyncChangeEmail process = createProcess("old@mail.tld", "new@mail.tld");
given(player.getName()).willReturn("Bobby");
given(playerCache.isAuthenticated("bobby")).willReturn(true);
PlayerAuth auth = authWithMail("old@mail.tld");
given(playerCache.getAuth("bobby")).willReturn(auth);
given(dataSource.updateEmail(auth)).willReturn(false);
// when
process.process();
// then
verify(dataSource).updateEmail(auth);
verify(playerCache, never()).updatePlayer(auth);
verify(messages).send(player, MessageKey.ERROR);
}
@Test
public void shouldShowAddEmailUsage() {
// given
AsyncChangeEmail process = createProcess("old@mail.tld", "new@mail.tld");
given(player.getName()).willReturn("Bobby");
given(playerCache.isAuthenticated("bobby")).willReturn(true);
PlayerAuth auth = authWithMail(null);
given(playerCache.getAuth("bobby")).willReturn(auth);
// when
process.process();
// then
verify(dataSource, never()).updateEmail(any(PlayerAuth.class));
verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
verify(messages).send(player, MessageKey.USAGE_ADD_EMAIL);
}
@Test
public void shouldRejectInvalidNewMail() {
// given
AsyncChangeEmail process = createProcess("old@mail.tld", "bogus");
given(player.getName()).willReturn("Bobby");
given(playerCache.isAuthenticated("bobby")).willReturn(true);
PlayerAuth auth = authWithMail("old@mail.tld");
given(playerCache.getAuth("bobby")).willReturn(auth);
// when
process.process();
// then
verify(dataSource, never()).updateEmail(any(PlayerAuth.class));
verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
verify(messages).send(player, MessageKey.INVALID_NEW_EMAIL);
}
@Test
public void shouldRejectInvalidOldEmail() {
// given
AsyncChangeEmail process = createProcess("old@mail.tld", "new@mail.tld");
given(player.getName()).willReturn("Bobby");
given(playerCache.isAuthenticated("bobby")).willReturn(true);
PlayerAuth auth = authWithMail("other@address.email");
given(playerCache.getAuth("bobby")).willReturn(auth);
// when
process.process();
// then
verify(dataSource, never()).updateEmail(any(PlayerAuth.class));
verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
verify(messages).send(player, MessageKey.INVALID_OLD_EMAIL);
}
@Test
public void shouldRejectAlreadyUsedEmail() {
// given
AsyncChangeEmail process = createProcess("old@example.com", "new@example.com");
given(player.getName()).willReturn("Username");
given(playerCache.isAuthenticated("username")).willReturn(true);
PlayerAuth auth = authWithMail("old@example.com");
given(playerCache.getAuth("username")).willReturn(auth);
given(dataSource.isEmailStored("new@example.com")).willReturn(true);
// when
process.process();
// then
verify(dataSource, never()).updateEmail(any(PlayerAuth.class));
verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
verify(messages).send(player, MessageKey.EMAIL_ALREADY_USED_ERROR);
}
@Test
public void shouldSendLoginMessage() {
// given
AsyncChangeEmail process = createProcess("old@mail.tld", "new@mail.tld");
given(player.getName()).willReturn("Bobby");
given(playerCache.isAuthenticated("bobby")).willReturn(false);
given(dataSource.isAuthAvailable("Bobby")).willReturn(true);
// when
process.process();
// then
verify(dataSource, never()).updateEmail(any(PlayerAuth.class));
verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
verify(messages).send(player, MessageKey.LOGIN_MESSAGE);
}
@Test
public void shouldShowEmailRegistrationMessage() {
// given
AsyncChangeEmail process = createProcess("old@mail.tld", "new@mail.tld");
given(player.getName()).willReturn("Bobby");
given(playerCache.isAuthenticated("bobby")).willReturn(false);
given(dataSource.isAuthAvailable("Bobby")).willReturn(false);
Settings.emailRegistration = true;
// when
process.process();
// then
verify(dataSource, never()).updateEmail(any(PlayerAuth.class));
verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
verify(messages).send(player, MessageKey.REGISTER_EMAIL_MESSAGE);
}
@Test
public void shouldShowRegistrationMessage() {
// given
AsyncChangeEmail process = createProcess("old@mail.tld", "new@mail.tld");
given(player.getName()).willReturn("Bobby");
given(playerCache.isAuthenticated("bobby")).willReturn(false);
given(dataSource.isAuthAvailable("Bobby")).willReturn(false);
Settings.emailRegistration = false;
// when
process.process();
// then
verify(dataSource, never()).updateEmail(any(PlayerAuth.class));
verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
verify(messages).send(player, MessageKey.REGISTER_MESSAGE);
}
private static PlayerAuth authWithMail(String email) {
PlayerAuth auth = mock(PlayerAuth.class);
when(auth.getEmail()).thenReturn(email);
return auth;
}
private AsyncChangeEmail createProcess(String oldEmail, String newEmail) {
player = mock(Player.class);
messages = mock(Messages.class);
AuthMe authMe = mock(AuthMe.class);
when(authMe.getMessages()).thenReturn(messages);
playerCache = mock(PlayerCache.class);
dataSource = mock(DataSource.class);
settings = mock(NewSetting.class);
return new AsyncChangeEmail(player, authMe, oldEmail, newEmail, dataSource, playerCache, settings);
}
}

5
src/test/java/fr/xephi/authme/util/UtilsTest.java
View File

@ -11,6 +11,7 @@ import fr.xephi.authme.settings.properties.EmailSettings;
import org.bukkit.entity.Player;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
import java.util.Arrays;
@ -70,6 +71,10 @@ public class UtilsTest {
}
@Test
@Ignore
// TODO ljacqu 20160206: Running this test with all others results in an error
// because Utils is used elsewhere. The AuthMe field is set in a static block
// so creating the WrapperMock here will have no effect
public void shouldNotAddToNormalGroupIfPermManagerIsNull() {
// given
Settings.isPermissionCheckEnabled = true;