PatternMatchingSuite.java

                                                                     
                                                                     
                                                                     
                                             
package org.doxla.junit4;

import java.io.IOException;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.HashSet;
import java.util.Set;

import org.junit.internal.runners.InitializationError;
import org.junit.runners.Suite;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.type.ClassMetadata;
import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;

public class PatternMatchingSuite 
	extends Suite{
	
	private static final MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory();
	
	@Retention(RetentionPolicy.RUNTIME)
	@Target(ElementType.TYPE)
	public @interface SuiteClassPattern {
		public String value();
	}

	public PatternMatchingSuite(Class<?> klass) throws InitializationError {
		super(klass,getClassesFromAnnotation(klass));
	}

	private static Class<?>[] getClassesFromAnnotation(Class<?> klass) throws InitializationError {
		SuiteClassPattern annotation= klass.getAnnotation(SuiteClassPattern.class);
		if (annotation == null)
			throw new InitializationError(String.format("class '%s' must have a SuiteClassPattern annotation", klass.getName()));
		
		Resource[] testClassesAsResource = getResourcesFromAnnotationPattern(annotation);
		
		Set<Class<?>> classes = resourcesToClasses(testClassesAsResource);
		return classes.toArray(new Class<?>[]{});
	}

	private static Set<Class<?>> resourcesToClasses(Resource[] testClassesAsResource) throws InitializationError {
		Set<Class<?>> classes = new HashSet<Class<?>>(); 
		for (Resource resource : testClassesAsResource) {
			ClassMetadata classMetadata = getMetaDataFromResource(resource);
			
			if(classMetadata != null){
				classes.add( getClassFromMetaData(classMetadata) );
			}
		}
		return classes;
	}

	private static Class<?> getClassFromMetaData(ClassMetadata classMetadata) throws InitializationError {
		Class<?> c;
		try {
			c = Class.forName(classMetadata.getClassName());
		} catch (ClassNotFoundException e) {
			throw new InitializationError("matched bad class: "+classMetadata.getClassName());
		}
		return c;
	}
	
	private static ClassMetadata getMetaDataFromResource(Resource resource) throws InitializationError{
		MetadataReader metadataReader;
		try {
			metadataReader = metadataReaderFactory.getMetadataReader(resource);
		} catch (IOException e1) {
			throw new InitializationError("Error getting class metadata from matched resource: "+resource);
		}
		return metadataReader.getClassMetadata();
	}

	private static Resource[] getResourcesFromAnnotationPattern(
			SuiteClassPattern annotation) throws InitializationError {
		PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
		Resource[] testClassesAsResource;
		try {
			testClassesAsResource = resolver.getResources(annotation.value());
		} catch (IOException e1) {
			throw new InitializationError("Exception resolving resources check pattern: "+annotation.value());
		}
		return testClassesAsResource;
	}

}