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

[core] OnlineFileSource is never accessed directly

Browse Source
This commit is contained in:
Mikhail Pozdnyakov
2020-02-26 17:47:03 +02:00
parent 25d8eab973
commit ba4f5efa09
10 changed files with 143 additions and 153 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/mbgl/storage/online_file_source.hpp
View File

@@ -10,6 +10,7 @@ public:
OnlineFileSource();
~OnlineFileSource() override;
private:
// FileSource overrides
std::unique_ptr<AsyncRequest> request(const Resource&, Callback) override;
bool canRequest(const Resource&) const override;
@@ -19,7 +20,6 @@ public:
mapbox::base::Value getProperty(const std::string&) const override;
void setResourceTransform(ResourceTransform) override;
private:
class Impl;
const std::unique_ptr<Impl> impl;
};

3
platform/android/src/file_source.cpp
View File

@@ -43,8 +43,7 @@ FileSource::FileSource(jni::JNIEnv& _env, const jni::String& accessToken, const
mbgl::FileSourceManager::get()->getFileSource(mbgl::FileSourceType::ResourceLoader, resourceOptions);
databaseSource = std::static_pointer_cast<mbgl::DatabaseFileSource>(std::shared_ptr<mbgl::FileSource>(
mbgl::FileSourceManager::get()->getFileSource(mbgl::FileSourceType::Database, resourceOptions)));
onlineSource = std::static_pointer_cast<mbgl::OnlineFileSource>(std::shared_ptr<mbgl::FileSource>(
mbgl::FileSourceManager::get()->getFileSource(mbgl::FileSourceType::Network, resourceOptions)));
onlineSource = mbgl::FileSourceManager::get()->getFileSource(mbgl::FileSourceType::Network, resourceOptions);
}
FileSource::~FileSource() {

2
platform/android/src/file_source.hpp
View File

@@ -75,7 +75,7 @@ private:
std::unique_ptr<Actor<ResourceTransform::TransformCallback>> resourceTransform;
std::function<void()> pathChangeCallback;
std::shared_ptr<mbgl::DatabaseFileSource> databaseSource;
std::shared_ptr<mbgl::OnlineFileSource> onlineSource;
std::shared_ptr<mbgl::FileSource> onlineSource;
std::shared_ptr<mbgl::FileSource> resourceLoader;
};

4
platform/darwin/src/MGLOfflineStorage.mm
View File

@@ -46,7 +46,7 @@ const MGLExceptionName MGLUnsupportedRegionTypeException = @"MGLUnsupportedRegio
@property (nonatomic, strong, readwrite) NSMutableArray<MGLOfflinePack *> *packs;
@property (nonatomic) std::shared_ptr<mbgl::DatabaseFileSource> mbglDatabaseFileSource;
@property (nonatomic) std::shared_ptr<mbgl::OnlineFileSource> mbglOnlineFileSource;
@property (nonatomic) std::shared_ptr<mbgl::FileSource> mbglOnlineFileSource;
@property (nonatomic) std::shared_ptr<mbgl::FileSource> mbglFileSource;
@property (nonatomic) std::string mbglCachePath;
@property (nonatomic, getter=isPaused) BOOL paused;
@@ -233,7 +233,7 @@ const MGLExceptionName MGLUnsupportedRegionTypeException = @"MGLUnsupportedRegio
options.withCachePath(_mbglCachePath)
.withAssetPath([NSBundle mainBundle].resourceURL.path.UTF8String);
_mbglFileSource = mbgl::FileSourceManager::get()->getFileSource(mbgl::FileSourceType::ResourceLoader, options);
_mbglOnlineFileSource = std::static_pointer_cast<mbgl::OnlineFileSource>(std::shared_ptr<mbgl::FileSource>(mbgl::FileSourceManager::get()->getFileSource(mbgl::FileSourceType::Network, options)));
_mbglOnlineFileSource = mbgl::FileSourceManager::get()->getFileSource(mbgl::FileSourceType::Network, options);
_mbglDatabaseFileSource = std::static_pointer_cast<mbgl::DatabaseFileSource>(std::shared_ptr<mbgl::FileSource>(mbgl::FileSourceManager::get()->getFileSource(mbgl::FileSourceType::Database, options)));
// Observe for changes to the API base URL (and find out the current one).

