[Spring] Remove cucumber.xml and implied context configuration

The preferred way to use `cucumber-spring` is to annotate a class
with both `@CucumberContextConfiguration` and a Spring context
configuration annotation such as `@ContextConfiguration`,
`@SpringBootTest`, ect.

Previously Cucumber would support the discovery of context
configuration on any step definition class. This requires a
significant amount of code and intimate knowledge of the
Spring Framework.
By restricting this too only classes annotated with
`@CucumberContextConfiguration` we remove this complexity and
simply pass the annotated class to Spring `TestContextManager`
framework.

If no context configuration is available Cucumber currently also
supports reading the application context from a magical
`cucumber.xml` file or should none exist an empty application
context.
Both these fallback strategies tend to hide user errors. And
removing them will provide more clarity and also removes
a nugget of complexity.

Author: mpkorstanje

spring/src/main/java/io/cucumber/spring/SpringFactory.java

@@ -2,15 +2,15 @@
 
 import io.cucumber.core.backend.CucumberBackendException;
 import io.cucumber.core.backend.ObjectFactory;
-import io.cucumber.core.logging.Logger;
-import io.cucumber.core.logging.LoggerFactory;
 import org.apiguardian.api.API;
 import org.springframework.beans.BeansException;
 import org.springframework.stereotype.Component;
+import org.springframework.test.annotation.DirtiesContext;
 import org.springframework.test.context.BootstrapWith;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.ContextHierarchy;
 import org.springframework.test.context.TestContextManager;
+import org.springframework.test.context.web.WebAppConfiguration;
 
 import java.lang.annotation.Annotation;
 import java.util.ArrayDeque;
@@ -20,53 +20,58 @@
 import java.util.HashSet;
 import java.util.Set;
 
-import static io.cucumber.spring.TestContextAdaptor.createClassPathXmlApplicationContextAdaptor;
-import static io.cucumber.spring.TestContextAdaptor.createGenericApplicationContextAdaptor;
 import static io.cucumber.spring.TestContextAdaptor.createTestContextManagerAdaptor;
