@Test
public void testFilterShould() throws Exception {
// Given:
Filter filter = Filter.ALL;
// When:
underTest.filter(filter);
// Then:
assertThat(underTest.getDescription().getChildren().size()).isGreaterThan(0);
}
@Test
public void testDataProviderRunner() throws Exception {
// Given:
@SuppressWarnings("rawtypes")
Class clazz = DataProviderRunnerTest.class;
// When:
DataProviderRunner underTest = new DataProviderRunner(clazz);
// Then:
assertThat(underTest).isNotNull();
assertThat(underTest.getTestClass()).isNotNull();
assertThat(underTest.getTestClass().getJavaClass()).isEqualTo(clazz);
}
@edu.umd.cs.findbugs.annotations.SuppressWarnings("ST_WRITE_TO_STATIC_FROM_INSTANCE_METHOD")
@Before
public void setup() throws Exception {
classSetupException = null;
underTest = new DataProviderRunner(DataProviderRunnerTest.class);
MockitoAnnotations.initMocks(this);
underTest.dataConverter = dataConverter; // override default dataConverter
underTest.testValidator = testValidator;
underTest.testGenerator = testGenerator;
underTest.testGenerator = frameworkMethodGenerator;
doReturn(testClass).when(underTest).getTestClassInt();
doReturn(anyMethod()).when(testMethod).getMethod();
doReturn(anyMethod()).when(dataProviderMethod).getMethod();
}
@Test(expected = NullPointerException.class)
public void testValidateTestMethodsShouldThrowNullPointerExceptionIfArgumentIsNull() {
// Given:
// When:
underTest.validateTestMethods(null);
// Then: expect exception
}
@Test(expected = NullPointerException.class)
public void testFilterShouldThrowNullPointerExceptionForNull() throws Exception {
// Given:
// When:
underTest.filter(null);
// Then: expect exception
}
@Test(expected = NullPointerException.class)
public void testValidateInstanceMethodsShouldThrowNullPointerExceptionIfErrorsIsNull() {
// Given:
// When:
underTest.validateInstanceMethods(null);
// Then: expect exception
}
@Test(expected = IllegalArgumentException.class)
public void testGetDataProviderMethodShouldThrowIllegalArgumentExceptionIfTestMethodIsNull() {
// Given:
// When:
underTest.getDataProviderMethod(null);
// Then: expect exception
}
@Test
public void testGenerateExplodedTestMethodsForShouldReturnEmptyListIfArgumentIsNull() {
// Given:
// When:
List<FrameworkMethod> result = underTest.generateExplodedTestMethodsFor(null);
// Then:
assertThat(result).isEmpty();
}
@Test
public void testGetDataProviderMethodShouldReturnNullForNonDataProviderMethod() {
// Given:
doReturn(null).when(testMethod).getAnnotation(UseDataProvider.class);
// When:
FrameworkMethod result = underTest.getDataProviderMethod(testMethod);
// Then:
assertThat(result).isNull();
}
@Test
public void
testComputeTestMethodsShouldCallGenerateExplodedTestMethodsAndCacheResultIfCalledTheFirstTime() {
// Given:
underTest.computedTestMethods = null;
doReturn(new ArrayList<FrameworkMethod>())
.when(underTest)
.generateExplodedTestMethodsFor(anyListOf(FrameworkMethod.class));
// When:
List<FrameworkMethod> result = underTest.computeTestMethods();
// Then:
assertThat(result).isEqualTo(underTest.computedTestMethods);
InOrder inOrder = inOrder(underTest);
inOrder.verify(underTest).computeTestMethods();
inOrder.verify(underTest).invokeBeforeClass();
inOrder.verify(underTest).generateExplodedTestMethodsFor(anyListOf(FrameworkMethod.class));
verifyNoMoreInteractions(underTest);
}
@Test
public void
testFindDataProviderLocationShouldReturnTestClassForNotSetLocationInUseDataProviderAnnotation() {
// Given:
doReturn(new Class<?>[0]).when(useDataProvider).location();
// When:
TestClass result = underTest.findDataProviderLocation(useDataProvider);
// Then:
assertThat(result).isEqualTo(testClass);
}
@Test
public void
testComputeTestMethodsShouldNotCallGenerateExplodedTestMethodsAndUseCachedResultIfCalledTheSecondTime() {
// Given:
final List<FrameworkMethod> expected = new ArrayList<FrameworkMethod>();
underTest.computedTestMethods = expected;
doReturn(expected)
.when(underTest)
.generateExplodedTestMethodsFor(anyListOf(FrameworkMethod.class));
// When:
List<FrameworkMethod> result = underTest.computeTestMethods();
// Then:
assertThat(result).isSameAs(expected);
assertThat(underTest.computedTestMethods).isSameAs(expected);
verify(underTest).computeTestMethods();
verifyNoMoreInteractions(underTest);
}
@Test(expected = IllegalArgumentException.class)
public void
testWithBeforeClassesShouldReturnNewStatementWrapingGivenStatementWhichThrowsStoredFailureOnEvaluation()
throws Throwable {
// Given:
underTest.failure = new IllegalArgumentException();
Statement statement =
new Statement() {
@Override
public void evaluate() {
// to nothing
}
};
// When:
Statement result = underTest.withBeforeClasses(statement);
// Then:
assertThat(result).isNotNull();
result.evaluate();
}
@Test(expected = IllegalStateException.class)
public void
testValidateTestMethodsShouldThrowIllegalStateExceptionIfDataProviderAnnotationNotFoundOnDataProviderMethod() {
// Given:
doReturn(asList(testMethod)).when(testClass).getAnnotatedMethods(UseDataProvider.class);
doReturn(dataProviderMethod).when(underTest).getDataProviderMethod(testMethod);
List<Throwable> errors = new ArrayList<Throwable>();
// When:
underTest.validateTestMethods(errors);
// Then: expect exception
}
@Test
public void
testValidateInstanceMethodsShouldNotThrowExceptionIfNoErrorsExistAndTestMethodsAreAvailable() {
// Given:
List<Throwable> errors = new ArrayList<Throwable>();
doReturn(asList(testMethod)).when(underTest).computeTestMethods();
// When:
underTest.validateInstanceMethods(errors);
// Then:
assertThat(errors).isEmpty();
}
@edu.umd.cs.findbugs.annotations.SuppressWarnings("ST_WRITE_TO_STATIC_FROM_INSTANCE_METHOD")
@Test
public void testInvokeBeforeClassShouldNotThrowButStoreFailure() {
// Given:
Throwable t = new Throwable();
classSetupException = t;
// When:
underTest.invokeBeforeClass();
// Then:
assertThat(underTest.failure).isSameAs(t);
}
@Test
public void
testValidateInstanceMethodsShouldAddExceptionIfComputeTestMethodsReturnsNoTestMethods() {
// Given:
List<Throwable> errors = new ArrayList<Throwable>();
doReturn(asList()).when(underTest).computeTestMethods();
// When:
underTest.validateInstanceMethods(errors);
// Then:
assertThat(errors).hasSize(1);
assertThat(errors.get(0)).hasMessage("No runnable methods");
}
@Test
public void
testValidateTestMethodsShouldCallTestValidatorValidateTestMethodForSingleTestMethod() {
// Given:
doReturn(asList(testMethod)).when(testClass).getAnnotatedMethods(Test.class);
List<Throwable> errors = new ArrayList<Throwable>();
// When:
underTest.validateTestMethods(errors);
// Then:
verify(testValidator).validateTestMethod(testMethod, errors);
verifyNoMoreInteractions(testValidator);
}
@Test
public void
testFindDataProviderLocationShouldReturnTestClassContainingSetLocationInUseDataProviderAnnotation() {
// Given:
final Class<?> dataProviderLocation = DataProviderRunnerTest.class;
doReturn(new Class<?>[] {dataProviderLocation}).when(useDataProvider).location();
// When:
TestClass result = underTest.findDataProviderLocation(useDataProvider);
// Then:
assertThat(result).isNotNull();
// assertThat(result.getJavaClass()).isEqualTo(dataProviderLocation);
assertThat(result.getName()).isEqualTo(dataProviderLocation.getName());
}
@Test
public void testGetDataProviderMethodShouldReturnNullForNotFoundDataProviderMethod() {
// Given:
doReturn(useDataProvider).when(testMethod).getAnnotation(UseDataProvider.class);
doReturn("notAvailableDataProviderMethod").when(useDataProvider).value();
doReturn(testClass).when(underTest).findDataProviderLocation(useDataProvider);
doReturn(asList(dataProviderMethod)).when(testClass).getAnnotatedMethods(DataProvider.class);
doReturn("availableDataProviderMethod").when(dataProviderMethod).getName();
// When:
FrameworkMethod result = underTest.getDataProviderMethod(testMethod);
// Then:
assertThat(result).isNull();
}
@Test
public void
testValidateTestMethodsShouldCallTestValidatorValidateDataProviderMethodIfDataProviderMethodFound() {
// Given:
doReturn(asList(testMethod)).when(testClass).getAnnotatedMethods(UseDataProvider.class);
doReturn(dataProviderMethod).when(underTest).getDataProviderMethod(testMethod);
doReturn(dataProvider).when(dataProviderMethod).getAnnotation(DataProvider.class);
List<Throwable> errors = new ArrayList<Throwable>();
// When:
underTest.validateTestMethods(errors);
// Then:
verify(testValidator).validateDataProviderMethod(dataProviderMethod, dataProvider, errors);
verifyNoMoreInteractions(testValidator);
}
@Test
public void
testGenerateExplodedTestMethodsForShouldCallFrameworkMethodGeneratorWithNotFoundDataProviderMethodAndAddResult() {
// Given:
doReturn(null).when(underTest).getDataProviderMethod(testMethod);
doReturn(asList(testMethod))
.when(frameworkMethodGenerator)
.generateExplodedTestMethodsFor(testMethod, null);
// When:
List<FrameworkMethod> result = underTest.generateExplodedTestMethodsFor(asList(testMethod));
// Then:
assertThat(result).containsOnly(testMethod);
verify(frameworkMethodGenerator).generateExplodedTestMethodsFor(testMethod, null);
verifyNoMoreInteractions(frameworkMethodGenerator);
}
@Test
public void testGetDataProviderMethodShouldReturnDataProviderMethodIfItExists() {
// Given:
final String dataProviderMethodName = "availableDataProviderMethod";
doReturn(useDataProvider).when(testMethod).getAnnotation(UseDataProvider.class);
doReturn(dataProviderMethodName).when(useDataProvider).value();
doReturn(testClass).when(underTest).findDataProviderLocation(useDataProvider);
doReturn(asList(dataProviderMethod)).when(testClass).getAnnotatedMethods(DataProvider.class);
doReturn(dataProviderMethodName).when(dataProviderMethod).getName();
// When:
FrameworkMethod result = underTest.getDataProviderMethod(testMethod);
// Then:
assertThat(result).isEqualTo(dataProviderMethod);
}
@Test
public void
testValidateTestMethodsShouldCallTestValidatorValidateTestMethodForMultipleTestMethods() {
// Given:
FrameworkMethod testMethod2 = mock(FrameworkMethod.class);
FrameworkMethod testMethod3 = mock(FrameworkMethod.class);
doReturn(asList(testMethod, testMethod2, testMethod3))
.when(testClass)
.getAnnotatedMethods(Test.class);
List<Throwable> errors = new ArrayList<Throwable>();
// When:
underTest.validateTestMethods(errors);
// Then:
verify(testValidator).validateTestMethod(testMethod, errors);
verify(testValidator).validateTestMethod(testMethod2, errors);
verify(testValidator).validateTestMethod(testMethod3, errors);
verifyNoMoreInteractions(testValidator);
}
@Test
public void
testGenerateExplodedTestMethodsForShouldCallFrameworkMethodGeneratorWithFoundDataProviderMethodAndAddResult() {
// Given:
doReturn(dataProviderMethod).when(underTest).getDataProviderMethod(testMethod);
List<FrameworkMethod> explodedMethods = new ArrayList<FrameworkMethod>();
explodedMethods.add(mock(FrameworkMethod.class));
explodedMethods.add(mock(FrameworkMethod.class));
doReturn(explodedMethods)
.when(frameworkMethodGenerator)
.generateExplodedTestMethodsFor(testMethod, dataProviderMethod);
// When:
List<FrameworkMethod> result = underTest.generateExplodedTestMethodsFor(asList(testMethod));
// Then:
assertThat(result).hasSize(2).containsAll(explodedMethods);
verify(frameworkMethodGenerator).generateExplodedTestMethodsFor(testMethod, dataProviderMethod);
verifyNoMoreInteractions(frameworkMethodGenerator);
}
@Test
public void
testValidateTestMethodsShouldWorkCorrectlyForMultipleMethodsAnnotatedWithUseDataProvider() {
// Given:
String dataProviderName = "notFoundDataProvider3";
FrameworkMethod testMethod2 = mock(FrameworkMethod.class);
FrameworkMethod testMethod3 = mock(FrameworkMethod.class);
FrameworkMethod dataProviderMethod2 = mock(FrameworkMethod.class);
DataProvider dataProvider2 = mock(DataProvider.class);
doReturn(asList(testMethod, testMethod2, testMethod3))
.when(testClass)
.getAnnotatedMethods(UseDataProvider.class);
doReturn(dataProviderMethod).when(underTest).getDataProviderMethod(testMethod);
doReturn(dataProvider).when(dataProviderMethod).getAnnotation(DataProvider.class);
doReturn(dataProviderMethod2).when(underTest).getDataProviderMethod(testMethod2);
doReturn(dataProvider2).when(dataProviderMethod2).getAnnotation(DataProvider.class);
doReturn(null).when(underTest).getDataProviderMethod(testMethod3);
doReturn(useDataProvider).when(testMethod3).getAnnotation(UseDataProvider.class);
doReturn(dataProviderName).when(useDataProvider).value();
List<Throwable> errors = new ArrayList<Throwable>();
// When:
underTest.validateTestMethods(errors);
// Then:
assertThat(errors).hasSize(1);
assertThat(errors.get(0).getMessage())
.contains(dataProviderName)
.containsIgnoringCase("no such dataprovider");
verify(testValidator).validateDataProviderMethod(dataProviderMethod, dataProvider, errors);
verify(testValidator).validateDataProviderMethod(dataProviderMethod2, dataProvider2, errors);
verifyNoMoreInteractions(testMethod);
}
@Test
public void
testValidateTestMethodsShouldAddErrorIfDataProviderMethodNotFoundForMethodWithUseDataProvider() {
// Given:
String dataProviderName = "notFoundDataProvider";
doReturn(asList(testMethod)).when(testClass).getAnnotatedMethods(UseDataProvider.class);
doReturn(null).when(underTest).getDataProviderMethod(testMethod);
doReturn(useDataProvider).when(testMethod).getAnnotation(UseDataProvider.class);
doReturn(dataProviderName).when(useDataProvider).value();
List<Throwable> errors = new ArrayList<Throwable>();
// When:
underTest.validateTestMethods(errors);
// Then:
assertThat(errors).hasSize(1);
assertThat(errors.get(0).getMessage())
.contains(dataProviderName)
.containsIgnoringCase("no such dataprovider");
verifyZeroInteractions(testValidator);
}
@Test
public void
testWithBeforeClassesShouldReturnNewStatementWrapingGivenStatementWhichShouldBeExecutedOnEvaluation()
throws Throwable {
// Given:
final AtomicBoolean evaluated = new AtomicBoolean(false);
Statement statement =
new Statement() {
@Override
public void evaluate() {
evaluated.set(true);
}
};
// When:
Statement result = underTest.withBeforeClasses(statement);
// Then:
assertThat(result).isNotNull();
assertThat(evaluated.get()).isFalse();
result.evaluate();
assertThat(evaluated.get()).isTrue();
}
@Test
public void
testValidateInstanceMethodsShouldNotThrowExceptionIfComputeTestMethodsWouldThrowExceptionButErrorsAlreadyExistsBefore() {
// Given:
List<Throwable> errors = new ArrayList<Throwable>();
doAnswer(
new Answer<Void>() {
@SuppressWarnings("unchecked")
public Void answer(InvocationOnMock invocation) throws Throwable {
((List<Throwable>) invocation.getArguments()[0]).add(new Error());
return null;
}
})
.when(underTest)
.validateTestMethods(errors);
doThrow(IllegalArgumentException.class).when(underTest).computeTestMethods();
// When:
underTest.validateInstanceMethods(errors);
// Then: no exception
}
