kopia lustrzana https://github.com/onthegomap/planetiler
229 wiersze
5.7 KiB
Java
229 wiersze
5.7 KiB
Java
package com.onthegomap.planetiler.basemap;
|
|
|
|
import static com.onthegomap.planetiler.basemap.Generate.parseYaml;
|
|
import static com.onthegomap.planetiler.expression.Expression.*;
|
|
import static org.junit.jupiter.api.Assertions.assertEquals;
|
|
import static org.junit.jupiter.api.DynamicTest.dynamicTest;
|
|
|
|
import com.fasterxml.jackson.databind.JsonNode;
|
|
import com.onthegomap.planetiler.expression.Expression;
|
|
import com.onthegomap.planetiler.expression.MultiExpression;
|
|
import java.util.LinkedHashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.stream.Stream;
|
|
import org.junit.jupiter.api.DynamicTest;
|
|
import org.junit.jupiter.api.Test;
|
|
import org.junit.jupiter.api.TestFactory;
|
|
|
|
class GenerateTest {
|
|
|
|
@Test
|
|
void testParseSimple() {
|
|
MultiExpression<String> parsed = Generate.generateFieldMapping(parseYaml("""
|
|
output:
|
|
key: value
|
|
key2:
|
|
- value2
|
|
- '%value3%'
|
|
"""));
|
|
assertEquals(MultiExpression.of(List.of(
|
|
MultiExpression.entry("output", or(
|
|
matchAny("key", "value"),
|
|
matchAny("key2", "value2", "%value3%")
|
|
))
|
|
)), parsed);
|
|
}
|
|
|
|
@Test
|
|
void testParseAnd() {
|
|
MultiExpression<String> parsed = Generate.generateFieldMapping(parseYaml("""
|
|
output:
|
|
__AND__:
|
|
key1: val1
|
|
key2: val2
|
|
"""));
|
|
assertEquals(MultiExpression.of(List.of(
|
|
MultiExpression.entry("output", and(
|
|
matchAny("key1", "val1"),
|
|
matchAny("key2", "val2")
|
|
))
|
|
)), parsed);
|
|
}
|
|
|
|
@Test
|
|
void testParseAndWithOthers() {
|
|
MultiExpression<String> parsed = Generate.generateFieldMapping(parseYaml("""
|
|
output:
|
|
- key0: val0
|
|
- __AND__:
|
|
key1: val1
|
|
key2: val2
|
|
"""));
|
|
assertEquals(MultiExpression.of(List.of(
|
|
MultiExpression.entry("output", or(
|
|
matchAny("key0", "val0"),
|
|
and(
|
|
matchAny("key1", "val1"),
|
|
matchAny("key2", "val2")
|
|
)
|
|
))
|
|
)), parsed);
|
|
}
|
|
|
|
@Test
|
|
void testParseAndContainingOthers() {
|
|
MultiExpression<String> parsed = Generate.generateFieldMapping(parseYaml("""
|
|
output:
|
|
__AND__:
|
|
- key1: val1
|
|
- __OR__:
|
|
key2: val2
|
|
key3: val3
|
|
"""));
|
|
assertEquals(MultiExpression.of(List.of(
|
|
MultiExpression.entry("output", and(
|
|
matchAny("key1", "val1"),
|
|
or(
|
|
matchAny("key2", "val2"),
|
|
matchAny("key3", "val3")
|
|
)
|
|
))
|
|
)), parsed);
|
|
}
|
|
|
|
@Test
|
|
void testParseContainsKey() {
|
|
MultiExpression<String> parsed = Generate.generateFieldMapping(parseYaml("""
|
|
output:
|
|
key1: val1
|
|
key2:
|
|
"""));
|
|
assertEquals(MultiExpression.of(List.of(
|
|
MultiExpression.entry("output", or(
|
|
matchAny("key1", "val1"),
|
|
matchField("key2")
|
|
))
|
|
)), parsed);
|
|
}
|
|
|
|
@TestFactory
|
|
Stream<DynamicTest> testParseImposm3Mapping() {
|
|
record TestCase(String name, String mapping, String require, String reject, Expression expected) {
|
|
|
|
TestCase(String mapping, Expression expected) {
|
|
this(mapping, mapping, null, null, expected);
|
|
}
|
|
}
|
|
return Stream.of(
|
|
new TestCase(
|
|
"key: val", matchAny("key", "val")
|
|
),
|
|
new TestCase(
|
|
"key: [val1, val2]", matchAny("key", "val1", "val2")
|
|
),
|
|
new TestCase(
|
|
"key: [\"__any__\"]", matchField("key")
|
|
),
|
|
new TestCase("reject",
|
|
"key: val",
|
|
"mustkey: mustval",
|
|
null,
|
|
and(
|
|
matchAny("key", "val"),
|
|
matchAny("mustkey", "mustval")
|
|
)
|
|
),
|
|
new TestCase("require",
|
|
"key: val",
|
|
null,
|
|
"badkey: badval",
|
|
and(
|
|
matchAny("key", "val"),
|
|
not(matchAny("badkey", "badval"))
|
|
)
|
|
),
|
|
new TestCase("require and reject complex",
|
|
"""
|
|
key: val
|
|
key2:
|
|
- val1
|
|
- val2
|
|
""",
|
|
"""
|
|
mustkey: mustval
|
|
mustkey2:
|
|
- mustval1
|
|
- mustval2
|
|
""",
|
|
"""
|
|
notkey: notval
|
|
notkey2:
|
|
- notval1
|
|
- notval2
|
|
""",
|
|
and(
|
|
or(
|
|
matchAny("key", "val"),
|
|
matchAny("key2", "val1", "val2")
|
|
),
|
|
matchAny("mustkey", "mustval"),
|
|
matchAny("mustkey2", "mustval1", "mustval2"),
|
|
not(matchAny("notkey", "notval")),
|
|
not(matchAny("notkey2", "notval1", "notval2"))
|
|
)
|
|
)
|
|
).map(test -> dynamicTest(test.name, () -> {
|
|
Expression parsed = Generate
|
|
.parseImposm3MappingExpression("point", parseYaml(test.mapping), new Generate.Imposm3Filters(
|
|
parseYaml(test.reject),
|
|
parseYaml(test.require)
|
|
));
|
|
assertEquals(test.expected, parsed.replace(matchType("point"), TRUE).simplify());
|
|
}));
|
|
}
|
|
|
|
@Test
|
|
void testTypeMappingTopLevelType() {
|
|
Expression parsed = Generate
|
|
.parseImposm3MappingExpression("point", parseYaml("""
|
|
key: val
|
|
"""), new Generate.Imposm3Filters(null, null));
|
|
assertEquals(and(
|
|
matchAny("key", "val"),
|
|
matchType("point")
|
|
), parsed);
|
|
}
|
|
|
|
@Test
|
|
void testTypeMappings() {
|
|
Map<String, JsonNode> props = new LinkedHashMap<>();
|
|
props.put("points", parseYaml("""
|
|
key: val
|
|
"""));
|
|
props.put("polygons", parseYaml("""
|
|
key2: val2
|
|
"""));
|
|
Expression parsed = Generate
|
|
.parseImposm3MappingExpression(new Generate.Imposm3Table(
|
|
"geometry",
|
|
false,
|
|
List.of(),
|
|
null,
|
|
null,
|
|
props,
|
|
List.of()
|
|
));
|
|
assertEquals(or(
|
|
and(
|
|
matchAny("key", "val"),
|
|
matchType("point")
|
|
),
|
|
and(
|
|
matchAny("key2", "val2"),
|
|
matchType("polygon")
|
|
)
|
|
), parsed);
|
|
}
|
|
}
|