695 lines
31 KiB
Java
695 lines
31 KiB
Java
/**
|
|
*
|
|
* Copyright 2015-2017 Florian Schmaus
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
package org.igniterealtime.smack.inttest;
|
|
|
|
import static org.reflections.ReflectionUtils.getAllMethods;
|
|
import static org.reflections.ReflectionUtils.withAnnotation;
|
|
import static org.reflections.ReflectionUtils.withModifier;
|
|
import static org.reflections.ReflectionUtils.withParametersCount;
|
|
import static org.reflections.ReflectionUtils.withReturnType;
|
|
|
|
import java.io.IOException;
|
|
import java.lang.reflect.Constructor;
|
|
import java.lang.reflect.InvocationTargetException;
|
|
import java.lang.reflect.Method;
|
|
import java.lang.reflect.Modifier;
|
|
import java.security.KeyManagementException;
|
|
import java.security.NoSuchAlgorithmException;
|
|
import java.util.Collections;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
import java.util.LinkedList;
|
|
import java.util.List;
|
|
import java.util.Locale;
|
|
import java.util.Map;
|
|
import java.util.Map.Entry;
|
|
import java.util.Set;
|
|
import java.util.concurrent.atomic.AtomicInteger;
|
|
import java.util.logging.Level;
|
|
import java.util.logging.Logger;
|
|
|
|
import org.jivesoftware.smack.ConnectionConfiguration.SecurityMode;
|
|
import org.jivesoftware.smack.SmackConfiguration;
|
|
import org.jivesoftware.smack.SmackException;
|
|
import org.jivesoftware.smack.SmackException.NoResponseException;
|
|
import org.jivesoftware.smack.XMPPException;
|
|
import org.jivesoftware.smack.debugger.ConsoleDebugger;
|
|
import org.jivesoftware.smack.tcp.XMPPTCPConnection;
|
|
import org.jivesoftware.smack.tcp.XMPPTCPConnectionConfiguration;
|
|
import org.jivesoftware.smack.util.StringUtils;
|
|
|
|
import org.jivesoftware.smackx.debugger.EnhancedDebugger;
|
|
import org.jivesoftware.smackx.debugger.EnhancedDebuggerWindow;
|
|
import org.jivesoftware.smackx.iqregister.AccountManager;
|
|
|
|
import org.igniterealtime.smack.inttest.IntTestUtil.UsernameAndPassword;
|
|
import org.junit.AfterClass;
|
|
import org.junit.BeforeClass;
|
|
import org.reflections.Reflections;
|
|
import org.reflections.scanners.MethodAnnotationsScanner;
|
|
import org.reflections.scanners.MethodParameterScanner;
|
|
import org.reflections.scanners.SubTypesScanner;
|
|
import org.reflections.scanners.TypeAnnotationsScanner;
|
|
|
|
public class SmackIntegrationTestFramework {
|
|
|
|
private static final Logger LOGGER = Logger.getLogger(SmackIntegrationTestFramework.class.getName());
|
|
private static final char CLASS_METHOD_SEP = '#';
|
|
|
|
protected final Configuration config;
|
|
protected TestRunResult testRunResult;
|
|
private SmackIntegrationTestEnvironment environment;
|
|
|
|
public enum TestType {
|
|
Normal,
|
|
LowLevel,
|
|
}
|
|
|
|
public static void main(String[] args) throws IOException, KeyManagementException,
|
|
NoSuchAlgorithmException, SmackException, XMPPException, InterruptedException {
|
|
Configuration config = Configuration.newConfiguration(args);
|
|
|
|
SmackIntegrationTestFramework sinttest = new SmackIntegrationTestFramework(config);
|
|
TestRunResult testRunResult = sinttest.run();
|
|
|
|
for (Entry<Class<? extends AbstractSmackIntTest>, String> entry : testRunResult.impossibleTestClasses.entrySet()) {
|
|
LOGGER.info("Could not run " + entry.getKey().getName() + " because: "
|
|
+ entry.getValue());
|
|
}
|
|
for (TestNotPossible testNotPossible : testRunResult.impossibleTestMethods) {
|
|
LOGGER.info("Could not run " + testNotPossible.testMethod.getName() + " because: "
|
|
+ testNotPossible.testNotPossibleException.getMessage());
|
|
}
|
|
final int successfulTests = testRunResult.successfulTests.size();
|
|
final int availableTests = testRunResult.getNumberOfAvailableTests();
|
|
final int possibleTests = testRunResult.getNumberOfPossibleTests();
|
|
LOGGER.info("SmackIntegrationTestFramework[" + testRunResult.testRunId + ']' + ": Finished ["
|
|
+ successfulTests + '/' + possibleTests + "] (of " + availableTests + " available tests)");
|
|
|
|
int exitStatus;
|
|
if (!testRunResult.failedIntegrationTests.isEmpty()) {
|
|
final int failedTests = testRunResult.failedIntegrationTests.size();
|
|
LOGGER.warning("The following " + failedTests + " tests failed!");
|
|
for (FailedTest failedTest : testRunResult.failedIntegrationTests) {
|
|
final Method method = failedTest.testMethod;
|
|
final String className = method.getDeclaringClass().getName();
|
|
final String methodName = method.getName();
|
|
final Throwable cause = failedTest.failureReason;
|
|
LOGGER.severe(className + CLASS_METHOD_SEP + methodName + " failed: " + cause);
|
|
}
|
|
exitStatus = 2;
|
|
} else {
|
|
LOGGER.info("All possible Smack Integration Tests completed successfully. \\o/");
|
|
exitStatus = 0;
|
|
}
|
|
|
|
switch (config.debugger) {
|
|
case enhanced:
|
|
EnhancedDebuggerWindow.getInstance().waitUntilClosed();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
System.exit(exitStatus);
|
|
}
|
|
|
|
public SmackIntegrationTestFramework(Configuration configuration) {
|
|
this.config = configuration;
|
|
}
|
|
|
|
public synchronized TestRunResult run() throws KeyManagementException, NoSuchAlgorithmException, SmackException,
|
|
IOException, XMPPException, InterruptedException {
|
|
testRunResult = new TestRunResult();
|
|
LOGGER.info("SmackIntegrationTestFramework [" + testRunResult.testRunId + ']' + ": Starting");
|
|
if (config.debugger != Configuration.Debugger.none) {
|
|
// JUL Debugger will not print any information until configured to print log messages of
|
|
// level FINE
|
|
// TODO configure JUL for log?
|
|
SmackConfiguration.addDisabledSmackClass("org.jivesoftware.smack.debugger.JulDebugger");
|
|
SmackConfiguration.DEBUG = true;
|
|
}
|
|
if (config.replyTimeout > 0) {
|
|
SmackConfiguration.setDefaultReplyTimeout(config.replyTimeout);
|
|
}
|
|
if (config.securityMode != SecurityMode.required) {
|
|
AccountManager.sensitiveOperationOverInsecureConnectionDefault(true);
|
|
}
|
|
// TODO print effective configuration
|
|
|
|
String[] testPackages;
|
|
if (config.testPackages == null) {
|
|
testPackages = new String[] { "org.jivesoftware.smackx", "org.jivesoftware.smack" };
|
|
}
|
|
else {
|
|
testPackages = config.testPackages.toArray(new String[config.testPackages.size()]);
|
|
}
|
|
Reflections reflections = new Reflections(testPackages, new SubTypesScanner(),
|
|
new TypeAnnotationsScanner(), new MethodAnnotationsScanner(), new MethodParameterScanner());
|
|
Set<Class<? extends AbstractSmackIntegrationTest>> inttestClasses = reflections.getSubTypesOf(AbstractSmackIntegrationTest.class);
|
|
Set<Class<? extends AbstractSmackLowLevelIntegrationTest>> lowLevelInttestClasses = reflections.getSubTypesOf(AbstractSmackLowLevelIntegrationTest.class);
|
|
|
|
Set<Class<? extends AbstractSmackIntTest>> classes = new HashSet<>(inttestClasses.size()
|
|
+ lowLevelInttestClasses.size());
|
|
classes.addAll(inttestClasses);
|
|
classes.addAll(lowLevelInttestClasses);
|
|
|
|
if (classes.isEmpty()) {
|
|
throw new IllegalStateException("No test classes found");
|
|
}
|
|
|
|
LOGGER.info("SmackIntegrationTestFramework [" + testRunResult.testRunId
|
|
+ "]: Finished scanning for tests, preparing environment");
|
|
environment = prepareEnvironment();
|
|
|
|
try {
|
|
runTests(classes);
|
|
}
|
|
finally {
|
|
// Ensure that the accounts are deleted and disconnected before we continue
|
|
disconnectAndMaybeDelete(environment.conOne);
|
|
disconnectAndMaybeDelete(environment.conTwo);
|
|
disconnectAndMaybeDelete(environment.conThree);
|
|
}
|
|
|
|
return testRunResult;
|
|
}
|
|
|
|
@SuppressWarnings({"unchecked", "Finally"})
|
|
private void runTests(Set<Class<? extends AbstractSmackIntTest>> classes)
|
|
throws NoResponseException, InterruptedException {
|
|
for (Class<? extends AbstractSmackIntTest> testClass : classes) {
|
|
final String testClassName = testClass.getName();
|
|
|
|
if (config.enabledTests != null && !isInSet(testClass, config.enabledTests)) {
|
|
LOGGER.info("Skipping test class " + testClassName + " because it is not enabled");
|
|
continue;
|
|
}
|
|
|
|
if (isInSet(testClass, config.disabledTests)) {
|
|
LOGGER.info("Skipping test class " + testClassName + " because it is disalbed");
|
|
continue;
|
|
}
|
|
|
|
TestType testType;
|
|
if (AbstractSmackLowLevelIntegrationTest.class.isAssignableFrom(testClass)) {
|
|
testType = TestType.LowLevel;
|
|
} else if (AbstractSmackIntegrationTest.class.isAssignableFrom(testClass)) {
|
|
testType = TestType.Normal;
|
|
} else {
|
|
throw new AssertionError();
|
|
}
|
|
List<Method> smackIntegrationTestMethods = new LinkedList<>();
|
|
for (Method method : testClass.getMethods()) {
|
|
if (!method.isAnnotationPresent(SmackIntegrationTest.class)) {
|
|
continue;
|
|
}
|
|
Class<?> retClass = method.getReturnType();
|
|
if (!retClass.equals(Void.TYPE)) {
|
|
LOGGER.warning("SmackIntegrationTest annotation on method that does not return void");
|
|
continue;
|
|
}
|
|
final Class<?>[] parameterTypes = method.getParameterTypes();
|
|
switch (testType) {
|
|
case Normal:
|
|
if (method.getParameterTypes().length > 0) {
|
|
LOGGER.warning("SmackIntegrationTest annotaton on method that takes arguments ");
|
|
continue;
|
|
}
|
|
break;
|
|
case LowLevel:
|
|
for (Class<?> parameterType : parameterTypes) {
|
|
if (!parameterType.isAssignableFrom(XMPPTCPConnection.class)) {
|
|
LOGGER.warning("SmackIntegrationTest low-level test method declares parameter that is not of type XMPPTCPConnection");
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
smackIntegrationTestMethods.add(method);
|
|
}
|
|
|
|
if (smackIntegrationTestMethods.isEmpty()) {
|
|
LOGGER.warning("No integration test methods found");
|
|
continue;
|
|
}
|
|
|
|
Iterator<Method> it = smackIntegrationTestMethods.iterator();
|
|
while (it.hasNext()) {
|
|
final Method method = it.next();
|
|
final String methodName = method.getName();
|
|
if (config.enabledTests != null && !(config.enabledTests.contains(methodName)
|
|
|| isInSet(testClass, config.enabledTests))) {
|
|
LOGGER.fine("Skipping test method " + methodName + " because it is not enabled");
|
|
it.remove();
|
|
continue;
|
|
}
|
|
if (config.disabledTests != null && config.disabledTests.contains(methodName)) {
|
|
LOGGER.info("Skipping test method " + methodName + " because it is disabled");
|
|
it.remove();
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (smackIntegrationTestMethods.isEmpty()) {
|
|
LOGGER.info("All tests in " + testClassName + " are disabled");
|
|
continue;
|
|
}
|
|
|
|
final int detectedTestMethodsCount = smackIntegrationTestMethods.size();
|
|
testRunResult.numberOfAvailableTests.addAndGet(detectedTestMethodsCount);
|
|
testRunResult.numberOfPossibleTests.addAndGet(detectedTestMethodsCount);
|
|
|
|
AbstractSmackIntTest test;
|
|
switch (testType) {
|
|
case Normal: {
|
|
Constructor<? extends AbstractSmackIntegrationTest> cons;
|
|
try {
|
|
cons = ((Class<? extends AbstractSmackIntegrationTest>) testClass).getConstructor(SmackIntegrationTestEnvironment.class);
|
|
}
|
|
catch (NoSuchMethodException | SecurityException e) {
|
|
LOGGER.log(Level.WARNING,
|
|
"Smack Integration Test class could not get constructed (public Con)structor(SmackIntegrationTestEnvironment) missing?)",
|
|
e);
|
|
continue;
|
|
}
|
|
|
|
try {
|
|
test = cons.newInstance(environment);
|
|
}
|
|
catch (InvocationTargetException e) {
|
|
Throwable cause = e.getCause();
|
|
if (cause instanceof TestNotPossibleException) {
|
|
testRunResult.impossibleTestClasses.put(testClass, cause.getMessage());
|
|
testRunResult.numberOfPossibleTests.addAndGet(-detectedTestMethodsCount);
|
|
}
|
|
else {
|
|
throwFatalException(cause);
|
|
LOGGER.log(Level.WARNING, "Could not construct test class", e);
|
|
}
|
|
continue;
|
|
}
|
|
catch (InstantiationException | IllegalAccessException | IllegalArgumentException e) {
|
|
LOGGER.log(Level.WARNING, "todo", e);
|
|
continue;
|
|
}
|
|
} break;
|
|
case LowLevel: {
|
|
Constructor<? extends AbstractSmackLowLevelIntegrationTest> cons;
|
|
try {
|
|
cons = ((Class<? extends AbstractSmackLowLevelIntegrationTest>) testClass).getConstructor(
|
|
SmackIntegrationTestEnvironment.class);
|
|
}
|
|
catch (NoSuchMethodException | SecurityException e) {
|
|
LOGGER.log(Level.WARNING,
|
|
"Smack Integration Test class could not get constructed (public Con)structor(SmackIntegrationTestEnvironment) missing?)",
|
|
e);
|
|
continue;
|
|
}
|
|
|
|
try {
|
|
test = cons.newInstance(environment);
|
|
}
|
|
catch (InvocationTargetException e) {
|
|
Throwable cause = e.getCause();
|
|
if (cause instanceof TestNotPossibleException) {
|
|
testRunResult.impossibleTestClasses.put(testClass, cause.getMessage());
|
|
testRunResult.numberOfPossibleTests.addAndGet(-detectedTestMethodsCount);
|
|
}
|
|
else {
|
|
throwFatalException(cause);
|
|
LOGGER.log(Level.WARNING, "Could not construct test class", e);
|
|
}
|
|
continue;
|
|
}
|
|
catch (InstantiationException | IllegalAccessException | IllegalArgumentException e) {
|
|
LOGGER.log(Level.WARNING, "todo", e);
|
|
continue;
|
|
}
|
|
} break;
|
|
default:
|
|
throw new AssertionError();
|
|
}
|
|
|
|
try {
|
|
// Run the @BeforeClass methods (if any)
|
|
Set<Method> beforeClassMethods = getAllMethods(testClass,
|
|
withAnnotation(BeforeClass.class), withReturnType(Void.TYPE),
|
|
withParametersCount(0), withModifier(Modifier.PUBLIC
|
|
));
|
|
|
|
// See if there are any methods that have the @BeforeClassAnnotation but a wrong signature
|
|
Set<Method> allBeforeClassMethods = getAllMethods(testClass, withAnnotation(BeforeClass.class));
|
|
allBeforeClassMethods.removeAll(beforeClassMethods);
|
|
if (!allBeforeClassMethods.isEmpty()) {
|
|
throw new IllegalArgumentException("@BeforeClass methods with wrong signature found");
|
|
}
|
|
|
|
if (beforeClassMethods.size() == 1) {
|
|
Method beforeClassMethod = beforeClassMethods.iterator().next();
|
|
LOGGER.info("Executing @BeforeClass method of " + testClass);
|
|
try {
|
|
beforeClassMethod.invoke(test);
|
|
}
|
|
catch (InvocationTargetException | IllegalAccessException e) {
|
|
LOGGER.log(Level.SEVERE, "Exception executing @BeforeClass method", e);
|
|
}
|
|
catch (IllegalArgumentException e) {
|
|
throw new AssertionError(e);
|
|
}
|
|
}
|
|
else if (beforeClassMethods.size() > 1) {
|
|
throw new IllegalArgumentException("Only one @BeforeClass method allowed");
|
|
}
|
|
|
|
for (Method testMethod : smackIntegrationTestMethods) {
|
|
final String testPrefix = testClass.getSimpleName() + '.'
|
|
+ testMethod.getName() + " (" + testType + "): ";
|
|
// Invoke all test methods on the test instance
|
|
LOGGER.info(testPrefix + "Start");
|
|
long testStart = System.currentTimeMillis();
|
|
try {
|
|
switch (testType) {
|
|
case Normal:
|
|
testMethod.invoke(test);
|
|
break;
|
|
case LowLevel:
|
|
invokeLowLevel(testMethod, test);
|
|
break;
|
|
}
|
|
LOGGER.info(testPrefix + "Success");
|
|
long testEnd = System.currentTimeMillis();
|
|
testRunResult.successfulTests.add(new SuccessfulTest(testMethod, testStart, testEnd, null));
|
|
}
|
|
catch (InvocationTargetException e) {
|
|
long testEnd = System.currentTimeMillis();
|
|
Throwable cause = e.getCause();
|
|
if (cause instanceof TestNotPossibleException) {
|
|
LOGGER.info(testPrefix + "Not possible");
|
|
testRunResult.impossibleTestMethods.add(new TestNotPossible(testMethod, testStart, testEnd,
|
|
null, (TestNotPossibleException) cause));
|
|
continue;
|
|
}
|
|
Throwable nonFatalFailureReason;
|
|
// junit assert's throw an AssertionError if they fail, those should not be
|
|
// thrown up, as it would be done by throwFatalException()
|
|
if (cause instanceof AssertionError) {
|
|
nonFatalFailureReason = cause;
|
|
} else {
|
|
nonFatalFailureReason = throwFatalException(cause);
|
|
}
|
|
// An integration test failed
|
|
testRunResult.failedIntegrationTests.add(new FailedTest(testMethod, testStart, testEnd, null,
|
|
nonFatalFailureReason));
|
|
LOGGER.log(Level.SEVERE, testPrefix + "Failed", e);
|
|
}
|
|
catch (IllegalArgumentException | IllegalAccessException e) {
|
|
throw new AssertionError(e);
|
|
}
|
|
}
|
|
}
|
|
finally {
|
|
// Run the @AfterClass method (if any)
|
|
Set<Method> afterClassMethods = getAllMethods(testClass,
|
|
withAnnotation(AfterClass.class), withReturnType(Void.TYPE),
|
|
withParametersCount(0), withModifier(Modifier.PUBLIC
|
|
));
|
|
|
|
// See if there are any methods that have the @AfterClassAnnotation but a wrong signature
|
|
Set<Method> allAfterClassMethods = getAllMethods(testClass, withAnnotation(AfterClass.class));
|
|
allAfterClassMethods.removeAll(afterClassMethods);
|
|
if (!allAfterClassMethods.isEmpty()) {
|
|
throw new IllegalArgumentException("@AfterClass methods with wrong signature found");
|
|
}
|
|
|
|
if (afterClassMethods.size() == 1) {
|
|
Method afterClassMethod = afterClassMethods.iterator().next();
|
|
LOGGER.info("Executing @AfterClass method of " + testClass);
|
|
try {
|
|
afterClassMethod.invoke(test);
|
|
}
|
|
catch (InvocationTargetException | IllegalAccessException e) {
|
|
LOGGER.log(Level.SEVERE, "Exception executing @AfterClass method", e);
|
|
}
|
|
catch (IllegalArgumentException e) {
|
|
throw new AssertionError(e);
|
|
}
|
|
}
|
|
else if (afterClassMethods.size() > 1) {
|
|
throw new IllegalArgumentException("Only one @AfterClass method allowed");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void invokeLowLevel(Method testMethod, AbstractSmackIntTest test) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, InterruptedException {
|
|
// We have checked before that every parameter, if any, is of type XMPPTCPConnection
|
|
final int numberOfConnections = testMethod.getParameterTypes().length;
|
|
XMPPTCPConnection[] connections = null;
|
|
try {
|
|
if (numberOfConnections > 0 && !config.isAccountRegistrationPossible()) {
|
|
throw new TestNotPossibleException(
|
|
"Must create accounts for this test, but it's not enabled");
|
|
}
|
|
connections = new XMPPTCPConnection[numberOfConnections];
|
|
for (int i = 0; i < numberOfConnections; ++i) {
|
|
connections[i] = getConnectedConnection(environment, i);
|
|
}
|
|
}
|
|
catch (Exception e) {
|
|
if (e instanceof RuntimeException) {
|
|
throw (RuntimeException) e;
|
|
}
|
|
// Behave like this was an InvocationTargetException
|
|
throw new InvocationTargetException(e);
|
|
}
|
|
try {
|
|
testMethod.invoke(test, (Object[]) connections);
|
|
}
|
|
finally {
|
|
for (int i = 0; i < numberOfConnections; ++i) {
|
|
IntTestUtil.disconnectAndMaybeDelete(connections[i], config);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected void disconnectAndMaybeDelete(XMPPTCPConnection connection) throws InterruptedException {
|
|
IntTestUtil.disconnectAndMaybeDelete(connection, config);
|
|
}
|
|
|
|
protected SmackIntegrationTestEnvironment prepareEnvironment() throws SmackException,
|
|
IOException, XMPPException, InterruptedException, KeyManagementException,
|
|
NoSuchAlgorithmException {
|
|
XMPPTCPConnection conOne = null;
|
|
XMPPTCPConnection conTwo = null;
|
|
XMPPTCPConnection conThree = null;
|
|
try {
|
|
conOne = getConnectedConnectionFor(AccountNum.One);
|
|
conTwo = getConnectedConnectionFor(AccountNum.Two);
|
|
conThree = getConnectedConnectionFor(AccountNum.Three);
|
|
}
|
|
catch (Exception e) {
|
|
// TODO Reverse the order, i.e. conThree should be disconnected first.
|
|
if (conOne != null) {
|
|
conOne.disconnect();
|
|
}
|
|
if (conTwo != null) {
|
|
conTwo.disconnect();
|
|
}
|
|
if (conThree != null) {
|
|
conThree.disconnect();
|
|
}
|
|
throw e;
|
|
}
|
|
|
|
return new SmackIntegrationTestEnvironment(conOne, conTwo, conThree, testRunResult.testRunId, config);
|
|
}
|
|
|
|
enum AccountNum {
|
|
One,
|
|
Two,
|
|
Three,
|
|
}
|
|
|
|
private static final String USERNAME_PREFIX = "smack-inttest";
|
|
|
|
private XMPPTCPConnection getConnectedConnectionFor(AccountNum accountNum)
|
|
throws SmackException, IOException, XMPPException, InterruptedException,
|
|
KeyManagementException, NoSuchAlgorithmException {
|
|
String middlefix;
|
|
String accountUsername;
|
|
String accountPassword;
|
|
switch (accountNum) {
|
|
case One:
|
|
accountUsername = config.accountOneUsername;
|
|
accountPassword = config.accountOnePassword;
|
|
middlefix = "one";
|
|
break;
|
|
case Two:
|
|
accountUsername = config.accountTwoUsername;
|
|
accountPassword = config.accountTwoPassword;
|
|
middlefix = "two";
|
|
break;
|
|
case Three:
|
|
accountUsername = config.accountThreeUsername;
|
|
accountPassword = config.accountThreePassword;
|
|
middlefix = "three";
|
|
break;
|
|
default:
|
|
throw new IllegalStateException();
|
|
}
|
|
if (StringUtils.isNullOrEmpty(accountUsername)) {
|
|
accountUsername = USERNAME_PREFIX + '-' + middlefix + '-' + testRunResult.testRunId;
|
|
}
|
|
if (StringUtils.isNullOrEmpty(accountPassword)) {
|
|
accountPassword = StringUtils.insecureRandomString(16);
|
|
}
|
|
|
|
XMPPTCPConnectionConfiguration.Builder builder = getConnectionConfigurationBuilder(config);
|
|
builder.setUsernameAndPassword(accountUsername, accountPassword)
|
|
.setResource(middlefix + '-' + testRunResult.testRunId);
|
|
|
|
XMPPTCPConnection connection = new XMPPTCPConnection(builder.build());
|
|
connection.connect();
|
|
if (config.isAccountRegistrationPossible()) {
|
|
UsernameAndPassword uap = IntTestUtil.registerAccount(connection, accountUsername, accountPassword, config);
|
|
|
|
// TODO is this still required?
|
|
// Some servers, e.g. Openfire, do not support a login right after the account was
|
|
// created, so disconnect and re-connection the connection first.
|
|
connection.disconnect();
|
|
connection.connect();
|
|
|
|
connection.login(uap.username, uap.password);
|
|
} else {
|
|
connection.login();
|
|
}
|
|
|
|
return connection;
|
|
}
|
|
|
|
static XMPPTCPConnectionConfiguration.Builder getConnectionConfigurationBuilder(Configuration config) {
|
|
XMPPTCPConnectionConfiguration.Builder builder = XMPPTCPConnectionConfiguration.builder();
|
|
if (config.tlsContext != null) {
|
|
builder.setCustomSSLContext(config.tlsContext);
|
|
}
|
|
builder.setSecurityMode(config.securityMode);
|
|
builder.setXmppDomain(config.service);
|
|
|
|
switch (config.debugger) {
|
|
case enhanced:
|
|
builder.setDebuggerFactory(EnhancedDebugger.Factory.INSTANCE);
|
|
break;
|
|
case console:
|
|
builder.setDebuggerFactory(ConsoleDebugger.Factory.INSTANCE);
|
|
break;
|
|
case none:
|
|
// Nothing to do :).
|
|
break;
|
|
}
|
|
|
|
return builder;
|
|
}
|
|
|
|
static XMPPTCPConnection getConnectedConnection(SmackIntegrationTestEnvironment environment, int connectionId)
|
|
throws KeyManagementException, NoSuchAlgorithmException, InterruptedException,
|
|
SmackException, IOException, XMPPException {
|
|
Configuration config = environment.configuration;
|
|
XMPPTCPConnectionConfiguration.Builder builder = getConnectionConfigurationBuilder(config);
|
|
|
|
XMPPTCPConnection connection = new XMPPTCPConnection(builder.build());
|
|
connection.connect();
|
|
UsernameAndPassword uap = IntTestUtil.registerAccount(connection, environment, connectionId);
|
|
connection.login(uap.username, uap.password);
|
|
return connection;
|
|
}
|
|
|
|
private static Exception throwFatalException(Throwable e) throws Error, NoResponseException,
|
|
InterruptedException {
|
|
if (e instanceof NoResponseException) {
|
|
throw (NoResponseException) e;
|
|
}
|
|
if (e instanceof InterruptedException) {
|
|
throw (InterruptedException) e;
|
|
}
|
|
if (e instanceof RuntimeException) {
|
|
throw (RuntimeException) e;
|
|
}
|
|
if (e instanceof Error) {
|
|
throw (Error) e;
|
|
}
|
|
return (Exception) e;
|
|
}
|
|
|
|
private static boolean isInSet(Class<?> clz, Set<String> classes) {
|
|
if (classes == null) {
|
|
return false;
|
|
}
|
|
final String className = clz.getName();
|
|
final String unqualifiedClassName = clz.getSimpleName();
|
|
return (classes.contains(className) || classes.contains(unqualifiedClassName));
|
|
}
|
|
|
|
public static final class TestRunResult {
|
|
|
|
/**
|
|
* A short String of lowercase characters and numbers used to identify a integration test
|
|
* run. We use lowercase characters because this string will eventually be part of the
|
|
* localpart of the used JIDs (and the localpart is case insensitive).
|
|
*/
|
|
public final String testRunId = StringUtils.insecureRandomString(5).toLowerCase(Locale.US);
|
|
|
|
private final List<SuccessfulTest> successfulTests = Collections.synchronizedList(new LinkedList<SuccessfulTest>());
|
|
private final List<FailedTest> failedIntegrationTests = Collections.synchronizedList(new LinkedList<FailedTest>());
|
|
private final List<TestNotPossible> impossibleTestMethods = Collections.synchronizedList(new LinkedList<TestNotPossible>());
|
|
private final Map<Class<? extends AbstractSmackIntTest>, String> impossibleTestClasses = new HashMap<>();
|
|
private final AtomicInteger numberOfAvailableTests = new AtomicInteger();
|
|
private final AtomicInteger numberOfPossibleTests = new AtomicInteger();
|
|
|
|
private TestRunResult() {
|
|
}
|
|
|
|
public String getTestRunId() {
|
|
return testRunId;
|
|
}
|
|
|
|
public int getNumberOfAvailableTests() {
|
|
return numberOfAvailableTests.get();
|
|
}
|
|
|
|
public int getNumberOfPossibleTests() {
|
|
return numberOfPossibleTests.get();
|
|
}
|
|
|
|
public List<SuccessfulTest> getSuccessfulTests() {
|
|
return Collections.unmodifiableList(successfulTests);
|
|
}
|
|
|
|
public List<FailedTest> getFailedTests() {
|
|
return Collections.unmodifiableList(failedIntegrationTests);
|
|
}
|
|
|
|
public List<TestNotPossible> getNotPossibleTests() {
|
|
return Collections.unmodifiableList(impossibleTestMethods);
|
|
}
|
|
|
|
public Map<Class<? extends AbstractSmackIntTest>, String> getImpossibleTestClasses() {
|
|
return Collections.unmodifiableMap(impossibleTestClasses);
|
|
}
|
|
}
|
|
}
|