diff options
Diffstat (limited to 'deps/cpp-httplib/test/test.cc')
| -rw-r--r-- | deps/cpp-httplib/test/test.cc | 4237 |
1 files changed, 4237 insertions, 0 deletions
diff --git a/deps/cpp-httplib/test/test.cc b/deps/cpp-httplib/test/test.cc new file mode 100644 index 0000000..df06444 --- /dev/null +++ b/deps/cpp-httplib/test/test.cc @@ -0,0 +1,4237 @@ +#include <httplib.h> + +#include <gtest/gtest.h> + +#include <atomic> +#include <chrono> +#include <future> +#include <stdexcept> +#include <thread> + +#define SERVER_CERT_FILE "./cert.pem" +#define SERVER_CERT2_FILE "./cert2.pem" +#define SERVER_PRIVATE_KEY_FILE "./key.pem" +#define CA_CERT_FILE "./ca-bundle.crt" +#define CLIENT_CA_CERT_FILE "./rootCA.cert.pem" +#define CLIENT_CA_CERT_DIR "." +#define CLIENT_CERT_FILE "./client.cert.pem" +#define CLIENT_PRIVATE_KEY_FILE "./client.key.pem" + +using namespace std; +using namespace httplib; + +const char *HOST = "localhost"; +const int PORT = 1234; + +const string LONG_QUERY_VALUE = string(25000, '@'); +const string LONG_QUERY_URL = "/long-query-value?key=" + LONG_QUERY_VALUE; + +const std::string JSON_DATA = "{\"hello\":\"world\"}"; + +const string LARGE_DATA = string(1024 * 1024 * 100, '@'); // 100MB + +MultipartFormData &get_file_value(MultipartFormDataItems &files, + const char *key) { + auto it = std::find_if( + files.begin(), files.end(), + [&](const MultipartFormData &file) { return file.name == key; }); + if (it != files.end()) { return *it; } + throw std::runtime_error("invalid mulitpart form data name error"); +} + +#ifdef _WIN32 +TEST(StartupTest, WSAStartup) { + WSADATA wsaData; + int ret = WSAStartup(0x0002, &wsaData); + ASSERT_EQ(0, ret); +} +#endif + +TEST(EncodeQueryParamTest, ParseUnescapedChararactersTest) { + string unescapedCharacters = "-_.!~*'()"; + + EXPECT_EQ(detail::encode_query_param(unescapedCharacters), "-_.!~*'()"); +} + +TEST(EncodeQueryParamTest, ParseReservedCharactersTest) { + string reservedCharacters = ";,/?:@&=+$"; + + EXPECT_EQ(detail::encode_query_param(reservedCharacters), + "%3B%2C%2F%3F%3A%40%26%3D%2B%24"); +} + +TEST(EncodeQueryParamTest, TestUTF8Characters) { + string chineseCharacters = "中国語"; + string russianCharacters = "дом"; + string brazilianCharacters = "óculos"; + + EXPECT_EQ(detail::encode_query_param(chineseCharacters), + "%E4%B8%AD%E5%9B%BD%E8%AA%9E"); + + EXPECT_EQ(detail::encode_query_param(russianCharacters), + "%D0%B4%D0%BE%D0%BC"); + + EXPECT_EQ(detail::encode_query_param(brazilianCharacters), "%C3%B3culos"); +} + +TEST(TrimTests, TrimStringTests) { + EXPECT_EQ("abc", detail::trim_copy("abc")); + EXPECT_EQ("abc", detail::trim_copy(" abc ")); + EXPECT_TRUE(detail::trim_copy("").empty()); +} + +TEST(SplitTest, ParseQueryString) { + string s = "key1=val1&key2=val2&key3=val3"; + Params dic; + + detail::split(s.c_str(), s.c_str() + s.size(), '&', + [&](const char *b, const char *e) { + string key, val; + detail::split(b, e, '=', [&](const char *b, const char *e) { + if (key.empty()) { + key.assign(b, e); + } else { + val.assign(b, e); + } + }); + dic.emplace(key, val); + }); + + EXPECT_EQ("val1", dic.find("key1")->second); + EXPECT_EQ("val2", dic.find("key2")->second); + EXPECT_EQ("val3", dic.find("key3")->second); +} + +TEST(SplitTest, ParseInvalidQueryTests) { + + { + string s = " "; + Params dict; + detail::parse_query_text(s, dict); + EXPECT_TRUE(dict.empty()); + } + + { + string s = " = ="; + Params dict; + detail::parse_query_text(s, dict); + EXPECT_TRUE(dict.empty()); + } +} + +TEST(ParseQueryTest, ParseQueryString) { + string s = "key1=val1&key2=val2&key3=val3"; + Params dic; + + detail::parse_query_text(s, dic); + + EXPECT_EQ("val1", dic.find("key1")->second); + EXPECT_EQ("val2", dic.find("key2")->second); + EXPECT_EQ("val3", dic.find("key3")->second); +} + +TEST(ParamsToQueryTest, ConvertParamsToQuery) { + Params dic; + + EXPECT_EQ(detail::params_to_query_str(dic), ""); + + dic.emplace("key1", "val1"); + + EXPECT_EQ(detail::params_to_query_str(dic), "key1=val1"); + + dic.emplace("key2", "val2"); + dic.emplace("key3", "val3"); + + EXPECT_EQ(detail::params_to_query_str(dic), "key1=val1&key2=val2&key3=val3"); +} + +TEST(GetHeaderValueTest, DefaultValue) { + Headers headers = {{"Dummy", "Dummy"}}; + auto val = detail::get_header_value(headers, "Content-Type", 0, "text/plain"); + EXPECT_STREQ("text/plain", val); +} + +TEST(GetHeaderValueTest, DefaultValueInt) { + Headers headers = {{"Dummy", "Dummy"}}; + auto val = + detail::get_header_value<uint64_t>(headers, "Content-Length", 0, 100); + EXPECT_EQ(100ull, val); +} + +TEST(GetHeaderValueTest, RegularValue) { + Headers headers = {{"Content-Type", "text/html"}, {"Dummy", "Dummy"}}; + auto val = detail::get_header_value(headers, "Content-Type", 0, "text/plain"); + EXPECT_STREQ("text/html", val); +} + +TEST(GetHeaderValueTest, SetContent) { + Response res; + + res.set_content("html", "text/html"); + EXPECT_EQ("text/html", res.get_header_value("Content-Type")); + + res.set_content("text", "text/plain"); + EXPECT_EQ(1, res.get_header_value_count("Content-Type")); + EXPECT_EQ("text/plain", res.get_header_value("Content-Type")); +} + +TEST(GetHeaderValueTest, RegularValueInt) { + Headers headers = {{"Content-Length", "100"}, {"Dummy", "Dummy"}}; + auto val = + detail::get_header_value<uint64_t>(headers, "Content-Length", 0, 0); + EXPECT_EQ(100ull, val); +} + +TEST(GetHeaderValueTest, Range) { + { + Headers headers = {make_range_header({{1, -1}})}; + auto val = detail::get_header_value(headers, "Range", 0, 0); + EXPECT_STREQ("bytes=1-", val); + } + + { + Headers headers = {make_range_header({{-1, 1}})}; + auto val = detail::get_header_value(headers, "Range", 0, 0); + EXPECT_STREQ("bytes=-1", val); + } + + { + Headers headers = {make_range_header({{1, 10}})}; + auto val = detail::get_header_value(headers, "Range", 0, 0); + EXPECT_STREQ("bytes=1-10", val); + } + + { + Headers headers = {make_range_header({{1, 10}, {100, -1}})}; + auto val = detail::get_header_value(headers, "Range", 0, 0); + EXPECT_STREQ("bytes=1-10, 100-", val); + } + + { + Headers headers = {make_range_header({{1, 10}, {100, 200}})}; + auto val = detail::get_header_value(headers, "Range", 0, 0); + EXPECT_STREQ("bytes=1-10, 100-200", val); + } + + { + Headers headers = {make_range_header({{0, 0}, {-1, 1}})}; + auto val = detail::get_header_value(headers, "Range", 0, 0); + EXPECT_STREQ("bytes=0-0, -1", val); + } +} + +TEST(ParseHeaderValueTest, Range) { + { + Ranges ranges; + auto ret = detail::parse_range_header("bytes=1-", ranges); + EXPECT_TRUE(ret); + EXPECT_EQ(1u, ranges.size()); + EXPECT_EQ(1u, ranges[0].first); + EXPECT_EQ(-1, ranges[0].second); + } + + { + Ranges ranges; + auto ret = detail::parse_range_header("bytes=-1", ranges); + EXPECT_TRUE(ret); + EXPECT_EQ(1u, ranges.size()); + EXPECT_EQ(-1, ranges[0].first); + EXPECT_EQ(1u, ranges[0].second); + } + + { + Ranges ranges; + auto ret = detail::parse_range_header("bytes=1-10", ranges); + EXPECT_TRUE(ret); + EXPECT_EQ(1u, ranges.size()); + EXPECT_EQ(1u, ranges[0].first); + EXPECT_EQ(10u, ranges[0].second); + } + + { + Ranges ranges; + auto ret = detail::parse_range_header("bytes=10-1", ranges); + EXPECT_FALSE(ret); + } + + { + Ranges ranges; + auto ret = detail::parse_range_header("bytes=1-10, 100-", ranges); + EXPECT_TRUE(ret); + EXPECT_EQ(2u, ranges.size()); + EXPECT_EQ(1u, ranges[0].first); + EXPECT_EQ(10u, ranges[0].second); + EXPECT_EQ(100u, ranges[1].first); + EXPECT_EQ(-1, ranges[1].second); + } + + { + Ranges ranges; + auto ret = + detail::parse_range_header("bytes=1-10, 100-200, 300-400", ranges); + EXPECT_TRUE(ret); + EXPECT_EQ(3u, ranges.size()); + EXPECT_EQ(1u, ranges[0].first); + EXPECT_EQ(10u, ranges[0].second); + EXPECT_EQ(100u, ranges[1].first); + EXPECT_EQ(200u, ranges[1].second); + EXPECT_EQ(300u, ranges[2].first); + EXPECT_EQ(400u, ranges[2].second); + } +} + +TEST(ParseAcceptEncoding1, AcceptEncoding) { + Request req; + req.set_header("Accept-Encoding", "gzip"); + + Response res; + res.set_header("Content-Type", "text/plain"); + + auto ret = detail::encoding_type(req, res); + +#ifdef CPPHTTPLIB_ZLIB_SUPPORT + EXPECT_TRUE(ret == detail::EncodingType::Gzip); +#else + EXPECT_TRUE(ret == detail::EncodingType::None); +#endif +} + +TEST(ParseAcceptEncoding2, AcceptEncoding) { + Request req; + req.set_header("Accept-Encoding", "gzip, deflate, br"); + + Response res; + res.set_header("Content-Type", "text/plain"); + + auto ret = detail::encoding_type(req, res); + +#ifdef CPPHTTPLIB_BROTLI_SUPPORT + EXPECT_TRUE(ret == detail::EncodingType::Brotli); +#elif CPPHTTPLIB_ZLIB_SUPPORT + EXPECT_TRUE(ret == detail::EncodingType::Gzip); +#else + EXPECT_TRUE(ret == detail::EncodingType::None); +#endif +} + +TEST(ParseAcceptEncoding3, AcceptEncoding) { + Request req; + req.set_header("Accept-Encoding", "br;q=1.0, gzip;q=0.8, *;q=0.1"); + + Response res; + res.set_header("Content-Type", "text/plain"); + + auto ret = detail::encoding_type(req, res); + +#ifdef CPPHTTPLIB_BROTLI_SUPPORT + EXPECT_TRUE(ret == detail::EncodingType::Brotli); +#elif CPPHTTPLIB_ZLIB_SUPPORT + EXPECT_TRUE(ret == detail::EncodingType::Gzip); +#else + EXPECT_TRUE(ret == detail::EncodingType::None); +#endif +} + +TEST(BufferStreamTest, read) { + detail::BufferStream strm1; + Stream &strm = strm1; + + EXPECT_EQ(5, strm.write("hello")); + + char buf[512]; + EXPECT_EQ(2, strm.read(buf, 2)); + EXPECT_EQ('h', buf[0]); + EXPECT_EQ('e', buf[1]); + + EXPECT_EQ(2, strm.read(buf, 2)); + EXPECT_EQ('l', buf[0]); + EXPECT_EQ('l', buf[1]); + + EXPECT_EQ(1, strm.read(buf, 1)); + EXPECT_EQ('o', buf[0]); + + EXPECT_EQ(0, strm.read(buf, 1)); +} + +TEST(ChunkedEncodingTest, FromHTTPWatch) { + auto host = "www.httpwatch.com"; + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + auto port = 443; + SSLClient cli(host, port); +#else + auto port = 80; + Client cli(host, port); +#endif + cli.set_connection_timeout(2); + + auto res = + cli.Get("/httpgallery/chunked/chunkedimage.aspx?0.4153841143030137"); + ASSERT_TRUE(res); + + std::string out; + detail::read_file("./image.jpg", out); + + EXPECT_EQ(200, res->status); + EXPECT_EQ(out, res->body); +} + +TEST(ChunkedEncodingTest, WithContentReceiver) { + auto host = "www.httpwatch.com"; + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + auto port = 443; + SSLClient cli(host, port); +#else + auto port = 80; + Client cli(host, port); +#endif + cli.set_connection_timeout(2); + + std::string body; + auto res = + cli.Get("/httpgallery/chunked/chunkedimage.aspx?0.4153841143030137", + [&](const char *data, size_t data_length) { + body.append(data, data_length); + return true; + }); + ASSERT_TRUE(res); + + std::string out; + detail::read_file("./image.jpg", out); + + EXPECT_EQ(200, res->status); + EXPECT_EQ(out, body); +} + +TEST(ChunkedEncodingTest, WithResponseHandlerAndContentReceiver) { + auto host = "www.httpwatch.com"; + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + auto port = 443; + SSLClient cli(host, port); +#else + auto port = 80; + Client cli(host, port); +#endif + cli.set_connection_timeout(2); + + std::string body; + auto res = cli.Get( + "/httpgallery/chunked/chunkedimage.aspx?0.4153841143030137", + [&](const Response &response) { + EXPECT_EQ(200, response.status); + return true; + }, + [&](const char *data, size_t data_length) { + body.append(data, data_length); + return true; + }); + ASSERT_TRUE(res); + + std::string out; + detail::read_file("./image.jpg", out); + + EXPECT_EQ(200, res->status); + EXPECT_EQ(out, body); +} + +TEST(DefaultHeadersTest, FromHTTPBin) { + Client cli("httpbin.org"); + cli.set_default_headers({make_range_header({{1, 10}})}); + cli.set_connection_timeout(5); + + { + auto res = cli.Get("/range/32"); + ASSERT_TRUE(res); + EXPECT_EQ("bcdefghijk", res->body); + EXPECT_EQ(206, res->status); + } + + { + auto res = cli.Get("/range/32"); + ASSERT_TRUE(res); + EXPECT_EQ("bcdefghijk", res->body); + EXPECT_EQ(206, res->status); + } +} + +TEST(RangeTest, FromHTTPBin) { + auto host = "httpbin.org"; + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + auto port = 443; + SSLClient cli(host, port); +#else + auto port = 80; + Client cli(host, port); +#endif + cli.set_connection_timeout(5); + + { + auto res = cli.Get("/range/32"); + ASSERT_TRUE(res); + EXPECT_EQ("abcdefghijklmnopqrstuvwxyzabcdef", res->body); + EXPECT_EQ(200, res->status); + } + + { + Headers headers = {make_range_header({{1, -1}})}; + auto res = cli.Get("/range/32", headers); + ASSERT_TRUE(res); + EXPECT_EQ("bcdefghijklmnopqrstuvwxyzabcdef", res->body); + EXPECT_EQ(206, res->status); + } + + { + Headers headers = {make_range_header({{1, 10}})}; + auto res = cli.Get("/range/32", headers); + ASSERT_TRUE(res); + EXPECT_EQ("bcdefghijk", res->body); + EXPECT_EQ(206, res->status); + } + + { + Headers headers = {make_range_header({{0, 31}})}; + auto res = cli.Get("/range/32", headers); + ASSERT_TRUE(res); + EXPECT_EQ("abcdefghijklmnopqrstuvwxyzabcdef", res->body); + EXPECT_EQ(200, res->status); + } + + { + Headers headers = {make_range_header({{0, -1}})}; + auto res = cli.Get("/range/32", headers); + ASSERT_TRUE(res); + EXPECT_EQ("abcdefghijklmnopqrstuvwxyzabcdef", res->body); + EXPECT_EQ(200, res->status); + } + + { + Headers headers = {make_range_header({{0, 32}})}; + auto res = cli.Get("/range/32", headers); + ASSERT_TRUE(res); + EXPECT_EQ(416, res->status); + } +} + +TEST(ConnectionErrorTest, InvalidHost) { + auto host = "-abcde.com"; + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + auto port = 443; + SSLClient cli(host, port); +#else + auto port = 80; + Client cli(host, port); +#endif + cli.set_connection_timeout(std::chrono::seconds(2)); + + auto res = cli.Get("/"); + ASSERT_TRUE(!res); + EXPECT_EQ(Error::Connection, res.error()); +} + +TEST(ConnectionErrorTest, InvalidHost2) { + auto host = "httpbin.org/"; + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + SSLClient cli(host); +#else + Client cli(host); +#endif + cli.set_connection_timeout(std::chrono::seconds(2)); + + auto res = cli.Get("/"); + ASSERT_TRUE(!res); + EXPECT_EQ(Error::Connection, res.error()); +} + +TEST(ConnectionErrorTest, InvalidPort) { + auto host = "localhost"; + auto port = 44380; + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + SSLClient cli(host, port); +#else + Client cli(host, port); +#endif + cli.set_connection_timeout(std::chrono::seconds(2)); + + auto res = cli.Get("/"); + ASSERT_TRUE(!res); + EXPECT_EQ(Error::Connection, res.error()); +} + +TEST(ConnectionErrorTest, Timeout) { + auto host = "google.com"; + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + auto port = 44380; + SSLClient cli(host, port); +#else + auto port = 8080; + Client cli(host, port); +#endif + cli.set_connection_timeout(std::chrono::seconds(2)); + + auto res = cli.Get("/"); + ASSERT_TRUE(!res); + EXPECT_TRUE(res.error() == Error::Connection); +} + +TEST(CancelTest, NoCancel) { + auto host = "httpbin.org"; + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + auto port = 443; + SSLClient cli(host, port); +#else + auto port = 80; + Client cli(host, port); +#endif + cli.set_connection_timeout(std::chrono::seconds(5)); + + auto res = cli.Get("/range/32", [](uint64_t, uint64_t) { return true; }); + ASSERT_TRUE(res); + EXPECT_EQ("abcdefghijklmnopqrstuvwxyzabcdef", res->body); + EXPECT_EQ(200, res->status); +} + +TEST(CancelTest, WithCancelSmallPayload) { + auto host = "httpbin.org"; + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + auto port = 443; + SSLClient cli(host, port); +#else + auto port = 80; + Client cli(host, port); +#endif + + auto res = cli.Get("/range/32", [](uint64_t, uint64_t) { return false; }); + cli.set_connection_timeout(std::chrono::seconds(5)); + ASSERT_TRUE(!res); + EXPECT_EQ(Error::Canceled, res.error()); +} + +TEST(CancelTest, WithCancelLargePayload) { + auto host = "httpbin.org"; + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + auto port = 443; + SSLClient cli(host, port); +#else + auto port = 80; + Client cli(host, port); +#endif + cli.set_connection_timeout(std::chrono::seconds(5)); + + uint32_t count = 0; + auto res = cli.Get("/range/65536", + [&count](uint64_t, uint64_t) { return (count++ == 0); }); + ASSERT_TRUE(!res); + EXPECT_EQ(Error::Canceled, res.error()); +} + +TEST(BaseAuthTest, FromHTTPWatch) { + auto host = "httpbin.org"; + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + auto port = 443; + SSLClient cli(host, port); +#else + auto port = 80; + Client cli(host, port); +#endif + + { + auto res = cli.Get("/basic-auth/hello/world"); + ASSERT_TRUE(res); + EXPECT_EQ(401, res->status); + } + + { + auto res = cli.Get("/basic-auth/hello/world", + {make_basic_authentication_header("hello", "world")}); + ASSERT_TRUE(res); + EXPECT_EQ("{\n \"authenticated\": true, \n \"user\": \"hello\"\n}\n", + res->body); + EXPECT_EQ(200, res->status); + } + + { + cli.set_basic_auth("hello", "world"); + auto res = cli.Get("/basic-auth/hello/world"); + ASSERT_TRUE(res); + EXPECT_EQ("{\n \"authenticated\": true, \n \"user\": \"hello\"\n}\n", + res->body); + EXPECT_EQ(200, res->status); + } + + { + cli.set_basic_auth("hello", "bad"); + auto res = cli.Get("/basic-auth/hello/world"); + ASSERT_TRUE(res); + EXPECT_EQ(401, res->status); + } + + { + cli.set_basic_auth("bad", "world"); + auto res = cli.Get("/basic-auth/hello/world"); + ASSERT_TRUE(res); + EXPECT_EQ(401, res->status); + } +} + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +TEST(DigestAuthTest, FromHTTPWatch) { + auto host = "httpbin.org"; + auto port = 443; + SSLClient cli(host, port); + + { + auto res = cli.Get("/digest-auth/auth/hello/world"); + ASSERT_TRUE(res); + EXPECT_EQ(401, res->status); + } + + { + std::vector<std::string> paths = { + "/digest-auth/auth/hello/world/MD5", + "/digest-auth/auth/hello/world/SHA-256", + "/digest-auth/auth/hello/world/SHA-512", + "/digest-auth/auth-int/hello/world/MD5", + }; + + cli.set_digest_auth("hello", "world"); + for (auto path : paths) { + auto res = cli.Get(path.c_str()); + ASSERT_TRUE(res); + EXPECT_EQ("{\n \"authenticated\": true, \n \"user\": \"hello\"\n}\n", + res->body); + EXPECT_EQ(200, res->status); + } + + cli.set_digest_auth("hello", "bad"); + for (auto path : paths) { + auto res = cli.Get(path.c_str()); + ASSERT_TRUE(res); + EXPECT_EQ(401, res->status); + } + + // NOTE: Until httpbin.org fixes issue #46, the following test is commented + // out. Plese see https://httpbin.org/digest-auth/auth/hello/world + // cli.set_digest_auth("bad", "world"); + // for (auto path : paths) { + // auto res = cli.Get(path.c_str()); + // ASSERT_TRUE(res); + // EXPECT_EQ(400, res->status); + // } + } +} +#endif + +TEST(AbsoluteRedirectTest, Redirect) { + auto host = "nghttp2.org"; + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + SSLClient cli(host); +#else + Client cli(host); +#endif + + cli.set_follow_location(true); + auto res = cli.Get("/httpbin/absolute-redirect/3"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); +} + +TEST(RedirectTest, Redirect) { + auto host = "nghttp2.org"; + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + SSLClient cli(host); +#else + Client cli(host); +#endif + + cli.set_follow_location(true); + auto res = cli.Get("/httpbin/redirect/3"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); +} + +TEST(RelativeRedirectTest, Redirect) { + auto host = "nghttp2.org"; + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + SSLClient cli(host); +#else + Client cli(host); +#endif + + cli.set_follow_location(true); + auto res = cli.Get("/httpbin/relative-redirect/3"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); +} + +TEST(TooManyRedirectTest, Redirect) { + auto host = "nghttp2.org"; + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + SSLClient cli(host); +#else + Client cli(host); +#endif + + cli.set_follow_location(true); + auto res = cli.Get("/httpbin/redirect/21"); + ASSERT_TRUE(!res); + EXPECT_EQ(Error::ExceedRedirectCount, res.error()); +} + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +TEST(YahooRedirectTest, Redirect) { + Client cli("yahoo.com"); + + auto res = cli.Get("/"); + ASSERT_TRUE(res); + EXPECT_EQ(301, res->status); + + cli.set_follow_location(true); + res = cli.Get("/"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("https://yahoo.com/", res->location); +} + +TEST(HttpsToHttpRedirectTest, Redirect) { + SSLClient cli("nghttp2.org"); + cli.set_follow_location(true); + auto res = cli.Get( + "/httpbin/redirect-to?url=http%3A%2F%2Fwww.google.com&status_code=302"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); +} + +TEST(HttpsToHttpRedirectTest2, Redirect) { + SSLClient cli("nghttp2.org"); + cli.set_follow_location(true); + + Params params; + params.emplace("url", "http://www.google.com"); + params.emplace("status_code", "302"); + + auto res = cli.Get("/httpbin/redirect-to", params, Headers{}); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); +} + +TEST(HttpsToHttpRedirectTest3, Redirect) { + SSLClient cli("nghttp2.org"); + cli.set_follow_location(true); + + Params params; + params.emplace("url", "http://www.google.com"); + + auto res = cli.Get("/httpbin/redirect-to?status_code=302", params, Headers{}); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); +} + +TEST(RedirectToDifferentPort, Redirect) { + Server svr8080; + Server svr8081; + + svr8080.Get("/1", [&](const Request & /*req*/, Response &res) { + res.set_redirect("http://localhost:8081/2"); + }); + + svr8081.Get("/2", [&](const Request & /*req*/, Response &res) { + res.set_content("Hello World!", "text/plain"); + }); + + auto thread8080 = std::thread([&]() { svr8080.listen("localhost", 8080); }); + + auto thread8081 = std::thread([&]() { svr8081.listen("localhost", 8081); }); + + while (!svr8080.is_running() || !svr8081.is_running()) { + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + } + + // Give GET time to get a few messages. + std::this_thread::sleep_for(std::chrono::seconds(1)); + + Client cli("localhost", 8080); + cli.set_follow_location(true); + + auto res = cli.Get("/1"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("Hello World!", res->body); + + svr8080.stop(); + svr8081.stop(); + thread8080.join(); + thread8081.join(); + ASSERT_FALSE(svr8080.is_running()); + ASSERT_FALSE(svr8081.is_running()); +} + +TEST(UrlWithSpace, Redirect) { + SSLClient cli("edge.forgecdn.net"); + cli.set_follow_location(true); + + auto res = cli.Get("/files/2595/310/Neat 1.4-17.jar"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ(18527, res->get_header_value<uint64_t>("Content-Length")); +} + +TEST(RedirectFromPageWithContent, Redirect) { + Server svr; + + svr.Get("/1", [&](const Request & /*req*/, Response &res) { + res.set_content("___", "text/plain"); + res.set_redirect("/2"); + }); + + svr.Get("/2", [&](const Request & /*req*/, Response &res) { + res.set_content("Hello World!", "text/plain"); + }); + + auto th = std::thread([&]() { svr.listen("localhost", PORT); }); + + while (!svr.is_running()) { + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + } + + // Give GET time to get a few messages. + std::this_thread::sleep_for(std::chrono::seconds(1)); + + { + Client cli("localhost", PORT); + cli.set_follow_location(true); + + std::string body; + auto res = cli.Get("/1", [&](const char *data, size_t data_length) { + body.append(data, data_length); + return true; + }); + + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("Hello World!", body); + } + + { + Client cli("localhost", PORT); + + std::string body; + auto res = cli.Get("/1", [&](const char *data, size_t data_length) { + body.append(data, data_length); + return true; + }); + + ASSERT_TRUE(res); + EXPECT_EQ(302, res->status); + EXPECT_EQ("___", body); + } + + svr.stop(); + th.join(); + ASSERT_FALSE(svr.is_running()); +} + +#endif + +TEST(BindServerTest, BindDualStack) { + Server svr; + + svr.Get("/1", [&](const Request & /*req*/, Response &res) { + res.set_content("Hello World!", "text/plain"); + }); + + auto thread = std::thread([&]() { svr.listen("::", PORT); }); + + // Give GET time to get a few messages. + std::this_thread::sleep_for(std::chrono::seconds(1)); + + { + Client cli("127.0.0.1", PORT); + + auto res = cli.Get("/1"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("Hello World!", res->body); + } + { + Client cli("::1", PORT); + + auto res = cli.Get("/1"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("Hello World!", res->body); + } + svr.stop(); + thread.join(); + ASSERT_FALSE(svr.is_running()); +} + +TEST(BindServerTest, BindAndListenSeparately) { + Server svr; + int port = svr.bind_to_any_port("0.0.0.0"); + ASSERT_TRUE(svr.is_valid()); + ASSERT_TRUE(port > 0); + svr.stop(); +} + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +TEST(BindServerTest, BindAndListenSeparatelySSL) { + SSLServer svr(SERVER_CERT_FILE, SERVER_PRIVATE_KEY_FILE, CLIENT_CA_CERT_FILE, + CLIENT_CA_CERT_DIR); + int port = svr.bind_to_any_port("0.0.0.0"); + ASSERT_TRUE(svr.is_valid()); + ASSERT_TRUE(port > 0); + svr.stop(); +} +#endif + +TEST(ErrorHandlerTest, ContentLength) { + Server svr; + + svr.set_error_handler([](const Request & /*req*/, Response &res) { + res.status = 200; + res.set_content("abcdefghijklmnopqrstuvwxyz", + "text/html"); // <= Content-Length still 13 + }); + + svr.Get("/hi", [](const Request & /*req*/, Response &res) { + res.set_content("Hello World!\n", "text/plain"); + res.status = 524; + }); + + auto thread = std::thread([&]() { svr.listen(HOST, PORT); }); + + // Give GET time to get a few messages. + std::this_thread::sleep_for(std::chrono::seconds(1)); + + { + Client cli(HOST, PORT); + + auto res = cli.Get("/hi"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("text/html", res->get_header_value("Content-Type")); + EXPECT_EQ("26", res->get_header_value("Content-Length")); + EXPECT_EQ("abcdefghijklmnopqrstuvwxyz", res->body); + } + + svr.stop(); + thread.join(); + ASSERT_FALSE(svr.is_running()); +} + +TEST(ExceptionHandlerTest, ContentLength) { + Server svr; + + svr.set_exception_handler( + [](const Request & /*req*/, Response &res, std::exception & /*e*/) { + res.status = 500; + res.set_content("abcdefghijklmnopqrstuvwxyz", + "text/html"); // <= Content-Length still 13 + }); + + svr.Get("/hi", [](const Request & /*req*/, Response &res) { + res.set_content("Hello World!\n", "text/plain"); + throw std::runtime_error("abc"); + }); + + auto thread = std::thread([&]() { svr.listen(HOST, PORT); }); + + // Give GET time to get a few messages. + std::this_thread::sleep_for(std::chrono::seconds(1)); + + { + Client cli(HOST, PORT); + + auto res = cli.Get("/hi"); + ASSERT_TRUE(res); + EXPECT_EQ(500, res->status); + EXPECT_EQ("text/html", res->get_header_value("Content-Type")); + EXPECT_EQ("26", res->get_header_value("Content-Length")); + EXPECT_EQ("abcdefghijklmnopqrstuvwxyz", res->body); + } + + svr.stop(); + thread.join(); + ASSERT_FALSE(svr.is_running()); +} + +TEST(NoContentTest, ContentLength) { + Server svr; + + svr.Get("/hi", + [](const Request & /*req*/, Response &res) { res.status = 204; }); + auto thread = std::thread([&]() { svr.listen(HOST, PORT); }); + + // Give GET time to get a few messages. + std::this_thread::sleep_for(std::chrono::seconds(1)); + + { + Client cli(HOST, PORT); + + auto res = cli.Get("/hi"); + ASSERT_TRUE(res); + EXPECT_EQ(204, res->status); + EXPECT_EQ("0", res->get_header_value("Content-Length")); + } + + svr.stop(); + thread.join(); + ASSERT_FALSE(svr.is_running()); +} + +TEST(RoutingHandlerTest, PreRoutingHandler) { + Server svr; + + svr.set_pre_routing_handler([](const Request &req, Response &res) { + if (req.path == "/routing_handler") { + res.set_header("PRE_ROUTING", "on"); + res.set_content("Routing Handler", "text/plain"); + return httplib::Server::HandlerResponse::Handled; + } + return httplib::Server::HandlerResponse::Unhandled; + }); + + svr.set_error_handler([](const Request & /*req*/, Response &res) { + res.set_content("Error", "text/html"); + }); + + svr.set_post_routing_handler([](const Request &req, Response &res) { + if (req.path == "/routing_handler") { + res.set_header("POST_ROUTING", "on"); + } + }); + + svr.Get("/hi", [](const Request & /*req*/, Response &res) { + res.set_content("Hello World!\n", "text/plain"); + }); + + auto thread = std::thread([&]() { svr.listen(HOST, PORT); }); + + // Give GET time to get a few messages. + std::this_thread::sleep_for(std::chrono::seconds(1)); + + { + Client cli(HOST, PORT); + + auto res = cli.Get("/routing_handler"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("Routing Handler", res->body); + EXPECT_EQ(1, res->get_header_value_count("PRE_ROUTING")); + EXPECT_EQ("on", res->get_header_value("PRE_ROUTING")); + EXPECT_EQ(1, res->get_header_value_count("POST_ROUTING")); + EXPECT_EQ("on", res->get_header_value("POST_ROUTING")); + } + + { + Client cli(HOST, PORT); + + auto res = cli.Get("/hi"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("Hello World!\n", res->body); + EXPECT_EQ(0, res->get_header_value_count("PRE_ROUTING")); + EXPECT_EQ(0, res->get_header_value_count("POST_ROUTING")); + } + + { + Client cli(HOST, PORT); + + auto res = cli.Get("/aaa"); + ASSERT_TRUE(res); + EXPECT_EQ(404, res->status); + EXPECT_EQ("Error", res->body); + EXPECT_EQ(0, res->get_header_value_count("PRE_ROUTING")); + EXPECT_EQ(0, res->get_header_value_count("POST_ROUTING")); + } + + svr.stop(); + thread.join(); + ASSERT_FALSE(svr.is_running()); +} + +TEST(InvalidFormatTest, StatusCode) { + Server svr; + + svr.Get("/hi", [](const Request & /*req*/, Response &res) { + res.set_content("Hello World!\n", "text/plain"); + res.status = 9999; // Status should be a three-digit code... + }); + + auto thread = std::thread([&]() { svr.listen(HOST, PORT); }); + + // Give GET time to get a few messages. + std::this_thread::sleep_for(std::chrono::seconds(1)); + + { + Client cli(HOST, PORT); + + auto res = cli.Get("/hi"); + ASSERT_FALSE(res); + } + + svr.stop(); + thread.join(); + ASSERT_FALSE(svr.is_running()); +} + +class ServerTest : public ::testing::Test { +protected: + ServerTest() + : cli_(HOST, PORT) +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + , + svr_(SERVER_CERT_FILE, SERVER_PRIVATE_KEY_FILE) +#endif + { +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + cli_.enable_server_certificate_verification(false); +#endif + } + + virtual void SetUp() { + svr_.set_mount_point("/", "./www"); + svr_.set_mount_point("/mount", "./www2"); + svr_.set_file_extension_and_mimetype_mapping("abcde", "text/abcde"); + + svr_.Get("/hi", + [&](const Request & /*req*/, Response &res) { + res.set_content("Hello World!", "text/plain"); + }) + .Get("/http_response_splitting", + [&](const Request & /*req*/, Response &res) { + res.set_header("a", "1\r\nSet-Cookie: a=1"); + EXPECT_EQ(0, res.headers.size()); + EXPECT_FALSE(res.has_header("a")); + + res.set_header("a", "1\nSet-Cookie: a=1"); + EXPECT_EQ(0, res.headers.size()); + EXPECT_FALSE(res.has_header("a")); + + res.set_header("a", "1\rSet-Cookie: a=1"); + EXPECT_EQ(0, res.headers.size()); + EXPECT_FALSE(res.has_header("a")); + + res.set_header("a\r\nb", "0"); + EXPECT_EQ(0, res.headers.size()); + EXPECT_FALSE(res.has_header("a")); + + res.set_header("a\rb", "0"); + EXPECT_EQ(0, res.headers.size()); + EXPECT_FALSE(res.has_header("a")); + + res.set_header("a\nb", "0"); + EXPECT_EQ(0, res.headers.size()); + EXPECT_FALSE(res.has_header("a")); + + res.set_redirect("1\r\nSet-Cookie: a=1"); + EXPECT_EQ(0, res.headers.size()); + EXPECT_FALSE(res.has_header("Location")); + }) + .Get("/slow", + [&](const Request & /*req*/, Response &res) { + std::this_thread::sleep_for(std::chrono::seconds(2)); + res.set_content("slow", "text/plain"); + }) + .Post("/slowpost", + [&](const Request & /*req*/, Response &res) { + std::this_thread::sleep_for(std::chrono::seconds(2)); + res.set_content("slow", "text/plain"); + }) + .Get("/remote_addr", + [&](const Request &req, Response &res) { + auto remote_addr = req.headers.find("REMOTE_ADDR")->second; + EXPECT_TRUE(req.has_header("REMOTE_PORT")); + EXPECT_EQ(req.remote_addr, req.get_header_value("REMOTE_ADDR")); + EXPECT_EQ(req.remote_port, + std::stoi(req.get_header_value("REMOTE_PORT"))); + res.set_content(remote_addr.c_str(), "text/plain"); + }) + .Get("/endwith%", + [&](const Request & /*req*/, Response &res) { + res.set_content("Hello World!", "text/plain"); + }) + .Get("/a\\+\\+b", + [&](const Request &req, Response &res) { + ASSERT_TRUE(req.has_param("a +b")); + auto val = req.get_param_value("a +b"); + res.set_content(val, "text/plain"); + }) + .Get("/", [&](const Request & /*req*/, + Response &res) { res.set_redirect("/hi"); }) + .Post("/1", [](const Request & /*req*/, + Response &res) { res.set_redirect("/2", 303); }) + .Get("/2", + [](const Request & /*req*/, Response &res) { + res.set_content("redirected.", "text/plain"); + res.status = 200; + }) + .Post("/person", + [&](const Request &req, Response &res) { + if (req.has_param("name") && req.has_param("note")) { + persons_[req.get_param_value("name")] = + req.get_param_value("note"); + } else { + res.status = 400; + } + }) + .Put("/person", + [&](const Request &req, Response &res) { + if (req.has_param("name") && req.has_param("note")) { + persons_[req.get_param_value("name")] = + req.get_param_value("note"); + } else { + res.status = 400; + } + }) + .Get("/person/(.*)", + [&](const Request &req, Response &res) { + string name = req.matches[1]; + if (persons_.find(name) != persons_.end()) { + auto note = persons_[name]; + res.set_content(note, "text/plain"); + } else { + res.status = 404; + } + }) + .Post("/x-www-form-urlencoded-json", + [&](const Request &req, Response &res) { + auto json = req.get_param_value("json"); + ASSERT_EQ(JSON_DATA, json); + res.set_content(json, "appliation/json"); + res.status = 200; + }) + .Get("/streamed-chunked", + [&](const Request & /*req*/, Response &res) { + res.set_chunked_content_provider( + "text/plain", [](size_t /*offset*/, DataSink &sink) { + EXPECT_TRUE(sink.is_writable()); + sink.os << "123"; + sink.os << "456"; + sink.os << "789"; + sink.done(); + return true; + }); + }) + .Get("/streamed-chunked2", + [&](const Request & /*req*/, Response &res) { + auto i = new int(0); + res.set_chunked_content_provider( + "text/plain", + [i](size_t /*offset*/, DataSink &sink) { + EXPECT_TRUE(sink.is_writable()); + switch (*i) { + case 0: sink.os << "123"; break; + case 1: sink.os << "456"; break; + case 2: sink.os << "789"; break; + case 3: sink.done(); break; + } + (*i)++; + return true; + }, + [i] { delete i; }); + }) + .Get("/streamed", + [&](const Request & /*req*/, Response &res) { + res.set_content_provider( + 6, "text/plain", + [](size_t offset, size_t /*length*/, DataSink &sink) { + sink.os << (offset < 3 ? "a" : "b"); + return true; + }); + }) + .Get("/streamed-with-range", + [&](const Request & /*req*/, Response &res) { + auto data = new std::string("abcdefg"); + res.set_content_provider( + data->size(), "text/plain", + [data](size_t offset, size_t length, DataSink &sink) { + EXPECT_TRUE(sink.is_writable()); + size_t DATA_CHUNK_SIZE = 4; + const auto &d = *data; + auto out_len = + std::min(static_cast<size_t>(length), DATA_CHUNK_SIZE); + auto ret = sink.write(&d[static_cast<size_t>(offset)], out_len); + EXPECT_TRUE(ret); + return true; + }, + [data] { delete data; }); + }) + .Get("/streamed-cancel", + [&](const Request & /*req*/, Response &res) { + res.set_content_provider( + size_t(-1), "text/plain", + [](size_t /*offset*/, size_t /*length*/, DataSink &sink) { + EXPECT_TRUE(sink.is_writable()); + sink.os << "data_chunk"; + return true; + }); + }) + .Get("/with-range", + [&](const Request & /*req*/, Response &res) { + res.set_content("abcdefg", "text/plain"); + }) + .Post("/chunked", + [&](const Request &req, Response & /*res*/) { + EXPECT_EQ(req.body, "dechunked post body"); + }) + .Post("/large-chunked", + [&](const Request &req, Response & /*res*/) { + std::string expected(6 * 30 * 1024u, 'a'); + EXPECT_EQ(req.body, expected); + }) + .Post("/multipart", + [&](const Request &req, Response & /*res*/) { + EXPECT_EQ(6u, req.files.size()); + ASSERT_TRUE(!req.has_file("???")); + ASSERT_TRUE(req.body.empty()); + + { + const auto &file = req.get_file_value("text1"); + EXPECT_TRUE(file.filename.empty()); + EXPECT_EQ("text default", file.content); + } + + { + const auto &file = req.get_file_value("text2"); + EXPECT_TRUE(file.filename.empty()); + EXPECT_EQ("aωb", file.content); + } + + { + const auto &file = req.get_file_value("file1"); + EXPECT_EQ("hello.txt", file.filename); + EXPECT_EQ("text/plain", file.content_type); + EXPECT_EQ("h\ne\n\nl\nl\no\n", file.content); + } + + { + const auto &file = req.get_file_value("file3"); + EXPECT_TRUE(file.filename.empty()); + EXPECT_EQ("application/octet-stream", file.content_type); + EXPECT_EQ(0u, file.content.size()); + } + + { + const auto &file = req.get_file_value("file4"); + EXPECT_TRUE(file.filename.empty()); + EXPECT_EQ(0u, file.content.size()); + EXPECT_EQ("application/json tmp-string", file.content_type); + } + }) + .Post("/empty", + [&](const Request &req, Response &res) { + EXPECT_EQ(req.body, ""); + EXPECT_EQ("text/plain", req.get_header_value("Content-Type")); + EXPECT_EQ("0", req.get_header_value("Content-Length")); + res.set_content("empty", "text/plain"); + }) + .Post("/empty-no-content-type", + [&](const Request &req, Response &res) { + EXPECT_EQ(req.body, ""); + EXPECT_FALSE(req.has_header("Content-Type")); + EXPECT_EQ("0", req.get_header_value("Content-Length")); + res.set_content("empty-no-content-type", "text/plain"); + }) + .Put("/empty-no-content-type", + [&](const Request &req, Response &res) { + EXPECT_EQ(req.body, ""); + EXPECT_FALSE(req.has_header("Content-Type")); + EXPECT_EQ("0", req.get_header_value("Content-Length")); + res.set_content("empty-no-content-type", "text/plain"); + }) + .Put("/put", + [&](const Request &req, Response &res) { + EXPECT_EQ(req.body, "PUT"); + res.set_content(req.body, "text/plain"); + }) + .Put("/put-large", + [&](const Request &req, Response &res) { + EXPECT_EQ(req.body, LARGE_DATA); + res.set_content(req.body, "text/plain"); + }) + .Patch("/patch", + [&](const Request &req, Response &res) { + EXPECT_EQ(req.body, "PATCH"); + res.set_content(req.body, "text/plain"); + }) + .Delete("/delete", + [&](const Request & /*req*/, Response &res) { + res.set_content("DELETE", "text/plain"); + }) + .Delete("/delete-body", + [&](const Request &req, Response &res) { + EXPECT_EQ(req.body, "content"); + res.set_content(req.body, "text/plain"); + }) + .Options(R"(\*)", + [&](const Request & /*req*/, Response &res) { + res.set_header("Allow", "GET, POST, HEAD, OPTIONS"); + }) + .Get("/request-target", + [&](const Request &req, Response & /*res*/) { + EXPECT_EQ("/request-target?aaa=bbb&ccc=ddd", req.target); + EXPECT_EQ("bbb", req.get_param_value("aaa")); + EXPECT_EQ("ddd", req.get_param_value("ccc")); + }) + .Get("/long-query-value", + [&](const Request &req, Response & /*res*/) { + EXPECT_EQ(LONG_QUERY_URL, req.target); + EXPECT_EQ(LONG_QUERY_VALUE, req.get_param_value("key")); + }) + .Get("/array-param", + [&](const Request &req, Response & /*res*/) { + EXPECT_EQ(3u, req.get_param_value_count("array")); + EXPECT_EQ("value1", req.get_param_value("array", 0)); + EXPECT_EQ("value2", req.get_param_value("array", 1)); + EXPECT_EQ("value3", req.get_param_value("array", 2)); + }) + .Post("/validate-no-multiple-headers", + [&](const Request &req, Response & /*res*/) { + EXPECT_EQ(1u, req.get_header_value_count("Content-Length")); + EXPECT_EQ("5", req.get_header_value("Content-Length")); + }) + .Post("/content_receiver", + [&](const Request &req, Response &res, + const ContentReader &content_reader) { + if (req.is_multipart_form_data()) { + MultipartFormDataItems files; + content_reader( + [&](const MultipartFormData &file) { + files.push_back(file); + return true; + }, + [&](const char *data, size_t data_length) { + files.back().content.append(data, data_length); + return true; + }); + + EXPECT_EQ(5u, files.size()); + + { + const auto &file = get_file_value(files, "text1"); + EXPECT_TRUE(file.filename.empty()); + EXPECT_EQ("text default", file.content); + } + + { + const auto &file = get_file_value(files, "text2"); + EXPECT_TRUE(file.filename.empty()); + EXPECT_EQ("aωb", file.content); + } + + { + const auto &file = get_file_value(files, "file1"); + EXPECT_EQ("hello.txt", file.filename); + EXPECT_EQ("text/plain", file.content_type); + EXPECT_EQ("h\ne\n\nl\nl\no\n", file.content); + } + + { + const auto &file = get_file_value(files, "file3"); + EXPECT_TRUE(file.filename.empty()); + EXPECT_EQ("application/octet-stream", file.content_type); + EXPECT_EQ(0u, file.content.size()); + } + } else { + std::string body; + content_reader([&](const char *data, size_t data_length) { + EXPECT_EQ(data_length, 7); + body.append(data, data_length); + return true; + }); + EXPECT_EQ(body, "content"); + res.set_content(body, "text/plain"); + } + }) + .Put("/content_receiver", + [&](const Request & /*req*/, Response &res, + const ContentReader &content_reader) { + std::string body; + content_reader([&](const char *data, size_t data_length) { + body.append(data, data_length); + return true; + }); + EXPECT_EQ(body, "content"); + res.set_content(body, "text/plain"); + }) + .Patch("/content_receiver", + [&](const Request & /*req*/, Response &res, + const ContentReader &content_reader) { + std::string body; + content_reader([&](const char *data, size_t data_length) { + body.append(data, data_length); + return true; + }); + EXPECT_EQ(body, "content"); + res.set_content(body, "text/plain"); + }) + .Post("/query-string-and-body", + [&](const Request &req, Response & /*res*/) { + ASSERT_TRUE(req.has_param("key")); + EXPECT_EQ(req.get_param_value("key"), "value"); + EXPECT_EQ(req.body, "content"); + }) + .Get("/last-request", + [&](const Request &req, Response & /*res*/) { + EXPECT_EQ("close", req.get_header_value("Connection")); + }) + .Get(R"(/redirect/(\d+))", + [&](const Request &req, Response &res) { + auto num = std::stoi(req.matches[1]) + 1; + std::string url = "/redirect/" + std::to_string(num); + res.set_redirect(url); + }) + .Post("/binary", + [&](const Request &req, Response &res) { + EXPECT_EQ(4, req.body.size()); + EXPECT_EQ("application/octet-stream", + req.get_header_value("Content-Type")); + EXPECT_EQ("4", req.get_header_value("Content-Length")); + res.set_content(req.body, "application/octet-stream"); + }) + .Put("/binary", + [&](const Request &req, Response &res) { + EXPECT_EQ(4, req.body.size()); + EXPECT_EQ("application/octet-stream", + req.get_header_value("Content-Type")); + EXPECT_EQ("4", req.get_header_value("Content-Length")); + res.set_content(req.body, "application/octet-stream"); + }) + .Patch("/binary", + [&](const Request &req, Response &res) { + EXPECT_EQ(4, req.body.size()); + EXPECT_EQ("application/octet-stream", + req.get_header_value("Content-Type")); + EXPECT_EQ("4", req.get_header_value("Content-Length")); + res.set_content(req.body, "application/octet-stream"); + }) + .Delete("/binary", + [&](const Request &req, Response &res) { + EXPECT_EQ(4, req.body.size()); + EXPECT_EQ("application/octet-stream", + req.get_header_value("Content-Type")); + EXPECT_EQ("4", req.get_header_value("Content-Length")); + res.set_content(req.body, "application/octet-stream"); + }) +#if defined(CPPHTTPLIB_ZLIB_SUPPORT) || defined(CPPHTTPLIB_BROTLI_SUPPORT) + .Get("/compress", + [&](const Request & /*req*/, Response &res) { + res.set_content( + "12345678901234567890123456789012345678901234567890123456789" + "01234567890123456789012345678901234567890", + "text/plain"); + }) + .Get("/nocompress", + [&](const Request & /*req*/, Response &res) { + res.set_content( + "12345678901234567890123456789012345678901234567890123456789" + "01234567890123456789012345678901234567890", + "application/octet-stream"); + }) + .Post("/compress-multipart", + [&](const Request &req, Response & /*res*/) { + EXPECT_EQ(2u, req.files.size()); + ASSERT_TRUE(!req.has_file("???")); + + { + const auto &file = req.get_file_value("key1"); + EXPECT_TRUE(file.filename.empty()); + EXPECT_EQ("test", file.content); + } + + { + const auto &file = req.get_file_value("key2"); + EXPECT_TRUE(file.filename.empty()); + EXPECT_EQ("--abcdefg123", file.content); + } + }) +#endif + ; + + persons_["john"] = "programmer"; + + t_ = thread([&]() { ASSERT_TRUE(svr_.listen(HOST, PORT)); }); + + while (!svr_.is_running()) { + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + } + } + + virtual void TearDown() { + svr_.stop(); + if (!request_threads_.empty()) { + std::this_thread::sleep_for(std::chrono::seconds(1)); + for (auto &t : request_threads_) { + t.join(); + } + } + t_.join(); + } + + map<string, string> persons_; +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + SSLClient cli_; + SSLServer svr_; +#else + Client cli_; + Server svr_; +#endif + thread t_; + std::vector<thread> request_threads_; +}; + +TEST_F(ServerTest, GetMethod200) { + auto res = cli_.Get("/hi"); + ASSERT_TRUE(res); + EXPECT_EQ("HTTP/1.1", res->version); + EXPECT_EQ(200, res->status); + EXPECT_EQ("OK", res->reason); + EXPECT_EQ("text/plain", res->get_header_value("Content-Type")); + EXPECT_EQ(1, res->get_header_value_count("Content-Type")); + EXPECT_EQ("Hello World!", res->body); +} + +TEST_F(ServerTest, GetMethod200withPercentEncoding) { + auto res = cli_.Get("/%68%69"); // auto res = cli_.Get("/hi"); + ASSERT_TRUE(res); + EXPECT_EQ("HTTP/1.1", res->version); + EXPECT_EQ(200, res->status); + EXPECT_EQ("text/plain", res->get_header_value("Content-Type")); + EXPECT_EQ(1, res->get_header_value_count("Content-Type")); + EXPECT_EQ("Hello World!", res->body); +} + +TEST_F(ServerTest, GetMethod302) { + auto res = cli_.Get("/"); + ASSERT_TRUE(res); + EXPECT_EQ(302, res->status); + EXPECT_EQ("/hi", res->get_header_value("Location")); +} + +TEST_F(ServerTest, GetMethod302Redirect) { + cli_.set_follow_location(true); + auto res = cli_.Get("/"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("Hello World!", res->body); + EXPECT_EQ("/hi", res->location); +} + +TEST_F(ServerTest, GetMethod404) { + auto res = cli_.Get("/invalid"); + ASSERT_TRUE(res); + EXPECT_EQ(404, res->status); +} + +TEST_F(ServerTest, HeadMethod200) { + auto res = cli_.Head("/hi"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("text/plain", res->get_header_value("Content-Type")); + EXPECT_TRUE(res->body.empty()); +} + +TEST_F(ServerTest, HeadMethod200Static) { + auto res = cli_.Head("/mount/dir/index.html"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("text/html", res->get_header_value("Content-Type")); + EXPECT_EQ(104, std::stoi(res->get_header_value("Content-Length"))); + EXPECT_TRUE(res->body.empty()); +} + +TEST_F(ServerTest, HeadMethod404) { + auto res = cli_.Head("/invalid"); + ASSERT_TRUE(res); + EXPECT_EQ(404, res->status); + EXPECT_TRUE(res->body.empty()); +} + +TEST_F(ServerTest, GetMethodPersonJohn) { + auto res = cli_.Get("/person/john"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("text/plain", res->get_header_value("Content-Type")); + EXPECT_EQ("programmer", res->body); +} + +TEST_F(ServerTest, PostMethod1) { + auto res = cli_.Get("/person/john1"); + ASSERT_TRUE(res); + ASSERT_EQ(404, res->status); + + res = cli_.Post("/person", "name=john1¬e=coder", + "application/x-www-form-urlencoded"); + ASSERT_TRUE(res); + ASSERT_EQ(200, res->status); + + res = cli_.Get("/person/john1"); + ASSERT_TRUE(res); + ASSERT_EQ(200, res->status); + ASSERT_EQ("text/plain", res->get_header_value("Content-Type")); + ASSERT_EQ("coder", res->body); +} + +TEST_F(ServerTest, PostMethod2) { + auto res = cli_.Get("/person/john2"); + ASSERT_TRUE(res); + ASSERT_EQ(404, res->status); + + Params params; + params.emplace("name", "john2"); + params.emplace("note", "coder"); + + res = cli_.Post("/person", params); + ASSERT_TRUE(res); + ASSERT_EQ(200, res->status); + + res = cli_.Get("/person/john2"); + ASSERT_TRUE(res); + ASSERT_EQ(200, res->status); + ASSERT_EQ("text/plain", res->get_header_value("Content-Type")); + ASSERT_EQ("coder", res->body); +} + +TEST_F(ServerTest, PutMethod3) { + auto res = cli_.Get("/person/john3"); + ASSERT_TRUE(res); + ASSERT_EQ(404, res->status); + + Params params; + params.emplace("name", "john3"); + params.emplace("note", "coder"); + + res = cli_.Put("/person", params); + ASSERT_TRUE(res); + ASSERT_EQ(200, res->status); + + res = cli_.Get("/person/john3"); + ASSERT_TRUE(res); + ASSERT_EQ(200, res->status); + ASSERT_EQ("text/plain", res->get_header_value("Content-Type")); + ASSERT_EQ("coder", res->body); +} + +TEST_F(ServerTest, PostWwwFormUrlEncodedJson) { + Params params; + params.emplace("json", JSON_DATA); + + auto res = cli_.Post("/x-www-form-urlencoded-json", params); + + ASSERT_TRUE(res); + ASSERT_EQ(200, res->status); + ASSERT_EQ(JSON_DATA, res->body); +} + +TEST_F(ServerTest, PostEmptyContent) { + auto res = cli_.Post("/empty", "", "text/plain"); + ASSERT_TRUE(res); + ASSERT_EQ(200, res->status); + ASSERT_EQ("empty", res->body); +} + +TEST_F(ServerTest, PostEmptyContentWithNoContentType) { + auto res = cli_.Post("/empty-no-content-type"); + ASSERT_TRUE(res); + ASSERT_EQ(200, res->status); + ASSERT_EQ("empty-no-content-type", res->body); +} + +TEST_F(ServerTest, PutEmptyContentWithNoContentType) { + auto res = cli_.Put("/empty-no-content-type"); + ASSERT_TRUE(res); + ASSERT_EQ(200, res->status); + ASSERT_EQ("empty-no-content-type", res->body); +} + +TEST_F(ServerTest, GetMethodDir) { + auto res = cli_.Get("/dir/"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("text/html", res->get_header_value("Content-Type")); + + auto body = R"(<html> +<head> +</head> +<body> + <a href="/dir/test.html">Test</a> + <a href="/hi">hi</a> +</body> +</html> +)"; + EXPECT_EQ(body, res->body); +} + +TEST_F(ServerTest, GetMethodDirTest) { + auto res = cli_.Get("/dir/test.html"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("text/html", res->get_header_value("Content-Type")); + EXPECT_EQ("test.html", res->body); +} + +TEST_F(ServerTest, GetMethodDirTestWithDoubleDots) { + auto res = cli_.Get("/dir/../dir/test.html"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("text/html", res->get_header_value("Content-Type")); + EXPECT_EQ("test.html", res->body); +} + +TEST_F(ServerTest, GetMethodInvalidPath) { + auto res = cli_.Get("/dir/../test.html"); + ASSERT_TRUE(res); + EXPECT_EQ(404, res->status); +} + +TEST_F(ServerTest, GetMethodOutOfBaseDir) { + auto res = cli_.Get("/../www/dir/test.html"); + ASSERT_TRUE(res); + EXPECT_EQ(404, res->status); +} + +TEST_F(ServerTest, GetMethodOutOfBaseDir2) { + auto res = cli_.Get("/dir/../../www/dir/test.html"); + ASSERT_TRUE(res); + EXPECT_EQ(404, res->status); +} + +TEST_F(ServerTest, GetMethodDirMountTest) { + auto res = cli_.Get("/mount/dir/test.html"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("text/html", res->get_header_value("Content-Type")); + EXPECT_EQ("test.html", res->body); +} + +TEST_F(ServerTest, GetMethodDirMountTestWithDoubleDots) { + auto res = cli_.Get("/mount/dir/../dir/test.html"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("text/html", res->get_header_value("Content-Type")); + EXPECT_EQ("test.html", res->body); +} + +TEST_F(ServerTest, GetMethodInvalidMountPath) { + auto res = cli_.Get("/mount/dir/../test.html"); + ASSERT_TRUE(res); + EXPECT_EQ(404, res->status); +} + +TEST_F(ServerTest, GetMethodOutOfBaseDirMount) { + auto res = cli_.Get("/mount/../www2/dir/test.html"); + ASSERT_TRUE(res); + EXPECT_EQ(404, res->status); +} + +TEST_F(ServerTest, GetMethodOutOfBaseDirMount2) { + auto res = cli_.Get("/mount/dir/../../www2/dir/test.html"); + ASSERT_TRUE(res); + EXPECT_EQ(404, res->status); +} + +TEST_F(ServerTest, PostMethod303) { + auto res = cli_.Post("/1", "body", "text/plain"); + ASSERT_TRUE(res); + EXPECT_EQ(303, res->status); + EXPECT_EQ("/2", res->get_header_value("Location")); +} + +TEST_F(ServerTest, PostMethod303Redirect) { + cli_.set_follow_location(true); + auto res = cli_.Post("/1", "body", "text/plain"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("redirected.", res->body); + EXPECT_EQ("/2", res->location); +} + +TEST_F(ServerTest, UserDefinedMIMETypeMapping) { + auto res = cli_.Get("/dir/test.abcde"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("text/abcde", res->get_header_value("Content-Type")); + EXPECT_EQ("abcde", res->body); +} + +TEST_F(ServerTest, StaticFileRange) { + auto res = cli_.Get("/dir/test.abcde", {{make_range_header({{2, 3}})}}); + ASSERT_TRUE(res); + EXPECT_EQ(206, res->status); + EXPECT_EQ("text/abcde", res->get_header_value("Content-Type")); + EXPECT_EQ("2", res->get_header_value("Content-Length")); + EXPECT_EQ(true, res->has_header("Content-Range")); + EXPECT_EQ(std::string("cd"), res->body); +} + +TEST_F(ServerTest, InvalidBaseDirMount) { + EXPECT_EQ(false, svr_.set_mount_point("invalid_mount_point", "./www3")); +} + +TEST_F(ServerTest, Binary) { + std::vector<char> binary{0x00, 0x01, 0x02, 0x03}; + + auto res = cli_.Post("/binary", binary.data(), binary.size(), + "application/octet-stream"); + ASSERT_TRUE(res); + ASSERT_EQ(200, res->status); + ASSERT_EQ(4, res->body.size()); + + res = cli_.Put("/binary", binary.data(), binary.size(), + "application/octet-stream"); + ASSERT_TRUE(res); + ASSERT_EQ(200, res->status); + ASSERT_EQ(4, res->body.size()); + + res = cli_.Patch("/binary", binary.data(), binary.size(), + "application/octet-stream"); + ASSERT_TRUE(res); + ASSERT_EQ(200, res->status); + ASSERT_EQ(4, res->body.size()); + + res = cli_.Delete("/binary", binary.data(), binary.size(), + "application/octet-stream"); + ASSERT_TRUE(res); + ASSERT_EQ(200, res->status); + ASSERT_EQ(4, res->body.size()); +} + +TEST_F(ServerTest, BinaryString) { + auto binary = std::string("\x00\x01\x02\x03", 4); + + auto res = cli_.Post("/binary", binary, "application/octet-stream"); + ASSERT_TRUE(res); + ASSERT_EQ(200, res->status); + ASSERT_EQ(4, res->body.size()); + + res = cli_.Put("/binary", binary, "application/octet-stream"); + ASSERT_TRUE(res); + ASSERT_EQ(200, res->status); + ASSERT_EQ(4, res->body.size()); + + res = cli_.Patch("/binary", binary, "application/octet-stream"); + ASSERT_TRUE(res); + ASSERT_EQ(200, res->status); + ASSERT_EQ(4, res->body.size()); + + res = cli_.Delete("/binary", binary, "application/octet-stream"); + ASSERT_TRUE(res); + ASSERT_EQ(200, res->status); + ASSERT_EQ(4, res->body.size()); +} + +TEST_F(ServerTest, EmptyRequest) { + auto res = cli_.Get(""); + ASSERT_TRUE(!res); + EXPECT_EQ(Error::Connection, res.error()); +} + +TEST_F(ServerTest, LongRequest) { + std::string request; + for (size_t i = 0; i < 545; i++) { + request += "/TooLongRequest"; + } + request += "OK"; + + auto res = cli_.Get(request.c_str()); + + ASSERT_TRUE(res); + EXPECT_EQ(404, res->status); +} + +TEST_F(ServerTest, TooLongRequest) { + std::string request; + for (size_t i = 0; i < 545; i++) { + request += "/TooLongRequest"; + } + request += "_NG"; + + auto res = cli_.Get(request.c_str()); + + ASSERT_TRUE(res); + EXPECT_EQ(414, res->status); +} + +TEST_F(ServerTest, LongHeader) { + Request req; + req.method = "GET"; + req.path = "/hi"; + + std::string host_and_port; + host_and_port += HOST; + host_and_port += ":"; + host_and_port += std::to_string(PORT); + + req.headers.emplace("Host", host_and_port.c_str()); + req.headers.emplace("Accept", "*/*"); + req.headers.emplace("User-Agent", "cpp-httplib/0.1"); + + req.headers.emplace( + "Header-Name", + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@"); + + auto res = std::make_shared<Response>(); + auto error = Error::Success; + auto ret = cli_.send(req, *res, error); + + ASSERT_TRUE(ret); + EXPECT_EQ(200, res->status); +} + +TEST_F(ServerTest, LongQueryValue) { + auto res = cli_.Get(LONG_QUERY_URL.c_str()); + + ASSERT_TRUE(res); + EXPECT_EQ(414, res->status); +} + +TEST_F(ServerTest, TooLongHeader) { + Request req; + req.method = "GET"; + req.path = "/hi"; + + std::string host_and_port; + host_and_port += HOST; + host_and_port += ":"; + host_and_port += std::to_string(PORT); + + req.headers.emplace("Host", host_and_port.c_str()); + req.headers.emplace("Accept", "*/*"); + req.headers.emplace("User-Agent", "cpp-httplib/0.1"); + + req.headers.emplace( + "Header-Name", + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + "@@@@@@@@@@@@@@@@@"); + + auto res = std::make_shared<Response>(); + auto error = Error::Success; + auto ret = cli_.send(req, *res, error); + + ASSERT_TRUE(ret); + EXPECT_EQ(200, res->status); +} + +TEST_F(ServerTest, PercentEncoding) { + auto res = cli_.Get("/e%6edwith%"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); +} + +TEST_F(ServerTest, PercentEncodingUnicode) { + auto res = cli_.Get("/e%u006edwith%"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); +} + +TEST_F(ServerTest, InvalidPercentEncoding) { + auto res = cli_.Get("/%endwith%"); + ASSERT_TRUE(res); + EXPECT_EQ(404, res->status); +} + +TEST_F(ServerTest, InvalidPercentEncodingUnicode) { + auto res = cli_.Get("/%uendwith%"); + ASSERT_TRUE(res); + EXPECT_EQ(404, res->status); +} + +TEST_F(ServerTest, EndWithPercentCharacterInQuery) { + auto res = cli_.Get("/hello?aaa=bbb%"); + ASSERT_TRUE(res); + EXPECT_EQ(404, res->status); +} + +TEST_F(ServerTest, PlusSignEncoding) { + auto res = cli_.Get("/a+%2Bb?a %2bb=a %2Bb"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("a +b", res->body); +} + +TEST_F(ServerTest, MultipartFormData) { + MultipartFormDataItems items = { + {"text1", "text default", "", ""}, + {"text2", "aωb", "", ""}, + {"file1", "h\ne\n\nl\nl\no\n", "hello.txt", "text/plain"}, + {"file2", "{\n \"world\", true\n}\n", "world.json", "application/json"}, + {"file3", "", "", "application/octet-stream"}, + {"file4", "", "", " application/json tmp-string "}}; + + auto res = cli_.Post("/multipart", items); + + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); +} + +TEST_F(ServerTest, CaseInsensitiveHeaderName) { + auto res = cli_.Get("/hi"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("text/plain", res->get_header_value("content-type")); + EXPECT_EQ("Hello World!", res->body); +} + +TEST_F(ServerTest, CaseInsensitiveTransferEncoding) { + Request req; + req.method = "POST"; + req.path = "/chunked"; + + std::string host_and_port; + host_and_port += HOST; + host_and_port += ":"; + host_and_port += std::to_string(PORT); + + req.headers.emplace("Host", host_and_port.c_str()); + req.headers.emplace("Accept", "*/*"); + req.headers.emplace("User-Agent", "cpp-httplib/0.1"); + req.headers.emplace("Content-Type", "text/plain"); + req.headers.emplace("Content-Length", "0"); + req.headers.emplace( + "Transfer-Encoding", + "Chunked"); // Note, "Chunked" rather than typical "chunked". + + // Client does not chunk, so make a chunked body manually. + req.body = "4\r\ndech\r\nf\r\nunked post body\r\n0\r\n\r\n"; + + auto res = std::make_shared<Response>(); + auto error = Error::Success; + auto ret = cli_.send(req, *res, error); + + ASSERT_TRUE(ret); + EXPECT_EQ(200, res->status); +} + +TEST_F(ServerTest, GetStreamed2) { + auto res = cli_.Get("/streamed", {{make_range_header({{2, 3}})}}); + ASSERT_TRUE(res); + EXPECT_EQ(206, res->status); + EXPECT_EQ("2", res->get_header_value("Content-Length")); + EXPECT_EQ(std::string("ab"), res->body); +} + +TEST_F(ServerTest, GetStreamed) { + auto res = cli_.Get("/streamed"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("6", res->get_header_value("Content-Length")); + EXPECT_EQ(std::string("aaabbb"), res->body); +} + +TEST_F(ServerTest, GetStreamedWithRange1) { + auto res = cli_.Get("/streamed-with-range", {{make_range_header({{3, 5}})}}); + ASSERT_TRUE(res); + EXPECT_EQ(206, res->status); + EXPECT_EQ("3", res->get_header_value("Content-Length")); + EXPECT_EQ(true, res->has_header("Content-Range")); + EXPECT_EQ(std::string("def"), res->body); +} + +TEST_F(ServerTest, GetStreamedWithRange2) { + auto res = cli_.Get("/streamed-with-range", {{make_range_header({{1, -1}})}}); + ASSERT_TRUE(res); + EXPECT_EQ(206, res->status); + EXPECT_EQ("6", res->get_header_value("Content-Length")); + EXPECT_EQ(true, res->has_header("Content-Range")); + EXPECT_EQ(std::string("bcdefg"), res->body); +} + +TEST_F(ServerTest, GetStreamedWithRangeSuffix1) { + auto res = cli_.Get("/streamed-with-range", {{"Range", "bytes=-3"}}); + ASSERT_TRUE(res); + EXPECT_EQ(206, res->status); + EXPECT_EQ("3", res->get_header_value("Content-Length")); + EXPECT_EQ(true, res->has_header("Content-Range")); + EXPECT_EQ(std::string("efg"), res->body); +} + +TEST_F(ServerTest, GetStreamedWithRangeSuffix2) { + auto res = cli_.Get("/streamed-with-range", {{"Range", "bytes=-9999"}}); + ASSERT_TRUE(res); + EXPECT_EQ(206, res->status); + EXPECT_EQ("7", res->get_header_value("Content-Length")); + EXPECT_EQ(true, res->has_header("Content-Range")); + EXPECT_EQ(std::string("abcdefg"), res->body); +} + +TEST_F(ServerTest, GetStreamedWithRangeError) { + auto res = cli_.Get("/streamed-with-range", + {{"Range", "bytes=92233720368547758079223372036854775806-" + "92233720368547758079223372036854775807"}}); + ASSERT_TRUE(res); + EXPECT_EQ(416, res->status); +} + +TEST_F(ServerTest, GetRangeWithMaxLongLength) { + auto res = + cli_.Get("/with-range", {{"Range", "bytes=0-9223372036854775807"}}); + EXPECT_EQ(206, res->status); + EXPECT_EQ("7", res->get_header_value("Content-Length")); + EXPECT_EQ(true, res->has_header("Content-Range")); + EXPECT_EQ(std::string("abcdefg"), res->body); +} + +TEST_F(ServerTest, GetStreamedWithRangeMultipart) { + auto res = + cli_.Get("/streamed-with-range", {{make_range_header({{1, 2}, {4, 5}})}}); + ASSERT_TRUE(res); + EXPECT_EQ(206, res->status); + EXPECT_EQ("269", res->get_header_value("Content-Length")); + EXPECT_EQ(false, res->has_header("Content-Range")); + EXPECT_EQ(269, res->body.size()); +} + +TEST_F(ServerTest, GetStreamedEndless) { + uint64_t offset = 0; + auto res = cli_.Get("/streamed-cancel", + [&](const char * /*data*/, uint64_t data_length) { + if (offset < 100) { + offset += data_length; + return true; + } + return false; + }); + ASSERT_TRUE(!res); + EXPECT_EQ(Error::Canceled, res.error()); +} + +TEST_F(ServerTest, ClientStop) { + std::vector<std::thread> threads; + for (auto i = 0; i < 3; i++) { + threads.emplace_back(thread([&]() { + auto res = cli_.Get("/streamed-cancel", + [&](const char *, uint64_t) { return true; }); + ASSERT_TRUE(!res); + EXPECT_TRUE(res.error() == Error::Canceled || + res.error() == Error::Read || res.error() == Error::Write); + })); + } + + std::this_thread::sleep_for(std::chrono::seconds(2)); + while (cli_.is_socket_open()) { + cli_.stop(); + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + } + for (auto &t : threads) { + t.join(); + } +} + +TEST_F(ServerTest, GetWithRange1) { + auto res = cli_.Get("/with-range", {{make_range_header({{3, 5}})}}); + ASSERT_TRUE(res); + EXPECT_EQ(206, res->status); + EXPECT_EQ("3", res->get_header_value("Content-Length")); + EXPECT_EQ(true, res->has_header("Content-Range")); + EXPECT_EQ(std::string("def"), res->body); +} + +TEST_F(ServerTest, GetWithRange2) { + auto res = cli_.Get("/with-range", {{make_range_header({{1, -1}})}}); + ASSERT_TRUE(res); + EXPECT_EQ(206, res->status); + EXPECT_EQ("6", res->get_header_value("Content-Length")); + EXPECT_EQ(true, res->has_header("Content-Range")); + EXPECT_EQ(std::string("bcdefg"), res->body); +} + +TEST_F(ServerTest, GetWithRange3) { + auto res = cli_.Get("/with-range", {{make_range_header({{0, 0}})}}); + ASSERT_TRUE(res); + EXPECT_EQ(206, res->status); + EXPECT_EQ("1", res->get_header_value("Content-Length")); + EXPECT_EQ(true, res->has_header("Content-Range")); + EXPECT_EQ(std::string("a"), res->body); +} + +TEST_F(ServerTest, GetWithRange4) { + auto res = cli_.Get("/with-range", {{make_range_header({{-1, 2}})}}); + ASSERT_TRUE(res); + EXPECT_EQ(206, res->status); + EXPECT_EQ("2", res->get_header_value("Content-Length")); + EXPECT_EQ(true, res->has_header("Content-Range")); + EXPECT_EQ(std::string("fg"), res->body); +} + +TEST_F(ServerTest, GetWithRangeOffsetGreaterThanContent) { + auto res = cli_.Get("/with-range", {{make_range_header({{10000, 20000}})}}); + ASSERT_TRUE(res); + EXPECT_EQ(416, res->status); +} + +TEST_F(ServerTest, GetWithRangeMultipart) { + auto res = cli_.Get("/with-range", {{make_range_header({{1, 2}, {4, 5}})}}); + ASSERT_TRUE(res); + EXPECT_EQ(206, res->status); + EXPECT_EQ("269", res->get_header_value("Content-Length")); + EXPECT_EQ(false, res->has_header("Content-Range")); + EXPECT_EQ(269, res->body.size()); +} + +TEST_F(ServerTest, GetWithRangeMultipartOffsetGreaterThanContent) { + auto res = + cli_.Get("/with-range", {{make_range_header({{-1, 2}, {10000, 30000}})}}); + ASSERT_TRUE(res); + EXPECT_EQ(416, res->status); +} + +TEST_F(ServerTest, GetStreamedChunked) { + auto res = cli_.Get("/streamed-chunked"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ(std::string("123456789"), res->body); +} + +TEST_F(ServerTest, GetStreamedChunked2) { + auto res = cli_.Get("/streamed-chunked2"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ(std::string("123456789"), res->body); +} + +TEST_F(ServerTest, LargeChunkedPost) { + Request req; + req.method = "POST"; + req.path = "/large-chunked"; + + std::string host_and_port; + host_and_port += HOST; + host_and_port += ":"; + host_and_port += std::to_string(PORT); + + req.headers.emplace("Host", host_and_port.c_str()); + req.headers.emplace("Accept", "*/*"); + req.headers.emplace("User-Agent", "cpp-httplib/0.1"); + req.headers.emplace("Content-Type", "text/plain"); + req.headers.emplace("Content-Length", "0"); + req.headers.emplace("Transfer-Encoding", "chunked"); + + std::string long_string(30 * 1024u, 'a'); + std::string chunk = "7800\r\n" + long_string + "\r\n"; + + // Attempt to make a large enough post to exceed OS buffers, to test that + // the server handles short reads if the full chunk data isn't available. + req.body = chunk + chunk + chunk + chunk + chunk + chunk + "0\r\n\r\n"; + + auto res = std::make_shared<Response>(); + auto error = Error::Success; + auto ret = cli_.send(req, *res, error); + + ASSERT_TRUE(ret); + EXPECT_EQ(200, res->status); +} + +TEST_F(ServerTest, GetMethodRemoteAddr) { + auto res = cli_.Get("/remote_addr"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("text/plain", res->get_header_value("Content-Type")); + EXPECT_TRUE(res->body == "::1" || res->body == "127.0.0.1"); +} + +TEST_F(ServerTest, HTTPResponseSplitting) { + auto res = cli_.Get("/http_response_splitting"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); +} + +TEST_F(ServerTest, SlowRequest) { + request_threads_.push_back( + std::thread([=]() { auto res = cli_.Get("/slow"); })); + request_threads_.push_back( + std::thread([=]() { auto res = cli_.Get("/slow"); })); + request_threads_.push_back( + std::thread([=]() { auto res = cli_.Get("/slow"); })); +} + +TEST_F(ServerTest, SlowPost) { + char buffer[64 * 1024]; + memset(buffer, 0x42, sizeof(buffer)); + + auto res = cli_.Post( + "/slowpost", 64 * 1024 * 1024, + [&](size_t /*offset*/, size_t /*length*/, DataSink &sink) { + auto ret = sink.write(buffer, sizeof(buffer)); + EXPECT_TRUE(ret); + return true; + }, + "text/plain"); + + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); +} + +TEST_F(ServerTest, SlowPostFail) { + char buffer[64 * 1024]; + memset(buffer, 0x42, sizeof(buffer)); + + cli_.set_write_timeout(std::chrono::seconds(0)); + auto res = cli_.Post( + "/slowpost", 64 * 1024 * 1024, + [&](size_t /*offset*/, size_t /*length*/, DataSink &sink) { + sink.write(buffer, sizeof(buffer)); + return true; + }, + "text/plain"); + + ASSERT_TRUE(!res); + EXPECT_EQ(Error::Write, res.error()); +} + +TEST_F(ServerTest, Put) { + auto res = cli_.Put("/put", "PUT", "text/plain"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("PUT", res->body); +} + +TEST_F(ServerTest, PutWithContentProvider) { + auto res = cli_.Put( + "/put", 3, + [](size_t /*offset*/, size_t /*length*/, DataSink &sink) { + EXPECT_TRUE(sink.is_writable()); + sink.os << "PUT"; + return true; + }, + "text/plain"); + + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("PUT", res->body); +} + +TEST_F(ServerTest, PostWithContentProviderAbort) { + auto res = cli_.Post( + "/post", 42, + [](size_t /*offset*/, size_t /*length*/, DataSink & /*sink*/) { + return false; + }, + "text/plain"); + + ASSERT_TRUE(!res); + EXPECT_EQ(Error::Canceled, res.error()); +} + +TEST_F(ServerTest, PutWithContentProviderWithoutLength) { + auto res = cli_.Put( + "/put", + [](size_t /*offset*/, DataSink &sink) { + EXPECT_TRUE(sink.is_writable()); + sink.os << "PUT"; + sink.done(); + return true; + }, + "text/plain"); + + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("PUT", res->body); +} + +TEST_F(ServerTest, PostWithContentProviderWithoutLengthAbort) { + auto res = cli_.Post( + "/post", [](size_t /*offset*/, DataSink & /*sink*/) { return false; }, + "text/plain"); + + ASSERT_TRUE(!res); + EXPECT_EQ(Error::Canceled, res.error()); +} + +#ifdef CPPHTTPLIB_ZLIB_SUPPORT +TEST_F(ServerTest, PutWithContentProviderWithGzip) { + cli_.set_compress(true); + auto res = cli_.Put( + "/put", 3, + [](size_t /*offset*/, size_t /*length*/, DataSink &sink) { + EXPECT_TRUE(sink.is_writable()); + sink.os << "PUT"; + return true; + }, + "text/plain"); + + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("PUT", res->body); +} + +TEST_F(ServerTest, PostWithContentProviderWithGzipAbort) { + cli_.set_compress(true); + auto res = cli_.Post( + "/post", 42, + [](size_t /*offset*/, size_t /*length*/, DataSink & /*sink*/) { + return false; + }, + "text/plain"); + + ASSERT_TRUE(!res); + EXPECT_EQ(Error::Canceled, res.error()); +} + +TEST_F(ServerTest, PutWithContentProviderWithoutLengthWithGzip) { + cli_.set_compress(true); + auto res = cli_.Put( + "/put", + [](size_t /*offset*/, DataSink &sink) { + EXPECT_TRUE(sink.is_writable()); + sink.os << "PUT"; + sink.done(); + return true; + }, + "text/plain"); + + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("PUT", res->body); +} + +TEST_F(ServerTest, PostWithContentProviderWithoutLengthWithGzipAbort) { + cli_.set_compress(true); + auto res = cli_.Post( + "/post", [](size_t /*offset*/, DataSink & /*sink*/) { return false; }, + "text/plain"); + + ASSERT_TRUE(!res); + EXPECT_EQ(Error::Canceled, res.error()); +} + +TEST_F(ServerTest, PutLargeFileWithGzip) { + cli_.set_compress(true); + auto res = cli_.Put("/put-large", LARGE_DATA, "text/plain"); + + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ(LARGE_DATA, res->body); +} + +TEST_F(ServerTest, PutLargeFileWithGzip2) { +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + Client cli("https://localhost:1234"); + cli.enable_server_certificate_verification(false); +#else + Client cli("http://localhost:1234"); +#endif + cli.set_compress(true); + + auto res = cli.Put("/put-large", LARGE_DATA, "text/plain"); + + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ(LARGE_DATA, res->body); + EXPECT_EQ(101942u, res.get_request_header_value<uint64_t>("Content-Length")); + EXPECT_EQ("gzip", res.get_request_header_value("Content-Encoding")); +} + +TEST_F(ServerTest, PutContentWithDeflate) { + cli_.set_compress(false); + Headers headers; + headers.emplace("Content-Encoding", "deflate"); + // PUT in deflate format: + auto res = cli_.Put("/put", headers, + "\170\234\013\010\015\001\0\001\361\0\372", "text/plain"); + + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("PUT", res->body); +} + +TEST_F(ServerTest, GetStreamedChunkedWithGzip) { + Headers headers; + headers.emplace("Accept-Encoding", "gzip, deflate"); + + auto res = cli_.Get("/streamed-chunked", headers); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ(std::string("123456789"), res->body); +} + +TEST_F(ServerTest, GetStreamedChunkedWithGzip2) { + Headers headers; + headers.emplace("Accept-Encoding", "gzip, deflate"); + + auto res = cli_.Get("/streamed-chunked2", headers); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ(std::string("123456789"), res->body); +} + +TEST(GzipDecompressor, ChunkedDecompression) { + std::string data; + for (size_t i = 0; i < 32 * 1024; ++i) { + data.push_back(static_cast<char>('a' + i % 26)); + } + + std::string compressed_data; + { + httplib::detail::gzip_compressor compressor; + bool result = compressor.compress( + data.data(), data.size(), + /*last=*/true, [&](const char *data, size_t size) { + compressed_data.insert(compressed_data.size(), data, size); + return true; + }); + ASSERT_TRUE(result); + } + + std::string decompressed_data; + { + httplib::detail::gzip_decompressor decompressor; + + // Chunk size is chosen specificaly to have a decompressed chunk size equal + // to 16384 bytes 16384 bytes is the size of decompressor output buffer + size_t chunk_size = 130; + for (size_t chunk_begin = 0; chunk_begin < compressed_data.size(); + chunk_begin += chunk_size) { + size_t current_chunk_size = + std::min(compressed_data.size() - chunk_begin, chunk_size); + bool result = decompressor.decompress( + compressed_data.data() + chunk_begin, current_chunk_size, + [&](const char *data, size_t size) { + decompressed_data.insert(decompressed_data.size(), data, size); + return true; + }); + ASSERT_TRUE(result); + } + } + ASSERT_EQ(data, decompressed_data); +} +#endif + +#ifdef CPPHTTPLIB_BROTLI_SUPPORT +TEST_F(ServerTest, GetStreamedChunkedWithBrotli) { + Headers headers; + headers.emplace("Accept-Encoding", "br"); + + auto res = cli_.Get("/streamed-chunked", headers); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ(std::string("123456789"), res->body); +} + +TEST_F(ServerTest, GetStreamedChunkedWithBrotli2) { + Headers headers; + headers.emplace("Accept-Encoding", "br"); + + auto res = cli_.Get("/streamed-chunked2", headers); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ(std::string("123456789"), res->body); +} +#endif + +TEST_F(ServerTest, Patch) { + auto res = cli_.Patch("/patch", "PATCH", "text/plain"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("PATCH", res->body); +} + +TEST_F(ServerTest, Delete) { + auto res = cli_.Delete("/delete"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("DELETE", res->body); +} + +TEST_F(ServerTest, DeleteContentReceiver) { + auto res = cli_.Delete("/delete-body", "content", "text/plain"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("content", res->body); +} + +TEST_F(ServerTest, Options) { + auto res = cli_.Options("*"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("GET, POST, HEAD, OPTIONS", res->get_header_value("Allow")); + EXPECT_TRUE(res->body.empty()); +} + +TEST_F(ServerTest, URL) { + auto res = cli_.Get("/request-target?aaa=bbb&ccc=ddd"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); +} + +TEST_F(ServerTest, ArrayParam) { + auto res = cli_.Get("/array-param?array=value1&array=value2&array=value3"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); +} + +TEST_F(ServerTest, NoMultipleHeaders) { + Headers headers = {{"Content-Length", "5"}}; + auto res = cli_.Post("/validate-no-multiple-headers", headers, "hello", + "text/plain"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); +} + +TEST_F(ServerTest, PostContentReceiver) { + auto res = cli_.Post("/content_receiver", "content", "text/plain"); + ASSERT_TRUE(res); + ASSERT_EQ(200, res->status); + ASSERT_EQ("content", res->body); +} + +TEST_F(ServerTest, PostMulitpartFilsContentReceiver) { + MultipartFormDataItems items = { + {"text1", "text default", "", ""}, + {"text2", "aωb", "", ""}, + {"file1", "h\ne\n\nl\nl\no\n", "hello.txt", "text/plain"}, + {"file2", "{\n \"world\", true\n}\n", "world.json", "application/json"}, + {"file3", "", "", "application/octet-stream"}, + }; + + auto res = cli_.Post("/content_receiver", items); + + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); +} + +TEST_F(ServerTest, PostMulitpartPlusBoundary) { + MultipartFormDataItems items = { + {"text1", "text default", "", ""}, + {"text2", "aωb", "", ""}, + {"file1", "h\ne\n\nl\nl\no\n", "hello.txt", "text/plain"}, + {"file2", "{\n \"world\", true\n}\n", "world.json", "application/json"}, + {"file3", "", "", "application/octet-stream"}, + }; + + auto boundary = std::string("+++++"); + + std::string body; + + for (const auto &item : items) { + body += "--" + boundary + "\r\n"; + body += "Content-Disposition: form-data; name=\"" + item.name + "\""; + if (!item.filename.empty()) { + body += "; filename=\"" + item.filename + "\""; + } + body += "\r\n"; + if (!item.content_type.empty()) { + body += "Content-Type: " + item.content_type + "\r\n"; + } + body += "\r\n"; + body += item.content + "\r\n"; + } + body += "--" + boundary + "--\r\n"; + + std::string content_type = "multipart/form-data; boundary=" + boundary; + auto res = cli_.Post("/content_receiver", body, content_type.c_str()); + + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); +} + +TEST_F(ServerTest, PostContentReceiverGzip) { + cli_.set_compress(true); + auto res = cli_.Post("/content_receiver", "content", "text/plain"); + ASSERT_TRUE(res); + ASSERT_EQ(200, res->status); + ASSERT_EQ("content", res->body); +} + +TEST_F(ServerTest, PutContentReceiver) { + auto res = cli_.Put("/content_receiver", "content", "text/plain"); + ASSERT_TRUE(res); + ASSERT_EQ(200, res->status); + ASSERT_EQ("content", res->body); +} + +TEST_F(ServerTest, PatchContentReceiver) { + auto res = cli_.Patch("/content_receiver", "content", "text/plain"); + ASSERT_TRUE(res); + ASSERT_EQ(200, res->status); + ASSERT_EQ("content", res->body); +} + +TEST_F(ServerTest, PostQueryStringAndBody) { + auto res = + cli_.Post("/query-string-and-body?key=value", "content", "text/plain"); + ASSERT_TRUE(res); + ASSERT_EQ(200, res->status); +} + +TEST_F(ServerTest, HTTP2Magic) { + Request req; + req.method = "PRI"; + req.path = "*"; + req.body = "SM"; + + auto res = std::make_shared<Response>(); + auto error = Error::Success; + auto ret = cli_.send(req, *res, error); + + ASSERT_TRUE(ret); + EXPECT_EQ(400, res->status); +} + +TEST_F(ServerTest, KeepAlive) { + auto res = cli_.Get("/hi"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("text/plain", res->get_header_value("Content-Type")); + EXPECT_EQ("Hello World!", res->body); + + res = cli_.Get("/hi"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("text/plain", res->get_header_value("Content-Type")); + EXPECT_EQ("Hello World!", res->body); + + res = cli_.Get("/hi"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("text/plain", res->get_header_value("Content-Type")); + EXPECT_EQ("Hello World!", res->body); + + res = cli_.Get("/not-exist"); + ASSERT_TRUE(res); + EXPECT_EQ(404, res->status); + + res = cli_.Post("/empty", "", "text/plain"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("text/plain", res->get_header_value("Content-Type")); + EXPECT_EQ("empty", res->body); + EXPECT_EQ("close", res->get_header_value("Connection")); + + res = cli_.Post( + "/empty", 0, [&](size_t, size_t, DataSink &) { return true; }, + "text/plain"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("text/plain", res->get_header_value("Content-Type")); + EXPECT_EQ("empty", res->body); + + cli_.set_keep_alive(false); + res = cli_.Get("/last-request"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("close", res->get_header_value("Connection")); +} + +TEST_F(ServerTest, TooManyRedirect) { + cli_.set_follow_location(true); + auto res = cli_.Get("/redirect/0"); + ASSERT_TRUE(!res); + EXPECT_EQ(Error::ExceedRedirectCount, res.error()); +} + +#ifdef CPPHTTPLIB_ZLIB_SUPPORT +TEST_F(ServerTest, Gzip) { + Headers headers; + headers.emplace("Accept-Encoding", "gzip, deflate"); + auto res = cli_.Get("/compress", headers); + + ASSERT_TRUE(res); + EXPECT_EQ("gzip", res->get_header_value("Content-Encoding")); + EXPECT_EQ("text/plain", res->get_header_value("Content-Type")); + EXPECT_EQ("33", res->get_header_value("Content-Length")); + EXPECT_EQ("123456789012345678901234567890123456789012345678901234567890123456" + "7890123456789012345678901234567890", + res->body); + EXPECT_EQ(200, res->status); +} + +TEST_F(ServerTest, GzipWithoutAcceptEncoding) { + auto res = cli_.Get("/compress"); + + ASSERT_TRUE(res); + EXPECT_TRUE(res->get_header_value("Content-Encoding").empty()); + EXPECT_EQ("text/plain", res->get_header_value("Content-Type")); + EXPECT_EQ("100", res->get_header_value("Content-Length")); + EXPECT_EQ("123456789012345678901234567890123456789012345678901234567890123456" + "7890123456789012345678901234567890", + res->body); + EXPECT_EQ(200, res->status); +} + +TEST_F(ServerTest, GzipWithContentReceiver) { + Headers headers; + headers.emplace("Accept-Encoding", "gzip, deflate"); + std::string body; + auto res = cli_.Get("/compress", headers, + [&](const char *data, uint64_t data_length) { + EXPECT_EQ(data_length, 100); + body.append(data, data_length); + return true; + }); + + ASSERT_TRUE(res); + EXPECT_EQ("gzip", res->get_header_value("Content-Encoding")); + EXPECT_EQ("text/plain", res->get_header_value("Content-Type")); + EXPECT_EQ("33", res->get_header_value("Content-Length")); + EXPECT_EQ("123456789012345678901234567890123456789012345678901234567890123456" + "7890123456789012345678901234567890", + body); + EXPECT_EQ(200, res->status); +} + +TEST_F(ServerTest, GzipWithoutDecompressing) { + Headers headers; + headers.emplace("Accept-Encoding", "gzip, deflate"); + + cli_.set_decompress(false); + auto res = cli_.Get("/compress", headers); + + ASSERT_TRUE(res); + EXPECT_EQ("gzip", res->get_header_value("Content-Encoding")); + EXPECT_EQ("text/plain", res->get_header_value("Content-Type")); + EXPECT_EQ("33", res->get_header_value("Content-Length")); + EXPECT_EQ(33, res->body.size()); + EXPECT_EQ(200, res->status); +} + +TEST_F(ServerTest, GzipWithContentReceiverWithoutAcceptEncoding) { + std::string body; + auto res = cli_.Get("/compress", [&](const char *data, uint64_t data_length) { + EXPECT_EQ(data_length, 100); + body.append(data, data_length); + return true; + }); + + ASSERT_TRUE(res); + EXPECT_TRUE(res->get_header_value("Content-Encoding").empty()); + EXPECT_EQ("text/plain", res->get_header_value("Content-Type")); + EXPECT_EQ("100", res->get_header_value("Content-Length")); + EXPECT_EQ("123456789012345678901234567890123456789012345678901234567890123456" + "7890123456789012345678901234567890", + body); + EXPECT_EQ(200, res->status); +} + +TEST_F(ServerTest, NoGzip) { + Headers headers; + headers.emplace("Accept-Encoding", "gzip, deflate"); + auto res = cli_.Get("/nocompress", headers); + + ASSERT_TRUE(res); + EXPECT_EQ(false, res->has_header("Content-Encoding")); + EXPECT_EQ("application/octet-stream", res->get_header_value("Content-Type")); + EXPECT_EQ("100", res->get_header_value("Content-Length")); + EXPECT_EQ("123456789012345678901234567890123456789012345678901234567890123456" + "7890123456789012345678901234567890", + res->body); + EXPECT_EQ(200, res->status); +} + +TEST_F(ServerTest, NoGzipWithContentReceiver) { + Headers headers; + headers.emplace("Accept-Encoding", "gzip, deflate"); + std::string body; + auto res = cli_.Get("/nocompress", headers, + [&](const char *data, uint64_t data_length) { + EXPECT_EQ(data_length, 100); + body.append(data, data_length); + return true; + }); + + ASSERT_TRUE(res); + EXPECT_EQ(false, res->has_header("Content-Encoding")); + EXPECT_EQ("application/octet-stream", res->get_header_value("Content-Type")); + EXPECT_EQ("100", res->get_header_value("Content-Length")); + EXPECT_EQ("123456789012345678901234567890123456789012345678901234567890123456" + "7890123456789012345678901234567890", + body); + EXPECT_EQ(200, res->status); +} + +TEST_F(ServerTest, MultipartFormDataGzip) { + MultipartFormDataItems items = { + {"key1", "test", "", ""}, + {"key2", "--abcdefg123", "", ""}, + }; + + cli_.set_compress(true); + auto res = cli_.Post("/compress-multipart", items); + + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); +} +#endif + +#ifdef CPPHTTPLIB_BROTLI_SUPPORT +TEST_F(ServerTest, Brotli) { + Headers headers; + headers.emplace("Accept-Encoding", "br"); + auto res = cli_.Get("/compress", headers); + + ASSERT_TRUE(res); + EXPECT_EQ("br", res->get_header_value("Content-Encoding")); + EXPECT_EQ("text/plain", res->get_header_value("Content-Type")); + EXPECT_EQ("19", res->get_header_value("Content-Length")); + EXPECT_EQ("123456789012345678901234567890123456789012345678901234567890123456" + "7890123456789012345678901234567890", + res->body); + EXPECT_EQ(200, res->status); +} +#endif + +// Sends a raw request to a server listening at HOST:PORT. +static bool send_request(time_t read_timeout_sec, const std::string &req, + std::string *resp = nullptr) { + auto error = Error::Success; + + auto client_sock = + detail::create_client_socket(HOST, PORT, AF_UNSPEC, false, nullptr, + /*connection_timeout_sec=*/5, 0, + /*read_timeout_sec=*/5, 0, + /*write_timeout_sec=*/5, 0, + std::string(), error); + + if (client_sock == INVALID_SOCKET) { return false; } + + auto ret = detail::process_client_socket( + client_sock, read_timeout_sec, 0, 0, 0, [&](Stream &strm) { + if (req.size() != + static_cast<size_t>(strm.write(req.data(), req.size()))) { + return false; + } + + char buf[512]; + + detail::stream_line_reader line_reader(strm, buf, sizeof(buf)); + while (line_reader.getline()) { + if (resp) { *resp += line_reader.ptr(); } + } + return true; + }); + + detail::close_socket(client_sock); + + return ret; +} + +TEST(ServerRequestParsingTest, TrimWhitespaceFromHeaderValues) { + Server svr; + std::string header_value; + svr.Get("/validate-ws-in-headers", [&](const Request &req, Response &res) { + header_value = req.get_header_value("foo"); + res.set_content("ok", "text/plain"); + }); + + thread t = thread([&] { svr.listen(HOST, PORT); }); + while (!svr.is_running()) { + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + } + + // Only space and horizontal tab are whitespace. Make sure other whitespace- + // like characters are not treated the same - use vertical tab and escape. + const std::string req = "GET /validate-ws-in-headers HTTP/1.1\r\n" + "foo: \t \v bar \e\t \r\n" + "Connection: close\r\n" + "\r\n"; + + ASSERT_TRUE(send_request(5, req)); + svr.stop(); + t.join(); + EXPECT_EQ(header_value, "\v bar \e"); +} + +// Sends a raw request and verifies that there isn't a crash or exception. +static void test_raw_request(const std::string &req, + std::string *out = nullptr) { + Server svr; + svr.Get("/hi", [&](const Request & /*req*/, Response &res) { + res.set_content("ok", "text/plain"); + }); + svr.Put("/put_hi", [&](const Request & /*req*/, Response &res) { + res.set_content("ok", "text/plain"); + }); + + // Server read timeout must be longer than the client read timeout for the + // bug to reproduce, probably to force the server to process a request + // without a trailing blank line. + const time_t client_read_timeout_sec = 1; + svr.set_read_timeout(std::chrono::seconds(client_read_timeout_sec + 1)); + bool listen_thread_ok = false; + thread t = thread([&] { listen_thread_ok = svr.listen(HOST, PORT); }); + while (!svr.is_running()) { + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + } + + ASSERT_TRUE(send_request(client_read_timeout_sec, req, out)); + svr.stop(); + t.join(); + EXPECT_TRUE(listen_thread_ok); +} + +TEST(ServerRequestParsingTest, ReadHeadersRegexComplexity) { + // A certain header line causes an exception if the header property is parsed + // naively with a single regex. This occurs with libc++ but not libstdc++. + test_raw_request( + "GET /hi HTTP/1.1\r\n" + " : " + " " + " "); +} + +TEST(ServerRequestParsingTest, ReadHeadersRegexComplexity2) { + // A certain header line causes an exception if the header property *name* is + // parsed with a regular expression starting with "(.+?):" - this is a non- + // greedy matcher and requires backtracking when there are a lot of ":" + // characters. + // This occurs with libc++ but not libstdc++. + test_raw_request( + "GET /hi HTTP/1.1\r\n" + ":-:::::::::::::::::::::::::::-::::::::::::::::::::::::@-&&&&&&&&&&&" + "--:::::::-:::::::::::::::::::::::::::::-:::::::::::::::::@-&&&&&&&&" + "&&&--:::::::-:::::::::::::::::::::::::::::-:::::::::::::::::@-:::::" + "::-:::::::::::::::::@-&&&&&&&&&&&--:::::::-::::::::::::::::::::::::" + ":::::-:::::::::::::::::@-&&&&&&&&&&&--:::::::-:::::::::::::::::::::" + "::::::::-:::::::::::::::::@-&&&&&&&--:::::::-::::::::::::::::::::::" + ":::::::-:::::::::::::::::@-&&&&&&&&&&&--:::::::-:::::::::::::::::::" + "::::::::::-:::::::::::::::::@-&&&&&::::::::::::-:::::::::::::::::@-" + "&&&&&&&&&&&--:::::::-:::::::::::::::::::::::::::::-::::::::::::::::" + ":@-&&&&&&&&&&&--:::::::-:::::::::::::::::::::::::::::-:::::::::::::" + "::::@-&&&&&&&&&&&--:::::::-:::::::::::::::::::::::::::::-::::::@-&&" + "&&&&&&&&&--:::::::-:::::::::::::::::::::::::::::-:::::::::::::::::@" + "::::::-:::::::::::::::::::::::::::::-:::::::::::::::::@-&&&&&&&&&&&" + "--:::::::-:::::::::::::::::::::::::::::-:::::::::::::::::@-&&&&&&&&" + "&&&--:::::::-:::::::::::::::::::::::::::::-:::::::::::::::::@-&&&&&" + "&&&&&&--:::::::-:::::::::::::::::::::::::::::-:::::::::::::::::@-&&" + "&&&&&&&&&--:::::::-:::::::::::::::::::::::::::::-:::::::::::::::::@" + "-&&&&&&&&&&&--:::::::-:::::::::::::::::::::::::::::-:::::::::::::::" + "::@-&&&&&&&&&&&--:::::::-:::::::::::::::::::::::::::::-::::::::::::" + ":::::@-&&&&&&&&&&&::-:::::::::::::::::@-&&&&&&&&&&&--:::::::-::::::" + ":::::::::::::::::::::::-:::::::::::::::::@-&&&&&&&&&&&--:::::::-:::" + "::::::::::::::::::::::::::-:::::::::::::::::@-&&&&&&&&&&&--:::::::-" + ":::::::::::::::::::::::::::::-:::::::::::::::::@-&&&&&&&&&&&---&&:&" + "&&.0------------:-:::::::::::::::::::::::::::::-:::::::::::::::::@-" + "&&&&&&&&&&&--:::::::-:::::::::::::::::::::::::::::-::::::::::::::::" + ":@-&&&&&&&&&&&--:::::::-:::::::::::::::::::::::::::::-:::::::::::::" + "::::@-&&&&&&&&&&&---&&:&&&.0------------O--------\rH PUTHTTP/1.1\r\n" + "&&&%%%"); +} + +TEST(ServerRequestParsingTest, ExcessiveWhitespaceInUnparseableHeaderLine) { + // Make sure this doesn't crash the server. + // In a previous version of the header line regex, the "\r" rendered the line + // unparseable and the regex engine repeatedly backtracked, trying to look for + // a new position where the leading white space ended and the field value + // began. + // The crash occurs with libc++ but not libstdc++. + test_raw_request("GET /hi HTTP/1.1\r\n" + "a:" + + std::string(2000, ' ') + '\r' + std::string(20, 'z') + + "\r\n" + "\r\n"); +} + +TEST(ServerRequestParsingTest, InvalidFirstChunkLengthInRequest) { + std::string out; + + test_raw_request("PUT /put_hi HTTP/1.1\r\n" + "Content-Type: text/plain\r\n" + "Transfer-Encoding: chunked\r\n" + "\r\n" + "nothex\r\n", + &out); + EXPECT_EQ("HTTP/1.1 400 Bad Request", out.substr(0, 24)); +} + +TEST(ServerRequestParsingTest, InvalidSecondChunkLengthInRequest) { + std::string out; + + test_raw_request("PUT /put_hi HTTP/1.1\r\n" + "Content-Type: text/plain\r\n" + "Transfer-Encoding: chunked\r\n" + "\r\n" + "3\r\n" + "xyz\r\n" + "NaN\r\n", + &out); + EXPECT_EQ("HTTP/1.1 400 Bad Request", out.substr(0, 24)); +} + +TEST(ServerRequestParsingTest, ChunkLengthTooHighInRequest) { + std::string out; + + test_raw_request("PUT /put_hi HTTP/1.1\r\n" + "Content-Type: text/plain\r\n" + "Transfer-Encoding: chunked\r\n" + "\r\n" + // Length is too large for 64 bits. + "1ffffffffffffffff\r\n" + "xyz\r\n", + &out); + EXPECT_EQ("HTTP/1.1 400 Bad Request", out.substr(0, 24)); +} + +TEST(ServerRequestParsingTest, InvalidHeaderTextWithExtraCR) { + test_raw_request("GET /hi HTTP/1.1\r\n" + "Content-Type: text/plain\r\n\r"); +} + +TEST(ServerRequestParsingTest, InvalidSpaceInURL) { + std::string out; + test_raw_request("GET /h i HTTP/1.1\r\n\r\n", &out); + EXPECT_EQ("HTTP/1.1 400 Bad Request", out.substr(0, 24)); +} + +TEST(ServerStopTest, StopServerWithChunkedTransmission) { + Server svr; + + svr.Get("/events", [](const Request & /*req*/, Response &res) { + res.set_header("Cache-Control", "no-cache"); + res.set_chunked_content_provider("text/event-stream", [](size_t offset, + DataSink &sink) { + char buffer[27]; + auto size = static_cast<size_t>(sprintf(buffer, "data:%ld\n\n", offset)); + auto ret = sink.write(buffer, size); + EXPECT_TRUE(ret); + std::this_thread::sleep_for(std::chrono::seconds(1)); + return true; + }); + }); + + auto listen_thread = std::thread([&svr]() { svr.listen("localhost", PORT); }); + while (!svr.is_running()) { + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + } + + Client client(HOST, PORT); + const Headers headers = {{"Accept", "text/event-stream"}}; + + auto get_thread = std::thread([&client, &headers]() { + auto res = client.Get( + "/events", headers, + [](const char * /*data*/, size_t /*len*/) -> bool { return true; }); + }); + + // Give GET time to get a few messages. + std::this_thread::sleep_for(std::chrono::seconds(2)); + + svr.stop(); + + listen_thread.join(); + get_thread.join(); + + ASSERT_FALSE(svr.is_running()); +} + +TEST(StreamingTest, NoContentLengthStreaming) { + Server svr; + + svr.Get("/stream", [](const Request & /*req*/, Response &res) { + res.set_content_provider("text/plain", [](size_t offset, DataSink &sink) { + if (offset < 6) { + sink.os << (offset < 3 ? "a" : "b"); + } else { + sink.done(); + } + return true; + }); + }); + + auto listen_thread = std::thread([&svr]() { svr.listen("localhost", PORT); }); + while (!svr.is_running()) { + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + } + + Client client(HOST, PORT); + + auto get_thread = std::thread([&client]() { + auto res = client.Get("/stream", [](const char *data, size_t len) -> bool { + EXPECT_EQ("aaabbb", std::string(data, len)); + return true; + }); + }); + + // Give GET time to get a few messages. + std::this_thread::sleep_for(std::chrono::milliseconds(500)); + + svr.stop(); + + listen_thread.join(); + get_thread.join(); + + ASSERT_FALSE(svr.is_running()); +} + +TEST(MountTest, Unmount) { + Server svr; + + auto listen_thread = std::thread([&svr]() { svr.listen("localhost", PORT); }); + while (!svr.is_running()) { + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + } + + // Give GET time to get a few messages. + std::this_thread::sleep_for(std::chrono::seconds(1)); + + Client cli("localhost", PORT); + + svr.set_mount_point("/mount2", "./www2"); + + auto res = cli.Get("/"); + ASSERT_TRUE(res); + EXPECT_EQ(404, res->status); + + res = cli.Get("/mount2/dir/test.html"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + + svr.set_mount_point("/", "./www"); + + res = cli.Get("/dir/"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + + svr.remove_mount_point("/"); + res = cli.Get("/dir/"); + ASSERT_TRUE(res); + EXPECT_EQ(404, res->status); + + svr.remove_mount_point("/mount2"); + res = cli.Get("/mount2/dir/test.html"); + ASSERT_TRUE(res); + EXPECT_EQ(404, res->status); + + svr.stop(); + listen_thread.join(); + ASSERT_FALSE(svr.is_running()); +} + +TEST(ExceptionTest, ThrowExceptionInHandler) { + Server svr; + + svr.Get("/hi", [&](const Request & /*req*/, Response & /*res*/) { + throw std::runtime_error("exception..."); + // res.set_content("Hello World!", "text/plain"); + }); + + auto listen_thread = std::thread([&svr]() { svr.listen("localhost", PORT); }); + while (!svr.is_running()) { + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + } + + // Give GET time to get a few messages. + std::this_thread::sleep_for(std::chrono::seconds(1)); + + Client cli("localhost", PORT); + + auto res = cli.Get("/hi"); + ASSERT_TRUE(res); + EXPECT_EQ(500, res->status); + ASSERT_TRUE(res->has_header("EXCEPTION_WHAT")); + EXPECT_EQ("exception...", res->get_header_value("EXCEPTION_WHAT")); + + svr.stop(); + listen_thread.join(); + ASSERT_FALSE(svr.is_running()); +} + +TEST(KeepAliveTest, ReadTimeout) { + Server svr; + + svr.Get("/a", [&](const Request & /*req*/, Response &res) { + std::this_thread::sleep_for(std::chrono::seconds(2)); + res.set_content("a", "text/plain"); + }); + + svr.Get("/b", [&](const Request & /*req*/, Response &res) { + res.set_content("b", "text/plain"); + }); + + auto listen_thread = std::thread([&svr]() { svr.listen("localhost", PORT); }); + while (!svr.is_running()) { + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + } + + // Give GET time to get a few messages. + std::this_thread::sleep_for(std::chrono::seconds(1)); + + Client cli("localhost", PORT); + cli.set_keep_alive(true); + cli.set_read_timeout(std::chrono::seconds(1)); + + auto resa = cli.Get("/a"); + ASSERT_TRUE(!resa); + EXPECT_EQ(Error::Read, resa.error()); + + auto resb = cli.Get("/b"); + ASSERT_TRUE(resb); + EXPECT_EQ(200, resb->status); + EXPECT_EQ("b", resb->body); + + svr.stop(); + listen_thread.join(); + ASSERT_FALSE(svr.is_running()); +} + +TEST(ErrorHandlerWithContentProviderTest, ErrorHandler) { + Server svr; + + svr.set_error_handler([](Request const &, Response &res) -> void { + res.set_chunked_content_provider( + "text/plain", [](std::size_t const, DataSink &sink) -> bool { + sink.os << "hello"; + sink.os << "world"; + sink.done(); + return true; + }); + }); + + auto listen_thread = std::thread([&svr]() { svr.listen("localhost", PORT); }); + while (!svr.is_running()) { + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + } + + // Give GET time to get a few messages. + std::this_thread::sleep_for(std::chrono::seconds(1)); + + Client cli("localhost", PORT); + + auto res = cli.Get("/"); + ASSERT_TRUE(res); + EXPECT_EQ(404, res->status); + EXPECT_EQ("helloworld", res->body); + + svr.stop(); + listen_thread.join(); + ASSERT_FALSE(svr.is_running()); +} + +TEST(GetWithParametersTest, GetWithParameters) { + Server svr; + + svr.Get("/", [&](const Request &req, Response &res) { + auto text = req.get_param_value("hello"); + res.set_content(text, "text/plain"); + }); + + auto listen_thread = std::thread([&svr]() { svr.listen("localhost", PORT); }); + while (!svr.is_running()) { + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + } + std::this_thread::sleep_for(std::chrono::seconds(1)); + + Client cli("localhost", PORT); + + Params params; + params.emplace("hello", "world"); + auto res = cli.Get("/", params, Headers{}); + + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("world", res->body); + + svr.stop(); + listen_thread.join(); + ASSERT_FALSE(svr.is_running()); +} + +TEST(GetWithParametersTest, GetWithParameters2) { + Server svr; + + svr.Get("/", [&](const Request &req, Response &res) { + auto text = req.get_param_value("hello"); + res.set_content(text, "text/plain"); + }); + + auto listen_thread = std::thread([&svr]() { svr.listen("localhost", PORT); }); + while (!svr.is_running()) { + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + } + std::this_thread::sleep_for(std::chrono::seconds(1)); + + Client cli("localhost", PORT); + + Params params; + params.emplace("hello", "world"); + + std::string body; + auto res = cli.Get("/", params, Headers{}, + [&](const char *data, size_t data_length) { + body.append(data, data_length); + return true; + }); + + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("world", body); + + svr.stop(); + listen_thread.join(); + ASSERT_FALSE(svr.is_running()); +} + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +TEST(KeepAliveTest, ReadTimeoutSSL) { + SSLServer svr(SERVER_CERT_FILE, SERVER_PRIVATE_KEY_FILE); + ASSERT_TRUE(svr.is_valid()); + + svr.Get("/a", [&](const Request & /*req*/, Response &res) { + std::this_thread::sleep_for(std::chrono::seconds(2)); + res.set_content("a", "text/plain"); + }); + + svr.Get("/b", [&](const Request & /*req*/, Response &res) { + res.set_content("b", "text/plain"); + }); + + auto listen_thread = std::thread([&svr]() { svr.listen("localhost", PORT); }); + while (!svr.is_running()) { + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + } + + // Give GET time to get a few messages. + std::this_thread::sleep_for(std::chrono::seconds(1)); + + SSLClient cli("localhost", PORT); + cli.enable_server_certificate_verification(false); + cli.set_keep_alive(true); + cli.set_read_timeout(std::chrono::seconds(1)); + + auto resa = cli.Get("/a"); + ASSERT_TRUE(!resa); + EXPECT_EQ(Error::Read, resa.error()); + + auto resb = cli.Get("/b"); + ASSERT_TRUE(resb); + EXPECT_EQ(200, resb->status); + EXPECT_EQ("b", resb->body); + + svr.stop(); + listen_thread.join(); + ASSERT_FALSE(svr.is_running()); +} +#endif + +class ServerTestWithAI_PASSIVE : public ::testing::Test { +protected: + ServerTestWithAI_PASSIVE() + : cli_(HOST, PORT) +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + , + svr_(SERVER_CERT_FILE, SERVER_PRIVATE_KEY_FILE) +#endif + { +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + cli_.enable_server_certificate_verification(false); +#endif + } + + virtual void SetUp() { + svr_.Get("/hi", [&](const Request & /*req*/, Response &res) { + res.set_content("Hello World!", "text/plain"); + }); + + t_ = thread([&]() { ASSERT_TRUE(svr_.listen(nullptr, PORT, AI_PASSIVE)); }); + + while (!svr_.is_running()) { + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + } + } + + virtual void TearDown() { + svr_.stop(); + t_.join(); + } + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + SSLClient cli_; + SSLServer svr_; +#else + Client cli_; + Server svr_; +#endif + thread t_; +}; + +TEST_F(ServerTestWithAI_PASSIVE, GetMethod200) { + auto res = cli_.Get("/hi"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("text/plain", res->get_header_value("Content-Type")); + EXPECT_EQ("Hello World!", res->body); +} + +class ServerUpDownTest : public ::testing::Test { +protected: + ServerUpDownTest() : cli_(HOST, PORT) {} + + virtual void SetUp() { + t_ = thread([&]() { + svr_.bind_to_any_port(HOST); + std::this_thread::sleep_for(std::chrono::milliseconds(500)); + ASSERT_TRUE(svr_.listen_after_bind()); + }); + + while (!svr_.is_running()) { + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + } + } + + virtual void TearDown() { + svr_.stop(); + t_.join(); + } + + Client cli_; + Server svr_; + thread t_; +}; + +TEST_F(ServerUpDownTest, QuickStartStop) { + // Should not crash, especially when run with + // --gtest_filter=ServerUpDownTest.QuickStartStop --gtest_repeat=1000 +} + +class PayloadMaxLengthTest : public ::testing::Test { +protected: + PayloadMaxLengthTest() + : cli_(HOST, PORT) +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + , + svr_(SERVER_CERT_FILE, SERVER_PRIVATE_KEY_FILE) +#endif + { +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + cli_.enable_server_certificate_verification(false); +#endif + } + + virtual void SetUp() { + svr_.set_payload_max_length(8); + + svr_.Post("/test", [&](const Request & /*req*/, Response &res) { + res.set_content("test", "text/plain"); + }); + + t_ = thread([&]() { ASSERT_TRUE(svr_.listen(HOST, PORT)); }); + + while (!svr_.is_running()) { + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + } + } + + virtual void TearDown() { + svr_.stop(); + t_.join(); + } + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + SSLClient cli_; + SSLServer svr_; +#else + Client cli_; + Server svr_; +#endif + thread t_; +}; + +TEST_F(PayloadMaxLengthTest, ExceedLimit) { + auto res = cli_.Post("/test", "123456789", "text/plain"); + ASSERT_TRUE(res); + EXPECT_EQ(413, res->status); + + res = cli_.Post("/test", "12345678", "text/plain"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); +} + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +TEST(SSLClientTest, UpdateCAStore) { + httplib::SSLClient httplib_client("www.google.com"); + auto ca_store_1 = X509_STORE_new(); + X509_STORE_load_locations(ca_store_1, "/etc/ssl/certs/ca-certificates.crt", + nullptr); + httplib_client.set_ca_cert_store(ca_store_1); + + auto ca_store_2 = X509_STORE_new(); + X509_STORE_load_locations(ca_store_2, "/etc/ssl/certs/ca-certificates.crt", + nullptr); + httplib_client.set_ca_cert_store(ca_store_2); +} + +TEST(SSLClientTest, ServerNameIndication) { + SSLClient cli("httpbin.org", 443); + auto res = cli.Get("/get"); + ASSERT_TRUE(res); + ASSERT_EQ(200, res->status); +} + +TEST(SSLClientTest, ServerCertificateVerification1) { + SSLClient cli("google.com"); + auto res = cli.Get("/"); + ASSERT_TRUE(res); + ASSERT_EQ(301, res->status); +} + +TEST(SSLClientTest, ServerCertificateVerification2) { + SSLClient cli("google.com"); + cli.enable_server_certificate_verification(true); + cli.set_ca_cert_path("hello"); + auto res = cli.Get("/"); + ASSERT_TRUE(!res); + EXPECT_EQ(Error::SSLLoadingCerts, res.error()); +} + +TEST(SSLClientTest, ServerCertificateVerification3) { + SSLClient cli("google.com"); + cli.set_ca_cert_path(CA_CERT_FILE); + auto res = cli.Get("/"); + ASSERT_TRUE(res); + ASSERT_EQ(301, res->status); +} + +TEST(SSLClientTest, ServerCertificateVerification4) { + SSLServer svr(SERVER_CERT2_FILE, SERVER_PRIVATE_KEY_FILE); + ASSERT_TRUE(svr.is_valid()); + + svr.Get("/test", [&](const Request &, Response &res) { + res.set_content("test", "text/plain"); + svr.stop(); + ASSERT_TRUE(true); + }); + + thread t = thread([&]() { ASSERT_TRUE(svr.listen("127.0.0.1", PORT)); }); + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + + SSLClient cli("127.0.0.1", PORT); + cli.set_ca_cert_path(SERVER_CERT2_FILE); + cli.enable_server_certificate_verification(true); + cli.set_connection_timeout(30); + + auto res = cli.Get("/test"); + ASSERT_TRUE(res); + ASSERT_EQ(200, res->status); + + t.join(); +} + +TEST(SSLClientTest, WildcardHostNameMatch) { + SSLClient cli("www.youtube.com"); + + cli.set_ca_cert_path(CA_CERT_FILE); + cli.enable_server_certificate_verification(true); + cli.set_follow_location(true); + + auto res = cli.Get("/"); + ASSERT_TRUE(res); + ASSERT_EQ(200, res->status); +} + +TEST(SSLClientServerTest, ClientCertPresent) { + SSLServer svr(SERVER_CERT_FILE, SERVER_PRIVATE_KEY_FILE, CLIENT_CA_CERT_FILE, + CLIENT_CA_CERT_DIR); + ASSERT_TRUE(svr.is_valid()); + + svr.Get("/test", [&](const Request &req, Response &res) { + res.set_content("test", "text/plain"); + svr.stop(); + ASSERT_TRUE(true); + + auto peer_cert = SSL_get_peer_certificate(req.ssl); + ASSERT_TRUE(peer_cert != nullptr); + + auto subject_name = X509_get_subject_name(peer_cert); + ASSERT_TRUE(subject_name != nullptr); + + std::string common_name; + { + char name[BUFSIZ]; + auto name_len = X509_NAME_get_text_by_NID(subject_name, NID_commonName, + name, sizeof(name)); + common_name.assign(name, static_cast<size_t>(name_len)); + } + + EXPECT_EQ("Common Name", common_name); + + X509_free(peer_cert); + }); + + thread t = thread([&]() { ASSERT_TRUE(svr.listen(HOST, PORT)); }); + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + + SSLClient cli(HOST, PORT, CLIENT_CERT_FILE, CLIENT_PRIVATE_KEY_FILE); + cli.enable_server_certificate_verification(false); + cli.set_connection_timeout(30); + + auto res = cli.Get("/test"); + ASSERT_TRUE(res); + ASSERT_EQ(200, res->status); + + t.join(); +} + +#if !defined(_WIN32) || defined(OPENSSL_USE_APPLINK) +TEST(SSLClientServerTest, MemoryClientCertPresent) { + X509 *server_cert; + EVP_PKEY *server_private_key; + X509_STORE *client_ca_cert_store; + X509 *client_cert; + EVP_PKEY *client_private_key; + + FILE *f = fopen(SERVER_CERT_FILE, "r+"); + server_cert = PEM_read_X509(f, nullptr, nullptr, nullptr); + fclose(f); + + f = fopen(SERVER_PRIVATE_KEY_FILE, "r+"); + server_private_key = PEM_read_PrivateKey(f, nullptr, nullptr, nullptr); + fclose(f); + + f = fopen(CLIENT_CA_CERT_FILE, "r+"); + client_cert = PEM_read_X509(f, nullptr, nullptr, nullptr); + client_ca_cert_store = X509_STORE_new(); + X509_STORE_add_cert(client_ca_cert_store, client_cert); + X509_free(client_cert); + fclose(f); + + f = fopen(CLIENT_CERT_FILE, "r+"); + client_cert = PEM_read_X509(f, nullptr, nullptr, nullptr); + fclose(f); + + f = fopen(CLIENT_PRIVATE_KEY_FILE, "r+"); + client_private_key = PEM_read_PrivateKey(f, nullptr, nullptr, nullptr); + fclose(f); + + SSLServer svr(server_cert, server_private_key, client_ca_cert_store); + ASSERT_TRUE(svr.is_valid()); + + svr.Get("/test", [&](const Request &req, Response &res) { + res.set_content("test", "text/plain"); + svr.stop(); + ASSERT_TRUE(true); + + auto peer_cert = SSL_get_peer_certificate(req.ssl); + ASSERT_TRUE(peer_cert != nullptr); + + auto subject_name = X509_get_subject_name(peer_cert); + ASSERT_TRUE(subject_name != nullptr); + + std::string common_name; + { + char name[BUFSIZ]; + auto name_len = X509_NAME_get_text_by_NID(subject_name, NID_commonName, + name, sizeof(name)); + common_name.assign(name, static_cast<size_t>(name_len)); + } + + EXPECT_EQ("Common Name", common_name); + + X509_free(peer_cert); + }); + + thread t = thread([&]() { ASSERT_TRUE(svr.listen(HOST, PORT)); }); + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + + SSLClient cli(HOST, PORT, client_cert, client_private_key); + cli.enable_server_certificate_verification(false); + cli.set_connection_timeout(30); + + auto res = cli.Get("/test"); + ASSERT_TRUE(res); + ASSERT_EQ(200, res->status); + + X509_free(server_cert); + EVP_PKEY_free(server_private_key); + X509_free(client_cert); + EVP_PKEY_free(client_private_key); + + t.join(); +} +#endif + +TEST(SSLClientServerTest, ClientCertMissing) { + SSLServer svr(SERVER_CERT_FILE, SERVER_PRIVATE_KEY_FILE, CLIENT_CA_CERT_FILE, + CLIENT_CA_CERT_DIR); + ASSERT_TRUE(svr.is_valid()); + + svr.Get("/test", [&](const Request &, Response &) { ASSERT_TRUE(false); }); + + thread t = thread([&]() { ASSERT_TRUE(svr.listen(HOST, PORT)); }); + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + + SSLClient cli(HOST, PORT); + auto res = cli.Get("/test"); + cli.set_connection_timeout(30); + ASSERT_TRUE(!res); + EXPECT_EQ(Error::SSLServerVerification, res.error()); + + svr.stop(); + + t.join(); +} + +TEST(SSLClientServerTest, TrustDirOptional) { + SSLServer svr(SERVER_CERT_FILE, SERVER_PRIVATE_KEY_FILE, CLIENT_CA_CERT_FILE); + ASSERT_TRUE(svr.is_valid()); + + svr.Get("/test", [&](const Request &, Response &res) { + res.set_content("test", "text/plain"); + svr.stop(); + }); + + thread t = thread([&]() { ASSERT_TRUE(svr.listen(HOST, PORT)); }); + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + + SSLClient cli(HOST, PORT, CLIENT_CERT_FILE, CLIENT_PRIVATE_KEY_FILE); + cli.enable_server_certificate_verification(false); + cli.set_connection_timeout(30); + + auto res = cli.Get("/test"); + ASSERT_TRUE(res); + ASSERT_EQ(200, res->status); + + t.join(); +} + +TEST(SSLClientServerTest, SSLConnectTimeout) { + class NoListenSSLServer : public SSLServer { + public: + NoListenSSLServer(const char *cert_path, const char *private_key_path, + const char *client_ca_cert_file_path, + const char *client_ca_cert_dir_path = nullptr) + : SSLServer(cert_path, private_key_path, client_ca_cert_file_path, + client_ca_cert_dir_path), + stop_(false) {} + + bool stop_; + + private: + bool process_and_close_socket(socket_t /*sock*/) override { + // Don't create SSL context + while (!stop_) { + std::this_thread::sleep_for(std::chrono::milliseconds(100)); + } + return true; + } + }; + NoListenSSLServer svr(SERVER_CERT_FILE, SERVER_PRIVATE_KEY_FILE, + CLIENT_CA_CERT_FILE); + ASSERT_TRUE(svr.is_valid()); + + svr.Get("/test", [&](const Request &, Response &res) { + res.set_content("test", "text/plain"); + }); + + thread t = thread([&]() { ASSERT_TRUE(svr.listen(HOST, PORT)); }); + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + + SSLClient cli(HOST, PORT, CLIENT_CERT_FILE, CLIENT_PRIVATE_KEY_FILE); + cli.enable_server_certificate_verification(false); + cli.set_connection_timeout(1); + + auto res = cli.Get("/test"); + ASSERT_TRUE(!res); + EXPECT_EQ(Error::SSLConnection, res.error()); + + svr.stop_ = true; + svr.stop(); + t.join(); +} +#endif + +#ifdef _WIN32 +TEST(CleanupTest, WSACleanup) { + int ret = WSACleanup(); + ASSERT_EQ(0, ret); +} +#endif + +#ifndef CPPHTTPLIB_OPENSSL_SUPPORT +TEST(NoSSLSupport, SimpleInterface) { + ASSERT_ANY_THROW(Client cli("https://yahoo.com")); +} +#endif + +TEST(InvalidScheme, SimpleInterface) { + ASSERT_ANY_THROW(Client cli("scheme://yahoo.com")); +} + +TEST(NoScheme, SimpleInterface) { + Client cli("yahoo.com:80"); + ASSERT_TRUE(cli.is_valid()); +} + +TEST(SendAPI, SimpleInterface) { + Client cli("http://yahoo.com"); + + Request req; + req.method = "GET"; + req.path = "/"; + auto res = cli.send(req); + + ASSERT_TRUE(res); + EXPECT_EQ(301, res->status); +} + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +TEST(YahooRedirectTest2, SimpleInterface) { + Client cli("http://yahoo.com"); + + auto res = cli.Get("/"); + ASSERT_TRUE(res); + EXPECT_EQ(301, res->status); + + cli.set_follow_location(true); + res = cli.Get("/"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("https://yahoo.com/", res->location); +} + +TEST(YahooRedirectTest3, SimpleInterface) { + Client cli("https://yahoo.com"); + + auto res = cli.Get("/"); + ASSERT_TRUE(res); + EXPECT_EQ(301, res->status); + + cli.set_follow_location(true); + res = cli.Get("/"); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ("https://www.yahoo.com/", res->location); +} + +TEST(YahooRedirectTest3, NewResultInterface) { + Client cli("https://yahoo.com"); + + auto res = cli.Get("/"); + ASSERT_TRUE(res); + ASSERT_FALSE(!res); + ASSERT_TRUE(res); + ASSERT_FALSE(res == nullptr); + ASSERT_TRUE(res != nullptr); + EXPECT_EQ(Error::Success, res.error()); + EXPECT_EQ(301, res.value().status); + EXPECT_EQ(301, (*res).status); + EXPECT_EQ(301, res->status); + + cli.set_follow_location(true); + res = cli.Get("/"); + ASSERT_TRUE(res); + EXPECT_EQ(Error::Success, res.error()); + EXPECT_EQ(200, res.value().status); + EXPECT_EQ(200, (*res).status); + EXPECT_EQ(200, res->status); + EXPECT_EQ("https://www.yahoo.com/", res->location); +} + +#ifdef CPPHTTPLIB_BROTLI_SUPPORT +TEST(DecodeWithChunkedEncoding, BrotliEncoding) { + Client cli("https://cdnjs.cloudflare.com"); + auto res = + cli.Get("/ajax/libs/jquery/3.5.1/jquery.js", {{"Accept-Encoding", "br"}}); + + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); + EXPECT_EQ(287630, res->body.size()); + EXPECT_EQ("application/javascript; charset=utf-8", + res->get_header_value("Content-Type")); +} +#endif + +TEST(HttpsToHttpRedirectTest, SimpleInterface) { + Client cli("https://nghttp2.org"); + cli.set_follow_location(true); + auto res = + cli.Get("/httpbin/" + "redirect-to?url=http%3A%2F%2Fwww.google.com&status_code=302"); + + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); +} + +TEST(HttpsToHttpRedirectTest2, SimpleInterface) { + Client cli("https://nghttp2.org"); + cli.set_follow_location(true); + + Params params; + params.emplace("url", "http://www.google.com"); + params.emplace("status_code", "302"); + + auto res = cli.Get("/httpbin/redirect-to", params, Headers{}); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); +} + +TEST(HttpsToHttpRedirectTest3, SimpleInterface) { + Client cli("https://nghttp2.org"); + cli.set_follow_location(true); + + Params params; + params.emplace("url", "http://www.google.com"); + + auto res = cli.Get("/httpbin/redirect-to?status_code=302", params, Headers{}); + ASSERT_TRUE(res); + EXPECT_EQ(200, res->status); +} +#endif |