/** * {@inheritDoc} * <p> * Is copied from {@link BlockJUnit4ClassRunner#validateInstanceMethods} because {@link #computeTestMethods()} must * not be called if validation already found errors! */ @Override @Deprecated protected void validateInstanceMethods(List<Throwable> errors) { validatePublicVoidNoArgMethods(After.class, false, errors); validatePublicVoidNoArgMethods(Before.class, false, errors); validateTestMethods(errors); if (errors.isEmpty() && computeTestMethods().size() == 0) { errors.add(new Exception("No runnable methods")); } }
/** * Generates the exploded list of methods that run tests. All methods annotated with {@code @Test} on this class and * super classes that are not overridden are checked if they use a {@code @}{@link DataProvider} or not. If yes, for * each row of the {@link DataProvider}s result a specific, parameterized test method will be added. If not, the * original test method is added. * <p> * Additionally, caches the result as {@link #computeTestMethods()} is call multiple times while test execution by * the JUnit framework (to validate, to filter, to execute, ...). * * @return the exploded list of test methods (never {@code null}) */ @Override protected List<FrameworkMethod> computeTestMethods() { if (computedTestMethods == null) { // Further method for generation is required due to stubbing of "super.computeTestMethods()" is not possible computedTestMethods = generateExplodedTestMethodsFor(super.computeTestMethods()); } return computedTestMethods; }
/** * Returns a {@link TestClass} object wrapping the class to be executed. This method is required for testing because * {@link #getTestClass()} is final and therefore cannot be stubbed :( */ TestClass getTestClassInt() { return getTestClass(); }
for (FrameworkMethod testMethod : getTestClassInt().getAnnotatedMethods(Test.class)) { testValidator.validateTestMethod(testMethod, errors); for (FrameworkMethod testMethod : getTestClassInt().getAnnotatedMethods(UseDataProvider.class)) { FrameworkMethod dataProviderMethod = getDataProviderMethod(testMethod); if (dataProviderMethod == null) { errors.add(new Exception(String.format(
@Test(expected = IllegalStateException.class) public void testValidateTestMethodsShouldThrowIllegalStateExceptionIfDataProviderAnnotationNotFoundOnDataProviderMethod() { // Given: doReturn(asList(testMethod)).when(testClass).getAnnotatedMethods(UseDataProvider.class); doReturn(asList(dataProviderMethod)).when(underTest).getDataProviderMethods(testMethod); List<Throwable> errors = new ArrayList<Throwable>(); // When: underTest.validateTestMethods(errors); // Then: expect exception }
@Test public void testGetDataProviderMethodShouldReturnEmptyListIfUseDataProviderResolversAreEmpty() { // Given: doReturn(useDataProvider).when(testMethod).getAnnotation(UseDataProvider.class); doReturn(dataProviderMethodResolver).when(underTest).getResolverInstanceInt(any(Class.class)); // When: List<FrameworkMethod> result = underTest.getDataProviderMethods(testMethod); // Then: assertThat(result).isEmpty(); assertThat(underTest.dataProviderMethods).containsEntry(testMethod, result); }
@Test public void testGenerateExplodedTestMethodsForShouldCallTestGeneratorWithNotFoundDataProviderMethodAndAddResult() { // Given: doReturn(singletonList(null)).when(underTest).getDataProviderMethods(testMethod); doReturn(asList(testMethod)).when(testGenerator).generateExplodedTestMethodsFor(testMethod, null); // When: List<FrameworkMethod> result = underTest.generateExplodedTestMethodsFor(asList(testMethod)); // Then: assertThat(result).containsOnly(testMethod); verify(testGenerator).generateExplodedTestMethodsFor(testMethod, null); verifyNoMoreInteractions(testGenerator); }
for (FrameworkMethod testMethod : getTestClassInt().getAnnotatedMethods(Test.class)) { testValidator.validateTestMethod(testMethod, errors); for (FrameworkMethod testMethod : getTestClassInt().getAnnotatedMethods(UseDataProvider.class)) { List<FrameworkMethod> dataProviderMethods = getDataProviderMethods(testMethod); if (dataProviderMethods.isEmpty()) { Class<? extends DataProviderMethodResolver>[] resolvers = testMethod.getAnnotation(UseDataProvider.class).resolver();
@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).generateExplodedTestMethodsFor(anyListOf(FrameworkMethod.class)); verifyNoMoreInteractions(underTest); }
@Test public void testValidateInstanceMethodsShouldNotThrowExceptionIfComputeTestMethodsWouldThrowExceptionButErrorsAlreadyExistsBefore() { // Given: List<Throwable> errors = new ArrayList<Throwable>(); doAnswer(new Answer<Void>() { @Override 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: assertThat(errors).hasSize(1); }
@Override protected void validateTestMethods(List<Throwable> errors) { super.validateTestMethods(errors); } }
@Test(expected = IllegalStateException.class) public void testGetResolverInstanceIntShouldThrowIllegalStateExceptionIfDefaultConstructorThrowsException() { // When: underTest.getResolverInstanceInt(ExceptionInDefaultConstructor.class); // 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(); }
/** * Generates the exploded list of test methods for the given {@code testMethods}. Each of the given * {@link FrameworkMethod}s is checked if it uses a {@code @}{@link DataProvider} or not. If yes, for each line of * the {@link DataProvider}s result a specific, parameterized test method will be added. If no, the original test * method is added. * <p> * This method is package private (= visible) for testing. * </p> * * @param testMethods the original test methods * @return the exploded list of test methods (never {@code null}) */ List<FrameworkMethod> generateExplodedTestMethodsFor(List<FrameworkMethod> testMethods) { List<FrameworkMethod> result = new ArrayList<FrameworkMethod>(); if (testMethods == null) { return result; } for (FrameworkMethod testMethod : testMethods) { for (FrameworkMethod dataProviderMethod : getDataProviderMethods(testMethod)) { result.addAll(testGenerator.generateExplodedTestMethodsFor(testMethod, dataProviderMethod)); } } return result; }
@Override protected void collectInitializationErrors(List<Throwable> errors) { // initialize testValidator, testGenerator and dataConverter here because "super" in constructor already calls // this, i.e. fields are not initialized yet but required in super.collectInitializationErrors(errors) ... initializeHelpers(); super.collectInitializationErrors(errors); }
/** * <p> * This method is package private (= visible) for testing. * </p> */ TestClass findDataProviderLocation(UseDataProvider useDataProvider) { if (useDataProvider.location().length == 0) { return getTestClassInt(); } return new TestClass(useDataProvider.location()[0]); }
@Override protected List<FrameworkMethod> computeTestMethods() { return super.computeTestMethods(); }
@Test public void testDataProviderRunner() throws Exception { // Given: Class<?> clazz = DataProviderRunnerTest.class; // When: DataProviderRunner underTest = new DataProviderRunner(clazz); // Then: assertThat(underTest).isNotNull(); assertThat(underTest.getTestClass()).isNotNull(); assertThat(underTest.getTestClass().getJavaClass()).isEqualTo(clazz); }
@SuppressFBWarnings("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; underTest.testValidator = testValidator; underTest.testGenerator = testGenerator; doReturn(testClass).when(underTest).getTestClassInt(); doReturn(useDataProvider).when(testMethod).getAnnotation(UseDataProvider.class); doReturn(anyMethod()).when(testMethod).getMethod(); doReturn("testMethod").when(testMethod).getName(); doReturn(UseDataProvider.DEFAULT_VALUE).when(useDataProvider).value(); doReturn(new Class<?>[] { DataProviderMethodResolver.class }).when(useDataProvider).resolver(); }
@Test public void testValidateTestMethodsShouldCallTestValidatorValidateDataProviderMethodIfDataProviderMethodFound() { // Given: doReturn(asList(testMethod)).when(testClass).getAnnotatedMethods(UseDataProvider.class); doReturn(asList(dataProviderMethod)).when(underTest).getDataProviderMethods(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); }