We are using an approach similar to System Rules to handle (system) properties in our JUnit 4 tests. The main reason for this is to clean up the environment after each test, so that other tests do not inadvertently depend on possible side effects.
Since JUnit 5 is released, I wonder if there is a "JUnit 5 way" of doing this?
There is JUnit Pioneer, a "JUnit 5 extension pack". It comes with @ClearSystemProperty and @SetSystemProperty. From the docs:
The
@ClearSystemPropertyand@SetSystemPropertyannotations can be used to clear, respectively, set the values of system properties for a test execution. Both annotations work on the test method and class level, are repeatable as well as combinable. After the annotated method has been executed, the properties mentioned in the annotation will be restored to their original value or will be cleared if they didn't have one before. Other system properties that are changed during the test, are not restored.
Example:
@Test
@ClearSystemProperty(key = "some key")
@SetSystemProperty(key = "another key", value = "new value")
void test() {
assertNull(System.getProperty("some key"));
assertEquals("new value", System.getProperty("another key"));
}
You can use the extension API. You could create an annotation which defines your extension to a test method.
import org.junit.jupiter.api.extension.ExtendWith;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@ExtendWith(SystemPropertyExtension.class)
public @interface SystemProperty {
String key();
String value();
}
Then, you can create the extension class:
import org.junit.jupiter.api.extension.AfterEachCallback;
import org.junit.jupiter.api.extension.BeforeEachCallback;
import org.junit.jupiter.api.extension.ExtensionContext;
public class SystemPropertyExtension implements AfterEachCallback, BeforeEachCallback {
@Override
public void afterEach(ExtensionContext extensionContext) throws Exception {
SystemProperty annotation = extensionContext.getTestMethod().get().getAnnotation(SystemProperty.class);
System.clearProperty(annotation.key());
}
@Override
public void beforeEach(ExtensionContext extensionContext) throws Exception {
SystemProperty annotation = extensionContext.getTestMethod().get().getAnnotation(SystemProperty.class);
System.setProperty(annotation.key(), annotation.value());
}
}
Finally, you can annotate your test with properties:
@Test
@SystemProperty(key = "key", value = "value")
void testPropertey() {
System.out.println(System.getProperty("key"));
}
This solution supports only one system property for each test. If you want to support multiple test, you could use a nested annotation and the extension could handle this as well:
@Test
@SystemProperties({
@SystemProperty(key = "key1", value = "value"),
@SystemProperty(key = "key2", value = "value")
})
void testPropertey() {
System.out.println(System.getProperty("key1"));
System.out.println(System.getProperty("key2"));
}
The JUnit Pioneer way requires the system properties to be known at compile time. Where they are generated at runtime, say via Testcontainers or Wiremock creating things on random ports, it may be better to use something which can be driven from dynamic values.
The problem can be solved with System Stubs https://github.com/webcompere/system-stubs which provides JUnit 5 and is a fork of the code from System Lambda, itself built by the author of System Rules.
@ExtendWith(SystemStubsExtension.class)
class SomeTest {
// can be initialised here with some up front properties
// or leave like this for auto initialization
@SystemStub
private SystemProperties someProperties;
@BeforeEach
void beforeEach() {
someProperties.set("prop1", "value1")
.set("prop2", "value2");
}
@Test
void someTest() {
// properties are set here
// and can also call System.setProperty
// properties reset to state before the test case ran
// as the test case is tidied up
}
}
