/** * 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; }
/** * 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; }
/** * 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; }
@Test public void testGetDataProviderMethodShouldReturnedChachedValueIfExists() { // Given: final List<FrameworkMethod> expected = asList(dataProviderMethod, testMethod); underTest.dataProviderMethods = new HashMap<FrameworkMethod, List<FrameworkMethod>>(); underTest.dataProviderMethods.put(testMethod, expected); // When: List<FrameworkMethod> result = underTest.getDataProviderMethods(testMethod); // Then: assertThat(result).isSameAs(expected); }
@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 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); }
@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); }
@Test public void testValidateTestMethodsShouldAddErrorIfDataProviderMethodNotFoundForMethodWithUseDataProviderUsingAdditionalCustomResolver() { // Given: doReturn(asList(testMethod)).when(testClass).getAnnotatedMethods(UseDataProvider.class); doReturn(Collections.emptyList()).when(underTest).getDataProviderMethods(testMethod); doReturn(useDataProvider).when(testMethod).getAnnotation(UseDataProvider.class); doReturn(new Class<?>[] { null, DefaultDataProviderMethodResolver.class }).when(useDataProvider).resolver(); List<Throwable> errors = new ArrayList<Throwable>(); // When: underTest.validateTestMethods(errors); // Then: assertThat(errors).hasSize(1); assertThat(errors.get(0).getMessage()).contains("No valid dataprovider found for test 'testMethod' using custom resolvers: ") .containsIgnoringCase("[null, " + DefaultDataProviderMethodResolver.class + "]. Please examine"); verifyZeroInteractions(testValidator); }
@Test public void testGetDataProviderMethodShouldInitializeMapUsedForCaching() { // Given: doReturn(null).when(testMethod).getAnnotation(UseDataProvider.class); underTest.dataProviderMethods = null; // When: underTest.getDataProviderMethods(testMethod); // Then: assertThat(underTest.dataProviderMethods).isNotNull(); }
@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 testGenerateExplodedTestMethodsForShouldCallTestGeneratorWithFoundDataProviderMethodAndAddResult() { // Given: doReturn(asList(dataProviderMethod)).when(underTest).getDataProviderMethods(testMethod); List<FrameworkMethod> explodedMethods = new ArrayList<FrameworkMethod>(); explodedMethods.add(mock(FrameworkMethod.class)); explodedMethods.add(mock(FrameworkMethod.class)); doReturn(explodedMethods).when(testGenerator).generateExplodedTestMethodsFor(testMethod, dataProviderMethod); // When: List<FrameworkMethod> result = underTest.generateExplodedTestMethodsFor(asList(testMethod)); // Then: assertThat(result).hasSize(2).containsAll(explodedMethods); verify(testGenerator).generateExplodedTestMethodsFor(testMethod, dataProviderMethod); verifyNoMoreInteractions(testGenerator); }
@Test public void testValidateTestMethodsShouldAddErrorIfDataProviderMethodNotFoundForMethodWithUseDataProviderUsingOnlyDefaultResolver() { // Given: doReturn(asList(testMethod)).when(testClass).getAnnotatedMethods(UseDataProvider.class); doReturn(emptyList()).when(underTest).getDataProviderMethods(testMethod); doReturn(useDataProvider).when(testMethod).getAnnotation(UseDataProvider.class); doReturn(new Class<?>[] { DefaultDataProviderMethodResolver.class }).when(useDataProvider).resolver(); List<Throwable> errors = new ArrayList<Throwable>(); // When: underTest.validateTestMethods(errors); // Then: assertThat(errors).hasSize(1); assertThat(errors.get(0).getMessage()) .contains("No valid dataprovider found for test 'testMethod' using the default resolver. By convention") .contains("or is explicitely set"); verifyZeroInteractions(testValidator); }
@Test public void testGetDataProviderMethodShouldReturnEmptyListForNotFoundDataProviderMethod() { // Given: doReturn(useDataProvider).when(testMethod).getAnnotation(UseDataProvider.class); doReturn("notAvailableDataProviderMethod").when(useDataProvider).value(); doReturn(asList(dataProviderMethod)).when(testClass).getAnnotatedMethods(DataProvider.class); doReturn("availableDataProviderMethod").when(dataProviderMethod).getName(); 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); }
List<FrameworkMethod> dataProviderMethods = getDataProviderMethods(testMethod); if (dataProviderMethods.isEmpty()) { Class<? extends DataProviderMethodResolver>[] resolvers = testMethod.getAnnotation(UseDataProvider.class).resolver();
@Test public void testGetDataProviderMethodShouldReturnSingletonListContainingNullForNotFoundUseDataProviderAnnotation() { // Given: doReturn(null).when(testMethod).getAnnotation(UseDataProvider.class); // When: List<FrameworkMethod> result = underTest.getDataProviderMethods(testMethod); // Then: assertThat(result).hasSize(1).containsNull(); assertThat(underTest.dataProviderMethods).containsEntry(testMethod, result); }
List<FrameworkMethod> dataProviderMethods = getDataProviderMethods(testMethod); if (dataProviderMethods.isEmpty()) { Class<? extends DataProviderMethodResolver>[] resolvers = testMethod.getAnnotation(UseDataProvider.class).resolver();
@Test public void testValidateTestMethodsShouldWorkCorrectlyForMultipleMethodsAnnotatedWithUseDataProvider() { // Given: FrameworkMethod testMethod2 = mock(FrameworkMethod.class); UseDataProvider useDataProvider2 = mock(UseDataProvider.class); FrameworkMethod dataProviderMethod2 = mock(FrameworkMethod.class); DataProvider dataProvider2 = mock(DataProvider.class); FrameworkMethod testMethod3 = mock(FrameworkMethod.class); UseDataProvider useDataProvider3 = mock(UseDataProvider.class); doReturn(asList(testMethod, testMethod2, testMethod3)).when(testClass).getAnnotatedMethods(UseDataProvider.class); doReturn(useDataProvider).when(testMethod).getAnnotation(UseDataProvider.class); doReturn(asList(dataProviderMethod)).when(underTest).getDataProviderMethods(testMethod); doReturn(dataProvider).when(dataProviderMethod).getAnnotation(DataProvider.class); doReturn(useDataProvider2).when(testMethod2).getAnnotation(UseDataProvider.class); doReturn(asList(dataProviderMethod2)).when(underTest).getDataProviderMethods(testMethod2); doReturn(dataProvider2).when(dataProviderMethod2).getAnnotation(DataProvider.class); doReturn(useDataProvider3).when(testMethod3).getAnnotation(UseDataProvider.class); doReturn(emptyList()).when(underTest).getDataProviderMethods(testMethod3); doReturn(new Class<?>[] { DataProviderMethodResolver.class }).when(useDataProvider3).resolver(); List<Throwable> errors = new ArrayList<Throwable>(); // When: underTest.validateTestMethods(errors); // Then: assertThat(errors).hasSize(1); assertThat(errors.get(0).getMessage()).containsIgnoringCase("no valid dataprovider found for test"); verify(testValidator).validateDataProviderMethod(dataProviderMethod, dataProvider, errors); verify(testValidator).validateDataProviderMethod(dataProviderMethod2, dataProvider2, errors); verifyNoMoreInteractions(testValidator); }
@Test public void testGetDataProviderMethodShouldReturnFirstNotEmptyListIfResolveStrategyIsUntilFirstMatchAndMultipleResolversWouldMatch() { // Given: final DataProviderMethodResolver resolver2 = mock(DataProviderMethodResolver.class); final DataProviderMethodResolver resolver3 = mock(DataProviderMethodResolver.class); final List<FrameworkMethod> expected2 = Arrays.asList(mock(FrameworkMethod.class), mock(FrameworkMethod.class)); final List<FrameworkMethod> expected3 = Arrays.asList(mock(FrameworkMethod.class)); doReturn(useDataProvider).when(testMethod).getAnnotation(UseDataProvider.class); doReturn(new Class<?>[] { DataProviderMethodResolver.class, DataProviderMethodResolver.class, DataProviderMethodResolver.class }) .when(useDataProvider).resolver(); doReturn(ResolveStrategy.UNTIL_FIRST_MATCH).when(useDataProvider).resolveStrategy(); doReturn(dataProviderMethodResolver, resolver2, resolver3).when(underTest).getResolverInstanceInt(any(Class.class)); doReturn(emptyList()).when(dataProviderMethodResolver).resolve(testMethod, useDataProvider); doReturn(expected2).when(resolver2).resolve(testMethod, useDataProvider); doReturn(expected3).when(resolver3).resolve(testMethod, useDataProvider); // When: List<FrameworkMethod> result = underTest.getDataProviderMethods(testMethod); // Then: assertThat(result).containsExactlyElementsOf(expected2); assertThat(underTest.dataProviderMethods).containsEntry(testMethod, result); }
@Test public void testGetDataProviderMethodShouldReturnFirstNotEmptyListIfResolveStrategyIsAggregateAllMatchesAndMultipleResolversWouldMatch() { // Given: final DataProviderMethodResolver resolver2 = mock(DataProviderMethodResolver.class); final DataProviderMethodResolver resolver3 = mock(DataProviderMethodResolver.class); final List<FrameworkMethod> expected2 = Arrays.asList(mock(FrameworkMethod.class), mock(FrameworkMethod.class)); final List<FrameworkMethod> expected3 = Arrays.asList(mock(FrameworkMethod.class)); doReturn(useDataProvider).when(testMethod).getAnnotation(UseDataProvider.class); doReturn(new Class<?>[] { DataProviderMethodResolver.class, DataProviderMethodResolver.class, DataProviderMethodResolver.class }) .when(useDataProvider).resolver(); doReturn(ResolveStrategy.AGGREGATE_ALL_MATCHES).when(useDataProvider).resolveStrategy(); doReturn(dataProviderMethodResolver, resolver2, resolver3).when(underTest).getResolverInstanceInt(any(Class.class)); doReturn(emptyList()).when(dataProviderMethodResolver).resolve(testMethod, useDataProvider); doReturn(expected2).when(resolver2).resolve(testMethod, useDataProvider); doReturn(expected3).when(resolver3).resolve(testMethod, useDataProvider); // When: List<FrameworkMethod> result = underTest.getDataProviderMethods(testMethod); // Then: assertThat(result).hasSize(3).containsAll(expected2).containsAll(expected3); assertThat(underTest.dataProviderMethods).containsEntry(testMethod, result); }
@Test public void testGenerateExplodedTestMethodsForShouldCallTestGeneratorForAllTestMethodsAndAddResult() { // Given: FrameworkMethod testMethod2 = mock(FrameworkMethod.class); FrameworkMethod dataProviderMethod21 = mock(FrameworkMethod.class); FrameworkMethod dataProviderMethod22 = mock(FrameworkMethod.class); doReturn(asList(dataProviderMethod)).when(underTest).getDataProviderMethods(testMethod); doReturn(asList(dataProviderMethod21, dataProviderMethod22)).when(underTest).getDataProviderMethods(testMethod2); List<FrameworkMethod> explodedMethods = new ArrayList<FrameworkMethod>(); explodedMethods.add(mock(FrameworkMethod.class)); explodedMethods.add(mock(FrameworkMethod.class)); doReturn(explodedMethods).when(testGenerator).generateExplodedTestMethodsFor(testMethod, dataProviderMethod); List<FrameworkMethod> explodedMethods21 = new ArrayList<FrameworkMethod>(); explodedMethods21.add(mock(FrameworkMethod.class)); explodedMethods21.add(mock(FrameworkMethod.class)); explodedMethods21.add(mock(FrameworkMethod.class)); doReturn(explodedMethods21).when(testGenerator).generateExplodedTestMethodsFor(testMethod2, dataProviderMethod21); List<FrameworkMethod> explodedMethods22 = new ArrayList<FrameworkMethod>(); explodedMethods22.add(mock(FrameworkMethod.class)); explodedMethods22.add(mock(FrameworkMethod.class)); doReturn(explodedMethods22).when(testGenerator).generateExplodedTestMethodsFor(testMethod2, dataProviderMethod22); // When: List<FrameworkMethod> result = underTest.generateExplodedTestMethodsFor(asList(testMethod, testMethod2)); // Then: assertThat(result).hasSize(7).containsAll(explodedMethods).containsAll(explodedMethods21).containsAll(explodedMethods22); verify(testGenerator).generateExplodedTestMethodsFor(testMethod, dataProviderMethod); verify(testGenerator).generateExplodedTestMethodsFor(testMethod2, dataProviderMethod21); verify(testGenerator).generateExplodedTestMethodsFor(testMethod2, dataProviderMethod22); verifyNoMoreInteractions(testGenerator); }