move cpr in-tree (#605)

* added cpr 1.10.5 in-tree to allow updates to vcpkg without breaking the build
* added asio 1.29.0 in-tree to remove one more vcpkg dependency
* bumped vcpkg to 2024.06.15 to address failure to build due to use of deprecated binaries in vcpkg (404 error: `https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-pkgconf-1~2.1.0-1-any.pkg.tar.zst` during build)

1 files changed, 437 insertions, 0 deletions

diff --git a/thirdparty/cpr/test/multiasync_tests.cpp b/thirdparty/cpr/test/multiasync_tests.cpp
new file mode 100644
index 000000000..1e39f73f4
--- /dev/null
+++ b/thirdparty/cpr/test/multiasync_tests.cpp
@@ -0,0 +1,437 @@
+#include <string>
+#include <vector>
+
+#include <cpr/cpr.h>
+
+#include "httpServer.hpp"
+#include "multiasync_tests.hpp"
+
+using namespace cpr;
+
+static HttpServer* server = new HttpServer();
+
+// A cancellable AsyncResponse
+using AsyncResponseC = AsyncWrapper<Response, true>;
+
+/** This property is tested at compile-time, so if compilation succeeds, it has already been verified. It is, however, useful to structure it as a test for semantic purposes.
+ */
+TEST(AsyncWrapperTests, TestConstructorDeductions) {
+    auto wrapper_non_cancellable{AsyncWrapper{std::future<std::string>{}}};
+    auto wrapper_cancellable{AsyncWrapper{std::future<std::string>{}, std::make_shared<std::atomic_bool>(false)}};
+
+    static_assert(std::is_same<AsyncWrapper<std::string, false>, decltype(wrapper_non_cancellable)>::value);
+    static_assert(std::is_same<AsyncWrapper<std::string, true>, decltype(wrapper_cancellable)>::value);
+    SUCCEED();
+}
+
+/** These tests aim to set a point of reference for AsyncWrapper behavior.
+ * Those functions that replicate std::future member functions should behave in a way that is in all ways compatible.
+ * Others should behave as expected by the below test set.
+ */
+TEST(AsyncWrapperNonCancellableTests, TestGetNoError) {
+    const Url hello_url{server->GetBaseUrl() + "/hello.html"};
+    const std::string expected_hello{"Hello world!"};
+    const Response resp{GetAsync(hello_url).get()};
+    EXPECT_EQ(expected_hello, resp.text);
+}
+
+TEST(AsyncWrapperNonCancellableTests, TestExceptionsNoSharedState) {
+    const std::chrono::duration five_secs{std::chrono::seconds(1)};
+    const std::chrono::time_point in_five_s{std::chrono::steady_clock::now() + five_secs};
+
+    // We create an AsyncWrapper for a future without a shared state (default-initialized)
+    AsyncWrapper test_wrapper{std::future<std::string>{}};
+
+
+    ASSERT_FALSE(test_wrapper.valid());
+    ASSERT_FALSE(test_wrapper.IsCancelled());
+
+    // Trying to get or wait for a future that doesn't have a shared state should result to an exception
+    // It should be noted that there is a divergence from std::future behavior here: calling wait* on the original std::future is undefined behaviour, according to cppreference.com . We find it preferrable to throw an exception.
+    EXPECT_THROW(std::ignore = test_wrapper.get(), std::exception);
+    EXPECT_THROW(test_wrapper.wait(), std::exception);
+    EXPECT_THROW(test_wrapper.wait_for(five_secs), std::exception);
+    EXPECT_THROW(test_wrapper.wait_until(in_five_s), std::exception);
+}
+
+TEST(AsyncWrapperCancellableTests, TestExceptionsNoSharedState) {
+    const std::chrono::duration five_secs{std::chrono::seconds(5)};
+    const std::chrono::time_point in_five_s{std::chrono::steady_clock::now() + five_secs};
+
+    AsyncWrapper test_wrapper{std::future<std::string>{}, std::make_shared<std::atomic_bool>(false)};
+
+    static_assert(std::is_same<AsyncWrapper<std::string, true>, decltype(test_wrapper)>::value);
+
+    ASSERT_FALSE(test_wrapper.valid());
+    ASSERT_FALSE(test_wrapper.IsCancelled());
+
+    EXPECT_THROW(std::ignore = test_wrapper.get(), std::exception);
+    EXPECT_THROW(test_wrapper.wait(), std::exception);
+    EXPECT_THROW(test_wrapper.wait_for(five_secs), std::exception);
+    EXPECT_THROW(test_wrapper.wait_until(in_five_s), std::exception);
+}
+
+TEST(AsyncWrapperCancellableTests, TestExceptionsCancelledRequest) {
+    const Url call_url{server->GetBaseUrl() + "/low_speed_bytes.html"};
+    const std::chrono::duration five_secs{std::chrono::seconds(5)};
+    const std::chrono::time_point in_five_s{std::chrono::steady_clock::now() + five_secs};
+
+    AsyncResponseC test_wrapper{std::move(MultiGetAsync(std::tuple{call_url}).at(0))};
+    EXPECT_EQ(CancellationResult::success, test_wrapper.Cancel());
+    EXPECT_EQ(CancellationResult::invalid_operation, test_wrapper.Cancel());
+    ASSERT_TRUE(test_wrapper.IsCancelled());
+
+    EXPECT_THROW(std::ignore = test_wrapper.get(), std::exception);
+    EXPECT_THROW(test_wrapper.wait(), std::exception);
+    EXPECT_THROW(test_wrapper.wait_for(five_secs), std::exception);
+    EXPECT_THROW(test_wrapper.wait_until(in_five_s), std::exception);
+}
+
+TEST(AsyncWrapperCancellableTests, TestWaitFor) {
+    constexpr std::chrono::duration wait_for_time{std::chrono::milliseconds(100)};
+    constexpr std::chrono::duration teardown_time{std::chrono::milliseconds(10)};
+
+    const Url call_url{server->GetBaseUrl() + "/low_speed_bytes.html"};
+
+    AsyncResponseC test_wrapper{std::move(MultiGetAsync(std::tuple{call_url}).at(0))};
+
+    EXPECT_EQ(std::future_status::timeout, test_wrapper.wait_for(wait_for_time));
+
+    ASSERT_TRUE(test_wrapper.valid());
+    ASSERT_FALSE(test_wrapper.IsCancelled());
+
+    EXPECT_EQ(CancellationResult::success, test_wrapper.Cancel());
+
+    std::this_thread::sleep_for(teardown_time);
+}
+/** The group MultiAsyncBasicTests executes multiple tests from the test sources associated with every Http action in parallel.
+ * These tests are reproductions of tests from the appropriate test suites, but they guarantee that the multiasync function template produces correctly working instantiations for every Http action.
+ */
+TEST(MultiAsyncBasicTests, MultiAsyncGetTest) {
+    const Url hello_url{server->GetBaseUrl() + "/hello.html"};
+    const std::string expected_hello{"Hello world!"};
+    std::vector<AsyncResponseC> resps{MultiGetAsync(std::tuple{hello_url}, std::tuple{hello_url}, std::tuple{hello_url})};
+
+    for (AsyncResponseC& resp : resps) {
+        EXPECT_EQ(expected_hello, resp.get().text);
+    }
+}
+
+TEST(MultiAsyncBasicTests, MultiAsyncDeleteTest) {
+    const std::string server_base{server->GetBaseUrl()};
+    const Url delete_allowed{server_base + "/delete.html"};
+    const Url delete_unallowed{server_base + "/delete_unallowed.html"};
+    const std::tuple del_json_params{delete_allowed, Body{"'foo':'bar'"}, Header{{"Content-Type", "application/json"}}};
+    const std::string expected_text_success{"Delete success"};
+    const std::string expected_text_fail{"Method Not Allowed"};
+    const std::string expected_text_json{"'foo':'bar'"};
+
+    std::vector<AsyncResponseC> resps{MultiDeleteAsync(std::tuple{delete_allowed}, std::tuple{delete_unallowed}, del_json_params)};
+
+    Response del_success{resps.at(0).get()};
+    Response del_fail{resps.at(1).get()};
+    Response del_json{resps.at(2).get()};
+
+    EXPECT_EQ(expected_text_success, del_success.text);
+    EXPECT_EQ(delete_allowed, del_success.url);
+    EXPECT_EQ(std::string{"text/html"}, del_success.header["content-type"]);
+    EXPECT_EQ(200, del_success.status_code);
+    EXPECT_EQ(ErrorCode::OK, del_success.error.code);
+
+    EXPECT_EQ(expected_text_fail, del_fail.text);
+    EXPECT_EQ(delete_unallowed, del_fail.url);
+    EXPECT_EQ(std::string{"text/plain"}, del_fail.header["content-type"]);
+    EXPECT_EQ(405, del_fail.status_code);
+    EXPECT_EQ(ErrorCode::OK, del_fail.error.code);
+
+    EXPECT_EQ(expected_text_json, del_json.text);
+    EXPECT_EQ(delete_allowed, del_json.url);
+    EXPECT_EQ(std::string{"application/json"}, del_json.header["content-type"]);
+    EXPECT_EQ(200, del_json.status_code);
+    EXPECT_EQ(ErrorCode::OK, del_json.error.code);
+}
+
+TEST(MultiAsyncBasicTests, MultiAsyncHeadTest) {
+    const std::string server_base{server->GetBaseUrl()};
+    const Url hello_url{server_base + "/hello.html"};
+    const Url json_url{server_base + "/basic.json"};
+    const Url notfound_url{server_base + "/error.html"};
+    const Url digest_url{server_base + "/digest_auth.html"};
+    const Authentication digest_auth{"user", "password", AuthMode::DIGEST};
+
+    std::vector<AsyncResponseC> resps{MultiHeadAsync(std::tuple{hello_url}, std::tuple{json_url}, std::tuple{notfound_url}, std::tuple{digest_url, digest_auth})};
+    Response hello_resp{resps.at(0).get()};
+    Response json_resp{resps.at(1).get()};
+    Response notfound_resp{resps.at(2).get()};
+    Response digest_resp{resps.at(3).get()};
+
+    EXPECT_EQ(std::string{}, hello_resp.text);
+    EXPECT_EQ(hello_url, hello_resp.url);
+    EXPECT_EQ(std::string{"text/html"}, hello_resp.header["content-type"]);
+    EXPECT_EQ(200, hello_resp.status_code);
+    EXPECT_EQ(ErrorCode::OK, hello_resp.error.code);
+
+    EXPECT_EQ(std::string{}, json_resp.text);
+    EXPECT_EQ(json_url, json_resp.url);
+    EXPECT_EQ(std::string{"application/json"}, json_resp.header["content-type"]);
+    EXPECT_EQ(200, json_resp.status_code);
+    EXPECT_EQ(ErrorCode::OK, json_resp.error.code);
+
+    EXPECT_EQ(std::string{}, notfound_resp.text);
+    EXPECT_EQ(notfound_url, notfound_resp.url);
+    EXPECT_EQ(std::string{"text/plain"}, notfound_resp.header["content-type"]);
+    EXPECT_EQ(404, notfound_resp.status_code);
+    EXPECT_EQ(ErrorCode::OK, notfound_resp.error.code);
+
+    EXPECT_EQ(std::string{}, digest_resp.text);
+    EXPECT_EQ(digest_url, digest_resp.url);
+    EXPECT_EQ(std::string{"text/html"}, digest_resp.header["content-type"]);
+    EXPECT_EQ(200, digest_resp.status_code);
+    EXPECT_EQ(ErrorCode::OK, digest_resp.error.code);
+}
+
+TEST(MultiAsyncBasicTests, MultiAsyncOptionsTest) {
+    const std::string server_base{server->GetBaseUrl()};
+    const Url root_url{server_base + "/"};
+    const Url hello_url{server_base + "/hello.html"};
+
+    std::vector<AsyncResponseC> resps{MultiOptionsAsync(std::tuple{root_url}, std::tuple{hello_url})};
+
+    Response root_resp{resps.at(0).get()};
+    Response hello_resp{resps.at(1).get()};
+
+    EXPECT_EQ(std::string{}, root_resp.text);
+    EXPECT_EQ(root_url, root_resp.url);
+    EXPECT_EQ(std::string{"GET, POST, PUT, DELETE, PATCH, OPTIONS"}, root_resp.header["Access-Control-Allow-Methods"]);
+    EXPECT_EQ(200, root_resp.status_code);
+    EXPECT_EQ(ErrorCode::OK, root_resp.error.code);
+
+    EXPECT_EQ(std::string{}, hello_resp.text);
+    EXPECT_EQ(hello_url, hello_resp.url);
+    EXPECT_EQ(std::string{"GET, POST, PUT, DELETE, PATCH, OPTIONS"}, hello_resp.header["Access-Control-Allow-Methods"]);
+    EXPECT_EQ(200, hello_resp.status_code);
+    EXPECT_EQ(ErrorCode::OK, hello_resp.error.code);
+}
+
+TEST(MultiAsyncBasicTests, MultiAsyncPatchTest) {
+    const std::string server_base{server->GetBaseUrl()};
+    const Url patch_url{server_base + "/patch.html"};
+    const Url patch_not_allowed_url{server_base + "/patch_unallowed.html"};
+    const Payload pl{{"x", "10"}, {"y", "1"}};
+    const std::string expected_text{
+            "{\n"
+            "  \"x\": 10,\n"
+            "  \"y\": 1,\n"
+            "  \"sum\": 11\n"
+            "}"};
+    const std::string notallowed_text{"Method Not Allowed"};
+    std::vector<AsyncResponseC> resps{MultiPatchAsync(std::tuple{patch_url, pl}, std::tuple{patch_not_allowed_url, pl})};
+    const Response success{resps.at(0).get()};
+    const Response fail{resps.at(1).get()};
+    EXPECT_EQ(expected_text, success.text);
+    EXPECT_EQ(200, success.status_code);
+    EXPECT_EQ(patch_url, success.url);
+
+    EXPECT_EQ(notallowed_text, fail.text);
+    EXPECT_EQ(405, fail.status_code);
+    EXPECT_EQ(ErrorCode::OK, fail.error.code);
+}
+
+TEST(MultiAsyncBasicTests, MultiAsyncPostTest) {
+    const std::string server_base{server->GetBaseUrl()};
+    const Url post_url{server_base + "/url_post.html"};
+    const Url form_post_url{server_base + "/form_post.html"};
+
+    const Payload post_data{{"x", "5"}, {"y", "15"}};
+    const Multipart form_data{{"x", 5}};
+
+    const std::string post_text{
+            "{\n"
+            "  \"x\": 5,\n"
+            "  \"y\": 15,\n"
+            "  \"sum\": 20\n"
+            "}"};
+    const std::string form_text{
+            "{\n"
+            "  \"x\": \"5\"\n"
+            "}"};
+
+    std::vector<AsyncResponseC> resps{MultiPostAsync(std::tuple{post_url, post_data}, std::tuple{form_post_url, form_data})};
+
+    Response post_resp{resps.at(0).get()};
+    Response form_resp{resps.at(1).get()};
+
+    EXPECT_EQ(post_text, post_resp.text);
+    EXPECT_EQ(post_url, post_resp.url);
+    EXPECT_EQ(std::string{"application/json"}, post_resp.header["content-type"]);
+    EXPECT_EQ(201, post_resp.status_code);
+    EXPECT_EQ(ErrorCode::OK, post_resp.error.code);
+
+    EXPECT_EQ(form_text, form_resp.text);
+    EXPECT_EQ(form_post_url, form_resp.url);
+    EXPECT_EQ(std::string{"application/json"}, form_resp.header["content-type"]);
+    EXPECT_EQ(201, form_resp.status_code);
+    EXPECT_EQ(ErrorCode::OK, form_resp.error.code);
+}
+
+TEST(MultiAsyncBasicTests, MultiAsyncPutTest) {
+    const std::string server_base{server->GetBaseUrl()};
+    const Url put_url{server_base + "/put.html"};
+    const Url put_failure_url{server_base + "/put_unallowed.html"};
+    const Payload pl{{"x", "7"}};
+    const std::string success_text{
+            "{\n"
+            "  \"x\": 7\n"
+            "}"};
+    const std::string failure_text{"Method Not Allowed"};
+
+    std::vector<AsyncResponseC> resps{MultiPutAsync(std::tuple{put_url, pl}, std::tuple{put_failure_url, pl})};
+    Response success_resp{resps.at(0).get()};
+    Response failure_resp{resps.at(1).get()};
+
+    EXPECT_EQ(success_text, success_resp.text);
+    EXPECT_EQ(put_url, success_resp.url);
+    EXPECT_EQ(std::string{"application/json"}, success_resp.header["content-type"]);
+    EXPECT_EQ(200, success_resp.status_code);
+    EXPECT_EQ(ErrorCode::OK, success_resp.error.code);
+
+    EXPECT_EQ(failure_text, failure_resp.text);
+    EXPECT_EQ(put_failure_url, failure_resp.url);
+    EXPECT_EQ(std::string{"text/plain"}, failure_resp.header["content-type"]);
+    EXPECT_EQ(405, failure_resp.status_code);
+    EXPECT_EQ(ErrorCode::OK, failure_resp.error.code);
+}
+
+static TestSynchronizationEnv* synchro_env = new TestSynchronizationEnv();
+
+/**
+ * We test that cancellation on queue, works, ie libcurl does not get engaged at all
+ * To do this, we plant an observer function in the progress call sequence, which
+ * will set an atomic boolean to true. The objective is to verify that within 500ms,
+ * the function is never called.
+ */
+TEST(MultiAsyncCancelTests, CancellationOnQueue) {
+    synchro_env->Reset();
+    const Url hello_url{server->GetBaseUrl() + "/hello.html"};
+    const std::function observer_fn{[](cpr_pf_arg_t, cpr_pf_arg_t, cpr_pf_arg_t, cpr_pf_arg_t, intptr_t) -> bool {
+        synchro_env->fn_called.store(true);
+        return true;
+    }};
+
+    GlobalThreadPool::GetInstance()->Pause();
+    std::vector<AsyncResponseC> resps{MultiGetAsync(std::tuple{hello_url, ProgressCallback{observer_fn}})};
+    EXPECT_EQ(CancellationResult::success, resps.at(0).Cancel());
+    GlobalThreadPool::GetInstance()->Resume();
+    const bool was_called{synchro_env->fn_called};
+    EXPECT_EQ(false, was_called);
+}
+
+/**
+ * We test that cancellation works as intended while the request is being processed by the server.
+ * To achieve this we use a condition variable to ensure that the observer function, wrapped in a
+ * cpr::ProgressCallback, is called at least once, and then no further calls are made for half a
+ * second after cancellation.
+ *
+ * The usage of the condition variable and mutex to synchronize this procedure is analogous to the section "Example" in https://en.cppreference.com/w/cpp/thread/condition_variable
+ * We use the condition variable in our synchronization environment to ensure that the transfer has
+ * started at the time of cancellation, ie the observer function has been called at least once.
+ */
+TEST(MultiAsyncCancelTests, TestCancellationInTransit) {
+    const Url call_url{server->GetBaseUrl() + "/low_speed_bytes.html"};
+    synchro_env->Reset();
+
+    // 1. Thread running the test acquires the condition variable's mutex
+    std::unique_lock setup_lock{synchro_env->test_cv_mutex};
+    const std::function observer_fn{[](cpr_pf_arg_t, cpr_pf_arg_t, cpr_pf_arg_t, cpr_pf_arg_t, intptr_t) -> bool {
+        if (synchro_env->counter == 0) {
+            // 3. in Threadpool, the cv mutex is obtained by the worker thread
+            const std::unique_lock l{synchro_env->test_cv_mutex};
+            synchro_env->counter++;
+            // 4. the cv is notified
+            synchro_env->test_cv.notify_all();
+        } else {
+            synchro_env->counter++;
+        }
+        return true;
+    }};
+    std::vector<AsyncResponseC> res{cpr::MultiGetAsync(std::tuple{call_url, cpr::ProgressCallback{observer_fn}})};
+    // 2. cv mutex is released, thread waits for notification on cv
+    // see https://en.cppreference.com/w/cpp/thread/condition_variable/wait
+    synchro_env->test_cv.wait(setup_lock);
+    // 5. execution continues after notification
+    const size_t init_calls{synchro_env->counter};
+    EXPECT_LT(0, init_calls);
+    EXPECT_EQ(cpr::CancellationResult::success, res.at(0).Cancel());
+    const size_t calls{synchro_env->counter};
+    std::this_thread::sleep_for(std::chrono::milliseconds{101});
+    const size_t calls_post{synchro_env->counter};
+    EXPECT_LT(calls_post, calls + 2);
+}
+
+/** Checks that the request is cancelled when the corresponding AsyncResponseC is desturcted
+ */
+TEST(MultiAsyncCancelTests, TestCancellationOnResponseWrapperDestruction) {
+    const Url call_url{server->GetBaseUrl() + "/hello.html"};
+    synchro_env->Reset();
+    std::unique_lock setup_lock{synchro_env->test_cv_mutex};
+    const std::function observer_fn{[](cpr_pf_arg_t, cpr_pf_arg_t, cpr_pf_arg_t, cpr_pf_arg_t, intptr_t) -> bool {
+        const std::unique_lock l{synchro_env->test_cv_mutex};
+        synchro_env->counter++;
+        synchro_env->test_cv.notify_all();
+        return true;
+    }};
+
+    // We construct a Request that will not terminate, wait until it is being processed by a thread, and destruct the AsyncResponseC
+    {
+        AsyncResponseC resp{std::move(MultiGetAsync(std::tuple{call_url, ProgressCallback{observer_fn}}).at(0))};
+        synchro_env->test_cv.wait(setup_lock);
+        const size_t init_calls{synchro_env->counter};
+        EXPECT_LT(0, init_calls);
+    }
+
+    const size_t calls{synchro_env->counter};
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    const size_t post_calls{synchro_env->counter};
+    EXPECT_EQ(calls, post_calls);
+}
+
+/**
+ * This test checks if the interval of calls to the progress function is
+ * acceptable during a low-speed transaction. The server's low_speed_bytes
+ * uri sends 1 Byte/second, and we aim to evaluate that 15 calls to the
+ * progress function happen within 5 seconds. This would indicate that
+ * the user can realistically expect to have their request cancelled within
+ * ~1s on a bad case (low network speed).
+ * INFO this test is not, strictly speaking, deterministic. It depends at the
+ * least on scheduler behaviour. We have tried, however, to set a boundary that
+ * is permissive enough to ensure consistency.
+ */
+
+TEST(MultiAsyncCancelTests, TestIntervalOfProgressCallsLowSpeed) {
+    const Url call_url{server->GetBaseUrl() + "/low_speed_bytes.html"};
+
+    synchro_env->Reset();
+    size_t N{15};
+    // This variable will be used to cancel the transaction at the point of the Nth call.
+    const std::chrono::time_point start{std::chrono::steady_clock::now()};
+
+    const std::function observer_fn{[N](cpr_pf_arg_t, cpr_pf_arg_t, cpr_pf_arg_t, cpr_pf_arg_t, intptr_t) -> bool {
+        const size_t current_iteration{++(synchro_env->counter)};
+        return current_iteration <= N;
+    }};
+    const ProgressCallback pcall{observer_fn};
+
+    std::vector<AsyncResponseC> resp{MultiGetAsync(std::tuple{call_url, pcall})};
+    resp.at(0).wait();
+
+    const std::chrono::duration elapsed_time{std::chrono::steady_clock::now() - start};
+    EXPECT_GT(std::chrono::seconds(N), elapsed_time);
+    std::this_thread::sleep_for(std::chrono::milliseconds{101});
+}
+
+int main(int argc, char** argv) {
+    ::testing::InitGoogleTest(&argc, argv);
+    ::testing::AddGlobalTestEnvironment(server);
+    ::testing::AddGlobalTestEnvironment(synchro_env);
+    return RUN_ALL_TESTS();
+}