tei/MapLibreParticleLab
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replacing hardcoded configuration with configurable API and removing Mapbox assets (#90)

Browse Source 
* Refactoring online file source so that tile server configuration is not hardcoded - part 1

* Added default templates

* Update from master

* Renaming MGLAccountManager to MGLSettings. Passing ResourceOptions and TileServerOptions to relevant classes and method in order to remove mapbox hardocded configuration

* Fixing build

* Addedm missing theme

* Unit tests fixes

* Fixing unit tests, adding factory methods for creating predefined configuration.

* Fixing mapbox unit tests

* Additional unit test fixes

* Making MapboxConfiguration default

* Making get/set resource options available in all classes that inherits from FileSource

* Making get/set resource options available in all classes that inherits from FileSource - part 2

* Fixes for Android

* Disable test coverage reports

* Disable test coverage reports

* Disable test coverage reports

* Disable test coverage reports

* Removing hardcoded configuration in iOS project - part 1

* Fixing wrong file extension, making use of tile server options.

* Use apiKey and MGL_API_KEY everywhere

* Just a rename

* Re-enabling tests and improving MGLSettings init

* Removing mapbox hardcoded configuration, using api key everywhere, implementing JNI conversion for TileServerOptions

* Lint issues.

* Integrating configurable tile server properties into Android SDK - part 2

* Removing mabox accounts

* Exposing multiple configurations to Android SDK - bug fixes

* Removing TileServerOptions from public interface - native methods dont work before mapbox-gl library is loaded

* Adding support for configurable predefined styles

* Migrating predefined styles in test app + cleanup

* Parameter fix

* Bug fixes

* Fixing render test build

* Fixing offline tester

* Fixing benchmark tool

* Fix: typo in method name

* Adding code for public access to TileServerOptions

* Bug fixes and debug code removal

* Fixes for macOS, adding unit tests from MapLibre, removing redundant members from OnlineFileSource

* Unit test fixes

* MacOS test app - migrating to configurable tile server options, part 1

* Fixing offline maps

* Migrating macOS test app to MapTiler

* Minor improvements

* Putting back apiKey test

* Added unit tests for MapTiler configuration

* Migrating test resources to MapTiler

* minor fix

* A few fixes

* Fixing macOS tests, removing feedback functionality

* Migrating ios test app to MapTiler

* Migrating ui tests

* UI tests fix

* Benchmarking app fix

* Cleanup and strings updates

* Migrating benchmark app to maptiler

* API key injection in benchmark app

* Putting back release configuration

* Additional tests and fixing issues identified by thread sanitizer.

* Removing test filters

* Fixes and addressing lint issues

* More Maptiler tests + minro fix

* Android instrumentation test migration to MapTiler. Exposing missing TileServerOptions in Android SDK. Minor fixes.

* No requirements on API key format.

* Fixing offline cache test tool

* Adding configurable domain name for sources, adding source domain int MapTiler configuration, cleanup

* Migrating tests to MapTiler, adding code for canonicalizing URLs, removing mapbox stuff from comments, cleanup

* More tests

* Updated database size

* Lint issues

* Fixed test

* Updating developer config API key

* Fixes for Android, propagaing updated tileServerOptions to native file sources, more tests

* Just a few more fixes

* Propagating updated settings to file sources + additional unit test

* Lint issues

* Removing test filter and fixing incorrect uri

* Release preparation

* macos release notes
This commit is contained in:
Petr Pokorny
2021-06-29 12:44:51 +02:00
committed by GitHub
parent 9a49fa16c9
commit d62ff400c6
398 changed files with 107907 additions and 184517 deletions
Download Patch File Download Diff File Expand all files Collapse all files

288
test/storage/offline_database.test.cpp
View File

@@ -102,21 +102,23 @@ static int databaseAutoVacuum(const std::string& path) {
namespace fixture {
const Resource resource{ Resource::Style, "mapbox://test" };
const Resource tile = Resource::tile("mapbox://test", 1, 0, 0, 0, Tileset::Scheme::XYZ);
const Resource resource{ Resource::Style, "maptiler://test" };
const Resource tile = Resource::tile("maptiler://test", 1, 0, 0, 0, Tileset::Scheme::XYZ);
const Response response = [] {
Response res;
res.data = std::make_shared<std::string>("first");
return res;
}();
const TileServerOptions& tileServerOptions = TileServerOptions::MapTilerConfiguration();
} // namespace fixture
TEST(OfflineDatabase, TEST_REQUIRES_WRITE(Create)) {
FixtureLog log;
deleteDatabaseFiles();
OfflineDatabase db(filename);
EXPECT_FALSE(bool(db.get({ Resource::Unknown, "mapbox://test" })));
OfflineDatabase db(filename, fixture::tileServerOptions);
EXPECT_FALSE(bool(db.get({ Resource::Unknown, "maptiler://test" })));
EXPECT_EQ(0u, log.uncheckedCount());
}
@@ -131,7 +133,7 @@ TEST(OfflineDatabase, TEST_REQUIRES_WRITE(CreateFail)) {
// it is not allowed to create the file. The OfflineDatabase object should handle this gracefully
// and treat it like an empty cache that can't be written to.
fs.allowFileCreate(false);
OfflineDatabase db(filename_test_fs);
OfflineDatabase db(filename_test_fs, fixture::tileServerOptions);
EXPECT_EQ(1u, log.count(warning(ResultCode::CantOpen, "Can't open database: unable to open database file")));
EXPECT_EQ(0u, log.uncheckedCount());
@@ -224,12 +226,12 @@ TEST(OfflineDatabase, TEST_REQUIRES_WRITE(SchemaVersion)) {
}
{
OfflineDatabase db(filename);
OfflineDatabase db(filename, fixture::tileServerOptions);
}
EXPECT_EQ(6, databaseUserVersion(filename));
OfflineDatabase db(filename);
OfflineDatabase db(filename, fixture::tileServerOptions);
// Now try inserting and reading back to make sure we have a valid database.
for (const auto& res : { fixture::resource, fixture::tile }) {
EXPECT_EQ(std::make_pair(true, uint64_t(5)), db.put(res, fixture::response));
@@ -248,7 +250,7 @@ TEST(OfflineDatabase, TEST_REQUIRES_WRITE(Invalid)) {
deleteDatabaseFiles();
util::write_file(filename, "this is an invalid file");
OfflineDatabase db(filename);
OfflineDatabase db(filename, fixture::tileServerOptions);
// Checking two possibilities for the error string because it apparently changes between SQLite versions.
EXPECT_EQ(1u, log.count(error(ResultCode::NotADB, "Can't open database: file is encrypted or is not a database"), true) +
log.count(error(ResultCode::NotADB, "Can't open database: file is not a database"), true));
@@ -267,7 +269,7 @@ TEST(OfflineDatabase, TEST_REQUIRES_WRITE(Invalid)) {
TEST(OfflineDatabase, PutDoesNotStoreConnectionErrors) {
FixtureLog log;
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
Resource resource { Resource::Unknown, "http://example.com/" };
Response response;
@@ -281,7 +283,7 @@ TEST(OfflineDatabase, PutDoesNotStoreConnectionErrors) {
TEST(OfflineDatabase, PutDoesNotStoreServerErrors) {
FixtureLog log;
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
Resource resource { Resource::Unknown, "http://example.com/" };
Response response;
@@ -295,7 +297,7 @@ TEST(OfflineDatabase, PutDoesNotStoreServerErrors) {
TEST(OfflineDatabase, PutResource) {
FixtureLog log;
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
Resource resource { Resource::Style, "http://example.com/" };
Response response;
@@ -326,9 +328,9 @@ TEST(OfflineDatabase, TEST_REQUIRES_WRITE(GetResourceFromOfflineRegion)) {
deleteDatabaseFiles();
util::copyFile(filename, "test/fixtures/offline_database/satellite_test.db");
OfflineDatabase db(filename);
OfflineDatabase db(filename, fixture::tileServerOptions);
Resource resource = Resource::style("mapbox://styles/mapbox/satellite-v9");
Resource resource = Resource::style("maptiler://maps/hybrid");
ASSERT_TRUE(db.get(resource));
EXPECT_EQ(0u, log.uncheckedCount());
@@ -336,12 +338,12 @@ TEST(OfflineDatabase, TEST_REQUIRES_WRITE(GetResourceFromOfflineRegion)) {
TEST(OfflineDatabase, PutAndGetResource) {
FixtureLog log;
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
Response response1;
response1.data = std::make_shared<std::string>("foobar");
Resource resource = Resource::style("mapbox://example.com/style");
Resource resource = Resource::style("maptiler://example.com/style");
db.put(resource, response1);
@@ -354,7 +356,7 @@ TEST(OfflineDatabase, PutAndGetResource) {
TEST(OfflineDatabase, PutTile) {
FixtureLog log;
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
Resource resource { Resource::Tile, "http://example.com/" };
resource.tileData = Resource::TileData {
@@ -389,7 +391,7 @@ TEST(OfflineDatabase, PutTile) {
TEST(OfflineDatabase, PutResourceNoContent) {
FixtureLog log;
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
Resource resource { Resource::Style, "http://example.com/" };
Response response;
@@ -406,7 +408,7 @@ TEST(OfflineDatabase, PutResourceNoContent) {
TEST(OfflineDatabase, PutTileNotFound) {
FixtureLog log;
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
Resource resource { Resource::Tile, "http://example.com/" };
resource.tileData = Resource::TileData {
@@ -430,7 +432,7 @@ TEST(OfflineDatabase, PutTileNotFound) {
TEST(OfflineDatabase, CreateRegion) {
FixtureLog log;
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
OfflineTilePyramidRegionDefinition definition { "http://example.com/style", LatLngBounds::hull({1, 2}, {3, 4}), 5, 6, 2.0, true };
OfflineRegionMetadata metadata {{ 1, 2, 3 }};
auto region = db.createRegion(definition, metadata);
@@ -455,7 +457,7 @@ TEST(OfflineDatabase, CreateRegion) {
TEST(OfflineDatabase, UpdateMetadata) {
FixtureLog log;
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
OfflineTilePyramidRegionDefinition definition { "http://example.com/style", LatLngBounds::hull({1, 2}, {3, 4}), 5, 6, 2.0, true };
OfflineRegionMetadata metadata {{ 1, 2, 3 }};
auto region = db.createRegion(definition, metadata);
@@ -471,7 +473,7 @@ TEST(OfflineDatabase, UpdateMetadata) {
TEST(OfflineDatabase, ListRegions) {
FixtureLog log;
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
OfflineTilePyramidRegionDefinition definition { "http://example.com/style", LatLngBounds::hull({1, 2}, {3, 4}), 5, 6, 2.0, false };
OfflineRegionMetadata metadata {{ 1, 2, 3 }};
@@ -501,7 +503,7 @@ TEST(OfflineDatabase, ListRegions) {
TEST(OfflineDatabase, GetRegionDefinition) {
FixtureLog log;
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
OfflineTilePyramidRegionDefinition definition { "http://example.com/style", LatLngBounds::hull({1, 2}, {3, 4}), 5, 6, 2.0, false };
OfflineRegionMetadata metadata {{ 1, 2, 3 }};
@@ -533,7 +535,7 @@ TEST(OfflineDatabase, TEST_REQUIRES_WRITE(DISABLED_MaximumAmbientCacheSize)) {
};
{
OfflineDatabase db(filename);
OfflineDatabase db(filename, fixture::tileServerOptions);
}
size_t initialSize = util::read_file(filename).size();
@@ -543,26 +545,26 @@ TEST(OfflineDatabase, TEST_REQUIRES_WRITE(DISABLED_MaximumAmbientCacheSize)) {
response.data = randomString(100 * 1024);
{
OfflineDatabase db(filename);
OfflineDatabase db(filename, fixture::tileServerOptions);
db.setMaximumAmbientCacheSize(maximumSize); // 50 MB
OfflineTilePyramidRegionDefinition definition{ "mapbox://style", LatLngBounds::hull({1, 2}, {3, 4}), 5, 6, 2.0, true };
OfflineTilePyramidRegionDefinition definition{ "maptiler://masp/style", LatLngBounds::hull({1, 2}, {3, 4}), 5, 6, 2.0, true };
OfflineRegionMetadata metadata{{ 1, 2, 3 }};
auto region = db.createRegion(definition, metadata);
// Add 100 MB of resources (50/50 ambient/region)
for (unsigned i = 0; i < 250; ++i) {
const Resource ambientTile = Resource::tile("mapbox://ambient_tile_" + std::to_string(i), 1, 0, 0, 0, Tileset::Scheme::XYZ);
const Resource ambientTile = Resource::tile("maptiler://tiles/tiles/ambient_tile_" + std::to_string(i), 1, 0, 0, 0, Tileset::Scheme::XYZ);
db.put(ambientTile, response);
const Resource ambientStyle = Resource::style("mapbox://ambient_style_" + std::to_string(i));
const Resource ambientStyle = Resource::style("maptiler://maps/ambient_style_" + std::to_string(i));
db.put(ambientStyle, response);
const Resource regionTile = Resource::tile("mapbox://region_tile_" + std::to_string(i), 1, 0, 0, 0, Tileset::Scheme::XYZ);
const Resource regionTile = Resource::tile("maptiler://tiles/tiles/region_tile_" + std::to_string(i), 1, 0, 0, 0, Tileset::Scheme::XYZ);
db.putRegionResource(region->getID(), regionTile, response);
const Resource regionStyle = Resource::style("mapbox://region_style_" + std::to_string(i));
const Resource regionStyle = Resource::style("maptiler://maps/region_style_" + std::to_string(i));
db.putRegionResource(region->getID(), regionStyle, response);
}
}
@@ -577,7 +579,7 @@ TEST(OfflineDatabase, TEST_REQUIRES_WRITE(DISABLED_MaximumAmbientCacheSize)) {
maximumSize = 30 * 1024 * 1024;
{
OfflineDatabase db(filename);
OfflineDatabase db(filename, fixture::tileServerOptions);
db.setMaximumAmbientCacheSize(maximumSize); // 30 MB
}
@@ -587,7 +589,7 @@ TEST(OfflineDatabase, TEST_REQUIRES_WRITE(DISABLED_MaximumAmbientCacheSize)) {
EXPECT_LE(databaseSize(), 60 * 1024 * 1024);
{
OfflineDatabase db(filename);
OfflineDatabase db(filename, fixture::tileServerOptions);
db.setMaximumAmbientCacheSize(maximumSize); // 30 MB
db.deleteRegion(std::move(db.listRegions().value()[0]));
}
@@ -598,7 +600,7 @@ TEST(OfflineDatabase, TEST_REQUIRES_WRITE(DISABLED_MaximumAmbientCacheSize)) {
EXPECT_GE(databaseSize(), maximumSize / 2);
{
OfflineDatabase db(filename);
OfflineDatabase db(filename, fixture::tileServerOptions);
db.setMaximumAmbientCacheSize(maximumSize * 2); // 60 MB
}
@@ -609,15 +611,15 @@ TEST(OfflineDatabase, TEST_REQUIRES_WRITE(DISABLED_MaximumAmbientCacheSize)) {
EXPECT_GE(databaseSize(), maximumSize / 2);
{
OfflineDatabase db(filename);
OfflineDatabase db(filename, fixture::tileServerOptions);
db.setMaximumAmbientCacheSize(maximumSize); // 30 MB
// Add ~50 MB in ambient cache data.
for (unsigned i = 0; i < 250; ++i) {
const Resource ambientTile = Resource::tile("mapbox://ambient_tile_" + std::to_string(i), 1, 0, 0, 0, Tileset::Scheme::XYZ);
const Resource ambientTile = Resource::tile("maptiler://tiles/tiles/ambient_tile_" + std::to_string(i), 1, 0, 0, 0, Tileset::Scheme::XYZ);
db.put(ambientTile, response);
const Resource ambientStyle = Resource::style("mapbox://ambient_style_" + std::to_string(i));
const Resource ambientStyle = Resource::style("maptiler://mas/ambient_style_" + std::to_string(i));
db.put(ambientStyle, response);
}
}
@@ -630,7 +632,7 @@ TEST(OfflineDatabase, TEST_REQUIRES_WRITE(DISABLED_MaximumAmbientCacheSize)) {
maximumSize = 20 * 1024 * 1024;
{
OfflineDatabase db(filename);
OfflineDatabase db(filename, fixture::tileServerOptions);
db.setMaximumAmbientCacheSize(maximumSize); // 20 MB
}
@@ -639,15 +641,15 @@ TEST(OfflineDatabase, TEST_REQUIRES_WRITE(DISABLED_MaximumAmbientCacheSize)) {
EXPECT_GE(databaseSize(), initialSize);
{
OfflineDatabase db(filename);
OfflineDatabase db(filename, fixture::tileServerOptions);
db.setMaximumAmbientCacheSize(0);
for (unsigned i = 0; i < 5; ++i) {
const Resource ambientTile = Resource::tile("mapbox://ambient_tile_" + std::to_string(i), 1, 0, 0, 0, Tileset::Scheme::XYZ);
const Resource ambientTile = Resource::tile("maptiler://tiles/tiles/ambient_tile_" + std::to_string(i), 1, 0, 0, 0, Tileset::Scheme::XYZ);
db.put(ambientTile, response);
ASSERT_FALSE(db.get(ambientTile));
const Resource ambientStyle = Resource::style("mapbox://ambient_style_" + std::to_string(i));
const Resource ambientStyle = Resource::style("maptiler://maps/ambient_style_" + std::to_string(i));
db.put(ambientStyle, response);
ASSERT_FALSE(db.get(ambientStyle));
}
@@ -679,7 +681,7 @@ TEST(OfflineDatabase, TEST_REQUIRES_WRITE(DeleteRegion)) {
deleteDatabaseFiles();
{
OfflineDatabase dbCreate(filename);
OfflineDatabase dbCreate(filename, fixture::tileServerOptions);
}
size_t initialSize = util::read_file(filename).size();
@@ -688,17 +690,17 @@ TEST(OfflineDatabase, TEST_REQUIRES_WRITE(DeleteRegion)) {
Response response;
response.data = randomString(.5 * 1024 * 1024);
OfflineDatabase db(filename);
OfflineDatabase db(filename, fixture::tileServerOptions);
OfflineTilePyramidRegionDefinition definition{ "mapbox://style", LatLngBounds::hull({1, 2}, {3, 4}), 5, 6, 2.0, true };
OfflineTilePyramidRegionDefinition definition{ "maptiler://maps/style", LatLngBounds::hull({1, 2}, {3, 4}), 5, 6, 2.0, true };
OfflineRegionMetadata metadata{{ 1, 2, 3 }};
auto region1 = db.createRegion(definition, metadata);
auto region2 = db.createRegion(definition, metadata);
OfflineRegionStatus status;
db.putRegionResources(region1->getID(), generateResources("mapbox://tile_1", "mapbox://style_1"), status);
db.putRegionResources(region2->getID(), generateResources("mapbox://tile_2", "mapbox://style_2"), status);
db.putRegionResources(region1->getID(), generateResources("maptiler://tiles/tiles/tile_1", "maptiler://maps/style_1"), status);
db.putRegionResources(region2->getID(), generateResources("maptiler://tiles/tiles/tile_2", "maptiler://maps/style_2"), status);
const size_t sizeWithTwoRegions = util::read_file(filename).size();
db.runPackDatabaseAutomatically(false);
@@ -740,7 +742,7 @@ TEST(OfflineDatabase, TEST_REQUIRES_WRITE(Pack)) {
FixtureLog log;
deleteDatabaseFiles();
OfflineDatabase db(filename);
OfflineDatabase db(filename, fixture::tileServerOptions);
size_t initialSize = util::read_file(filename).size();
db.runPackDatabaseAutomatically(false);
@@ -748,10 +750,10 @@ TEST(OfflineDatabase, TEST_REQUIRES_WRITE(Pack)) {
response.data = randomString(.5 * 1024 * 1024);
for (unsigned i = 0; i < 50; ++i) {
const Resource tile = Resource::tile("mapbox://tile_" + std::to_string(i), 1, 0, 0, 0, Tileset::Scheme::XYZ);
const Resource tile = Resource::tile("maptiler://tiles/tiles/tile_" + std::to_string(i), 1, 0, 0, 0, Tileset::Scheme::XYZ);
db.put(tile, response);
const Resource style = Resource::style("mapbox://style_" + std::to_string(i));
const Resource style = Resource::style("maptiler://maps/style_" + std::to_string(i));
db.put(style, response);
}
size_t populatedSize = util::read_file(filename).size();
@@ -771,26 +773,26 @@ TEST(OfflineDatabase, MapboxTileLimitExceeded) {
uint64_t limit = 60;
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
db.setOfflineMapboxTileCountLimit(limit);
Response response;
response.data = randomString(4096);
auto insertAmbientTile = [&](unsigned i) {
const Resource ambientTile = Resource::tile("mapbox://ambient_tile_" + std::to_string(i), 1, 0, 0, 0, Tileset::Scheme::XYZ);
const Resource ambientTile = Resource::tile("maptiler://tiles/tiles/ambient_tile_" + std::to_string(i), 1, 0, 0, 0, Tileset::Scheme::XYZ);
db.put(ambientTile, response);
};
auto insertRegionTile = [&](int64_t regionID, uint64_t i) {
const Resource tile = Resource::tile("mapbox://region_tile_" + std::to_string(i), 1, 0, 0, 0, Tileset::Scheme::XYZ);
const Resource tile = Resource::tile("maptiler://tiles/tiles/region_tile_" + std::to_string(i), 1, 0, 0, 0, Tileset::Scheme::XYZ);
db.putRegionResource(regionID, tile, response);
};
OfflineTilePyramidRegionDefinition definition1{ "mapbox://style1", LatLngBounds::hull({1, 2}, {3, 4}), 5, 6, 2.0, true };
OfflineTilePyramidRegionDefinition definition1{ "maptiler://maps/style1", LatLngBounds::hull({1, 2}, {3, 4}), 5, 6, 2.0, true };
OfflineRegionMetadata metadata1{{ 1, 2, 3 }};
OfflineTilePyramidRegionDefinition definition2{ "mapbox://style2", LatLngBounds::hull({1, 2}, {3, 4}), 5, 6, 2.0, true };
OfflineTilePyramidRegionDefinition definition2{ "maptiler://maps/style2", LatLngBounds::hull({1, 2}, {3, 4}), 5, 6, 2.0, true };
OfflineRegionMetadata metadata2{{ 1, 2, 3 }};
auto region1 = db.createRegion(definition1, metadata1);
@@ -868,34 +870,34 @@ TEST(OfflineDatabase, Invalidate) {
using namespace std::chrono_literals;
FixtureLog log;
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
Response response;
response.noContent = true;
response.mustRevalidate = false;
response.expires = util::now() + 1h;
const Resource ambientTile = Resource::tile("mapbox://tile_ambient", 1, 0, 0, 0, Tileset::Scheme::XYZ);
const Resource ambientTile = Resource::tile("maptiler://tiles/tiles/tile_ambient", 1, 0, 0, 0, Tileset::Scheme::XYZ);
db.put(ambientTile, response);
const Resource ambientStyle = Resource::style("mapbox://style_ambient");
const Resource ambientStyle = Resource::style("maptiler://maps/style_ambient");
db.put(ambientStyle, response);
OfflineTilePyramidRegionDefinition definition { "mapbox://style", LatLngBounds::hull({1, 2}, {3, 4}), 5, 6, 2.0, true };
OfflineTilePyramidRegionDefinition definition { "maptiler://maps/style", LatLngBounds::hull({1, 2}, {3, 4}), 5, 6, 2.0, true };
OfflineRegionMetadata metadata {{ 1, 2, 3 }};
auto region1 = db.createRegion(definition, metadata);
const Resource region1Tile = Resource::tile("mapbox://tile_offline_region1", 1.0, 0, 0, 0, Tileset::Scheme::XYZ);
const Resource region1Tile = Resource::tile("maptiler://tiles/tiles/tile_offline_region1", 1.0, 0, 0, 0, Tileset::Scheme::XYZ);
db.putRegionResource(region1->getID(), region1Tile, response);
const Resource region1Style = Resource::style("mapbox://style_offline_region1");
const Resource region1Style = Resource::style("maptiler://maps/style_offline_region1");
db.putRegionResource(region1->getID(), region1Style, response);
auto region2 = db.createRegion(definition, metadata);
const Resource region2Tile = Resource::tile("mapbox://tile_offline_region2", 1.0, 0, 0, 0, Tileset::Scheme::XYZ);
const Resource region2Tile = Resource::tile("maptiler://tiles/tiles/tile_offline_region2", 1.0, 0, 0, 0, Tileset::Scheme::XYZ);
db.putRegionResource(region2->getID(), region2Tile, response);
const Resource region2Style = Resource::style("mapbox://style_offline_region2");
const Resource region2Style = Resource::style("maptiler://maps/style_offline_region2");
db.putRegionResource(region2->getID(), region2Style, response);
// Prior to invalidation, all tiles are usable.
@@ -960,7 +962,7 @@ TEST(OfflineDatabase, TEST_REQUIRES_WRITE(ClearAmbientCache)) {
deleteDatabaseFiles();
{
OfflineDatabase dbCreate(filename);
OfflineDatabase dbCreate(filename, fixture::tileServerOptions);
}
size_t initialSize = util::read_file(filename).size();
@@ -969,13 +971,13 @@ TEST(OfflineDatabase, TEST_REQUIRES_WRITE(ClearAmbientCache)) {
Response response;
response.data = randomString(.5 * 1024 * 1024);
OfflineDatabase db(filename);
OfflineDatabase db(filename, fixture::tileServerOptions);
for (unsigned i = 0; i < 50; ++i) {
const Resource tile = Resource::tile("mapbox://tile_" + std::to_string(i), 1, 0, 0, 0, Tileset::Scheme::XYZ);
const Resource tile = Resource::tile("maptiler://tiles/tiles/tile_" + std::to_string(i), 1, 0, 0, 0, Tileset::Scheme::XYZ);
db.put(tile, response);
const Resource style = Resource::style("mapbox://style_" + std::to_string(i));
const Resource style = Resource::style("maptiler://maps/style_" + std::to_string(i));
db.put(style, response);
}
@@ -988,7 +990,7 @@ TEST(OfflineDatabase, TEST_REQUIRES_WRITE(ClearAmbientCache)) {
TEST(OfflineDatabase, CreateRegionInfiniteMaxZoom) {
FixtureLog log;
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
OfflineTilePyramidRegionDefinition definition { "", LatLngBounds::world(), 0, INFINITY, 1.0, false };
OfflineRegionMetadata metadata;
auto region = db.createRegion(definition, metadata);
@@ -1006,10 +1008,10 @@ TEST(OfflineDatabase, TEST_REQUIRES_WRITE(ConcurrentUse)) {
FixtureLog log;
deleteDatabaseFiles();
OfflineDatabase db1(filename);
OfflineDatabase db1(filename, fixture::tileServerOptions);
EXPECT_EQ(0u, log.uncheckedCount());
OfflineDatabase db2(filename);
OfflineDatabase db2(filename, fixture::tileServerOptions);
std::thread thread1([&] {
for (auto i = 0; i < 100; i++) {
@@ -1037,7 +1039,7 @@ TEST(OfflineDatabase, TEST_REQUIRES_WRITE(ConcurrentUse)) {
TEST(OfflineDatabase, PutReturnsSize) {
FixtureLog log;
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
Response compressible;
compressible.data = std::make_shared<std::string>(1024, 0);
@@ -1056,7 +1058,7 @@ TEST(OfflineDatabase, PutReturnsSize) {
TEST(OfflineDatabase, PutEvictsLeastRecentlyUsedResources) {
FixtureLog log;
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
db.setMaximumAmbientCacheSize(1024 * 100);
Response response;
@@ -1076,7 +1078,7 @@ TEST(OfflineDatabase, PutEvictsLeastRecentlyUsedResources) {
TEST(OfflineDatabase, OfflineRegionDoesNotAffectAmbientCacheSize) {
FixtureLog log;
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
unsigned dataSize = 1024u * 100u;
unsigned numberOfCachedResources = 2u;
unsigned databasePage = 4096u;
@@ -1097,10 +1099,10 @@ TEST(OfflineDatabase, OfflineRegionDoesNotAffectAmbientCacheSize) {
// 1MB of offline region data.
for (std::size_t i = 0; i < 5; ++i) {
const Resource tile = Resource::tile("mapbox://tile_" + std::to_string(i), 1, 0, 0, 0, Tileset::Scheme::XYZ);
const Resource tile = Resource::tile("maptiler://tiles/tiles/tile_" + std::to_string(i), 1, 0, 0, 0, Tileset::Scheme::XYZ);
db.putRegionResource(region->getID(), tile, response);
const Resource style = Resource::style("mapbox://style_" + std::to_string(i));
const Resource style = Resource::style("maptiler://maps/style_" + std::to_string(i));
db.putRegionResource(region->getID(), style, response);
}
@@ -1115,7 +1117,7 @@ TEST(OfflineDatabase, OfflineRegionDoesNotAffectAmbientCacheSize) {
TEST(OfflineDatabase, PutRegionResourceDoesNotEvict) {
FixtureLog log;
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
db.setMaximumAmbientCacheSize(1024 * 100);
OfflineTilePyramidRegionDefinition definition { "", LatLngBounds::world(), 0, INFINITY, 1.0, true };
@@ -1137,7 +1139,7 @@ TEST(OfflineDatabase, PutRegionResourceDoesNotEvict) {
TEST(OfflineDatabase, PutFailsWhenEvictionInsuffices) {
FixtureLog log;
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
db.setMaximumAmbientCacheSize(1024 * 100);
Response big;
@@ -1156,7 +1158,7 @@ TEST(OfflineDatabase, PutFailsWhenEvictionInsuffices) {
TEST(OfflineDatabase, GetRegionCompletedStatus) {
FixtureLog log;
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
OfflineTilePyramidRegionDefinition definition { "http://example.com/style", LatLngBounds::hull({1, 2}, {3, 4}), 5, 6, 2.0, false };
OfflineRegionMetadata metadata;
auto region = db.createRegion(definition, metadata);
@@ -1195,7 +1197,7 @@ TEST(OfflineDatabase, GetRegionCompletedStatus) {
TEST(OfflineDatabase, HasRegionResource) {
FixtureLog log;
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
db.setMaximumAmbientCacheSize(1024 * 100);
OfflineTilePyramidRegionDefinition definition { "", LatLngBounds::world(), 0, INFINITY, 1.0, true };
@@ -1221,7 +1223,7 @@ TEST(OfflineDatabase, HasRegionResource) {
TEST(OfflineDatabase, HasRegionResourceTile) {
FixtureLog log;
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
db.setMaximumAmbientCacheSize(1024 * 100);
OfflineTilePyramidRegionDefinition definition { "", LatLngBounds::world(), 0, INFINITY, 1.0, false };
@@ -1257,7 +1259,7 @@ TEST(OfflineDatabase, HasRegionResourceTile) {
TEST(OfflineDatabase, OfflineMapboxTileCount) {
FixtureLog log;
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
OfflineTilePyramidRegionDefinition definition { "http://example.com/style", LatLngBounds::hull({1, 2}, {3, 4}), 5, 6, 2.0 , true};
OfflineRegionMetadata metadata;
@@ -1267,8 +1269,8 @@ TEST(OfflineDatabase, OfflineMapboxTileCount) {
ASSERT_TRUE(region2);
Resource nonMapboxTile = Resource::tile("http://example.com/", 1.0, 0, 0, 0, Tileset::Scheme::XYZ);
Resource mapboxTile1 = Resource::tile("mapbox://tiles/1", 1.0, 0, 0, 0, Tileset::Scheme::XYZ);
Resource mapboxTile2 = Resource::tile("mapbox://tiles/2", 1.0, 0, 0, 1, Tileset::Scheme::XYZ);
Resource mapboxTile1 = Resource::tile("maptiler://tiles/tiles/1", 1.0, 0, 0, 0, Tileset::Scheme::XYZ);
Resource mapboxTile2 = Resource::tile("maptiler://tiles/tiles/2", 1.0, 0, 0, 1, Tileset::Scheme::XYZ);
Response response;
response.data = std::make_shared<std::string>("data");
@@ -1318,7 +1320,7 @@ TEST(OfflineDatabase, OfflineMapboxTileCount) {
TEST(OfflineDatabase, BatchInsertion) {
FixtureLog log;
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
db.setMaximumAmbientCacheSize(1024 * 100);
OfflineTilePyramidRegionDefinition definition { "", LatLngBounds::world(), 0, INFINITY, 1.0, true };
@@ -1345,7 +1347,7 @@ TEST(OfflineDatabase, BatchInsertion) {
TEST(OfflineDatabase, BatchInsertionMapboxTileCountExceeded) {
FixtureLog log;
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
db.setOfflineMapboxTileCountLimit(1);
db.setMaximumAmbientCacheSize(1024 * 100);
@@ -1358,8 +1360,8 @@ TEST(OfflineDatabase, BatchInsertionMapboxTileCountExceeded) {
std::list<std::tuple<Resource, Response>> resources;
resources.emplace_back(Resource::style("http://example.com/"), response);
resources.emplace_back(Resource::tile("mapbox://tiles/1", 1.0, 0, 0, 0, Tileset::Scheme::XYZ), response);
resources.emplace_back(Resource::tile("mapbox://tiles/2", 1.0, 0, 0, 0, Tileset::Scheme::XYZ), response);
resources.emplace_back(Resource::tile("maptiler://tiles/1", 1.0, 0, 0, 0, Tileset::Scheme::XYZ), response);
resources.emplace_back(Resource::tile("maptiler://tiles/2", 1.0, 0, 0, 0, Tileset::Scheme::XYZ), response);
OfflineRegionStatus status;
try {
@@ -1385,7 +1387,7 @@ TEST(OfflineDatabase, MigrateFromV2Schema) {
util::copyFile(filename, "test/fixtures/offline_database/v2.db");
{
OfflineDatabase db(filename);
OfflineDatabase db(filename, fixture::tileServerOptions);
db.setMaximumAmbientCacheSize(0);
auto regions = db.listRegions();
@@ -1409,7 +1411,7 @@ TEST(OfflineDatabase, MigrateFromV3Schema) {
util::copyFile(filename, "test/fixtures/offline_database/v3.db");
{
OfflineDatabase db(filename);
OfflineDatabase db(filename, fixture::tileServerOptions);
db.setMaximumAmbientCacheSize(0);
auto regions = db.listRegions().value();
@@ -1430,7 +1432,7 @@ TEST(OfflineDatabase, MigrateFromV4Schema) {
util::copyFile(filename, "test/fixtures/offline_database/v4.db");
{
OfflineDatabase db(filename);
OfflineDatabase db(filename, fixture::tileServerOptions);
db.setMaximumAmbientCacheSize(0);
auto regions = db.listRegions().value();
@@ -1458,7 +1460,7 @@ TEST(OfflineDatabase, MigrateFromV5Schema) {
util::copyFile(filename, "test/fixtures/offline_database/v5.db");
{
OfflineDatabase db(filename);
OfflineDatabase db(filename, fixture::tileServerOptions);
db.setMaximumAmbientCacheSize(0);
auto regions = db.listRegions().value();
@@ -1498,7 +1500,7 @@ TEST(OfflineDatabase, IncrementalVacuum) {
EXPECT_EQ(0, databaseAutoVacuum(filename));
{
OfflineDatabase db(filename);
OfflineDatabase db(filename, fixture::tileServerOptions);
db.setMaximumAmbientCacheSize(0);
auto regions = db.listRegions().value();
@@ -1520,7 +1522,7 @@ TEST(OfflineDatabase, DowngradeSchema) {
util::copyFile(filename, "test/fixtures/offline_database/v999.db");
{
OfflineDatabase db(filename);
OfflineDatabase db(filename, fixture::tileServerOptions);
db.setMaximumAmbientCacheSize(0);
}
@@ -1544,7 +1546,7 @@ TEST(OfflineDatabase, CorruptDatabaseOnOpen) {
util::copyFile(filename, "test/fixtures/offline_database/corrupt-immediate.db");
// This database is corrupt in a way that will prevent opening the database.
OfflineDatabase db(filename);
OfflineDatabase db(filename, fixture::tileServerOptions);
EXPECT_EQ(1u, log.count(error(ResultCode::Corrupt, "Can't open database: database disk image is malformed"), true));
EXPECT_EQ(1u, log.count({ EventSeverity::Warning, Event::Database, -1, "Removing existing incompatible offline database" }));
EXPECT_EQ(0u, log.uncheckedCount());
@@ -1567,7 +1569,7 @@ TEST(OfflineDatabase, CorruptDatabaseOnQuery) {
// This database is corrupt in a way that won't manifest itself until we start querying it,
// so just opening it will not cause an error.
OfflineDatabase db(filename);
OfflineDatabase db(filename, fixture::tileServerOptions);
// Just opening this corrupt database should not have produced an error yet, since
// PRAGMA user_version still succeeds with this database.
@@ -1596,12 +1598,12 @@ TEST(OfflineDatabase, TEST_REQUIRES_WRITE(DisallowedIO)) {
deleteDatabaseFiles();
test::SQLite3TestFS fs;
OfflineDatabase db(filename_test_fs);
OfflineDatabase db(filename_test_fs, fixture::tileServerOptions);
EXPECT_EQ(0u, log.uncheckedCount());
// First, create a region object so that we can try deleting it later.
OfflineTilePyramidRegionDefinition definition(
"mapbox://style", LatLngBounds::hull({ 37.66, -122.57 }, { 37.83, -122.32 }), 0, 8, 2, false);
"maptiler://maps/style", LatLngBounds::hull({ 37.66, -122.57 }, { 37.83, -122.32 }), 0, 8, 2, false);
auto region = db.createRegion(definition, {});
ASSERT_TRUE(region);
@@ -1671,17 +1673,19 @@ TEST(OfflineDatabase, MergeDatabaseWithSingleRegion_New) {
util::deleteFile(filename_sideload);
util::copyFile(filename_sideload, "test/fixtures/offline_database/sideload_sat.db");
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
EXPECT_EQ(0u, db.listRegions()->size());
OfflineDatabase db_sideload(filename_sideload, fixture::tileServerOptions);
auto newRegionsCount = db_sideload.listRegions()->size();
auto result = db.mergeDatabase(filename_sideload);
EXPECT_EQ(1u, result->size());
EXPECT_EQ(1u, db.listRegions()->size());
EXPECT_EQ(newRegionsCount, db.listRegions()->size());
auto regionId = result->front().getID();
auto status = db.getRegionCompletedStatus(regionId);
EXPECT_EQ(2u, status->completedResourceCount);
EXPECT_EQ(1u, status->completedTileCount);
EXPECT_EQ(398u, status->completedResourceCount);
EXPECT_EQ(5u, status->completedTileCount);
}
TEST(OfflineDatabase, TEST_REQUIRES_WRITE(MergeDatabaseWithSingleRegion_Update)) {
@@ -1692,69 +1696,77 @@ TEST(OfflineDatabase, TEST_REQUIRES_WRITE(MergeDatabaseWithSingleRegion_Update))
int64_t regionId;
{
OfflineDatabase db(filename);
std::string tileURL = "maptiler://tiles/tiles/satellite/{z}/{x}/{y}{ratio}.jpg";
OfflineDatabase db1(filename_sideload, fixture::tileServerOptions);
auto originalTile = db1.getRegionResource(
Resource::tile(tileURL, 1, 0, 0, 1, Tileset::Scheme::XYZ));
auto originalStamp = originalTile->first.modified;
OfflineDatabase db(filename, fixture::tileServerOptions);
auto regions = db.listRegions();
EXPECT_EQ(1u, db.listRegions()->size());
regionId = regions->front().getID();
auto result = db.mergeDatabase(filename_sideload);
EXPECT_EQ(1u, result->size());
// When updating an identical region, the region id remains unchanged.
EXPECT_EQ(regionId, result->front().getID());
auto status = db.getRegionCompletedStatus(regionId);
EXPECT_EQ(5u, status->completedResourceCount);
EXPECT_EQ(1u, status->completedTileCount);
EXPECT_EQ(395u, status->completedResourceCount);
EXPECT_EQ(2u, status->completedTileCount);
//Verify the modified timestamp matches the tile in the sideloaded db.
auto updatedTile = db.getRegionResource(
Resource::tile("mapbox://tiles/mapbox.satellite/{z}/{x}/{y}{ratio}.webp",
1, 0, 0, 1, Tileset::Scheme::XYZ));
EXPECT_EQ(Timestamp{ Seconds(1520409600) }, *(updatedTile->first.modified));
Resource::tile(tileURL, 1, 0, 0, 1, Tileset::Scheme::XYZ));
auto updatedStamp = updatedTile->first.modified;
EXPECT_EQ(*originalStamp, *updatedStamp);
}
}
TEST(OfflineDatabase, MergeDatabaseWithSingleRegion_NoUpdate) {
deleteDatabaseFiles();
util::deleteFile(filename_sideload);
//Swap sideload/main database from update test and ensure that an older tile is not copied over
util::copyFile(filename_sideload, "test/fixtures/offline_database/satellite_test.db");
util::copyFile(filename, "test/fixtures/offline_database/sideload_sat.db");
OfflineDatabase db(filename);
OfflineDatabase db(filename, fixture::tileServerOptions);
std::string tileURL = "maptiler://tiles/tiles/satellite/{z}/{x}/{y}{ratio}.jpg";
auto originalTile = db.getRegionResource(Resource::tile(tileURL, 1, 0, 0, 1, Tileset::Scheme::XYZ));
auto originalStamp = originalTile->first.modified;
auto result = db.mergeDatabase(filename_sideload);
EXPECT_EQ(1u, result->size());
EXPECT_EQ(1u, db.listRegions()->size());
EXPECT_EQ(2u, db.listRegions()->size());
auto updatedTile = db.getRegionResource(
Resource::tile("mapbox://tiles/mapbox.satellite/{z}/{x}/{y}{ratio}.webp",
1, 0, 0, 1, Tileset::Scheme::XYZ));
auto updatedTile = db.getRegionResource(Resource::tile(tileURL,1, 0, 0, 1, Tileset::Scheme::XYZ));
//Verify the modified timestamp matches the tile in the main db.
EXPECT_EQ(Timestamp{ Seconds(1520409600) }, *(updatedTile->first.modified));
EXPECT_EQ(originalStamp, updatedTile->first.modified);
}
TEST(OfflineDatabase, MergeDatabaseWithSingleRegion_AmbientTiles) {
util::deleteFile(filename_sideload);
util::copyFile(filename_sideload, "test/fixtures/offline_database/sideload_ambient.db");
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
auto result = db.mergeDatabase(filename_sideload);
EXPECT_TRUE(bool(db.hasRegionResource(Resource::tile("mapbox://tiles/mapbox.satellite/{z}/{x}/{y}{ratio}.png", 1, 0, 0, 1, Tileset::Scheme::XYZ))));
EXPECT_TRUE(bool(db.hasRegionResource(Resource::tile("maptiler://tiles/tiles/satellite/{z}/{x}/{y}{ratio}.jpg", 1, 0, 0, 1, Tileset::Scheme::XYZ))));
//Ambient resources should not be copied
EXPECT_FALSE(bool(db.hasRegionResource(Resource::style("mapbox://styles/mapbox/streets-v9"))));
EXPECT_FALSE(bool(db.hasRegionResource(Resource::tile("mapbox://tiles/mapbox.satellite/{z}/{x}/{y}{ratio}.png", 1, 0, 1, 2, Tileset::Scheme::XYZ))));
EXPECT_FALSE(bool(db.hasRegionResource(Resource::tile("mapbox://tiles/mapbox.satellite/{z}/{x}/{y}{ratio}.png", 1, 1, 1, 2, Tileset::Scheme::XYZ))));
EXPECT_FALSE(bool(db.hasRegionResource(Resource::style("maptiler://maps/streets"))));
EXPECT_FALSE(bool(db.hasRegionResource(Resource::tile("maptiler://tiles/tiles/satellite/{z}/{x}/{y}{ratio}.jpg", 1, 0, 1, 2, Tileset::Scheme::XYZ))));
EXPECT_FALSE(bool(db.hasRegionResource(Resource::tile("maptiler://tiles/tiles/satellite/{z}/{x}/{y}{ratio}.jpg", 1, 1, 1, 2, Tileset::Scheme::XYZ))));
}
TEST(OfflineDatabase, MergeDatabaseWithMultipleRegions_New) {
util::deleteFile(filename_sideload);
util::copyFile(filename_sideload, "test/fixtures/offline_database/sideload_sat_multiple.db");
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
EXPECT_EQ(0u, db.listRegions()->size());
auto result = db.mergeDatabase(filename_sideload);
@@ -1763,13 +1775,13 @@ TEST(OfflineDatabase, MergeDatabaseWithMultipleRegions_New) {
auto region1Id = result->front().getID();
auto status = db.getRegionCompletedStatus(region1Id);
EXPECT_EQ(4u, status->completedResourceCount);
EXPECT_EQ(3u, status->completedTileCount);
EXPECT_EQ(398u, status->completedResourceCount);
EXPECT_EQ(5u, status->completedTileCount);
auto region2Id = result->back().getID();
status = db.getRegionCompletedStatus(region2Id);
EXPECT_EQ(1u, status->completedTileCount);
EXPECT_EQ(2u, status->completedResourceCount);
EXPECT_EQ(0u, status->completedTileCount);
EXPECT_EQ(200u, status->completedResourceCount);
}
TEST(OfflineDatabase, MergeDatabaseWithMultipleRegionsWithOverlap) {
@@ -1779,12 +1791,12 @@ TEST(OfflineDatabase, MergeDatabaseWithMultipleRegionsWithOverlap) {
util::copyFile(filename_sideload, "test/fixtures/offline_database/sideload_sat_multiple.db");
{
OfflineDatabase db(filename);
OfflineDatabase db(filename, fixture::tileServerOptions);
EXPECT_EQ(1u, db.listRegions()->size());
auto result = db.mergeDatabase(filename_sideload);
EXPECT_EQ(2u, result->size());
EXPECT_EQ(3u, db.listRegions()->size());
EXPECT_EQ(2u, db.listRegions()->size());
}
mapbox::sqlite::Database db = mapbox::sqlite::Database::open(filename, mapbox::sqlite::ReadOnly);
@@ -1798,7 +1810,7 @@ TEST(OfflineDatabase, MergeDatabaseWithMultipleRegionsWithOverlap) {
query.run();
// Ensure multiple entries for tiles shared between regions
EXPECT_EQ(1 + 3 + 1, query.get<int>(0));
EXPECT_EQ(5, query.get<int>(0));
}
{
// clang-format off
@@ -1810,7 +1822,7 @@ TEST(OfflineDatabase, MergeDatabaseWithMultipleRegionsWithOverlap) {
query.run();
// Ensure multiple entries for resources shared between regions
EXPECT_EQ(1 + 1 + 1, query.get<int>(0));
EXPECT_EQ(593, query.get<int>(0));
}
}
@@ -1819,7 +1831,7 @@ TEST(OfflineDatabase, MergeDatabaseWithSingleRegionTooManyNewTiles) {
util::deleteFile(filename_sideload);
util::copyFile(filename_sideload, "test/fixtures/offline_database/sideload_sat_multiple.db");
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
db.setOfflineMapboxTileCountLimit(1);
auto result = db.mergeDatabase(filename_sideload);
@@ -1835,7 +1847,7 @@ TEST(OfflineDatabase, MergeDatabaseWithSingleRegionTooManyExistingTiles) {
util::copyFile(filename, "test/fixtures/offline_database/sideload_sat_multiple.db");
util::copyFile(filename_sideload, "test/fixtures/offline_database/satellite_test.db");
OfflineDatabase db(filename);
OfflineDatabase db(filename, fixture::tileServerOptions);
db.setOfflineMapboxTileCountLimit(2);
auto result = db.mergeDatabase(filename_sideload);
@@ -1851,7 +1863,7 @@ TEST(OfflineDatabase, MergeDatabaseWithInvalidPath) {
util::deleteFile(filename_sideload);
util::copyFile(filename_sideload, "test/fixtures/offline_database");
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
auto result = db.mergeDatabase(filename_sideload);
EXPECT_FALSE(result);
@@ -1866,7 +1878,7 @@ TEST(OfflineDatabase, MergeDatabaseWithInvalidDb) {
util::deleteFile(filename_sideload);
util::copyFile(filename_sideload, "test/fixtures/offline_database/corrupt-immediate.db");
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
auto result = db.mergeDatabase(filename_sideload);
EXPECT_FALSE(result);
@@ -1885,7 +1897,7 @@ TEST(OfflineDatabase, TEST_REQUIRES_WRITE(MergeDatabaseWithDiskFull)) {
util::copyFile(filename, "test/fixtures/offline_database/satellite_test.db");
util::copyFile(filename_sideload, "test/fixtures/offline_database/sideload_sat.db");
OfflineDatabase db(filename_test_fs);
OfflineDatabase db(filename_test_fs, fixture::tileServerOptions);
fs.setWriteLimit(0);
@@ -1899,7 +1911,7 @@ TEST(OfflineDatabase, TEST_REQUIRES_WRITE(MergeDatabaseWithDiskFull)) {
TEST(OfflineDatabase, ChangePath) {
std::string newPath("test/fixtures/offline_database/test.db");
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
db.changePath(newPath);
mapbox::sqlite::Database::open(newPath, mapbox::sqlite::ReadOnly);
util::deleteFile(newPath);
@@ -1910,7 +1922,7 @@ TEST(OfflineDatabase, ResetDatabase) {
deleteDatabaseFiles();
util::copyFile(filename, "test/fixtures/offline_database/satellite_test.db");
OfflineDatabase db(filename);
OfflineDatabase db(filename, fixture::tileServerOptions);
auto result = db.resetDatabase();
EXPECT_FALSE(result);
@@ -1922,7 +1934,7 @@ TEST(OfflineDatabase, ResetDatabase) {
TEST(OfflineDatabase, PutResourceReadOnlyMode) {
FixtureLog log;
OfflineDatabase db(":memory:");
OfflineDatabase db(":memory:", fixture::tileServerOptions);
Resource resource{Resource::Style, "http://example.com/"};
Response response;
@@ -1951,7 +1963,7 @@ TEST(OfflineDatabase, TEST_REQUIRES_WRITE(UpdateDatabaseReadOnlyMode)) {
FixtureLog log;
deleteDatabaseFiles();
OfflineDatabase db(filename);
OfflineDatabase db(filename, fixture::tileServerOptions);
db.reopenDatabaseReadOnly(true /*readOnly*/);
db.clearAmbientCache();
EXPECT_EQ(1u,