-import static java.util.Arrays.asList;
 
 /**
  * Spring based implementation of ObjectFactory.
  * <p>
  * Application beans are accessible from the step definitions using autowiring
  * (with annotations).
  * <p>
- * SpringFactory uses TestContextManager to manage the spring context. The step definitions are added to the
- * TestContextManagers context and the context is reloaded for each scenario.
- * <p>
- * The spring context can be configured by:
- * <ul>
- * <li>Annotating one step definition with: @{@link ContextConfiguration},  @{@link ContextHierarchy}
- * or @{@link BootstrapWith}. This step definition can also be annotated
- * with @{@link org.springframework.test.context.web.WebAppConfiguration}
- * or @{@link org.springframework.test.annotation.DirtiesContext} annotation.
- * </li>
- * <li>Deprecated: If no step definition class with @ContextConfiguration or @ContextHierarchy
- * is found, it will try to load cucumber.xml from the classpath.</li>
- * </ul>
+ * The spring context can be configured by annotating one glue class with a @{@link CucumberContextConfiguration} and
+ * any one of the following @{@link ContextConfiguration}, @{@link ContextHierarchy} or @{@link BootstrapWith}.
+ * This glue class can also be annotated with @{@link WebAppConfiguration} or @{@link DirtiesContext} annotation.
  * <p>
  * Notes:
  * <ul>
- * <li>
- * Step definitions should not be annotated with @{@link Component} or other annotations that mark it as eligible for
- * detection by classpath scanning. When a step definition class is annotated by @Component or an annotation that has
- * the @Component stereotype an exception will be thrown
- * </li>
- * <li>
- * If more that one glue class is used to configure the spring context an exception will be thrown.
- * </li>
+ *     <li>
+ *          SpringFactory uses Springs TestContextManager framework to manage the spring context. The class annotated
+ *          with {@code CucumberContextConfiguration} will be use to instantiate the {@link TestContextManager}.
+ *     </li>
+ *      <li>
+ *          If not exactly one glue class is annotated with {@code CucumberContextConfiguration} an exception will be
+ *          thrown.
+ *      </li>
+ *
+ *      <li>
+ *          Step definitions should not be annotated with @{@link Component} or other annotations that mark it as
+ *          eligible for detection by classpath scanning. When a step definition class is annotated by @Component or an
+ *          annotation that has the @Component stereotype an exception will be thrown
+ *      </li>
  * </ul>
  */
 @API(status = API.Status.STABLE)
 public final class SpringFactory implements ObjectFactory {
 
-    private static final Logger log = LoggerFactory.getLogger(SpringFactory.class);
-
-    private static final String CUCUMBER_XML = "cucumber.xml";
     private final Collection<Class<?>> stepClasses = new HashSet<>();
-    private Class<?> stepClassWithSpringContext = null;
+    private Class<?> withCucumberContextConfiguration = null;
     private TestContextAdaptor testContextAdaptor;
 
+    @Override
+    public boolean addClass(final Class<?> stepClass) {
+        if (stepClasses.contains(stepClass)) {
+            return true;
+        }
+
+        checkNoComponentAnnotations(stepClass);
+        if (hasCucumberContextConfiguration(stepClass)) {
+            checkOnlyOneClassHasCucumberContextConfiguration(stepClass);
+            withCucumberContextConfiguration = stepClass;
+        }
+        stepClasses.add(stepClass);
+        return true;
+    }
+
     private static void checkNoComponentAnnotations(Class<?> type) {
         for (Annotation annotation : type.getAnnotations()) {
             if (hasComponentAnnotation(annotation)) {
@@ -80,143 +85,49 @@ private static void checkNoComponentAnnotations(Class<?> type) {
         }
     }
 
-    private static boolean hasComponentAnnotation(Annotation annotation) {
-        return hasAnnotation(annotation, Collections.singleton(Component.class));
-    }
-
-    private static boolean hasAnnotation(Annotation annotation, Collection<Class<? extends Annotation>> desired) {
-        Set<Class<? extends Annotation>> seen = new HashSet<>();
-        Deque<Class<? extends Annotation>> toCheck = new ArrayDeque<>();
-        toCheck.add(annotation.annotationType());
-
-        while (!toCheck.isEmpty()) {
-            Class<? extends Annotation> annotationType = toCheck.pop();
-            if (desired.contains(annotationType)) {
-                return true;
-            }
-
-            seen.add(annotationType);
-            for (Annotation annotationTypesAnnotations : annotationType.getAnnotations()) {
-                if (!seen.contains(annotationTypesAnnotations.annotationType())) {
-                    toCheck.add(annotationTypesAnnotations.annotationType());
-                }
-            }
-
-        }
-        return false;
-    }
-
-    @Deprecated
-    private static boolean dependsOnSpringContext(Class<?> type) {
-        for (Annotation annotation : type.getAnnotations()) {
-            if (annotatedWithSupportedSpringRootTestAnnotations(annotation)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    @Deprecated
-    private static boolean annotatedWithSupportedSpringRootTestAnnotations(Annotation type) {
-        return hasAnnotation(type, asList(
-            ContextConfiguration.class,
-            ContextHierarchy.class,
-            BootstrapWith.class
-        ));
+    private static boolean hasCucumberContextConfiguration(Class<?> stepClass) {
+        return stepClass.getAnnotation(CucumberContextConfiguration.class) != null;
     }
 
-    @Override
-    public boolean addClass(final Class<?> stepClass) {
-        if (!stepClasses.contains(stepClass)) {
-            checkNoComponentAnnotations(stepClass);
-            if (dependsOnSpringContext(stepClass) || hasCucumberContextConfiguration(stepClass)) {
-                if (stepClassWithSpringContext != null) {
-                    throw new CucumberBackendException(String.format("" +
-                        "Glue class %1$s and %2$s both attempt to configure the spring context. Please ensure only one " +
-                        "glue class configures the spring context", stepClass, stepClassWithSpringContext
-                    ));
-                }
-
-                if (dependsOnSpringContext(stepClass) && !hasCucumberContextConfiguration(stepClass)) {
-                    log.warn(() -> String.format(
-                        "Glue class %1$s attempts to configure the spring context but was not annotated with %2$s.\n" +
-                            "Implicit configuration of the spring context is deprecated.\n" +
-                            "Please add the %2$s to %1$s", stepClass, CucumberContextConfiguration.class.getName()
-                    ));
-                }
-
-                stepClassWithSpringContext = stepClass;
-            }
-            stepClasses.add(stepClass);
+    private void checkOnlyOneClassHasCucumberContextConfiguration(Class<?> stepClass) {
+        if (withCucumberContextConfiguration != null) {
+            throw new CucumberBackendException(String.format("" +
+                    "Glue class %1$s and %2$s are both annotated with @CucumberContextConfiguration.\n" +
+                    "Please ensure only one class configures the spring context",
+                stepClass,
+                withCucumberContextConfiguration
+            ));
         }
-        return true;
-    }
-
-    private boolean hasCucumberContextConfiguration(Class<?> stepClass) {
-        return stepClass.getAnnotation(CucumberContextConfiguration.class) != null;
     }
 
-
     @Override
     public void start() {
-        if (stepClassWithSpringContext != null) {
-            // The application context created by the TestContextManager is
-            // a singleton and reused between scenarios and shared between
-            // threads.
-            TestContextManager testContextManager = new TestContextManager(stepClassWithSpringContext);
-            testContextAdaptor = createTestContextManagerAdaptor(testContextManager, stepClasses);
-        } else if (getClass().getClassLoader().getResource(CUCUMBER_XML) == null) {
-            warnAboutDeprecationOfGenericApplicationContext();
-            // The generic fallback application context is not shared between
-            // threads (because the spring factory is not shared) and not reused
-            // between scenarios because we recreate it each time the spring
-            // factory starts.
-            testContextAdaptor = createGenericApplicationContextAdaptor(stepClasses);
-        } else if (testContextAdaptor == null) {
-            warnAboutDeprecationOfCucumberXml();
-
-            // The xml fallback application context is not shared between
-            // threads (because the spring factory is not shared) but is reused
-            // between scenarios.
-            String[] configLocations = {CUCUMBER_XML};
-            testContextAdaptor = createClassPathXmlApplicationContextAdaptor(configLocations, stepClasses);
+        if (withCucumberContextConfiguration == null) {
+            throw new CucumberBackendException("" +
+                "Please annotate a glue class with some context configuration.\n" +
+                "\n" +
+                "For example:\n" +
+                "\n" +
+                "   @CucumberContextConfiguration\n" +
+                "   @SpringBootTest(classes = TestConfig.class)\n" +
+                "   public class CucumberSpringConfiguration { }" +
+                "\n" +
+                "Or: \n" +
+                "\n" +
+                "   @CucumberContextConfiguration\n" +
+                "   @ContextConfiguration( ... )\n" +
+                "   public class CucumberSpringConfiguration { }"
+            );
         }
-        testContextAdaptor.start();
-    }
-
-    private void warnAboutDeprecationOfGenericApplicationContext() {
-        log.warn(() -> "" +
-            "Glue glue classes have been annotated with a Spring Context Configuration.\n" +
-            "Falling back to a generic application context.\n" +
-            "This fallback has beep deprecated. Please annotate a glue class with some context configuration.\n" +
-            "\n" +
-            "For example:\n" +
-            "\n" +
-            "   @@CucumberContextConfiguration\n" +
-            "   @SpringBootTest(classes = TestConfig.class)\n" +
-            "   public class CucumberSpringConfiguration { }" +
-            "\n" +
-            "Or: \n" +
-            "\n" +
-            "   @@CucumberContextConfiguration\n" +
-            "   @ContextConfiguration( ... )\n" +
-            "   public class CucumberSpringConfiguration { }"
-        );
-    }
 
-    private void warnAboutDeprecationOfCucumberXml() {
-        log.warn(() -> "" +
-            "You are using cucumber.xml to configure the Spring Application Context.\n" +
-            "cucumber.xml has been deprecated. Instead consider annotation based configuration.\n" +
-            "You may create a glue class containing:\n" +
-            "\n" +
-            "   @@CucumberContextConfiguration\n" +
-            "   @ContextConfiguration(\"classpath:cucumber.xml\")\n" +
-            "   public class CucumberSpringConfiguration { }"
-        );
+        // The application context created by the TestContextManager is
+        // a singleton and reused between scenarios and shared between
+        // threads.
+        TestContextManager testContextManager = new TestContextManager(withCucumberContextConfiguration);
+        testContextAdaptor = createTestContextManagerAdaptor(testContextManager, stepClasses);
+        testContextAdaptor.start();
     }
 
-
     @Override
     public void stop() {
         if (testContextAdaptor != null) {
@@ -233,4 +144,29 @@ public <T> T getInstance(final Class<T> type) {
         }
     }
 
-}
+    private static boolean hasComponentAnnotation(Annotation annotation) {
+        return hasAnnotation(annotation, Collections.singleton(Component.class));
+    }
+
+    private static boolean hasAnnotation(Annotation annotation, Collection<Class<? extends Annotation>> desired) {
+        Set<Class<? extends Annotation>> seen = new HashSet<>();
+        Deque<Class<? extends Annotation>> toCheck = new ArrayDeque<>();
+        toCheck.add(annotation.annotationType());
+
+        while (!toCheck.isEmpty()) {
+            Class<? extends Annotation> annotationType = toCheck.pop();
+            if (desired.contains(annotationType)) {
+                return true;
+            }
+
+            seen.add(annotationType);
+            for (Annotation annotationTypesAnnotations : annotationType.getAnnotations()) {
+                if (!seen.contains(annotationTypesAnnotations.annotationType())) {
+                    toCheck.add(annotationTypesAnnotations.annotationType());
+                }
+            }
+
+        }
+        return false;
+    }
+}