799 lines
24 KiB
Go
799 lines
24 KiB
Go
package test
|
|
|
|
import (
|
|
"database/sql"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"os"
|
|
|
|
"github.com/omniscale/imposm3/cache"
|
|
|
|
"github.com/omniscale/imposm3/element"
|
|
"github.com/omniscale/imposm3/geom"
|
|
"github.com/omniscale/imposm3/proj"
|
|
|
|
"testing"
|
|
|
|
"github.com/omniscale/imposm3/geom/geos"
|
|
)
|
|
|
|
func TestComplete(t *testing.T) {
|
|
if testing.Short() {
|
|
t.Skip("system test skipped with -test.short")
|
|
}
|
|
t.Parallel()
|
|
|
|
ts := importTestSuite{
|
|
name: "complete",
|
|
}
|
|
|
|
t.Run("Prepare", func(t *testing.T) {
|
|
var err error
|
|
|
|
ts.dir, err = ioutil.TempDir("", "imposm_test")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ts.config = importConfig{
|
|
connection: "postgis://",
|
|
cacheDir: ts.dir,
|
|
osmFileName: "build/complete_db.pbf",
|
|
mappingFileName: "complete_db_mapping.json",
|
|
}
|
|
ts.g = geos.NewGeos()
|
|
|
|
ts.db, err = sql.Open("postgres", "sslmode=disable")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ts.dropSchemas()
|
|
})
|
|
|
|
t.Run("Import", func(t *testing.T) {
|
|
if ts.tableExists(t, ts.dbschemaImport(), "osm_roads") != false {
|
|
t.Fatalf("table osm_roads exists in schema %s", ts.dbschemaImport())
|
|
}
|
|
ts.importOsm(t)
|
|
if ts.tableExists(t, ts.dbschemaImport(), "osm_roads") != true {
|
|
t.Fatalf("table osm_roads does not exists in schema %s", ts.dbschemaImport())
|
|
}
|
|
})
|
|
|
|
t.Run("Deploy", func(t *testing.T) {
|
|
ts.deployOsm(t)
|
|
if ts.tableExists(t, ts.dbschemaImport(), "osm_roads") != false {
|
|
t.Fatalf("table osm_roads exists in schema %s", ts.dbschemaImport())
|
|
}
|
|
if ts.tableExists(t, ts.dbschemaProduction(), "osm_roads") != true {
|
|
t.Fatalf("table osm_roads does not exists in schema %s", ts.dbschemaProduction())
|
|
}
|
|
})
|
|
|
|
t.Run("OnlyNewStyleMultipolgon", func(t *testing.T) {
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_landusages", -1001, "wood", nil},
|
|
{"osm_landusages", -1011, Missing, nil},
|
|
{"osm_landusages", -1021, Missing, nil},
|
|
})
|
|
})
|
|
|
|
t.Run("LandusageToWaterarea1", func(t *testing.T) {
|
|
// Parks inserted into landusages
|
|
cache := ts.cache(t)
|
|
defer cache.Close()
|
|
ts.assertCachedWay(t, cache, 11001)
|
|
ts.assertCachedWay(t, cache, 13001)
|
|
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_waterareas", 11001, Missing, nil},
|
|
{"osm_waterareas", -13001, Missing, nil},
|
|
|
|
{"osm_waterareas_gen0", 11001, Missing, nil},
|
|
{"osm_waterareas_gen0", -13001, Missing, nil},
|
|
|
|
{"osm_waterareas_gen1", 11001, Missing, nil},
|
|
{"osm_waterareas_gen1", -13001, Missing, nil},
|
|
|
|
{"osm_landusages", 11001, "park", nil},
|
|
{"osm_landusages", -13001, "park", nil},
|
|
|
|
{"osm_landusages_gen0", 11001, "park", nil},
|
|
{"osm_landusages_gen0", -13001, "park", nil},
|
|
|
|
{"osm_landusages_gen1", 11001, "park", nil},
|
|
{"osm_landusages_gen1", -13001, "park", nil},
|
|
})
|
|
})
|
|
|
|
t.Run("ChangedHoleTags1", func(t *testing.T) {
|
|
// Multipolygon relation with untagged hole
|
|
cache := ts.cache(t)
|
|
defer cache.Close()
|
|
ts.assertCachedWay(t, cache, 14001)
|
|
ts.assertCachedWay(t, cache, 14011)
|
|
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_waterareas", 14011, Missing, nil},
|
|
{"osm_waterareas", -14011, Missing, nil},
|
|
{"osm_landusages", 14001, "park", nil},
|
|
{"osm_landusages", -14001, Missing, nil},
|
|
})
|
|
})
|
|
|
|
t.Run("SplitOuterMultipolygonWay1", func(t *testing.T) {
|
|
// Single outer way of multipolygon was inserted.
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_roads", 15002, Missing, nil},
|
|
{"osm_landusages", -15001, "park", nil},
|
|
})
|
|
ts.assertGeomArea(t, checkElem{"osm_landusages", -15001, "park", nil}, 9816216452)
|
|
})
|
|
|
|
t.Run("MergeOuterMultipolygonWay1", func(t *testing.T) {
|
|
// Splitted outer way of multipolygon was inserted.
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_landusages", -16001, "park", nil},
|
|
{"osm_roads", 16002, "residential", nil},
|
|
})
|
|
ts.assertGeomArea(t, checkElem{"osm_landusages", -16001, "park", nil}, 12779350582)
|
|
})
|
|
|
|
t.Run("BrokenMultipolygonWays", func(t *testing.T) {
|
|
// MultiPolygons with broken outer ways are handled.
|
|
// outer way does not merge (17002 has one node)
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_landusages", -17001, Missing, nil},
|
|
{"osm_roads", 17001, "residential", nil},
|
|
{"osm_roads", 17002, Missing, nil},
|
|
})
|
|
|
|
// outer way does not merge (17102 has no nodes)
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_landusages", -17101, Missing, nil},
|
|
{"osm_roads", 17101, "residential", nil},
|
|
{"osm_roads", 17102, Missing, nil},
|
|
})
|
|
})
|
|
|
|
t.Run("NodeWayInsertedTwice", func(t *testing.T) {
|
|
// Way with multiple mappings is inserted twice in same table
|
|
rows := ts.queryRows(t, "osm_roads", 18001)
|
|
if len(rows) != 2 || rows[0].osmType != "residential" || rows[1].osmType != "tram" {
|
|
t.Errorf("unexpected roads: %v", rows)
|
|
}
|
|
})
|
|
|
|
t.Run("OuterWayInsertedTwice", func(t *testing.T) {
|
|
// Outer way with different tag value is inserted twice into same table
|
|
// behavior changed from pre-old-style-mp-removal:
|
|
// test outer way not inserted (different tag but same table)
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_landusages", -19001, "farmland", nil},
|
|
{"osm_landusages", 19002, "farmyard", nil},
|
|
{"osm_landusages", 19001, "farm", nil},
|
|
})
|
|
})
|
|
|
|
t.Run("OuterWayInserted", func(t *testing.T) {
|
|
// Outer way with different tag is inserted twice into different table
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_landusages", 19101, "farm", nil},
|
|
{"osm_landusages", 19102, "farmyard", nil},
|
|
{"osm_admin", -19101, "administrative", nil},
|
|
})
|
|
})
|
|
|
|
t.Run("NodeWayRefAfterDelete1", func(t *testing.T) {
|
|
// Nodes references way
|
|
|
|
cache := ts.diffCache(t)
|
|
defer cache.Close()
|
|
if ids := cache.Coords.Get(20001); len(ids) != 1 || ids[0] != 20001 {
|
|
t.Error("node does not references way")
|
|
}
|
|
if ids := cache.Coords.Get(20002); len(ids) != 1 || ids[0] != 20001 {
|
|
t.Error("node does not references way")
|
|
}
|
|
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_roads", 20001, "residential", nil},
|
|
{"osm_barrierpoints", 20001, "block", nil},
|
|
})
|
|
})
|
|
|
|
t.Run("WayRelRefAfterDelete1", func(t *testing.T) {
|
|
// Ways references relation
|
|
|
|
cache := ts.diffCache(t)
|
|
defer cache.Close()
|
|
if ids := cache.Ways.Get(21001); len(ids) != 1 || ids[0] != 21001 {
|
|
t.Error("way does not references relation")
|
|
}
|
|
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_roads", 21001, "residential", nil},
|
|
{"osm_landusages", -21001, "park", nil},
|
|
})
|
|
})
|
|
|
|
t.Run("OldStyleMpRelationWayInserted", func(t *testing.T) {
|
|
// Old-style-mp: Part of relation is now inserted.
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_landusages", -9001, "park", map[string]string{"name": "rel 9001"}},
|
|
{"osm_landusages", 9009, "park", map[string]string{"name": "way 9009"}},
|
|
{"osm_landusages", -9101, "park", map[string]string{"name": "rel 9101"}},
|
|
{"osm_landusages", 9109, "park", map[string]string{"name": "way 9109"}},
|
|
{"osm_landusages", 9110, "scrub", nil},
|
|
})
|
|
})
|
|
|
|
t.Run("RelationWaysInserted", func(t *testing.T) {
|
|
// Outer ways of multipolygon are inserted.
|
|
ts.assertRecords(t, []checkElem{
|
|
// no name on relation
|
|
{"osm_landusages", -9201, "park", map[string]string{"name": ""}},
|
|
{"osm_landusages", 9201, Missing, nil},
|
|
{"osm_landusages", 9209, Missing, nil},
|
|
{"osm_landusages", 9210, Missing, nil},
|
|
// outer ways of multipolygon stand for their own
|
|
{"osm_roads", 9209, "secondary", map[string]string{"name": "9209"}},
|
|
{"osm_roads", 9210, "residential", map[string]string{"name": "9210"}},
|
|
})
|
|
})
|
|
|
|
t.Run("RelationWayInserted", func(t *testing.T) {
|
|
// Part of relation was inserted twice.
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_landusages", -8001, "park", map[string]string{"name": "rel 8001"}},
|
|
{"osm_roads", 8009, "residential", nil},
|
|
})
|
|
})
|
|
|
|
t.Run("SingleNodeWaysNotInserted", func(t *testing.T) {
|
|
// Ways with single/duplicate nodes are not inserted.
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_landusages", 30001, Missing, nil},
|
|
{"osm_landusages", 30002, Missing, nil},
|
|
{"osm_landusages", 30003, Missing, nil},
|
|
})
|
|
})
|
|
|
|
t.Run("PolygonWithDuplicateNodesIsValid", func(t *testing.T) {
|
|
// Polygon with duplicate nodes is valid.
|
|
ts.assertGeomValid(t, checkElem{"osm_landusages", 30005, "park", nil})
|
|
})
|
|
|
|
t.Run("IncompletePolygons", func(t *testing.T) {
|
|
// Non-closed/incomplete polygons are not inserted.
|
|
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_landusages", 30004, Missing, nil},
|
|
{"osm_landusages", 30006, Missing, nil},
|
|
})
|
|
})
|
|
|
|
t.Run("ResidentialToSecondary", func(t *testing.T) {
|
|
// Residential road is not in roads_gen0/1.
|
|
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_roads", 40001, "residential", nil},
|
|
{"osm_roads_gen0", 40001, Missing, nil},
|
|
{"osm_roads_gen1", 40002, Missing, nil},
|
|
})
|
|
})
|
|
|
|
t.Run("RelationBeforeRemove", func(t *testing.T) {
|
|
// Relation and way is inserted.
|
|
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_buildings", 50011, "yes", nil},
|
|
{"osm_landusages", -50021, "park", nil},
|
|
})
|
|
})
|
|
|
|
t.Run("OldStyleRelationIsIgnored", func(t *testing.T) {
|
|
// Relation without tags is not inserted.
|
|
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_buildings", 50111, "yes", nil},
|
|
{"osm_buildings", -50121, Missing, nil},
|
|
})
|
|
})
|
|
|
|
t.Run("DuplicateIds", func(t *testing.T) {
|
|
// Relation/way with same ID is inserted.
|
|
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_buildings", 51001, "way", nil},
|
|
{"osm_buildings", -51001, "mp", nil},
|
|
{"osm_buildings", 51011, "way", nil},
|
|
{"osm_buildings", -51011, "mp", nil},
|
|
})
|
|
})
|
|
|
|
t.Run("RelationUpdatedByNode", func(t *testing.T) {
|
|
// Relations was updated after modified node.
|
|
|
|
ts.assertGeomArea(t, checkElem{"osm_buildings", -52121, "yes", nil}, 13653930440.868315)
|
|
})
|
|
|
|
t.Run("GeneralizedBananaPolygonIsValid", func(t *testing.T) {
|
|
// Generalized polygons are valid.
|
|
|
|
ts.assertGeomValid(t, checkElem{"osm_landusages", 7101, Missing, nil})
|
|
// simplified geometies are valid too
|
|
ts.assertGeomValid(t, checkElem{"osm_landusages_gen0", 7101, Missing, nil})
|
|
ts.assertGeomValid(t, checkElem{"osm_landusages_gen1", 7101, Missing, nil})
|
|
})
|
|
|
|
t.Run("GeneralizedLinestringIsValid", func(t *testing.T) {
|
|
// Generalized linestring is valid.
|
|
|
|
// geometry is not simple, but valid
|
|
ts.assertGeomLength(t, checkElem{"osm_roads", 7201, "primary", nil}, 1243660.044819)
|
|
if ts.g.IsSimple(ts.queryGeom(t, "osm_roads", 7201)) {
|
|
t.Errorf("expected non-simple geometry for 7201")
|
|
}
|
|
// check that geometry 'survives' simplification
|
|
ts.assertGeomLength(t, checkElem{"osm_roads_gen0", 7201, "primary", nil}, 1243660.044819)
|
|
ts.assertGeomLength(t, checkElem{"osm_roads_gen1", 7201, "primary", nil}, 1243660.044819)
|
|
})
|
|
|
|
t.Run("RingWithGap", func(t *testing.T) {
|
|
// Multipolygon with gap (overlapping but different endpoints) gets closed
|
|
ts.assertGeomValid(t, checkElem{"osm_landusages", -7301, Missing, nil})
|
|
// but not way
|
|
ts.assertRecords(t, []checkElem{
|
|
checkElem{"osm_landusages", 7311, Missing, nil},
|
|
})
|
|
})
|
|
|
|
t.Run("MultipolygonWithOpenRing", func(t *testing.T) {
|
|
// Multipolygon is inserted even if there is an open ring/member
|
|
ts.assertGeomValid(t, checkElem{"osm_landusages", -7401, Missing, nil})
|
|
})
|
|
|
|
t.Run("UpdatedNodes1", func(t *testing.T) {
|
|
// Zig-Zag line is inserted.
|
|
ts.assertGeomLength(t, checkElem{"osm_roads", 60000, Missing, nil}, 14035.61150207768)
|
|
})
|
|
|
|
t.Run("UpdateNodeToCoord1", func(t *testing.T) {
|
|
// Node is inserted with tag.
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_amenities", 70001, "police", nil},
|
|
{"osm_amenities", 70002, Missing, nil},
|
|
})
|
|
})
|
|
|
|
t.Run("EnumerateKey", func(t *testing.T) {
|
|
// Enumerate from key.
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_landusages", 100001, "park", map[string]string{"enum": "1"}},
|
|
{"osm_landusages", 100002, "park", map[string]string{"enum": "0"}},
|
|
{"osm_landusages", 100003, "wood", map[string]string{"enum": "15"}},
|
|
})
|
|
})
|
|
|
|
t.Run("AreaMapping", func(t *testing.T) {
|
|
// Mapping type dependent area-defaults.
|
|
|
|
ts.assertRecords(t, []checkElem{
|
|
// highway=pedestrian
|
|
{"osm_roads", 301151, "pedestrian", nil},
|
|
{"osm_landusages", 301151, Missing, nil},
|
|
|
|
// // highway=pedestrian, area=yes
|
|
{"osm_roads", 301152, Missing, nil},
|
|
{"osm_landusages", 301152, "pedestrian", nil},
|
|
|
|
// // leisure=track
|
|
{"osm_roads", 301153, Missing, nil},
|
|
{"osm_landusages", 301153, "track", nil},
|
|
|
|
// // leisure=track, area=no
|
|
{"osm_roads", 301154, "track", nil},
|
|
{"osm_landusages", 301154, Missing, nil},
|
|
})
|
|
})
|
|
|
|
t.Run("HstoreTags", func(t *testing.T) {
|
|
// Mapping type dependent area-defaults.
|
|
|
|
ts.assertHstore(t, []checkElem{
|
|
{"osm_buildings", 401151, "*", map[string]string{"amenity": "fuel", "opening_hours": "24/7"}},
|
|
})
|
|
})
|
|
|
|
// #######################################################################
|
|
|
|
t.Run("Update", func(t *testing.T) {
|
|
ts.updateOsm(t, "build/complete_db.osc.gz")
|
|
})
|
|
|
|
// #######################################################################
|
|
|
|
t.Run("NoDuplicates", func(t *testing.T) {
|
|
// Relations/ways are only inserted once Checks #66
|
|
|
|
for _, table := range []string{"osm_roads", "osm_landusages"} {
|
|
rows, err := ts.db.Query(
|
|
fmt.Sprintf(`SELECT osm_id, count(osm_id) FROM "%s"."%s" GROUP BY osm_id HAVING count(osm_id) > 1`,
|
|
ts.dbschemaProduction(), table))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var osmId, count int64
|
|
for rows.Next() {
|
|
if err := rows.Scan(&osmId, &count); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if table == "osm_roads" && osmId == 18001 {
|
|
// # duplicate for TestNodeWayInsertedTwice is expected
|
|
if count != 2 {
|
|
t.Error("highway not inserted twice", osmId, count)
|
|
}
|
|
} else {
|
|
t.Error("found duplicate way in osm_roads", osmId, count)
|
|
}
|
|
}
|
|
}
|
|
})
|
|
|
|
t.Run("UpdatedLandusage", func(t *testing.T) {
|
|
// Multipolygon relation was modified
|
|
|
|
nd := element.Node{Long: 13.4, Lat: 47.5}
|
|
proj.NodeToMerc(&nd)
|
|
point, err := geom.Point(ts.g, nd)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
poly := ts.queryGeom(t, "osm_landusages", -1001)
|
|
// point not in polygon after update
|
|
if ts.g.Intersects(point, poly) {
|
|
t.Error("point intersects polygon")
|
|
}
|
|
})
|
|
|
|
t.Run("PartialDelete", func(t *testing.T) {
|
|
// Deleted relation but nodes are still cached
|
|
|
|
cache := ts.cache(t)
|
|
defer cache.Close()
|
|
ts.assertCachedNode(t, cache, 2001)
|
|
ts.assertCachedWay(t, cache, 2001)
|
|
ts.assertCachedWay(t, cache, 2002)
|
|
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_landusages", -2001, Missing, nil},
|
|
{"osm_landusages", 2001, Missing, nil},
|
|
})
|
|
})
|
|
|
|
t.Run("UpdatedNodes", func(t *testing.T) {
|
|
// Nodes were added, modified or deleted
|
|
|
|
c := ts.cache(t)
|
|
defer c.Close()
|
|
if _, err := c.Coords.GetCoord(10000); err != cache.NotFound {
|
|
t.Fatal("coord not missing")
|
|
}
|
|
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_places", 10001, "village", map[string]string{"name": "Bar"}},
|
|
{"osm_places", 10002, "city", map[string]string{"name": "Baz"}},
|
|
})
|
|
})
|
|
|
|
t.Run("LandusageToWaterarea2", func(t *testing.T) {
|
|
// Parks converted to water moved from landusages to waterareas
|
|
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_waterareas", 11001, "water", nil},
|
|
{"osm_waterareas", -13001, "water", nil},
|
|
|
|
{"osm_waterareas_gen0", 11001, "water", nil},
|
|
{"osm_waterareas_gen0", -13001, "water", nil},
|
|
|
|
{"osm_waterareas_gen1", 11001, "water", nil},
|
|
{"osm_waterareas_gen1", -13001, "water", nil},
|
|
|
|
{"osm_landusages", 11001, Missing, nil},
|
|
{"osm_landusages", -13001, Missing, nil},
|
|
|
|
{"osm_landusages_gen0", 11001, Missing, nil},
|
|
{"osm_landusages_gen0", -13001, Missing, nil},
|
|
|
|
{"osm_landusages_gen1", 11001, Missing, nil},
|
|
{"osm_landusages_gen1", -13001, Missing, nil},
|
|
})
|
|
})
|
|
|
|
t.Run("ChangedHoleTags2", func(t *testing.T) {
|
|
// Newly tagged hole is inserted
|
|
|
|
cache := ts.cache(t)
|
|
defer cache.Close()
|
|
ts.assertCachedWay(t, cache, 14001)
|
|
ts.assertCachedWay(t, cache, 14011)
|
|
|
|
ts.assertGeomArea(t, checkElem{"osm_waterareas", 14011, "water", nil}, 26672019779)
|
|
ts.assertGeomArea(t, checkElem{"osm_landusages", -14001, "park", nil}, 10373697182)
|
|
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_waterareas", -14011, Missing, nil},
|
|
{"osm_landusages", -14001, "park", nil},
|
|
})
|
|
})
|
|
|
|
t.Run("SplitOuterMultipolygonWay2", func(t *testing.T) {
|
|
// Splitted outer way of multipolygon was inserted
|
|
|
|
diffCache := ts.diffCache(t)
|
|
defer diffCache.Close()
|
|
if ids := diffCache.Ways.Get(15001); len(ids) != 1 || ids[0] != 15001 {
|
|
t.Error("way does not references relation")
|
|
}
|
|
if ids := diffCache.Ways.Get(15002); len(ids) != 1 || ids[0] != 15001 {
|
|
t.Error("way does not references relation")
|
|
}
|
|
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_landusages", 15001, Missing, nil},
|
|
{"osm_roads", 15002, "residential", nil},
|
|
})
|
|
ts.assertGeomArea(t, checkElem{"osm_landusages", -15001, "park", nil}, 9816216452)
|
|
})
|
|
|
|
t.Run("MergeOuterMultipolygonWay2", func(t *testing.T) {
|
|
// Merged outer way of multipolygon was inserted
|
|
|
|
diffCache := ts.diffCache(t)
|
|
defer diffCache.Close()
|
|
if ids := diffCache.Ways.Get(16001); len(ids) != 1 || ids[0] != 16001 {
|
|
t.Error("way does not references relation")
|
|
}
|
|
if ids := diffCache.Ways.Get(16002); len(ids) != 0 {
|
|
t.Error("way references relation")
|
|
}
|
|
|
|
cache := ts.cache(t)
|
|
defer cache.Close()
|
|
rel, err := cache.Relations.GetRelation(16001)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(rel.Members) != 2 || rel.Members[0].Id != 16001 || rel.Members[1].Id != 16011 {
|
|
t.Error("unexpected relation members", rel)
|
|
}
|
|
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_landusages", 16001, Missing, nil},
|
|
{"osm_roads", 16002, Missing, nil},
|
|
})
|
|
ts.assertGeomArea(t, checkElem{"osm_landusages", -16001, "park", nil}, 12779350582)
|
|
})
|
|
|
|
t.Run("NodeWayRefAfterDelete2", func(t *testing.T) {
|
|
// Node does not referece deleted way
|
|
|
|
diffCache := ts.diffCache(t)
|
|
defer diffCache.Close()
|
|
if ids := diffCache.Coords.Get(20001); len(ids) != 0 {
|
|
t.Error("node references way")
|
|
}
|
|
c := ts.cache(t)
|
|
defer c.Close()
|
|
_, err := c.Coords.GetCoord(20002)
|
|
if err != cache.NotFound {
|
|
t.Error("found deleted node")
|
|
}
|
|
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_roads", 20001, Missing, nil},
|
|
{"osm_barrierpoints", 20001, "block", nil},
|
|
})
|
|
})
|
|
|
|
t.Run("WayRelRefAfterDelete2", func(t *testing.T) {
|
|
// Way does not referece deleted relation
|
|
|
|
diffCache := ts.diffCache(t)
|
|
defer diffCache.Close()
|
|
if ids := diffCache.Ways.Get(21001); len(ids) != 0 {
|
|
t.Error("way references relation")
|
|
}
|
|
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_roads", 21001, "residential", nil},
|
|
{"osm_landusages", 21001, Missing, nil},
|
|
{"osm_landusages", -21001, Missing, nil},
|
|
})
|
|
})
|
|
|
|
t.Run("ResidentialToSecondary2", func(t *testing.T) {
|
|
// New secondary (from residential) is now in roads_gen0/1.
|
|
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_roads", 40001, "secondary", nil},
|
|
{"osm_roads_gen0", 40001, "secondary", nil},
|
|
{"osm_roads_gen1", 40001, "secondary", nil},
|
|
})
|
|
})
|
|
|
|
t.Run("RelationAfterRemove", func(t *testing.T) {
|
|
// Relation is deleted and way is still present.
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_buildings", 50011, "yes", nil},
|
|
{"osm_landusages", 50021, Missing, nil},
|
|
{"osm_landusages", -50021, Missing, nil},
|
|
})
|
|
})
|
|
|
|
t.Run("RelationWithoutTags2", func(t *testing.T) {
|
|
// Relation without tags is removed.
|
|
|
|
c := ts.cache(t)
|
|
defer c.Close()
|
|
ts.assertCachedWay(t, c, 50111)
|
|
|
|
_, err := c.Ways.GetWay(20002)
|
|
if err != cache.NotFound {
|
|
t.Error("found deleted node")
|
|
}
|
|
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_buildings", 50111, "yes", nil},
|
|
{"osm_buildings", 50121, Missing, nil},
|
|
{"osm_buildings", -50121, Missing, nil},
|
|
})
|
|
})
|
|
|
|
t.Run("DuplicateIds2", func(t *testing.T) {
|
|
// Only relation/way with same ID was deleted.
|
|
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_buildings", 51001, "way", nil},
|
|
{"osm_buildings", -51001, Missing, nil},
|
|
{"osm_buildings", 51011, Missing, nil},
|
|
{"osm_buildings", -51011, "mp", nil},
|
|
})
|
|
})
|
|
|
|
t.Run("RelationUpdatedByNode2", func(t *testing.T) {
|
|
// Relations was updated after modified node.
|
|
|
|
ts.assertGeomArea(t, checkElem{"osm_buildings", -52121, "yes", nil}, 16276875196.653734)
|
|
})
|
|
|
|
t.Run("UpdatedWay2", func(t *testing.T) {
|
|
// All nodes of straightened way are updated.
|
|
|
|
// new length 0.1 degree
|
|
ts.assertGeomLength(t, checkElem{"osm_roads", 60000, "park", nil}, 20037508.342789244/180.0/10.0)
|
|
})
|
|
|
|
t.Run("UpdateNodeToCoord2", func(t *testing.T) {
|
|
// Node is becomes coord after tags are removed.
|
|
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_amenities", 70001, Missing, nil},
|
|
{"osm_amenities", 70002, "police", nil},
|
|
})
|
|
})
|
|
|
|
t.Run("NoDuplicateInsert", func(t *testing.T) {
|
|
// Relation is not inserted again if a nother relation with the same way was modified
|
|
// Checks #65
|
|
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_landusages", -201191, "park", nil},
|
|
{"osm_landusages", -201192, "forest", nil},
|
|
{"osm_roads", 201151, "residential", nil},
|
|
})
|
|
})
|
|
|
|
t.Run("UnsupportedRelation", func(t *testing.T) {
|
|
// Unsupported relation type is not inserted with update
|
|
|
|
ts.assertRecords(t, []checkElem{
|
|
{"osm_landusages", -201291, Missing, nil},
|
|
{"osm_landusages", 201251, "park", nil},
|
|
})
|
|
})
|
|
|
|
// #######################################################################
|
|
|
|
t.Run("DeployRevert", func(t *testing.T) {
|
|
if ts.tableExists(t, ts.dbschemaImport(), "osm_roads") {
|
|
t.Fatalf("table osm_roads exists in schema %s", ts.dbschemaImport())
|
|
}
|
|
if !ts.tableExists(t, ts.dbschemaProduction(), "osm_roads") {
|
|
t.Fatalf("table osm_roads does not exists in schema %s", ts.dbschemaProduction())
|
|
}
|
|
if ts.tableExists(t, ts.dbschemaBackup(), "osm_roads") {
|
|
t.Fatalf("table osm_roads exists in schema %s", ts.dbschemaBackup())
|
|
}
|
|
|
|
ts.importOsm(t)
|
|
|
|
if !ts.tableExists(t, ts.dbschemaImport(), "osm_roads") {
|
|
t.Fatalf("table osm_roads does not exists in schema %s", ts.dbschemaImport())
|
|
}
|
|
if !ts.tableExists(t, ts.dbschemaProduction(), "osm_roads") {
|
|
t.Fatalf("table osm_roads does not exists in schema %s", ts.dbschemaProduction())
|
|
}
|
|
if ts.tableExists(t, ts.dbschemaBackup(), "osm_roads") {
|
|
t.Fatalf("table osm_roads exists in schema %s", ts.dbschemaBackup())
|
|
}
|
|
|
|
ts.deployOsm(t)
|
|
|
|
if ts.tableExists(t, ts.dbschemaImport(), "osm_roads") {
|
|
t.Fatalf("table osm_roads exists in schema %s", ts.dbschemaImport())
|
|
}
|
|
if !ts.tableExists(t, ts.dbschemaProduction(), "osm_roads") {
|
|
t.Fatalf("table osm_roads does not exists in schema %s", ts.dbschemaProduction())
|
|
}
|
|
if !ts.tableExists(t, ts.dbschemaBackup(), "osm_roads") {
|
|
t.Fatalf("table osm_roads does exists in schema %s", ts.dbschemaBackup())
|
|
}
|
|
|
|
ts.revertDeployOsm(t)
|
|
|
|
if !ts.tableExists(t, ts.dbschemaImport(), "osm_roads") {
|
|
t.Fatalf("table osm_roads does not exists in schema %s", ts.dbschemaImport())
|
|
}
|
|
if !ts.tableExists(t, ts.dbschemaProduction(), "osm_roads") {
|
|
t.Fatalf("table osm_roads does not exists in schema %s", ts.dbschemaProduction())
|
|
}
|
|
if ts.tableExists(t, ts.dbschemaBackup(), "osm_roads") {
|
|
t.Fatalf("table osm_roads exists in schema %s", ts.dbschemaBackup())
|
|
}
|
|
})
|
|
|
|
t.Run("RemoveBackup", func(t *testing.T) {
|
|
if !ts.tableExists(t, ts.dbschemaImport(), "osm_roads") {
|
|
t.Fatalf("table osm_roads does not exists in schema %s", ts.dbschemaImport())
|
|
}
|
|
if !ts.tableExists(t, ts.dbschemaProduction(), "osm_roads") {
|
|
t.Fatalf("table osm_roads does not exists in schema %s", ts.dbschemaProduction())
|
|
}
|
|
if ts.tableExists(t, ts.dbschemaBackup(), "osm_roads") {
|
|
t.Fatalf("table osm_roads exists in schema %s", ts.dbschemaBackup())
|
|
}
|
|
|
|
ts.deployOsm(t)
|
|
|
|
if ts.tableExists(t, ts.dbschemaImport(), "osm_roads") {
|
|
t.Fatalf("table osm_roads exists in schema %s", ts.dbschemaImport())
|
|
}
|
|
if !ts.tableExists(t, ts.dbschemaProduction(), "osm_roads") {
|
|
t.Fatalf("table osm_roads does not exists in schema %s", ts.dbschemaProduction())
|
|
}
|
|
if !ts.tableExists(t, ts.dbschemaBackup(), "osm_roads") {
|
|
t.Fatalf("table osm_roads does exists in schema %s", ts.dbschemaBackup())
|
|
}
|
|
|
|
ts.removeBackupOsm(t)
|
|
|
|
if ts.tableExists(t, ts.dbschemaImport(), "osm_roads") {
|
|
t.Fatalf("table osm_roads exists in schema %s", ts.dbschemaImport())
|
|
}
|
|
if !ts.tableExists(t, ts.dbschemaProduction(), "osm_roads") {
|
|
t.Fatalf("table osm_roads does not exists in schema %s", ts.dbschemaProduction())
|
|
}
|
|
if ts.tableExists(t, ts.dbschemaBackup(), "osm_roads") {
|
|
t.Fatalf("table osm_roads exists in schema %s", ts.dbschemaBackup())
|
|
}
|
|
})
|
|
|
|
t.Run("Cleanup", func(t *testing.T) {
|
|
ts.dropSchemas()
|
|
if err := os.RemoveAll(ts.dir); err != nil {
|
|
t.Error(err)
|
|
}
|
|
})
|
|
}
|