computeTestMethods() {
49 | String mName = methodName != null ? methodName : threadLocalMethodName.get();
50 | return super.computeTestMethods().
51 | stream().
52 | filter(fm -> fm.getName().equals(mName)).
53 | collect(Collectors.toList());
54 | }
55 |
56 | }
57 |
58 | }
59 |
--------------------------------------------------------------------------------
/jexter-junit4-core/src/test/java/io/thundra/jexter/junit4/core/envvar/EnvironmentVariableSandboxRuleTest.java:
--------------------------------------------------------------------------------
1 | package io.thundra.jexter.junit4.core.envvar;
2 |
3 | import io.thundra.jexter.core.envvar.EnvironmentVariableHelper;
4 | import io.thundra.jexter.junit4.core.BaseTest;
5 | import org.junit.Assert;
6 | import org.junit.ClassRule;
7 | import org.junit.Rule;
8 | import org.junit.Test;
9 |
10 | /**
11 | * @author serkan
12 | */
13 | public class EnvironmentVariableSandboxRuleTest extends BaseTest {
14 |
15 | private static final String TEST_ENV_VAR_NAME = "key";
16 | private static final String TEST_ENV_VAR_VALUE = "val";
17 | private static final String TEST_ENV_VAR_VALUE_UPDATED = "val-updated";
18 |
19 | @Test
20 | public void setEnvVarShouldBeClearedAfterTestMethod_whenTestMethodAnnotated() {
21 | Assert.assertNull(EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
22 | runTestMethod(EnvironmentVariableSandboxRuleTestInternal1.class, "setEnvVar");
23 | Assert.assertNull(EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
24 | }
25 |
26 | @Test
27 | public void updatedEnvVarShouldBeRevertedBackAfterTestMethod_whenTestMethodAnnotated() {
28 | EnvironmentVariableHelper.set(TEST_ENV_VAR_NAME, TEST_ENV_VAR_VALUE);
29 | try {
30 | Assert.assertEquals(TEST_ENV_VAR_VALUE, EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
31 | runTestMethod(EnvironmentVariableSandboxRuleTestInternal1.class, "updateEnvVar");
32 | Assert.assertEquals(TEST_ENV_VAR_VALUE, EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
33 | } finally {
34 | EnvironmentVariableHelper.remove(TEST_ENV_VAR_NAME);
35 | }
36 | }
37 |
38 | @Test
39 | public void clearedEnvVarShouldBePutBackAfterTestMethod_whenTestMethodAnnotated() {
40 | EnvironmentVariableHelper.set(TEST_ENV_VAR_NAME, TEST_ENV_VAR_VALUE);
41 | try {
42 | Assert.assertEquals(TEST_ENV_VAR_VALUE, EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
43 | runTestMethod(EnvironmentVariableSandboxRuleTestInternal1.class, "clearEnvVar");
44 | Assert.assertEquals(TEST_ENV_VAR_VALUE, EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
45 | } finally {
46 | EnvironmentVariableHelper.remove(TEST_ENV_VAR_NAME);
47 | }
48 | }
49 |
50 | @Test
51 | public void setEnvVarShouldBeClearedAfterTestMethod_whenTestClassAnnotated() {
52 | Assert.assertNull(EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
53 | runTestMethod(EnvironmentVariableSandboxRuleTestInternal2.class, "setEnvVar");
54 | Assert.assertNull(EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
55 | }
56 |
57 | @Test
58 | public void updatedEnvVarShouldBeRevertedBackAfterTestMethod_whenTestClassAnnotated() {
59 | EnvironmentVariableHelper.set(TEST_ENV_VAR_NAME, TEST_ENV_VAR_VALUE);
60 | try {
61 | Assert.assertEquals(TEST_ENV_VAR_VALUE, EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
62 | runTestMethod(EnvironmentVariableSandboxRuleTestInternal2.class, "updateEnvVar");
63 | Assert.assertEquals(TEST_ENV_VAR_VALUE, EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
64 | } finally {
65 | EnvironmentVariableHelper.remove(TEST_ENV_VAR_NAME);
66 | }
67 | }
68 |
69 | @Test
70 | public void clearedEnvVarShouldBePutBackAfterTestMethod_whenTestClassAnnotated() {
71 | EnvironmentVariableHelper.set(TEST_ENV_VAR_NAME, TEST_ENV_VAR_VALUE);
72 | try {
73 | Assert.assertEquals(TEST_ENV_VAR_VALUE, EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
74 | runTestMethod(EnvironmentVariableSandboxRuleTestInternal2.class, "clearEnvVar");
75 | Assert.assertEquals(TEST_ENV_VAR_VALUE, EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
76 | } finally {
77 | EnvironmentVariableHelper.remove(TEST_ENV_VAR_NAME);
78 | }
79 | }
80 |
81 | public static class EnvironmentVariableSandboxRuleTestInternal1 {
82 |
83 | @Rule
84 | public EnvironmentVariableSandboxRule rule = new EnvironmentVariableSandboxRule();
85 |
86 | @Test
87 | public void setEnvVar() {
88 | EnvironmentVariableHelper.set(TEST_ENV_VAR_NAME, TEST_ENV_VAR_VALUE);
89 | Assert.assertEquals(TEST_ENV_VAR_VALUE, EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
90 | }
91 |
92 | @Test
93 | public void updateEnvVar() {
94 | EnvironmentVariableHelper.set(TEST_ENV_VAR_NAME, TEST_ENV_VAR_VALUE_UPDATED);
95 | Assert.assertEquals(TEST_ENV_VAR_VALUE_UPDATED, EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
96 | }
97 |
98 | @Test
99 | public void clearEnvVar() {
100 | EnvironmentVariableHelper.remove(TEST_ENV_VAR_NAME);
101 | Assert.assertNull(EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
102 | }
103 |
104 | }
105 |
106 | public static class EnvironmentVariableSandboxRuleTestInternal2 {
107 |
108 | @ClassRule
109 | public static EnvironmentVariableSandboxRule rule = new EnvironmentVariableSandboxRule();
110 |
111 | @Test
112 | public void setEnvVar() {
113 | EnvironmentVariableHelper.set(TEST_ENV_VAR_NAME, TEST_ENV_VAR_VALUE);
114 | Assert.assertEquals(TEST_ENV_VAR_VALUE, EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
115 | }
116 |
117 | @Test
118 | public void updateEnvVar() {
119 | EnvironmentVariableHelper.set(TEST_ENV_VAR_NAME, TEST_ENV_VAR_VALUE_UPDATED);
120 | Assert.assertEquals(TEST_ENV_VAR_VALUE_UPDATED, EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
121 | }
122 |
123 | @Test
124 | public void clearEnvVar() {
125 | EnvironmentVariableHelper.remove(TEST_ENV_VAR_NAME);
126 | Assert.assertNull(EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
127 | }
128 |
129 | }
130 |
131 | }
132 |
--------------------------------------------------------------------------------
/jexter-junit4-core/src/test/java/io/thundra/jexter/junit4/core/sw/StopwatchRuleTest.java:
--------------------------------------------------------------------------------
1 | package io.thundra.jexter.junit4.core.sw;
2 |
3 | import io.thundra.jexter.junit4.core.BaseTest;
4 | import org.junit.Assert;
5 | import org.junit.ClassRule;
6 | import org.junit.Rule;
7 | import org.junit.Test;
8 |
9 | import java.io.ByteArrayOutputStream;
10 | import java.io.PrintStream;
11 |
12 | /**
13 | * @author serkan
14 | */
15 | public class StopwatchRuleTest extends BaseTest {
16 |
17 | @Test
18 | public void elapsedTimeShouldBePrinted_whenTestMethodAnnotated() {
19 | PrintStream out = System.out;
20 | try {
21 | ByteArrayOutputStream baos = new ByteArrayOutputStream();
22 | System.setOut(new PrintStream(baos));
23 | runTestMethod(StopwatchRuleTest.StopwatchRuleTestInternal1.class, "test");
24 | String outContent = baos.toString();
25 | Assert.assertNotNull(outContent);
26 | Assert.assertTrue(outContent.contains("Execution of test"));
27 | } finally {
28 | System.setOut(out);
29 | }
30 | }
31 |
32 | @Test
33 | public void elapsedTimeShouldBePrinted_whenTestClassAnnotated() {
34 | PrintStream out = System.out;
35 | try {
36 | ByteArrayOutputStream baos = new ByteArrayOutputStream();
37 | System.setOut(new PrintStream(baos));
38 | runTestMethod(StopwatchRuleTest.StopwatchRuleTestInternal2.class, "test");
39 | String outContent = baos.toString();
40 | Assert.assertNotNull(outContent);
41 | Assert.assertTrue(outContent.contains("Execution of test suite"));
42 | } finally {
43 | System.setOut(out);
44 | }
45 | }
46 |
47 | public static class StopwatchRuleTestInternal1 {
48 |
49 | @Rule
50 | public StopwatchRule rule = new StopwatchRule();
51 |
52 | @Test
53 | public void test() {
54 | }
55 |
56 | }
57 |
58 | public static class StopwatchRuleTestInternal2 {
59 |
60 | @ClassRule
61 | public static StopwatchRule rule = new StopwatchRule();
62 |
63 | @Test
64 | public void test() {
65 | }
66 |
67 | }
68 |
69 | }
70 |
--------------------------------------------------------------------------------
/jexter-junit4-core/src/test/java/io/thundra/jexter/junit4/core/sysprop/SystemPropertySandboxRuleTest.java:
--------------------------------------------------------------------------------
1 | package io.thundra.jexter.junit4.core.sysprop;
2 |
3 | import io.thundra.jexter.junit4.core.BaseTest;
4 | import org.junit.Assert;
5 | import org.junit.ClassRule;
6 | import org.junit.Rule;
7 | import org.junit.Test;
8 |
9 | /**
10 | * @author serkan
11 | */
12 | public class SystemPropertySandboxRuleTest extends BaseTest {
13 |
14 | private static final String TEST_SYS_PROP_NAME = "key";
15 | private static final String TEST_SYS_PROP_VALUE = "val";
16 | private static final String TEST_SYS_PROP_VALUE_UPDATED = "val-updated";
17 |
18 | @Test
19 | public void setSysPropShouldBeClearedAfterTestMethod_whenTestMethodAnnotated() {
20 | Assert.assertNull(System.getProperty(TEST_SYS_PROP_NAME));
21 | runTestMethod(EnvironmentVariableSandboxRuleTestInternal1.class, "setSysProp");
22 | Assert.assertNull(System.getProperty(TEST_SYS_PROP_NAME));
23 | }
24 |
25 | @Test
26 | public void updatedSysPropShouldBeRevertedBackAfterTestMethod_whenTestMethodAnnotated() {
27 | System.setProperty(TEST_SYS_PROP_NAME, TEST_SYS_PROP_VALUE);
28 | try {
29 | Assert.assertEquals(TEST_SYS_PROP_VALUE, System.getProperty(TEST_SYS_PROP_NAME));
30 | runTestMethod(EnvironmentVariableSandboxRuleTestInternal1.class, "updateSysProp");
31 | Assert.assertEquals(TEST_SYS_PROP_VALUE, System.getProperty(TEST_SYS_PROP_NAME));
32 | } finally {
33 | System.clearProperty(TEST_SYS_PROP_NAME);
34 | }
35 | }
36 |
37 | @Test
38 | public void clearedSysPropShouldBePutBackAfterTestMethod_whenTestMethodAnnotated() {
39 | System.setProperty(TEST_SYS_PROP_NAME, TEST_SYS_PROP_VALUE);
40 | try {
41 | Assert.assertEquals(TEST_SYS_PROP_VALUE, System.getProperty(TEST_SYS_PROP_NAME));
42 | runTestMethod(EnvironmentVariableSandboxRuleTestInternal1.class, "clearSysProp");
43 | Assert.assertEquals(TEST_SYS_PROP_VALUE, System.getProperty(TEST_SYS_PROP_NAME));
44 | } finally {
45 | System.clearProperty(TEST_SYS_PROP_NAME);
46 | }
47 | }
48 |
49 | @Test
50 | public void setSysPropShouldBeClearedAfterTestMethod_whenTestClassAnnotated() {
51 | Assert.assertNull(System.getProperty(TEST_SYS_PROP_NAME));
52 | runTestMethod(EnvironmentVariableSandboxRuleTestInternal2.class, "setSysProp");
53 | Assert.assertNull(System.getProperty(TEST_SYS_PROP_NAME));
54 | }
55 |
56 | @Test
57 | public void updatedSysPropShouldBeRevertedBackAfterTestMethod_whenTestClassAnnotated() {
58 | System.setProperty(TEST_SYS_PROP_NAME, TEST_SYS_PROP_VALUE);
59 | try {
60 | Assert.assertEquals(TEST_SYS_PROP_VALUE, System.getProperty(TEST_SYS_PROP_NAME));
61 | runTestMethod(EnvironmentVariableSandboxRuleTestInternal2.class, "updateSysProp");
62 | Assert.assertEquals(TEST_SYS_PROP_VALUE, System.getProperty(TEST_SYS_PROP_NAME));
63 | } finally {
64 | System.clearProperty(TEST_SYS_PROP_NAME);
65 | }
66 | }
67 |
68 | @Test
69 | public void clearedSysPropShouldBePutBackAfterTestMethod_whenTestClassAnnotated() {
70 | System.setProperty(TEST_SYS_PROP_NAME, TEST_SYS_PROP_VALUE);
71 | try {
72 | Assert.assertEquals(TEST_SYS_PROP_VALUE, System.getProperty(TEST_SYS_PROP_NAME));
73 | runTestMethod(EnvironmentVariableSandboxRuleTestInternal2.class, "clearSysProp");
74 | Assert.assertEquals(TEST_SYS_PROP_VALUE, System.getProperty(TEST_SYS_PROP_NAME));
75 | } finally {
76 | System.clearProperty(TEST_SYS_PROP_NAME);
77 | }
78 | }
79 |
80 | public static class EnvironmentVariableSandboxRuleTestInternal1 {
81 |
82 | @Rule
83 | public SystemPropertySandboxRule rule = new SystemPropertySandboxRule();
84 |
85 | @Test
86 | public void setSysProp() {
87 | System.setProperty(TEST_SYS_PROP_NAME, TEST_SYS_PROP_VALUE);
88 | Assert.assertEquals(TEST_SYS_PROP_VALUE, System.getProperty(TEST_SYS_PROP_NAME));
89 | }
90 |
91 | @Test
92 | public void updateSysProp() {
93 | System.setProperty(TEST_SYS_PROP_NAME, TEST_SYS_PROP_VALUE_UPDATED);
94 | Assert.assertEquals(TEST_SYS_PROP_VALUE_UPDATED, System.getProperty(TEST_SYS_PROP_NAME));
95 | }
96 |
97 | @Test
98 | public void clearSysProp() {
99 | System.clearProperty(TEST_SYS_PROP_NAME);
100 | Assert.assertNull(System.getProperty(TEST_SYS_PROP_NAME));
101 | }
102 |
103 | }
104 |
105 | public static class EnvironmentVariableSandboxRuleTestInternal2 {
106 |
107 | @ClassRule
108 | public static SystemPropertySandboxRule rule = new SystemPropertySandboxRule();
109 |
110 | @Test
111 | public void setSysProp() {
112 | System.setProperty(TEST_SYS_PROP_NAME, TEST_SYS_PROP_VALUE);
113 | Assert.assertEquals(TEST_SYS_PROP_VALUE, System.getProperty(TEST_SYS_PROP_NAME));
114 | }
115 |
116 | @Test
117 | public void updateSysProp() {
118 | System.setProperty(TEST_SYS_PROP_NAME, TEST_SYS_PROP_VALUE_UPDATED);
119 | Assert.assertEquals(TEST_SYS_PROP_VALUE_UPDATED, System.getProperty(TEST_SYS_PROP_NAME));
120 | }
121 |
122 | @Test
123 | public void clearSysProp() {
124 | System.clearProperty(TEST_SYS_PROP_NAME);
125 | Assert.assertNull(System.getProperty(TEST_SYS_PROP_NAME));
126 | }
127 |
128 | }
129 |
130 | }
131 |
--------------------------------------------------------------------------------
/jexter-junit5-core/pom.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 | 4.0.0
4 |
5 |
6 | io.thundra
7 | jexter
8 | 1.0.2-SNAPSHOT
9 |
10 |
11 | io.thundra
12 | jexter-junit5-core
13 | jexter-junit5-core
14 | jar
15 |
16 |
17 | 5.7.1
18 | 1.7.1
19 |
20 |
21 |
22 |
23 | io.thundra
24 | jexter-core
25 |
26 |
27 |
28 | org.junit.jupiter
29 | junit-jupiter
30 | ${junit5.jupiter.version}
31 | provided
32 | true
33 |
34 |
35 | org.junit.jupiter
36 | junit-jupiter-engine
37 | ${junit5.jupiter.version}
38 | test
39 |
40 |
41 | org.junit.platform
42 | junit-platform-launcher
43 | ${junit5.platform.version}
44 | test
45 |
46 |
47 |
48 |
--------------------------------------------------------------------------------
/jexter-junit5-core/src/main/java/io/thundra/jexter/junit5/core/JexterBaseExtension.java:
--------------------------------------------------------------------------------
1 | package io.thundra.jexter.junit5.core;
2 |
3 | import org.junit.jupiter.api.extension.Extension;
4 | import org.junit.jupiter.api.extension.ExtensionContext;
5 |
6 | /**
7 | * Base class for Jexter {@link Extension}s
8 | *
9 | * @author serkan
10 | */
11 | public abstract class JexterBaseExtension implements Extension {
12 |
13 | protected ExtensionContext.Store getStore(ExtensionContext context) {
14 | return context.getStore(ExtensionContext.Namespace.create(getClass()));
15 | }
16 |
17 | protected String getStoreKey(ExtensionContext context) {
18 | return context.getUniqueId() + "$" + getClass().getName();
19 | }
20 |
21 | }
22 |
--------------------------------------------------------------------------------
/jexter-junit5-core/src/main/java/io/thundra/jexter/junit5/core/envvar/EnvironmentVariableSandbox.java:
--------------------------------------------------------------------------------
1 | package io.thundra.jexter.junit5.core.envvar;
2 |
3 | import org.junit.jupiter.api.extension.ExtendWith;
4 |
5 | import java.lang.annotation.ElementType;
6 | import java.lang.annotation.Inherited;
7 | import java.lang.annotation.Retention;
8 | import java.lang.annotation.RetentionPolicy;
9 | import java.lang.annotation.Target;
10 |
11 | /**
12 | * {@code @EnvironmentVariableSandbox} is a JUnit Jupiter extension
13 | * to manage environment variables in a sandbox for a test execution.
14 | *
15 | * So modifications over environment variables during the text execution are rolled-back
16 | * after the test to prevent effecting subsequent tests.
17 | *
18 | * {@code EnvironmentVariableSandbox} can be used on the method and
19 | * on the class level. If a class is annotated, environment variables will be
20 | * sandboxed for all tests inside that class.
21 | *
22 | * WARNING: Java considers environment variables to be immutable, so this extension
23 | * uses reflection to change them. This requires that the {@link SecurityManager}
24 | * allows modifications and can potentially break on different operating systems and
25 | * Java versions. Be aware that this is a fragile solution and consider finding a
26 | * better one for your specific situation. If you're running on Java 9 or later, you
27 | * may have to add {@code --add-opens=java.base/java.util=ALL-UNNAMED} to your test
28 | * execution to prevent warnings or even errors.
29 | *
30 | * @author serkan
31 | */
32 | @Retention(RetentionPolicy.RUNTIME)
33 | @Target({ ElementType.METHOD, ElementType.TYPE })
34 | @Inherited
35 | @ExtendWith(EnvironmentVariableSandboxExtension.class)
36 | public @interface EnvironmentVariableSandbox {
37 | }
38 |
--------------------------------------------------------------------------------
/jexter-junit5-core/src/main/java/io/thundra/jexter/junit5/core/envvar/EnvironmentVariableSandboxExtension.java:
--------------------------------------------------------------------------------
1 | package io.thundra.jexter.junit5.core.envvar;
2 |
3 | import io.thundra.jexter.core.envvar.EnvironmentVariableHelper;
4 | import io.thundra.jexter.junit5.core.JexterBaseExtension;
5 | import org.junit.jupiter.api.extension.AfterAllCallback;
6 | import org.junit.jupiter.api.extension.AfterEachCallback;
7 | import org.junit.jupiter.api.extension.BeforeAllCallback;
8 | import org.junit.jupiter.api.extension.BeforeEachCallback;
9 | import org.junit.jupiter.api.extension.ExtensionContext;
10 |
11 | import java.util.Map;
12 |
13 | /**
14 | * {@link org.junit.jupiter.api.extension.Extension} implementation
15 | * which stores environment variables before the test
16 | * and restores them back to original value after the test.
17 | *
18 | * @author serkan
19 | */
20 | public class EnvironmentVariableSandboxExtension
21 | extends JexterBaseExtension
22 | implements BeforeAllCallback, BeforeEachCallback, AfterAllCallback, AfterEachCallback {
23 |
24 | private void storeEnvVars(ExtensionContext context) {
25 | ExtensionContext.Store store = getStore(context);
26 | String storeKey = getStoreKey(context);
27 | EnvVarsBackup envVarsBackup = new EnvVarsBackup(EnvironmentVariableHelper.getAllCopy());
28 | store.put(storeKey, envVarsBackup);
29 | }
30 |
31 | private void restoreEnvVars(ExtensionContext context) {
32 | ExtensionContext.Store store = getStore(context);
33 | String storeKey = getStoreKey(context);
34 | EnvVarsBackup envVarsBackup = (EnvVarsBackup) store.get(storeKey);
35 | if (envVarsBackup != null) {
36 | EnvironmentVariableHelper.setAll(envVarsBackup.envVars);
37 | }
38 | }
39 |
40 | private static class EnvVarsBackup {
41 |
42 | private final Map envVars;
43 |
44 | public EnvVarsBackup(Map envVars) {
45 | this.envVars = envVars;
46 | }
47 |
48 | }
49 |
50 | @Override
51 | public void beforeAll(ExtensionContext context) throws Exception {
52 | storeEnvVars(context);
53 | }
54 |
55 | @Override
56 | public void beforeEach(ExtensionContext context) throws Exception {
57 | storeEnvVars(context);
58 | }
59 |
60 | @Override
61 | public void afterEach(ExtensionContext context) throws Exception {
62 | restoreEnvVars(context);
63 | }
64 |
65 | @Override
66 | public void afterAll(ExtensionContext context) throws Exception {
67 | restoreEnvVars(context);
68 | }
69 |
70 | }
71 |
--------------------------------------------------------------------------------
/jexter-junit5-core/src/main/java/io/thundra/jexter/junit5/core/sw/Stopwatch.java:
--------------------------------------------------------------------------------
1 | package io.thundra.jexter.junit5.core.sw;
2 |
3 | import org.junit.jupiter.api.extension.ExtendWith;
4 |
5 | import java.lang.annotation.ElementType;
6 | import java.lang.annotation.Inherited;
7 | import java.lang.annotation.Retention;
8 | import java.lang.annotation.RetentionPolicy;
9 | import java.lang.annotation.Target;
10 |
11 | /**
12 | * {@code @Stopwatch} is a JUnit Jupiter extension
13 | * to measure the elapsed time of a test execution.
14 | *
15 | * {@code Stopwatch} can be used on the method and
16 | * on the class level. If a class is annotated, total execution time will be
17 | * measured for all tests inside that class.
18 | *
19 | * @author serkan
20 | */
21 | @Retention(RetentionPolicy.RUNTIME)
22 | @Target({ ElementType.METHOD, ElementType.TYPE })
23 | @Inherited
24 | @ExtendWith(StopwatchExtension.class)
25 | public @interface Stopwatch {
26 | }
27 |
--------------------------------------------------------------------------------
/jexter-junit5-core/src/main/java/io/thundra/jexter/junit5/core/sw/StopwatchExtension.java:
--------------------------------------------------------------------------------
1 | package io.thundra.jexter.junit5.core.sw;
2 |
3 | import io.thundra.jexter.junit5.core.JexterBaseExtension;
4 | import org.junit.jupiter.api.extension.AfterAllCallback;
5 | import org.junit.jupiter.api.extension.AfterEachCallback;
6 | import org.junit.jupiter.api.extension.BeforeAllCallback;
7 | import org.junit.jupiter.api.extension.BeforeEachCallback;
8 | import org.junit.jupiter.api.extension.ExtensionContext;
9 |
10 | import java.lang.reflect.Method;
11 | import java.util.Optional;
12 |
13 | /**
14 | * {@link org.junit.jupiter.api.extension.Extension} implementation
15 | * which measures the elapsed time of a test execution.
16 | *
17 | * @author serkan
18 | */
19 | public class StopwatchExtension
20 | extends JexterBaseExtension
21 | implements BeforeAllCallback, BeforeEachCallback, AfterAllCallback, AfterEachCallback {
22 |
23 | private void storeStopwatch(ExtensionContext context) {
24 | ExtensionContext.Store store = getStore(context);
25 | String storeKey = getStoreKey(context);
26 | StopwatchExtension.StopwatchBackup stopwatchBackup =
27 | new StopwatchExtension.StopwatchBackup(System.currentTimeMillis());
28 | store.put(storeKey, stopwatchBackup);
29 | }
30 |
31 | private void restoreStopwatch(ExtensionContext context) {
32 | ExtensionContext.Store store = getStore(context);
33 | String storeKey = getStoreKey(context);
34 | StopwatchExtension.StopwatchBackup stopwatchBackup = (StopwatchExtension.StopwatchBackup) store.get(storeKey);
35 | if (stopwatchBackup != null) {
36 | long elapsedTime = System.currentTimeMillis() - stopwatchBackup.startTime;
37 | Optional testMethod = context.getTestMethod();
38 | String message;
39 | if (!testMethod.isPresent()) {
40 | message = String.format(
41 | "Execution of test suite '%s' took [%d] ms.",
42 | context.getRequiredTestClass().getName(),
43 | elapsedTime);
44 | } else {
45 | message = String.format(
46 | "Execution of test '%s#%s' took [%d] ms.",
47 | context.getRequiredTestClass().getName(),
48 | testMethod.get().getName(),
49 | elapsedTime);
50 | }
51 | System.out.println(message);
52 | context.publishReportEntry(getStoreKey(context), message);
53 | }
54 | }
55 |
56 | private static class StopwatchBackup {
57 |
58 | private final long startTime;
59 |
60 | public StopwatchBackup(long startTime) {
61 | this.startTime = startTime;
62 | }
63 |
64 | }
65 |
66 | @Override
67 | public void beforeAll(ExtensionContext context) throws Exception {
68 | storeStopwatch(context);
69 | }
70 |
71 | @Override
72 | public void beforeEach(ExtensionContext context) throws Exception {
73 | storeStopwatch(context);
74 | }
75 |
76 | @Override
77 | public void afterEach(ExtensionContext context) throws Exception {
78 | restoreStopwatch(context);
79 | }
80 |
81 | @Override
82 | public void afterAll(ExtensionContext context) throws Exception {
83 | restoreStopwatch(context);
84 | }
85 |
86 | }
87 |
--------------------------------------------------------------------------------
/jexter-junit5-core/src/main/java/io/thundra/jexter/junit5/core/sysprop/SystemPropertySandbox.java:
--------------------------------------------------------------------------------
1 | package io.thundra.jexter.junit5.core.sysprop;
2 |
3 | import org.junit.jupiter.api.extension.ExtendWith;
4 |
5 | import java.lang.annotation.ElementType;
6 | import java.lang.annotation.Inherited;
7 | import java.lang.annotation.Retention;
8 | import java.lang.annotation.RetentionPolicy;
9 | import java.lang.annotation.Target;
10 |
11 | /**
12 | * {@code @SystemPropertySandbox} is a JUnit Jupiter extension
13 | * to manage system properties in a sandbox for a test execution.
14 | *
15 | * So modifications over system properties during the text execution are rolled-back
16 | * after the test to prevent effecting subsequent tests.
17 | *
18 | * {@code SystemPropertySandbox} can be used on the method and
19 | * on the class level. If a class is annotated, system properties will be
20 | * sandboxed for all tests inside that class.
21 | *
22 | * @author serkan
23 | */
24 | @Retention(RetentionPolicy.RUNTIME)
25 | @Target({ ElementType.METHOD, ElementType.TYPE })
26 | @Inherited
27 | @ExtendWith(SystemPropertySandboxExtension.class)
28 | public @interface SystemPropertySandbox {
29 | }
30 |
--------------------------------------------------------------------------------
/jexter-junit5-core/src/main/java/io/thundra/jexter/junit5/core/sysprop/SystemPropertySandboxExtension.java:
--------------------------------------------------------------------------------
1 | package io.thundra.jexter.junit5.core.sysprop;
2 |
3 | import io.thundra.jexter.core.sysprop.ThreadLocalProperties;
4 | import io.thundra.jexter.junit5.core.JexterBaseExtension;
5 | import org.junit.jupiter.api.extension.AfterAllCallback;
6 | import org.junit.jupiter.api.extension.AfterEachCallback;
7 | import org.junit.jupiter.api.extension.BeforeAllCallback;
8 | import org.junit.jupiter.api.extension.BeforeEachCallback;
9 | import org.junit.jupiter.api.extension.ExtensionContext;
10 |
11 | import java.util.Properties;
12 |
13 | /**
14 | * {@link org.junit.jupiter.api.extension.Extension} implementation
15 | * which stores system properties before the test
16 | * and restores them back to original value after the test.
17 | *
18 | * @author serkan
19 | */
20 | public class SystemPropertySandboxExtension
21 | extends JexterBaseExtension
22 | implements BeforeAllCallback, BeforeEachCallback, AfterAllCallback, AfterEachCallback {
23 |
24 | private void storeSysProps(ExtensionContext context) {
25 | ExtensionContext.Store store = getStore(context);
26 | String storeKey = getStoreKey(context);
27 | Properties sysProps = System.getProperties();
28 | System.setProperties(new ThreadLocalProperties(sysProps));
29 | SysPropsBackup sysPropsBackup = new SysPropsBackup(sysProps);
30 | store.put(storeKey, sysPropsBackup);
31 | }
32 |
33 | private void restoreSysProps(ExtensionContext context) {
34 | ExtensionContext.Store store = getStore(context);
35 | String storeKey = getStoreKey(context);
36 | SysPropsBackup sysPropsBackup = (SysPropsBackup) store.get(storeKey);
37 | if (sysPropsBackup != null) {
38 | System.setProperties(sysPropsBackup.sysProps);
39 | }
40 | }
41 |
42 | private static class SysPropsBackup {
43 |
44 | private final Properties sysProps;
45 |
46 | public SysPropsBackup(Properties sysProps) {
47 | this.sysProps = sysProps;
48 | }
49 |
50 | }
51 |
52 | @Override
53 | public void beforeAll(ExtensionContext context) throws Exception {
54 | storeSysProps(context);
55 | }
56 |
57 | @Override
58 | public void beforeEach(ExtensionContext context) throws Exception {
59 | storeSysProps(context);
60 | }
61 |
62 | @Override
63 | public void afterEach(ExtensionContext context) throws Exception {
64 | restoreSysProps(context);
65 | }
66 |
67 | @Override
68 | public void afterAll(ExtensionContext context) throws Exception {
69 | restoreSysProps(context);
70 | }
71 |
72 | }
73 |
--------------------------------------------------------------------------------
/jexter-junit5-core/src/test/java/io/thundra/jexter/junit5/core/BaseTest.java:
--------------------------------------------------------------------------------
1 | package io.thundra.jexter.junit5.core;
2 |
3 | import io.thundra.jexter.core.utils.ExceptionUtils;
4 | import org.junit.platform.engine.TestExecutionResult;
5 | import org.junit.platform.launcher.Launcher;
6 | import org.junit.platform.launcher.LauncherDiscoveryRequest;
7 | import org.junit.platform.launcher.TestExecutionListener;
8 | import org.junit.platform.launcher.TestIdentifier;
9 | import org.junit.platform.launcher.TestPlan;
10 | import org.junit.platform.launcher.core.LauncherDiscoveryRequestBuilder;
11 | import org.junit.platform.launcher.core.LauncherFactory;
12 |
13 | import java.util.concurrent.atomic.AtomicReference;
14 |
15 | import static org.junit.platform.engine.discovery.DiscoverySelectors.selectMethod;
16 |
17 | /**
18 | * @author serkan
19 | */
20 | public abstract class BaseTest {
21 |
22 | private static final Launcher launcher = LauncherFactory.create();
23 |
24 | protected static void runTestMethod(Class testClass, String testMethodName) {
25 | LauncherDiscoveryRequest launcherDiscoveryRequest =
26 | LauncherDiscoveryRequestBuilder.
27 | request().
28 | selectors(selectMethod(testClass, testMethodName)).
29 | build();
30 | TestPlan testPlan = launcher.discover(launcherDiscoveryRequest);
31 | AtomicReference errorRef = new AtomicReference<>();
32 | launcher.execute(testPlan, new TestExecutionListener[]{ new TestExecutionListener() {
33 | @Override
34 | public void executionFinished(TestIdentifier testIdentifier, TestExecutionResult testExecutionResult) {
35 | if (testExecutionResult.getThrowable().isPresent()) {
36 | errorRef.set(testExecutionResult.getThrowable().get());
37 | }
38 | }
39 | }});
40 | if (errorRef.get() != null) {
41 | ExceptionUtils.sneakyThrow(errorRef.get());
42 | }
43 | }
44 |
45 | }
46 |
--------------------------------------------------------------------------------
/jexter-junit5-core/src/test/java/io/thundra/jexter/junit5/core/envvar/EnvironmentVariableSandboxExtensionTest.java:
--------------------------------------------------------------------------------
1 | package io.thundra.jexter.junit5.core.envvar;
2 |
3 | import io.thundra.jexter.core.envvar.EnvironmentVariableHelper;
4 | import io.thundra.jexter.junit5.core.BaseTest;
5 | import org.junit.jupiter.api.Assertions;
6 | import org.junit.jupiter.api.Test;
7 |
8 | /**
9 | * @author serkan
10 | */
11 | public class EnvironmentVariableSandboxExtensionTest extends BaseTest {
12 |
13 | private static final String TEST_ENV_VAR_NAME = "key";
14 | private static final String TEST_ENV_VAR_VALUE = "val";
15 | private static final String TEST_ENV_VAR_VALUE_UPDATED = "val-updated";
16 |
17 | @Test
18 | public void setEnvVarShouldBeClearedAfterTestMethod_whenTestMethodAnnotated() {
19 | Assertions.assertNull(EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
20 | runTestMethod(EnvironmentVariableSandboxExtensionTestInternal1.class, "setEnvVar");
21 | Assertions.assertNull(EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
22 | }
23 |
24 | @Test
25 | public void updatedEnvVarShouldBeRevertedBackAfterTestMethod_whenTestMethodAnnotated() {
26 | EnvironmentVariableHelper.set(TEST_ENV_VAR_NAME, TEST_ENV_VAR_VALUE);
27 | try {
28 | Assertions.assertEquals(TEST_ENV_VAR_VALUE, EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
29 | runTestMethod(EnvironmentVariableSandboxExtensionTestInternal1.class, "updateEnvVar");
30 | Assertions.assertEquals(TEST_ENV_VAR_VALUE, EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
31 | } finally {
32 | EnvironmentVariableHelper.remove(TEST_ENV_VAR_NAME);
33 | }
34 | }
35 |
36 | @Test
37 | public void clearedEnvVarShouldBePutBackAfterTestMethod_whenTestMethodAnnotated() {
38 | EnvironmentVariableHelper.set(TEST_ENV_VAR_NAME, TEST_ENV_VAR_VALUE);
39 | try {
40 | Assertions.assertEquals(TEST_ENV_VAR_VALUE, EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
41 | runTestMethod(EnvironmentVariableSandboxExtensionTestInternal1.class, "clearEnvVar");
42 | Assertions.assertEquals(TEST_ENV_VAR_VALUE, EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
43 | } finally {
44 | EnvironmentVariableHelper.remove(TEST_ENV_VAR_NAME);
45 | }
46 | }
47 |
48 | @Test
49 | public void setEnvVarShouldBeClearedAfterTestMethod_whenTestClassAnnotated() {
50 | Assertions.assertNull(EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
51 | runTestMethod(EnvironmentVariableSandboxExtensionTestInternal2.class, "setEnvVar");
52 | Assertions.assertNull(EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
53 | }
54 |
55 | @Test
56 | public void updatedEnvVarShouldBeRevertedBackAfterTestMethod_whenTestClassAnnotated() {
57 | EnvironmentVariableHelper.set(TEST_ENV_VAR_NAME, TEST_ENV_VAR_VALUE);
58 | try {
59 | Assertions.assertEquals(TEST_ENV_VAR_VALUE, EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
60 | runTestMethod(EnvironmentVariableSandboxExtensionTestInternal2.class, "updateEnvVar");
61 | Assertions.assertEquals(TEST_ENV_VAR_VALUE, EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
62 | } finally {
63 | EnvironmentVariableHelper.remove(TEST_ENV_VAR_NAME);
64 | }
65 | }
66 |
67 | @Test
68 | public void clearedEnvVarShouldBePutBackAfterTestMethod_whenTestClassAnnotated() {
69 | EnvironmentVariableHelper.set(TEST_ENV_VAR_NAME, TEST_ENV_VAR_VALUE);
70 | try {
71 | Assertions.assertEquals(TEST_ENV_VAR_VALUE, EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
72 | runTestMethod(EnvironmentVariableSandboxExtensionTestInternal2.class, "clearEnvVar");
73 | Assertions.assertEquals(TEST_ENV_VAR_VALUE, EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
74 | } finally {
75 | EnvironmentVariableHelper.remove(TEST_ENV_VAR_NAME);
76 | }
77 | }
78 |
79 | public static class EnvironmentVariableSandboxExtensionTestInternal1 {
80 |
81 | @Test
82 | @EnvironmentVariableSandbox
83 | public void setEnvVar() {
84 | EnvironmentVariableHelper.set(TEST_ENV_VAR_NAME, TEST_ENV_VAR_VALUE);
85 | Assertions.assertEquals(TEST_ENV_VAR_VALUE, EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
86 | }
87 |
88 | @Test
89 | @EnvironmentVariableSandbox
90 | public void updateEnvVar() {
91 | EnvironmentVariableHelper.set(TEST_ENV_VAR_NAME, TEST_ENV_VAR_VALUE_UPDATED);
92 | Assertions.assertEquals(TEST_ENV_VAR_VALUE_UPDATED, EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
93 | }
94 |
95 | @Test
96 | @EnvironmentVariableSandbox
97 | public void clearEnvVar() {
98 | EnvironmentVariableHelper.remove(TEST_ENV_VAR_NAME);
99 | Assertions.assertNull(EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
100 | }
101 |
102 | }
103 |
104 | @EnvironmentVariableSandbox
105 | public static class EnvironmentVariableSandboxExtensionTestInternal2 {
106 |
107 | @Test
108 | public void setEnvVar() {
109 | EnvironmentVariableHelper.set(TEST_ENV_VAR_NAME, TEST_ENV_VAR_VALUE);
110 | Assertions.assertEquals(TEST_ENV_VAR_VALUE, EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
111 | }
112 |
113 | @Test
114 | public void updateEnvVar() {
115 | EnvironmentVariableHelper.set(TEST_ENV_VAR_NAME, TEST_ENV_VAR_VALUE_UPDATED);
116 | Assertions.assertEquals(TEST_ENV_VAR_VALUE_UPDATED, EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
117 | }
118 |
119 | @Test
120 | public void clearEnvVar() {
121 | EnvironmentVariableHelper.remove(TEST_ENV_VAR_NAME);
122 | Assertions.assertNull(EnvironmentVariableHelper.get(TEST_ENV_VAR_NAME));
123 | }
124 |
125 | }
126 |
127 | }
128 |
--------------------------------------------------------------------------------
/jexter-junit5-core/src/test/java/io/thundra/jexter/junit5/core/sw/StopwatchExtensionTest.java:
--------------------------------------------------------------------------------
1 | package io.thundra.jexter.junit5.core.sw;
2 |
3 | import io.thundra.jexter.junit5.core.BaseTest;
4 | import org.junit.jupiter.api.Assertions;
5 | import org.junit.jupiter.api.Test;
6 |
7 | import java.io.ByteArrayOutputStream;
8 | import java.io.PrintStream;
9 |
10 | /**
11 | * @author serkan
12 | */
13 | public class StopwatchExtensionTest extends BaseTest {
14 |
15 | @Test
16 | public void elapsedTimeShouldBePrinted_whenTestMethodAnnotated() {
17 | PrintStream out = System.out;
18 | try {
19 | ByteArrayOutputStream baos = new ByteArrayOutputStream();
20 | System.setOut(new PrintStream(baos));
21 | runTestMethod(StopwatchExtensionTest.StopwatchExtensionTestInternal1.class, "test");
22 | String outContent = baos.toString();
23 | Assertions.assertNotNull(outContent);
24 | Assertions.assertTrue(outContent.contains("Execution of test"));
25 | } finally {
26 | System.setOut(out);
27 | }
28 | }
29 |
30 | @Test
31 | public void elapsedTimeShouldBePrinted_whenTestClassAnnotated() {
32 | PrintStream out = System.out;
33 | try {
34 | ByteArrayOutputStream baos = new ByteArrayOutputStream();
35 | System.setOut(new PrintStream(baos));
36 | runTestMethod(StopwatchExtensionTest.StopwatchExtensionTestInternal2.class, "test");
37 | String outContent = baos.toString();
38 | Assertions.assertNotNull(outContent);
39 | Assertions.assertTrue(outContent.contains("Execution of test suite"));
40 | } finally {
41 | System.setOut(out);
42 | }
43 | }
44 |
45 | public static class StopwatchExtensionTestInternal1 {
46 |
47 | @Stopwatch
48 | @Test
49 | public void test() {
50 | }
51 |
52 | }
53 |
54 | @Stopwatch
55 | public static class StopwatchExtensionTestInternal2 {
56 |
57 | @Test
58 | public void test() {
59 | }
60 |
61 | }
62 |
63 | }
64 |
--------------------------------------------------------------------------------
/jexter-junit5-core/src/test/java/io/thundra/jexter/junit5/core/sysprop/SystemPropertySandboxExtensionTest.java:
--------------------------------------------------------------------------------
1 | package io.thundra.jexter.junit5.core.sysprop;
2 |
3 | import io.thundra.jexter.junit5.core.BaseTest;
4 | import org.junit.jupiter.api.Assertions;
5 | import org.junit.jupiter.api.Test;
6 |
7 | /**
8 | * @author serkan
9 | */
10 | public class SystemPropertySandboxExtensionTest extends BaseTest {
11 |
12 | private static final String TEST_SYS_PROP_NAME = "key";
13 | private static final String TEST_SYS_PROP_VALUE = "val";
14 | private static final String TEST_SYS_PROP_VALUE_UPDATED = "val-updated";
15 |
16 | @Test
17 | public void setSysPropShouldBeClearedAfterTestMethod_whenTestMethodAnnotated() {
18 | Assertions.assertNull(System.getProperty(TEST_SYS_PROP_NAME));
19 | runTestMethod(SystemPropertySandboxExtensionTestInternal1.class, "setSysProp");
20 | Assertions.assertNull(System.getProperty(TEST_SYS_PROP_NAME));
21 | }
22 |
23 | @Test
24 | public void updatedSysPropShouldBeRevertedBackAfterTestMethod_whenTestMethodAnnotated() {
25 | System.setProperty(TEST_SYS_PROP_NAME, TEST_SYS_PROP_VALUE);
26 | try {
27 | Assertions.assertEquals(TEST_SYS_PROP_VALUE, System.getProperty(TEST_SYS_PROP_NAME));
28 | runTestMethod(SystemPropertySandboxExtensionTestInternal1.class, "updateSysProp");
29 | Assertions.assertEquals(TEST_SYS_PROP_VALUE, System.getProperty(TEST_SYS_PROP_NAME));
30 | } finally {
31 | System.clearProperty(TEST_SYS_PROP_NAME);
32 | }
33 | }
34 |
35 | @Test
36 | public void clearedSysPropShouldBePutBackAfterTestMethod_whenTestMethodAnnotated() {
37 | System.setProperty(TEST_SYS_PROP_NAME, TEST_SYS_PROP_VALUE);
38 | try {
39 | Assertions.assertEquals(TEST_SYS_PROP_VALUE, System.getProperty(TEST_SYS_PROP_NAME));
40 | runTestMethod(SystemPropertySandboxExtensionTestInternal1.class, "clearSysProp");
41 | Assertions.assertEquals(TEST_SYS_PROP_VALUE, System.getProperty(TEST_SYS_PROP_NAME));
42 | } finally {
43 | System.clearProperty(TEST_SYS_PROP_NAME);
44 | }
45 | }
46 |
47 | @Test
48 | public void setSysPropShouldBeClearedAfterTestMethod_whenTestClassAnnotated() {
49 | Assertions.assertNull(System.getProperty(TEST_SYS_PROP_NAME));
50 | runTestMethod(SystemPropertySandboxExtensionTestInternal2.class, "setSysProp");
51 | Assertions.assertNull(System.getProperty(TEST_SYS_PROP_NAME));
52 | }
53 |
54 | @Test
55 | public void updatedSysPropShouldBeRevertedBackAfterTestMethod_whenTestClassAnnotated() {
56 | System.setProperty(TEST_SYS_PROP_NAME, TEST_SYS_PROP_VALUE);
57 | try {
58 | Assertions.assertEquals(TEST_SYS_PROP_VALUE, System.getProperty(TEST_SYS_PROP_NAME));
59 | runTestMethod(SystemPropertySandboxExtensionTestInternal2.class, "updateSysProp");
60 | Assertions.assertEquals(TEST_SYS_PROP_VALUE, System.getProperty(TEST_SYS_PROP_NAME));
61 | } finally {
62 | System.clearProperty(TEST_SYS_PROP_NAME);
63 | }
64 | }
65 |
66 | @Test
67 | public void clearedSysPropShouldBePutBackAfterTestMethod_whenTestClassAnnotated() {
68 | System.setProperty(TEST_SYS_PROP_NAME, TEST_SYS_PROP_VALUE);
69 | try {
70 | Assertions.assertEquals(TEST_SYS_PROP_VALUE, System.getProperty(TEST_SYS_PROP_NAME));
71 | runTestMethod(SystemPropertySandboxExtensionTestInternal2.class, "clearSysProp");
72 | Assertions.assertEquals(TEST_SYS_PROP_VALUE, System.getProperty(TEST_SYS_PROP_NAME));
73 | } finally {
74 | System.clearProperty(TEST_SYS_PROP_NAME);
75 | }
76 | }
77 |
78 | public static class SystemPropertySandboxExtensionTestInternal1 {
79 |
80 | @Test
81 | @SystemPropertySandbox
82 | public void setSysProp() {
83 | System.setProperty(TEST_SYS_PROP_NAME, TEST_SYS_PROP_VALUE);
84 | Assertions.assertEquals(TEST_SYS_PROP_VALUE, System.getProperty(TEST_SYS_PROP_NAME));
85 | }
86 |
87 | @Test
88 | @SystemPropertySandbox
89 | public void updateSysProp() {
90 | System.setProperty(TEST_SYS_PROP_NAME, TEST_SYS_PROP_VALUE_UPDATED);
91 | Assertions.assertEquals(TEST_SYS_PROP_VALUE_UPDATED, System.getProperty(TEST_SYS_PROP_NAME));
92 | }
93 |
94 | @Test
95 | @SystemPropertySandbox
96 | public void clearSysProp() {
97 | System.clearProperty(TEST_SYS_PROP_NAME);
98 | Assertions.assertNull(System.getProperty(TEST_SYS_PROP_NAME));
99 | }
100 |
101 | }
102 |
103 | @SystemPropertySandbox
104 | public static class SystemPropertySandboxExtensionTestInternal2 {
105 |
106 | @Test
107 | public void setSysProp() {
108 | System.setProperty(TEST_SYS_PROP_NAME, TEST_SYS_PROP_VALUE);
109 | Assertions.assertEquals(TEST_SYS_PROP_VALUE, System.getProperty(TEST_SYS_PROP_NAME));
110 | }
111 |
112 | @Test
113 | public void updateSysProp() {
114 | System.setProperty(TEST_SYS_PROP_NAME, TEST_SYS_PROP_VALUE_UPDATED);
115 | Assertions.assertEquals(TEST_SYS_PROP_VALUE_UPDATED, System.getProperty(TEST_SYS_PROP_NAME));
116 | }
117 |
118 | @Test
119 | public void clearSysProp() {
120 | System.clearProperty(TEST_SYS_PROP_NAME);
121 | Assertions.assertNull(System.getProperty(TEST_SYS_PROP_NAME));
122 | }
123 |
124 | }
125 |
126 | }
127 |
--------------------------------------------------------------------------------
/pom.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 | 4.0.0
4 |
5 | io.thundra
6 | jexter
7 | 1.0.2-SNAPSHOT
8 | pom
9 |
10 | Jexter
11 | Extensions/Plugins for JVM test frameworks
12 |
13 | https://github.com/thundra-io/jexter
14 |
15 |
16 |
17 | The Apache License, Version 2.0
18 | https://www.apache.org/licenses/LICENSE-2.0.txt
19 |
20 |
21 |
22 |
23 |
24 | Serkan Özal
25 | serkan@thundra.io
26 | Thundra
27 | https://thundra.io
28 |
29 |
30 |
31 |
32 | https://github.com/thundra-io/jexter.git
33 | scm:git:https://${GITHUB_TOKEN}@github.com/thundra-io/jexter.git
34 | scm:git:https://${GITHUB_TOKEN}@github.com/thundra-io/jexter.git
35 | HEAD
36 |
37 |
38 |
39 | 1.8
40 | 1.8
41 | UTF-8
42 |
43 |
44 |
45 | jexter-core
46 | jexter-junit4-core
47 | jexter-junit5-core
48 |
49 |
50 |
51 |
52 |
53 | io.thundra
54 | jexter-core
55 | ${project.version}
56 |
57 |
58 |
59 |
60 |
61 |
62 |
63 | org.apache.maven.plugins
64 | maven-surefire-plugin
65 | 2.22.0
66 |
67 |
68 | org.apache.maven.plugins
69 | maven-failsafe-plugin
70 | 2.22.0
71 |
72 |
73 | maven-jar-plugin
74 | 3.2.0
75 |
76 |
77 | org.apache.maven.plugins
78 | maven-shade-plugin
79 | 3.2.4
80 |
81 | false
82 |
83 |
84 |
85 |
86 |
87 |
88 | package
89 |
90 | shade
91 |
92 |
93 |
94 |
95 |
96 | org.sonatype.plugins
97 | nexus-staging-maven-plugin
98 | 1.6.8
99 | true
100 |
101 | ossrh
102 | https://s01.oss.sonatype.org/
103 | true
104 |
105 |
106 |
107 |
108 |
109 |
110 |
111 | release
112 |
113 |
114 |
115 | org.codehaus.mojo
116 | build-helper-maven-plugin
117 | 3.2.0
118 |
119 |
120 | org.apache.maven.plugins
121 | maven-source-plugin
122 | 2.4
123 |
124 |
125 | attach-sources
126 |
127 | jar-no-fork
128 |
129 |
130 |
131 |
132 |
133 | org.apache.maven.plugins
134 | maven-javadoc-plugin
135 | 2.10.4
136 |
137 |
138 | attach-javadocs
139 |
140 | jar
141 |
142 |
143 |
144 |
145 |
146 | org.apache.maven.plugins
147 | maven-gpg-plugin
148 | 1.6
149 |
150 |
151 | sign-artifacts
152 | verify
153 |
154 | sign
155 |
156 |
157 |
158 | --pinentry-mode
159 | loopback
160 |
161 |
162 |
163 |
164 |
165 |
166 | org.apache.maven.plugins
167 | maven-release-plugin
168 | 2.5.3
169 |
170 |
171 | org.apache.maven.scm
172 | maven-scm-provider-gitexe
173 | 1.8.1
174 |
175 |
176 | org.apache.maven.plugins
177 | maven-scm-plugin
178 | 1.8.1
179 |
180 |
181 |
182 | v@{project.version}
183 | [ci skip]
184 | true
185 | release
186 | false
187 |
188 | pom.xml
189 |
190 |
191 |
192 |
193 |
194 |
195 |
196 |
197 |
198 |
199 | ossrh
200 | https://s01.oss.sonatype.org/content/repositories/snapshots
201 |
202 |
203 | ossrh
204 | https://s01.oss.sonatype.org/service/local/staging/deploy/maven2/
205 |
206 |
207 |
208 |
209 |
--------------------------------------------------------------------------------