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

17
test/storage/asset_file_source.test.cpp
View File

@@ -1,5 +1,6 @@
#include <mbgl/actor/actor_ref.hpp>
#include <mbgl/storage/asset_file_source.hpp>
#include <mbgl/storage/resource_options.hpp>
#include <mbgl/storage/resource.hpp>
#include <mbgl/util/chrono.hpp>
#include <mbgl/util/platform.hpp>
@@ -15,7 +16,7 @@ using namespace mbgl;
TEST(AssetFileSource, Load) {
util::RunLoop loop;
AssetFileSource fs("test/fixtures/storage/assets");
AssetFileSource fs(ResourceOptions::Default().withAssetPath("test/fixtures/storage/assets"));
// iOS seems to run out of file descriptors...
#if TARGET_OS_IPHONE
@@ -71,7 +72,7 @@ TEST(AssetFileSource, Load) {
}
TEST(AssetFileSource, AcceptsURL) {
AssetFileSource fs("test/fixtures/storage/assets");
AssetFileSource fs(ResourceOptions::Default().withAssetPath("test/fixtures/storage/assets"));
EXPECT_TRUE(fs.canRequest(Resource::style("asset://empty")));
EXPECT_TRUE(fs.canRequest(Resource::style("asset:///test")));
EXPECT_FALSE(fs.canRequest(Resource::style("assds://foo")));
@@ -83,7 +84,7 @@ TEST(AssetFileSource, AcceptsURL) {
TEST(AssetFileSource, EmptyFile) {
util::RunLoop loop;
AssetFileSource fs("test/fixtures/storage/assets");
AssetFileSource fs(ResourceOptions::Default().withAssetPath("test/fixtures/storage/assets"));
std::unique_ptr<AsyncRequest> req = fs.request({ Resource::Unknown, "asset://empty" }, [&](Response res) {
req.reset();
@@ -99,7 +100,7 @@ TEST(AssetFileSource, EmptyFile) {
TEST(AssetFileSource, NonEmptyFile) {
util::RunLoop loop;
AssetFileSource fs("test/fixtures/storage/assets");
AssetFileSource fs(ResourceOptions::Default().withAssetPath("test/fixtures/storage/assets"));
std::unique_ptr<AsyncRequest> req = fs.request({ Resource::Unknown, "asset://nonempty" }, [&](Response res) {
req.reset();
@@ -115,7 +116,7 @@ TEST(AssetFileSource, NonEmptyFile) {
TEST(AssetFileSource, NonExistentFile) {
util::RunLoop loop;
AssetFileSource fs("test/fixtures/storage/assets");
AssetFileSource fs(ResourceOptions::Default().withAssetPath("test/fixtures/storage/assets"));
std::unique_ptr<AsyncRequest> req = fs.request({ Resource::Unknown, "asset://does_not_exist" }, [&](Response res) {
req.reset();
@@ -132,7 +133,7 @@ TEST(AssetFileSource, NonExistentFile) {
TEST(AssetFileSource, InvalidURL) {
util::RunLoop loop;
AssetFileSource fs("test/fixtures/storage/assets");
AssetFileSource fs(ResourceOptions::Default().withAssetPath("test/fixtures/storage/assets"));
std::unique_ptr<AsyncRequest> req = fs.request({ Resource::Unknown, "test://wrong-scheme" }, [&](Response res) {
req.reset();
@@ -149,7 +150,7 @@ TEST(AssetFileSource, InvalidURL) {
TEST(AssetFileSource, ReadDirectory) {
util::RunLoop loop;
AssetFileSource fs("test/fixtures/storage/assets");
AssetFileSource fs(ResourceOptions::Default().withAssetPath("test/fixtures/storage/assets"));
std::unique_ptr<AsyncRequest> req = fs.request({ Resource::Unknown, "asset://directory" }, [&](Response res) {
req.reset();
@@ -166,7 +167,7 @@ TEST(AssetFileSource, ReadDirectory) {
TEST(AssetFileSource, URLEncoding) {
util::RunLoop loop;
AssetFileSource fs("test/fixtures/storage/assets");
AssetFileSource fs(ResourceOptions::Default().withAssetPath("test/fixtures/storage/assets"));
std::unique_ptr<AsyncRequest> req = fs.request({ Resource::Unknown, "asset://%6eonempty" }, [&](Response res) {
req.reset();

21
test/storage/http_file_source.test.cpp
View File

@@ -5,12 +5,13 @@
#include <mbgl/util/exception.hpp>
#include <mbgl/util/run_loop.hpp>
#include <mbgl/util/string.hpp>
#include <mbgl/storage/resource_options.hpp>
using namespace mbgl;
TEST(HTTPFileSource, TEST_REQUIRES_SERVER(Cancel)) {
util::RunLoop loop;
HTTPFileSource fs;
HTTPFileSource fs(ResourceOptions::Default());
fs.request({ Resource::Unknown, "http://127.0.0.1:3000/test" }, [&](Response) {
ADD_FAILURE() << "Callback should not be called";
@@ -21,7 +22,7 @@ TEST(HTTPFileSource, TEST_REQUIRES_SERVER(Cancel)) {
TEST(HTTPFileSource, TEST_REQUIRES_SERVER(HTTP200)) {
util::RunLoop loop;
HTTPFileSource fs;
HTTPFileSource fs(ResourceOptions::Default());
auto req = fs.request({ Resource::Unknown, "http://127.0.0.1:3000/test" }, [&](Response res) {
EXPECT_EQ(nullptr, res.error);
@@ -39,7 +40,7 @@ TEST(HTTPFileSource, TEST_REQUIRES_SERVER(HTTP200)) {
TEST(HTTPFileSource, TEST_REQUIRES_SERVER(HTTP404)) {
util::RunLoop loop;
HTTPFileSource fs;
HTTPFileSource fs(ResourceOptions::Default());
auto req = fs.request({ Resource::Unknown, "http://127.0.0.1:3000/doesnotexist" }, [&](Response res) {
ASSERT_NE(nullptr, res.error);
@@ -58,7 +59,7 @@ TEST(HTTPFileSource, TEST_REQUIRES_SERVER(HTTP404)) {
TEST(HTTPFileSource, TEST_REQUIRES_SERVER(HTTPTile404)) {
util::RunLoop loop;
HTTPFileSource fs;
HTTPFileSource fs(ResourceOptions::Default());
auto req = fs.request({ Resource::Tile, "http://127.0.0.1:3000/doesnotexist" }, [&](Response res) {
EXPECT_TRUE(res.noContent);
@@ -76,7 +77,7 @@ TEST(HTTPFileSource, TEST_REQUIRES_SERVER(HTTPTile404)) {
TEST(HTTPFileSource, TEST_REQUIRES_SERVER(HTTP200EmptyData)) {
util::RunLoop loop;
HTTPFileSource fs;
HTTPFileSource fs(ResourceOptions::Default());
auto req = fs.request({ Resource::Unknown, "http://127.0.0.1:3000/empty-data" }, [&](Response res) {
EXPECT_FALSE(res.noContent);
@@ -94,7 +95,7 @@ TEST(HTTPFileSource, TEST_REQUIRES_SERVER(HTTP200EmptyData)) {
TEST(HTTPFileSource, TEST_REQUIRES_SERVER(HTTP204)) {
util::RunLoop loop;
HTTPFileSource fs;
HTTPFileSource fs(ResourceOptions::Default());
auto req = fs.request({ Resource::Unknown, "http://127.0.0.1:3000/no-content" }, [&](Response res) {
EXPECT_TRUE(res.noContent);
@@ -112,7 +113,7 @@ TEST(HTTPFileSource, TEST_REQUIRES_SERVER(HTTP204)) {
TEST(HTTPFileSource, TEST_REQUIRES_SERVER(HTTP500)) {
util::RunLoop loop;
HTTPFileSource fs;
HTTPFileSource fs(ResourceOptions::Default());
auto req = fs.request({ Resource::Unknown, "http://127.0.0.1:3000/permanent-error" }, [&](Response res) {
ASSERT_NE(nullptr, res.error);
@@ -131,7 +132,7 @@ TEST(HTTPFileSource, TEST_REQUIRES_SERVER(HTTP500)) {
TEST(HTTPFileSource, TEST_REQUIRES_SERVER(ExpiresParsing)) {
util::RunLoop loop;
HTTPFileSource fs;
HTTPFileSource fs(ResourceOptions::Default());
auto req = fs.request({ Resource::Unknown,
"http://127.0.0.1:3000/test?modified=1420794326&expires=1420797926&etag=foo" }, [&](Response res) {
@@ -150,7 +151,7 @@ TEST(HTTPFileSource, TEST_REQUIRES_SERVER(ExpiresParsing)) {
TEST(HTTPFileSource, TEST_REQUIRES_SERVER(CacheControlParsing)) {
util::RunLoop loop;
HTTPFileSource fs;
HTTPFileSource fs(ResourceOptions::Default());
auto req = fs.request({ Resource::Unknown, "http://127.0.0.1:3000/test?cachecontrol=max-age=120" }, [&](Response res) {
EXPECT_EQ(nullptr, res.error);
@@ -168,7 +169,7 @@ TEST(HTTPFileSource, TEST_REQUIRES_SERVER(CacheControlParsing)) {
TEST(HTTPFileSource, TEST_REQUIRES_SERVER(Load)) {
util::RunLoop loop;
HTTPFileSource fs;
HTTPFileSource fs(ResourceOptions::Default());
const int concurrency = 50;
const int max = 10000;

17
test/storage/local_file_source.test.cpp
View File

@@ -1,5 +1,6 @@
#include <mbgl/storage/local_file_source.hpp>
#include <mbgl/storage/resource.hpp>
#include <mbgl/storage/resource_options.hpp>
#include <mbgl/util/platform.hpp>
#include <mbgl/util/run_loop.hpp>
@@ -22,7 +23,7 @@ std::string toAbsoluteURL(const std::string& fileName) {
using namespace mbgl;
TEST(LocalFileSource, AcceptsURL) {
LocalFileSource fs;
LocalFileSource fs(ResourceOptions::Default());
EXPECT_TRUE(fs.canRequest(Resource::style("file://empty")));
EXPECT_TRUE(fs.canRequest(Resource::style("file:///test")));
EXPECT_FALSE(fs.canRequest(Resource::style("flie://foo")));
@@ -34,7 +35,7 @@ TEST(LocalFileSource, AcceptsURL) {
TEST(LocalFileSource, EmptyFile) {
util::RunLoop loop;
LocalFileSource fs;
LocalFileSource fs(ResourceOptions::Default());
std::unique_ptr<AsyncRequest> req = fs.request({ Resource::Unknown, toAbsoluteURL("empty") }, [&](Response res) {
req.reset();
@@ -50,7 +51,7 @@ TEST(LocalFileSource, EmptyFile) {
TEST(LocalFileSource, NonEmptyFile) {
util::RunLoop loop;
LocalFileSource fs;
LocalFileSource fs(ResourceOptions::Default());
std::unique_ptr<AsyncRequest> req = fs.request({ Resource::Unknown, toAbsoluteURL("nonempty") }, [&](Response res) {
req.reset();
@@ -66,7 +67,7 @@ TEST(LocalFileSource, NonEmptyFile) {
TEST(LocalFileSource, NonExistentFile) {
util::RunLoop loop;
LocalFileSource fs;
LocalFileSource fs(ResourceOptions::Default());
std::unique_ptr<AsyncRequest> req = fs.request({ Resource::Unknown, toAbsoluteURL("does_not_exist") }, [&](Response res) {
req.reset();
@@ -83,7 +84,7 @@ TEST(LocalFileSource, NonExistentFile) {
TEST(LocalFileSource, InvalidURL) {
util::RunLoop loop;
LocalFileSource fs;
LocalFileSource fs(ResourceOptions::Default());
std::unique_ptr<AsyncRequest> req = fs.request({ Resource::Unknown, "test://wrong-scheme" }, [&](Response res) {
req.reset();
@@ -100,7 +101,7 @@ TEST(LocalFileSource, InvalidURL) {
TEST(LocalFileSource, ReadDirectory) {
util::RunLoop loop;
LocalFileSource fs;
LocalFileSource fs(ResourceOptions::Default());
std::unique_ptr<AsyncRequest> req = fs.request({ Resource::Unknown, toAbsoluteURL("directory") }, [&](Response res) {
req.reset();
@@ -117,7 +118,7 @@ TEST(LocalFileSource, ReadDirectory) {
TEST(LocalFileSource, URLEncoding) {
util::RunLoop loop;
LocalFileSource fs;
LocalFileSource fs(ResourceOptions::Default());
std::unique_ptr<AsyncRequest> req = fs.request({ Resource::Unknown, toAbsoluteURL("%6eonempty") }, [&](Response res) {
req.reset();
@@ -134,7 +135,7 @@ TEST(LocalFileSource, URLLimit) {
util::RunLoop loop;
size_t length = PATH_MAX - toAbsoluteURL("").size();
LocalFileSource fs;
LocalFileSource fs(ResourceOptions::Default());
char filename[length];
memset(filename, 'x', length);

24
test/storage/main_resource_loader.test.cpp
View File

@@ -9,6 +9,7 @@
#include <mbgl/test/util.hpp>
#include <mbgl/util/run_loop.hpp>
#include <mbgl/util/timer.hpp>
#include <mbgl/util/tile_server_options.hpp>
using namespace mbgl;
@@ -823,3 +824,26 @@ TEST(MainResourceLoader, TEST_REQUIRES_SERVER(NoDoubleDispatch)) {
loop.run();
}
TEST(MainResourceLoader, ResourceOptions) {
MainResourceLoader fs(
ResourceOptions().withTileServerOptions(
TileServerOptions()
.withBaseURL("originalBaseURL")
.withUriSchemeAlias("originalAlias")
)
);
fs.setResourceOptions(ResourceOptions()
.withTileServerOptions(
TileServerOptions()
.withBaseURL("updatedBaseURL")
.withUriSchemeAlias("updatedAlias")
).clone()
);
auto updatedOptions = fs.getResourceOptions().tileServerOptions();
EXPECT_EQ(updatedOptions.baseURL(), "updatedBaseURL");
EXPECT_EQ(updatedOptions.uriSchemeAlias(), "updatedAlias");
}

4
test/storage/offline.test.cpp
View File

@@ -8,7 +8,7 @@ using SourceType = mbgl::style::SourceType;
TEST(OfflineTilePyramidRegionDefinition, EncodeDecode) {
OfflineTilePyramidRegionDefinition region("mapbox://style", LatLngBounds::hull({ 37.6609, -122.5744 }, { 37.8271, -122.3204 }), 0, 20, 1.0, true);
OfflineTilePyramidRegionDefinition region("maptiler://style", LatLngBounds::hull({ 37.6609, -122.5744 }, { 37.8271, -122.3204 }), 0, 20, 1.0, true);
auto encoded = encodeOfflineRegionDefinition(region);
auto decoded = decodeOfflineRegionDefinition(encoded).get<OfflineTilePyramidRegionDefinition>();
@@ -23,7 +23,7 @@ TEST(OfflineTilePyramidRegionDefinition, EncodeDecode) {
}
TEST(OfflineGeometryRegionDefinition, EncodeDecode) {
OfflineGeometryRegionDefinition region("mapbox://style", Point<double>(-122.5744, 37.6609), 0, 2, 1.0, false);
OfflineGeometryRegionDefinition region("maptiler://style", Point<double>(-122.5744, 37.6609), 0, 2, 1.0, false);
auto encoded = encodeOfflineRegionDefinition(region);
auto decoded = decodeOfflineRegionDefinition(encoded).get<OfflineGeometryRegionDefinition>();

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,

10
test/storage/offline_download.test.cpp
View File

@@ -59,7 +59,7 @@ public:
class OfflineTest {
public:
OfflineTest(const std::string& path = ":memory:") : db(path) {
OfflineTest(const std::string& path = ":memory:") : db(path, TileServerOptions::MapTilerConfiguration()) {
}
util::RunLoop loop;
@@ -542,6 +542,10 @@ TEST(OfflineDownload, TileCountLimitExceededNoTileResponse) {
EXPECT_EQ("http://127.0.0.1:3000/style.json", resource.url);
return test.response("mapbox_source.style.json");
};
// test.fileSource.tileResponse = [&] (const Resource& resource) {
// EXPECT_EQ("maptiler://0-0-0.vector.pbf", resource.url);
// return test.response("0-0-0.vector.pbf");
// };
auto observer = std::make_unique<MockObserver>();
bool mapboxTileCountLimitExceededCalled = false;
@@ -588,7 +592,7 @@ TEST(OfflineDownload, TileCountLimitExceededWithTileResponse) {
test.fileSource.tileResponse = [&] (const Resource& resource) {
const Resource::TileData& tile = *resource.tileData;
EXPECT_EQ("mapbox://{z}-{x}-{y}.vector.pbf", tile.urlTemplate);
EXPECT_EQ("maptiler://{z}-{x}-{y}.vector.pbf", tile.urlTemplate);
EXPECT_EQ(1, tile.pixelRatio);
EXPECT_EQ(0, tile.x);
EXPECT_EQ(0, tile.y);
@@ -1130,4 +1134,4 @@ TEST(OfflineDownload, NoFreezingOnNotFoundError) {
test.loop.run();
// Passes if does not freeze.
}
}

104
test/storage/online_file_source.test.cpp
View File

@@ -1,6 +1,7 @@
#include <mbgl/storage/network_status.hpp>
#include <mbgl/storage/online_file_source.hpp>
#include <mbgl/storage/resource.hpp>
#include <mbgl/storage/resource_options.hpp>
#include <mbgl/test/util.hpp>
#include <mbgl/util/chrono.hpp>
#include <mbgl/util/constants.hpp>
@@ -14,7 +15,7 @@ using namespace mbgl;
TEST(OnlineFileSource, Cancel) {
util::RunLoop loop;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>(ResourceOptions::Default());
fs->request({Resource::Unknown, "http://127.0.0.1:3000/test"},
[&](Response) { ADD_FAILURE() << "Callback should not be called"; });
@@ -24,7 +25,7 @@ TEST(OnlineFileSource, Cancel) {
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(CancelMultiple)) {
util::RunLoop loop;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>(ResourceOptions::Default());
const Resource resource { Resource::Unknown, "http://127.0.0.1:3000/test" };
@@ -48,7 +49,7 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(CancelMultiple)) {
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(TemporaryError)) {
util::RunLoop loop;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>(ResourceOptions::Default());
const auto start = Clock::now();
int counter = 0;
@@ -88,7 +89,7 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(TemporaryError)) {
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(ConnectionError)) {
util::RunLoop loop;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>(ResourceOptions::Default());
const auto start = Clock::now();
int counter = 0;
@@ -119,7 +120,7 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(ConnectionError)) {
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(Timeout)) {
util::RunLoop loop;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>(ResourceOptions::Default());
int counter = 0;
@@ -146,7 +147,7 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(Timeout)) {
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(RetryDelayOnExpiredTile)) {
util::RunLoop loop;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>(ResourceOptions::Default());
int counter = 0;
@@ -166,7 +167,7 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(RetryDelayOnExpiredTile)) {
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(RetryOnClockSkew)) {
util::RunLoop loop;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>(ResourceOptions::Default());
int counter = 0;
@@ -195,7 +196,7 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(RetryOnClockSkew)) {
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(RespectPriorExpires)) {
util::RunLoop loop;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>(ResourceOptions::Default());
// Very long expiration time, should never arrive.
Resource resource1{ Resource::Unknown, "http://127.0.0.1:3000/test" };
@@ -219,7 +220,7 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(RespectPriorExpires)) {
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(RespectMinimumUpdateInterval)) {
util::RunLoop loop;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>(ResourceOptions::Default());
auto start = util::now();
Resource resource{Resource::Unknown, "http://127.0.0.1:3000/test"};
@@ -237,7 +238,7 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(RespectMinimumUpdateInterval)) {
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(Load)) {
util::RunLoop loop;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>(ResourceOptions::Default());
const int concurrency = 50;
const int max = 10000;
@@ -281,7 +282,7 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(Load)) {
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(NetworkStatusChange)) {
util::RunLoop loop;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>(ResourceOptions::Default());
const Resource resource { Resource::Unknown, "http://127.0.0.1:3000/delayed" };
@@ -311,7 +312,7 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(NetworkStatusChange)) {
// reachability issues.
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(NetworkStatusChangePreempt)) {
util::RunLoop loop;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>(ResourceOptions::Default());
fs->pause();
const auto start = Clock::now();
@@ -354,7 +355,7 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(NetworkStatusChangePreempt)) {
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(NetworkStatusOnlineOffline)) {
util::RunLoop loop;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>(ResourceOptions::Default());
const Resource resource { Resource::Unknown, "http://127.0.0.1:3000/test" };
@@ -382,7 +383,7 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(NetworkStatusOnlineOffline)) {
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(RateLimitStandard)) {
util::RunLoop loop;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>(ResourceOptions::Default());
auto req = fs->request({Resource::Unknown, "http://127.0.0.1:3000/rate-limit?std=true"}, [&](Response res) {
ASSERT_NE(nullptr, res.error);
@@ -397,7 +398,7 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(RateLimitStandard)) {
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(RateLimitMBX)) {
util::RunLoop loop;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>(ResourceOptions::Default());
auto req = fs->request({Resource::Unknown, "http://127.0.0.1:3000/rate-limit?mbx=true"}, [&](Response res) {
ASSERT_NE(nullptr, res.error);
@@ -412,7 +413,7 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(RateLimitMBX)) {
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(RateLimitDefault)) {
util::RunLoop loop;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>(ResourceOptions::Default());
auto req = fs->request({Resource::Unknown, "http://127.0.0.1:3000/rate-limit"}, [&](Response res) {
ASSERT_NE(nullptr, res.error);
@@ -424,36 +425,83 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(RateLimitDefault)) {
loop.run();
}
TEST(OnlineFileSource, GetBaseURLAndAccessTokenWhilePaused) {
TEST(OnlineFileSource, GetBaseURLAndApiKeyWhilePaused) {
util::RunLoop loop;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>(ResourceOptions::Default());
fs->pause();
auto baseURL = "http://url";
auto accessToken = "access_token";
auto apiKey = "api_key";
fs->setProperty(API_BASE_URL_KEY, baseURL);
fs->setProperty(ACCESS_TOKEN_KEY, accessToken);
fs->setProperty(API_KEY_KEY, apiKey);
EXPECT_EQ(*fs->getProperty(API_BASE_URL_KEY).getString(), baseURL);
EXPECT_EQ(*fs->getProperty(ACCESS_TOKEN_KEY).getString(), accessToken);
EXPECT_EQ(*fs->getProperty(API_KEY_KEY).getString(), apiKey);
}
TEST(OnlineFileSource, ChangeAPIBaseURL){
util::RunLoop loop;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
EXPECT_EQ(mbgl::util::API_BASE_URL, *fs->getProperty(API_BASE_URL_KEY).getString());
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>(ResourceOptions::Default());
EXPECT_EQ(ResourceOptions::Default().tileServerOptions().baseURL(), *fs->getProperty(API_BASE_URL_KEY).getString());
const std::string customURL = "test.domain";
fs->setProperty(API_BASE_URL_KEY, customURL);
EXPECT_EQ(customURL, *fs->getProperty(API_BASE_URL_KEY).getString());
auto updatedTileServerOptions = fs->getResourceOptions().tileServerOptions();
EXPECT_EQ(customURL, updatedTileServerOptions.baseURL());
}
TEST(OnlineFileSource, ChangeTileServerOptions){
util::RunLoop loop;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>(ResourceOptions::Default());
TileServerOptions tileServerOptsChanged;
tileServerOptsChanged.withApiKeyParameterName("apiKeyChanged")
.withBaseURL("baseURLChanged")
.withDefaultStyle("defaultStyleChanged")
.withGlyphsTemplate("defaultGlyphsTemplateChanged", "glyphsDomainChanged", {})
.withSourceTemplate("sourceTemplateChanged", "sourceDomainChanged", {})
.withSpritesTemplate("spritesTemplateChanged", "spritesDomainChanged", {})
.withStyleTemplate("styleTemplateChanged", "styleDomainChanged", {})
.withTileTemplate("tileTemplateChanged", "tileDomainChanged", {})
.withUriSchemeAlias("uriSchemeAliasChanged");
ResourceOptions resOpts;
resOpts.withApiKey("changedAPIKey")
.withTileServerOptions(tileServerOptsChanged);
fs->setResourceOptions(resOpts.clone());
auto actualResourceOpts = fs->getResourceOptions();
EXPECT_EQ(tileServerOptsChanged.baseURL(), *fs->getProperty(API_BASE_URL_KEY).getString());
EXPECT_EQ(actualResourceOpts.apiKey(), *fs->getProperty(API_KEY_KEY).getString());
EXPECT_EQ(resOpts.apiKey(), actualResourceOpts.apiKey());
EXPECT_EQ(resOpts.tileServerOptions().defaultStyle(), tileServerOptsChanged.defaultStyle());
EXPECT_EQ(resOpts.tileServerOptions().baseURL(), tileServerOptsChanged.baseURL());
EXPECT_EQ(resOpts.tileServerOptions().glyphsTemplate(), tileServerOptsChanged.glyphsTemplate());
EXPECT_EQ(resOpts.tileServerOptions().glyphsDomainName(), tileServerOptsChanged.glyphsDomainName());
EXPECT_EQ(resOpts.tileServerOptions().glyphsVersionPrefix(), tileServerOptsChanged.glyphsVersionPrefix());
EXPECT_EQ(resOpts.tileServerOptions().sourceTemplate(), tileServerOptsChanged.sourceTemplate());
EXPECT_EQ(resOpts.tileServerOptions().sourceDomainName(), tileServerOptsChanged.sourceDomainName());
EXPECT_EQ(resOpts.tileServerOptions().sourceVersionPrefix(), tileServerOptsChanged.sourceVersionPrefix());
EXPECT_EQ(resOpts.tileServerOptions().spritesTemplate(), tileServerOptsChanged.spritesTemplate());
EXPECT_EQ(resOpts.tileServerOptions().spritesDomainName(), tileServerOptsChanged.spritesDomainName());
EXPECT_EQ(resOpts.tileServerOptions().spritesVersionPrefix(), tileServerOptsChanged.spritesVersionPrefix());
EXPECT_EQ(resOpts.tileServerOptions().tileTemplate(), tileServerOptsChanged.tileTemplate());
EXPECT_EQ(resOpts.tileServerOptions().tileDomainName(), tileServerOptsChanged.tileDomainName());
EXPECT_EQ(resOpts.tileServerOptions().tileVersionPrefix(), tileServerOptsChanged.tileVersionPrefix());
EXPECT_EQ(resOpts.tileServerOptions().styleTemplate(), tileServerOptsChanged.styleTemplate());
EXPECT_EQ(resOpts.tileServerOptions().styleDomainName(), tileServerOptsChanged.styleDomainName());
EXPECT_EQ(resOpts.tileServerOptions().styleVersionPrefix(), tileServerOptsChanged.styleVersionPrefix());
}
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(LowHighPriorityRequests)) {
util::RunLoop loop;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>(ResourceOptions::Default());
std::size_t response_counter = 0;
const std::size_t NUM_REQUESTS = 3;
@@ -495,7 +543,7 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(LowHighPriorityRequests)) {
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(LowHighPriorityRequestsMany)) {
util::RunLoop loop;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>(ResourceOptions::Default());
int response_counter = 0;
int correct_low = 0;
int correct_regular = 0;
@@ -550,7 +598,7 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(LowHighPriorityRequestsMany)) {
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(MaximumConcurrentRequests)) {
util::RunLoop loop;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>(ResourceOptions::Default());
ASSERT_EQ(*fs->getProperty(MAX_CONCURRENT_REQUESTS_KEY).getUint(), 20u);
@@ -560,7 +608,7 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(MaximumConcurrentRequests)) {
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(RequestSameUrlMultipleTimes)) {
util::RunLoop loop;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>(ResourceOptions::Default());
int count = 0;
std::vector<std::unique_ptr<AsyncRequest>> requests;

6
test/storage/sync_file_source.test.cpp
View File

@@ -41,12 +41,10 @@ private:
TEST(SyncFileSource, LoadSyncRender) {
util::RunLoop loop;
auto fs = std::make_shared<SyncFileSource>();
fs->add("mapbox://mapbox.mapbox-terrain-v2,mapbox.mapbox-streets-v7",
fs->add("maptiler://maps/streets",
util::read_file("test/fixtures/resources/source_vector.json"));
fs->add("mapbox://sprites/mapbox/streets-v9.png",
fs->add("maptiler://sprites/streets/sprite",
util::read_file("test/fixtures/resources/sprite.png"));
fs->add("mapbox://sprites/mapbox/streets-v9.json",
util::read_file("test/fixtures/resources/sprite.json"));
HeadlessFrontend frontend{ { 512, 512 }, 1.0 };
MapAdapter map{ frontend, MapObserver::nullObserver(), fs, MapOptions() };
map.getStyle().loadJSON(util::read_file("test/fixtures/resources/style_vector.json"));