Meishin/LoginSystem
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'master' of https://github.com/AuthMe-Team/AuthMeReloaded into configme-integration

Browse Source 
Conflicts:
	pom.xml
This commit is contained in:
ljacqu
2016-09-04 15:25:18 +02:00
parent 34a2b46768 6857bd929e
commit 09f403f357
22 changed files with 529 additions and 381 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/test/java/fr/xephi/authme/command/executable/authme/ConverterCommandTest.java
+57 -27
View File
@@ -3,25 +3,30 @@ package fr.xephi.authme.command.executable.authme;
import ch.jalu.injector.Injector;
import fr.xephi.authme.TestHelper;
import fr.xephi.authme.command.CommandService;
import fr.xephi.authme.converter.RakamakConverter;
import fr.xephi.authme.converter.Converter;
import fr.xephi.authme.output.MessageKey;
import fr.xephi.authme.util.BukkitService;
import fr.xephi.authme.util.StringUtils;
import org.bukkit.command.CommandSender;
import org.junit.BeforeClass;
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.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import static org.hamcrest.Matchers.hasItem;
import static org.hamcrest.Matchers.not;
import static org.hamcrest.Matchers.nullValue;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.argThat;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
@@ -45,6 +50,11 @@ public class ConverterCommandTest {
@Mock
private Injector injector;
@BeforeClass
public static void initLogger() {
TestHelper.setupLogger();
}
@Test
public void shouldHandleUnknownConversionType() {
// given
@@ -54,51 +64,71 @@ public class ConverterCommandTest {
command.executeCommand(sender, Collections.singletonList("invalid"));
// then
verify(commandService).send(sender, MessageKey.ERROR);
verify(sender).sendMessage(argThat(containsString("Converter does not exist")));
verifyNoMoreInteractions(commandService);
verifyZeroInteractions(injector);
verifyZeroInteractions(bukkitService);
}
@Test
public void shouldHaveUniqueNameAndClassForEachType() {
public void shouldHaveUniqueClassForEachConverter() {
// given
ConverterCommand.ConvertType[] types = ConverterCommand.ConvertType.values();
List<String> names = new ArrayList<>(types.length);
List<Class<?>> classes = new ArrayList<>(types.length);
Set<Class<? extends Converter>> classes = new HashSet<>();
// when / then
for (ConverterCommand.ConvertType type : types) {
assertThat("Name for '" + type + "' is not null",
type.getName(), not(nullValue()));
assertThat("Class for '" + type + "' is not null",
type.getConverterClass(), not(nullValue()));
assertThat("Name '" + type.getName() + "' is unique",
names, not(hasItem(type.getName())));
assertThat("Class '" + type.getConverterClass() + "' is unique",
classes, not(hasItem(type.getConverterClass())));
names.add(type.getName());
classes.add(type.getConverterClass());
for (Map.Entry<String, Class<? extends Converter>> entry : ConverterCommand.CONVERTERS.entrySet()) {
assertThat("Name is not null or empty",
StringUtils.isEmpty(entry.getKey()), equalTo(false));
assertThat("Converter class is unique for each entry",
classes.add(entry.getValue()), equalTo(true));
}
}
@Test
public void shouldLaunchConverterForAllTypes() {
// given
ConverterCommand.ConvertType type = ConverterCommand.ConvertType.RAKAMAK;
RakamakConverter converter = mock(RakamakConverter.class);
given(injector.newInstance(RakamakConverter.class)).willReturn(converter);
String converterName = "rakamak";
Class<? extends Converter> converterClass = ConverterCommand.CONVERTERS.get(converterName);
Converter converter = createMockReturnedByInjector(converterClass);
CommandSender sender = mock(CommandSender.class);
// when
command.executeCommand(sender, Collections.singletonList(type.getName()));
command.executeCommand(sender, Collections.singletonList(converterName));
TestHelper.runInnerRunnable(bukkitService);
// then
verify(converter).execute(sender);
verifyNoMoreInteractions(converter);
verify(injector).newInstance(type.getConverterClass());
verify(injector).newInstance(converterClass);
verifyNoMoreInteractions(injector);
}
@Test
public void shouldCatchExceptionInConverterAndInformSender() {
// given
String converterName = "vauth";
Class<? extends Converter> converterClass = ConverterCommand.CONVERTERS.get(converterName);
Converter converter = createMockReturnedByInjector(converterClass);
doThrow(IllegalStateException.class).when(converter).execute(any(CommandSender.class));
CommandSender sender = mock(CommandSender.class);
// when
command.executeCommand(sender, Collections.singletonList(converterName.toUpperCase()));
TestHelper.runInnerRunnable(bukkitService);
// then
verify(converter).execute(sender);
verifyNoMoreInteractions(converter);
verify(injector).newInstance(converterClass);
verifyNoMoreInteractions(injector);
verify(commandService).send(sender, MessageKey.ERROR);
}
private <T extends Converter> T createMockReturnedByInjector(Class<T> clazz) {
T converter = mock(clazz);
given(injector.newInstance(clazz)).willReturn(converter);
return converter;
}
}
src/test/java/fr/xephi/authme/converter/AbstractDataSourceConverterTest.java
+126
View File
@@ -0,0 +1,126 @@
package fr.xephi.authme.converter;
import fr.xephi.authme.TestHelper;
import fr.xephi.authme.cache.auth.PlayerAuth;
import fr.xephi.authme.datasource.DataSource;
import fr.xephi.authme.datasource.DataSourceType;
import org.bukkit.command.CommandSender;
import org.junit.BeforeClass;
import org.junit.Test;
import org.mockito.Mockito;
import java.util.Arrays;
import java.util.List;
import static org.hamcrest.Matchers.containsString;
import static org.mockito.BDDMockito.given;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.argThat;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.only;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.verifyZeroInteractions;
/**
* Test for {@link AbstractDataSourceConverter}.
*/
public class AbstractDataSourceConverterTest {
@BeforeClass
public static void initLogger() {
TestHelper.setupLogger();
}
@Test
public void shouldThrowForDestinationTypeMismatch() {
// given
DataSource destination = mock(DataSource.class);
given(destination.getType()).willReturn(DataSourceType.MYSQL);
DataSourceType destinationType = DataSourceType.SQLITE;
DataSource source = mock(DataSource.class);
Converter converter = new DataSourceConverterTestImpl<>(source, destination, destinationType);
CommandSender sender = mock(CommandSender.class);
// when
converter.execute(sender);
// then
verify(sender).sendMessage(argThat(containsString("Please configure your connection to SQLITE")));
verify(destination, only()).getType();
verifyZeroInteractions(source);
}
@Test
public void shouldHandleSourceThrowingException() {
// given
DataSource source = mock(DataSource.class);
DataSource destination = mock(DataSource.class);
DataSourceType destinationType = DataSourceType.SQLITE;
given(destination.getType()).willReturn(destinationType);
DataSourceConverterTestImpl converter =
Mockito.spy(new DataSourceConverterTestImpl<>(source, destination, destinationType));
doThrow(IllegalStateException.class).when(converter).getSource();
CommandSender sender = mock(CommandSender.class);
// when
converter.execute(sender);
// then
verify(sender).sendMessage("The data source to convert from could not be initialized");
verify(destination, only()).getType();
verifyZeroInteractions(source);
}
@Test
public void shouldConvertAndSkipExistingPlayers() {
// given
DataSource source = mock(DataSource.class);
DataSource destination = mock(DataSource.class);
DataSourceType destinationType = DataSourceType.MYSQL;
given(destination.getType()).willReturn(destinationType);
List<PlayerAuth> auths =
Arrays.asList(mockAuthWithName("Steven"), mockAuthWithName("bobby"), mockAuthWithName("Jack"));
given(source.getAllAuths()).willReturn(auths);
given(destination.isAuthAvailable(auths.get(0).getNickname())).willReturn(true);
Converter converter = new DataSourceConverterTestImpl<>(source, destination, destinationType);
CommandSender sender = mock(CommandSender.class);
// when
converter.execute(sender);
// then
verify(destination).getType();
verify(destination, times(3)).isAuthAvailable(anyString());
verify(destination, times(2)).saveAuth(any(PlayerAuth.class));
verify(destination, times(2)).updateQuitLoc(any(PlayerAuth.class));
verifyNoMoreInteractions(destination);
verify(sender).sendMessage(argThat(containsString(auths.get(0).getNickname())));
verify(sender).sendMessage(argThat(containsString("successfully converted")));
}
private static PlayerAuth mockAuthWithName(String name) {
PlayerAuth auth = mock(PlayerAuth.class);
given(auth.getNickname()).willReturn(name);
return auth;
}
private static class DataSourceConverterTestImpl<S extends DataSource> extends AbstractDataSourceConverter<S> {
private final S source;
DataSourceConverterTestImpl(S source, DataSource destination, DataSourceType destinationType) {
super(destination, destinationType);
this.source = source;
}
@Override
protected S getSource() {
return source;
}
}
}
src/test/java/fr/xephi/authme/converter/ForceFlatToSqliteTest.java
+4 -1
View File
@@ -4,6 +4,7 @@ import com.google.common.io.Files;
import fr.xephi.authme.TestHelper;
import fr.xephi.authme.cache.auth.PlayerAuth;
import fr.xephi.authme.datasource.DataSource;
import fr.xephi.authme.datasource.DataSourceType;
import fr.xephi.authme.datasource.FlatFile;
import org.junit.Before;
import org.junit.BeforeClass;
@@ -20,6 +21,7 @@ import static fr.xephi.authme.AuthMeMatchers.hasAuthBasicData;
import static fr.xephi.authme.AuthMeMatchers.hasAuthLocation;
import static org.hamcrest.Matchers.hasItem;
import static org.junit.Assert.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
@@ -51,10 +53,11 @@ public class ForceFlatToSqliteTest {
public void shouldConvertToSqlite() {
// given
DataSource dataSource = mock(DataSource.class);
given(dataSource.getType()).willReturn(DataSourceType.MYSQL);
ForceFlatToSqlite converter = new ForceFlatToSqlite(flatFile, dataSource);
// when
converter.run();
converter.execute(null);
// then
ArgumentCaptor<PlayerAuth> authCaptor = ArgumentCaptor.forClass(PlayerAuth.class);