Skip to content

Commit

Permalink
Merge pull request #707 from Netflix/junit-5-missing-tests
Browse files Browse the repository at this point in the history 
Update some additional missed tests to junit5
  • Loading branch information
@rgallardo-netflix
rgallardo-netflix authored Feb 27, 2024
2 parents 483949d + 3e452b6 commit 443d562
Show file tree
Hide file tree
Showing 3 changed files with 61 additions and 55 deletions.
41 changes: 22 additions & 19 deletions archaius2-api/src/test/java/com/netflix/archaius/api/ArchaiusTypeTest.java
View file
Original file line number Diff line number Diff line change
@@ -1,54 +1,57 @@
package com.netflix.archaius.api;

import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;
import java.util.Set;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotSame;

public class ArchaiusTypeTest {
@Test
public void testEquals() {
ParameterizedType archaiusType = ArchaiusType.forListOf(String.class);
Assert.assertEquals(archaiusType, listOfString);
Assert.assertEquals(listOfString, archaiusType);
Assert.assertEquals(archaiusType, ArchaiusType.forListOf(String.class));
Assert.assertNotEquals(archaiusType, ArchaiusType.forListOf(Integer.class));
Assert.assertNotEquals(archaiusType, setOfLong);
assertEquals(archaiusType, listOfString);
assertEquals(listOfString, archaiusType);
assertEquals(archaiusType, ArchaiusType.forListOf(String.class));
assertNotEquals(archaiusType, ArchaiusType.forListOf(Integer.class));
assertNotEquals(archaiusType, setOfLong);
}

@Test
public void testHashCode() {
Assert.assertEquals(listOfString.hashCode(), ArchaiusType.forListOf(String.class).hashCode());
Assert.assertEquals(ArchaiusType.forListOf(String.class).hashCode(), ArchaiusType.forListOf(String.class).hashCode());
Assert.assertEquals(setOfLong.hashCode(), ArchaiusType.forSetOf(Long.class).hashCode());
Assert.assertEquals(ArchaiusType.forMapOf(Integer.class, CharSequence.class).hashCode(), mapOfIntToCharSequence.hashCode());
assertEquals(listOfString.hashCode(), ArchaiusType.forListOf(String.class).hashCode());
assertEquals(ArchaiusType.forListOf(String.class).hashCode(), ArchaiusType.forListOf(String.class).hashCode());
assertEquals(setOfLong.hashCode(), ArchaiusType.forSetOf(Long.class).hashCode());
assertEquals(ArchaiusType.forMapOf(Integer.class, CharSequence.class).hashCode(), mapOfIntToCharSequence.hashCode());
}

@Test
public void testToString() {
Assert.assertEquals("java.util.List<java.lang.String>", ArchaiusType.forListOf(String.class).toString());
Assert.assertEquals(listOfString.toString(), ArchaiusType.forListOf(String.class).toString());
Assert.assertEquals(setOfLong.toString(), ArchaiusType.forSetOf(Long.class).toString());
Assert.assertEquals(mapOfIntToCharSequence.toString(), ArchaiusType.forMapOf(Integer.class, CharSequence.class).toString());
assertEquals("java.util.List<java.lang.String>", ArchaiusType.forListOf(String.class).toString());
assertEquals(listOfString.toString(), ArchaiusType.forListOf(String.class).toString());
assertEquals(setOfLong.toString(), ArchaiusType.forSetOf(Long.class).toString());
assertEquals(mapOfIntToCharSequence.toString(), ArchaiusType.forMapOf(Integer.class, CharSequence.class).toString());
}

@Test
public void testPrimitiveType() {
Assert.assertEquals(setOfLong, ArchaiusType.forSetOf(long.class));
assertEquals(setOfLong, ArchaiusType.forSetOf(long.class));
}

@Test
public void testGetTypeParameters() {
ParameterizedType archaiusType = ArchaiusType.forSetOf(Long.class);
Type[] typeArguments = archaiusType.getActualTypeArguments();
// check that returned array is defensively copied
Assert.assertNotSame(typeArguments, archaiusType.getActualTypeArguments());
Assert.assertEquals(1, typeArguments.length);
Assert.assertEquals(Long.class, typeArguments[0]);
assertNotSame(typeArguments, archaiusType.getActualTypeArguments());
assertEquals(1, typeArguments.length);
assertEquals(Long.class, typeArguments[0]);
}

private static List<String> listOfString() { throw new AssertionError(); }
Expand Down
12 changes: 6 additions & 6 deletions archaius2-typesafe/src/test/java/com/netflix/archaius/typesafe/TypesafeConfigLoaderTest.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -16,14 +16,15 @@
package com.netflix.archaius.typesafe;

import com.netflix.archaius.config.DefaultCompositeConfig;
import org.junit.Assert;
import org.junit.Test;

import com.netflix.archaius.DefaultConfigLoader;
import com.netflix.archaius.cascade.ConcatCascadeStrategy;
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;

public class TypesafeConfigLoaderTest {
@Test
Expand All @@ -43,9 +44,8 @@ public void test() throws ConfigException {
.withCascadeStrategy(ConcatCascadeStrategy.from("${env}", "${region}"))
.load("foo"));

Assert.assertEquals("prod", config.getString("@environment"));
Assert.assertEquals("foo-prod", config.getString("foo.prop1"));
Assert.assertEquals("foo", config.getString("foo.prop2"));
assertEquals("prod", config.getString("@environment"));
assertEquals("foo-prod", config.getString("foo.prop1"));
assertEquals("foo", config.getString("foo.prop2"));
}

}
63 changes: 33 additions & 30 deletions archaius2-typesafe/src/test/java/com/netflix/archaius/typesafe/TypesafeConfigTest.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -16,81 +16,84 @@
package com.netflix.archaius.typesafe;