2
platform/darwin/src/MGLOfflineStorage_Private.h
View File

@@ -19,7 +19,7 @@ NS_ASSUME_NONNULL_BEGIN
/**
The shared online file source object owned by the shared offline storage object.
*/
@property (nonatomic) std::shared_ptr<mbgl::OnlineFileSource> mbglOnlineFileSource;
@property (nonatomic) std::shared_ptr<mbgl::FileSource> mbglOnlineFileSource;
/**
The shared resource loader file source object owned by the shared offline storage object.

2
platform/default/src/mbgl/storage/file_source_manager.cpp
View File

@@ -27,7 +27,7 @@ public:
[](const ResourceOptions&) { return std::make_unique<LocalFileSource>(); });
registerFileSourceFactory(FileSourceType::Network, [](const ResourceOptions& options) {
auto networkSource = std::make_unique<OnlineFileSource>();
std::unique_ptr<FileSource> networkSource = std::make_unique<OnlineFileSource>();
networkSource->setProperty(ACCESS_TOKEN_KEY, options.accessToken());
networkSource->setProperty(API_BASE_URL_KEY, options.baseURL());
return networkSource;

2
platform/qt/src/qmapboxgl.cpp
View File

@@ -1753,7 +1753,7 @@ QMapboxGLPrivate::QMapboxGLPrivate(QMapboxGL *q, const QMapboxGLSettings &settin
}};
std::shared_ptr<mbgl::FileSource> fs =
mbgl::FileSourceManager::get()->getFileSource(mbgl::FileSourceType::Network, resourceOptions);
std::static_pointer_cast<mbgl::OnlineFileSource>(fs)->setResourceTransform(std::move(transform));
fs->setResourceTransform(std::move(transform));
}
// Needs to be Queued to give time to discard redundant draw calls via the `renderQueued` flag.

4
test/src/mbgl/test/fake_file_source.hpp
View File

@@ -75,10 +75,10 @@ public:
}
mapbox::base::Value getProperty(const std::string& property) const override {
return onlineFs.getProperty(property);
return onlineFs->getProperty(property);
}
OnlineFileSource onlineFs;
std::unique_ptr<FileSource> onlineFs = std::make_unique<OnlineFileSource>();
};
} // namespace mbgl

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

@@ -530,9 +530,8 @@ TEST(MainResourceLoader, TEST_REQUIRES_SERVER(NoCacheRefreshModifiedModified)) {
TEST(MainResourceLoader, TEST_REQUIRES_SERVER(SetResourceTransform)) {
util::RunLoop loop;
MainResourceLoader resourceLoader(ResourceOptions{});
std::shared_ptr<FileSource> fs =
std::shared_ptr<FileSource> onlinefs =
FileSourceManager::get()->getFileSource(FileSourceType::Network, ResourceOptions{});
auto onlinefs = std::static_pointer_cast<OnlineFileSource>(fs);
// Translates the URL "localhost://test to http://127.0.0.1:3000/test
Actor<ResourceTransform::TransformCallback> transform(

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

@@ -14,25 +14,23 @@ using namespace mbgl;
TEST(OnlineFileSource, Cancel) {
util::RunLoop loop;
OnlineFileSource fs;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
fs.request({ Resource::Unknown, "http://127.0.0.1:3000/test" }, [&](Response) {
ADD_FAILURE() << "Callback should not be called";
});
fs->request({Resource::Unknown, "http://127.0.0.1:3000/test"},
[&](Response) { ADD_FAILURE() << "Callback should not be called"; });
loop.runOnce();
}
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(CancelMultiple)) {
util::RunLoop loop;
OnlineFileSource fs;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
const Resource resource { Resource::Unknown, "http://127.0.0.1:3000/test" };
std::unique_ptr<AsyncRequest> req2 = fs.request(resource, [&](Response) {
ADD_FAILURE() << "Callback should not be called";
});
std::unique_ptr<AsyncRequest> req = fs.request(resource, [&](Response res) {
std::unique_ptr<AsyncRequest> req2 =
fs->request(resource, [&](Response) { ADD_FAILURE() << "Callback should not be called"; });
std::unique_ptr<AsyncRequest> req = fs->request(resource, [&](Response res) {
req.reset();
EXPECT_EQ(nullptr, res.error);
ASSERT_TRUE(res.data.get());
@@ -50,38 +48,38 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(CancelMultiple)) {
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(TemporaryError)) {
util::RunLoop loop;
OnlineFileSource fs;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
const auto start = Clock::now();
int counter = 0;
auto req = fs.request({ Resource::Unknown, "http://127.0.0.1:3000/temporary-error" }, [&](Response res) {
auto req = fs->request({Resource::Unknown, "http://127.0.0.1:3000/temporary-error"}, [&](Response res) {
switch (counter++) {
case 0: {
const auto duration = std::chrono::duration<const double>(Clock::now() - start).count();
EXPECT_GT(0.2, duration) << "Initial error request took too long";
ASSERT_NE(nullptr, res.error);
EXPECT_EQ(Response::Error::Reason::Server, res.error->reason);
EXPECT_EQ("HTTP status code 500", res.error->message);
ASSERT_FALSE(bool(res.data));
EXPECT_FALSE(bool(res.expires));
EXPECT_FALSE(res.mustRevalidate);
EXPECT_FALSE(bool(res.modified));
EXPECT_FALSE(bool(res.etag));
} break;
case 1: {
const auto duration = std::chrono::duration<const double>(Clock::now() - start).count();
EXPECT_LT(0.99, duration) << "Backoff timer didn't wait 1 second";
EXPECT_GT(1.2, duration) << "Backoff timer fired too late";
EXPECT_EQ(nullptr, res.error);
ASSERT_TRUE(res.data.get());
EXPECT_EQ("Hello World!", *res.data);
EXPECT_FALSE(bool(res.expires));
EXPECT_FALSE(res.mustRevalidate);
EXPECT_FALSE(bool(res.modified));
EXPECT_FALSE(bool(res.etag));
loop.stop();
} break;
case 0: {
const auto duration = std::chrono::duration<const double>(Clock::now() - start).count();
EXPECT_GT(0.2, duration) << "Initial error request took too long";
ASSERT_NE(nullptr, res.error);
EXPECT_EQ(Response::Error::Reason::Server, res.error->reason);
EXPECT_EQ("HTTP status code 500", res.error->message);
ASSERT_FALSE(bool(res.data));
EXPECT_FALSE(bool(res.expires));
EXPECT_FALSE(res.mustRevalidate);
EXPECT_FALSE(bool(res.modified));
EXPECT_FALSE(bool(res.etag));
} break;
case 1: {
const auto duration = std::chrono::duration<const double>(Clock::now() - start).count();
EXPECT_LT(0.99, duration) << "Backoff timer didn't wait 1 second";
EXPECT_GT(1.2, duration) << "Backoff timer fired too late";
EXPECT_EQ(nullptr, res.error);
ASSERT_TRUE(res.data.get());
EXPECT_EQ("Hello World!", *res.data);
EXPECT_FALSE(bool(res.expires));
EXPECT_FALSE(res.mustRevalidate);
EXPECT_FALSE(bool(res.modified));
EXPECT_FALSE(bool(res.etag));
loop.stop();
} break;
}
});
@@ -90,13 +88,13 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(TemporaryError)) {
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(ConnectionError)) {
util::RunLoop loop;
OnlineFileSource fs;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
const auto start = Clock::now();
int counter = 0;
int wait = 0;
std::unique_ptr<AsyncRequest> req = fs.request({ Resource::Unknown, "http://127.0.0.1:3001/" }, [&](Response res) {
std::unique_ptr<AsyncRequest> req = fs->request({Resource::Unknown, "http://127.0.0.1:3001/"}, [&](Response res) {
const auto duration = std::chrono::duration<const double>(Clock::now() - start).count();
EXPECT_LT(wait - 0.01, duration) << "Backoff timer didn't wait 1 second";
EXPECT_GT(wait + 0.3, duration) << "Backoff timer fired too late";
@@ -121,12 +119,12 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(ConnectionError)) {
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(Timeout)) {
util::RunLoop loop;
OnlineFileSource fs;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
int counter = 0;
const Resource resource { Resource::Unknown, "http://127.0.0.1:3000/test?cachecontrol=max-age=1" };
std::unique_ptr<AsyncRequest> req = fs.request(resource, [&](Response res) {
std::unique_ptr<AsyncRequest> req = fs->request(resource, [&](Response res) {
counter++;
EXPECT_EQ(nullptr, res.error);
ASSERT_TRUE(res.data.get());
@@ -148,12 +146,12 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(Timeout)) {
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(RetryDelayOnExpiredTile)) {
util::RunLoop loop;
OnlineFileSource fs;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
int counter = 0;
const Resource resource { Resource::Unknown, "http://127.0.0.1:3000/test?expires=10000" };
std::unique_ptr<AsyncRequest> req = fs.request(resource, [&](Response res) {
std::unique_ptr<AsyncRequest> req = fs->request(resource, [&](Response res) {
counter++;
EXPECT_EQ(nullptr, res.error);
EXPECT_GT(util::now(), *res.expires);
@@ -168,27 +166,27 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(RetryDelayOnExpiredTile)) {
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(RetryOnClockSkew)) {
util::RunLoop loop;
OnlineFileSource fs;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
int counter = 0;
const Resource resource { Resource::Unknown, "http://127.0.0.1:3000/clockskew" };
std::unique_ptr<AsyncRequest> req1 = fs.request(resource, [&](Response res) {
std::unique_ptr<AsyncRequest> req1 = fs->request(resource, [&](Response res) {
EXPECT_FALSE(res.mustRevalidate);
switch (counter++) {
case 0: {
EXPECT_EQ(nullptr, res.error);
EXPECT_GT(util::now(), *res.expires);
} break;
case 1: {
EXPECT_EQ(nullptr, res.error);
case 0: {
EXPECT_EQ(nullptr, res.error);
EXPECT_GT(util::now(), *res.expires);
} break;
case 1: {
EXPECT_EQ(nullptr, res.error);
auto now = util::now();
EXPECT_LT(now + Seconds(40), *res.expires) << "Expiration not interpolated to 60s";
EXPECT_GT(now + Seconds(80), *res.expires) << "Expiration not interpolated to 60s";
auto now = util::now();
EXPECT_LT(now + Seconds(40), *res.expires) << "Expiration not interpolated to 60s";
EXPECT_GT(now + Seconds(80), *res.expires) << "Expiration not interpolated to 60s";
loop.stop();
} break;
loop.stop();
} break;
}
});
@@ -197,37 +195,31 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(RetryOnClockSkew)) {
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(RespectPriorExpires)) {
util::RunLoop loop;
OnlineFileSource fs;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
// Very long expiration time, should never arrive.
Resource resource1{ Resource::Unknown, "http://127.0.0.1:3000/test" };
resource1.priorExpires = util::now() + Seconds(100000);
std::unique_ptr<AsyncRequest> req1 = fs.request(resource1, [&](Response) {
FAIL() << "Should never be called";
});
std::unique_ptr<AsyncRequest> req1 = fs->request(resource1, [&](Response) { FAIL() << "Should never be called"; });
// No expiration time, should be requested immediately.
Resource resource2{ Resource::Unknown, "http://127.0.0.1:3000/test" };
std::unique_ptr<AsyncRequest> req2 = fs.request(resource2, [&](Response) {
loop.stop();
});
std::unique_ptr<AsyncRequest> req2 = fs->request(resource2, [&](Response) { loop.stop(); });
// Very long expiration time, should never arrive.
Resource resource3{ Resource::Unknown, "http://127.0.0.1:3000/test" };
resource3.priorExpires = util::now() + Seconds(100000);
std::unique_ptr<AsyncRequest> req3 = fs.request(resource3, [&](Response) {
FAIL() << "Should never be called";
});
std::unique_ptr<AsyncRequest> req3 = fs->request(resource3, [&](Response) { FAIL() << "Should never be called"; });
loop.run();
}
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(Load)) {
util::RunLoop loop;
OnlineFileSource fs;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
const int concurrency = 50;
const int max = 10000;
@@ -237,24 +229,23 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(Load)) {
std::function<void(int)> req = [&](int i) {
const auto current = number++;
reqs[i] = fs.request({ Resource::Unknown,
std::string("http://127.0.0.1:3000/load/") + util::toString(current) },
[&, i, current](Response res) {
reqs[i].reset();
EXPECT_EQ(nullptr, res.error);
ASSERT_TRUE(res.data.get());
EXPECT_EQ(std::string("Request ") + util::toString(current), *res.data);
EXPECT_FALSE(bool(res.expires));
EXPECT_FALSE(res.mustRevalidate);
EXPECT_FALSE(bool(res.modified));
EXPECT_FALSE(bool(res.etag));
reqs[i] = fs->request({Resource::Unknown, std::string("http://127.0.0.1:3000/load/") + util::toString(current)},
[&, i, current](Response res) {
reqs[i].reset();
EXPECT_EQ(nullptr, res.error);
ASSERT_TRUE(res.data.get());
EXPECT_EQ(std::string("Request ") + util::toString(current), *res.data);
EXPECT_FALSE(bool(res.expires));
EXPECT_FALSE(res.mustRevalidate);
EXPECT_FALSE(bool(res.modified));
EXPECT_FALSE(bool(res.etag));
if (number <= max) {
req(i);
} else if (current == max) {
loop.stop();
}
});
if (number <= max) {
req(i);
} else if (current == max) {
loop.stop();
}
});
};
for (int i = 0; i < concurrency; i++) {
@@ -272,21 +263,21 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(Load)) {
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(NetworkStatusChange)) {
util::RunLoop loop;
OnlineFileSource fs;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
const Resource resource { Resource::Unknown, "http://127.0.0.1:3000/delayed" };
// This request takes 200 milliseconds to answer.
std::unique_ptr<AsyncRequest> req = fs.request(resource, [&](Response res) {
req.reset();
EXPECT_EQ(nullptr, res.error);
ASSERT_TRUE(res.data.get());
EXPECT_EQ("Response", *res.data);
EXPECT_FALSE(bool(res.expires));
EXPECT_FALSE(res.mustRevalidate);
EXPECT_FALSE(bool(res.modified));
EXPECT_FALSE(bool(res.etag));
loop.stop();
std::unique_ptr<AsyncRequest> req = fs->request(resource, [&](Response res) {
req.reset();
EXPECT_EQ(nullptr, res.error);
ASSERT_TRUE(res.data.get());
EXPECT_EQ("Response", *res.data);
EXPECT_FALSE(bool(res.expires));
EXPECT_FALSE(res.mustRevalidate);
EXPECT_FALSE(bool(res.modified));
EXPECT_FALSE(bool(res.etag));
loop.stop();
});
// After 50 milliseconds, we're going to trigger a NetworkStatus change.
@@ -302,14 +293,14 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(NetworkStatusChange)) {
// reachability issues.
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(NetworkStatusChangePreempt)) {
util::RunLoop loop;
OnlineFileSource fs;
fs.pause();
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
fs->pause();
const auto start = Clock::now();
int counter = 0;
const Resource resource{ Resource::Unknown, "http://127.0.0.1:3001/test" };
std::unique_ptr<AsyncRequest> req = fs.request(resource, [&](Response res) {
std::unique_ptr<AsyncRequest> req = fs->request(resource, [&](Response res) {
const auto duration = std::chrono::duration<const double>(Clock::now() - start).count();
if (counter == 0) {
EXPECT_GT(0.2, duration) << "Response came in too late";
@@ -339,13 +330,13 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(NetworkStatusChangePreempt)) {
mbgl::NetworkStatus::Reachable();
});
fs.resume();
fs->resume();
loop.run();
}
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(NetworkStatusOnlineOffline)) {
util::RunLoop loop;
OnlineFileSource fs;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
const Resource resource { Resource::Unknown, "http://127.0.0.1:3000/test" };
@@ -357,7 +348,7 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(NetworkStatusOnlineOffline)) {
NetworkStatus::Set(NetworkStatus::Status::Online);
});
std::unique_ptr<AsyncRequest> req = fs.request(resource, [&](Response res) {
std::unique_ptr<AsyncRequest> req = fs->request(resource, [&](Response res) {
req.reset();
EXPECT_EQ(nullptr, res.error);
@@ -373,9 +364,9 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(NetworkStatusOnlineOffline)) {
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(RateLimitStandard)) {
util::RunLoop loop;
OnlineFileSource fs;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
auto req = fs.request({ Resource::Unknown, "http://127.0.0.1:3000/rate-limit?std=true" }, [&](Response res) {
auto req = fs->request({Resource::Unknown, "http://127.0.0.1:3000/rate-limit?std=true"}, [&](Response res) {
ASSERT_NE(nullptr, res.error);
EXPECT_EQ(Response::Error::Reason::RateLimit, res.error->reason);
ASSERT_EQ(true, bool(res.error->retryAfter));
@@ -388,9 +379,9 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(RateLimitStandard)) {
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(RateLimitMBX)) {
util::RunLoop loop;
OnlineFileSource fs;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
auto req = fs.request({ Resource::Unknown, "http://127.0.0.1:3000/rate-limit?mbx=true" }, [&](Response res) {
auto req = fs->request({Resource::Unknown, "http://127.0.0.1:3000/rate-limit?mbx=true"}, [&](Response res) {
ASSERT_NE(nullptr, res.error);
EXPECT_EQ(Response::Error::Reason::RateLimit, res.error->reason);
ASSERT_EQ(true, bool(res.error->retryAfter));
@@ -403,9 +394,9 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(RateLimitMBX)) {
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(RateLimitDefault)) {
util::RunLoop loop;
OnlineFileSource fs;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
auto req = fs.request({ Resource::Unknown, "http://127.0.0.1:3000/rate-limit" }, [&](Response res) {
auto req = fs->request({Resource::Unknown, "http://127.0.0.1:3000/rate-limit"}, [&](Response res) {
ASSERT_NE(nullptr, res.error);
EXPECT_EQ(Response::Error::Reason::RateLimit, res.error->reason);
ASSERT_FALSE(res.error->retryAfter);
@@ -417,46 +408,46 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(RateLimitDefault)) {
TEST(OnlineFileSource, GetBaseURLAndAccessTokenWhilePaused) {
util::RunLoop loop;
OnlineFileSource fs;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
fs.pause();
fs->pause();
auto baseURL = "http://url";
auto accessToken = "access_token";
fs.setProperty(API_BASE_URL_KEY, baseURL);
fs.setProperty(ACCESS_TOKEN_KEY, accessToken);
fs->setProperty(API_BASE_URL_KEY, baseURL);
fs->setProperty(ACCESS_TOKEN_KEY, accessToken);
EXPECT_EQ(*fs.getProperty(API_BASE_URL_KEY).getString(), baseURL);
EXPECT_EQ(*fs.getProperty(ACCESS_TOKEN_KEY).getString(), accessToken);
EXPECT_EQ(*fs->getProperty(API_BASE_URL_KEY).getString(), baseURL);
EXPECT_EQ(*fs->getProperty(ACCESS_TOKEN_KEY).getString(), accessToken);
}
TEST(OnlineFileSource, ChangeAPIBaseURL){
util::RunLoop loop;
OnlineFileSource fs;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
EXPECT_EQ(mbgl::util::API_BASE_URL, *fs.getProperty(API_BASE_URL_KEY).getString());
EXPECT_EQ(mbgl::util::API_BASE_URL, *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());
fs->setProperty(API_BASE_URL_KEY, customURL);
EXPECT_EQ(customURL, *fs->getProperty(API_BASE_URL_KEY).getString());
}
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(LowHighPriorityRequests)) {
util::RunLoop loop;
OnlineFileSource fs;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
std::size_t response_counter = 0;
const std::size_t NUM_REQUESTS = 3;
NetworkStatus::Set(NetworkStatus::Status::Offline);
fs.setProperty(MAX_CONCURRENT_REQUESTS_KEY, 1u);
fs->setProperty(MAX_CONCURRENT_REQUESTS_KEY, 1u);
// After DefaultFileSource was split, OnlineFileSource lives on a separate
// thread. Pause OnlineFileSource, so that messages are queued for processing.
fs.pause();
fs->pause();
// First regular request.
Resource regular1{Resource::Unknown, "http://127.0.0.1:3000/load/1"};
std::unique_ptr<AsyncRequest> req_0 = fs.request(regular1, [&](Response) {
std::unique_ptr<AsyncRequest> req_0 = fs->request(regular1, [&](Response) {
response_counter++;
req_0.reset();
});
@@ -464,7 +455,7 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(LowHighPriorityRequests)) {
// Low priority request that will be queued and should be requested last.
Resource low_prio{Resource::Unknown, "http://127.0.0.1:3000/load/2"};
low_prio.setPriority(Resource::Priority::Low);
std::unique_ptr<AsyncRequest> req_1 = fs.request(low_prio, [&](Response) {
std::unique_ptr<AsyncRequest> req_1 = fs->request(low_prio, [&](Response) {
response_counter++;
req_1.reset();
EXPECT_EQ(response_counter, NUM_REQUESTS); // make sure this is responded last
@@ -473,12 +464,12 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(LowHighPriorityRequests)) {
// Second regular priority request that should de-preoritize low priority request.
Resource regular2{ Resource::Unknown, "http://127.0.0.1:3000/load/3" };
std::unique_ptr<AsyncRequest> req_2 = fs.request(regular2, [&](Response) {
std::unique_ptr<AsyncRequest> req_2 = fs->request(regular2, [&](Response) {
response_counter++;
req_2.reset();
});
fs.resume();
fs->resume();
NetworkStatus::Set(NetworkStatus::Status::Online);
loop.run();
}
@@ -486,33 +477,34 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(LowHighPriorityRequests)) {
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(LowHighPriorityRequestsMany)) {
util::RunLoop loop;
OnlineFileSource fs;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
int response_counter = 0;
int correct_low = 0;
int correct_regular = 0;
NetworkStatus::Set(NetworkStatus::Status::Offline);
fs.setProperty(MAX_CONCURRENT_REQUESTS_KEY, 1u);
fs.pause();
fs->setProperty(MAX_CONCURRENT_REQUESTS_KEY, 1u);
fs->pause();
std::vector<std::unique_ptr<AsyncRequest>> collector;
for (int num_reqs = 0; num_reqs < 20; num_reqs++) {
if (num_reqs % 2 == 0) {
std::unique_ptr<AsyncRequest> req = fs.request({ Resource::Unknown, "http://127.0.0.1:3000/load/" + std::to_string(num_reqs) }, [&](Response) {
response_counter++;
std::unique_ptr<AsyncRequest> req = fs->request(
{Resource::Unknown, "http://127.0.0.1:3000/load/" + std::to_string(num_reqs)}, [&](Response) {
response_counter++;
if (response_counter <= 10) { // count the high priority requests that arrive late correctly
correct_regular++;
}
});
if (response_counter <= 10) { // count the high priority requests that arrive late correctly
correct_regular++;
}
});
collector.push_back(std::move(req));
}
else {
Resource resource = { Resource::Unknown, "http://127.0.0.1:3000/load/" + std::to_string(num_reqs) };
resource.setPriority(Resource::Priority::Low);
std::unique_ptr<AsyncRequest> req = fs.request(std::move(resource), [&](Response) {
std::unique_ptr<AsyncRequest> req = fs->request(std::move(resource), [&](Response) {
response_counter++;
if (response_counter > 10) { // count the low priority requests that arrive late correctly
@@ -533,30 +525,30 @@ TEST(OnlineFileSource, TEST_REQUIRES_SERVER(LowHighPriorityRequestsMany)) {
}
}
fs.resume();
fs->resume();
NetworkStatus::Set(NetworkStatus::Status::Online);
loop.run();
}
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(MaximumConcurrentRequests)) {
util::RunLoop loop;
OnlineFileSource fs;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
ASSERT_EQ(*fs.getProperty(MAX_CONCURRENT_REQUESTS_KEY).getUint(), 20u);
ASSERT_EQ(*fs->getProperty(MAX_CONCURRENT_REQUESTS_KEY).getUint(), 20u);
fs.setProperty(MAX_CONCURRENT_REQUESTS_KEY, 10u);
ASSERT_EQ(*fs.getProperty(MAX_CONCURRENT_REQUESTS_KEY).getUint(), 10u);
fs->setProperty(MAX_CONCURRENT_REQUESTS_KEY, 10u);
ASSERT_EQ(*fs->getProperty(MAX_CONCURRENT_REQUESTS_KEY).getUint(), 10u);
}
TEST(OnlineFileSource, TEST_REQUIRES_SERVER(RequestSameUrlMultipleTimes)) {
util::RunLoop loop;
OnlineFileSource fs;
std::unique_ptr<FileSource> fs = std::make_unique<OnlineFileSource>();
int count = 0;
std::vector<std::unique_ptr<AsyncRequest>> requests;
for (int i = 0; i < 100; ++i) {
requests.emplace_back(fs.request({ Resource::Unknown, "http://127.0.0.1:3000/load" }, [&](Response) {
requests.emplace_back(fs->request({Resource::Unknown, "http://127.0.0.1:3000/load"}, [&](Response) {
if (++count == 100) {
loop.stop();
}