From 3f3fc7b7723698e44427e2a14a2f4906832800bf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Konstantin=20K=C3=A4fer?= Date: Wed, 28 Sep 2016 11:45:33 +0200 Subject: [test] add .test.cpp suffix to test case files --- test/storage/offline_database.test.cpp | 647 +++++++++++++++++++++++++++++++++ 1 file changed, 647 insertions(+) create mode 100644 test/storage/offline_database.test.cpp (limited to 'test/storage/offline_database.test.cpp') diff --git a/test/storage/offline_database.test.cpp b/test/storage/offline_database.test.cpp new file mode 100644 index 0000000000..bcc9784b35 --- /dev/null +++ b/test/storage/offline_database.test.cpp @@ -0,0 +1,647 @@ +#include +#include + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +using namespace std::literals::string_literals; + +namespace { + +void createDir(const char* name) { + const int ret = mkdir(name, 0755); + if (ret == -1) { + ASSERT_EQ(EEXIST, errno); + } else { + ASSERT_EQ(0, ret); + } +} + +void deleteFile(const char* name) { + const int ret = unlink(name); + if (ret == -1) { + ASSERT_EQ(ENOENT, errno); + } else { + ASSERT_EQ(0, ret); + } +} + +void writeFile(const char* name, const std::string& data) { + mbgl::util::write_file(name, data); +} + +class FileLock { +public: + FileLock(const std::string& path) { + const int err = sqlite3_open_v2(path.c_str(), &db, SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, nullptr); + if (err != SQLITE_OK) { + throw std::runtime_error("Could not open db"); + } + lock(); + } + + void lock() { + assert(!locked); + const int err = sqlite3_exec(db, "begin exclusive transaction", nullptr, nullptr, nullptr); + if (err != SQLITE_OK) { + throw std::runtime_error("Could not lock db"); + } + locked = true; + } + + void unlock() { + assert(locked); + const int err = sqlite3_exec(db, "commit", nullptr, nullptr, nullptr); + if (err != SQLITE_OK) { + throw std::runtime_error("Could not unlock db"); + } + locked = false; + } + + ~FileLock() { + if (locked) { + unlock(); + } + } + +private: + sqlite3* db = nullptr; + bool locked = false; +}; + +} // namespace + +TEST(OfflineDatabase, TEST_REQUIRES_WRITE(Create)) { + using namespace mbgl; + + createDir("test/fixtures/offline_database"); + deleteFile("test/fixtures/offline_database/offline.db"); + + Log::setObserver(std::make_unique()); + + OfflineDatabase db("test/fixtures/offline_database/offline.db"); + EXPECT_FALSE(bool(db.get({ Resource::Unknown, "mapbox://test" }))); + + Log::removeObserver(); +} + +TEST(OfflineDatabase, TEST_REQUIRES_WRITE(SchemaVersion)) { + using namespace mbgl; + + createDir("test/fixtures/offline_database"); + deleteFile("test/fixtures/offline_database/offline.db"); + std::string path("test/fixtures/offline_database/offline.db"); + + { + sqlite3* db = nullptr; + sqlite3_open_v2(path.c_str(), &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, nullptr); + sqlite3_exec(db, "PRAGMA user_version = 1", nullptr, nullptr, nullptr); + sqlite3_close_v2(db); + } + + Log::setObserver(std::make_unique()); + OfflineDatabase db(path); + + auto observer = Log::removeObserver(); + auto flo = dynamic_cast(observer.get()); + EXPECT_EQ(1u, flo->count({ EventSeverity::Warning, Event::Database, -1, "Removing existing incompatible offline database" })); +} + +TEST(OfflineDatabase, TEST_REQUIRES_WRITE(Invalid)) { + using namespace mbgl; + + createDir("test/fixtures/offline_database"); + deleteFile("test/fixtures/offline_database/invalid.db"); + writeFile("test/fixtures/offline_database/invalid.db", "this is an invalid file"); + + Log::setObserver(std::make_unique()); + + OfflineDatabase db("test/fixtures/offline_database/invalid.db"); + + auto observer = Log::removeObserver(); + auto flo = dynamic_cast(observer.get()); + EXPECT_EQ(1u, flo->count({ EventSeverity::Warning, Event::Database, -1, "Removing existing incompatible offline database" })); +} + +TEST(OfflineDatabase, PutDoesNotStoreConnectionErrors) { + using namespace mbgl; + + OfflineDatabase db(":memory:"); + + Resource resource { Resource::Unknown, "http://example.com/" }; + Response response; + response.error = std::make_unique(Response::Error::Reason::Connection); + + db.put(resource, response); + EXPECT_FALSE(bool(db.get(resource))); +} + +TEST(OfflineDatabase, PutDoesNotStoreServerErrors) { + using namespace mbgl; + + OfflineDatabase db(":memory:"); + + Resource resource { Resource::Unknown, "http://example.com/" }; + Response response; + response.error = std::make_unique(Response::Error::Reason::Server); + + db.put(resource, response); + EXPECT_FALSE(bool(db.get(resource))); +} + +TEST(OfflineDatabase, PutResource) { + using namespace mbgl; + + OfflineDatabase db(":memory:"); + + Resource resource { Resource::Style, "http://example.com/" }; + Response response; + + response.data = std::make_shared("first"); + auto insertPutResult = db.put(resource, response); + EXPECT_TRUE(insertPutResult.first); + EXPECT_EQ(5u, insertPutResult.second); + + auto insertGetResult = db.get(resource); + EXPECT_EQ(nullptr, insertGetResult->error.get()); + EXPECT_EQ("first", *insertGetResult->data); + + response.data = std::make_shared("second"); + auto updatePutResult = db.put(resource, response); + EXPECT_FALSE(updatePutResult.first); + EXPECT_EQ(6u, updatePutResult.second); + + auto updateGetResult = db.get(resource); + EXPECT_EQ(nullptr, updateGetResult->error.get()); + EXPECT_EQ("second", *updateGetResult->data); +} + +TEST(OfflineDatabase, PutTile) { + using namespace mbgl; + + OfflineDatabase db(":memory:"); + + Resource resource { Resource::Tile, "http://example.com/" }; + resource.tileData = Resource::TileData { + "http://example.com/", + 1, + 0, + 0, + 0 + }; + Response response; + + response.data = std::make_shared("first"); + auto insertPutResult = db.put(resource, response); + EXPECT_TRUE(insertPutResult.first); + EXPECT_EQ(5u, insertPutResult.second); + + auto insertGetResult = db.get(resource); + EXPECT_EQ(nullptr, insertGetResult->error.get()); + EXPECT_EQ("first", *insertGetResult->data); + + response.data = std::make_shared("second"); + auto updatePutResult = db.put(resource, response); + EXPECT_FALSE(updatePutResult.first); + EXPECT_EQ(6u, updatePutResult.second); + + auto updateGetResult = db.get(resource); + EXPECT_EQ(nullptr, updateGetResult->error.get()); + EXPECT_EQ("second", *updateGetResult->data); +} + +TEST(OfflineDatabase, PutResourceNoContent) { + using namespace mbgl; + + OfflineDatabase db(":memory:"); + + Resource resource { Resource::Style, "http://example.com/" }; + Response response; + response.noContent = true; + + db.put(resource, response); + auto res = db.get(resource); + EXPECT_EQ(nullptr, res->error); + EXPECT_TRUE(res->noContent); + EXPECT_FALSE(res->data.get()); +} + +TEST(OfflineDatabase, PutTileNotFound) { + using namespace mbgl; + + OfflineDatabase db(":memory:"); + + Resource resource { Resource::Tile, "http://example.com/" }; + resource.tileData = Resource::TileData { + "http://example.com/", + 1, + 0, + 0, + 0 + }; + Response response; + response.noContent = true; + + db.put(resource, response); + auto res = db.get(resource); + EXPECT_EQ(nullptr, res->error); + EXPECT_TRUE(res->noContent); + EXPECT_FALSE(res->data.get()); +} + +TEST(OfflineDatabase, CreateRegion) { + using namespace mbgl; + + OfflineDatabase db(":memory:"); + OfflineRegionDefinition definition { "http://example.com/style", LatLngBounds::hull({1, 2}, {3, 4}), 5, 6, 2.0 }; + OfflineRegionMetadata metadata {{ 1, 2, 3 }}; + OfflineRegion region = db.createRegion(definition, metadata); + + EXPECT_EQ(definition.styleURL, region.getDefinition().styleURL); + EXPECT_EQ(definition.bounds, region.getDefinition().bounds); + EXPECT_EQ(definition.minZoom, region.getDefinition().minZoom); + EXPECT_EQ(definition.maxZoom, region.getDefinition().maxZoom); + EXPECT_EQ(definition.pixelRatio, region.getDefinition().pixelRatio); + EXPECT_EQ(metadata, region.getMetadata()); +} + +TEST(OfflineDatabase, UpdateMetadata) { + using namespace mbgl; + + OfflineDatabase db(":memory:"); + OfflineRegionDefinition definition { "http://example.com/style", LatLngBounds::hull({1, 2}, {3, 4}), 5, 6, 2.0 }; + OfflineRegionMetadata metadata {{ 1, 2, 3 }}; + OfflineRegion region = db.createRegion(definition, metadata); + + OfflineRegionMetadata newmetadata {{ 4, 5, 6 }}; + db.updateMetadata(region.getID(), newmetadata); + EXPECT_EQ(db.listRegions().at(0).getMetadata(), newmetadata); +} + +TEST(OfflineDatabase, ListRegions) { + using namespace mbgl; + + OfflineDatabase db(":memory:"); + OfflineRegionDefinition definition { "http://example.com/style", LatLngBounds::hull({1, 2}, {3, 4}), 5, 6, 2.0 }; + OfflineRegionMetadata metadata {{ 1, 2, 3 }}; + + OfflineRegion region = db.createRegion(definition, metadata); + std::vector regions = db.listRegions(); + + ASSERT_EQ(1u, regions.size()); + EXPECT_EQ(region.getID(), regions.at(0).getID()); + EXPECT_EQ(definition.styleURL, regions.at(0).getDefinition().styleURL); + EXPECT_EQ(definition.bounds, regions.at(0).getDefinition().bounds); + EXPECT_EQ(definition.minZoom, regions.at(0).getDefinition().minZoom); + EXPECT_EQ(definition.maxZoom, regions.at(0).getDefinition().maxZoom); + EXPECT_EQ(definition.pixelRatio, regions.at(0).getDefinition().pixelRatio); + EXPECT_EQ(metadata, regions.at(0).getMetadata()); +} + +TEST(OfflineDatabase, GetRegionDefinition) { + using namespace mbgl; + + OfflineDatabase db(":memory:"); + OfflineRegionDefinition definition { "http://example.com/style", LatLngBounds::hull({1, 2}, {3, 4}), 5, 6, 2.0 }; + OfflineRegionMetadata metadata {{ 1, 2, 3 }}; + + OfflineRegion region = db.createRegion(definition, metadata); + OfflineRegionDefinition result = db.getRegionDefinition(region.getID()); + + EXPECT_EQ(definition.styleURL, result.styleURL); + EXPECT_EQ(definition.bounds, result.bounds); + EXPECT_EQ(definition.minZoom, result.minZoom); + EXPECT_EQ(definition.maxZoom, result.maxZoom); + EXPECT_EQ(definition.pixelRatio, result.pixelRatio); +} + +TEST(OfflineDatabase, DeleteRegion) { + using namespace mbgl; + + OfflineDatabase db(":memory:"); + OfflineRegionDefinition definition { "http://example.com/style", LatLngBounds::hull({1, 2}, {3, 4}), 5, 6, 2.0 }; + OfflineRegionMetadata metadata {{ 1, 2, 3 }}; + OfflineRegion region = db.createRegion(definition, metadata); + + Response response; + response.noContent = true; + + db.putRegionResource(region.getID(), Resource::style("http://example.com/"), response); + db.putRegionResource(region.getID(), Resource::tile("http://example.com/", 1.0, 0, 0, 0, Tileset::Scheme::XYZ), response); + + db.deleteRegion(std::move(region)); + + ASSERT_EQ(0u, db.listRegions().size()); +} + +TEST(OfflineDatabase, CreateRegionInfiniteMaxZoom) { + using namespace mbgl; + + OfflineDatabase db(":memory:"); + OfflineRegionDefinition definition { "", LatLngBounds::world(), 0, INFINITY, 1.0 }; + OfflineRegionMetadata metadata; + OfflineRegion region = db.createRegion(definition, metadata); + + EXPECT_EQ(0, region.getDefinition().minZoom); + EXPECT_EQ(INFINITY, region.getDefinition().maxZoom); +} + +TEST(OfflineDatabase, TEST_REQUIRES_WRITE(ConcurrentUse)) { + using namespace mbgl; + + createDir("test/fixtures/offline_database"); + deleteFile("test/fixtures/offline_database/offline.db"); + + OfflineDatabase db1("test/fixtures/offline_database/offline.db"); + OfflineDatabase db2("test/fixtures/offline_database/offline.db"); + + Resource resource { Resource::Style, "http://example.com/" }; + Response response; + response.noContent = true; + + std::thread thread1([&] { + for (auto i = 0; i < 100; i++) { + db1.put(resource, response); + EXPECT_TRUE(bool(db1.get(resource))); + } + }); + + std::thread thread2([&] { + for (auto i = 0; i < 100; i++) { + db2.put(resource, response); + EXPECT_TRUE(bool(db2.get(resource))); + } + }); + + thread1.join(); + thread2.join(); +} + +static std::shared_ptr randomString(size_t size) { + auto result = std::make_shared(size, 0); + std::mt19937 random; + + for (size_t i = 0; i < size; i++) { + (*result)[i] = random(); + } + + return result; +} + +TEST(OfflineDatabase, PutReturnsSize) { + using namespace mbgl; + + OfflineDatabase db(":memory:"); + + Response compressible; + compressible.data = std::make_shared(1024, 0); + EXPECT_EQ(17u, db.put(Resource::style("http://example.com/compressible"), compressible).second); + + Response incompressible; + incompressible.data = randomString(1024); + EXPECT_EQ(1024u, db.put(Resource::style("http://example.com/incompressible"), incompressible).second); + + Response noContent; + noContent.noContent = true; + EXPECT_EQ(0u, db.put(Resource::style("http://example.com/noContent"), noContent).second); +} + +TEST(OfflineDatabase, PutEvictsLeastRecentlyUsedResources) { + using namespace mbgl; + + OfflineDatabase db(":memory:", 1024 * 100); + + Response response; + response.data = randomString(1024); + + for (uint32_t i = 1; i <= 100; i++) { + Resource resource = Resource::style("http://example.com/"s + util::toString(i)); + db.put(resource, response); + EXPECT_TRUE(bool(db.get(resource))) << i; + } + + EXPECT_FALSE(bool(db.get(Resource::style("http://example.com/1")))); +} + +TEST(OfflineDatabase, PutRegionResourceDoesNotEvict) { + using namespace mbgl; + + OfflineDatabase db(":memory:", 1024 * 100); + OfflineRegionDefinition definition { "", LatLngBounds::world(), 0, INFINITY, 1.0 }; + OfflineRegion region = db.createRegion(definition, OfflineRegionMetadata()); + + Response response; + response.data = randomString(1024); + + for (uint32_t i = 1; i <= 100; i++) { + db.putRegionResource(region.getID(), Resource::style("http://example.com/"s + util::toString(i)), response); + } + + EXPECT_TRUE(bool(db.get(Resource::style("http://example.com/1")))); + EXPECT_TRUE(bool(db.get(Resource::style("http://example.com/20")))); +} + +TEST(OfflineDatabase, PutFailsWhenEvictionInsuffices) { + using namespace mbgl; + + OfflineDatabase db(":memory:", 1024 * 100); + + Response big; + big.data = randomString(1024 * 100); + + EXPECT_FALSE(db.put(Resource::style("http://example.com/big"), big).first); + EXPECT_FALSE(bool(db.get(Resource::style("http://example.com/big")))); +} + +TEST(OfflineDatabase, GetRegionCompletedStatus) { + using namespace mbgl; + + OfflineDatabase db(":memory:"); + OfflineRegionDefinition definition { "http://example.com/style", LatLngBounds::hull({1, 2}, {3, 4}), 5, 6, 2.0 }; + OfflineRegionMetadata metadata; + OfflineRegion region = db.createRegion(definition, metadata); + + OfflineRegionStatus status1 = db.getRegionCompletedStatus(region.getID()); + EXPECT_EQ(0u, status1.completedResourceCount); + EXPECT_EQ(0u, status1.completedResourceSize); + EXPECT_EQ(0u, status1.completedTileCount); + EXPECT_EQ(0u, status1.completedTileSize); + + Response response; + response.data = std::make_shared("data"); + + uint64_t styleSize = db.putRegionResource(region.getID(), Resource::style("http://example.com/"), response); + + OfflineRegionStatus status2 = db.getRegionCompletedStatus(region.getID()); + EXPECT_EQ(1u, status2.completedResourceCount); + EXPECT_EQ(styleSize, status2.completedResourceSize); + EXPECT_EQ(0u, status2.completedTileCount); + EXPECT_EQ(0u, status2.completedTileSize); + + uint64_t tileSize = db.putRegionResource(region.getID(), Resource::tile("http://example.com/", 1.0, 0, 0, 0, Tileset::Scheme::XYZ), response); + + OfflineRegionStatus status3 = db.getRegionCompletedStatus(region.getID()); + EXPECT_EQ(2u, status3.completedResourceCount); + EXPECT_EQ(styleSize + tileSize, status3.completedResourceSize); + EXPECT_EQ(1u, status3.completedTileCount); + EXPECT_EQ(tileSize, status3.completedTileSize); +} + +TEST(OfflineDatabase, OfflineMapboxTileCount) { + using namespace mbgl; + + OfflineDatabase db(":memory:"); + OfflineRegionDefinition definition { "http://example.com/style", LatLngBounds::hull({1, 2}, {3, 4}), 5, 6, 2.0 }; + OfflineRegionMetadata metadata; + + OfflineRegion region1 = db.createRegion(definition, metadata); + OfflineRegion region2 = db.createRegion(definition, metadata); + + 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); + + Response response; + response.data = std::make_shared("data"); + + // Count is initially zero. + EXPECT_EQ(0u, db.getOfflineMapboxTileCount()); + + // Count stays the same after putting a non-tile resource. + db.putRegionResource(region1.getID(), Resource::style("http://example.com/"), response); + EXPECT_EQ(0u, db.getOfflineMapboxTileCount()); + + // Count stays the same after putting a non-Mapbox tile. + db.putRegionResource(region1.getID(), nonMapboxTile, response); + EXPECT_EQ(0u, db.getOfflineMapboxTileCount()); + + // Count increases after putting a Mapbox tile not used by another region. + db.putRegionResource(region1.getID(), mapboxTile1, response); + EXPECT_EQ(1u, db.getOfflineMapboxTileCount()); + + // Count stays the same after putting a Mapbox tile used by another region. + db.putRegionResource(region2.getID(), mapboxTile1, response); + EXPECT_EQ(1u, db.getOfflineMapboxTileCount()); + + // Count stays the same after putting a Mapbox tile used by the same region. + db.putRegionResource(region2.getID(), mapboxTile1, response); + EXPECT_EQ(1u, db.getOfflineMapboxTileCount()); + + // Count stays the same after deleting a region when the tile is still used by another region. + db.deleteRegion(std::move(region2)); + EXPECT_EQ(1u, db.getOfflineMapboxTileCount()); + + // Count stays the same after the putting a non-offline Mapbox tile. + db.put(mapboxTile2, response); + EXPECT_EQ(1u, db.getOfflineMapboxTileCount()); + + // Count increases after putting a pre-existing, but non-offline Mapbox tile. + db.putRegionResource(region1.getID(), mapboxTile2, response); + EXPECT_EQ(2u, db.getOfflineMapboxTileCount()); + + // Count decreases after deleting a region when the tiles are not used by other regions. + db.deleteRegion(std::move(region1)); + EXPECT_EQ(0u, db.getOfflineMapboxTileCount()); +} + +static int databasePageCount(const std::string& path) { + mapbox::sqlite::Database db(path, mapbox::sqlite::ReadOnly); + mapbox::sqlite::Statement stmt = db.prepare("pragma page_count"); + stmt.run(); + return stmt.get(0); +} + +static int databaseUserVersion(const std::string& path) { + mapbox::sqlite::Database db(path, mapbox::sqlite::ReadOnly); + mapbox::sqlite::Statement stmt = db.prepare("pragma user_version"); + stmt.run(); + return stmt.get(0); +} + +static std::string databaseJournalMode(const std::string& path) { + mapbox::sqlite::Database db(path, mapbox::sqlite::ReadOnly); + mapbox::sqlite::Statement stmt = db.prepare("pragma journal_mode"); + stmt.run(); + return stmt.get(0); +} + +static int databaseSyncMode(const std::string& path) { + mapbox::sqlite::Database db(path, mapbox::sqlite::ReadOnly); + mapbox::sqlite::Statement stmt = db.prepare("pragma synchronous"); + stmt.run(); + return stmt.get(0); +} + +TEST(OfflineDatabase, MigrateFromV2Schema) { + using namespace mbgl; + + // v2.db is a v2 database containing a single offline region with a small number of resources. + + deleteFile("test/fixtures/offline_database/v5.db"); + writeFile("test/fixtures/offline_database/v5.db", util::read_file("test/fixtures/offline_database/v2.db")); + + { + OfflineDatabase db("test/fixtures/offline_database/v5.db", 0); + auto regions = db.listRegions(); + for (auto& region : regions) { + db.deleteRegion(std::move(region)); + } + } + + EXPECT_EQ(5, databaseUserVersion("test/fixtures/offline_database/v5.db")); + EXPECT_LT(databasePageCount("test/fixtures/offline_database/v5.db"), + databasePageCount("test/fixtures/offline_database/v2.db")); +} + +TEST(OfflineDatabase, MigrateFromV3Schema) { + using namespace mbgl; + + // v3.db is a v3 database, migrated from v2. + + deleteFile("test/fixtures/offline_database/v5.db"); + writeFile("test/fixtures/offline_database/v5.db", util::read_file("test/fixtures/offline_database/v3.db")); + + { + OfflineDatabase db("test/fixtures/offline_database/v5.db", 0); + auto regions = db.listRegions(); + for (auto& region : regions) { + db.deleteRegion(std::move(region)); + } + } + + EXPECT_EQ(5, databaseUserVersion("test/fixtures/offline_database/v5.db")); +} + +TEST(OfflineDatabase, MigrateFromV4Schema) { + using namespace mbgl; + + // v4.db is a v4 database, migrated from v2 & v3. This database used `journal_mode = WAL` and `synchronous = NORMAL`. + + deleteFile("test/fixtures/offline_database/v5.db"); + writeFile("test/fixtures/offline_database/v5.db", util::read_file("test/fixtures/offline_database/v4.db")); + + { + OfflineDatabase db("test/fixtures/offline_database/v5.db", 0); + auto regions = db.listRegions(); + for (auto& region : regions) { + db.deleteRegion(std::move(region)); + } + } + + EXPECT_EQ(5, databaseUserVersion("test/fixtures/offline_database/v5.db")); + + // Journal mode should be DELETE after migration to v5. + EXPECT_EQ("delete", databaseJournalMode("test/fixtures/offline_database/v5.db")); + + // Synchronous setting should be FULL (2) after migration to v5. + EXPECT_EQ(2, databaseSyncMode("test/fixtures/offline_database/v5.db")); +} -- cgit v1.2.1