Coverage Report - org.jbehave.core.configuration.spring.SpringAnnotationBuilder
 
Classes in this File Line Coverage Branch Coverage Complexity
SpringAnnotationBuilder
100%
38/38
100%
18/18
2.556
 
 1  
 package org.jbehave.core.configuration.spring;
 2  
 
 3  
 import java.util.ArrayList;
 4  
 import java.util.List;
 5  
 import java.util.Map;
 6  
 
 7  
 import org.jbehave.core.annotations.spring.UsingSpring;
 8  
 import org.jbehave.core.configuration.AnnotationBuilder;
 9  
 import org.jbehave.core.configuration.AnnotationFinder;
 10  
 import org.jbehave.core.configuration.AnnotationMonitor;
 11  
 import org.jbehave.core.configuration.AnnotationRequired;
 12  
 import org.jbehave.core.configuration.Configuration;
 13  
 import org.jbehave.core.steps.CompositeStepsFactory;
 14  
 import org.jbehave.core.steps.InjectableStepsFactory;
 15  
 import org.jbehave.core.steps.ParameterConverters;
 16  
 import org.jbehave.core.steps.ParameterConverters.ParameterConverter;
 17  
 import org.jbehave.core.steps.spring.SpringApplicationContextFactory;
 18  
 import org.jbehave.core.steps.spring.SpringStepsFactory;
 19  
 import org.springframework.context.ApplicationContext;
 20  
 
 21  
 /**
 22  
  * Extends {@link AnnotationBuilder} to provide Spring-based dependency
 23  
  * injection if {@link UsingSpring} annotation is present.
 24  
  * 
 25  
  * @author Cristiano GaviĆ£o
 26  
  * @author Mauro Talevi
 27  
  */
 28  
 public class SpringAnnotationBuilder extends AnnotationBuilder {
 29  
 
 30  
     private ApplicationContext context;
 31  
 
 32  
     public SpringAnnotationBuilder(Class<?> annotatedClass) {
 33  10
         super(annotatedClass);
 34  10
     }
 35  
 
 36  
     public SpringAnnotationBuilder(Class<?> annotatedClass, AnnotationMonitor annotationMonitor) {
 37  1
         super(annotatedClass, annotationMonitor);
 38  1
     }
 39  
 
 40  
     @Override
 41  
     public Configuration buildConfiguration() throws AnnotationRequired {
 42  11
         if (annotationFinder().isAnnotationPresent(UsingSpring.class)) {
 43  9
             List<String> resources = annotationFinder()
 44  
                     .getAnnotatedValues(UsingSpring.class, String.class, "resources");
 45  9
             if (resources.size() > 0) {
 46  
                 try {
 47  7
                     context = createApplicationContext(annotatedClass().getClassLoader(), resources);
 48  1
                 } catch ( Exception e ){
 49  1
                     annotationMonitor().elementCreationFailed(ApplicationContext.class, e);
 50  6
                 }
 51  
             }
 52  9
         } else {
 53  2
             annotationMonitor().annotationNotFound(UsingSpring.class, annotatedClass());
 54  
         }
 55  11
         return super.buildConfiguration();
 56  
     }
 57  
 
 58  
     @Override
 59  
     public InjectableStepsFactory buildStepsFactory(Configuration configuration) {
 60  6
         InjectableStepsFactory factoryUsingSteps = super.buildStepsFactory(configuration);
 61  6
         if (context != null) {
 62  3
             return new CompositeStepsFactory(new SpringStepsFactory(configuration, context), factoryUsingSteps);
 63  
         }
 64  3
         return factoryUsingSteps;
 65  
     }
 66  
 
 67  
     @Override
 68  
     protected ParameterConverters parameterConverters(AnnotationFinder annotationFinder) {
 69  9
         ParameterConverters converters = super.parameterConverters(annotationFinder);
 70  9
         if (context != null) {
 71  6
             return converters.addConverters(getBeansOfType(context, ParameterConverter.class));
 72  
         }
 73  3
         return converters;
 74  
     }
 75  
 
 76  
     @SuppressWarnings("unchecked")
 77  
     private List<ParameterConverter> getBeansOfType(ApplicationContext context, Class<ParameterConverter> type) {
 78  6
         Map<String, ParameterConverter> beansOfType = context.getBeansOfType(type);
 79  6
         List<ParameterConverter> converters = new ArrayList<ParameterConverter>();
 80  6
         for (ParameterConverter converter : beansOfType.values()) {
 81  6
             converters.add(converter);
 82  
         }
 83  6
         return converters;
 84  
     }
 85  
 
 86  
     @Override
 87  
     @SuppressWarnings("unchecked")
 88  
     protected <T, V extends T> T instanceOf(Class<T> type, Class<V> ofClass) {
 89  164
         if (context != null) {
 90  
             Map<String, Object> beansOfType;
 91  110
             if (!type.equals(Object.class)) {
 92  108
                 beansOfType = context.getBeansOfType(type);
 93  
             } else {
 94  2
                 beansOfType = context.getBeansOfType(ofClass);
 95  
             }
 96  110
             if (beansOfType.size() > 0) {
 97  30
                 return (T) beansOfType.values().iterator().next();
 98  
             }
 99  
         }
 100  134
         return super.instanceOf(type, ofClass);
 101  
     }
 102  
 
 103  
     protected ApplicationContext createApplicationContext(ClassLoader classLoader, List<String> resources) {
 104  7
         if ( context != null ){
 105  1
             return context;
 106  
         }
 107  6
         return new SpringApplicationContextFactory(classLoader, resources.toArray(new String[resources.size()]))
 108  
                 .createApplicationContext();
 109  
     }
 110  
 
 111  
     protected ApplicationContext applicationContext() {
 112  2
         return context;
 113  
     }
 114  
 
 115  
 }