Include AnnotatedElement description in @⁠TempDir log messages

Prior to this commit, log messages for @⁠TempDir retention looked
similar to the following.

  INFO: Skipping cleanup of temp dir <path> due to cleanup mode configuration.

However, the lack of information about which @⁠TempDir declaration was
affected did not provide sufficient information to users.

To improve diagnostics, log messages for @⁠TempDir retention now
include the configured CleanupMode and describe the AnnotatedElement
(field, constructor parameter, or method parameter), as in the
following examples.

Field:

  INFO: Skipping cleanup of temp dir <path> for field TestCase.tempDir
  due to CleanupMode.NEVER.

Constructor Parameter:

  INFO: Skipping cleanup of temp dir <path> for parameter 'tempDir' in
  constructor TestCase(TestInfo, Path) due to CleanupMode.ON_SUCCESS.

Method Parameter:

  INFO: Skipping cleanup of temp dir <path> for parameter 'tempDir' in
  method test(TestInfo, Path) due to CleanupMode.ON_SUCCESS.

Closes: #4282

Author: sbrannen

junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/extension/TempDirectory.java

@@ -24,6 +24,8 @@
 import java.io.File;
 import java.io.IOException;
 import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Executable;
 import java.lang.reflect.Field;
 import java.lang.reflect.Parameter;
 import java.nio.file.DirectoryNotEmptyException;
@@ -63,6 +65,7 @@
 import org.junit.platform.commons.logging.LoggerFactory;
 import org.junit.platform.commons.support.ModifierSupport;
 import org.junit.platform.commons.support.ReflectionSupport;
+import org.junit.platform.commons.util.ClassUtils;
 import org.junit.platform.commons.util.ExceptionUtils;
 import org.junit.platform.commons.util.Preconditions;
 import org.junit.platform.commons.util.ToStringBuilder;
