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, 369 insertions, 0 deletions

diff --git a/thirdparty/cpr/test/interceptor_tests.cpp b/thirdparty/cpr/test/interceptor_tests.cpp
new file mode 100644
index 000000000..8bdc06b25
--- /dev/null
+++ b/thirdparty/cpr/test/interceptor_tests.cpp
@@ -0,0 +1,369 @@
+#include <gtest/gtest.h>
+#include <iostream>
+
+#include "cpr/cpr.h"
+#include "httpServer.hpp"
+
+using namespace cpr;
+
+static HttpServer* server = new HttpServer();
+
+class HiddenHelloWorldRedirectInterceptor : public Interceptor {
+  public:
+    Response intercept(Session& session) override {
+        // Save original url
+        Url old_url = session.GetFullRequestUrl();
+
+        // Rewrite the url
+        Url url{server->GetBaseUrl() + "/hello.html"};
+        session.SetUrl(url);
+
+        // Proceed the chain
+        Response response = proceed(session);
+
+        // Restore the url again
+        response.url = old_url;
+        return response;
+    }
+};
+
+class ChangeStatusCodeInterceptor : public Interceptor {
+  public:
+    Response intercept(Session& session) override {
+        // Proceed the chain
+        Response response = proceed(session);
+
+        // Change the status code
+        response.status_code = 12345;
+        return response;
+    }
+};
+
+class SetBasicAuthInterceptor : public Interceptor {
+  public:
+    Response intercept(Session& session) override {
+        // Set authentication
+        session.SetAuth(Authentication{"user", "password", AuthMode::BASIC});
+
+        // Proceed the chain
+        return proceed(session);
+    }
+};
+
+class SetUnsupportedProtocolErrorInterceptor : public Interceptor {
+  public:
+    Response intercept(Session& session) override {
+        // Proceed the chain
+        Response response = proceed(session);
+
+        // Set unsupported protocol error
+        response.error = Error{CURLE_UNSUPPORTED_PROTOCOL, "SetErrorInterceptor"};
+
+        // Return response
+        return response;
+    }
+};
+
+class ChangeRequestMethodToGetInterceptor : public Interceptor {
+  public:
+    Response intercept(Session& session) override {
+        return proceed(session, Interceptor::ProceedHttpMethod::GET_REQUEST);
+    }
+};
+
+class ChangeRequestMethodToPostInterceptor : public Interceptor {
+  public:
+    Response intercept(Session& session) override {
+        session.SetOption(Payload{{"x", "5"}});
+        return proceed(session, Interceptor::ProceedHttpMethod::POST_REQUEST);
+    }
+};
+
+class ChangeRequestMethodToPutInterceptor : public Interceptor {
+  public:
+    Response intercept(Session& session) override {
+        session.SetOption(Payload{{"x", "5"}});
+        return proceed(session, Interceptor::ProceedHttpMethod::PUT_REQUEST);
+    }
+};
+
+class ChangeRequestMethodToDeleteInterceptor : public Interceptor {
+  public:
+    Response intercept(Session& session) override {
+        return proceed(session, Interceptor::ProceedHttpMethod::DELETE_REQUEST);
+    }
+};
+
+bool write_data(std::string /*data*/, intptr_t /*userdata*/) {
+    return true;
+}
+
+class ChangeRequestMethodToDownloadCallbackInterceptor : public Interceptor {
+  public:
+    Response intercept(Session& session) override {
+        return proceed(session, Interceptor::ProceedHttpMethod::DOWNLOAD_CALLBACK_REQUEST, WriteCallback{write_data, 0});
+    }
+};
+
+class ChangeRequestMethodToHeadInterceptor : public Interceptor {
+  public:
+    Response intercept(Session& session) override {
+        return proceed(session, Interceptor::ProceedHttpMethod::HEAD_REQUEST);
+    }
+};
+
+class ChangeRequestMethodToOptionsInterceptor : public Interceptor {
+  public:
+    Response intercept(Session& session) override {
+        return proceed(session, Interceptor::ProceedHttpMethod::OPTIONS_REQUEST);
+    }
+};
+
+class ChangeRequestMethodToPatchInterceptor : public Interceptor {
+  public:
+    Response intercept(Session& session) override {
+        session.SetOption(Payload{{"x", "5"}});
+        return proceed(session, Interceptor::ProceedHttpMethod::PATCH_REQUEST);
+    }
+};
+
+TEST(InterceptorTest, HiddenUrlRewriteInterceptorTest) {
+    Url url{server->GetBaseUrl() + "/basic.json"};
+    Session session;
+    session.SetUrl(url);
+    session.AddInterceptor(std::make_shared<HiddenHelloWorldRedirectInterceptor>());
+    Response response = session.Get();
+
+    std::string expected_text{"Hello world!"};
+    EXPECT_EQ(expected_text, response.text);
+    EXPECT_EQ(url, response.url);
+    EXPECT_EQ(ErrorCode::OK, response.error.code);
+}
+
+TEST(InterceptorTest, ChangeStatusCodeInterceptorTest) {
+    Url url{server->GetBaseUrl() + "/hello.html"};
+    Session session;
+    session.SetUrl(url);
+    session.AddInterceptor(std::make_shared<ChangeStatusCodeInterceptor>());
+    Response response = session.Get();
+
+    long expected_status_code{12345};
+    EXPECT_EQ(url, response.url);
+    EXPECT_EQ(expected_status_code, response.status_code);
+    EXPECT_EQ(ErrorCode::OK, response.error.code);
+}
+
+TEST(InterceptorTest, DownloadChangeStatusCodeInterceptorTest) {
+    cpr::Url url{server->GetBaseUrl() + "/download_gzip.html"};
+    cpr::Session session;
+    session.SetHeader(cpr::Header{{"Accept-Encoding", "gzip"}});
+    session.SetUrl(url);
+    session.AddInterceptor(std::make_shared<ChangeStatusCodeInterceptor>());
+    Response response = session.Download(cpr::WriteCallback{write_data, 0});
+
+    long expected_status_code{12345};
+    EXPECT_EQ(url, response.url);
+    EXPECT_EQ(expected_status_code, response.status_code);
+    EXPECT_EQ(cpr::ErrorCode::OK, response.error.code);
+}
+
+TEST(InterceptorTest, SetBasicAuthInterceptorTest) {
+    Url url{server->GetBaseUrl() + "/basic_auth.html"};
+    Session session;
+    session.SetUrl(url);
+    session.AddInterceptor(std::make_shared<SetBasicAuthInterceptor>());
+
+    Response response = session.Get();
+    std::string expected_text{"Header reflect GET"};
+    EXPECT_EQ(expected_text, response.text);
+    EXPECT_EQ(url, response.url);
+    EXPECT_EQ(std::string{"text/html"}, response.header["content-type"]);
+    EXPECT_EQ(200, response.status_code);
+    EXPECT_EQ(ErrorCode::OK, response.error.code);
+}
+
+TEST(InterceptorTest, SetUnsupportedProtocolErrorInterceptorTest) {
+    Url url{server->GetBaseUrl() + "/hello.html"};
+    Session session;
+    session.SetUrl(url);
+    session.AddInterceptor(std::make_shared<SetUnsupportedProtocolErrorInterceptor>());
+
+    Response response = session.Get();
+    std::string expected_error_message{"SetErrorInterceptor"};
+    ErrorCode expected_error_code{ErrorCode::UNSUPPORTED_PROTOCOL};
+    EXPECT_EQ(url, response.url);
+    EXPECT_EQ(std::string{"text/html"}, response.header["content-type"]);
+    EXPECT_EQ(200, response.status_code);
+    EXPECT_EQ(expected_error_message, response.error.message);
+    EXPECT_EQ(expected_error_code, response.error.code);
+}
+
+TEST(InterceptorTest, ChangeRequestMethodToGetInterceptorTest) {
+    Url url{server->GetBaseUrl() + "/hello.html"};
+    Session session;
+    session.SetUrl(url);
+    session.AddInterceptor(std::make_shared<ChangeRequestMethodToGetInterceptor>());
+    Response response = session.Head();
+
+    std::string expected_text{"Hello world!"};
+    EXPECT_EQ(expected_text, response.text);
+    EXPECT_EQ(url, response.url);
+    EXPECT_EQ(std::string{"text/html"}, response.header["content-type"]);
+    EXPECT_EQ(200, response.status_code);
+    EXPECT_EQ(ErrorCode::OK, response.error.code);
+}
+
+TEST(InterceptorTest, ChangeRequestMethodToPostInterceptorTest) {
+    Url url{server->GetBaseUrl() + "/url_post.html"};
+    Session session;
+    session.SetUrl(url);
+    session.AddInterceptor(std::make_shared<ChangeRequestMethodToPostInterceptor>());
+    Response response = session.Head();
+
+    std::string expected_text{
+            "{\n"
+            "  \"x\": 5\n"
+            "}"};
+    EXPECT_EQ(expected_text, response.text);
+    EXPECT_EQ(url, response.url);
+    EXPECT_EQ(std::string{"application/json"}, response.header["content-type"]);
+    EXPECT_EQ(201, response.status_code);
+    EXPECT_EQ(ErrorCode::OK, response.error.code);
+}
+
+TEST(InterceptorTest, ChangeRequestMethodToPutInterceptorTest) {
+    Url url{server->GetBaseUrl() + "/put.html"};
+    Session session;
+    session.SetUrl(url);
+    session.AddInterceptor(std::make_shared<ChangeRequestMethodToPutInterceptor>());
+    Response response = session.Get();
+
+    std::string expected_text{
+            "{\n"
+            "  \"x\": 5\n"
+            "}"};
+    EXPECT_EQ(expected_text, response.text);
+    EXPECT_EQ(url, response.url);
+    EXPECT_EQ(std::string{"application/json"}, response.header["content-type"]);
+    EXPECT_EQ(200, response.status_code);
+    EXPECT_EQ(ErrorCode::OK, response.error.code);
+}
+
+TEST(InterceptorTest, ChangeRequestMethodToPatchInterceptorTest) {
+    Url url{server->GetBaseUrl() + "/patch.html"};
+    Session session;
+    session.SetUrl(url);
+    session.AddInterceptor(std::make_shared<ChangeRequestMethodToPatchInterceptor>());
+    Response response = session.Get();
+
+    std::string expected_text{
+            "{\n"
+            "  \"x\": 5\n"
+            "}"};
+    EXPECT_EQ(expected_text, response.text);
+    EXPECT_EQ(url, response.url);
+    EXPECT_EQ(std::string{"application/json"}, response.header["content-type"]);
+    EXPECT_EQ(200, response.status_code);
+    EXPECT_EQ(ErrorCode::OK, response.error.code);
+}
+
+TEST(InterceptorTest, ChangeRequestMethodToOptionsInterceptorTest) {
+    Url url{server->GetBaseUrl() + "/"};
+    Session session;
+    session.SetUrl(url);
+    session.AddInterceptor(std::make_shared<ChangeRequestMethodToOptionsInterceptor>());
+    Response response = session.Get();
+
+    std::string expected_text{""};
+    EXPECT_EQ(expected_text, response.text);
+    EXPECT_EQ(url, response.url);
+    EXPECT_EQ(std::string{"GET, POST, PUT, DELETE, PATCH, OPTIONS"}, response.header["Access-Control-Allow-Methods"]);
+    EXPECT_EQ(200, response.status_code);
+    EXPECT_EQ(ErrorCode::OK, response.error.code);
+}
+
+TEST(InterceptorTest, ChangeRequestMethodToHeadInterceptorTest) {
+    Url url{server->GetBaseUrl() + "/hello.html"};
+    Session session;
+    session.SetUrl(url);
+    session.AddInterceptor(std::make_shared<ChangeRequestMethodToHeadInterceptor>());
+    Response response = session.Get();
+
+    EXPECT_EQ(std::string{}, response.text);
+    EXPECT_EQ(url, response.url);
+    EXPECT_EQ(std::string{"text/html"}, response.header["content-type"]);
+    EXPECT_EQ(200, response.status_code);
+    EXPECT_EQ(ErrorCode::OK, response.error.code);
+}
+
+TEST(InterceptorTest, ChangeRequestMethodToDownloadCallbackInterceptorTest) {
+    Url url{server->GetBaseUrl() + "/download_gzip.html"};
+    Session session;
+    session.SetUrl(url);
+    session.SetHeader(cpr::Header{{"Accept-Encoding", "gzip"}});
+    session.SetTimeout(Timeout{2000});
+    session.AddInterceptor(std::make_shared<ChangeRequestMethodToDownloadCallbackInterceptor>());
+    Response response = session.Put();
+
+    EXPECT_EQ(url, response.url);
+    EXPECT_EQ(200, response.status_code);
+    EXPECT_EQ(cpr::ErrorCode::OK, response.error.code);
+}
+
+TEST(InterceptorTest, ChangeRequestMethodToDeleteInterceptorTest) {
+    Url url{server->GetBaseUrl() + "/delete.html"};
+    Session session;
+    session.SetUrl(url);
+    session.AddInterceptor(std::make_shared<ChangeRequestMethodToDeleteInterceptor>());
+    Response response = session.Get();
+
+
+    std::string expected_text{"Delete success"};
+    EXPECT_EQ(expected_text, response.text);
+    EXPECT_EQ(url, response.url);
+    EXPECT_EQ(std::string{"text/html"}, response.header["content-type"]);
+    EXPECT_EQ(200, response.status_code);
+    EXPECT_EQ(ErrorCode::OK, response.error.code);
+}
+
+TEST(InterceptorTest, TwoInterceptorsTest) {
+    Url url{server->GetBaseUrl() + "/basic.json"};
+    Session session;
+    session.SetUrl(url);
+    session.AddInterceptor(std::make_shared<HiddenHelloWorldRedirectInterceptor>());
+    session.AddInterceptor(std::make_shared<ChangeStatusCodeInterceptor>());
+    Response response = session.Get();
+
+    std::string expected_text{"Hello world!"};
+    long expected_status_code{12345};
+    EXPECT_EQ(expected_text, response.text);
+    EXPECT_EQ(url, response.url);
+    EXPECT_EQ(expected_status_code, response.status_code);
+    EXPECT_EQ(ErrorCode::OK, response.error.code);
+}
+
+TEST(InterceptorTest, ThreeInterceptorsTest) {
+    Url url{server->GetBaseUrl() + "/basic.json"};
+    Session session;
+    session.SetUrl(url);
+    session.AddInterceptor(std::make_shared<HiddenHelloWorldRedirectInterceptor>());
+    session.AddInterceptor(std::make_shared<ChangeStatusCodeInterceptor>());
+    session.AddInterceptor(std::make_shared<SetUnsupportedProtocolErrorInterceptor>());
+    Response response = session.Get();
+
+    std::string expected_text{"Hello world!"};
+    long expected_status_code{12345};
+    std::string expected_error_message{"SetErrorInterceptor"};
+    ErrorCode expected_error_code{ErrorCode::UNSUPPORTED_PROTOCOL};
+    EXPECT_EQ(expected_text, response.text);
+    EXPECT_EQ(url, response.url);
+    EXPECT_EQ(expected_status_code, response.status_code);
+    EXPECT_EQ(expected_error_message, response.error.message);
+    EXPECT_EQ(expected_error_code, response.error.code);
+}
+
+int main(int argc, char** argv) {
+    ::testing::InitGoogleTest(&argc, argv);
+    ::testing::AddGlobalTestEnvironment(server);
+    return RUN_ALL_TESTS();
+}
\ No newline at end of file