Add JUnit extension for attaching log record listener to test cases (#2558)

You can use the @WithLogRecordListener annotation to extend your test class.
```
    @WithLogRecordListener
    class FooTest {
```
It will attach an instance of LogRecordListener to each test method.
The method can access this instance by accepting an argument which
is automatically resolved by the extension:

    @test
    void fooBar(LogRecordListener logRecordListener) {
        LogRecord logRecord = logRecordListener.getLogRecords().get(0);

Closes #2546

Co-authored-by: M.P. Korstanje <[email protected]>

Author: Dom Corvasce

core/src/test/java/io/cucumber/core/logging/WithLogRecordListener.java

@@ -0,0 +1,62 @@
+package io.cucumber.core.logging;
+
+import org.junit.jupiter.api.extension.AfterEachCallback;
+import org.junit.jupiter.api.extension.BeforeEachCallback;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.api.extension.ExtensionContext.Namespace;
+import org.junit.jupiter.api.extension.ParameterContext;
+import org.junit.jupiter.api.extension.ParameterResolutionException;
+import org.junit.jupiter.api.extension.ParameterResolver;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import static org.junit.jupiter.api.extension.ExtensionContext.Namespace.create;
+
+@Target({ ElementType.TYPE, ElementType.METHOD })
+@Retention(RetentionPolicy.RUNTIME)
+@ExtendWith({ WithLogRecordListener.Extension.class })
+public @interface WithLogRecordListener {
+    class Extension implements BeforeEachCallback, AfterEachCallback, ParameterResolver {
+        private ExtensionContext.Store getContextStore(ExtensionContext context) {
+            Namespace namespace = create(Extension.class, context.getRequiredTestMethod());
+            return context.getStore(namespace);
+        }
+
+        private LogRecordListener getLogRecordListener(ExtensionContext context) {
+            return getContextStore(context).getOrComputeIfAbsent(LogRecordListener.class);
+        }
+
+        @Override
+        public void beforeEach(ExtensionContext extensionContext) {
+            LogRecordListener listener = getLogRecordListener(extensionContext);
+            LoggerFactory.addListener(listener);
+        }
+
+        @Override
+        public void afterEach(ExtensionContext extensionContext) {
+            LogRecordListener listener = getLogRecordListener(extensionContext);
+            LoggerFactory.removeListener(listener);
+        }
+
+        @Override
+        public boolean supportsParameter(ParameterContext parameterContext, ExtensionContext extensionContext)
+                throws ParameterResolutionException {
+            // @formatter:off
+            return parameterContext.getParameter().getType() == LogRecordListener.class
+                    && extensionContext.getTestMethod().isPresent();
+            // @formatter:on
+        }
+
+        @Override
+        public Object resolveParameter(ParameterContext paramContext, ExtensionContext context)
+                throws ParameterResolutionException {
+            return getLogRecordListener(context);
+        }
+
+    }
+
+}

core/src/test/java/io/cucumber/core/options/CommandlineOptionsParserTest.java

@@ -6,6 +6,7 @@
 import io.cucumber.core.gherkin.Pickle;
 import io.cucumber.core.logging.LogRecordListener;
 import io.cucumber.core.logging.LoggerFactory;
+import io.cucumber.core.logging.WithLogRecordListener;
 import io.cucumber.core.plugin.PluginFactory;
 import io.cucumber.core.plugin.Plugins;
 import io.cucumber.core.runtime.TimeServiceEventBus;
@@ -63,23 +64,12 @@
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
+@WithLogRecordListener
 class CommandlineOptionsParserTest {
 
     private final Map<String, String> properties = new HashMap<>();
     private final ByteArrayOutputStream out = new ByteArrayOutputStream();
     private final CommandlineOptionsParser parser = new CommandlineOptionsParser(out);
-    private LogRecordListener logRecordListener;
-
-    @BeforeEach
-    void setup() {
-        logRecordListener = new LogRecordListener();
-        LoggerFactory.addListener(logRecordListener);
-    }
-
-    @AfterEach
-    void tearDown() {
-        LoggerFactory.removeListener(logRecordListener);
-    }
 
     @Test
     void testParseWithObjectFactoryArgument() {
@@ -263,7 +253,7 @@ public void describeTo(Description description) {
     }
 
     @Test
-    void handles_null_summary_printer_backward_compatible() {
+    void handles_null_summary_printer_backward_compatible(LogRecordListener logRecordListener) {
         RuntimeOptions options = parser
                 .parse("--plugin", "null_summary", "--glue", "somewhere")
                 .build();

core/src/test/java/io/cucumber/core/resource/ClasspathScannerTest.java

@@ -1,31 +1,18 @@
 package io.cucumber.core.resource;
 
 import io.cucumber.core.logging.LogRecordListener;
-import io.cucumber.core.logging.LoggerFactory;
+import io.cucumber.core.logging.WithLogRecordListener;
 import io.cucumber.core.resource.test.ExampleClass;
 import io.cucumber.core.resource.test.ExampleInterface;
 import io.cucumber.core.resource.test.OtherClass;
-import org.hamcrest.CoreMatchers;
-import org.hamcrest.Matchers;
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 
 import java.io.IOException;
-import java.net.URI;
 import java.net.URL;
 import java.net.URLConnection;
 import java.net.URLStreamHandler;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.Enumeration;
 import java.util.List;
-import java.util.Vector;
-import java.util.logging.Level;
-import java.util.logging.LogRecord;
 
-import static java.util.Arrays.asList;
 import static java.util.Collections.enumeration;
 import static java.util.Collections.singletonList;
 import static org.hamcrest.MatcherAssert.assertThat;
@@ -36,24 +23,12 @@
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
+@WithLogRecordListener
 class ClasspathScannerTest {
 
     private final ClasspathScanner scanner = new ClasspathScanner(
         ClasspathScannerTest.class::getClassLoader);
 
-    private LogRecordListener logRecordListener;
-
-    @BeforeEach
-    void setup() {
-        logRecordListener = new LogRecordListener();
-        LoggerFactory.addListener(logRecordListener);
-    }
-
-    @AfterEach
-    void tearDown() {
-        LoggerFactory.removeListener(logRecordListener);
-    }
-
     @Test
     void scanForSubClassesInPackage() {
         List<Class<? extends ExampleInterface>> classes = scanner.scanForSubClassesInPackage(
@@ -88,7 +63,7 @@ void scanForClassesInNonExistingPackage() {
     }
 
     @Test
-    void scanForResourcesInUnsupportedFileSystem() throws IOException {
+    void scanForResourcesInUnsupportedFileSystem(LogRecordListener logRecordListener) throws IOException {
         ClassLoader classLoader = mock(ClassLoader.class);
         ClasspathScanner scanner = new ClasspathScanner(() -> classLoader);
         URLStreamHandler handler = new URLStreamHandler() {

core/src/test/java/io/cucumber/core/runtime/FeaturePathFeatureSupplierTest.java

@@ -5,6 +5,7 @@
 import io.cucumber.core.feature.Options;
 import io.cucumber.core.logging.LogRecordListener;
 import io.cucumber.core.logging.LoggerFactory;
+import io.cucumber.core.logging.WithLogRecordListener;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -21,25 +22,14 @@
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
+@WithLogRecordListener
 class FeaturePathFeatureSupplierTest {
 
     private final Supplier<ClassLoader> classLoader = FeaturePathFeatureSupplierTest.class::getClassLoader;
     private final FeatureParser parser = new FeatureParser(UUID::randomUUID);
-    private LogRecordListener logRecordListener;
-
-    @BeforeEach
-    void setup() {
-        logRecordListener = new LogRecordListener();
-        LoggerFactory.addListener(logRecordListener);
-    }
-
-    @AfterEach
-    void tearDown() {
-        LoggerFactory.removeListener(logRecordListener);
-    }
 
     @Test
-    void logs_message_if_no_features_are_found() {
+    void logs_message_if_no_features_are_found(LogRecordListener logRecordListener) {
         Options featureOptions = () -> singletonList(FeaturePath.parse("classpath:io/cucumber/core/options"));
 
         FeaturePathFeatureSupplier supplier = new FeaturePathFeatureSupplier(classLoader, featureOptions, parser);
@@ -49,7 +39,7 @@ void logs_message_if_no_features_are_found() {
     }
 
     @Test
-    void logs_message_if_no_feature_paths_are_given() {
+    void logs_message_if_no_feature_paths_are_given(LogRecordListener logRecordListener) {
         Options featureOptions = Collections::emptyList;
 
         FeaturePathFeatureSupplier supplier = new FeaturePathFeatureSupplier(classLoader, featureOptions, parser);

junit-platform-engine/src/test/java/io/cucumber/junit/platform/engine/DiscoverySelectorResolverTest.java

@@ -1,11 +1,9 @@
 package io.cucumber.junit.platform.engine;
 
 import io.cucumber.core.logging.LogRecordListener;
-import io.cucumber.core.logging.LoggerFactory;
 import io.cucumber.junit.platform.engine.nofeatures.NoFeatures;
 import org.hamcrest.CustomTypeSafeMatcher;
 import org.hamcrest.Matcher;
-import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.platform.engine.ConfigurationParameters;
@@ -51,25 +49,19 @@
 import static org.junit.platform.engine.discovery.DiscoverySelectors.selectUniqueId;
 import static org.junit.platform.engine.discovery.DiscoverySelectors.selectUri;
 
+@WithLogRecordListener
 class DiscoverySelectorResolverTest {
 
     private final DiscoverySelectorResolver resolver = new DiscoverySelectorResolver();
-    private final LogRecordListener logRecordListener = new LogRecordListener();
     private CucumberEngineDescriptor testDescriptor;
 
     @BeforeEach
     void before() {
-        LoggerFactory.addListener(logRecordListener);
         UniqueId id = UniqueId.forEngine(new CucumberTestEngine().getId());
         testDescriptor = new CucumberEngineDescriptor(id);
         assertEquals(0, testDescriptor.getChildren().size());
     }
 
-    @AfterEach
-    void after() {
-        LoggerFactory.removeListener(logRecordListener);
-    }
-
     @Test
     void resolveRequestWithClasspathResourceSelector() {
         DiscoverySelector resource = selectClasspathResource("io/cucumber/junit/platform/engine/single.feature");
@@ -409,7 +401,7 @@ void resolveRequestWithClassSelector() {
     }
 
     @Test
-    void resolveRequestWithClassSelectorShouldLogWarnIfNoFeaturesFound() {
+    void resolveRequestWithClassSelectorShouldLogWarnIfNoFeaturesFound(LogRecordListener logRecordListener) {
         DiscoverySelector resource = selectClass(NoFeatures.class);
         EngineDiscoveryRequest discoveryRequest = new SelectorRequest(resource);
         resolver.resolveSelectors(discoveryRequest, testDescriptor);

junit-platform-engine/src/test/java/io/cucumber/junit/platform/engine/WithLogRecordListener.java

@@ -0,0 +1,64 @@
+package io.cucumber.junit.platform.engine;
+
+import io.cucumber.core.logging.LogRecordListener;
+import io.cucumber.core.logging.LoggerFactory;
+import org.junit.jupiter.api.extension.AfterEachCallback;
+import org.junit.jupiter.api.extension.BeforeEachCallback;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.api.extension.ExtensionContext.Namespace;
+import org.junit.jupiter.api.extension.ParameterContext;
+import org.junit.jupiter.api.extension.ParameterResolutionException;
+import org.junit.jupiter.api.extension.ParameterResolver;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import static org.junit.jupiter.api.extension.ExtensionContext.Namespace.create;
+
+@Target({ ElementType.TYPE, ElementType.METHOD })
+@Retention(RetentionPolicy.RUNTIME)
+@ExtendWith({ WithLogRecordListener.Extension.class })
+public @interface WithLogRecordListener {
+    class Extension implements BeforeEachCallback, AfterEachCallback, ParameterResolver {
+        private ExtensionContext.Store getContextStore(ExtensionContext context) {
+            Namespace namespace = create(Extension.class, context.getRequiredTestMethod());
+            return context.getStore(namespace);
+        }
+
+        private LogRecordListener getLogRecordListener(ExtensionContext context) {
+            return getContextStore(context).getOrComputeIfAbsent(LogRecordListener.class);
+        }
+
+        @Override
+        public void beforeEach(ExtensionContext extensionContext) {
+            LogRecordListener listener = getLogRecordListener(extensionContext);
+            LoggerFactory.addListener(listener);
+        }
+
+        @Override
+        public void afterEach(ExtensionContext extensionContext) {
+            LogRecordListener listener = getLogRecordListener(extensionContext);
+            LoggerFactory.removeListener(listener);
+        }
+
+        @Override
+        public boolean supportsParameter(ParameterContext parameterContext, ExtensionContext extensionContext)
+                throws ParameterResolutionException {
+            // @formatter:off
+            return parameterContext.getParameter().getType() == LogRecordListener.class
+                    && extensionContext.getTestMethod().isPresent();
+            // @formatter:on
+        }
+
+        @Override
+        public Object resolveParameter(ParameterContext paramContext, ExtensionContext context)
+                throws ParameterResolutionException {
+            return getLogRecordListener(context);
+        }
+
+    }
+
+}