@@ -288,13 +291,15 @@ static class CloseablePath implements CloseableResource {
 		private final Path dir;
 		private final TempDirFactory factory;
 		private final CleanupMode cleanupMode;
+		private final AnnotatedElement annotatedElement;
 		private final ExtensionContext extensionContext;
 
 		private CloseablePath(TempDirFactory factory, CleanupMode cleanupMode, Class<?> elementType,
 				AnnotatedElementContext elementContext, ExtensionContext extensionContext) throws Exception {
 			this.dir = factory.createTempDirectory(elementContext, extensionContext);
 			this.factory = factory;
 			this.cleanupMode = cleanupMode;
+			this.annotatedElement = elementContext.getAnnotatedElement();
 			this.extensionContext = extensionContext;
 
 			if (dir == null || !Files.isDirectory(dir)) {
@@ -318,7 +323,8 @@ Path get() {
 		public void close() throws IOException {
 			try {
 				if (cleanupMode == NEVER || (cleanupMode == ON_SUCCESS && selfOrChildFailed(extensionContext))) {
-					logger.info(() -> "Skipping cleanup of temp dir " + dir + " due to cleanup mode configuration.");
+					logger.info(() -> String.format("Skipping cleanup of temp dir %s for %s due to CleanupMode.%s.",
+						dir, descriptionFor(annotatedElement), cleanupMode.name()));
 					return;
 				}
 
@@ -335,6 +341,33 @@ public void close() throws IOException {
 			}
 		}
 
+		/**
+		 * @since 5.12
+		 */
+		private static String descriptionFor(AnnotatedElement annotatedElement) {
+			if (annotatedElement instanceof Field) {
+				Field field = (Field) annotatedElement;
+				return "field " + field.getDeclaringClass().getSimpleName() + "." + field.getName();
+			}
+			if (annotatedElement instanceof Parameter) {
+				Parameter parameter = (Parameter) annotatedElement;
+				Executable executable = parameter.getDeclaringExecutable();
+				return "parameter '" + parameter.getName() + "' in " + descriptionFor(executable);
+			}
+			throw new IllegalStateException("Unsupported AnnotatedElement type for @TempDir: " + annotatedElement);
+		}
+
+		/**
+		 * @since 5.12
+		 */
+		private static String descriptionFor(Executable executable) {
+			boolean isConstructor = executable instanceof Constructor<?>;
+			String type = isConstructor ? "constructor" : "method";
+			String name = isConstructor ? executable.getDeclaringClass().getSimpleName() : executable.getName();
+			return String.format("%s %s(%s)", type, name,
+				ClassUtils.nullSafeToString(Class::getSimpleName, executable.getParameterTypes()));
+		}
+
 		private SortedMap<Path, IOException> deleteAllFilesAndDirectories(FileOperations fileOperations)
 				throws IOException {
 			if (dir == null || Files.notExists(dir)) {

jupiter-tests/src/test/java/org/junit/jupiter/engine/extension/CloseablePathTests.java

@@ -37,9 +37,16 @@
 import java.io.IOException;
 import java.lang.annotation.Retention;
 import java.lang.annotation.Target;
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
 import java.nio.file.FileSystem;
 import java.nio.file.Path;
 import java.util.Optional;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
 
 import com.google.common.jimfs.Jimfs;
 
@@ -49,11 +56,13 @@
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInfo;
 import org.junit.jupiter.api.condition.DisabledOnOs;
 import org.junit.jupiter.api.extension.AnnotatedElementContext;
 import org.junit.jupiter.api.extension.ExtensionConfigurationException;
 import org.junit.jupiter.api.extension.ExtensionContext;
 import org.junit.jupiter.api.extension.ExtensionContext.Namespace;
+import org.junit.jupiter.api.fixtures.TrackLogRecords;
 import org.junit.jupiter.api.io.CleanupMode;
 import org.junit.jupiter.api.io.TempDir;
 import org.junit.jupiter.api.io.TempDirFactory;
@@ -62,6 +71,7 @@
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
 import org.junit.platform.commons.PreconditionViolationException;
+import org.junit.platform.commons.logging.LogRecordListener;
 import org.junit.platform.engine.support.store.NamespacedHierarchicalStore;
 
 /**
@@ -273,7 +283,7 @@ void cleanupTempDirectory() throws IOException {
 		@DisplayName("is done for a cleanup mode of ALWAYS")
 		@ParameterizedTest
 		@ElementTypeSource
-		void always(Class<?> elementType) throws IOException {
+		void always(Class<?> elementType, @TrackLogRecords LogRecordListener listener) throws IOException {
 			reset(factory);
 
 			closeablePath = TempDirectory.createTempDir(factory, ALWAYS, elementType, elementContext, extensionContext);
@@ -283,30 +293,75 @@ void always(Class<?> elementType) throws IOException {
 
 			verify(factory).close();
 			assertThat(closeablePath.get()).doesNotExist();
+			assertThat(listener.stream(Level.INFO)).map(LogRecord::getMessage)//
+					.noneMatch(m -> m.startsWith("Skipping cleanup of temp dir"));
 		}
 
 		@DisplayName("is not done for a cleanup mode of NEVER")
 		@ParameterizedTest
 		@ElementTypeSource
-		void never(Class<?> elementType) throws IOException {
+		void never(Class<?> elementType, @TrackLogRecords LogRecordListener listener) throws Exception {
 			reset(factory);
 
+			when(elementContext.getAnnotatedElement()).thenReturn(TestCase.class.getDeclaredField("tempDir"));
+
 			closeablePath = TempDirectory.createTempDir(factory, NEVER, elementType, elementContext, extensionContext);
 			assertThat(closeablePath.get()).isDirectory();
 
 			closeablePath.close();
 
 			verify(factory).close();
 			assertThat(closeablePath.get()).exists();
+			assertThat(listener.stream(Level.INFO)).map(LogRecord::getMessage)//
+					.anyMatch(m -> m.startsWith("Skipping cleanup of temp dir ")
+							&& m.endsWith(" for field TestCase.tempDir due to CleanupMode.NEVER."));
+		}
+
+		@DisplayName("is not done for a cleanup mode of ON_SUCCESS, if there is an exception (for annotated field)")
+		@ParameterizedTest
+		@ElementTypeSource
+		void onSuccessWithExceptionForAnnotatedField(Class<?> elementType, @TrackLogRecords LogRecordListener listener)
+				throws Exception {
+
+			Field field = TestCase.class.getDeclaredField("tempDir");
+
+			onSuccessWithException(elementType, listener, field,
+				" for field TestCase.tempDir due to CleanupMode.ON_SUCCESS.");
+		}
+
+		@DisplayName("is not done for a cleanup mode of ON_SUCCESS, if there is an exception (for annotated method parameter)")
+		@ParameterizedTest
+		@ElementTypeSource
+		void onSuccessWithExceptionForAnnotatedMethodParameter(Class<?> elementType,
+				@TrackLogRecords LogRecordListener listener) throws Exception {
+
+			Method method = TestCase.class.getDeclaredMethod("test", TestInfo.class, Path.class);
+			Parameter parameter = method.getParameters()[1];
+
+			onSuccessWithException(elementType, listener, parameter,
+				"for parameter 'tempDir' in method test(TestInfo, Path) due to CleanupMode.ON_SUCCESS.");
 		}
 
-		@DisplayName("is not done for a cleanup mode of ON_SUCCESS, if there is an exception")
+		@DisplayName("is not done for a cleanup mode of ON_SUCCESS, if there is an exception (for annotated constructor parameter)")
 		@ParameterizedTest
 		@ElementTypeSource
-		void onSuccessWithException(Class<?> elementType) throws IOException {
+		void onSuccessWithExceptionForAnnotatedConstructorParameter(Class<?> elementType,
+				@TrackLogRecords LogRecordListener listener) throws Exception {
+
+			Constructor<?> constructor = TestCase.class.getDeclaredConstructor(TestInfo.class, Path.class);
+			Parameter parameter = constructor.getParameters()[1];
+
+			onSuccessWithException(elementType, listener, parameter,
+				"for parameter 'tempDir' in constructor TestCase(TestInfo, Path) due to CleanupMode.ON_SUCCESS.");
+		}
+
+		private void onSuccessWithException(Class<?> elementType, @TrackLogRecords LogRecordListener listener,
+				AnnotatedElement annotatedElement, String expectedMessage) throws Exception {
+
 			reset(factory);
 
 			when(extensionContext.getExecutionException()).thenReturn(Optional.of(new Exception()));
+			when(elementContext.getAnnotatedElement()).thenReturn(annotatedElement);
 
 			closeablePath = TempDirectory.createTempDir(factory, ON_SUCCESS, elementType, elementContext,
 				extensionContext);
@@ -316,12 +371,16 @@ void onSuccessWithException(Class<?> elementType) throws IOException {
 
 			verify(factory).close();
 			assertThat(closeablePath.get()).exists();
+			assertThat(listener.stream(Level.INFO)).map(LogRecord::getMessage)//
+					.anyMatch(m -> m.startsWith("Skipping cleanup of temp dir ") && m.endsWith(expectedMessage));
 		}
 
 		@DisplayName("is done for a cleanup mode of ON_SUCCESS, if there is no exception")
 		@ParameterizedTest
 		@ElementTypeSource
-		void onSuccessWithNoException(Class<?> elementType) throws IOException {
+		void onSuccessWithNoException(Class<?> elementType, @TrackLogRecords LogRecordListener listener)
+				throws IOException {
+
 			reset(factory);
 
 			when(extensionContext.getExecutionException()).thenReturn(Optional.empty());
@@ -334,8 +393,21 @@ void onSuccessWithNoException(Class<?> elementType) throws IOException {
 
 			verify(factory).close();
 			assertThat(closeablePath.get()).doesNotExist();
+			assertThat(listener.stream(Level.INFO)).map(LogRecord::getMessage)//
+					.noneMatch(m -> m.startsWith("Skipping cleanup of temp dir"));
 		}
 
 	}
 
+	static class TestCase {
+
+		Path tempDir;
+
+		TestCase(TestInfo testInfo, Path tempDir) {
+		}
+
+		void test(TestInfo testInfo, Path tempDir) {
+		}
+	}
+
 }