public List<String> findPaths() {
if (!finder.isAnnotationPresent(UsingPaths.class)) {
return new ArrayList<String>();
}
String searchIn = finder.getAnnotatedValue(UsingPaths.class, String.class, "searchIn");
List<String> includes = finder.getAnnotatedValues(UsingPaths.class, String.class, "includes");
List<String> excludes = finder.getAnnotatedValues(UsingPaths.class, String.class, "excludes");
return new StoryFinder().findPaths(searchIn, includes, excludes);
}
protected ParameterConverters parameterConverters(AnnotationFinder annotationFinder) {
List<ParameterConverter> converters = new ArrayList<ParameterConverter>();
for (Class<ParameterConverter> converterClass :
annotationFinder.getAnnotatedClasses(
Configure.class, ParameterConverter.class, "parameterConverters")) {
converters.add(instanceOf(ParameterConverter.class, converterClass));
}
return new ParameterConverters().addConverters(converters);
}
/**
* Builds CandidateSteps using annotation {@link UsingSteps} found in the annotated object
* instance and the configuration provided
*
* @param configuration the Configuration
* @return A List of CandidateSteps instances
*/
public List<CandidateSteps> buildCandidateSteps(Configuration configuration) {
List<Object> stepsInstances = new ArrayList<Object>();
InjectableStepsFactory factory = null;
if (finder.isAnnotationPresent(UsingSteps.class)) {
List<Class<Object>> stepsClasses =
finder.getAnnotatedClasses(UsingSteps.class, Object.class, "instances");
for (Class<Object> stepsClass : stepsClasses) {
stepsInstances.add(instanceOf(Object.class, stepsClass));
}
factory = new InstanceStepsFactory(configuration, stepsInstances);
} else {
annotationMonitor.annotationNotFound(UsingSteps.class, annotatedClass);
}
if (factory == null) {
factory = new InstanceStepsFactory(configuration);
}
return factory.createCandidateSteps();
}
@SuppressWarnings("unchecked")
public Embedder buildEmbedder() {
if (!finder.isAnnotationPresent(UsingEmbedder.class)) {
return new Embedder();
}
boolean batch = control(finder, "batch");
boolean skip = control(finder, "skip");
boolean generateViewAfterStories = control(finder, "generateViewAfterStories");
boolean ignoreFailureInStories = control(finder, "ignoreFailureInStories");
boolean ignoreFailureInView = control(finder, "ignoreFailureInView");
long storyTimeoutInSecs =
finder.getAnnotatedValue(UsingEmbedder.class, Long.class, "storyTimeoutInSecs");
int threads = finder.getAnnotatedValue(UsingEmbedder.class, Integer.class, "threads");
Configuration configuration = buildConfiguration();
List<CandidateSteps> candidateSteps = buildCandidateSteps(configuration);
Embedder embedder =
instanceOf(
Embedder.class,
(Class<? extends Embedder>)
finder.getAnnotatedValue(UsingEmbedder.class, Class.class, "embedder"));
embedder
.embedderControls()
.doBatch(batch)
.doSkip(skip)
.doGenerateViewAfterStories(generateViewAfterStories)
.doIgnoreFailureInStories(ignoreFailureInStories)
.doIgnoreFailureInView(ignoreFailureInView)
.useStoryTimeoutInSecs(storyTimeoutInSecs)
.useThreads(threads);
embedder.useConfiguration(configuration);
embedder.useCandidateSteps(candidateSteps);
List<String> metaFilters =
finder.getAnnotatedValues(UsingEmbedder.class, String.class, "metaFilters");
if (!metaFilters.isEmpty()) {
embedder.useMetaFilters(metaFilters);
}
return embedder;
}
/**
* Builds a Configuration instance based on annotation {@link Configure} found in the annotated
* object instance
*
* @return A Configuration instance
*/
public Configuration buildConfiguration() throws AnnotationRequired {
Configuration configuration = new MostUsefulConfiguration();
if (!finder.isAnnotationPresent(Configure.class)) {
// not using annotation configuration, default to most useful
// configuration
return configuration;
}
configuration.useKeywords(configurationElement(finder, "keywords", Keywords.class));
configuration.useFailureStrategy(
configurationElement(finder, "failureStrategy", FailureStrategy.class));
configuration.usePendingStepStrategy(
configurationElement(finder, "pendingStepStrategy", PendingStepStrategy.class));
configuration.useParanamer(configurationElement(finder, "paranamer", Paranamer.class));
configuration.useStoryControls(
configurationElement(finder, "storyControls", StoryControls.class));
configuration.useStepCollector(
configurationElement(finder, "stepCollector", StepCollector.class));
configuration.useStepdocReporter(
configurationElement(finder, "stepdocReporter", StepdocReporter.class));
configuration.useStepFinder(configurationElement(finder, "stepFinder", StepFinder.class));
configuration.useStepMonitor(configurationElement(finder, "stepMonitor", StepMonitor.class));
configuration.useStepPatternParser(
configurationElement(finder, "stepPatternParser", StepPatternParser.class));
configuration.useStoryLoader(configurationElement(finder, "storyLoader", StoryLoader.class));
configuration.useStoryParser(configurationElement(finder, "storyParser", StoryParser.class));
configuration.useStoryPathResolver(
configurationElement(finder, "storyPathResolver", StoryPathResolver.class));
configuration.useDefaultStoryReporter(
configurationElement(finder, "defaultStoryReporter", StoryReporter.class));
configuration.useStoryReporterBuilder(
configurationElement(finder, "storyReporterBuilder", StoryReporterBuilder.class));
configuration.useViewGenerator(
configurationElement(finder, "viewGenerator", ViewGenerator.class));
configuration.useParameterConverters(parameterConverters(finder));
configuration.usePathCalculator(
configurationElement(finder, "pathCalculator", PathCalculator.class));
return configuration;
}
@SuppressWarnings("unchecked")
private <T> Class<T> elementImplementation(AnnotationFinder finder, String name) {
return finder.getAnnotatedValue(Configure.class, Class.class, name);
}
private boolean control(AnnotationFinder finder, String name) {
return finder.getAnnotatedValue(UsingEmbedder.class, Boolean.class, name);
}
