diff options
Diffstat (limited to 'thirdparty/cpr/test/multiasync_tests.cpp')
| -rw-r--r-- | thirdparty/cpr/test/multiasync_tests.cpp | 437 |
1 files changed, 0 insertions, 437 deletions
diff --git a/thirdparty/cpr/test/multiasync_tests.cpp b/thirdparty/cpr/test/multiasync_tests.cpp deleted file mode 100644 index 1e39f73f4..000000000 --- a/thirdparty/cpr/test/multiasync_tests.cpp +++ /dev/null @@ -1,437 +0,0 @@ -#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(); -} |