import com.netflix.archaius.api.Config;
import com.netflix.archaius.test.ConfigInterfaceTest;
import com.typesafe.config.ConfigFactory;
import org.junit.Assert;
import org.junit.Test;

import com.netflix.archaius.config.MapConfig;
import com.netflix.archaius.api.exceptions.ConfigException;
import org.junit.jupiter.api.Test;

import java.util.Iterator;
import java.util.Map;

public class TypesafeConfigTest extends ConfigInterfaceTest {
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 TypesafeConfigTest {
@Test
public void simple() throws ConfigException {
public void simple() {
Config config = new TypesafeConfig(ConfigFactory.parseString("a=b"));
Assert.assertEquals("b", config.getString("a"));
Assert.assertTrue(config.containsKey("a"));
assertEquals("b", config.getString("a"));
assertTrue(config.containsKey("a"));
assertFalse(config.containsKey("foo"));
assertEquals("bar", config.getString("foo", "bar"));
}

@Test
public void simplePath() throws ConfigException {
public void simplePath() {
Config config = new TypesafeConfig(ConfigFactory.parseString("a.b.c=foo"));
Assert.assertEquals("foo", config.getString("a.b.c"));
Assert.assertTrue(config.containsKey("a.b.c"));
assertEquals("foo", config.getString("a.b.c"));
assertTrue(config.containsKey("a.b.c"));
}

@Test
public void nested() throws ConfigException {
public void nested() {
Config config = new TypesafeConfig(ConfigFactory.parseString("a { b { c=foo } }"));
Assert.assertEquals("foo", config.getString("a.b.c"));
Assert.assertTrue(config.containsKey("a.b.c"));
assertEquals("foo", config.getString("a.b.c"));
assertTrue(config.containsKey("a.b.c"));
}

@Test
public void keyWithAt() throws ConfigException {
public void keyWithAt() {
Config config = new TypesafeConfig(ConfigFactory.parseString("\"@a\"=b"));
Assert.assertEquals("b", config.getString("@a"));
Assert.assertTrue(config.containsKey("@a"));
assertEquals("b", config.getString("@a"));
assertTrue(config.containsKey("@a"));
}

@Test
public void pathWithAt() throws ConfigException {
public void pathWithAt() {
Config config = new TypesafeConfig(ConfigFactory.parseString("a.\"@b\".c=foo"));
Assert.assertEquals("foo", config.getString("[email protected]"));
Assert.assertTrue(config.containsKey("[email protected]"));
assertEquals("foo", config.getString("[email protected]"));
assertTrue(config.containsKey("[email protected]"));
}

@Test
public void specialChars() throws ConfigException {
public void specialChars() {
for (char c = '!'; c <= '~'; ++c) {
if (c == '.') continue;
String k = c + "a";
String escaped = k.replace("\\", "\\\\").replace("\"", "\\\"");
Config mc = MapConfig.builder().put(k, "b").build();
Config tc = new TypesafeConfig(ConfigFactory.parseString("\"" + escaped + "\"=b"));
Assert.assertEquals(mc.getString(k), tc.getString(k));
Assert.assertEquals(mc.containsKey(k), tc.containsKey(k));
assertEquals(mc.getString(k), tc.getString(k));
assertEquals(mc.containsKey(k), tc.containsKey(k));
}
}

@Test
public void iterate() throws Exception {
public void iterate() {
Config config = new TypesafeConfig(ConfigFactory.parseString("a { \"@env\"=prod }"));
Assert.assertEquals("prod", config.getString("a.@env"));
assertEquals("prod", config.getString("a.@env"));

// Make sure we can get all keys we get back from the iterator
@SuppressWarnings("deprecation")
Iterator<String> ks = config.getKeys();
while (ks.hasNext()) {
String k = ks.next();
config.getString(k);
}
}

@Override
protected Config getInstance(Map<String, String> properties) {
return new TypesafeConfig(ConfigFactory.parseMap(properties));
Iterable<String> keysIterable = config.keys();
for (String key : keysIterable) {
config.getString(key);
}
}
}

0 comments on commit 443d562

Please sign in to comment.