@Test public void testDataProviderResolverContext() { // When: DataProviderResolverContext result = new DataProviderResolverContext(testMethod, resolverClasses, resolveStrategy, locations, dataProviderAnnotationClass, dataProviderName); // Then: assertThat(result).isNotNull(); assertThat(result.getTestMethod()).isEqualTo(testMethod); assertThat(result.getResolverClasses()).isNotSameAs(resolverClasses).isEqualTo(resolverClasses); assertThat(result.getResolveStrategy()).isEqualTo(resolveStrategy); assertThat(result.getLocations()).isNotSameAs(locations).isEqualTo(locations); assertThat(result.getDataProviderAnnotationClass()).isEqualTo(dataProviderAnnotationClass); assertThat(result.getDataProviderName()).isEqualTo(dataProviderName); }
@Override protected DataProviderResolverContext getDataProviderResolverContext(ExtensionContext extensionContext, UseDataProvider testAnnotation) { return new DataProviderResolverContext(extensionContext.getRequiredTestMethod(), asList(sourceAnnotation.resolver()), sourceAnnotation.resolveStrategy(), generateLocations(extensionContext.getRequiredTestClass(), sourceAnnotation.location()), DataProvider.class, sourceAnnotation.value()); }
/** * {@inheritDoc} * * @see DefaultDataProviderMethodResolver */ @Override public List<Method> resolve(DataProviderResolverContext context) { checkNotNull(context, "'context' must not be null"); List<Method> dataProviderMethods = findAnnotatedMethods(context.getLocations(), context.getDataProviderAnnotationClass()); List<Method> result = new ArrayList<Method>(); for (Method dataProviderMethod : dataProviderMethods) { if (context.useDataProviderNameConvention()) { if (isMatchingNameConvention(context.getTestMethod().getName(), dataProviderMethod.getName())) { result.add(dataProviderMethod); } } else if (dataProviderMethod.getName().equals(context.getDataProviderName())) { result.add(dataProviderMethod); } } return result; }
/** * Method searches for dataprovider methods for the resolver context. * <p> * If {@link ResolveStrategy} is pointing to {@link ResolveStrategy#UNTIL_FIRST_MATCH}, the first found dataprovider * methods of the first resolver will be returned. {@link ResolveStrategy#AGGREGATE_ALL_MATCHES} will aggregate the * results of all resolvers such that all found dataprovider methods are returned. * * @param context to be used for resolving dataprovider methods * @return the found dataprovider methods or an empty list * @throws NullPointerException if and only if given context is {@code null} */ public static List<Method> findDataProviderMethods(DataProviderResolverContext context) { checkNotNull(context, "'context' must not be null"); List<Method> result = new ArrayList<Method>(); for (Class<? extends DataProviderMethodResolver> resolverClass : context.getResolverClasses()) { DataProviderMethodResolver resolver = newInstance(resolverClass); List<Method> dataProviderMethods = resolver.resolve(context); if (context.getResolveStrategy() == ResolveStrategy.UNTIL_FIRST_MATCH && !dataProviderMethods.isEmpty()) { result.addAll(dataProviderMethods); break; } else if (context.getResolveStrategy() == ResolveStrategy.AGGREGATE_ALL_MATCHES) { result.addAll(dataProviderMethods); } } return result; }
@Test public void testUseDataProviderNameConventionShouldReturnTrueIfDatProviderIsUseConvention() { // Given: final String dataProviderName = DataProviderResolverContext.METHOD_NAME_TO_USE_CONVENTION; DataProviderResolverContext underTest = new DataProviderResolverContext(testMethod, resolverClasses, resolveStrategy, locations, dataProviderAnnotationClass, dataProviderName); // When: boolean result = underTest.useDataProviderNameConvention(); // Then: assertThat(result).isTrue(); }
@Test public void testDataProviderResolverContextShouldThrowNullPointerExceptionIfTestMethodIsNull() { // Given: expectedException.expect(NullPointerException.class); expectedException.expectMessage("'testMethod' must not be null"); // When: new DataProviderResolverContext(null, resolverClasses, resolveStrategy, locations, dataProviderAnnotationClass, dataProviderName); // Then: expect exception }
@Override protected Stream<TestTemplateInvocationContext> provideInvocationContexts(ExtensionContext context, TEST_ANNOTATION annotation) { Method testMethod = context.getRequiredTestMethod(); DataProviderResolverContext dataProviderResolverContext = getDataProviderResolverContext(context, annotation); List<Method> dataProviderMethods = findDataProviderMethods(dataProviderResolverContext); checkArgument(dataProviderMethods.size() > 0, String.format("Could not find a dataprovider for test '%s' using resolvers '%s'.", testMethod, dataProviderResolverContext.getResolverClasses())); return dataProviderMethods.stream().flatMap(dpm -> { DATAPROVIDER_ANNOTATION dataProviderAnnotation = dpm.getAnnotation(dataProviderAnnotationClass); boolean cacheDataProviderResult = cacheDataProviderResult(dataProviderAnnotation); Object data = invokeDataProviderMethodToRetrieveData(dpm, cacheDataProviderResult, context); return convertData(testMethod, data, getConverterContext(dataProviderAnnotation)) .map(d -> (TestTemplateInvocationContext) new DataProviderInvocationContext(testMethod, d, getDisplayNameContext(dataProviderAnnotation))); }); }
@Test public void testDataProviderResolverContextShouldAddTestMethodsDeclaringClassToLocationsIfLocationsIsEmpty() { // Given: List<Class<?>> emptyLocations = emptyList(); // When: DataProviderResolverContext result = new DataProviderResolverContext(testMethod, resolverClasses, resolveStrategy, emptyLocations, dataProviderAnnotationClass, dataProviderName); // Then: assertThat(result.getLocations()).containsOnly(testMethod.getDeclaringClass()); }
@Test public void testGenerateLocationsShouldReturnTestClassIfExplicitLocationsAreEmpty() throws Exception { // Given: Class<?>[] explicitLocations = {}; // When: List<Class<?>> result = DataProviderResolverContext.generateLocations(this.getClass(), explicitLocations); // Then: assertThat(result).containsOnly(this.getClass()); }
@Test public void testResolveShouldReturnListContainingExplicitelySpecifiedDataProviderMethod() { // Given: final Method method2 = Methods.getMethod(this.getClass(), "dataProviderMethod"); final Method method3 = Methods.anyMethod(); doReturn(asList(method, method2, method3)).when(underTest).findAnnotatedMethods( ArgumentMatchers.<List<Class<?>>>any(), ArgumentMatchers.<Class<? extends Annotation>>any()); when(context.useDataProviderNameConvention()).thenReturn(false); when(context.getDataProviderName()).thenReturn("dataProviderMethod"); // When: List<Method> result = underTest.resolve(context); // Then: assertThat(result).containsOnly(method2); }
@Test public void testResolveShouldReturnListContainingOnlyConventionMatchingDataProviderMethods() { // Given: final Method method2 = Methods.anyMethod(); final Method method3 = Methods.anyMethod(); doReturn(asList(method, method2, method3)).when(underTest).findAnnotatedMethods( ArgumentMatchers.<List<Class<?>>>any(), ArgumentMatchers.<Class<? extends Annotation>>any()); doReturn(false).doReturn(true).doReturn(true).when(underTest).isMatchingNameConvention(any(String.class), any(String.class)); when(context.useDataProviderNameConvention()).thenReturn(true); when(context.getTestMethod()).thenReturn(Methods.anyMethod()); // When: List<Method> result = underTest.resolve(context); // Then: assertThat(result).containsOnly(method2, method3); }
@Test public void testFindDataProviderMethodsShouldReturnFirstMatchEvenIfMutlipleResolverReturnNonEmptyList() { // Given: @SuppressWarnings("unchecked") final List<Class<? extends DataProviderMethodResolver>> resolverClasses = Arrays .<Class<? extends DataProviderMethodResolver>>asList(TestResolver.class, TestResolver.class); when(context.getResolverClasses()).thenReturn(resolverClasses); when(context.getResolveStrategy()).thenReturn(ResolveStrategy.UNTIL_FIRST_MATCH); TestResolver.methods = emptyList(); // When: List<Method> result = DataProviderMethodResolverHelper.findDataProviderMethods(context); // Then: assertThat(result).isEmpty(); assertThat(TestResolver.usedContexts).containsOnly(context, context); }
@Test public void testDataProviderResolverContextShouldThrowNullPointerExceptionIfDataProviderAnnotationClassIsNull() { // Given: expectedException.expect(NullPointerException.class); expectedException.expectMessage("'dataProviderAnnotationClass' must not be null"); // When: new DataProviderResolverContext(testMethod, resolverClasses, resolveStrategy, locations, null, dataProviderName); // Then: expect exception }
@Test public void testFindDataProviderMethodsShouldReturnEmptyListIfContextDoesNotContainAnyResolver() { // Given: when(context.getResolverClasses()) .thenReturn(Collections.<Class<? extends DataProviderMethodResolver>>emptyList()); // When: List<Method> result = DataProviderMethodResolverHelper.findDataProviderMethods(context); // Then: assertThat(result).isEmpty(); }
@Test public void testUseDataProviderNameConventionShouldReturnFalseIfDataProviderNameIsSet() { // Given: final String dataProviderName = "dataProviderName"; DataProviderResolverContext underTest = new DataProviderResolverContext(testMethod, resolverClasses, resolveStrategy, locations, dataProviderAnnotationClass, dataProviderName); // When: boolean result = underTest.useDataProviderNameConvention(); // Then: assertThat(result).isFalse(); }
@Test public void testGenerateLocationsShouldReturnTestClassIfExplicitLocationsAreNull() throws Exception { // Given: Class<?>[] explicitLocations = null; // When: List<Class<?>> result = DataProviderResolverContext.generateLocations(this.getClass(), explicitLocations); // Then: assertThat(result).containsOnly(this.getClass()); }
@Test public void testFindDataProviderMethodsShouldReturnAllMatchesIfMutlipleResolverReturnNonEmptyList() { // Given: @SuppressWarnings("unchecked") final List<Class<? extends DataProviderMethodResolver>> resolverClasses = Arrays .<Class<? extends DataProviderMethodResolver>>asList(TestResolver.class, TestResolver.class); final Method method = Methods.anyMethod(); when(context.getResolverClasses()).thenReturn(resolverClasses); when(context.getResolveStrategy()).thenReturn(ResolveStrategy.AGGREGATE_ALL_MATCHES); TestResolver.methods = asList(method); // When: List<Method> result = DataProviderMethodResolverHelper.findDataProviderMethods(context); // Then: assertThat(result).containsOnly(method, method); assertThat(TestResolver.usedContexts).containsOnly(context, context); }
@Override protected DataProviderResolverContext getDataProviderResolverContext(ExtensionContext extensionContext, UseDataProvider testAnnotation) { return new DataProviderResolverContext(extensionContext.getRequiredTestMethod(), asList(testAnnotation.resolver()), testAnnotation.resolveStrategy(), generateLocations(extensionContext.getRequiredTestClass(), testAnnotation.location()), DataProvider.class, testAnnotation.value()); }
@Test public void testDataProviderResolverContextShouldThrowNullPointerExceptionIfDataProviderNameIsNull() { // Given: expectedException.expect(NullPointerException.class); expectedException.expectMessage("'dataProviderName' must not be null"); // When: new DataProviderResolverContext(testMethod, resolverClasses, resolveStrategy, locations, dataProviderAnnotationClass, null); // Then: expect exception }
@Test public void testFindDataProviderMethodsShouldReturnEmptyListIfSingleResolverReturnsEmptyList() { // Given: @SuppressWarnings("unchecked") List<Class<? extends DataProviderMethodResolver>> resolverClasses = Arrays .<Class<? extends DataProviderMethodResolver>>asList(TestResolver.class); when(context.getResolverClasses()).thenReturn(resolverClasses); TestResolver.methods = emptyList(); // When: List<Method> result = DataProviderMethodResolverHelper.findDataProviderMethods(context); // Then: assertThat(result).isEmpty(); assertThat(TestResolver.usedContexts).containsOnly(context); }