From f2d93c003f9338989c9e4e85de7cbbedbcfca354 Mon Sep 17 00:00:00 2001 From: Patrick Strawderman Date: Sun, 25 Feb 2024 18:55:42 -0800 Subject: [PATCH] Upgrade to junit 5 --- ...bstractConfigurationBridgeFailureTest.java | 34 ++-- .../AbstractConfigurationBridgeTest.java | 111 ++++++------ .../archaius/bridge/BaseBridgeTest.java | 24 +-- .../archaius/bridge/ConfigToCommonsTest.java | 26 +-- .../archaius/bridge/DynamicPropertyTest.java | 55 +++--- .../StaticBridgeAddConfigurationTest.java | 2 +- .../netflix/archaius/ConfigManagerTest.java | 2 +- .../netflix/archaius/CustomDecoderTest.java | 13 +- .../archaius/DefaultConfigLoaderTest.java | 12 +- .../netflix/archaius/DefaultDecoderTest.java | 106 ++++++------ .../DefaultPropertyContainerTest.java | 12 +- .../netflix/archaius/ProxyFactoryTest.java | 138 +++++++-------- .../archaius/config/AbstractConfigTest.java | 12 +- .../archaius/config/CompositeConfigTest.java | 114 +++++++------ .../archaius/config/ConfigLoaderTest.java | 9 +- .../config/DefaultLayeredConfigTest.java | 84 ++++----- .../config/DefaultSettableConfigTest.java | 46 ++--- .../archaius/config/InterpolationTest.java | 42 ++--- .../archaius/config/MapConfigTest.java | 159 +++++++++--------- .../config/PollingDynamicConfigTest.java | 98 ++++++----- .../archaius/config/PrefixedViewTest.java | 46 ++--- .../archaius/config/PrivateViewTest.java | 45 ++--- .../archaius/junit/TestHttpServer.java | 126 +++++++------- .../loaders/PropertyConfigReaderTest.java | 15 +- .../archaius/mapper/ProxyFactoryTest.java | 13 +- .../property/PropertiesServerHandler.java | 1 + .../archaius/property/PropertyTest.java | 141 ++++++++-------- .../archaius/readers/URLConfigReaderTest.java | 16 +- .../netflix/archaius/visitor/VisitorTest.java | 14 +- .../archaius/guice/ArchaiusModuleTest.java | 66 ++++---- .../ConfigurationInjectingListenerTest.java | 6 +- .../guice/InternalArchaiusModuleTest.java | 2 +- .../com/netflix/archaius/guice/ProxyTest.java | 39 +++-- .../FirstScopePropertyValueResolverTest.java | 27 +-- .../persisted2/JsonPersistedV2ReaderTest.java | 27 +-- .../persisted2/PlatformServiceTest.java | 7 +- archaius2-test/build.gradle | 2 + .../archaius/test/ConfigInterfaceTest.java | 1 - build.gradle | 7 +- 39 files changed, 883 insertions(+), 817 deletions(-) diff --git a/archaius2-archaius1-bridge/src/test/java/com/netflix/archaius/bridge/AbstractConfigurationBridgeFailureTest.java b/archaius2-archaius1-bridge/src/test/java/com/netflix/archaius/bridge/AbstractConfigurationBridgeFailureTest.java index 9b38ea1fd..1ceae2bd6 100644 --- a/archaius2-archaius1-bridge/src/test/java/com/netflix/archaius/bridge/AbstractConfigurationBridgeFailureTest.java +++ b/archaius2-archaius1-bridge/src/test/java/com/netflix/archaius/bridge/AbstractConfigurationBridgeFailureTest.java @@ -1,17 +1,18 @@ package com.netflix.archaius.bridge; -import org.junit.Assert; -import org.junit.Before; -import org.junit.Test; - import com.google.inject.AbstractModule; import com.google.inject.Guice; import com.netflix.archaius.guice.ArchaiusModule; import com.netflix.config.ConfigurationManager; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import java.io.PrintWriter; import java.io.StringWriter; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + public class AbstractConfigurationBridgeFailureTest { public static class TestModule extends AbstractModule { @Override @@ -29,26 +30,23 @@ protected void configure() { } } - @Before - public void before() throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException { + @BeforeEach + public void before() throws SecurityException { StaticAbstractConfiguration.reset(); StaticDeploymentContext.reset(); } @Test public void testStaticInModule() { - try { - Guice.createInjector( - new TestModule(), - new BadModule()); - Assert.fail(); - } catch (Exception e) { - StringWriter sw = new StringWriter(); - e.printStackTrace(new PrintWriter(sw)); - String stack = sw.toString(); + Exception exception = assertThrows(Exception.class, () -> + Guice.createInjector( + new TestModule(), + new BadModule())); + StringWriter sw = new StringWriter(); + exception.printStackTrace(new PrintWriter(sw)); + String stack = sw.toString(); - Assert.assertTrue(stack.contains("com.netflix.archaius.bridge.AbstractConfigurationBridgeFailureTest$BadModule")); - Assert.assertTrue(stack.contains("**** Remove static reference")); - } + assertTrue(stack.contains("com.netflix.archaius.bridge.AbstractConfigurationBridgeFailureTest$BadModule")); + assertTrue(stack.contains("**** Remove static reference")); } } diff --git a/archaius2-archaius1-bridge/src/test/java/com/netflix/archaius/bridge/AbstractConfigurationBridgeTest.java b/archaius2-archaius1-bridge/src/test/java/com/netflix/archaius/bridge/AbstractConfigurationBridgeTest.java index 6458dd80b..b860c0ecc 100644 --- a/archaius2-archaius1-bridge/src/test/java/com/netflix/archaius/bridge/AbstractConfigurationBridgeTest.java +++ b/archaius2-archaius1-bridge/src/test/java/com/netflix/archaius/bridge/AbstractConfigurationBridgeTest.java @@ -4,11 +4,8 @@ import org.apache.commons.configuration.ConfigurationException; import org.apache.commons.configuration.MapConfiguration; import org.apache.commons.configuration.event.ConfigurationListener; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Rule; -import org.junit.Test; -import org.junit.rules.TestName; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.mockito.Mockito; import com.google.inject.AbstractModule; @@ -28,6 +25,12 @@ import java.io.IOException; import java.util.Properties; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + public class AbstractConfigurationBridgeTest extends BaseBridgeTest { public static class TestModule extends AbstractModule { private Properties properties; @@ -47,17 +50,13 @@ protected void configure() { bind(SomeClient.class).asEagerSingleton(); } } - - @Rule - public TestName testName = new TestName(); - private static SettableConfig settable; private static Injector injector; private static AbstractConfiguration commonsConfig; private static Config config; - @BeforeClass - public static void before() throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException { + @BeforeAll + public static void before() { final Properties props = new Properties(); props.setProperty("app.override.foo", "bar"); props.setProperty(ContextKey.environment.getKey(), "test"); @@ -73,16 +72,16 @@ protected void configure() { config = injector.getInstance(Config.class); settable = injector.getInstance(Key.get(SettableConfig.class, RuntimeLayer.class)); - Assert.assertTrue(ConfigurationManager.isConfigurationInstalled()); + assertTrue(ConfigurationManager.isConfigurationInstalled()); commonsConfig = ConfigurationManager.getConfigInstance(); - Assert.assertEquals(StaticAbstractConfiguration.class, commonsConfig.getClass()); + assertEquals(StaticAbstractConfiguration.class, commonsConfig.getClass()); } @Test public void testBasicWiring() { SomeClient client = injector.getInstance(SomeClient.class); - Assert.assertNotNull(ConfigurationManager.getConfigInstance()); - Assert.assertEquals("bar", client.fooValue); + assertNotNull(ConfigurationManager.getConfigInstance()); + assertEquals("bar", client.fooValue); } @ConfigurationSource(value={"AbstractConfigurationBridgeTest_libA"}) @@ -94,32 +93,32 @@ static class LibB { } @Test - public void lastLoadedLibraryWins() throws IOException { + public void lastLoadedLibraryWins() { Config config = injector.getInstance(Config.class); injector.getInstance(LibA.class); - Assert.assertTrue(config.getBoolean("libA.loaded", false)); - Assert.assertEquals("libA", config.getString("lib.override", null)); + assertTrue(config.getBoolean("libA.loaded", false)); + assertEquals("libA", config.getString("lib.override", null)); injector.getInstance(LibB.class); - Assert.assertTrue(config.getBoolean("libB.loaded", false)); - Assert.assertEquals("libA", config.getString("lib.override", null)); + assertTrue(config.getBoolean("libB.loaded", false)); + assertEquals("libA", config.getString("lib.override", null)); } @Test public void basicBridgeTest() throws IOException { DeploymentContext context1 = ConfigurationManager.getDeploymentContext(); - Assert.assertNotNull(context1); - Assert.assertEquals("test", context1.getDeploymentEnvironment()); + assertNotNull(context1); + assertEquals("test", context1.getDeploymentEnvironment()); AbstractConfiguration config1 = ConfigurationManager.getConfigInstance(); DeploymentContext contextDi = injector.getInstance(DeploymentContext.class); - Assert.assertNotSame(contextDi, context1); + assertNotSame(contextDi, context1); ConfigurationManager.loadCascadedPropertiesFromResources("AbstractConfigurationBridgeTest_libA"); - Assert.assertTrue(config1.getBoolean("libA.loaded", false)); - Assert.assertEquals("libA", config1.getString("lib.override", null)); + assertTrue(config1.getBoolean("libA.loaded", false)); + assertEquals("libA", config1.getString("lib.override", null)); Config config2 = injector.getInstance(Config.class); SettableConfig settable = injector.getInstance(Key.get(SettableConfig.class, RuntimeLayer.class)); @@ -127,19 +126,19 @@ public void basicBridgeTest() throws IOException { DeploymentContext context2 = ConfigurationManager.getDeploymentContext(); - Assert.assertEquals("foo", ConfigurationManager.getDeploymentContext().getDeploymentEnvironment()); - Assert.assertEquals("foo", context2.getDeploymentEnvironment()); - Assert.assertNotSame(contextDi, context1); - Assert.assertEquals("foo", context1.getDeploymentEnvironment()); + assertEquals("foo", ConfigurationManager.getDeploymentContext().getDeploymentEnvironment()); + assertEquals("foo", context2.getDeploymentEnvironment()); + assertNotSame(contextDi, context1); + assertEquals("foo", context1.getDeploymentEnvironment()); - Assert.assertTrue(config2.getBoolean("libA.loaded", false)); - Assert.assertEquals("libA", config2.getString("lib.override", null)); + assertTrue(config2.getBoolean("libA.loaded", false)); + assertEquals("libA", config2.getString("lib.override", null)); ConfigurationManager.loadCascadedPropertiesFromResources("AbstractConfigurationBridgeTest_libB"); - Assert.assertTrue(config1.getBoolean("libB.loaded", false)); - Assert.assertEquals("libA", config1.getString("lib.override", null)); - Assert.assertTrue(config2.getBoolean("libB.loaded", false)); - Assert.assertEquals("libA", config2.getString("lib.override", null)); + assertTrue(config1.getBoolean("libB.loaded", false)); + assertEquals("libA", config1.getString("lib.override", null)); + assertTrue(config2.getBoolean("libB.loaded", false)); + assertEquals("libA", config2.getString("lib.override", null)); } @@ -155,16 +154,16 @@ public void testBridgePropertiesFromLegacyToNew() throws IOException { Config config2 = injector.getInstance(Config.class); ConfigurationManager.loadCascadedPropertiesFromResources("AbstractConfigurationBridgeTest_libA"); - Assert.assertTrue(config1.getBoolean("libA.loaded", false)); - Assert.assertEquals("libA", config1.getString("lib.override", null)); - Assert.assertTrue(config2.getBoolean("libA.loaded", false)); - Assert.assertEquals("libA", config2.getString("lib.override", null)); + assertTrue(config1.getBoolean("libA.loaded", false)); + assertEquals("libA", config1.getString("lib.override", null)); + assertTrue(config2.getBoolean("libA.loaded", false)); + assertEquals("libA", config2.getString("lib.override", null)); ConfigurationManager.loadCascadedPropertiesFromResources("AbstractConfigurationBridgeTest_libB"); - Assert.assertTrue(config1.getBoolean("libB.loaded", false)); - Assert.assertEquals("libA", config1.getString("lib.override", null)); - Assert.assertTrue(config2.getBoolean("libB.loaded", false)); - Assert.assertEquals("libA", config2.getString("lib.override", null)); + assertTrue(config1.getBoolean("libB.loaded", false)); + assertEquals("libA", config1.getString("lib.override", null)); + assertTrue(config2.getBoolean("libB.loaded", false)); + assertEquals("libA", config2.getString("lib.override", null)); } @@ -179,12 +178,12 @@ public void confirmLegacyOverrideOrder() throws IOException { AbstractConfiguration config = ConfigurationManager.getConfigInstance(); ConfigurationManager.loadCascadedPropertiesFromResources("AbstractConfigurationBridgeTest_libA"); - Assert.assertTrue(config.getBoolean("libA.loaded", false)); - Assert.assertEquals("libA", config.getString("lib.override", null)); + assertTrue(config.getBoolean("libA.loaded", false)); + assertEquals("libA", config.getString("lib.override", null)); ConfigurationManager.loadCascadedPropertiesFromResources("AbstractConfigurationBridgeTest_libB"); - Assert.assertTrue(config.getBoolean("libB.loaded", false)); - Assert.assertEquals("libA", config.getString("lib.override", null)); + assertTrue(config.getBoolean("libB.loaded", false)); + assertEquals("libA", config.getString("lib.override", null)); ConfigurationManager.loadCascadedPropertiesFromResources("AbstractConfigurationBridgeTest_libB"); } @@ -200,9 +199,9 @@ public void confirmLegacyOverrideOrder() throws IOException { public void confirmLegacyOverrideOrderResources() throws IOException, ConfigurationException { super.confirmLegacyOverrideOrderResources(); - Assert.assertEquals("libA", config.getString("lib.legacy.override")); - Assert.assertTrue(config.getBoolean("libA.legacy.loaded")); - Assert.assertTrue(config.getBoolean("libB.legacy.loaded")); + assertEquals("libA", config.getString("lib.legacy.override")); + assertTrue(config.getBoolean("libA.legacy.loaded")); + assertTrue(config.getBoolean("libB.legacy.loaded")); } /** @@ -220,16 +219,16 @@ public void confirmLegacyOverrideOrderAddConfig() throws IOException { p1.setProperty("libA.loaded", "true"); aggregatedConfig.addConfiguration(new MapConfiguration(p1)); - Assert.assertTrue(aggregatedConfig.getBoolean("libA.loaded", false)); - Assert.assertEquals("libA", aggregatedConfig.getString("lib.override", null)); + assertTrue(aggregatedConfig.getBoolean("libA.loaded", false)); + assertEquals("libA", aggregatedConfig.getString("lib.override", null)); Properties p2 = new Properties(); p2.setProperty("lib.override", "libB"); p2.setProperty("libB.loaded", "true"); aggregatedConfig.addConfiguration(new MapConfiguration(p2)); - Assert.assertTrue(aggregatedConfig.getBoolean("libB.loaded", false)); - Assert.assertEquals("libA", aggregatedConfig.getString("lib.override", null)); + assertTrue(aggregatedConfig.getBoolean("libB.loaded", false)); + assertEquals("libA", aggregatedConfig.getString("lib.override", null)); } @Test @@ -250,13 +249,13 @@ public void verifyValueInterpollation() { AbstractConfiguration config = ConfigurationManager.getConfigInstance(); config.setProperty("foo", "${ABC:true}"); boolean value = config.getBoolean("foo"); - Assert.assertTrue(value); + assertTrue(value); } @Test public void verifyMissingProperty() { AbstractConfiguration config = ConfigurationManager.getConfigInstance(); Boolean value = config.getBoolean("foo", null); - Assert.assertNull(value); + assertNull(value); } } diff --git a/archaius2-archaius1-bridge/src/test/java/com/netflix/archaius/bridge/BaseBridgeTest.java b/archaius2-archaius1-bridge/src/test/java/com/netflix/archaius/bridge/BaseBridgeTest.java index 4820f30e5..e0d88f049 100644 --- a/archaius2-archaius1-bridge/src/test/java/com/netflix/archaius/bridge/BaseBridgeTest.java +++ b/archaius2-archaius1-bridge/src/test/java/com/netflix/archaius/bridge/BaseBridgeTest.java @@ -2,20 +2,22 @@ import org.apache.commons.configuration.ConfigurationException; import org.apache.commons.configuration.PropertiesConfiguration; -import org.junit.Assert; -import org.junit.Ignore; -import org.junit.Test; import com.netflix.archaius.api.Config; import com.netflix.config.AggregatedConfiguration; import com.netflix.config.ConfigurationManager; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; import java.io.IOException; import javax.inject.Inject; import javax.inject.Singleton; -@Ignore +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +@Disabled public class BaseBridgeTest { @Singleton public static class SomeClient { @@ -34,16 +36,14 @@ public void confirmLegacyOverrideOrderResources() throws IOException, Configurat ConfigurationManager.loadPropertiesFromConfiguration( new PropertiesConfiguration("AbstractConfigurationBridgeTest_libA_legacy.properties")); - Assert.assertTrue(config.getBoolean("libA.legacy.loaded", false)); - Assert.assertEquals("libA", config.getString("lib.legacy.override", null)); - Assert.assertTrue(config.getBoolean("libA.legacy.loaded")); + assertTrue(config.getBoolean("libA.legacy.loaded", false)); + assertEquals("libA", config.getString("lib.legacy.override", null)); + assertTrue(config.getBoolean("libA.legacy.loaded")); ConfigurationManager.loadPropertiesFromConfiguration( new PropertiesConfiguration("AbstractConfigurationBridgeTest_libB_legacy.properties")); - Assert.assertTrue(config.getBoolean("libB.legacy.loaded", false)); - Assert.assertEquals("libA", config.getString("lib.legacy.override", null)); - Assert.assertTrue(config.getBoolean("libB.legacy.loaded")); - + assertTrue(config.getBoolean("libB.legacy.loaded", false)); + assertEquals("libA", config.getString("lib.legacy.override", null)); + assertTrue(config.getBoolean("libB.legacy.loaded")); } - } diff --git a/archaius2-archaius1-bridge/src/test/java/com/netflix/archaius/bridge/ConfigToCommonsTest.java b/archaius2-archaius1-bridge/src/test/java/com/netflix/archaius/bridge/ConfigToCommonsTest.java index 0cd8082ac..82bf3153c 100644 --- a/archaius2-archaius1-bridge/src/test/java/com/netflix/archaius/bridge/ConfigToCommonsTest.java +++ b/archaius2-archaius1-bridge/src/test/java/com/netflix/archaius/bridge/ConfigToCommonsTest.java @@ -3,13 +3,17 @@ import java.util.NoSuchElementException; import org.apache.commons.configuration.PropertiesConfiguration; -import org.junit.Assert; -import org.junit.Test; import com.netflix.archaius.config.MapConfig; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; public class ConfigToCommonsTest { - private ConfigToCommonsAdapter config = new ConfigToCommonsAdapter(MapConfig.builder() + private final ConfigToCommonsAdapter config = new ConfigToCommonsAdapter(MapConfig.builder() .put("boolean", true) .put("string", "set") .put("interpolated", "${string}") @@ -18,32 +22,32 @@ public class ConfigToCommonsTest { @Test public void testIsEmptyAPI() { - Assert.assertFalse(config.isEmpty()); + assertFalse(config.isEmpty()); } @Test public void confirmStringWorks() { - Assert.assertEquals("set", config.getString("string")); + assertEquals("set", config.getString("string")); } @Test public void confirmInterpolationWorks() { - Assert.assertEquals("set", config.getString("interpolated")); + assertEquals("set", config.getString("interpolated")); } @Test public void configNonStringWorks() { - Assert.assertEquals(true, config.getBoolean("boolean")); + assertTrue(config.getBoolean("boolean")); } - @Test(expected=NoSuchElementException.class) + @Test public void configNonExistentKeyWorks() { - Assert.assertNull(config.getString("nonexistent", null)); + assertThrows(NoSuchElementException.class, () -> config.getString("nonexistent", null)); } - @Test(expected=UnsupportedOperationException.class) + @Test public void configIsImmutable() { - config.setProperty("foo", "bar"); + assertThrows(UnsupportedOperationException.class, () -> config.setProperty("foo", "bar")); } @Test diff --git a/archaius2-archaius1-bridge/src/test/java/com/netflix/archaius/bridge/DynamicPropertyTest.java b/archaius2-archaius1-bridge/src/test/java/com/netflix/archaius/bridge/DynamicPropertyTest.java index 5cceed944..4feaa2e2d 100644 --- a/archaius2-archaius1-bridge/src/test/java/com/netflix/archaius/bridge/DynamicPropertyTest.java +++ b/archaius2-archaius1-bridge/src/test/java/com/netflix/archaius/bridge/DynamicPropertyTest.java @@ -1,12 +1,6 @@ package com.netflix.archaius.bridge; import org.apache.commons.configuration.AbstractConfiguration; -import org.junit.After; -import org.junit.Assert; -import org.junit.Before; -import org.junit.Rule; -import org.junit.Test; -import org.junit.rules.TestName; import com.google.inject.Guice; import com.google.inject.Injector; @@ -22,36 +16,45 @@ import com.netflix.config.DynamicIntProperty; import com.netflix.config.DynamicPropertyFactory; import com.netflix.config.DynamicStringProperty; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInfo; + +import java.lang.reflect.Method; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; public class DynamicPropertyTest { - @Rule - public TestName testName = new TestName(); private Injector injector; - @Before + @BeforeEach public void before() { injector = Guice.createInjector(new ArchaiusModule(), new StaticArchaiusBridgeModule()); } - @After + @AfterEach public void after() { StaticArchaiusBridgeModule.resetStaticBridges(); } @Test - public void settingOnArchaius2UpdateArchaius1() { - Property a2prop = injector.getInstance(PropertyFactory.class).getProperty(testName.getMethodName()).asString("default"); - DynamicStringProperty a1prop = DynamicPropertyFactory.getInstance().getStringProperty(testName.getMethodName(), "default"); + public void settingOnArchaius2UpdateArchaius1(TestInfo testInfo) { + String methodName = testInfo.getTestMethod().map(Method::getName).orElse("unknown"); + Property a2prop = injector.getInstance(PropertyFactory.class).getProperty(methodName).asString("default"); + DynamicStringProperty a1prop = DynamicPropertyFactory.getInstance().getStringProperty(methodName, "default"); - Assert.assertEquals("default", a1prop.get()); - Assert.assertEquals("default", a2prop.get()); + assertEquals("default", a1prop.get()); + assertEquals("default", a2prop.get()); SettableConfig config = injector.getInstance(Key.get(SettableConfig.class, RuntimeLayer.class)); - config.setProperty(testName.getMethodName(), "newvalue"); - - Assert.assertEquals("newvalue", a2prop.get()); - Assert.assertEquals("newvalue", a1prop.get()); + config.setProperty(methodName, "newvalue"); + + assertEquals("newvalue", a2prop.get()); + assertEquals("newvalue", a1prop.get()); } @Test @@ -64,8 +67,8 @@ public void testNonStringDynamicProperty() { DynamicIntProperty prop = DynamicPropertyFactory.getInstance().getIntProperty("foo", 2); - Assert.assertEquals(123, (int)prop2.get()); - Assert.assertEquals(123, prop.get()); + assertEquals(123, (int)prop2.get()); + assertEquals(123, prop.get()); } @Test @@ -77,7 +80,7 @@ public void testInterpolation() { DynamicStringProperty prop = DynamicPropertyFactory.getInstance().getStringProperty("foo", "default"); - Assert.assertEquals("value", prop.get()); + assertEquals("value", prop.get()); } @@ -86,12 +89,12 @@ public void testPropertyDeletion() { AbstractConfiguration config1 = ConfigurationManager.getConfigInstance(); Config config2 = injector.getInstance(Config.class); config1.setProperty("libA.loaded", "true"); - Assert.assertTrue(config1.getBoolean("libA.loaded", false)); - Assert.assertTrue(config2.getBoolean("libA.loaded", false)); + assertTrue(config1.getBoolean("libA.loaded", false)); + assertTrue(config2.getBoolean("libA.loaded", false)); config1.clearProperty("libA.loaded"); - Assert.assertFalse(config1.getBoolean("libA.loaded", false)); - Assert.assertFalse(config2.getBoolean("libA.loaded", false)); + assertFalse(config1.getBoolean("libA.loaded", false)); + assertFalse(config2.getBoolean("libA.loaded", false)); } } diff --git a/archaius2-archaius1-bridge/src/test/java/com/netflix/archaius/bridge/StaticBridgeAddConfigurationTest.java b/archaius2-archaius1-bridge/src/test/java/com/netflix/archaius/bridge/StaticBridgeAddConfigurationTest.java index 0792e485a..f40a69061 100644 --- a/archaius2-archaius1-bridge/src/test/java/com/netflix/archaius/bridge/StaticBridgeAddConfigurationTest.java +++ b/archaius2-archaius1-bridge/src/test/java/com/netflix/archaius/bridge/StaticBridgeAddConfigurationTest.java @@ -2,7 +2,7 @@ import org.apache.commons.configuration.event.ConfigurationEvent; import org.apache.commons.configuration.event.ConfigurationListener; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.mockito.Mockito; import com.google.inject.AbstractModule; diff --git a/archaius2-core/src/test/java/com/netflix/archaius/ConfigManagerTest.java b/archaius2-core/src/test/java/com/netflix/archaius/ConfigManagerTest.java index 6297b275c..941d3b3b0 100644 --- a/archaius2-core/src/test/java/com/netflix/archaius/ConfigManagerTest.java +++ b/archaius2-core/src/test/java/com/netflix/archaius/ConfigManagerTest.java @@ -18,13 +18,13 @@ import com.netflix.archaius.api.Property; import com.netflix.archaius.api.PropertyFactory; import com.netflix.archaius.config.DefaultCompositeConfig; -import org.junit.Test; import com.netflix.archaius.config.MapConfig; import com.netflix.archaius.api.config.CompositeConfig; import com.netflix.archaius.config.DefaultSettableConfig; import com.netflix.archaius.api.exceptions.ConfigException; import com.netflix.archaius.property.DefaultPropertyListener; +import org.junit.jupiter.api.Test; public class ConfigManagerTest { @Test diff --git a/archaius2-core/src/test/java/com/netflix/archaius/CustomDecoderTest.java b/archaius2-core/src/test/java/com/netflix/archaius/CustomDecoderTest.java index 5f50af8d2..1d091a1ad 100644 --- a/archaius2-core/src/test/java/com/netflix/archaius/CustomDecoderTest.java +++ b/archaius2-core/src/test/java/com/netflix/archaius/CustomDecoderTest.java @@ -1,13 +1,14 @@ package com.netflix.archaius; import com.netflix.archaius.api.TypeConverter; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Test; import java.lang.reflect.Type; import java.util.Collections; import java.util.Optional; +import static org.junit.jupiter.api.Assertions.assertEquals; + public class CustomDecoderTest { @Test @@ -23,11 +24,11 @@ public void testCustomTypeConverters() { return Optional.empty(); }; CustomDecoder decoder = CustomDecoder.create(Collections.singletonList(factory)); - Assert.assertEquals("FOO", decoder.decode((Type) CharSequence.class, "foo")); - Assert.assertEquals("FOO", decoder.decode((Type) String.class, "foo")); + assertEquals("FOO", decoder.decode((Type) CharSequence.class, "foo")); + assertEquals("FOO", decoder.decode((Type) String.class, "foo")); // default is overridden - Assert.assertEquals(Long.valueOf(6), decoder.decode((Type) Long.class, "3")); + assertEquals(Long.valueOf(6), decoder.decode((Type) Long.class, "3")); // default converter is used - Assert.assertEquals(Integer.valueOf(3), decoder.decode((Type) Integer.class, "3")); + assertEquals(Integer.valueOf(3), decoder.decode((Type) Integer.class, "3")); } } diff --git a/archaius2-core/src/test/java/com/netflix/archaius/DefaultConfigLoaderTest.java b/archaius2-core/src/test/java/com/netflix/archaius/DefaultConfigLoaderTest.java index fc28aabb2..146b12704 100644 --- a/archaius2-core/src/test/java/com/netflix/archaius/DefaultConfigLoaderTest.java +++ b/archaius2-core/src/test/java/com/netflix/archaius/DefaultConfigLoaderTest.java @@ -9,14 +9,14 @@ import com.netflix.archaius.config.DefaultCompositeConfig; import com.netflix.archaius.config.MapConfig; import com.netflix.archaius.readers.PropertiesConfigReader; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Test; import java.util.HashSet; -import java.util.Iterator; import java.util.Properties; import java.util.Set; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.Mockito.*; /** @@ -54,7 +54,7 @@ public void testBuildWithAllOptions() throws ConfigException { .build(); application.replaceConfig("application", loader.newLoader().load("application")); - Assert.assertTrue(config.getBoolean("application.loaded")); + assertTrue(config.getBoolean("application.loaded")); } @Test @@ -62,7 +62,7 @@ public void testDefaultLoaderBehavior() throws ConfigException { CompositeConfig applicationConfig = DefaultConfigLoader.builder().build().newLoader().load("application"); Config applicationProdConfig = DefaultConfigLoader.builder().build().newLoader().load("application-prod"); applicationConfig.addConfig("prod", applicationProdConfig); - Assert.assertEquals(applicationConfig.getString("application.list2"), "a,b"); - Assert.assertEquals(applicationConfig.getBoolean("application-prod.loaded"), true); + assertEquals("a,b", applicationConfig.getString("application.list2")); + assertTrue(applicationConfig.getBoolean("application-prod.loaded")); } } diff --git a/archaius2-core/src/test/java/com/netflix/archaius/DefaultDecoderTest.java b/archaius2-core/src/test/java/com/netflix/archaius/DefaultDecoderTest.java index 4e0988819..7ea5903ca 100644 --- a/archaius2-core/src/test/java/com/netflix/archaius/DefaultDecoderTest.java +++ b/archaius2-core/src/test/java/com/netflix/archaius/DefaultDecoderTest.java @@ -49,8 +49,12 @@ import com.netflix.archaius.converters.EnumTypeConverterFactory; import org.apache.commons.codec.DecoderException; import org.apache.commons.codec.binary.Hex; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; public class DefaultDecoderTest { @@ -84,98 +88,98 @@ public void testJavaNumbers() { DefaultDecoder decoder = DefaultDecoder.INSTANCE; boolean flag = decoder.decode(boolean.class, "true"); - Assert.assertTrue(flag); - int int_value = decoder.decode(int.class, "123"); - Assert.assertEquals(123, int_value); - - Assert.assertEquals(Byte.valueOf(Byte.MAX_VALUE), decoder.decode(Byte.class, String.valueOf(Byte.MAX_VALUE))); - Assert.assertEquals(Short.valueOf(Short.MAX_VALUE), decoder.decode(Short.class, String.valueOf(Short.MAX_VALUE))); - Assert.assertEquals(Long.valueOf(Long.MAX_VALUE), decoder.decode(Long.class, String.valueOf(Long.MAX_VALUE))); - Assert.assertEquals(Integer.valueOf(Integer.MAX_VALUE), decoder.decode(Integer.class, String.valueOf(Integer.MAX_VALUE))); - Assert.assertEquals(Float.valueOf(Float.MAX_VALUE), decoder.decode(Float.class, String.valueOf(Float.MAX_VALUE))); - Assert.assertEquals(Double.valueOf(Double.MAX_VALUE), decoder.decode(Double.class, String.valueOf(Double.MAX_VALUE))); - Assert.assertEquals(BigInteger.valueOf(Long.MAX_VALUE), decoder.decode(BigInteger.class, String.valueOf(Long.MAX_VALUE))); - Assert.assertEquals(BigDecimal.valueOf(Double.MAX_VALUE), decoder.decode(BigDecimal.class, String.valueOf(Double.MAX_VALUE))); - Assert.assertEquals(Integer.MAX_VALUE, decoder.decode(AtomicInteger.class, String.valueOf(Integer.MAX_VALUE)).get()); - Assert.assertEquals(Long.MAX_VALUE, decoder.decode(AtomicLong.class, String.valueOf(Long.MAX_VALUE)).get()); + assertTrue(flag); + int intValue = decoder.decode(int.class, "123"); + assertEquals(123, intValue); + + assertEquals(Byte.valueOf(Byte.MAX_VALUE), decoder.decode(Byte.class, String.valueOf(Byte.MAX_VALUE))); + assertEquals(Short.valueOf(Short.MAX_VALUE), decoder.decode(Short.class, String.valueOf(Short.MAX_VALUE))); + assertEquals(Long.valueOf(Long.MAX_VALUE), decoder.decode(Long.class, String.valueOf(Long.MAX_VALUE))); + assertEquals(Integer.valueOf(Integer.MAX_VALUE), decoder.decode(Integer.class, String.valueOf(Integer.MAX_VALUE))); + assertEquals(Float.valueOf(Float.MAX_VALUE), decoder.decode(Float.class, String.valueOf(Float.MAX_VALUE))); + assertEquals(Double.valueOf(Double.MAX_VALUE), decoder.decode(Double.class, String.valueOf(Double.MAX_VALUE))); + assertEquals(BigInteger.valueOf(Long.MAX_VALUE), decoder.decode(BigInteger.class, String.valueOf(Long.MAX_VALUE))); + assertEquals(BigDecimal.valueOf(Double.MAX_VALUE), decoder.decode(BigDecimal.class, String.valueOf(Double.MAX_VALUE))); + assertEquals(Integer.MAX_VALUE, decoder.decode(AtomicInteger.class, String.valueOf(Integer.MAX_VALUE)).get()); + assertEquals(Long.MAX_VALUE, decoder.decode(AtomicLong.class, String.valueOf(Long.MAX_VALUE)).get()); } @Test public void testJavaDateTime() { DefaultDecoder decoder = DefaultDecoder.INSTANCE; - Assert.assertEquals(Duration.parse("PT20M30S"), decoder.decode(Duration.class, "PT20M30S")); - Assert.assertEquals(Period.of(1, 2, 25), decoder.decode(Period.class, "P1Y2M3W4D")); - Assert.assertEquals(OffsetDateTime.parse("2016-08-03T10:15:30+07:00"), decoder.decode(OffsetDateTime.class, "2016-08-03T10:15:30+07:00")); - Assert.assertEquals(OffsetTime.parse("10:15:30+18:00"), decoder.decode(OffsetTime.class, "10:15:30+18:00")); - Assert.assertEquals(ZonedDateTime.parse("2016-08-03T10:15:30+01:00[Europe/Paris]"), decoder.decode(ZonedDateTime.class, "2016-08-03T10:15:30+01:00[Europe/Paris]")); - Assert.assertEquals(LocalDateTime.parse("2016-08-03T10:15:30"), decoder.decode(LocalDateTime.class, "2016-08-03T10:15:30")); - Assert.assertEquals(LocalDate.parse("2016-08-03"), decoder.decode(LocalDate.class, "2016-08-03")); - Assert.assertEquals(LocalTime.parse("10:15:30"), decoder.decode(LocalTime.class, "10:15:30")); - Assert.assertEquals(Instant.from(OffsetDateTime.parse("2016-08-03T10:15:30+07:00")), decoder.decode(Instant.class, "2016-08-03T10:15:30+07:00")); + assertEquals(Duration.parse("PT20M30S"), decoder.decode(Duration.class, "PT20M30S")); + assertEquals(Period.of(1, 2, 25), decoder.decode(Period.class, "P1Y2M3W4D")); + assertEquals(OffsetDateTime.parse("2016-08-03T10:15:30+07:00"), decoder.decode(OffsetDateTime.class, "2016-08-03T10:15:30+07:00")); + assertEquals(OffsetTime.parse("10:15:30+18:00"), decoder.decode(OffsetTime.class, "10:15:30+18:00")); + assertEquals(ZonedDateTime.parse("2016-08-03T10:15:30+01:00[Europe/Paris]"), decoder.decode(ZonedDateTime.class, "2016-08-03T10:15:30+01:00[Europe/Paris]")); + assertEquals(LocalDateTime.parse("2016-08-03T10:15:30"), decoder.decode(LocalDateTime.class, "2016-08-03T10:15:30")); + assertEquals(LocalDate.parse("2016-08-03"), decoder.decode(LocalDate.class, "2016-08-03")); + assertEquals(LocalTime.parse("10:15:30"), decoder.decode(LocalTime.class, "10:15:30")); + assertEquals(Instant.from(OffsetDateTime.parse("2016-08-03T10:15:30+07:00")), decoder.decode(Instant.class, "2016-08-03T10:15:30+07:00")); Date newDate = new Date(); - Assert.assertEquals(newDate, decoder.decode(Date.class, String.valueOf(newDate.getTime()))); + assertEquals(newDate, decoder.decode(Date.class, String.valueOf(newDate.getTime()))); } @Test public void testJavaMiscellaneous() throws DecoderException { DefaultDecoder decoder = DefaultDecoder.INSTANCE; - Assert.assertEquals(Currency.getInstance("USD"), decoder.decode(Currency.class, "USD")); - Assert.assertEquals(BitSet.valueOf(Hex.decodeHex("DEADBEEF00DEADBEEF")), decoder.decode(BitSet.class, "DEADBEEF00DEADBEEF")); - Assert.assertEquals("testString", decoder.decode(String.class, "testString")); - Assert.assertEquals(URI.create("https://netflix.com"), decoder.decode(URI.class, "https://netflix.com")); - Assert.assertEquals(Locale.ENGLISH, decoder.decode(Locale.class, "en")); + assertEquals(Currency.getInstance("USD"), decoder.decode(Currency.class, "USD")); + assertEquals(BitSet.valueOf(Hex.decodeHex("DEADBEEF00DEADBEEF")), decoder.decode(BitSet.class, "DEADBEEF00DEADBEEF")); + assertEquals("testString", decoder.decode(String.class, "testString")); + assertEquals(URI.create("https://netflix.com"), decoder.decode(URI.class, "https://netflix.com")); + assertEquals(Locale.ENGLISH, decoder.decode(Locale.class, "en")); } @Test public void testCollections() { Decoder decoder = DefaultDecoder.INSTANCE; - Assert.assertEquals(Collections.emptyList(), decoder.decode(listOfIntegerType, "")); - Assert.assertEquals(Arrays.asList(1, 2, 3, 4, 5, 6), decoder.decode(listOfIntegerType, "1,2,3,4,5,6")); - Assert.assertEquals(Arrays.asList(1L, 2L, 3L, 4L, 5L, 6L), decoder.decode(collectionOfLongType, "1,2,3,4,5,6")); - Assert.assertEquals(Collections.singleton(2L), decoder.decode(setOfLongType, "2,2,2,2")); - Assert.assertEquals(Collections.emptyMap(), decoder.decode(mapofStringToIntegerType, "")); - Assert.assertEquals(Collections.singletonMap("key", 12345), decoder.decode(mapofStringToIntegerType, "key=12345")); + assertEquals(Collections.emptyList(), decoder.decode(listOfIntegerType, "")); + assertEquals(Arrays.asList(1, 2, 3, 4, 5, 6), decoder.decode(listOfIntegerType, "1,2,3,4,5,6")); + assertEquals(Arrays.asList(1L, 2L, 3L, 4L, 5L, 6L), decoder.decode(collectionOfLongType, "1,2,3,4,5,6")); + assertEquals(Collections.singleton(2L), decoder.decode(setOfLongType, "2,2,2,2")); + assertEquals(Collections.emptyMap(), decoder.decode(mapofStringToIntegerType, "")); + assertEquals(Collections.singletonMap("key", 12345), decoder.decode(mapofStringToIntegerType, "key=12345")); } @Test public void testArrays() { DefaultDecoder decoder = DefaultDecoder.INSTANCE; - Assert.assertArrayEquals(new String[] { "foo", "bar", "baz" }, decoder.decode(String[].class, "foo,bar,baz")); - Assert.assertArrayEquals(new Integer[] {1, 2, 3, 4, 5}, decoder.decode(Integer[].class, "1,2,3,4,5")); - Assert.assertArrayEquals(new int[] {1, 2, 3, 4, 5}, decoder.decode(int[].class, "1,2,3,4,5")); - Assert.assertArrayEquals(new Integer[0], decoder.decode(Integer[].class, "")); - Assert.assertArrayEquals(new int[0], decoder.decode(int[].class, "")); - Assert.assertArrayEquals(new Long[] {1L, 2L, 3L, 4L, 5L}, decoder.decode(Long[].class, "1,2,3,4,5")); - Assert.assertArrayEquals(new long[] {1L, 2L, 3L, 4L, 5L}, decoder.decode(long[].class, "1,2,3,4,5")); - Assert.assertArrayEquals(new Long[0], decoder.decode(Long[].class, "")); - Assert.assertArrayEquals(new long[0], decoder.decode(long[].class, "")); + assertArrayEquals(new String[] { "foo", "bar", "baz" }, decoder.decode(String[].class, "foo,bar,baz")); + assertArrayEquals(new Integer[] {1, 2, 3, 4, 5}, decoder.decode(Integer[].class, "1,2,3,4,5")); + assertArrayEquals(new int[] {1, 2, 3, 4, 5}, decoder.decode(int[].class, "1,2,3,4,5")); + assertArrayEquals(new Integer[0], decoder.decode(Integer[].class, "")); + assertArrayEquals(new int[0], decoder.decode(int[].class, "")); + assertArrayEquals(new Long[] {1L, 2L, 3L, 4L, 5L}, decoder.decode(Long[].class, "1,2,3,4,5")); + assertArrayEquals(new long[] {1L, 2L, 3L, 4L, 5L}, decoder.decode(long[].class, "1,2,3,4,5")); + assertArrayEquals(new Long[0], decoder.decode(Long[].class, "")); + assertArrayEquals(new long[0], decoder.decode(long[].class, "")); } enum TestEnumType { FOO, BAR, BAZ } @Test public void testEnum() { Decoder decoder = DefaultDecoder.INSTANCE; - Assert.assertEquals(TestEnumType.FOO, decoder.decode((Type) TestEnumType.class, "FOO")); + assertEquals(TestEnumType.FOO, decoder.decode((Type) TestEnumType.class, "FOO")); } @Test public void testArrayConverterIgnoresParameterizedType() { Optional> maybeConverter = ArrayTypeConverterFactory.INSTANCE.get(listOfIntegerType, DefaultDecoder.INSTANCE); - Assert.assertFalse(maybeConverter.isPresent()); + assertFalse(maybeConverter.isPresent()); } @Test public void testEnumConverterIgnoresParameterizedType() { Optional> maybeConverter = EnumTypeConverterFactory.INSTANCE.get(listOfIntegerType, DefaultDecoder.INSTANCE); - Assert.assertFalse(maybeConverter.isPresent()); + assertFalse(maybeConverter.isPresent()); } @Test public void testTypeConverterRegistry() { - Assert.assertTrue(DefaultDecoder.INSTANCE.get(Instant.class).isPresent()); + assertTrue(DefaultDecoder.INSTANCE.get(Instant.class).isPresent()); class Foo {} - Assert.assertFalse(DefaultDecoder.INSTANCE.get(Foo.class).isPresent()); + assertFalse(DefaultDecoder.INSTANCE.get(Foo.class).isPresent()); } } diff --git a/archaius2-core/src/test/java/com/netflix/archaius/DefaultPropertyContainerTest.java b/archaius2-core/src/test/java/com/netflix/archaius/DefaultPropertyContainerTest.java index 513c45a8a..03f522f7f 100644 --- a/archaius2-core/src/test/java/com/netflix/archaius/DefaultPropertyContainerTest.java +++ b/archaius2-core/src/test/java/com/netflix/archaius/DefaultPropertyContainerTest.java @@ -1,11 +1,11 @@ package com.netflix.archaius; -import org.junit.Assert; -import org.junit.Test; - import com.netflix.archaius.api.Property; import com.netflix.archaius.api.config.SettableConfig; import com.netflix.archaius.config.DefaultSettableConfig; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; public class DefaultPropertyContainerTest { @Test @@ -14,9 +14,9 @@ public void basicTest() { DefaultPropertyFactory factory = DefaultPropertyFactory.from(config); Property prop = factory.getProperty("foo").asString("default"); - Assert.assertEquals("default", prop.get()); + assertEquals("default", prop.get()); config.setProperty("foo", "value1"); - Assert.assertEquals("value1", prop.get()); - Assert.assertEquals("value1", prop.get()); + assertEquals("value1", prop.get()); + assertEquals("value1", prop.get()); } } diff --git a/archaius2-core/src/test/java/com/netflix/archaius/ProxyFactoryTest.java b/archaius2-core/src/test/java/com/netflix/archaius/ProxyFactoryTest.java index 392d7b036..d867da307 100644 --- a/archaius2-core/src/test/java/com/netflix/archaius/ProxyFactoryTest.java +++ b/archaius2-core/src/test/java/com/netflix/archaius/ProxyFactoryTest.java @@ -3,6 +3,11 @@ import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.nullValue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; import java.util.ArrayList; import java.util.Arrays; @@ -20,9 +25,6 @@ import com.netflix.archaius.api.Decoder; import com.netflix.archaius.api.TypeConverter; import com.netflix.archaius.config.MapConfig; -import org.junit.Assert; -import org.junit.Ignore; -import org.junit.Test; import com.netflix.archaius.api.Config; import com.netflix.archaius.api.PropertyFactory; @@ -32,6 +34,8 @@ import com.netflix.archaius.api.config.SettableConfig; import com.netflix.archaius.config.DefaultSettableConfig; import com.netflix.archaius.config.EmptyConfig; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; @SuppressWarnings("deprecation") public class ProxyFactoryTest { @@ -209,7 +213,7 @@ public void testAllPropertiesSet() { try { a.getRequiredValue(); - Assert.fail("should have failed with no value for requiredValue"); + fail("should have failed with no value for requiredValue"); } catch (Exception expected) { } @@ -231,9 +235,9 @@ public void testWithArguments() { ConfigProxyFactory proxy = new ConfigProxyFactory(config, config.getDecoder(), factory); WithArguments withArgs = proxy.newProxy(WithArguments.class); - Assert.assertEquals("value1", withArgs.getProperty("a", 1)); - Assert.assertEquals("value2", withArgs.getProperty("b", 2)); - Assert.assertEquals("default", withArgs.getProperty("a", 2)); + assertEquals("value1", withArgs.getProperty("a", 1)); + assertEquals("value2", withArgs.getProperty("b", 2)); + assertEquals("default", withArgs.getProperty("a", 2)); } @Configuration(prefix = "foo.bar") @@ -258,12 +262,12 @@ public void testWithArgumentsAndPrefix() { ConfigProxyFactory proxy = new ConfigProxyFactory(config, config.getDecoder(), factory); WithArgumentsAndPrefix withArgs = proxy.newProxy(WithArgumentsAndPrefix.class); - Assert.assertEquals("value1", withArgs.getPropertyWithPrefix("a", 1)); - Assert.assertEquals("value1", withArgs.getPropertyWithoutPrefix("a", 1)); - Assert.assertEquals("value2", withArgs.getPropertyWithPrefix("b", 2)); - Assert.assertEquals("value2", withArgs.getPropertyWithoutPrefix("b", 2)); - Assert.assertEquals("default", withArgs.getPropertyWithPrefix("a", 2)); - Assert.assertEquals("default", withArgs.getPropertyWithoutPrefix("a", 2)); + assertEquals("value1", withArgs.getPropertyWithPrefix("a", 1)); + assertEquals("value1", withArgs.getPropertyWithoutPrefix("a", 1)); + assertEquals("value2", withArgs.getPropertyWithPrefix("b", 2)); + assertEquals("value2", withArgs.getPropertyWithoutPrefix("b", 2)); + assertEquals("default", withArgs.getPropertyWithPrefix("a", 2)); + assertEquals("default", withArgs.getPropertyWithoutPrefix("a", 2)); } @@ -291,12 +295,12 @@ public void testWithArgumentsAndDefaultMethod() { ConfigProxyFactory proxy = new ConfigProxyFactory(config, config.getDecoder(), factory); WithArgumentsAndDefaultMethod withArgsAndDefM = proxy.newProxy(WithArgumentsAndDefaultMethod.class); - Assert.assertEquals("value1", withArgsAndDefM.getPropertyWith2Placeholders("a", 1)); - Assert.assertEquals("value2", withArgsAndDefM.getPropertyWith2Placeholders("b", 2)); - Assert.assertEquals("defaultFor2", withArgsAndDefM.getPropertyWith2Placeholders("a", 2)); + assertEquals("value1", withArgsAndDefM.getPropertyWith2Placeholders("a", 1)); + assertEquals("value2", withArgsAndDefM.getPropertyWith2Placeholders("b", 2)); + assertEquals("defaultFor2", withArgsAndDefM.getPropertyWith2Placeholders("a", 2)); - Assert.assertEquals("value_c", withArgsAndDefM.getPropertyWith1Placeholder("c")); - Assert.assertEquals("defaultFor1", withArgsAndDefM.getPropertyWith1Placeholder("q")); + assertEquals("value_c", withArgsAndDefM.getPropertyWith1Placeholder("c")); + assertEquals("defaultFor1", withArgsAndDefM.getPropertyWith1Placeholder("q")); } public interface ConfigWithMaps { @@ -320,15 +324,15 @@ public void testWithLongMap() { long sub1 = withMaps.getStringToLongMap().get("a"); long sub2 = withMaps.getStringToLongMap().get("b"); - Assert.assertEquals(123, sub1); - Assert.assertEquals(456, sub2); + assertEquals(123, sub1); + assertEquals(456, sub2); config.setProperty("map", "a=123,b=789"); sub2 = withMaps.getStringToLongMap().get("b"); - Assert.assertEquals(789, sub2); + assertEquals(789, sub2); - Assert.assertEquals("a", withMaps.getLongToStringMap().get(1L)); - Assert.assertEquals("b", withMaps.getLongToStringMap().get(2L)); + assertEquals("a", withMaps.getLongToStringMap().get(1L)); + assertEquals("b", withMaps.getLongToStringMap().get(2L)); } @Test @@ -339,11 +343,11 @@ public void testWithLongMapDefaultValue() { ConfigProxyFactory proxy = new ConfigProxyFactory(config, config.getDecoder(), factory); ConfigWithMaps withArgs = proxy.newProxy(ConfigWithMaps.class); - Assert.assertEquals(Collections.singletonMap("default", 0L), withArgs.getStringToLongMap()); + assertEquals(Collections.singletonMap("default", 0L), withArgs.getStringToLongMap()); config.setProperty("map", "foo=123"); - Assert.assertEquals(Collections.singletonMap("foo", 123L), withArgs.getStringToLongMap()); + assertEquals(Collections.singletonMap("foo", 123L), withArgs.getStringToLongMap()); } public interface ConfigWithCollections { @@ -368,13 +372,13 @@ public void testCollections() { ConfigProxyFactory proxy = new ConfigProxyFactory(config, config.getDecoder(), factory); ConfigWithCollections withCollections = proxy.newProxy(ConfigWithCollections.class); - Assert.assertEquals(Arrays.asList(5,4,3,2,1), new ArrayList<>(withCollections.getLinkedList())); - Assert.assertEquals(Arrays.asList(5,4,3,2,1), new ArrayList<>(withCollections.getList())); - Assert.assertEquals(Arrays.asList(1,2,3,5,4), new ArrayList<>(withCollections.getSet())); - Assert.assertEquals(Arrays.asList(1,2,3,4,5), new ArrayList<>(withCollections.getSortedSet())); + assertEquals(Arrays.asList(5,4,3,2,1), new ArrayList<>(withCollections.getLinkedList())); + assertEquals(Arrays.asList(5,4,3,2,1), new ArrayList<>(withCollections.getList())); + assertEquals(Arrays.asList(1,2,3,5,4), new ArrayList<>(withCollections.getSet())); + assertEquals(Arrays.asList(1,2,3,4,5), new ArrayList<>(withCollections.getSortedSet())); config.setProperty("list", "6,7,8,9,10"); - Assert.assertEquals(Arrays.asList(6,7,8,9,10), new ArrayList<>(withCollections.getList())); + assertEquals(Arrays.asList(6,7,8,9,10), new ArrayList<>(withCollections.getList())); } @Test @@ -389,13 +393,13 @@ public void testCollectionsImmutable() { ConfigProxyFactory proxy = new ConfigProxyFactory(config, config.getDecoder(), factory); ConfigWithCollections withCollections = proxy.newProxy(ConfigWithCollections.class, "", true); - Assert.assertEquals(Arrays.asList(5,4,3,2,1), new ArrayList<>(withCollections.getLinkedList())); - Assert.assertEquals(Arrays.asList(5,4,3,2,1), new ArrayList<>(withCollections.getList())); - Assert.assertEquals(Arrays.asList(1,2,3,5,4), new ArrayList<>(withCollections.getSet())); - Assert.assertEquals(Arrays.asList(1,2,3,4,5), new ArrayList<>(withCollections.getSortedSet())); + assertEquals(Arrays.asList(5,4,3,2,1), new ArrayList<>(withCollections.getLinkedList())); + assertEquals(Arrays.asList(5,4,3,2,1), new ArrayList<>(withCollections.getList())); + assertEquals(Arrays.asList(1,2,3,5,4), new ArrayList<>(withCollections.getSet())); + assertEquals(Arrays.asList(1,2,3,4,5), new ArrayList<>(withCollections.getSortedSet())); config.setProperty("list", "4,7,8,9,10"); - Assert.assertEquals(Arrays.asList(5,4,3,2,1), new ArrayList<>(withCollections.getList())); + assertEquals(Arrays.asList(5,4,3,2,1), new ArrayList<>(withCollections.getList())); } @Test @@ -410,10 +414,10 @@ public void emptyNonStringValuesIgnoredInCollections() { ConfigProxyFactory proxy = new ConfigProxyFactory(config, config.getDecoder(), factory); ConfigWithCollections withCollections = proxy.newProxy(ConfigWithCollections.class); - Assert.assertEquals(Arrays.asList(4,2,1), new ArrayList<>(withCollections.getLinkedList())); - Assert.assertEquals(Arrays.asList(4,2,1), new ArrayList<>(withCollections.getList())); - Assert.assertEquals(Arrays.asList(2,5,4), new ArrayList<>(withCollections.getSet())); - Assert.assertEquals(Arrays.asList(1,2,4), new ArrayList<>(withCollections.getSortedSet())); + assertEquals(Arrays.asList(4,2,1), new ArrayList<>(withCollections.getLinkedList())); + assertEquals(Arrays.asList(4,2,1), new ArrayList<>(withCollections.getList())); + assertEquals(Arrays.asList(2,5,4), new ArrayList<>(withCollections.getSet())); + assertEquals(Arrays.asList(1,2,4), new ArrayList<>(withCollections.getSortedSet())); } public interface ConfigWithStringCollections { @@ -438,10 +442,10 @@ public void emptyStringValuesAreAddedToCollection() { ConfigProxyFactory proxy = new ConfigProxyFactory(config, config.getDecoder(), factory); ConfigWithStringCollections withCollections = proxy.newProxy(ConfigWithStringCollections.class); - Assert.assertEquals(Arrays.asList("", "4","", "2","1"), new ArrayList<>(withCollections.getLinkedList())); - Assert.assertEquals(Arrays.asList("", "4","", "2","1"), new ArrayList<>(withCollections.getList())); - Assert.assertEquals(Arrays.asList("" ,"2","5","4"), new ArrayList<>(withCollections.getSet())); - Assert.assertEquals(Arrays.asList("", "1","2","4"), new ArrayList<>(withCollections.getSortedSet())); + assertEquals(Arrays.asList("", "4","", "2","1"), new ArrayList<>(withCollections.getLinkedList())); + assertEquals(Arrays.asList("", "4","", "2","1"), new ArrayList<>(withCollections.getList())); + assertEquals(Arrays.asList("" ,"2","5","4"), new ArrayList<>(withCollections.getSet())); + assertEquals(Arrays.asList("", "1","2","4"), new ArrayList<>(withCollections.getSortedSet())); } @Test @@ -452,10 +456,10 @@ public void collectionsReturnEmptySetsByDefault() { ConfigProxyFactory proxy = new ConfigProxyFactory(config, config.getDecoder(), factory); ConfigWithStringCollections withCollections = proxy.newProxy(ConfigWithStringCollections.class); - Assert.assertTrue(withCollections.getLinkedList().isEmpty()); - Assert.assertTrue(withCollections.getList().isEmpty()); - Assert.assertTrue(withCollections.getSet().isEmpty()); - Assert.assertTrue(withCollections.getSortedSet().isEmpty()); + assertTrue(withCollections.getLinkedList().isEmpty()); + assertTrue(withCollections.getList().isEmpty()); + assertTrue(withCollections.getSet().isEmpty()); + assertTrue(withCollections.getSortedSet().isEmpty()); } @Test @@ -467,10 +471,10 @@ public void testCollectionsWithoutValue() { ConfigWithCollections withCollections = proxy.newProxy(ConfigWithCollections.class); System.out.println(withCollections.toString()); - Assert.assertTrue(withCollections.getLinkedList().isEmpty()); - Assert.assertTrue(withCollections.getList().isEmpty()); - Assert.assertTrue(withCollections.getSet().isEmpty()); - Assert.assertTrue(withCollections.getSortedSet().isEmpty()); + assertTrue(withCollections.getLinkedList().isEmpty()); + assertTrue(withCollections.getList().isEmpty()); + assertTrue(withCollections.getSet().isEmpty()); + assertTrue(withCollections.getSortedSet().isEmpty()); } @SuppressWarnings("unused") @@ -479,13 +483,13 @@ public interface ConfigWithCollectionsWithDefaultValueAnnotation { LinkedList getLinkedList(); } - @Test(expected=RuntimeException.class) + @Test public void testCollectionsWithDefaultValueAnnotation() { SettableConfig config = new DefaultSettableConfig(); PropertyFactory factory = DefaultPropertyFactory.from(config); ConfigProxyFactory proxy = new ConfigProxyFactory(config, config.getDecoder(), factory); - proxy.newProxy(ConfigWithCollectionsWithDefaultValueAnnotation.class); + assertThrows(RuntimeException.class, () -> proxy.newProxy(ConfigWithCollectionsWithDefaultValueAnnotation.class)); } public interface ConfigWithDefaultStringCollections { @@ -504,9 +508,9 @@ public void interfaceDefaultCollections() { ConfigProxyFactory proxy = new ConfigProxyFactory(config, config.getDecoder(), factory); ConfigWithDefaultStringCollections withCollections = proxy.newProxy(ConfigWithDefaultStringCollections.class); - Assert.assertEquals(Collections.singletonList("default"), new ArrayList<>(withCollections.getList())); - Assert.assertEquals(Collections.singletonList("default"), new ArrayList<>(withCollections.getSet())); - Assert.assertEquals(Collections.singletonList("default"), new ArrayList<>(withCollections.getSortedSet())); + assertEquals(Collections.singletonList("default"), new ArrayList<>(withCollections.getList())); + assertEquals(Collections.singletonList("default"), new ArrayList<>(withCollections.getSet())); + assertEquals(Collections.singletonList("default"), new ArrayList<>(withCollections.getSortedSet())); } @SuppressWarnings("UnusedReturnValue") @@ -514,14 +518,14 @@ public interface FailingError { default String getValue() { throw new IllegalStateException("error"); } } - @Test(expected=RuntimeException.class) + @Test public void interfaceWithBadDefault() { SettableConfig config = new DefaultSettableConfig(); PropertyFactory factory = DefaultPropertyFactory.from(config); ConfigProxyFactory proxy = new ConfigProxyFactory(config, config.getDecoder(), factory); FailingError c = proxy.newProxy(FailingError.class); - c.getValue(); + assertThrows(RuntimeException.class, c::getValue); } @Test @@ -532,11 +536,11 @@ public void testObjectMethods() { ConfigProxyFactory proxy = new ConfigProxyFactory(config, config.getDecoder(), factory); WithArguments withArgs = proxy.newProxy(WithArguments.class); - Assert.assertEquals("WithArguments[${0}.abc.${1}='default']", withArgs.toString()); + assertEquals("WithArguments[${0}.abc.${1}='default']", withArgs.toString()); //noinspection ObviousNullCheck - Assert.assertNotNull(withArgs.hashCode()); + assertNotNull(withArgs.hashCode()); //noinspection EqualsWithItself - Assert.assertEquals(withArgs, withArgs); + assertEquals(withArgs, withArgs); } @Test @@ -550,14 +554,14 @@ public void testObjectMethods_ClassWithArgumentsAndDefaultMethod() { // Printing 'null' here is a compromise. The default method in the interface is being called with a bad signature. // There's nothing the proxy could return here that isn't a lie, but at least this is a mostly harmless lie. // This test depends implicitly on the iteration order for HashMap, which could change on future Java releases. - Assert.assertEquals("WithArgumentsAndDefaultMethod[${0}.def='null',${0}.abc.${1}='null']", withArgs.toString()); + assertEquals("WithArgumentsAndDefaultMethod[${0}.def='null',${0}.abc.${1}='null']", withArgs.toString()); //noinspection ObviousNullCheck - Assert.assertNotNull(withArgs.hashCode()); + assertNotNull(withArgs.hashCode()); //noinspection EqualsWithItself - Assert.assertEquals(withArgs, withArgs); + assertEquals(withArgs, withArgs); } - @Ignore("Manual test. Output is just log entries, can't be verified by CI") + @Disabled("Manual test. Output is just log entries, can't be verified by CI") @Test public void testLogExcessiveUse() { SettableConfig config = new DefaultSettableConfig(); @@ -607,7 +611,7 @@ public void testNestedInterfaceWithCustomDecoder() { ConfigProxyFactory proxyFactory = new ConfigProxyFactory(config, config.getDecoder(), DefaultPropertyFactory.from(config)); ConfigWithNestedInterface proxy = proxyFactory.newProxy(ConfigWithNestedInterface.class); - Assert.assertEquals(5, proxy.intValue()); - Assert.assertEquals("BLAH", proxy.customValue().value()); + assertEquals(5, proxy.intValue()); + assertEquals("BLAH", proxy.customValue().value()); } } diff --git a/archaius2-core/src/test/java/com/netflix/archaius/config/AbstractConfigTest.java b/archaius2-core/src/test/java/com/netflix/archaius/config/AbstractConfigTest.java index ce84c1634..fcb897353 100644 --- a/archaius2-core/src/test/java/com/netflix/archaius/config/AbstractConfigTest.java +++ b/archaius2-core/src/test/java/com/netflix/archaius/config/AbstractConfigTest.java @@ -19,8 +19,10 @@ import java.util.Iterator; import java.util.function.BiConsumer; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; public class AbstractConfigTest { @@ -56,16 +58,16 @@ public void forEachProperty(BiConsumer consumer) { @Test public void testGet() throws Exception { - Assert.assertEquals("bar", config.get(String.class, "foo")); + assertEquals("bar", config.get(String.class, "foo")); } @Test public void getExistingProperty() { - Assert.assertEquals("bar", config.getProperty("foo").get()); + assertEquals("bar", config.getProperty("foo").get()); } @Test public void getNonExistentProperty() { - Assert.assertFalse(config.getProperty("non_existent").isPresent()); + assertFalse(config.getProperty("non_existent").isPresent()); } } diff --git a/archaius2-core/src/test/java/com/netflix/archaius/config/CompositeConfigTest.java b/archaius2-core/src/test/java/com/netflix/archaius/config/CompositeConfigTest.java index 161e876c3..0a76f3f20 100644 --- a/archaius2-core/src/test/java/com/netflix/archaius/config/CompositeConfigTest.java +++ b/archaius2-core/src/test/java/com/netflix/archaius/config/CompositeConfigTest.java @@ -30,16 +30,20 @@ import com.netflix.archaius.config.polling.PollingResponse; import com.netflix.archaius.instrumentation.AccessMonitorUtil; import com.netflix.archaius.api.PropertyDetails; -import org.junit.Assert; -import org.junit.Test; import com.netflix.archaius.DefaultConfigLoader; import com.netflix.archaius.cascade.ConcatCascadeStrategy; import com.netflix.archaius.api.exceptions.ConfigException; import com.netflix.archaius.visitor.PrintStreamVisitor; +import org.junit.jupiter.api.Test; import static com.netflix.archaius.TestUtils.set; import static com.netflix.archaius.TestUtils.size; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.spy; @@ -67,28 +71,27 @@ public void basicTest() throws ConfigException { .build(); application.replaceConfig("application", loader.newLoader().load("application")); - - Assert.assertTrue(config.getBoolean("application.loaded")); - Assert.assertTrue(config.getBoolean("application-prod.loaded", false)); - - Assert.assertFalse(config.getBoolean("libA.loaded", false)); - + + assertTrue(config.getBoolean("application.loaded")); + assertTrue(config.getBoolean("application-prod.loaded", false)); + + assertFalse(config.getBoolean("libA.loaded", false)); + libraries.replaceConfig("libA", loader.newLoader().load("libA")); libraries.accept(new PrintStreamVisitor()); - + config.accept(new PrintStreamVisitor()); - - Assert.assertTrue(config.getBoolean("libA.loaded")); - Assert.assertFalse(config.getBoolean("libB.loaded", false)); - Assert.assertEquals("libA", config.getString("libA.overrideA")); - + + assertTrue(config.getBoolean("libA.loaded")); + assertFalse(config.getBoolean("libB.loaded", false)); + assertEquals("libA", config.getString("libA.overrideA")); + libraries.replaceConfig("libB", loader.newLoader().load("libB")); - - System.out.println(config.toString()); - Assert.assertTrue(config.getBoolean("libA.loaded")); - Assert.assertTrue(config.getBoolean("libB.loaded")); - Assert.assertEquals("libA", config.getString("libA.overrideA")); - + + assertTrue(config.getBoolean("libA.loaded")); + assertTrue(config.getBoolean("libB.loaded")); + assertEquals("libA", config.getString("libA.overrideA")); + config.accept(new PrintStreamVisitor()); } @@ -113,53 +116,53 @@ public void basicReversedTest() throws ConfigException { application.replaceConfig("application", loader.newLoader().load("application")); - Assert.assertTrue(config.getBoolean("application.loaded")); - Assert.assertTrue(config.getBoolean("application-prod.loaded", false)); + assertTrue(config.getBoolean("application.loaded")); + assertTrue(config.getBoolean("application-prod.loaded", false)); - Assert.assertFalse(config.getBoolean("libA.loaded", false)); + assertFalse(config.getBoolean("libA.loaded", false)); libraries.replaceConfig("libA", loader.newLoader().load("libA")); libraries.accept(new PrintStreamVisitor()); config.accept(new PrintStreamVisitor()); - Assert.assertTrue(config.getBoolean("libA.loaded")); - Assert.assertFalse(config.getBoolean("libB.loaded", false)); - Assert.assertEquals("libA", config.getString("libA.overrideA")); - + assertTrue(config.getBoolean("libA.loaded")); + assertFalse(config.getBoolean("libB.loaded", false)); + assertEquals("libA", config.getString("libA.overrideA")); + libraries.replaceConfig("libB", loader.newLoader().load("libB")); - - System.out.println(config.toString()); - Assert.assertTrue(config.getBoolean("libA.loaded")); - Assert.assertTrue(config.getBoolean("libB.loaded")); - Assert.assertEquals("libB", config.getString("libA.overrideA")); + + assertTrue(config.getBoolean("libA.loaded")); + assertTrue(config.getBoolean("libB.loaded")); + assertEquals("libB", config.getString("libA.overrideA")); config.accept(new PrintStreamVisitor()); } - + + @SuppressWarnings("deprecation") @Test public void getKeysTest() throws ConfigException { com.netflix.archaius.api.config.CompositeConfig composite = new DefaultCompositeConfig(); composite.addConfig("a", EmptyConfig.INSTANCE); Iterator iter = composite.getKeys(); - Assert.assertFalse(iter.hasNext()); + assertFalse(iter.hasNext()); composite.addConfig("b", MapConfig.builder().put("b1", "A").put("b2", "B").build()); iter = composite.getKeys(); - Assert.assertEquals(set("b1", "b2"), set(iter)); + assertEquals(set("b1", "b2"), set(iter)); composite.addConfig("c", EmptyConfig.INSTANCE); iter = composite.getKeys(); - Assert.assertEquals(set("b1", "b2"), set(iter)); + assertEquals(set("b1", "b2"), set(iter)); composite.addConfig("d", MapConfig.builder().put("d1", "A").put("d2", "B").build()); composite.addConfig("e", MapConfig.builder().put("e1", "A").put("e2", "B").build()); iter = composite.getKeys(); - Assert.assertEquals(set("b1", "b2", "d1", "d2", "e1", "e2"), set(iter)); + assertEquals(set("b1", "b2", "d1", "d2", "e1", "e2"), set(iter)); } @Test @@ -170,10 +173,11 @@ public void testGetKeysIteratorRemoveThrows() throws ConfigException { composite.addConfig("d", MapConfig.builder().put("d1", "A").put("d2", "B").build()); composite.addConfig("e", MapConfig.builder().put("e1", "A").put("e2", "B").build()); + @SuppressWarnings("deprecation") Iterator keys = composite.getKeys(); - Assert.assertTrue(keys.hasNext()); + assertTrue(keys.hasNext()); keys.next(); - Assert.assertThrows(UnsupportedOperationException.class, keys::remove); + assertThrows(UnsupportedOperationException.class, keys::remove); } @Test @@ -185,8 +189,8 @@ public void testKeysIterable() throws ConfigException { Iterable keys = composite.keys(); - Assert.assertEquals(4, size(keys)); - Assert.assertEquals(set("d1", "d2", "e1", "e2"), set(keys)); + assertEquals(4, size(keys)); + assertEquals(set("d1", "d2", "e1", "e2"), set(keys)); } @Test @@ -196,8 +200,8 @@ public void testKeysIterableModificationThrows() throws ConfigException { composite.addConfig("d", MapConfig.builder().put("d1", "A").put("d2", "B").build()); composite.addConfig("e", MapConfig.builder().put("e1", "A").put("e2", "B").build()); - Assert.assertThrows(UnsupportedOperationException.class, composite.keys().iterator()::remove); - Assert.assertThrows(UnsupportedOperationException.class, ((Collection) composite.keys())::clear); + assertThrows(UnsupportedOperationException.class, composite.keys().iterator()::remove); + assertThrows(UnsupportedOperationException.class, ((Collection) composite.keys())::clear); } @Test @@ -211,7 +215,7 @@ public void unusedCompositeConfigIsGarbageCollected() throws ConfigException { // No more pointers to prefix means this should be garbage collected and any additional listeners on it config = null; System.gc(); - Assert.assertNull(weakReference.get()); + assertNull(weakReference.get()); } @Test @@ -220,9 +224,9 @@ public void instrumentationNotEnabled() throws Exception { composite.addConfig("polling", createPollingDynamicConfig("a1", "1", "b1", "2", null)); - Assert.assertFalse(composite.instrumentationEnabled()); - Assert.assertEquals(composite.getRawProperty("a1"), "1"); - Assert.assertEquals(composite.getRawProperty("b1"), "2"); + assertFalse(composite.instrumentationEnabled()); + assertEquals("1", composite.getRawProperty("a1")); + assertEquals("2", composite.getRawProperty("b1")); } @Test @@ -241,30 +245,30 @@ public void instrumentationPropagation() throws Exception { composite.addConfig("d", MapConfig.builder().put("c1", "4").put("d1", "5").build()); // Properties (a1: 1) and (b1: 2) are covered by the first polling config - Assert.assertEquals(composite.getRawProperty("a1"), "1"); + assertEquals("1", composite.getRawProperty("a1")); verify(accessMonitorUtil).registerUsage(eq(new PropertyDetails("a1", "a1", "1"))); - Assert.assertEquals(composite.getRawPropertyUninstrumented("a1"), "1"); + assertEquals("1", composite.getRawPropertyUninstrumented("a1")); verify(accessMonitorUtil, times(1)).registerUsage(any()); - Assert.assertEquals(composite.getRawProperty("b1"), "2"); + assertEquals("2", composite.getRawProperty("b1")); verify(accessMonitorUtil).registerUsage(eq(new PropertyDetails("b1", "b1", "2"))); - Assert.assertEquals(composite.getRawPropertyUninstrumented("b1"), "2"); + assertEquals("2", composite.getRawPropertyUninstrumented("b1")); verify(accessMonitorUtil, times(2)).registerUsage(any()); // Property (c1: 3) is covered by the composite config over the polling config - Assert.assertEquals(composite.getRawProperty("c1"), "3"); + assertEquals("3", composite.getRawProperty("c1")); verify(accessMonitorUtil).registerUsage(eq(new PropertyDetails("c1", "c1", "3"))); - Assert.assertEquals(composite.getRawPropertyUninstrumented("c1"), "3"); + assertEquals("3", composite.getRawPropertyUninstrumented("c1")); verify(accessMonitorUtil, times(3)).registerUsage(any()); // Property (d1: 5) is covered by the final, uninstrumented MapConfig - Assert.assertEquals(composite.getRawProperty("d1"), "5"); + assertEquals("5", composite.getRawProperty("d1")); verify(accessMonitorUtil, times(3)).registerUsage(any()); - Assert.assertEquals(composite.getRawPropertyUninstrumented("d1"), "5"); + assertEquals("5", composite.getRawPropertyUninstrumented("d1")); verify(accessMonitorUtil, times(3)).registerUsage(any()); // The instrumented forEachProperty endpoint updates the counts for every property diff --git a/archaius2-core/src/test/java/com/netflix/archaius/config/ConfigLoaderTest.java b/archaius2-core/src/test/java/com/netflix/archaius/config/ConfigLoaderTest.java index b731f9746..b2dbd5f5e 100644 --- a/archaius2-core/src/test/java/com/netflix/archaius/config/ConfigLoaderTest.java +++ b/archaius2-core/src/test/java/com/netflix/archaius/config/ConfigLoaderTest.java @@ -1,12 +1,13 @@ package com.netflix.archaius.config; -import org.junit.Assert; -import org.junit.Test; - import com.netflix.archaius.api.Config; import com.netflix.archaius.DefaultConfigLoader; import com.netflix.archaius.api.exceptions.ConfigException; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertTrue; + public class ConfigLoaderTest { @Test @@ -15,6 +16,6 @@ public void testLoadingOfNonExistantFile() throws ConfigException { .build(); Config config = loader.newLoader().load("non-existant"); - Assert.assertTrue(config.isEmpty()); + assertTrue(config.isEmpty()); } } diff --git a/archaius2-core/src/test/java/com/netflix/archaius/config/DefaultLayeredConfigTest.java b/archaius2-core/src/test/java/com/netflix/archaius/config/DefaultLayeredConfigTest.java index d9e6e09d5..4346c7bb5 100644 --- a/archaius2-core/src/test/java/com/netflix/archaius/config/DefaultLayeredConfigTest.java +++ b/archaius2-core/src/test/java/com/netflix/archaius/config/DefaultLayeredConfigTest.java @@ -10,8 +10,7 @@ import com.netflix.archaius.config.polling.ManualPollingStrategy; import com.netflix.archaius.config.polling.PollingResponse; import com.netflix.archaius.instrumentation.AccessMonitorUtil; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.mockito.Mockito; import java.lang.ref.Reference; @@ -24,6 +23,11 @@ import static com.netflix.archaius.TestUtils.set; import static com.netflix.archaius.TestUtils.size; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.spy; @@ -35,8 +39,8 @@ public class DefaultLayeredConfigTest { public void validateApiOnEmptyConfig() { LayeredConfig config = new DefaultLayeredConfig(); - Assert.assertFalse(config.getProperty("propname").isPresent()); - Assert.assertNull(config.getRawProperty("propname")); + assertFalse(config.getProperty("propname").isPresent()); + assertNull(config.getRawProperty("propname")); LayeredConfig.LayeredVisitor visitor = Mockito.mock(LayeredConfig.LayeredVisitor.class); config.accept(visitor); @@ -70,15 +74,15 @@ public void validatePropertyUpdates() { config.addConfig(Layers.APPLICATION, child); // Validate initial state - Assert.assertEquals("propvalue", config.getProperty("propname").get()); - Assert.assertEquals("propvalue", config.getRawProperty("propname")); + assertEquals("propvalue", config.getProperty("propname").get()); + assertEquals("propvalue", config.getRawProperty("propname")); // Update the property value child.setProperty("propname", "propvalue2"); // Validate new state - Assert.assertEquals("propvalue2", config.getProperty("propname").get()); - Assert.assertEquals("propvalue2", config.getRawProperty("propname")); + assertEquals("propvalue2", config.getProperty("propname").get()); + assertEquals("propvalue2", config.getRawProperty("propname")); Mockito.verify(listener, Mockito.times(2)).onConfigUpdated(any()); } @@ -97,15 +101,15 @@ public void validateApiWhenRemovingChild() { Mockito.verify(listener, Mockito.times(1)).onConfigUpdated(any()); // Validate initial state - Assert.assertEquals("propvalue", config.getProperty("propname").get()); - Assert.assertEquals("propvalue", config.getRawProperty("propname")); + assertEquals("propvalue", config.getProperty("propname").get()); + assertEquals("propvalue", config.getRawProperty("propname")); // Remove the child config.removeConfig(Layers.APPLICATION, child.getName()); // Validate new state - Assert.assertFalse(config.getProperty("propname").isPresent()); - Assert.assertNull(config.getRawProperty("propname")); + assertFalse(config.getProperty("propname").isPresent()); + assertNull(config.getRawProperty("propname")); Mockito.verify(listener, Mockito.times(2)).onConfigUpdated(any()); } @@ -132,22 +136,22 @@ public void validateOverrideOrder() { .build(); LayeredConfig config = new DefaultLayeredConfig(); - Assert.assertFalse(config.getProperty("propname").isPresent()); + assertFalse(config.getProperty("propname").isPresent()); config.addConfig(Layers.LIBRARY, lib1Config); - Assert.assertEquals(lib1Config.getName(), config.getRawProperty("propname")); + assertEquals(lib1Config.getName(), config.getRawProperty("propname")); config.addConfig(Layers.LIBRARY, lib2Config); - Assert.assertEquals(lib2Config.getName(), config.getRawProperty("propname")); + assertEquals(lib2Config.getName(), config.getRawProperty("propname")); config.addConfig(Layers.RUNTIME, runtimeConfig); - Assert.assertEquals(runtimeConfig.getName(), config.getRawProperty("propname")); + assertEquals(runtimeConfig.getName(), config.getRawProperty("propname")); config.addConfig(Layers.APPLICATION, appConfig); - Assert.assertEquals(runtimeConfig.getName(), config.getRawProperty("propname")); + assertEquals(runtimeConfig.getName(), config.getRawProperty("propname")); config.removeConfig(Layers.RUNTIME, runtimeConfig.getName()); - Assert.assertEquals(appConfig.getName(), config.getRawProperty("propname")); + assertEquals(appConfig.getName(), config.getRawProperty("propname")); } @Test @@ -160,7 +164,7 @@ public void unusedLayeredConfigIsGarbageCollected() { // No more pointers to prefix means this should be garbage collected and any additional listeners on it config = null; System.gc(); - Assert.assertNull(weakReference.get()); + assertNull(weakReference.get()); } @Test @@ -178,10 +182,11 @@ public void testGetKeys() { config.addConfig(Layers.APPLICATION, appConfig); config.addConfig(Layers.LIBRARY, libConfig); + @SuppressWarnings("deprecation") Iterator keys = config.getKeys(); - Assert.assertTrue(keys.hasNext()); - Assert.assertEquals("propname", keys.next()); - Assert.assertFalse(keys.hasNext()); + assertTrue(keys.hasNext()); + assertEquals("propname", keys.next()); + assertFalse(keys.hasNext()); } @Test @@ -199,10 +204,11 @@ public void testGetKeysIteratorRemoveThrows() { config.addConfig(Layers.APPLICATION, appConfig); config.addConfig(Layers.LIBRARY, libConfig); + @SuppressWarnings("deprecation") Iterator keys = config.getKeys(); - Assert.assertTrue(keys.hasNext()); + assertTrue(keys.hasNext()); keys.next(); - Assert.assertThrows(UnsupportedOperationException.class, keys::remove); + assertThrows(UnsupportedOperationException.class, keys::remove); } @Test @@ -221,8 +227,8 @@ public void testKeysIterable() { config.addConfig(Layers.LIBRARY, libConfig); Iterable keys = config.keys(); - Assert.assertEquals(1, size(keys)); - Assert.assertEquals(set("propname"), set(keys)); + assertEquals(1, size(keys)); + assertEquals(set("propname"), set(keys)); } @Test @@ -240,8 +246,8 @@ public void testKeysIterableModificationThrows() { config.addConfig(Layers.APPLICATION, appConfig); config.addConfig(Layers.LIBRARY, libConfig); - Assert.assertThrows(UnsupportedOperationException.class, config.keys().iterator()::remove); - Assert.assertThrows(UnsupportedOperationException.class, ((Collection) config.keys())::clear); + assertThrows(UnsupportedOperationException.class, config.keys().iterator()::remove); + assertThrows(UnsupportedOperationException.class, ((Collection) config.keys())::clear); } @Test @@ -250,9 +256,9 @@ public void instrumentationNotEnabled() throws Exception { config.addConfig(Layers.DEFAULT, createPollingDynamicConfig("a1", "1", "b1", "2", null)); - Assert.assertFalse(config.instrumentationEnabled()); - Assert.assertEquals(config.getRawProperty("a1"), "1"); - Assert.assertEquals(config.getRawProperty("b1"), "2"); + assertFalse(config.instrumentationEnabled()); + assertEquals(config.getRawProperty("a1"), "1"); + assertEquals(config.getRawProperty("b1"), "2"); } @Test @@ -271,30 +277,30 @@ public void instrumentationPropagation() throws Exception { layered.addConfig(Layers.ENVIRONMENT, MapConfig.builder().put("c1", "4").put("d1", "5").build()); // Properties (a1: 1) and (b1: 2) are covered by the first polling config - Assert.assertEquals(layered.getRawProperty("a1"), "1"); + assertEquals(layered.getRawProperty("a1"), "1"); verify(accessMonitorUtil).registerUsage(eq(new PropertyDetails("a1", "a1", "1"))); - Assert.assertEquals(layered.getRawPropertyUninstrumented("a1"), "1"); + assertEquals(layered.getRawPropertyUninstrumented("a1"), "1"); verify(accessMonitorUtil, times(1)).registerUsage(any()); - Assert.assertEquals(layered.getRawProperty("b1"), "2"); + assertEquals(layered.getRawProperty("b1"), "2"); verify(accessMonitorUtil).registerUsage(eq(new PropertyDetails("b1", "b1", "2"))); - Assert.assertEquals(layered.getRawPropertyUninstrumented("b1"), "2"); + assertEquals(layered.getRawPropertyUninstrumented("b1"), "2"); verify(accessMonitorUtil, times(2)).registerUsage(any()); // Property (c1: 3) is covered by the composite config over the polling config - Assert.assertEquals(layered.getRawProperty("c1"), "3"); + assertEquals(layered.getRawProperty("c1"), "3"); verify(accessMonitorUtil).registerUsage(eq(new PropertyDetails("c1", "c1", "3"))); - Assert.assertEquals(layered.getRawPropertyUninstrumented("c1"), "3"); + assertEquals(layered.getRawPropertyUninstrumented("c1"), "3"); verify(accessMonitorUtil, times(3)).registerUsage(any()); // Property (d1: 5) is covered by the final, uninstrumented MapConfig - Assert.assertEquals(layered.getRawProperty("d1"), "5"); + assertEquals(layered.getRawProperty("d1"), "5"); verify(accessMonitorUtil, times(3)).registerUsage(any()); - Assert.assertEquals(layered.getRawPropertyUninstrumented("d1"), "5"); + assertEquals(layered.getRawPropertyUninstrumented("d1"), "5"); verify(accessMonitorUtil, times(3)).registerUsage(any()); // The instrumented forEachProperty endpoint updates the counts for every property diff --git a/archaius2-core/src/test/java/com/netflix/archaius/config/DefaultSettableConfigTest.java b/archaius2-core/src/test/java/com/netflix/archaius/config/DefaultSettableConfigTest.java index dfa155a7e..dbbbc1f92 100644 --- a/archaius2-core/src/test/java/com/netflix/archaius/config/DefaultSettableConfigTest.java +++ b/archaius2-core/src/test/java/com/netflix/archaius/config/DefaultSettableConfigTest.java @@ -1,41 +1,45 @@ package com.netflix.archaius.config; import com.netflix.archaius.api.config.SettableConfig; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Test; import java.util.Collection; import java.util.Properties; import static com.netflix.archaius.TestUtils.set; import static com.netflix.archaius.TestUtils.size; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; public class DefaultSettableConfigTest { + @SuppressWarnings("deprecation") @Test public void testGetKeys() { SettableConfig config = new DefaultSettableConfig(); - Assert.assertFalse(config.getKeys().hasNext()); + assertFalse(config.getKeys().hasNext()); config.setProperty("prop1", "value1"); config.setProperty("prop2", "value2"); config.setProperty("prop3", "value3"); - Assert.assertEquals(set("prop1", "prop2", "prop3"), set(config.getKeys())); + assertEquals(set("prop1", "prop2", "prop3"), set(config.getKeys())); config.clearProperty("prop3"); - Assert.assertEquals(set("prop1", "prop2"), set(config.getKeys())); + assertEquals(set("prop1", "prop2"), set(config.getKeys())); config.setProperties(MapConfig.builder().put("prop4", "value4").build()); - Assert.assertEquals(set("prop1", "prop2", "prop4"), set(config.getKeys())); + assertEquals(set("prop1", "prop2", "prop4"), set(config.getKeys())); Properties props = new Properties(); props.put("prop5", "value5"); config.setProperties(props); - Assert.assertEquals(set("prop1", "prop2", "prop4", "prop5"), set(config.getKeys())); + assertEquals(set("prop1", "prop2", "prop4", "prop5"), set(config.getKeys())); } + @SuppressWarnings("deprecation") @Test public void testGetKeysIteratorRemoveThrows() { SettableConfig config = new DefaultSettableConfig(); @@ -43,45 +47,45 @@ public void testGetKeysIteratorRemoveThrows() { config.setProperty("prop1", "value1"); config.setProperty("prop2", "value2"); - Assert.assertThrows(UnsupportedOperationException.class, config.getKeys()::remove); + assertThrows(UnsupportedOperationException.class, config.getKeys()::remove); config.clearProperty("prop2"); - Assert.assertThrows(UnsupportedOperationException.class, config.getKeys()::remove); + assertThrows(UnsupportedOperationException.class, config.getKeys()::remove); config.setProperties(MapConfig.builder().put("prop3", "value3").build()); - Assert.assertThrows(UnsupportedOperationException.class, config.getKeys()::remove); + assertThrows(UnsupportedOperationException.class, config.getKeys()::remove); Properties properties = new Properties(); properties.put("prop5", "value5"); config.setProperties(properties); - Assert.assertThrows(UnsupportedOperationException.class, config.getKeys()::remove); + assertThrows(UnsupportedOperationException.class, config.getKeys()::remove); } @Test public void testKeysIterable() { SettableConfig config = new DefaultSettableConfig(); - Assert.assertEquals(0, size(config.keys())); + assertEquals(0, size(config.keys())); config.setProperty("prop1", "value1"); config.setProperty("prop2", "value2"); config.setProperty("prop3", "value3"); - Assert.assertEquals(set("prop1", "prop2", "prop3"), set(config.keys())); + assertEquals(set("prop1", "prop2", "prop3"), set(config.keys())); config.clearProperty("prop3"); - Assert.assertEquals(set("prop1", "prop2"), set(config.keys())); + assertEquals(set("prop1", "prop2"), set(config.keys())); config.setProperties(MapConfig.builder().put("prop4", "value4").build()); - Assert.assertEquals(set("prop1", "prop2", "prop4"), set(config.keys())); + assertEquals(set("prop1", "prop2", "prop4"), set(config.keys())); Properties props = new Properties(); props.put("prop5", "value5"); config.setProperties(props); - Assert.assertEquals(set("prop1", "prop2", "prop4", "prop5"), set(config.keys())); + assertEquals(set("prop1", "prop2", "prop4", "prop5"), set(config.keys())); } @Test @@ -91,21 +95,21 @@ public void testKeysIterableModificationThrows() { config.setProperty("prop1", "value1"); config.setProperty("prop2", "value2"); - Assert.assertThrows(UnsupportedOperationException.class, config.keys().iterator()::remove); + assertThrows(UnsupportedOperationException.class, config.keys().iterator()::remove); config.clearProperty("prop2"); - Assert.assertThrows(UnsupportedOperationException.class, config.keys().iterator()::remove); + assertThrows(UnsupportedOperationException.class, config.keys().iterator()::remove); config.setProperties(MapConfig.builder().put("prop3", "value3").build()); - Assert.assertThrows(UnsupportedOperationException.class, config.keys().iterator()::remove); + assertThrows(UnsupportedOperationException.class, config.keys().iterator()::remove); Properties properties = new Properties(); properties.put("prop4", "value4"); config.setProperties(properties); - Assert.assertThrows(UnsupportedOperationException.class, config.keys().iterator()::remove); - Assert.assertThrows(UnsupportedOperationException.class, ((Collection) config.keys())::clear); + assertThrows(UnsupportedOperationException.class, config.keys().iterator()::remove); + assertThrows(UnsupportedOperationException.class, ((Collection) config.keys())::clear); } } diff --git a/archaius2-core/src/test/java/com/netflix/archaius/config/InterpolationTest.java b/archaius2-core/src/test/java/com/netflix/archaius/config/InterpolationTest.java index 441d7bafe..3702e59e7 100644 --- a/archaius2-core/src/test/java/com/netflix/archaius/config/InterpolationTest.java +++ b/archaius2-core/src/test/java/com/netflix/archaius/config/InterpolationTest.java @@ -1,12 +1,13 @@ package com.netflix.archaius.config; -import org.junit.Assert; -import org.junit.Test; - import com.netflix.archaius.api.Config; import com.netflix.archaius.api.config.CompositeConfig; import com.netflix.archaius.api.exceptions.ConfigException; import com.netflix.archaius.visitor.PrintStreamVisitor; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; public class InterpolationTest { @Test @@ -16,7 +17,7 @@ public void simpleStringInterpolation() { .put("bar", "value") .build(); - Assert.assertEquals("value", config.getString("foo")); + assertEquals("value", config.getString("foo")); } @Test @@ -26,7 +27,7 @@ public void nonStringInterpolation() { .put("bar", "123") .build(); - Assert.assertEquals(123, config.getInteger("foo").intValue()); + assertEquals(123, config.getInteger("foo").intValue()); } @Test @@ -44,9 +45,9 @@ public void interpolationOnlyDoneOnParent() throws ConfigException { .withConfig("b", child2) .build(); - Assert.assertEquals("123", composite.getString("foo")); - Assert.assertEquals("not_found", child1.getString("foo", "not_found")); - Assert.assertEquals("not_found", child2.getString("${parent}", "not_found")); + assertEquals("123", composite.getString("foo")); + assertEquals("not_found", child1.getString("foo", "not_found")); + assertEquals("not_found", child2.getString("${parent}", "not_found")); } @Test @@ -55,7 +56,7 @@ public void stringInterpolationWithDefault() { .put("bar", "${foo:default}") .build(); - Assert.assertEquals("default", config.getString("bar")); + assertEquals("default", config.getString("bar")); } @Test @@ -64,7 +65,7 @@ public void numericInterpolationWithDefault() { .put("bar", "${foo:-123}") .build(); - Assert.assertEquals(-123, config.getInteger("bar").intValue()); + assertEquals(-123, config.getInteger("bar").intValue()); } @@ -75,11 +76,11 @@ public void interpolatePrefixedView() { .put("nonprefixed.key2", "key2_value") .build(); - Assert.assertEquals("key2_value", config.getString("prefix.key1")); + assertEquals("key2_value", config.getString("prefix.key1")); Config prefixedConfig = config.getPrefixedView("prefix"); prefixedConfig.accept(new PrintStreamVisitor()); - Assert.assertEquals("key2_value", prefixedConfig.getString("key1")); + assertEquals("key2_value", prefixedConfig.getString("key1")); } @Test @@ -89,11 +90,11 @@ public void interpolateNumericPrefixedView() { .put("nonprefixed.key2", "123") .build(); - Assert.assertEquals(123, config.getInteger("prefix.key1").intValue()); + assertEquals(123, config.getInteger("prefix.key1").intValue()); Config prefixedConfig = config.getPrefixedView("prefix"); - Assert.assertEquals(123, prefixedConfig.getInteger("key1").intValue()); + assertEquals(123, prefixedConfig.getInteger("key1").intValue()); } @Test @@ -103,7 +104,7 @@ public void nestedInterpolations() { .put("b", "${c:${a}}") .build(); - Assert.assertEquals("A", config.getString("b")); + assertEquals("A", config.getString("b")); } @Test @@ -112,15 +113,14 @@ public void nestedInterpolationsWithResolve() { .put("a", "A") .build(); - Assert.assertEquals("A", config.resolve("${b:${c:${a}}}")); + assertEquals("A", config.resolve("${b:${c:${a}}}")); } - - @Test(expected=IllegalStateException.class) + + @Test public void failOnCircularResolve() { Config config = MapConfig.builder() .build(); - - config.resolve("${b:${c:${b}}}"); + assertThrows(IllegalStateException.class, () -> config.resolve("${b:${c:${b}}}")); } @Test @@ -128,7 +128,7 @@ public void returnStringOnMissingInterpolation() { Config config = MapConfig.builder() .build(); - Assert.assertEquals("${c}", config.resolve("${b:${c}}")); + assertEquals("${c}", config.resolve("${b:${c}}")); } } diff --git a/archaius2-core/src/test/java/com/netflix/archaius/config/MapConfigTest.java b/archaius2-core/src/test/java/com/netflix/archaius/config/MapConfigTest.java index 95045d76d..1b296b4db 100644 --- a/archaius2-core/src/test/java/com/netflix/archaius/config/MapConfigTest.java +++ b/archaius2-core/src/test/java/com/netflix/archaius/config/MapConfigTest.java @@ -23,16 +23,16 @@ import java.util.NoSuchElementException; import java.util.Set; -import org.junit.Assert; -import org.junit.Ignore; -import org.junit.Test; - import com.netflix.archaius.api.Config; -import com.netflix.archaius.api.exceptions.ConfigException; import com.netflix.archaius.exceptions.ParseException; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; import static com.netflix.archaius.TestUtils.set; import static com.netflix.archaius.TestUtils.size; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; public class MapConfigTest { private final MapConfig config = MapConfig.builder() @@ -40,151 +40,150 @@ public class MapConfigTest { .put("badnumber", "badnumber") .build(); - @Test(expected=NoSuchElementException.class) - public void nonExistantString() { - config.getString("nonexistent"); + @Test + public void nonExistentString() { + assertThrows(NoSuchElementException.class, () -> config.getString("nonexistent")); } - @Test(expected=NoSuchElementException.class) - public void nonExistantBigDecimal() { - config.getBigDecimal("nonexistent"); + @Test + public void nonExistentBigDecimal() { + assertThrows(NoSuchElementException.class, () -> config.getBigDecimal("nonexistent")); } - @Test(expected=NoSuchElementException.class) - public void nonExistantBigInteger() { - config.getBigInteger("nonexistent"); + @Test + public void nonExistentBigInteger() { + assertThrows(NoSuchElementException.class, () -> config.getBigInteger("nonexistent")); } - @Test(expected=NoSuchElementException.class) - public void nonExistantBoolean() { - config.getBoolean("nonexistent"); + @Test + public void nonExistentBoolean() { + assertThrows(NoSuchElementException.class, () -> config.getBoolean("nonexistent")); } - @Test(expected=NoSuchElementException.class) - public void nonExistantByte() { - config.getByte("nonexistent"); + @Test + public void nonExistentByte() { + assertThrows(NoSuchElementException.class, () -> config.getByte("nonexistent")); } - @Test(expected=NoSuchElementException.class) - public void nonExistantDouble() { - config.getDouble("nonexistent"); + @Test + public void nonExistentDouble() { + assertThrows(NoSuchElementException.class, () -> config.getDouble("nonexistent")); } - @Test(expected=NoSuchElementException.class) - public void nonExistantFloat() { - config.getFloat("nonexistent"); + @Test + public void nonExistentFloat() { + assertThrows(NoSuchElementException.class, () -> config.getFloat("nonexistent")); } - @Test(expected=NoSuchElementException.class) - public void nonExistantInteger() { - config.getInteger("nonexistent"); + @Test + public void nonExistentInteger() { + assertThrows(NoSuchElementException.class, () -> config.getInteger("nonexistent")); } - @Test(expected=NoSuchElementException.class) - public void nonExistantList() { - config.getList("nonexistent"); + @Test + public void nonExistentList() { + assertThrows(NoSuchElementException.class, () -> config.getList("nonexistent")); } - @Test(expected=NoSuchElementException.class) - public void nonExistantLong() { - config.getLong("nonexistent"); + @Test + public void nonExistentLong() { + assertThrows(NoSuchElementException.class, () -> config.getLong("nonexistent")); } - @Test(expected=NoSuchElementException.class) - public void nonExistantShort() { - config.getShort("nonexistent"); + @Test + public void nonExistentShort() { + assertThrows(NoSuchElementException.class, () -> config.getShort("nonexistent")); } - @Test(expected=ParseException.class) + @Test public void invalidBigDecimal() { - config.getBigDecimal("badnumber"); + assertThrows(ParseException.class, () -> config.getBigDecimal("badnumber")); } - @Test(expected=ParseException.class) + @Test public void invalidBigInteger() { - config.getBigInteger("badnumber"); + assertThrows(ParseException.class, () -> config.getBigInteger("badnumber")); } - @Test(expected=ParseException.class) + @Test public void invalidBoolean() { - config.getBoolean("badnumber"); + assertThrows(ParseException.class, () -> config.getBoolean("badnumber")); } - @Test(expected=Exception.class) - @Ignore + @Test + @Disabled public void invalidByte() { - config.getByte("badnumber"); + assertThrows(Exception.class, () -> config.getByte("badnumber")); } - @Test(expected=ParseException.class) + @Test public void invalidDouble() { - config.getDouble("badnumber"); + assertThrows(ParseException.class, () -> config.getDouble("badnumber")); } - @Test(expected=ParseException.class) + @Test public void invalidFloat() { - config.getFloat("badnumber"); + assertThrows(ParseException.class, () -> config.getFloat("badnumber")); } - @Test(expected=ParseException.class) + @Test public void invalidInteger() { - config.getInteger("badnumber"); + assertThrows(ParseException.class, () -> config.getInteger("badnumber")); } - @Test(expected=Exception.class) - @Ignore + @Test + @Disabled public void invalidList() { // TODO } - @Test(expected=ParseException.class) + @Test public void invalidLong() { - config.getLong("badnumber"); + assertThrows(ParseException.class, () -> config.getLong("badnumber")); } - @Test(expected=ParseException.class) + @Test public void invalidShort() { - config.getShort("badnumber"); + assertThrows(ParseException.class, () -> config.getShort("badnumber")); } @Test - public void interpolationShouldWork() throws ConfigException { + public void interpolationShouldWork() { Config config = MapConfig.builder() .put("env", "prod") .put("replacement", "${env}") .build(); - Assert.assertEquals("prod", config.getString("replacement")); + assertEquals("prod", config.getString("replacement")); } @Test - public void interpolationWithDefaultReplacement() throws ConfigException { + public void interpolationWithDefaultReplacement() { Config config = MapConfig.builder() .put("env", "prod") .put("replacement", "${env}") .build(); - Assert.assertEquals("prod", config.getString("nonexistent", "${env}")); + assertEquals("prod", config.getString("nonexistent", "${env}")); } - @Test(expected=IllegalStateException.class) - public void infiniteInterpolationRecursionShouldFail() throws ConfigException { + @Test + public void infiniteInterpolationRecursionShouldFail() { Config config = MapConfig.builder() .put("env", "${env}") .put("replacement.env", "${env}") .build(); - - Assert.assertEquals("prod", config.getString("replacement.env")); + + assertThrows(IllegalStateException.class, () -> config.getString("replacement.env")); } @Test - public void numericInterpolationShouldWork() throws ConfigException { + public void numericInterpolationShouldWork() { Config config = MapConfig.builder() .put("default", "123") .put("value", "${default}") .build(); - - Assert.assertEquals((long)123L, (long)config.getLong("value")); + assertEquals(123L, (long) config.getLong("value")); } @Test @@ -195,16 +194,17 @@ public void getKeys() { Config config = MapConfig.from(props); + @SuppressWarnings("deprecation") Iterator keys = config.getKeys(); - Assert.assertTrue(keys.hasNext()); + assertTrue(keys.hasNext()); Set keySet = new HashSet<>(); while (keys.hasNext()) { keySet.add(keys.next()); } - Assert.assertEquals(2, keySet.size()); - Assert.assertEquals(props.keySet(), keySet); + assertEquals(2, keySet.size()); + assertEquals(props.keySet(), keySet); } @Test @@ -213,11 +213,12 @@ public void getKeysIteratorRemoveThrows() { .put("key1", "value1") .put("key2", "value2") .build(); + @SuppressWarnings("deprecation") Iterator keys = config.getKeys(); - Assert.assertTrue(keys.hasNext()); + assertTrue(keys.hasNext()); keys.next(); - Assert.assertThrows(UnsupportedOperationException.class, keys::remove); + assertThrows(UnsupportedOperationException.class, keys::remove); } @Test @@ -228,8 +229,8 @@ public void testKeysIterable() { .build(); Iterable keys = config.keys(); - Assert.assertEquals(2, size(keys)); - Assert.assertEquals(set("key1", "key2"), set(keys)); + assertEquals(2, size(keys)); + assertEquals(set("key1", "key2"), set(keys)); } @Test @@ -239,7 +240,7 @@ public void testKeysIterableModificationThrows() { .put("key2", "value2") .build(); - Assert.assertThrows(UnsupportedOperationException.class, config.keys().iterator()::remove); - Assert.assertThrows(UnsupportedOperationException.class, ((Collection) config.keys())::clear); + assertThrows(UnsupportedOperationException.class, config.keys().iterator()::remove); + assertThrows(UnsupportedOperationException.class, ((Collection) config.keys())::clear); } } diff --git a/archaius2-core/src/test/java/com/netflix/archaius/config/PollingDynamicConfigTest.java b/archaius2-core/src/test/java/com/netflix/archaius/config/PollingDynamicConfigTest.java index 2c474cb94..75eae9254 100644 --- a/archaius2-core/src/test/java/com/netflix/archaius/config/PollingDynamicConfigTest.java +++ b/archaius2-core/src/test/java/com/netflix/archaius/config/PollingDynamicConfigTest.java @@ -28,21 +28,25 @@ import com.netflix.archaius.api.PropertyDetails; import com.netflix.archaius.config.polling.PollingResponse; import com.netflix.archaius.instrumentation.AccessMonitorUtil; -import org.junit.Assert; -import org.junit.Rule; -import org.junit.Test; import com.netflix.archaius.api.Config; import com.netflix.archaius.config.polling.ManualPollingStrategy; import com.netflix.archaius.junit.TestHttpServer; import com.netflix.archaius.property.PropertiesServerHandler; import com.netflix.archaius.readers.URLConfigReader; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.Timeout; +import org.junit.jupiter.api.extension.RegisterExtension; import static com.netflix.archaius.TestUtils.set; import static com.netflix.archaius.TestUtils.size; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.spy; @@ -50,17 +54,29 @@ import static org.mockito.Mockito.verify; public class PollingDynamicConfigTest { - - private final PropertiesServerHandler prop1 = new PropertiesServerHandler(); - private final PropertiesServerHandler prop2 = new PropertiesServerHandler(); - - @Rule - public TestHttpServer server = new TestHttpServer() + + private static final PropertiesServerHandler prop1 = new PropertiesServerHandler(); + private static final PropertiesServerHandler prop2 = new PropertiesServerHandler(); + + @RegisterExtension + static TestHttpServer HTTP_SERVER = new TestHttpServer() .handler("/prop1", prop1) - .handler("/prop2", prop2) - ; - - @Test(timeout=1000) + .handler("/prop2", prop2); + + private final TestHttpServer server; + + PollingDynamicConfigTest(TestHttpServer server) { + this.server = server; + } + + @AfterEach + public void tearDown() { + prop1.clear(); + prop2.clear(); + } + + @Test + @Timeout(1000) public void testBasicRead() throws Exception { URLConfigReader reader = new URLConfigReader( server.getServerPathURI("/prop1").toURL() @@ -70,16 +86,17 @@ public void testBasicRead() throws Exception { prop1.setProperty("a", "a_value"); result = reader.call().getToAdd(); - Assert.assertFalse(result.isEmpty()); + assertFalse(result.isEmpty()); assertEquals("a_value", result.get("a")); prop1.setProperty("a", "b_value"); result = reader.call().getToAdd(); - Assert.assertFalse(result.isEmpty()); + assertFalse(result.isEmpty()); assertEquals("b_value", result.get("a")); } - @Test(timeout=1000) + @Test + @Timeout(1000) public void testCombineSources() throws Exception { URLConfigReader reader = new URLConfigReader( server.getServerPathURI("/prop1").toURL(), @@ -99,18 +116,18 @@ public void testCombineSources() throws Exception { assertEquals("B", result.get("b")); } - @Test(timeout=1000, expected=IOException.class) + @Test + @Timeout(1000) public void testFailure() throws Exception { URLConfigReader reader = new URLConfigReader( server.getServerPathURI("/prop1").toURL()); prop1.setResponseCode(500); - reader.call(); - - Assert.fail("Should have failed with 500 error"); + assertThrows(IOException.class, reader::call); } - @Test(timeout=1000) + @Test + @Timeout(1000) public void testDynamicConfig() throws Exception { URLConfigReader reader = new URLConfigReader( server.getServerPathURI("/prop1").toURL(), @@ -131,7 +148,7 @@ public void testDynamicConfig() throws Exception { // Modify // a=ANew // b=BNew - Assert.assertFalse(config.isEmpty()); + assertFalse(config.isEmpty()); assertEquals("A", config.getString("a")); assertEquals("B", config.getString("b")); @@ -151,11 +168,12 @@ public void testDynamicConfig() throws Exception { prop2.setProperty("b", "BNew"); strategy.fire(); - Assert.assertNull(config.getString("a", null)); + assertNull(config.getString("a", null)); assertEquals("BNew", config.getString("b")); } - @Test(timeout=1000) + @Test + @Timeout(1000) public void testDynamicConfigFailures() throws Exception { URLConfigReader reader = new URLConfigReader( server.getServerPathURI("/prop1").toURL(), @@ -195,7 +213,7 @@ public void onError(Throwable error, Config config) { try { strategy.fire(); - Assert.fail("Should have thrown an exception"); + fail("Should have thrown an exception"); } catch (Exception expected) { @@ -205,7 +223,7 @@ public void onError(Throwable error, Config config) { assertEquals(1, updateCount.get()); assertEquals("A", config.getString("a")); - // Confim state updates after failure + // Confirm state updates after failure prop1.setResponseCode(200); strategy.fire(); @@ -226,7 +244,7 @@ public void testGetKeys() throws Exception { }; PollingDynamicConfig config = new PollingDynamicConfig(reader, strategy); Iterator emptyKeys = config.getKeys(); - Assert.assertFalse(emptyKeys.hasNext()); + assertFalse(emptyKeys.hasNext()); strategy.fire(); @@ -236,9 +254,9 @@ public void testGetKeys() throws Exception { keySet.add(keys.next()); } - Assert.assertEquals(2, keySet.size()); - Assert.assertTrue(keySet.contains("foo")); - Assert.assertTrue(keySet.contains("bar")); + assertEquals(2, keySet.size()); + assertTrue(keySet.contains("foo")); + assertTrue(keySet.contains("bar")); } @Test @@ -254,9 +272,9 @@ public void testGetKeysIteratorRemoveThrows() throws Exception { strategy.fire(); Iterator keys = config.getKeys(); - Assert.assertTrue(keys.hasNext()); + assertTrue(keys.hasNext()); keys.next(); - Assert.assertThrows(UnsupportedOperationException.class, keys::remove); + assertThrows(UnsupportedOperationException.class, keys::remove); } @Test @@ -272,8 +290,8 @@ public void testKeysIterable() throws Exception { strategy.fire(); Iterable keys = config.keys(); - Assert.assertEquals(2, size(keys)); - Assert.assertEquals(set("foo", "bar"), set(keys)); + assertEquals(2, size(keys)); + assertEquals(set("foo", "bar"), set(keys)); } @Test @@ -288,8 +306,8 @@ public void testKeysIterableModificationThrows() throws Exception { PollingDynamicConfig config = new PollingDynamicConfig(reader, strategy); strategy.fire(); - Assert.assertThrows(UnsupportedOperationException.class, config.keys().iterator()::remove); - Assert.assertThrows(UnsupportedOperationException.class, ((Collection) config.keys())::clear); + assertThrows(UnsupportedOperationException.class, config.keys().iterator()::remove); + assertThrows(UnsupportedOperationException.class, ((Collection) config.keys())::clear); } @Test @@ -308,7 +326,7 @@ public void testInstrumentation() throws Exception { PollingDynamicConfig config = new PollingDynamicConfig(reader, strategy, accessMonitorUtil); strategy.fire(); - Assert.assertTrue(config.instrumentationEnabled()); + assertTrue(config.instrumentationEnabled()); config.getRawProperty("foo"); verify(accessMonitorUtil).registerUsage(eq(new PropertyDetails("foo", "1", "foo-value"))); diff --git a/archaius2-core/src/test/java/com/netflix/archaius/config/PrefixedViewTest.java b/archaius2-core/src/test/java/com/netflix/archaius/config/PrefixedViewTest.java index 9bd28f9e7..c6662d7d1 100644 --- a/archaius2-core/src/test/java/com/netflix/archaius/config/PrefixedViewTest.java +++ b/archaius2-core/src/test/java/com/netflix/archaius/config/PrefixedViewTest.java @@ -19,12 +19,16 @@ import com.netflix.archaius.config.polling.ManualPollingStrategy; import com.netflix.archaius.config.polling.PollingResponse; import com.netflix.archaius.instrumentation.AccessMonitorUtil; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.mockito.Mockito; import static com.netflix.archaius.TestUtils.set; import static com.netflix.archaius.TestUtils.size; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.spy; @@ -33,7 +37,7 @@ public class PrefixedViewTest { @Test - public void confirmNotifactionOnAnyChange() throws ConfigException { + public void confirmNotificactionOnAnyChange() throws ConfigException { com.netflix.archaius.api.config.CompositeConfig config = DefaultCompositeConfig.builder() .withConfig("foo", MapConfig.builder().put("foo.bar", "value").build()) .build(); @@ -66,13 +70,13 @@ public void confirmNotifactionOnSettableConfigChange() throws ConfigException { prefix.addListener(listener); // Confirm original state - Assert.assertEquals("original", prefix.getString("bar")); + assertEquals("original", prefix.getString("bar")); Mockito.verify(listener, Mockito.times(0)).onConfigAdded(any()); // Update the property and confirm onConfigUpdated notification settable.setProperty("foo.bar", "new"); Mockito.verify(listener, Mockito.times(1)).onConfigUpdated(any()); - Assert.assertEquals("new", prefix.getString("bar")); + assertEquals("new", prefix.getString("bar")); // Add a new config and confirm onConfigAdded notification config.addConfig("new", MapConfig.builder().put("foo.bar", "new2").build()); @@ -88,8 +92,8 @@ public void trailingDotAllowed() { Config prefixNoDot = settable.getPrefixedView("foo"); Config prefixWithDot = settable.getPrefixedView("foo."); - Assert.assertEquals(prefixNoDot.getString("bar"), "value"); - Assert.assertEquals(prefixWithDot.getString("bar"), "value"); + assertEquals(prefixNoDot.getString("bar"), "value"); + assertEquals(prefixWithDot.getString("bar"), "value"); } @Test @@ -101,7 +105,7 @@ public void unusedPrefixedViewIsGarbageCollected() { // No more pointers to prefix means this should be garbage collected and any additional listeners on it prefix = null; System.gc(); - Assert.assertNull(weakReference.get()); + assertNull(weakReference.get()); } @Test @@ -112,14 +116,15 @@ public void testGetKeys() { .build() .getPrefixedView("foo"); + @SuppressWarnings("deprecation") Iterator keys = config.getKeys(); Set keySet = new HashSet<>(); while (keys.hasNext()) { keySet.add(keys.next()); } - Assert.assertEquals(2, keySet.size()); - Assert.assertTrue(keySet.contains("prop1")); - Assert.assertTrue(keySet.contains("prop2")); + assertEquals(2, keySet.size()); + assertTrue(keySet.contains("prop1")); + assertTrue(keySet.contains("prop2")); } @Test @@ -130,9 +135,10 @@ public void testGetKeysIteratorRemoveThrows() { .build() .getPrefixedView("foo"); + @SuppressWarnings("deprecation") Iterator keys = config.getKeys(); keys.next(); - Assert.assertThrows(UnsupportedOperationException.class, keys::remove); + assertThrows(UnsupportedOperationException.class, keys::remove); } @Test @@ -144,8 +150,8 @@ public void testKeysIterable() { .getPrefixedView("foo"); Iterable keys = config.keys(); - Assert.assertEquals(2, size(keys)); - Assert.assertEquals(set("prop1", "prop2"), set(keys)); + assertEquals(2, size(keys)); + assertEquals(set("prop1", "prop2"), set(keys)); } @Test @@ -156,8 +162,8 @@ public void testKeysIterableModificationThrows() { .build() .getPrefixedView("foo"); - Assert.assertThrows(UnsupportedOperationException.class, config.keys().iterator()::remove); - Assert.assertThrows(UnsupportedOperationException.class, ((Collection) config.keys())::clear); + assertThrows(UnsupportedOperationException.class, config.keys().iterator()::remove); + assertThrows(UnsupportedOperationException.class, ((Collection) config.keys())::clear); } @Test @@ -168,9 +174,9 @@ public void instrumentationNotEnabled() throws Exception { .build() .getPrefixedView("foo"); - Assert.assertFalse(config.instrumentationEnabled()); - Assert.assertEquals(config.getRawProperty("prop1"), "value1"); - Assert.assertEquals(config.getRawProperty("prop2"), "value2"); + assertFalse(config.instrumentationEnabled()); + assertEquals(config.getRawProperty("prop1"), "value1"); + assertEquals(config.getRawProperty("prop2"), "value2"); } @Test @@ -191,7 +197,7 @@ public void instrumentation() throws Exception { Config config = baseConfig.getPrefixedView("foo"); - Assert.assertTrue(config.instrumentationEnabled()); + assertTrue(config.instrumentationEnabled()); config.getRawProperty("prop1"); verify(accessMonitorUtil).registerUsage(eq(new PropertyDetails("foo.prop1", "1", "foo-value"))); diff --git a/archaius2-core/src/test/java/com/netflix/archaius/config/PrivateViewTest.java b/archaius2-core/src/test/java/com/netflix/archaius/config/PrivateViewTest.java index 528f92754..acadc1394 100644 --- a/archaius2-core/src/test/java/com/netflix/archaius/config/PrivateViewTest.java +++ b/archaius2-core/src/test/java/com/netflix/archaius/config/PrivateViewTest.java @@ -9,8 +9,7 @@ import com.netflix.archaius.config.polling.ManualPollingStrategy; import com.netflix.archaius.config.polling.PollingResponse; import com.netflix.archaius.instrumentation.AccessMonitorUtil; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.mockito.Mockito; import java.lang.ref.Reference; @@ -23,11 +22,15 @@ import java.util.Set; import java.util.concurrent.Callable; -import static org.junit.Assert.assertNotSame; -import static org.junit.Assert.assertSame; - import static com.netflix.archaius.TestUtils.set; import static com.netflix.archaius.TestUtils.size; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.spy; @@ -91,13 +94,13 @@ public void confirmNotificationOnSettableConfigChange() throws ConfigException { privateView.addListener(listener); // Confirm original state - Assert.assertEquals("original", privateView.getString("foo.bar")); + assertEquals("original", privateView.getString("foo.bar")); Mockito.verify(listener, Mockito.times(0)).onConfigAdded(any()); // Update the property and confirm onConfigUpdated notification settable.setProperty("foo.bar", "new"); Mockito.verify(listener, Mockito.times(1)).onConfigUpdated(any()); - Assert.assertEquals("new", privateView.getString("foo.bar")); + assertEquals("new", privateView.getString("foo.bar")); // Add a new config and confirm onConfigAdded notification config.addConfig("new", MapConfig.builder().put("foo.bar", "new2").build()); @@ -113,7 +116,7 @@ public void unusedPrivateViewIsGarbageCollected() { // No more pointers to prefix means this should be garbage collected and any additional listeners on it privateView = null; System.gc(); - Assert.assertNull(weakReference.get()); + assertNull(weakReference.get()); } @Test @@ -124,14 +127,15 @@ public void testGetKeys() { .build() .getPrivateView(); + @SuppressWarnings("deprecation") Iterator keys = config.getKeys(); Set keySet = new HashSet<>(); while (keys.hasNext()) { keySet.add(keys.next()); } - Assert.assertEquals(2, keySet.size()); - Assert.assertTrue(keySet.contains("foo")); - Assert.assertTrue(keySet.contains("bar")); + assertEquals(2, keySet.size()); + assertTrue(keySet.contains("foo")); + assertTrue(keySet.contains("bar")); } @Test @@ -142,9 +146,10 @@ public void testGetKeysIteratorRemoveThrows() { .build() .getPrivateView(); + @SuppressWarnings("deprecation") Iterator keys = config.getKeys(); keys.next(); - Assert.assertThrows(UnsupportedOperationException.class, keys::remove); + assertThrows(UnsupportedOperationException.class, keys::remove); } @Test @@ -156,8 +161,8 @@ public void testKeysIterable() { .getPrivateView(); Iterable keys = config.keys(); - Assert.assertEquals(2, size(keys)); - Assert.assertEquals(set("foo", "bar"), set(keys)); + assertEquals(2, size(keys)); + assertEquals(set("foo", "bar"), set(keys)); } @Test @@ -168,8 +173,8 @@ public void testKeysIterableModificationThrows() { .build() .getPrivateView(); - Assert.assertThrows(UnsupportedOperationException.class, config.keys().iterator()::remove); - Assert.assertThrows(UnsupportedOperationException.class, ((Collection) config.keys())::clear); + assertThrows(UnsupportedOperationException.class, config.keys().iterator()::remove); + assertThrows(UnsupportedOperationException.class, ((Collection) config.keys())::clear); } @Test @@ -180,9 +185,9 @@ public void instrumentationNotEnabled() throws Exception { .build() .getPrivateView(); - Assert.assertFalse(config.instrumentationEnabled()); - Assert.assertEquals(config.getRawProperty("foo.prop1"), "value1"); - Assert.assertEquals(config.getRawProperty("foo.prop2"), "value2"); + assertFalse(config.instrumentationEnabled()); + assertEquals(config.getRawProperty("foo.prop1"), "value1"); + assertEquals(config.getRawProperty("foo.prop2"), "value2"); } @Test @@ -203,7 +208,7 @@ public void testInstrumentation() throws Exception { Config config = baseConfig.getPrivateView(); - Assert.assertTrue(config.instrumentationEnabled()); + assertTrue(config.instrumentationEnabled()); config.getRawProperty("foo.prop1"); verify(accessMonitorUtil).registerUsage(eq(new PropertyDetails("foo.prop1", "1", "foo-value"))); diff --git a/archaius2-core/src/test/java/com/netflix/archaius/junit/TestHttpServer.java b/archaius2-core/src/test/java/com/netflix/archaius/junit/TestHttpServer.java index 241bfad7e..20b0aac17 100644 --- a/archaius2-core/src/test/java/com/netflix/archaius/junit/TestHttpServer.java +++ b/archaius2-core/src/test/java/com/netflix/archaius/junit/TestHttpServer.java @@ -30,9 +30,12 @@ import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; -import org.junit.rules.TestRule; -import org.junit.runner.Description; -import org.junit.runners.model.Statement; +import org.junit.jupiter.api.extension.AfterAllCallback; +import org.junit.jupiter.api.extension.BeforeAllCallback; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.api.extension.ParameterContext; +import org.junit.jupiter.api.extension.ParameterResolutionException; +import org.junit.jupiter.api.extension.ParameterResolver; import com.netflix.archaius.util.ThreadFactories; import com.sun.net.httpserver.HttpExchange; @@ -59,7 +62,7 @@ * @author elandau * */ -public class TestHttpServer implements TestRule { +public class TestHttpServer implements BeforeAllCallback, AfterAllCallback, ParameterResolver { public static final String INTERNALERROR_PATH = "/internalerror"; public static final String NORESPONSE_PATH = "/noresponse"; public static final String STATUS_PATH = "/status"; @@ -73,41 +76,41 @@ public class TestHttpServer implements TestRule { private int localHttpServerPort = 0; private ExecutorService service; private int threadCount = DEFAULT_THREAD_COUNT; - private LinkedHashMap handlers = new LinkedHashMap(); - - private String GENERIC_RESPONSE = "GenericTestHttpServer Response"; + private final LinkedHashMap handlers = new LinkedHashMap<>(); + private final String GENERIC_RESPONSE = "GenericTestHttpServer Response"; + public TestHttpServer() { handlers.put(ROOT_PATH, new TestHttpHandler() { @Override protected void handle(RequestContext context) throws IOException { context.response(200, GENERIC_RESPONSE); }}); - + handlers.put(OK_PATH, new TestHttpHandler() { @Override protected void handle(RequestContext context) throws IOException { context.response(200, GENERIC_RESPONSE); }}); - + handlers.put(STATUS_PATH, new TestHttpHandler() { @Override protected void handle(RequestContext context) throws IOException { context.response(Integer.parseInt(context.query("code")), GENERIC_RESPONSE); }}); - + handlers.put(NORESPONSE_PATH, new TestHttpHandler() { @Override protected void handle(RequestContext context) throws IOException { }}); - + handlers.put(INTERNALERROR_PATH, new TestHttpHandler() { @Override protected void handle(RequestContext context) throws IOException { throw new RuntimeException("InternalError"); }}); } - + public TestHttpServer handler(String path, HttpHandler handler) { handlers.put(path, handler); return this; @@ -122,23 +125,46 @@ public TestHttpServer threadCount(int threads) { this.threadCount = threads; return this; } - + @Override - public Statement apply(final Statement statement, final Description description) { - return new Statement() { - @Override - public void evaluate() throws Throwable { - before(description); - try { - statement.evaluate(); - } finally { - after(description); - } - } - }; + public void beforeAll(ExtensionContext context) throws Exception { + this.service = Executors.newFixedThreadPool( + threadCount, + ThreadFactories.newNamedDaemonThreadFactory("TestHttpServer-%d")); + + InetSocketAddress inetSocketAddress = new InetSocketAddress("localhost", 0); + server = HttpServer.create(inetSocketAddress, 0); + server.setExecutor(service); + + for (Entry handler : handlers.entrySet()) { + server.createContext(handler.getKey(), handler.getValue()); + } + + server.start(); + localHttpServerPort = server.getAddress().getPort(); + + System.out.println("TestServer is started: " + getServerUrl()); } - private static interface RequestContext { + @Override + public void afterAll(ExtensionContext context) { + server.stop(0); + ((ExecutorService) server.getExecutor()).shutdownNow(); + + System.out.println("TestServer is shutdown: " + getServerUrl()); + } + + @Override + public boolean supportsParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException { + return parameterContext.getParameter().getType().equals(TestHttpServer.class); + } + + @Override + public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException { + return this; + } + + private interface RequestContext { void response(int code, String body) throws IOException; String query(String key); } @@ -150,13 +176,11 @@ public final void handle(final HttpExchange t) throws IOException { final Map queryParameters = queryToMap(t); if (queryParameters.containsKey(DELAY_QUERY_PARAM)) { - Long delay = Long.parseLong(queryParameters.get(DELAY_QUERY_PARAM)); - if (delay != null) { - try { - TimeUnit.MILLISECONDS.sleep(delay); - } catch (InterruptedException e) { - Thread.currentThread().interrupt(); - } + long delay = Long.parseLong(queryParameters.get(DELAY_QUERY_PARAM)); + try { + TimeUnit.MILLISECONDS.sleep(delay); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); } } @@ -192,11 +216,11 @@ public String query(String key) { private static Map queryToMap(HttpExchange t) { String queryString = t.getRequestURI().getQuery(); - Map result = new HashMap(); + Map result = new HashMap<>(); if (queryString != null) { for (String param : queryString.split("&")) { - String pair[] = param.split("="); - if (pair.length>1) { + String[] pair = param.split("="); + if (pair.length > 1) { result.put(pair[0], pair[1]); } else{ @@ -208,36 +232,6 @@ private static Map queryToMap(HttpExchange t) { } } - - public void before(final Description description) throws Exception { - this.service = Executors.newFixedThreadPool( - threadCount, - ThreadFactories.newNamedDaemonThreadFactory("TestHttpServer-%d")); - - InetSocketAddress inetSocketAddress = new InetSocketAddress("localhost", 0); - server = HttpServer.create(inetSocketAddress, 0); - server.setExecutor(service); - - for (Entry handler : handlers.entrySet()) { - server.createContext(handler.getKey(), handler.getValue()); - } - - server.start(); - localHttpServerPort = server.getAddress().getPort(); - - System.out.println(description.getClassName() + " TestServer is started: " + getServerUrl()); - } - - public void after(final Description description) { - try{ - server.stop(0); - ((ExecutorService) server.getExecutor()).shutdownNow(); - - System.out.println(description.getClassName() + " TestServer is shutdown: " + getServerUrl()); - } catch (Exception e) { - e.printStackTrace(); - } - } /** * @return Get the root server URL diff --git a/archaius2-core/src/test/java/com/netflix/archaius/loaders/PropertyConfigReaderTest.java b/archaius2-core/src/test/java/com/netflix/archaius/loaders/PropertyConfigReaderTest.java index 0ac70890e..df9514fc1 100644 --- a/archaius2-core/src/test/java/com/netflix/archaius/loaders/PropertyConfigReaderTest.java +++ b/archaius2-core/src/test/java/com/netflix/archaius/loaders/PropertyConfigReaderTest.java @@ -18,11 +18,10 @@ import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.is; +import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.Arrays; - -import org.junit.Assert; -import org.junit.Test; +import java.util.Collections; import com.netflix.archaius.api.Config; import com.netflix.archaius.api.StrInterpolator; @@ -33,6 +32,8 @@ import com.netflix.archaius.readers.PropertiesConfigReader; import com.netflix.archaius.visitor.PrintStreamVisitor; +import org.junit.jupiter.api.Test; + public class PropertyConfigReaderTest { @Test public void readerTest() throws ConfigException{ @@ -46,7 +47,7 @@ public String lookup(String key) { config.accept(new PrintStreamVisitor()); - assertThat(Arrays.asList("b"), is(config.getList("application.list", String.class))); + assertThat(Collections.singletonList("b"), is(config.getList("application.list", String.class))); assertThat(Arrays.asList("a", "b"), equalTo(config.getList("application.list2", String.class))); // assertThat(Arrays.asList("b"), config.getList("application.map")); assertThat(Arrays.asList("a", "b"), is(config.getList("application.set", String.class))); @@ -65,7 +66,7 @@ public void loadAtNext() throws ConfigException { Config config = reader.load(null, "test", CommonsStrInterpolator.INSTANCE, ConfigStrLookup.from(mainConfig)); config.accept(new PrintStreamVisitor()); - Assert.assertEquals("test-us-east-1.properties", config.getString("cascaded.property")); + assertEquals("test-us-east-1.properties", config.getString("cascaded.property")); } @Test @@ -76,7 +77,7 @@ public void loadMultipleAtNext() throws ConfigException { Config config = reader.load(null, "override", CommonsStrInterpolator.INSTANCE, ConfigStrLookup.from(mainConfig)); config.accept(new PrintStreamVisitor()); - Assert.assertEquals("200", config.getString("cascaded.property")); - Assert.assertEquals("true", config.getString("override.internal.style.next")); + assertEquals("200", config.getString("cascaded.property")); + assertEquals("true", config.getString("override.internal.style.next")); } } diff --git a/archaius2-core/src/test/java/com/netflix/archaius/mapper/ProxyFactoryTest.java b/archaius2-core/src/test/java/com/netflix/archaius/mapper/ProxyFactoryTest.java index 0a9b4460a..06b94b2f7 100644 --- a/archaius2-core/src/test/java/com/netflix/archaius/mapper/ProxyFactoryTest.java +++ b/archaius2-core/src/test/java/com/netflix/archaius/mapper/ProxyFactoryTest.java @@ -27,13 +27,12 @@ import com.netflix.archaius.api.exceptions.ConfigException; import com.netflix.archaius.config.EmptyConfig; import com.netflix.archaius.config.MapConfig; - -import org.junit.Test; +import org.junit.jupiter.api.Test; import java.util.Properties; public class ProxyFactoryTest { - public static interface MyConfigWithInterpolation { + public interface MyConfigWithInterpolation { @DefaultValue("default") String getString(); @@ -169,8 +168,8 @@ public void testProxy() throws ConfigException { ConfigProxyFactory proxy = new ConfigProxyFactory(config, config.getDecoder(), new DefaultPropertyFactory(config.getPrefixedView("prefix"))); MyConfigWithInterpolation c = proxy.newProxy(MyConfigWithInterpolation.class); - assertThat((long)c.getLong(), equalTo(1L)); - + assertThat(c.getLong(), equalTo(1L)); + assertThat(c.getString(), equalTo("loaded")); assertThat(c.getInterpolatedDefaultValue(), equalTo("replaced")); assertThat(c.getRenamed(), equalTo("loaded")); @@ -195,7 +194,7 @@ public void testProxy() throws ConfigException { } @Test - public void testProxyWithDefaults() throws ConfigException{ + public void testProxyWithDefaults() { Config config = EmptyConfig.INSTANCE; ConfigProxyFactory proxy = new ConfigProxyFactory(config, config.getDecoder(), new DefaultPropertyFactory(config.getPrefixedView("prefix"))); @@ -218,7 +217,5 @@ public void testProxyWithDefaults() throws ConfigException{ assertThat(c.getDouble(), equalTo(3.1)); assertThat(c.getDouble2(), nullValue()); - - System.out.println(c.toString()); } } diff --git a/archaius2-core/src/test/java/com/netflix/archaius/property/PropertiesServerHandler.java b/archaius2-core/src/test/java/com/netflix/archaius/property/PropertiesServerHandler.java index a64b96423..96df93274 100644 --- a/archaius2-core/src/test/java/com/netflix/archaius/property/PropertiesServerHandler.java +++ b/archaius2-core/src/test/java/com/netflix/archaius/property/PropertiesServerHandler.java @@ -67,6 +67,7 @@ public void setResponseCode(int code) { public void clear() { this.props.clear(); + this.responseCode = 200; } public void remove(String key) { diff --git a/archaius2-core/src/test/java/com/netflix/archaius/property/PropertyTest.java b/archaius2-core/src/test/java/com/netflix/archaius/property/PropertyTest.java index 282a97e9c..9b453b911 100644 --- a/archaius2-core/src/test/java/com/netflix/archaius/property/PropertyTest.java +++ b/archaius2-core/src/test/java/com/netflix/archaius/property/PropertyTest.java @@ -31,8 +31,6 @@ import java.util.function.Consumer; import java.util.function.Function; -import org.junit.Assert; -import org.junit.Test; import org.mockito.Mockito; import com.netflix.archaius.DefaultPropertyFactory; @@ -46,9 +44,14 @@ import com.netflix.archaius.config.DefaultSettableConfig; import com.netflix.archaius.config.MapConfig; -import static junit.framework.TestCase.assertEquals; -import static junit.framework.TestCase.fail; -import static org.junit.Assert.assertNotEquals; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.fail; @SuppressWarnings("deprecation") public class PropertyTest { @@ -98,15 +101,15 @@ public void test() throws ConfigException { MyService service = new MyService(factory); - Assert.assertEquals(1, (int)service.value.get()); - Assert.assertEquals(2, (int)service.value2.get()); + assertEquals(1, (int)service.value.get()); + assertEquals(2, (int)service.value2.get()); config.setProperty("foo", "123"); - Assert.assertEquals(123, (int)service.value.get()); - Assert.assertEquals(123, (int)service.value2.get()); + assertEquals(123, (int)service.value.get()); + assertEquals(123, (int)service.value2.get()); // setValue() is called once when we init to 1 and twice when we set foo to 123. - Assert.assertEquals(1, service.setValueCallsCounter.get()); + assertEquals(1, service.setValueCallsCounter.get()); } @Test @@ -131,17 +134,17 @@ public void testBasicTypes() { Property stringProp = factory.getProperty("foo").asType(String.class, "1"); Property customTypeProp = factory.getProperty("loo").asType(CustomType.class, CustomType.DEFAULT); - Assert.assertEquals(BigDecimal.TEN, bigDecimalProp.get()); - Assert.assertEquals(BigInteger.TEN, bigIntegerProp.get()); - Assert.assertEquals(true, booleanProp.get()); - Assert.assertEquals(10, byteProp.get().byteValue()); - Assert.assertEquals(10.0, doubleProp.get(), 0.0001); - Assert.assertEquals(10.0f, floatProp.get(), 0.0001f); - Assert.assertEquals(10, intProp.get().intValue()); - Assert.assertEquals(10L, longProp.get().longValue()); - Assert.assertEquals((short) 10, shortProp.get().shortValue()); - Assert.assertEquals("10", stringProp.get()); - Assert.assertEquals(CustomType.ONE_TWO, customTypeProp.get()); + assertEquals(BigDecimal.TEN, bigDecimalProp.get()); + assertEquals(BigInteger.TEN, bigIntegerProp.get()); + assertEquals(true, booleanProp.get()); + assertEquals(10, byteProp.get().byteValue()); + assertEquals(10.0, doubleProp.get(), 0.0001); + assertEquals(10.0f, floatProp.get(), 0.0001f); + assertEquals(10, intProp.get().intValue()); + assertEquals(10L, longProp.get().longValue()); + assertEquals((short) 10, shortProp.get().shortValue()); + assertEquals("10", stringProp.get()); + assertEquals(CustomType.ONE_TWO, customTypeProp.get()); } @Test @@ -153,36 +156,36 @@ public void testCollectionTypes() { // Test array decoding Property byteArray = factory.get("foo", Byte[].class); - Assert.assertEquals(new Byte[] {10, 13, 13, 20}, byteArray.get()); + assertArrayEquals(new Byte[] {10, 13, 13, 20}, byteArray.get()); // Tests list creation and parsing, decoding of list elements, proper handling if user gives us a primitive type Property> intList = factory.getList("foo", int.class); - Assert.assertEquals(Arrays.asList(10, 13, 13, 20), intList.get()); + assertEquals(Arrays.asList(10, 13, 13, 20), intList.get()); // Tests set creation, parsing non-int elements Property> doubleSet = factory.getSet("foo", Double.class); - Assert.assertEquals(new HashSet<>(Arrays.asList(10.0, 13.0, 20.0)), doubleSet.get()); + assertEquals(new HashSet<>(Arrays.asList(10.0, 13.0, 20.0)), doubleSet.get()); // Test map creation and parsing, keys and values of less-common types Property> mapProp = factory.getMap("shmoo", Short.class, Duration.class); Map expectedMap = new HashMap<>(); expectedMap.put((short) 1, Duration.ofMinutes(15)); expectedMap.put((short) 0, Duration.ZERO); - Assert.assertEquals(expectedMap, mapProp.get()); + assertEquals(expectedMap, mapProp.get()); // Test proper handling of unset properties Property> emptyProperty = factory.getMap("fubar", CustomType.class, CustomType.class); - Assert.assertNull(emptyProperty.get()); + assertNull(emptyProperty.get()); config.setProperty("fubar", ""); Property> emptyListProperty = factory.getList("fubar", String.class); - Assert.assertEquals(Collections.emptyList(), emptyListProperty.get()); + assertEquals(Collections.emptyList(), emptyListProperty.get()); Property> emptySetProperty = factory.getSet("fubar", String.class); - Assert.assertEquals(Collections.emptySet(), emptySetProperty.get()); + assertEquals(Collections.emptySet(), emptySetProperty.get()); Property> emptyMapProperty = factory.getMap("fubar", String.class, String.class); - Assert.assertEquals(Collections.emptyMap(), emptyMapProperty.get()); + assertEquals(Collections.emptyMap(), emptyMapProperty.get()); } @Test @@ -194,22 +197,22 @@ public void testCollectionTypesImmutability() { config.setProperty("baz", "a=1,b=2"); List list = factory.getList("foo", Integer.class).get(); - Assert.assertThrows(UnsupportedOperationException.class, () -> list.add(100)); + assertThrows(UnsupportedOperationException.class, () -> list.add(100)); Set set = factory.getSet("foo", Integer.class).get(); - Assert.assertThrows(UnsupportedOperationException.class, () -> set.add(100)); + assertThrows(UnsupportedOperationException.class, () -> set.add(100)); Map map = factory.getMap("baz", String.class, Integer.class).get(); - Assert.assertThrows(UnsupportedOperationException.class, () -> map.put("c", 3)); + assertThrows(UnsupportedOperationException.class, () -> map.put("c", 3)); List emptyList = factory.getList("bar", Integer.class).get(); - Assert.assertThrows(UnsupportedOperationException.class, () -> emptyList.add(100)); + assertThrows(UnsupportedOperationException.class, () -> emptyList.add(100)); Set emptySet = factory.getSet("bar", Integer.class).get(); - Assert.assertThrows(UnsupportedOperationException.class, () -> emptySet.add(100)); + assertThrows(UnsupportedOperationException.class, () -> emptySet.add(100)); Map emptyMap = factory.getMap("bar", String.class, Integer.class).get(); - Assert.assertThrows(UnsupportedOperationException.class, () -> emptyMap.put("c", 3)); + assertThrows(UnsupportedOperationException.class, () -> emptyMap.put("c", 3)); } @Test @@ -221,14 +224,14 @@ public void testUpdateDynamicChild() { Property intProp2 = factory.getProperty("foo").asInteger(2); Property strProp = factory.getProperty("foo").asString("3"); - Assert.assertEquals(1, (int)intProp1.get()); - Assert.assertEquals(2, (int)intProp2.get()); + assertEquals(1, (int)intProp1.get()); + assertEquals(2, (int)intProp2.get()); config.setProperty("foo", "123"); - Assert.assertEquals("123", strProp.get()); - Assert.assertEquals((Integer)123, intProp1.get()); - Assert.assertEquals((Integer)123, intProp2.get()); + assertEquals("123", strProp.get()); + assertEquals((Integer)123, intProp1.get()); + assertEquals((Integer)123, intProp2.get()); } @Test @@ -237,7 +240,7 @@ public void testDefaultNull() { DefaultPropertyFactory factory = DefaultPropertyFactory.from(config); Property prop = factory.getProperty("foo").asInteger(null); - Assert.assertNull(prop.get()); + assertNull(prop.get()); } @Test @@ -246,7 +249,7 @@ public void testDefault() { DefaultPropertyFactory factory = DefaultPropertyFactory.from(config); Property prop = factory.getProperty("foo").asInteger(123); - Assert.assertEquals(123, prop.get().intValue()); + assertEquals(123, prop.get().intValue()); } @Test @@ -259,13 +262,13 @@ public void testUpdateValue() { Property prop = factory.getProperty("foo").asInteger(123); config.setProperty("foo", 1); - Assert.assertEquals(1, prop.get().intValue()); + assertEquals(1, prop.get().intValue()); config.clearProperty("foo"); - Assert.assertEquals(123, prop.get().intValue()); + assertEquals(123, prop.get().intValue()); config.setProperty("foo", "${goo}"); - Assert.assertEquals(456, prop.get().intValue()); + assertEquals(456, prop.get().intValue()); } @@ -290,15 +293,15 @@ public void onParseError(Throwable error) { }); current.set(prop.get()); - Assert.assertEquals(123, current.get().intValue()); + assertEquals(123, current.get().intValue()); config.setProperty("foo", 1); - Assert.assertEquals(1, current.get().intValue()); + assertEquals(1, current.get().intValue()); config.setProperty("foo", 2); - Assert.assertEquals(2, current.get().intValue()); + assertEquals(2, current.get().intValue()); config.clearProperty("foo"); - Assert.assertEquals(123, current.get().intValue()); + assertEquals(123, current.get().intValue()); config.setProperty("foo", "${goo}"); - Assert.assertEquals(456, current.get().intValue()); + assertEquals(456, current.get().intValue()); } @Test @@ -336,11 +339,11 @@ public void subscribePropertyChange() { AtomicInteger value = new AtomicInteger(); prop.subscribe(value::set); - Assert.assertEquals(2, prop.get().intValue()); - Assert.assertEquals(0, value.get()); + assertEquals(2, prop.get().intValue()); + assertEquals(0, value.get()); config.setProperty("foo", "1"); - Assert.assertEquals(1, prop.get().intValue()); - Assert.assertEquals(1, value.get()); + assertEquals(1, prop.get().intValue()); + assertEquals(1, value.get()); } @Test @@ -375,7 +378,7 @@ public void chainedPropertyNoneSet() { .get("first", Integer.class) .orElseGet("second"); - Assert.assertNull(prop.get()); + assertNull(prop.get()); } @Test @@ -388,7 +391,7 @@ public void chainedPropertyDefault() { .orElseGet("second") .orElse(3); - Assert.assertEquals(3, prop.get().intValue()); + assertEquals(3, prop.get().intValue()); } @Test @@ -401,7 +404,7 @@ public void chainedPropertySecondSet() { .orElseGet("second") .orElse(3); - Assert.assertEquals(2, prop.get().intValue()); + assertEquals(2, prop.get().intValue()); } @Test @@ -414,7 +417,7 @@ public void chainedPropertyFirstSet() { .orElseGet("second") .orElse(3); - Assert.assertEquals(1, prop.get().intValue()); + assertEquals(1, prop.get().intValue()); } @Test @@ -477,36 +480,34 @@ public Integer apply(String t) { Mockito.verify(mapper, Mockito.never()).apply(Mockito.anyString()); - Assert.assertEquals(1, prop.get().intValue()); + assertEquals(1, prop.get().intValue()); Mockito.verify(mapper, Mockito.times(1)).apply("1"); - Assert.assertEquals(1, prop.get().intValue()); + assertEquals(1, prop.get().intValue()); Mockito.verify(mapper, Mockito.times(1)).apply("1"); config.setProperty("foo", "2"); - Assert.assertEquals(2, prop.get().intValue()); + assertEquals(2, prop.get().intValue()); Mockito.verify(mapper, Mockito.times(1)).apply("1"); Mockito.verify(mapper, Mockito.times(1)).apply("2"); config.setProperty("bar", "3"); - Assert.assertEquals(2, prop.get().intValue()); + assertEquals(2, prop.get().intValue()); Mockito.verify(mapper, Mockito.times(1)).apply("1"); Mockito.verify(mapper, Mockito.times(2)).apply("2"); } - @Test(expected=IllegalStateException.class) + @Test public void mapDiscardsType() { MapConfig config = MapConfig.builder().build(); DefaultPropertyFactory factory = DefaultPropertyFactory.from(config); - //noinspection unused - Property prop = factory + assertThrows(IllegalStateException.class, () -> factory .get("first", String.class) .orElseGet("second") .map(Integer::parseInt) - .orElseGet("third") - ; + .orElseGet("third")); } @Test @@ -515,7 +516,7 @@ public void customMappingWithDefault() { PropertyFactory factory = DefaultPropertyFactory.from(config); Integer value = factory.getProperty("a").asType(Integer::parseInt, "1").get(); - Assert.assertEquals(1, value.intValue()); + assertEquals(1, value.intValue()); } @Test @@ -526,7 +527,7 @@ public void customMapping() { PropertyFactory factory = DefaultPropertyFactory.from(config); Integer value = factory.getProperty("a").asType(Integer::parseInt, "1").get(); - Assert.assertEquals(2, value.intValue()); + assertEquals(2, value.intValue()); } @Test @@ -537,7 +538,7 @@ public void customMappingWithError() { PropertyFactory factory = DefaultPropertyFactory.from(config); Integer value = factory.getProperty("a").asType(Integer::parseInt, "1").get(); - Assert.assertEquals(1, value.intValue()); + assertEquals(1, value.intValue()); } @Test diff --git a/archaius2-core/src/test/java/com/netflix/archaius/readers/URLConfigReaderTest.java b/archaius2-core/src/test/java/com/netflix/archaius/readers/URLConfigReaderTest.java index 637cf7da9..73ef2bcae 100644 --- a/archaius2-core/src/test/java/com/netflix/archaius/readers/URLConfigReaderTest.java +++ b/archaius2-core/src/test/java/com/netflix/archaius/readers/URLConfigReaderTest.java @@ -1,9 +1,9 @@ package com.netflix.archaius.readers; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Test; -import java.net.MalformedURLException; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; /** * @author Nikos Michalakis @@ -15,15 +15,15 @@ public void testStringConstructorCommonCase() { final String url1 = "http://hello:8080/hey"; final String url2 = "http://hello:8080/heytoo"; URLConfigReader reader1 = new URLConfigReader(url1); - Assert.assertEquals(url1, reader1.getConfigUrls().get(0).toString()); + assertEquals(url1, reader1.getConfigUrls().get(0).toString()); URLConfigReader reader2 = new URLConfigReader(url1, url2); - Assert.assertEquals(url1, reader2.getConfigUrls().get(0).toString()); - Assert.assertEquals(url2, reader2.getConfigUrls().get(1).toString()); + assertEquals(url1, reader2.getConfigUrls().get(0).toString()); + assertEquals(url2, reader2.getConfigUrls().get(1).toString()); } - @Test(expected = RuntimeException.class) + @Test public void testStringConstructorMalformedUrl() { - new URLConfigReader("bad url"); + assertThrows(RuntimeException.class, () -> new URLConfigReader("bad url")); } } diff --git a/archaius2-core/src/test/java/com/netflix/archaius/visitor/VisitorTest.java b/archaius2-core/src/test/java/com/netflix/archaius/visitor/VisitorTest.java index 21be2f45a..0ab13b8bd 100644 --- a/archaius2-core/src/test/java/com/netflix/archaius/visitor/VisitorTest.java +++ b/archaius2-core/src/test/java/com/netflix/archaius/visitor/VisitorTest.java @@ -5,12 +5,14 @@ import java.util.List; import com.netflix.archaius.config.DefaultCompositeConfig; -import org.junit.Assert; -import org.junit.Test; import com.netflix.archaius.api.config.CompositeConfig; import com.netflix.archaius.config.MapConfig; import com.netflix.archaius.api.exceptions.ConfigException; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; public class VisitorTest { @Test @@ -19,7 +21,7 @@ public void testNotFound() throws ConfigException { LinkedHashMap sources = config.accept(new PropertyOverrideVisitor("foo")); - Assert.assertNull(sources); + assertNull(sources); } @@ -29,13 +31,13 @@ public void testOverrideVisitor() throws ConfigException { LinkedHashMap sources = config.accept(new PropertyOverrideVisitor("foo")); - Assert.assertEquals("a_foo", config.getString("foo")); + assertEquals("a_foo", config.getString("foo")); LinkedHashMap expected = new LinkedHashMap<>(); expected.put("a", "a_foo"); expected.put("b", "b_foo"); expected.put("c/d", "d_foo"); - Assert.assertEquals(expected, sources); + assertEquals(expected, sources); System.out.println(expected); } @@ -44,7 +46,7 @@ public void testOverrideVisitor() throws ConfigException { public void testFlattenedNames() throws ConfigException { CompositeConfig config = createComposite(); List result = config.accept(new FlattenedNamesVisitor()); - Assert.assertEquals(Arrays.asList("a", "b", "gap", "c", "d"), result); + assertEquals(Arrays.asList("a", "b", "gap", "c", "d"), result); } /* diff --git a/archaius2-guice/src/test/java/com/netflix/archaius/guice/ArchaiusModuleTest.java b/archaius2-guice/src/test/java/com/netflix/archaius/guice/ArchaiusModuleTest.java index 00b3686ad..6c7942d05 100644 --- a/archaius2-guice/src/test/java/com/netflix/archaius/guice/ArchaiusModuleTest.java +++ b/archaius2-guice/src/test/java/com/netflix/archaius/guice/ArchaiusModuleTest.java @@ -19,11 +19,6 @@ import javax.inject.Inject; -import com.netflix.archaius.DefaultConfigLoader; -import com.netflix.archaius.api.exceptions.ConfigException; -import org.junit.Assert; -import org.junit.Test; - import com.google.inject.AbstractModule; import com.google.inject.Guice; import com.google.inject.Injector; @@ -47,6 +42,11 @@ import com.netflix.archaius.config.MapConfig; import com.netflix.archaius.exceptions.MappingException; import com.netflix.archaius.visitor.PrintStreamVisitor; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; public class ArchaiusModuleTest { @@ -131,21 +131,21 @@ protected void configureArchaius() { }); Config config = injector.getInstance(Config.class); - Assert.assertEquals("prod", config.getString("env")); + assertEquals("prod", config.getString("env")); config.accept(new PrintStreamVisitor(System.err)); MyService service = injector.getInstance(MyService.class); - Assert.assertTrue(service.getValue()); + assertTrue(service.getValue()); MyServiceConfig serviceConfig = injector.getInstance(MyServiceConfig.class); - Assert.assertEquals("str_value", serviceConfig.str_value); - Assert.assertEquals(123, serviceConfig.int_value.intValue()); - Assert.assertEquals(true, serviceConfig.bool_value); - Assert.assertEquals(456.0, serviceConfig.double_value, 0); + assertEquals("str_value", serviceConfig.str_value); + assertEquals(123, serviceConfig.int_value.intValue()); + assertEquals(true, serviceConfig.bool_value); + assertEquals(456.0, serviceConfig.double_value, 0); - Assert.assertTrue(config.getBoolean("moduleTest.loaded")); - Assert.assertTrue(config.getBoolean("moduleTest-prod.loaded")); + assertTrue(config.getBoolean("moduleTest.loaded")); + assertTrue(config.getBoolean("moduleTest-prod.loaded")); } @Test @@ -171,11 +171,11 @@ protected void configure() { ); MyService service = injector.getInstance(MyService.class); - Assert.assertTrue(service.getValue()); + assertTrue(service.getValue()); MyServiceConfig serviceConfig = injector.getInstance(MyServiceConfig.class); - Assert.assertTrue(serviceConfig.named instanceof Named1); + assertTrue(serviceConfig.named instanceof Named1); } @Configuration(prefix="prefix.${name}.${id}", params={"name", "id"}, allowFields=true) @@ -200,7 +200,7 @@ public void testPrefixReplacements() throws MappingException { ChildService service = new ChildService("foo", 123L); binder.mapConfig(service, config); - Assert.assertEquals("loaded", service.loaded); + assertEquals("loaded", service.loaded); } public static interface TestProxyConfig { @@ -230,21 +230,21 @@ public TestProxyConfig getProxyConfig(ConfigProxyFactory factory) { SettableConfig settableConfig = injector.getInstance(Key.get(SettableConfig.class, RuntimeLayer.class)); TestProxyConfig object = injector.getInstance(TestProxyConfig.class); - Assert.assertEquals("default", object.getString()); - Assert.assertArrayEquals(new String[]{"foo", "bar"}, object.getStringArray()); - Assert.assertArrayEquals(new Integer[]{1,2}, object.getIntArray()); + assertEquals("default", object.getString()); + assertArrayEquals(new String[]{"foo", "bar"}, object.getStringArray()); + assertArrayEquals(new Integer[]{1,2}, object.getIntArray()); settableConfig.setProperty("string", "new"); settableConfig.setProperty("stringArray", "foonew,barnew"); settableConfig.setProperty("intArray", "3,4"); config.accept(new PrintStreamVisitor()); - Assert.assertEquals("new", object.getString()); - Assert.assertArrayEquals(new String[]{"foonew", "barnew"}, object.getStringArray()); - Assert.assertArrayEquals(new Integer[]{3,4}, object.getIntArray()); + assertEquals("new", object.getString()); + assertArrayEquals(new String[]{"foonew", "barnew"}, object.getStringArray()); + assertArrayEquals(new Integer[]{3,4}, object.getIntArray()); settableConfig.clearProperty("string"); - Assert.assertEquals("default", object.getString()); + assertEquals("default", object.getString()); } @Test @@ -272,7 +272,7 @@ protected void configureArchaius() { }); Config config = injector.getInstance(Config.class); - Assert.assertEquals("override", config.getString("a")); + assertEquals("override", config.getString("a")); } @Test @@ -284,7 +284,7 @@ public void testBasicLibraryOverride() { injector.getInstance(MyServiceConfig.class); Config config = injector.getInstance(Config.class); - Assert.assertEquals("fromFile", config.getString("moduleTest.prop1")); + assertEquals("fromFile", config.getString("moduleTest.prop1")); } @Test @@ -312,7 +312,7 @@ protected void configure() { Config config = injector.getInstance(Config.class); injector.getInstance(MyServiceConfig.class); config.accept(new PrintStreamVisitor()); - Assert.assertEquals("fromOverride", config.getString("moduleTest.prop1")); + assertEquals("fromOverride", config.getString("moduleTest.prop1")); } @Test @@ -337,12 +337,12 @@ public TestProxyConfig getProxyConfig(ConfigProxyFactory factory) { ); Config config = injector.getInstance(Config.class); - Assert.assertEquals("override", config.getString("a")); + assertEquals("override", config.getString("a")); TestProxyConfig configProxy = injector.getInstance(TestProxyConfig.class); - Assert.assertEquals("default", configProxy.getString()); - Assert.assertArrayEquals(new String[]{"foo", "bar"}, configProxy.getStringArray()); - Assert.assertArrayEquals(new Integer[]{1,2}, configProxy.getIntArray()); + assertEquals("default", configProxy.getString()); + assertArrayEquals(new String[]{"foo", "bar"}, configProxy.getStringArray()); + assertArrayEquals(new Integer[]{1,2}, configProxy.getIntArray()); } @Test @@ -354,8 +354,8 @@ protected void configureArchaius() { } }); Config config = injector.getInstance(Config.class); - Assert.assertEquals("b_value_no_override", config.getString("b")); - Assert.assertEquals("a_value_override", config.getString("a")); - Assert.assertEquals("c_value_override", config.getString("c")); + assertEquals("b_value_no_override", config.getString("b")); + assertEquals("a_value_override", config.getString("a")); + assertEquals("c_value_override", config.getString("c")); } } diff --git a/archaius2-guice/src/test/java/com/netflix/archaius/guice/ConfigurationInjectingListenerTest.java b/archaius2-guice/src/test/java/com/netflix/archaius/guice/ConfigurationInjectingListenerTest.java index 6112a73c9..dcc7cb8c2 100644 --- a/archaius2-guice/src/test/java/com/netflix/archaius/guice/ConfigurationInjectingListenerTest.java +++ b/archaius2-guice/src/test/java/com/netflix/archaius/guice/ConfigurationInjectingListenerTest.java @@ -5,9 +5,9 @@ import com.netflix.archaius.api.Config; import com.netflix.archaius.api.annotations.ConfigurationSource; import com.netflix.archaius.visitor.PrintStreamVisitor; +import org.junit.jupiter.api.Test; -import org.junit.Assert; -import org.junit.Test; +import static org.junit.jupiter.api.Assertions.assertEquals; public class ConfigurationInjectingListenerTest { @@ -23,6 +23,6 @@ public void confirmLoadOrder() { Config config = injector.getInstance(Config.class); config.accept(new PrintStreamVisitor()); - Assert.assertEquals("prod", config.getString("moduleTest.value")); + assertEquals("prod", config.getString("moduleTest.value")); } } diff --git a/archaius2-guice/src/test/java/com/netflix/archaius/guice/InternalArchaiusModuleTest.java b/archaius2-guice/src/test/java/com/netflix/archaius/guice/InternalArchaiusModuleTest.java index b8f160668..078117d31 100644 --- a/archaius2-guice/src/test/java/com/netflix/archaius/guice/InternalArchaiusModuleTest.java +++ b/archaius2-guice/src/test/java/com/netflix/archaius/guice/InternalArchaiusModuleTest.java @@ -1,7 +1,7 @@ package com.netflix.archaius.guice; import com.google.inject.Guice; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class InternalArchaiusModuleTest { diff --git a/archaius2-guice/src/test/java/com/netflix/archaius/guice/ProxyTest.java b/archaius2-guice/src/test/java/com/netflix/archaius/guice/ProxyTest.java index 31d4753e8..5cfe267c4 100644 --- a/archaius2-guice/src/test/java/com/netflix/archaius/guice/ProxyTest.java +++ b/archaius2-guice/src/test/java/com/netflix/archaius/guice/ProxyTest.java @@ -17,11 +17,14 @@ import com.netflix.archaius.guice.ArchaiusModuleTest.MyCascadingStrategy; import com.netflix.archaius.visitor.PrintStreamVisitor; -import org.junit.Assert; -import org.junit.Test; - import javax.inject.Singleton; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; + public class ProxyTest { public static interface MyConfig { @DefaultValue("0") @@ -36,13 +39,13 @@ default String getDefault() { } } - public static interface MySubConfig { + public interface MySubConfig { @DefaultValue("0") int getInteger(); } @Configuration(prefix="foo") - public static interface MyConfigWithPrefix { + public interface MyConfigWithPrefix { @DefaultValue("0") int getInteger(); @@ -72,13 +75,13 @@ public MyConfig getMyConfig(ConfigProxyFactory factory) { SettableConfig cfg = injector.getInstance(Key.get(SettableConfig.class, RuntimeLayer.class)); MyConfig config = injector.getInstance(MyConfig.class); - Assert.assertEquals("bar", config.getString()); - Assert.assertEquals(1, config.getInteger()); - Assert.assertEquals(2, config.getSubConfig().getInteger()); - Assert.assertEquals("1-bar", config.getDefault()); + assertEquals("bar", config.getString()); + assertEquals(1, config.getInteger()); + assertEquals(2, config.getSubConfig().getInteger()); + assertEquals("1-bar", config.getDefault()); cfg.setProperty("subConfig.integer", 3); - Assert.assertEquals(3, config.getSubConfig().getInteger()); + assertEquals(3, config.getSubConfig().getInteger()); } @Test @@ -101,8 +104,8 @@ public MyConfig getMyConfig(ConfigProxyFactory factory) { }); MyConfig config = injector.getInstance(MyConfig.class); - Assert.assertEquals("bar", config.getString()); - Assert.assertEquals(1, config.getInteger()); + assertEquals("bar", config.getString()); + assertEquals(1, config.getInteger()); } @Configuration(prefix="prefix-${env}", allowFields=true) @@ -124,13 +127,13 @@ public ModuleTestConfig getMyConfig(ConfigProxyFactory factory) { }); ModuleTestConfig config = injector.getInstance(ModuleTestConfig.class); - Assert.assertTrue(config.isLoaded()); - Assert.assertEquals("fromFile", config.getProp1()); + assertTrue(config.isLoaded()); + assertEquals("fromFile", config.getProp1()); injector.getInstance(Config.class).accept(new PrintStreamVisitor()); } - public static interface DefaultMethodWithAnnotation { + public interface DefaultMethodWithAnnotation { @DefaultValue("fromAnnotation") default String getValue() { return "fromDefault"; @@ -154,12 +157,12 @@ public DefaultMethodWithAnnotation getMyConfig(ConfigProxyFactory factory) { }); injector.getInstance(DefaultMethodWithAnnotation.class); - Assert.fail("Exepcted ProvisionException"); + fail("Exepcted ProvisionException"); } catch (ProvisionException e) { e.printStackTrace(); - Assert.assertEquals(IllegalArgumentException.class, e.getCause().getCause().getClass()); + assertEquals(IllegalArgumentException.class, e.getCause().getCause().getClass()); } catch (Exception e) { - Assert.fail("Expected ProvisionException"); + fail("Expected ProvisionException"); } } } diff --git a/archaius2-persisted2/src/test/java/com/netflix/archaius/persisted2/FirstScopePropertyValueResolverTest.java b/archaius2-persisted2/src/test/java/com/netflix/archaius/persisted2/FirstScopePropertyValueResolverTest.java index 120a20876..73db8278e 100644 --- a/archaius2-persisted2/src/test/java/com/netflix/archaius/persisted2/FirstScopePropertyValueResolverTest.java +++ b/archaius2-persisted2/src/test/java/com/netflix/archaius/persisted2/FirstScopePropertyValueResolverTest.java @@ -1,25 +1,27 @@ package com.netflix.archaius.persisted2; import java.util.Arrays; +import java.util.Collections; import java.util.HashSet; import java.util.LinkedHashMap; import java.util.List; import java.util.Set; import org.apache.commons.lang3.StringUtils; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; public class FirstScopePropertyValueResolverTest { private final ScopePriorityPropertyValueResolver resolver = new ScopePriorityPropertyValueResolver(); @Test public void testSingle() { - List variations = Arrays.asList( - create("1", "s1", "a") + List variations = Collections.singletonList( + create("1", "s1", "a") ); - Assert.assertEquals("1", resolver.resolve("propName", variations)); + assertEquals("1", resolver.resolve("propName", variations)); } @Test @@ -29,7 +31,7 @@ public void testIdentical() { create("2", "s1", "a") ); - Assert.assertEquals("1", resolver.resolve("propName", variations)); + assertEquals("1", resolver.resolve("propName", variations)); } @Test @@ -39,7 +41,7 @@ public void testFirst() { create("2", "s1", "") ); - Assert.assertEquals("1", resolver.resolve("propName", variations)); + assertEquals("1", resolver.resolve("propName", variations)); } @Test @@ -49,7 +51,7 @@ public void testSecond() { create("2", "s1", "a") ); - Assert.assertEquals("2", resolver.resolve("propName", variations)); + assertEquals("2", resolver.resolve("propName", variations)); } @Test @@ -58,15 +60,14 @@ public void test2Scopes() { create("1", "s1", "", "s2", "", "s3", "b"), create("2", "s1", "", "s2", "a,b", "s3", "") ); - - Assert.assertEquals("2", resolver.resolve("propName", variations)); + + assertEquals("2", resolver.resolve("propName", variations)); } ScopedValue create(String value, String... keyValuePairs) { - LinkedHashMap> map = new LinkedHashMap>(); + LinkedHashMap> map = new LinkedHashMap<>(); for (int i = 0; i < keyValuePairs.length; i += 2) { - Set set = new HashSet(); - set.addAll(Arrays.asList(StringUtils.split(keyValuePairs[i+1], ","))); + Set set = new HashSet<>(Arrays.asList(StringUtils.split(keyValuePairs[i + 1], ","))); map.put(keyValuePairs[i], set); } return new ScopedValue(value, map); diff --git a/archaius2-persisted2/src/test/java/com/netflix/archaius/persisted2/JsonPersistedV2ReaderTest.java b/archaius2-persisted2/src/test/java/com/netflix/archaius/persisted2/JsonPersistedV2ReaderTest.java index d99949613..f62b830a1 100644 --- a/archaius2-persisted2/src/test/java/com/netflix/archaius/persisted2/JsonPersistedV2ReaderTest.java +++ b/archaius2-persisted2/src/test/java/com/netflix/archaius/persisted2/JsonPersistedV2ReaderTest.java @@ -2,14 +2,15 @@ import com.fasterxml.jackson.databind.ObjectMapper; import com.netflix.archaius.config.polling.PollingResponse; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Test; import java.io.ByteArrayInputStream; import java.util.ArrayList; import java.util.List; import java.util.Map; -import java.util.Optional; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; public class JsonPersistedV2ReaderTest { @Test @@ -33,13 +34,13 @@ public void idFieldReturnedWhenPresent() throws Exception { PollingResponse response = reader.call(); Map props = response.getToAdd(); - Assert.assertEquals(2, props.size()); - Assert.assertEquals("value1", props.get("key1")); - Assert.assertEquals("value2", props.get("key2")); + assertEquals(2, props.size()); + assertEquals("value1", props.get("key1")); + assertEquals("value2", props.get("key2")); Map propIds = response.getNameToIdsMap(); - Assert.assertEquals(2, propIds.size()); - Assert.assertEquals("id1", propIds.get("key1")); - Assert.assertEquals("id2", propIds.get("key2")); + assertEquals(2, propIds.size()); + assertEquals("id1", propIds.get("key1")); + assertEquals("id2", propIds.get("key2")); } @Test public void idFieldAbsent() throws Exception { @@ -61,10 +62,10 @@ public void idFieldAbsent() throws Exception { PollingResponse response = reader.call(); Map props = response.getToAdd(); - Assert.assertEquals(2, props.size()); - Assert.assertEquals("value1", props.get("key1")); - Assert.assertEquals("value2", props.get("key2")); - Assert.assertTrue(response.getNameToIdsMap().isEmpty()); + assertEquals(2, props.size()); + assertEquals("value1", props.get("key1")); + assertEquals("value2", props.get("key2")); + assertTrue(response.getNameToIdsMap().isEmpty()); } public static class TestPropertyList { diff --git a/archaius2-persisted2/src/test/java/com/netflix/archaius/persisted2/PlatformServiceTest.java b/archaius2-persisted2/src/test/java/com/netflix/archaius/persisted2/PlatformServiceTest.java index 0a7260de4..c4f04630b 100644 --- a/archaius2-persisted2/src/test/java/com/netflix/archaius/persisted2/PlatformServiceTest.java +++ b/archaius2-persisted2/src/test/java/com/netflix/archaius/persisted2/PlatformServiceTest.java @@ -1,8 +1,5 @@ package com.netflix.archaius.persisted2; -import org.junit.Ignore; -import org.junit.Test; - import com.google.inject.AbstractModule; import com.google.inject.Guice; import com.google.inject.Injector; @@ -12,12 +9,14 @@ import com.netflix.archaius.api.inject.RemoteLayer; import com.netflix.archaius.guice.ArchaiusModule; import com.netflix.archaius.visitor.PrintStreamVisitor; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; public class PlatformServiceTest { // TODO: Provide an embedded version of this service. For now these tests are run // manually against internal Netflix systems @Test - @Ignore + @Disabled public void test() throws ConfigException { final Persisted2ClientConfig config = new DefaultPersisted2ClientConfig() .withServiceUrl("http://platformservice.us-east-1.dyntest.netflix.net:7001/platformservice/REST/v2/properties/jsonFilterprops") diff --git a/archaius2-test/build.gradle b/archaius2-test/build.gradle index b8ba3bb9d..f4f27db3f 100644 --- a/archaius2-test/build.gradle +++ b/archaius2-test/build.gradle @@ -5,6 +5,8 @@ dependencies { api project(':archaius2-core') api 'junit:junit:4.13.2' implementation 'org.apache.commons:commons-lang3:3.3.2' + testImplementation 'junit:junit:4.13.2' + testRuntimeOnly 'org.junit.vintage:junit-vintage-engine' } eclipse { diff --git a/archaius2-test/src/main/java/com/netflix/archaius/test/ConfigInterfaceTest.java b/archaius2-test/src/main/java/com/netflix/archaius/test/ConfigInterfaceTest.java index e84e43924..5d547aadb 100644 --- a/archaius2-test/src/main/java/com/netflix/archaius/test/ConfigInterfaceTest.java +++ b/archaius2-test/src/main/java/com/netflix/archaius/test/ConfigInterfaceTest.java @@ -1,7 +1,6 @@ package com.netflix.archaius.test; import com.netflix.archaius.api.Config; - import org.junit.Test; import java.util.HashMap; diff --git a/build.gradle b/build.gradle index 738160a7f..bc3f59ecf 100644 --- a/build.gradle +++ b/build.gradle @@ -27,9 +27,10 @@ subprojects { dependencies { testImplementation 'org.slf4j:slf4j-reload4j:1.7.36' - testImplementation 'junit:junit:4.13.2' + testImplementation 'org.junit.jupiter:junit-jupiter-api:5.10.+' testImplementation 'org.hamcrest:hamcrest-all:1.3' testImplementation 'org.mockito:mockito-core:4.+' + testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.10.+' } group = "com.netflix.${githubProjectName}" @@ -38,6 +39,10 @@ subprojects { options.addStringOption('Xdoclint:none', '-quiet') } + test { + useJUnitPlatform() + } + tasks.withType(Test) { var testJdk = System.getProperty("testJdk", "8") System.console().printf("Launching tests using JDK %s%n", testJdk)