kopia lustrzana https://github.com/onthegomap/planetiler
353 wiersze
11 KiB
Java
353 wiersze
11 KiB
Java
package com.onthegomap.planetiler.config;
|
|
|
|
import static org.junit.jupiter.api.Assertions.*;
|
|
|
|
import com.onthegomap.planetiler.ExpectedException;
|
|
import com.onthegomap.planetiler.TestUtils;
|
|
import com.onthegomap.planetiler.reader.osm.OsmInputFile;
|
|
import java.nio.file.Path;
|
|
import java.time.Duration;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
import org.junit.jupiter.api.Test;
|
|
import org.locationtech.jts.geom.Envelope;
|
|
|
|
class ArgumentsTest {
|
|
|
|
@Test
|
|
void testEmpty() {
|
|
assertEquals("fallback", Arguments.of().getString("key", "key", "fallback"));
|
|
}
|
|
|
|
@Test
|
|
void testMapBased() {
|
|
assertEquals("value", Arguments.of(
|
|
"key", "value"
|
|
).getString("key", "key", "fallback"));
|
|
}
|
|
|
|
@Test
|
|
void testOrElse() {
|
|
Arguments args = Arguments.of("key1", "value1a", "key2", "value2a")
|
|
.orElse(Arguments.of("key2", "value2b", "key3", "value3b"));
|
|
|
|
assertEquals("value1a", args.getString("key1", "key", "fallback"));
|
|
assertEquals("value2a", args.getString("key2", "key", "fallback"));
|
|
assertEquals("value3b", args.getString("key3", "key", "fallback"));
|
|
assertEquals("fallback", args.getString("key4", "key", "fallback"));
|
|
}
|
|
|
|
@Test
|
|
void testConfigFileParsing() {
|
|
Arguments args = Arguments.fromConfigFile(TestUtils.pathToResource("test.properties"));
|
|
|
|
assertEquals("value1fromfile", args.getString("key1", "key", "fallback"));
|
|
assertEquals("fallback", args.getString("key3", "key", "fallback"));
|
|
}
|
|
|
|
@Test
|
|
void testGetConfigFileFromArgs() {
|
|
Arguments args = Arguments.fromArgsOrConfigFile(
|
|
"config=" + TestUtils.pathToResource("test.properties"),
|
|
"key2=value2fromargs"
|
|
);
|
|
|
|
assertEquals("value1fromfile", args.getString("key1", "key", "fallback"));
|
|
assertEquals("value2fromargs", args.getString("key2", "key", "fallback"));
|
|
assertEquals("fallback", args.getString("key3", "key", "fallback"));
|
|
}
|
|
|
|
@Test
|
|
void testDefaultsMissingConfigFile() {
|
|
Arguments args = Arguments.fromArgsOrConfigFile(
|
|
"key=value"
|
|
);
|
|
|
|
assertEquals("value", args.getString("key", "key", "fallback"));
|
|
assertEquals("fallback", args.getString("key2", "key", "fallback"));
|
|
}
|
|
|
|
@Test
|
|
void testDuration() {
|
|
Arguments args = Arguments.of(
|
|
"duration", "1h30m"
|
|
);
|
|
|
|
assertEquals(Duration.ofMinutes(90), args.getDuration("duration", "key", "10m"));
|
|
assertEquals(Duration.ofSeconds(10), args.getDuration("duration2", "key", "10s"));
|
|
}
|
|
|
|
@Test
|
|
void testInteger() {
|
|
Arguments args = Arguments.of(
|
|
"integer", "30"
|
|
);
|
|
|
|
assertEquals(30, args.getInteger("integer", "key", 10));
|
|
assertEquals(10, args.getInteger("integer2", "key", 10));
|
|
}
|
|
|
|
@Test
|
|
void testLong() {
|
|
long maxInt = Integer.MAX_VALUE;
|
|
Arguments args = Arguments.of(
|
|
"long", Long.toString(maxInt * 2)
|
|
);
|
|
|
|
assertEquals(maxInt * 2, args.getLong("long", "key", maxInt + 1L));
|
|
assertEquals(maxInt + 1L, args.getLong("long2", "key", maxInt + 1L));
|
|
}
|
|
|
|
@Test
|
|
void testThreads() {
|
|
assertEquals(2, Arguments.of("threads", "2").threads());
|
|
assertTrue(Arguments.of().threads() > 0);
|
|
}
|
|
|
|
@Test
|
|
void testList() {
|
|
assertEquals(List.of("1", "2", "3"),
|
|
Arguments.of("list", "1,2,3").getList("list", "list", List.of("1")));
|
|
assertEquals(List.of("1"),
|
|
Arguments.of().getList("list", "list", List.of("1")));
|
|
}
|
|
|
|
@Test
|
|
void testBoolean() {
|
|
assertTrue(Arguments.of("boolean", "true").getBoolean("boolean", "list", false));
|
|
assertFalse(Arguments.of("boolean", "false").getBoolean("boolean", "list", true));
|
|
assertFalse(Arguments.of("boolean", "true1").getBoolean("boolean", "list", true));
|
|
assertFalse(Arguments.of().getBoolean("boolean", "list", false));
|
|
}
|
|
|
|
@Test
|
|
void testFile() {
|
|
assertNotNull(
|
|
Arguments.of("file", TestUtils.pathToResource("test.properties")).inputFile("file", "file", Path.of("")));
|
|
assertThrows(IllegalArgumentException.class,
|
|
() -> Arguments.of("file", TestUtils.pathToResource("test.Xproperties")).inputFile("file", "file", Path.of("")));
|
|
assertNotNull(
|
|
Arguments.of("file", TestUtils.pathToResource("test.Xproperties")).file("file", "file", Path.of("")));
|
|
}
|
|
|
|
@Test
|
|
void testBounds() {
|
|
assertEquals(new Envelope(1, 3, 2, 4),
|
|
new Bounds(Arguments.of("bounds", "1,2,3,4").bounds("bounds", "bounds")).latLon());
|
|
assertEquals(new Envelope(-180.0, 180.0, -85.0511287798066, 85.0511287798066),
|
|
new Bounds(Arguments.of("bounds", "world").bounds("bounds", "bounds")).latLon());
|
|
assertEquals(new Envelope(7.409205, 7.448637, 43.72335, 43.75169),
|
|
new Bounds(Arguments.of().bounds("bounds", "bounds"))
|
|
.addFallbackProvider(new OsmInputFile(TestUtils.pathToResource("monaco-latest.osm.pbf")))
|
|
.latLon());
|
|
}
|
|
|
|
@Test
|
|
void testStats() {
|
|
assertNotNull(Arguments.of().getStats());
|
|
}
|
|
|
|
@Test
|
|
void testArgsKeyPresentImplies() {
|
|
Arguments args = Arguments.fromArgs(
|
|
"--force"
|
|
);
|
|
|
|
assertTrue(args.getBoolean("force", "force", false));
|
|
}
|
|
|
|
@Test
|
|
void testUnderscoreDashSame() {
|
|
assertTrue(Arguments.fromArgs(
|
|
"--force-down-load=true"
|
|
).getBoolean("force_down_load", "force", false));
|
|
assertTrue(Arguments.fromArgs(
|
|
"--force-download=true"
|
|
).getBoolean("force_download", "force", false));
|
|
assertTrue(Arguments.fromArgs(
|
|
"--force_download=true"
|
|
).getBoolean("force-download", "force", false));
|
|
assertTrue(Arguments.fromArgs(
|
|
"--force_download=true"
|
|
).getBoolean("force_download", "force", false));
|
|
}
|
|
|
|
@Test
|
|
void testSpaceBetweenArgs() {
|
|
Arguments args = Arguments.fromArgs(
|
|
"--key value --key2 value2 --force1 --force2".split("\\s+")
|
|
);
|
|
|
|
assertEquals("value", args.getString("key", "key", null));
|
|
assertEquals("value2", args.getString("key2", "key2", null));
|
|
assertTrue(args.getBoolean("force1", "force1", false));
|
|
assertTrue(args.getBoolean("force2", "force2", false));
|
|
}
|
|
|
|
@Test
|
|
void testListArgumentValuesFromCommandLine() {
|
|
assertEquals(Map.of(), Arguments.fromArgs().toMap());
|
|
assertEquals(Map.of(
|
|
"key", "value",
|
|
"key2", "value2",
|
|
"force1", "true",
|
|
"force2", "true"
|
|
), Arguments.fromArgs(
|
|
"--key value --key2 value2 --force1 --force2".split("\\s+")
|
|
).toMap());
|
|
}
|
|
|
|
@Test
|
|
void testListArgumentValuesFromMap() {
|
|
assertEquals(Map.of(), Arguments.of(Map.of()).toMap());
|
|
assertEquals(Map.of("a", "1", "b", "2"), Arguments.of(Map.of("a", "1", "b", "2")).toMap());
|
|
}
|
|
|
|
@Test
|
|
void testListArgumentValuesFromConfigFile() {
|
|
Arguments args = Arguments.fromConfigFile(TestUtils.pathToResource("test.properties"));
|
|
assertEquals(Map.of("key1", "value1fromfile", "key2", "value2fromfile"), args.toMap());
|
|
}
|
|
|
|
@Test
|
|
void testListArgumentsFromEnvironment() {
|
|
Map<String, String> env = Map.of(
|
|
"OTHER", "value",
|
|
"PLANETILEROTHER", "VALUE",
|
|
"PLANETILER_KEY1", "value1",
|
|
"PLANETILER_KEY2", "value2"
|
|
);
|
|
Arguments args = Arguments.fromEnvironment(env::get, env::keySet);
|
|
assertEquals(Map.of(
|
|
"key1", "value1",
|
|
"key2", "value2"
|
|
), args.toMap());
|
|
}
|
|
|
|
@Test
|
|
void testListArgumentsFromJvmProperties() {
|
|
Map<String, String> jvm = Map.of(
|
|
"OTHER", "value",
|
|
"PLANETILEROTHER", "VALUE",
|
|
"PLANETILER_KEY1", "value1",
|
|
"PLANETILER_KEY2", "value2",
|
|
"planetiler.key3", "value4"
|
|
);
|
|
Arguments args = Arguments.fromJvmProperties(jvm::get, jvm::keySet);
|
|
assertEquals(Map.of(
|
|
"key3", "value4"
|
|
), args.toMap());
|
|
}
|
|
|
|
@Test
|
|
void testListArgumentsFromMerged() {
|
|
Map<String, String> env = Map.of(
|
|
"OTHER", "value",
|
|
"PLANETILEROTHER", "VALUE",
|
|
"PLANETILER_KEY1", "value1",
|
|
"PLANETILER_KEY2", "value2",
|
|
"planetiler.key3", "value3"
|
|
);
|
|
Map<String, String> jvm = Map.of(
|
|
"other", "value",
|
|
"PLANETILEROTHER", "VALUE",
|
|
"PLANETILER_KEY1", "value1",
|
|
"PLANETILER_KEY2", "value2",
|
|
"planetiler.key3", "value4"
|
|
);
|
|
Arguments args = Arguments.fromJvmProperties(jvm::get, jvm::keySet)
|
|
.orElse(Arguments.fromEnvironment(env::get, env::keySet));
|
|
assertEquals(Map.of(
|
|
"key3", "value4",
|
|
"key1", "value1",
|
|
"key2", "value2"
|
|
), args.toMap());
|
|
}
|
|
|
|
@Test
|
|
void testDontAccessArgListUntilUsed() {
|
|
Map<String, String> env = Map.of(
|
|
"OTHER", "value",
|
|
"PLANETILEROTHER", "VALUE",
|
|
"PLANETILER_KEY1", "value1",
|
|
"PLANETILER_KEY2", "value2",
|
|
"planetiler.key3", "value3"
|
|
);
|
|
Arguments args = Arguments.fromEnvironment(env::get, () -> {
|
|
throw new ExpectedException();
|
|
});
|
|
assertEquals("value1", args.getString("key1", ""));
|
|
assertThrows(ExpectedException.class, args::toMap);
|
|
}
|
|
|
|
@Test
|
|
void testBooleanObject() {
|
|
Map<String, String> env = Map.of(
|
|
"BOOL_TRUE", "true",
|
|
"BOOL_FALSE", "false",
|
|
"BOOL_NO", "no"
|
|
);
|
|
Arguments args = Arguments.of(env);
|
|
assertNull(args.getBooleanObject("BOOL_NULL", "test"));
|
|
assertEquals(true, args.getBooleanObject("BOOL_TRUE", "test"));
|
|
assertEquals(false, args.getBooleanObject("BOOL_FALSE", "test"));
|
|
assertEquals(false, args.getBooleanObject("BOOL_NO", "test"));
|
|
}
|
|
|
|
@Test
|
|
void testDeprecatedArgs() {
|
|
assertEquals("newvalue",
|
|
Arguments.of("oldkey", "oldvalue", "newkey", "newvalue")
|
|
.getString("newkey|oldkey", "key", "fallback"));
|
|
assertEquals("oldvalue",
|
|
Arguments.of("oldkey", "oldvalue")
|
|
.getString("newkey|oldkey", "key", "fallback"));
|
|
assertEquals("fallback",
|
|
Arguments.of()
|
|
.getString("newkey|oldkey", "key", "fallback"));
|
|
}
|
|
|
|
@Test
|
|
void testWithPrefix() {
|
|
var args = Arguments.of("prefix_a", "a_val", "prefix-b", "b_val", "other", "other_val").withPrefix("prefix");
|
|
assertEquals("a_val", args.getArg("a"));
|
|
assertEquals("b_val", args.getArg("b"));
|
|
assertNull(args.getArg("other"));
|
|
assertNull(args.getArg("prefix_a"));
|
|
assertNull(args.getArg("prefix_b"));
|
|
assertNull(args.getArg("prefix_other"));
|
|
assertEquals(Set.of("a", "b"), args.toMap().keySet());
|
|
}
|
|
|
|
@Test
|
|
void testPrefixFromEnvironment() {
|
|
Map<String, String> env = Map.of(
|
|
"OTHER", "value",
|
|
"PLANETILEROTHER", "VALUE",
|
|
"PLANETILER_MBTILES_KEY1", "value1",
|
|
"PLANETILER_PMTILES_KEY2", "value2"
|
|
);
|
|
Arguments args = Arguments.fromEnvironment(env::get, env::keySet).withPrefix("mbtiles");
|
|
assertEquals(Map.of(
|
|
"key1", "value1"
|
|
), args.toMap());
|
|
assertEquals("value1", args.getArg("key1"));
|
|
}
|
|
|
|
@Test
|
|
void testSubset() {
|
|
var args = Arguments.of(Map.of(
|
|
"key_1", "val_1",
|
|
"key-2", "val_2",
|
|
"key-3", "val_3"
|
|
)).subset("key-1", "key-2");
|
|
assertEquals(Map.of(
|
|
"key_1", "val_1",
|
|
"key_2", "val_2"
|
|
), args.toMap());
|
|
assertEquals("val_1", args.getArg("key-1"));
|
|
assertNull(args.getArg("key-3"));
|
|
}
|
|
}
|