lib/cpp-httplib
1
0
Fork 0
mirror of synced 2025-07-17 17:40:57 +03:00
Code Activity

Fix #1578 (#2171)

Browse Source 
* Fix #1578

* Update README

* Update

* Update

* Update

* Update

* Update

* Update
This commit is contained in:
yhirose
2025-07-06 21:27:24 -04:00
committed by GitHub
parent a3f5569196
commit af73377611
5 changed files with 620 additions and 465 deletions
Download Patch File Download Diff File Expand all files Collapse all files

561
test/test.cc
View File

@ -55,15 +55,14 @@ 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; });
FormData &get_file_value(std::vector<FormData> &items, const char *key) {
auto it = std::find_if(items.begin(), items.end(), [&](const FormData &file) {
return file.name == key;
});
#ifdef CPPHTTPLIB_NO_EXCEPTIONS
return *it;
#else
if (it != files.end()) { return *it; }
if (it != items.end()) { return *it; }
throw std::runtime_error("invalid multipart form data name error");
#endif
}
@ -3176,65 +3175,72 @@ protected:
})
.Post("/multipart",
[&](const Request &req, Response & /*res*/) {
EXPECT_EQ(6u, req.files.size());
ASSERT_TRUE(!req.has_file("???"));
EXPECT_EQ(4u, req.form.get_field_count("text1") +
req.form.get_field_count("text2") +
req.form.get_field_count("file3") +
req.form.get_field_count("file4"));
EXPECT_EQ(2u, req.form.get_file_count("file1") +
req.form.get_file_count("file2"));
ASSERT_TRUE(!req.form.has_file("???"));
ASSERT_TRUE(!req.form.has_field("???"));
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 &text = req.form.get_field("text1");
EXPECT_EQ("text default", text);
}
{
const auto &file = req.get_file_value("text2");
EXPECT_TRUE(file.filename.empty());
EXPECT_EQ("aωb", file.content);
const auto &text = req.form.get_field("text2");
EXPECT_EQ("aωb", text);
}
{
const auto &file = req.get_file_value("file1");
const auto &file = req.form.get_file("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.form.get_file("file2");
EXPECT_EQ("world.json", file.filename);
EXPECT_EQ("application/json", file.content_type);
EXPECT_EQ("{\n \"world\", true\n}\n", file.content);
}
{
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);
const auto &text = req.form.get_field("file3");
EXPECT_EQ(0u, text.size());
}
{
const auto &text = req.form.get_field("file4");
EXPECT_EQ(0u, text.size());
}
})
.Post("/multipart/multi_file_values",
[&](const Request &req, Response & /*res*/) {
EXPECT_EQ(5u, req.files.size());
ASSERT_TRUE(!req.has_file("???"));
EXPECT_EQ(3u, req.form.get_field_count("text") +
req.form.get_field_count("multi_text1"));
EXPECT_EQ(2u, req.form.get_file_count("multi_file1"));
ASSERT_TRUE(!req.form.has_file("???"));
ASSERT_TRUE(!req.form.has_field("???"));
ASSERT_TRUE(req.body.empty());
{
const auto &text_value = req.get_file_values("text");
EXPECT_EQ(1u, text_value.size());
auto &text = text_value[0];
EXPECT_TRUE(text.filename.empty());
EXPECT_EQ("default text", text.content);
const auto &text = req.form.get_field("text");
EXPECT_EQ("default text", text);
}
{
const auto &text1_values = req.get_file_values("multi_text1");
const auto &text1_values = req.form.get_fields("multi_text1");
EXPECT_EQ(2u, text1_values.size());
EXPECT_EQ("aaaaa", text1_values[0].content);
EXPECT_EQ("bbbbb", text1_values[1].content);
EXPECT_EQ("aaaaa", text1_values[0]);
EXPECT_EQ("bbbbb", text1_values[1]);
}
{
const auto &file1_values = req.get_file_values("multi_file1");
const auto &file1_values = req.form.get_files("multi_file1");
EXPECT_EQ(2u, file1_values.size());
auto file1 = file1_values[0];
EXPECT_EQ(file1.filename, "hello.txt");
@ -3349,40 +3355,47 @@ protected:
[&](const Request &req, Response &res,
const ContentReader &content_reader) {
if (req.is_multipart_form_data()) {
MultipartFormDataItems files;
std::vector<FormData> items;
content_reader(
[&](const MultipartFormData &file) {
files.push_back(file);
[&](const FormData &file) {
items.push_back(file);
return true;
},
[&](const char *data, size_t data_length) {
files.back().content.append(data, data_length);
items.back().content.append(data, data_length);
return true;
});
EXPECT_EQ(5u, files.size());
EXPECT_EQ(5u, items.size());
{
const auto &file = get_file_value(files, "text1");
const auto &file = get_file_value(items, "text1");
EXPECT_TRUE(file.filename.empty());
EXPECT_EQ("text default", file.content);
}
{
const auto &file = get_file_value(files, "text2");
const auto &file = get_file_value(items, "text2");
EXPECT_TRUE(file.filename.empty());
EXPECT_EQ("aωb", file.content);
}
{
const auto &file = get_file_value(files, "file1");
const auto &file = get_file_value(items, "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");
const auto &file = get_file_value(items, "file2");
EXPECT_EQ("world.json", file.filename);
EXPECT_EQ("application/json", file.content_type);
EXPECT_EQ(R"({\n "world": true\n}\n)", file.content);
}
{
const auto &file = get_file_value(items, "file3");
EXPECT_TRUE(file.filename.empty());
EXPECT_EQ("application/octet-stream", file.content_type);
EXPECT_EQ(0u, file.content.size());
@ -3496,19 +3509,17 @@ protected:
})
.Post("/compress-multipart",
[&](const Request &req, Response & /*res*/) {
EXPECT_EQ(2u, req.files.size());
ASSERT_TRUE(!req.has_file("???"));
EXPECT_EQ(2u, req.form.fields.size());
ASSERT_TRUE(!req.form.has_field("???"));
{
const auto &file = req.get_file_value("key1");
EXPECT_TRUE(file.filename.empty());
EXPECT_EQ("test", file.content);
const auto &text = req.form.get_field("key1");
EXPECT_EQ("test", text);
}
{
const auto &file = req.get_file_value("key2");
EXPECT_TRUE(file.filename.empty());
EXPECT_EQ("--abcdefg123", file.content);
const auto &text = req.form.get_field("key2");
EXPECT_EQ("--abcdefg123", text);
}
})
#endif
@ -4431,7 +4442,7 @@ TEST_F(ServerTest, HeaderCountSecurityTest) {
}
TEST_F(ServerTest, MultipartFormData) {
MultipartFormDataItemsForClientInput items = {
UploadFormDataItems items = {
{"text1", "text default", "", ""},
{"text2", "aωb", "", ""},
{"file1", "h\ne\n\nl\nl\no\n", "hello.txt", "text/plain"},
@ -4446,7 +4457,7 @@ TEST_F(ServerTest, MultipartFormData) {
}
TEST_F(ServerTest, MultipartFormDataMultiFileValues) {
MultipartFormDataItemsForClientInput items = {
UploadFormDataItems items = {
{"text", "default text", "", ""},
{"multi_text1", "aaaaa", "", ""},
@ -5386,11 +5397,11 @@ TEST_F(ServerTest, PostContentReceiver) {
}
TEST_F(ServerTest, PostMultipartFileContentReceiver) {
MultipartFormDataItemsForClientInput items = {
UploadFormDataItems 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"},
{"file2", R"({\n "world": true\n}\n)", "world.json", "application/json"},
{"file3", "", "", "application/octet-stream"},
};
@ -5401,11 +5412,11 @@ TEST_F(ServerTest, PostMultipartFileContentReceiver) {
}
TEST_F(ServerTest, PostMultipartPlusBoundary) {
MultipartFormDataItemsForClientInput items = {
UploadFormDataItems 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"},
{"file2", R"({\n "world": true\n}\n)", "world.json", "application/json"},
{"file3", "", "", "application/octet-stream"},
};
@ -5860,7 +5871,7 @@ TEST_F(ServerTest, NoGzipWithContentReceiver) {
}
TEST_F(ServerTest, MultipartFormDataGzip) {
MultipartFormDataItemsForClientInput items = {
UploadFormDataItems items = {
{"key1", "test", "", ""},
{"key2", "--abcdefg123", "", ""},
};
@ -6024,7 +6035,7 @@ TEST_F(ServerTest, NoZstdWithContentReceiver) {
// TODO: How to enable zstd ??
TEST_F(ServerTest, MultipartFormDataZstd) {
MultipartFormDataItemsForClientInput items = {
UploadFormDataItems items = {
{"key1", "test", "", ""},
{"key2", "--abcdefg123", "", ""},
};
@ -6059,135 +6070,153 @@ TEST_F(ServerTest, PutWithContentProviderWithZstd) {
// Pre-compression logging tests
TEST_F(ServerTest, PreCompressionLogging) {
// Test data for compression (matches the actual /compress endpoint content)
const std::string test_content = "1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890";
const std::string test_content =
"123456789012345678901234567890123456789012345678901234567890123456789012"
"3456789012345678901234567890";
// Variables to capture logging data
std::string pre_compression_body;
std::string pre_compression_content_type;
std::string pre_compression_content_encoding;
std::string post_compression_body;
std::string post_compression_content_type;
std::string post_compression_content_encoding;
// Set up pre-compression logger
svr_.set_pre_compression_logger([&](const Request &req, const Response &res) {
svr_.set_pre_compression_logger([&](const Request & /*req*/,
const Response &res) {
pre_compression_body = res.body;
pre_compression_content_type = res.get_header_value("Content-Type");
pre_compression_content_encoding = res.get_header_value("Content-Encoding");
});
// Set up post-compression logger
svr_.set_logger([&](const Request &req, const Response &res) {
svr_.set_logger([&](const Request & /*req*/, const Response &res) {
post_compression_body = res.body;
post_compression_content_type = res.get_header_value("Content-Type");
post_compression_content_encoding = res.get_header_value("Content-Encoding");
post_compression_content_encoding =
res.get_header_value("Content-Encoding");
});
// Test with gzip compression
Headers headers;
headers.emplace("Accept-Encoding", "gzip");
auto res = cli_.Get("/compress", headers);
// Verify response was compressed
ASSERT_TRUE(res);
EXPECT_EQ(StatusCode::OK_200, res->status);
EXPECT_EQ("gzip", res->get_header_value("Content-Encoding"));
// Verify pre-compression logger captured uncompressed content
EXPECT_EQ(test_content, pre_compression_body);
EXPECT_EQ("text/plain", pre_compression_content_type);
EXPECT_TRUE(pre_compression_content_encoding.empty()); // No encoding header before compression
EXPECT_TRUE(pre_compression_content_encoding
.empty()); // No encoding header before compression
// Verify post-compression logger captured compressed content
EXPECT_NE(test_content, post_compression_body); // Should be different after compression
EXPECT_NE(test_content,
post_compression_body); // Should be different after compression
EXPECT_EQ("text/plain", post_compression_content_type);
EXPECT_EQ("gzip", post_compression_content_encoding);
// Verify compressed content is smaller
EXPECT_LT(post_compression_body.size(), pre_compression_body.size());
}
TEST_F(ServerTest, PreCompressionLoggingWithBrotli) {
const std::string test_content = "1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890";
const std::string test_content =
"123456789012345678901234567890123456789012345678901234567890123456789012"
"3456789012345678901234567890";
std::string pre_compression_body;
std::string post_compression_body;
svr_.set_pre_compression_logger([&](const Request &req, const Response &res) {
pre_compression_body = res.body;
});
svr_.set_logger([&](const Request &req, const Response &res) {
svr_.set_pre_compression_logger(
[&](const Request & /*req*/, const Response &res) {
pre_compression_body = res.body;
});
svr_.set_logger([&](const Request & /*req*/, const Response &res) {
post_compression_body = res.body;
});
Headers headers;
headers.emplace("Accept-Encoding", "br");
auto res = cli_.Get("/compress", headers);
ASSERT_TRUE(res);
EXPECT_EQ(StatusCode::OK_200, res->status);
EXPECT_EQ("br", res->get_header_value("Content-Encoding"));
// Verify pre-compression content is uncompressed
EXPECT_EQ(test_content, pre_compression_body);
// Verify post-compression content is compressed
EXPECT_NE(test_content, post_compression_body);
EXPECT_LT(post_compression_body.size(), pre_compression_body.size());
}
TEST_F(ServerTest, PreCompressionLoggingWithoutCompression) {
const std::string test_content = "1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890";
const std::string test_content =
"123456789012345678901234567890123456789012345678901234567890123456789012"
"3456789012345678901234567890";
std::string pre_compression_body;
std::string post_compression_body;
svr_.set_pre_compression_logger([&](const Request &req, const Response &res) {
pre_compression_body = res.body;
});
svr_.set_logger([&](const Request &req, const Response &res) {
svr_.set_pre_compression_logger(
[&](const Request & /*req*/, const Response &res) {
pre_compression_body = res.body;
});
svr_.set_logger([&](const Request & /*req*/, const Response &res) {
post_compression_body = res.body;
});
// Request without compression (use /nocompress endpoint)
Headers headers;
auto res = cli_.Get("/nocompress", headers);
ASSERT_TRUE(res);
EXPECT_EQ(StatusCode::OK_200, res->status);
EXPECT_TRUE(res->get_header_value("Content-Encoding").empty());
// Pre-compression logger should not be called when no compression is applied
EXPECT_TRUE(pre_compression_body.empty()); // Pre-compression logger not called
EXPECT_EQ(test_content, post_compression_body); // Post-compression logger captures final content
EXPECT_TRUE(
pre_compression_body.empty()); // Pre-compression logger not called
EXPECT_EQ(
test_content,
post_compression_body); // Post-compression logger captures final content
}
TEST_F(ServerTest, PreCompressionLoggingOnlyPreLogger) {
const std::string test_content = "1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890";
const std::string test_content =
"123456789012345678901234567890123456789012345678901234567890123456789012"
"3456789012345678901234567890";
std::string pre_compression_body;
bool pre_logger_called = false;
// Set only pre-compression logger
svr_.set_pre_compression_logger([&](const Request &req, const Response &res) {
pre_compression_body = res.body;
pre_logger_called = true;
});
svr_.set_pre_compression_logger(
[&](const Request & /*req*/, const Response &res) {
pre_compression_body = res.body;
pre_logger_called = true;
});
Headers headers;
headers.emplace("Accept-Encoding", "gzip");
auto res = cli_.Get("/compress", headers);
ASSERT_TRUE(res);
EXPECT_EQ(StatusCode::OK_200, res->status);
EXPECT_EQ("gzip", res->get_header_value("Content-Encoding"));
// Verify pre-compression logger was called
EXPECT_TRUE(pre_logger_called);
EXPECT_EQ(test_content, pre_compression_body);
@ -6767,7 +6796,7 @@ void TestMultipartUploadProgress(SetupHandler &&setup_handler,
Client cli(HOST, PORT);
vector<uint64_t> progress_values;
MultipartFormDataItemsForClientInput items = {
UploadFormDataItems items = {
{"field1", "value1", "", ""},
{"field2", "longer value for progress tracking test", "", ""},
{"file1", "file content data for upload progress", "test.txt",
@ -6788,12 +6817,11 @@ TEST(UploadProgressTest, PostMultipartProgress) {
TestMultipartUploadProgress(
[](Server &svr) {
svr.Post("/multipart", [](const Request &req, Response &res) {
EXPECT_FALSE(req.files.empty());
EXPECT_TRUE(!req.form.files.empty() || !req.form.fields.empty());
res.set_content("multipart received", "text/plain");
});
},
[](Client &cli, const string &endpoint,
const MultipartFormDataItemsForClientInput &items,
[](Client &cli, const string &endpoint, const UploadFormDataItems &items,
UploadProgress progress_callback) {
return cli.Post(endpoint, items, progress_callback);
},
@ -8631,26 +8659,26 @@ TEST(MultipartFormDataTest, LargeData) {
svr.Post("/post", [&](const Request &req, Response & /*res*/,
const ContentReader &content_reader) {
if (req.is_multipart_form_data()) {
MultipartFormDataItems files;
std::vector<FormData> items;
content_reader(
[&](const MultipartFormData &file) {
files.push_back(file);
[&](const FormData &file) {
items.push_back(file);
return true;
},
[&](const char *data, size_t data_length) {
files.back().content.append(data, data_length);
items.back().content.append(data, data_length);
return true;
});
EXPECT_TRUE(std::string(files[0].name) == "document");
EXPECT_EQ(size_t(1024 * 1024 * 2), files[0].content.size());
EXPECT_TRUE(files[0].filename == "2MB_data");
EXPECT_TRUE(files[0].content_type == "application/octet-stream");
EXPECT_TRUE(std::string(items[0].name) == "document");
EXPECT_EQ(size_t(1024 * 1024 * 2), items[0].content.size());
EXPECT_TRUE(items[0].filename == "2MB_data");
EXPECT_TRUE(items[0].content_type == "application/octet-stream");
EXPECT_TRUE(files[1].name == "hello");
EXPECT_TRUE(files[1].content == "world");
EXPECT_TRUE(files[1].filename == "");
EXPECT_TRUE(files[1].content_type == "");
EXPECT_TRUE(items[1].name == "hello");
EXPECT_TRUE(items[1].content == "world");
EXPECT_TRUE(items[1].filename == "");
EXPECT_TRUE(items[1].content_type == "");
} else {
std::string body;
content_reader([&](const char *data, size_t data_length) {
@ -8677,7 +8705,7 @@ TEST(MultipartFormDataTest, LargeData) {
Client cli("https://localhost:8080");
cli.enable_server_certificate_verification(false);
MultipartFormDataItemsForClientInput items{
UploadFormDataItems items{
{"document", buffer.str(), "2MB_data", "application/octet-stream"},
{"hello", "world", "", ""},
};
@ -8719,92 +8747,92 @@ TEST(MultipartFormDataTest, DataProviderItems) {
svr.Post("/post-items", [&](const Request &req, Response & /*res*/,
const ContentReader &content_reader) {
ASSERT_TRUE(req.is_multipart_form_data());
MultipartFormDataItems files;
std::vector<FormData> items;
content_reader(
[&](const MultipartFormData &file) {
files.push_back(file);
[&](const FormData &file) {
items.push_back(file);
return true;
},
[&](const char *data, size_t data_length) {
files.back().content.append(data, data_length);
items.back().content.append(data, data_length);
return true;
});
ASSERT_TRUE(files.size() == 2);
ASSERT_TRUE(items.size() == 2);
EXPECT_EQ(std::string(files[0].name), "name1");
EXPECT_EQ(files[0].content, "Testing123");
EXPECT_EQ(files[0].filename, "filename1");
EXPECT_EQ(files[0].content_type, "application/octet-stream");
EXPECT_EQ(std::string(items[0].name), "name1");
EXPECT_EQ(items[0].content, "Testing123");
EXPECT_EQ(items[0].filename, "filename1");
EXPECT_EQ(items[0].content_type, "application/octet-stream");
EXPECT_EQ(files[1].name, "name2");
EXPECT_EQ(files[1].content, "Testing456");
EXPECT_EQ(files[1].filename, "");
EXPECT_EQ(files[1].content_type, "");
EXPECT_EQ(items[1].name, "name2");
EXPECT_EQ(items[1].content, "Testing456");
EXPECT_EQ(items[1].filename, "");
EXPECT_EQ(items[1].content_type, "");
});
svr.Post("/post-providers", [&](const Request &req, Response & /*res*/,
const ContentReader &content_reader) {
ASSERT_TRUE(req.is_multipart_form_data());
MultipartFormDataItems files;
std::vector<FormData> items;
content_reader(
[&](const MultipartFormData &file) {
files.push_back(file);
[&](const FormData &file) {
items.push_back(file);
return true;
},
[&](const char *data, size_t data_length) {
files.back().content.append(data, data_length);
items.back().content.append(data, data_length);
return true;
});
ASSERT_TRUE(files.size() == 2);
ASSERT_TRUE(items.size() == 2);
EXPECT_EQ(files[0].name, "name3");
EXPECT_EQ(files[0].content, rand1);
EXPECT_EQ(files[0].filename, "filename3");
EXPECT_EQ(files[0].content_type, "");
EXPECT_EQ(items[0].name, "name3");
EXPECT_EQ(items[0].content, rand1);
EXPECT_EQ(items[0].filename, "filename3");
EXPECT_EQ(items[0].content_type, "");
EXPECT_EQ(files[1].name, "name4");
EXPECT_EQ(files[1].content, rand2);
EXPECT_EQ(files[1].filename, "filename4");
EXPECT_EQ(files[1].content_type, "");
EXPECT_EQ(items[1].name, "name4");
EXPECT_EQ(items[1].content, rand2);
EXPECT_EQ(items[1].filename, "filename4");
EXPECT_EQ(items[1].content_type, "");
});
svr.Post("/post-both", [&](const Request &req, Response & /*res*/,
const ContentReader &content_reader) {
ASSERT_TRUE(req.is_multipart_form_data());
MultipartFormDataItems files;
std::vector<FormData> items;
content_reader(
[&](const MultipartFormData &file) {
files.push_back(file);
[&](const FormData &file) {
items.push_back(file);
return true;
},
[&](const char *data, size_t data_length) {
files.back().content.append(data, data_length);
items.back().content.append(data, data_length);
return true;
});
ASSERT_TRUE(files.size() == 4);
ASSERT_TRUE(items.size() == 4);
EXPECT_EQ(std::string(files[0].name), "name1");
EXPECT_EQ(files[0].content, "Testing123");
EXPECT_EQ(files[0].filename, "filename1");
EXPECT_EQ(files[0].content_type, "application/octet-stream");
EXPECT_EQ(std::string(items[0].name), "name1");
EXPECT_EQ(items[0].content, "Testing123");
EXPECT_EQ(items[0].filename, "filename1");
EXPECT_EQ(items[0].content_type, "application/octet-stream");
EXPECT_EQ(files[1].name, "name2");
EXPECT_EQ(files[1].content, "Testing456");
EXPECT_EQ(files[1].filename, "");
EXPECT_EQ(files[1].content_type, "");
EXPECT_EQ(items[1].name, "name2");
EXPECT_EQ(items[1].content, "Testing456");
EXPECT_EQ(items[1].filename, "");
EXPECT_EQ(items[1].content_type, "");
EXPECT_EQ(files[2].name, "name3");
EXPECT_EQ(files[2].content, rand1);
EXPECT_EQ(files[2].filename, "filename3");
EXPECT_EQ(files[2].content_type, "");
EXPECT_EQ(items[2].name, "name3");
EXPECT_EQ(items[2].content, rand1);
EXPECT_EQ(items[2].filename, "filename3");
EXPECT_EQ(items[2].content_type, "");
EXPECT_EQ(files[3].name, "name4");
EXPECT_EQ(files[3].content, rand2);
EXPECT_EQ(files[3].filename, "filename4");
EXPECT_EQ(files[3].content_type, "");
EXPECT_EQ(items[3].name, "name4");
EXPECT_EQ(items[3].content, rand2);
EXPECT_EQ(items[3].filename, "filename4");
EXPECT_EQ(items[3].content_type, "");
});
auto t = std::thread([&]() { svr.listen("localhost", 8080); });
@ -8820,7 +8848,7 @@ TEST(MultipartFormDataTest, DataProviderItems) {
Client cli("https://localhost:8080");
cli.enable_server_certificate_verification(false);
MultipartFormDataItemsForClientInput items{
UploadFormDataItems items{
{"name1", "Testing123", "filename1", "application/octet-stream"},
{"name2", "Testing456", "", ""}, // not a file
};
@ -8831,7 +8859,7 @@ TEST(MultipartFormDataTest, DataProviderItems) {
ASSERT_EQ(StatusCode::OK_200, res->status);
}
MultipartFormDataProviderItems providers;
FormDataProviderItems providers;
{
auto res =
@ -8979,26 +9007,26 @@ TEST(MultipartFormDataTest, PostCustomBoundary) {
svr.Post("/post_customboundary", [&](const Request &req, Response & /*res*/,
const ContentReader &content_reader) {
if (req.is_multipart_form_data()) {
MultipartFormDataItems files;
std::vector<FormData> items;
content_reader(
[&](const MultipartFormData &file) {
files.push_back(file);
[&](const FormData &file) {
items.push_back(file);
return true;
},
[&](const char *data, size_t data_length) {
files.back().content.append(data, data_length);
items.back().content.append(data, data_length);
return true;
});
EXPECT_TRUE(std::string(files[0].name) == "document");
EXPECT_EQ(size_t(1024 * 1024 * 2), files[0].content.size());
EXPECT_TRUE(files[0].filename == "2MB_data");
EXPECT_TRUE(files[0].content_type == "application/octet-stream");
EXPECT_TRUE(std::string(items[0].name) == "document");
EXPECT_EQ(size_t(1024 * 1024 * 2), items[0].content.size());
EXPECT_TRUE(items[0].filename == "2MB_data");
EXPECT_TRUE(items[0].content_type == "application/octet-stream");
EXPECT_TRUE(files[1].name == "hello");
EXPECT_TRUE(files[1].content == "world");
EXPECT_TRUE(files[1].filename == "");
EXPECT_TRUE(files[1].content_type == "");
EXPECT_TRUE(items[1].name == "hello");
EXPECT_TRUE(items[1].content == "world");
EXPECT_TRUE(items[1].filename == "");
EXPECT_TRUE(items[1].content_type == "");
} else {
std::string body;
content_reader([&](const char *data, size_t data_length) {
@ -9025,7 +9053,7 @@ TEST(MultipartFormDataTest, PostCustomBoundary) {
Client cli("https://localhost:8080");
cli.enable_server_certificate_verification(false);
MultipartFormDataItemsForClientInput items{
UploadFormDataItems items{
{"document", buffer.str(), "2MB_data", "application/octet-stream"},
{"hello", "world", "", ""},
};
@ -9043,7 +9071,7 @@ TEST(MultipartFormDataTest, PostInvalidBoundaryChars) {
Client cli("https://localhost:8080");
MultipartFormDataItemsForClientInput items{
UploadFormDataItems items{
{"document", buffer.str(), "2MB_data", "application/octet-stream"},
{"hello", "world", "", ""},
};
@ -9062,26 +9090,26 @@ TEST(MultipartFormDataTest, PutFormData) {
svr.Put("/put", [&](const Request &req, const Response & /*res*/,
const ContentReader &content_reader) {
if (req.is_multipart_form_data()) {
MultipartFormDataItems files;
std::vector<FormData> items;
content_reader(
[&](const MultipartFormData &file) {
files.push_back(file);
[&](const FormData &file) {
items.push_back(file);
return true;
},
[&](const char *data, size_t data_length) {
files.back().content.append(data, data_length);
items.back().content.append(data, data_length);
return true;
});
EXPECT_TRUE(std::string(files[0].name) == "document");
EXPECT_EQ(size_t(1024 * 1024 * 2), files[0].content.size());
EXPECT_TRUE(files[0].filename == "2MB_data");
EXPECT_TRUE(files[0].content_type == "application/octet-stream");
EXPECT_TRUE(std::string(items[0].name) == "document");
EXPECT_EQ(size_t(1024 * 1024 * 2), items[0].content.size());
EXPECT_TRUE(items[0].filename == "2MB_data");
EXPECT_TRUE(items[0].content_type == "application/octet-stream");
EXPECT_TRUE(files[1].name == "hello");
EXPECT_TRUE(files[1].content == "world");
EXPECT_TRUE(files[1].filename == "");
EXPECT_TRUE(files[1].content_type == "");
EXPECT_TRUE(items[1].name == "hello");
EXPECT_TRUE(items[1].content == "world");
EXPECT_TRUE(items[1].filename == "");
EXPECT_TRUE(items[1].content_type == "");
} else {
std::string body;
content_reader([&](const char *data, size_t data_length) {
@ -9108,7 +9136,7 @@ TEST(MultipartFormDataTest, PutFormData) {
Client cli("https://localhost:8080");
cli.enable_server_certificate_verification(false);
MultipartFormDataItemsForClientInput items{
UploadFormDataItems items{
{"document", buffer.str(), "2MB_data", "application/octet-stream"},
{"hello", "world", "", ""},
};
@ -9126,26 +9154,26 @@ TEST(MultipartFormDataTest, PutFormDataCustomBoundary) {
[&](const Request &req, const Response & /*res*/,
const ContentReader &content_reader) {
if (req.is_multipart_form_data()) {
MultipartFormDataItems files;
std::vector<FormData> items;
content_reader(
[&](const MultipartFormData &file) {
files.push_back(file);
[&](const FormData &file) {
items.push_back(file);
return true;
},
[&](const char *data, size_t data_length) {
files.back().content.append(data, data_length);
items.back().content.append(data, data_length);
return true;
});
EXPECT_TRUE(std::string(files[0].name) == "document");
EXPECT_EQ(size_t(1024 * 1024 * 2), files[0].content.size());
EXPECT_TRUE(files[0].filename == "2MB_data");
EXPECT_TRUE(files[0].content_type == "application/octet-stream");
EXPECT_TRUE(std::string(items[0].name) == "document");
EXPECT_EQ(size_t(1024 * 1024 * 2), items[0].content.size());
EXPECT_TRUE(items[0].filename == "2MB_data");
EXPECT_TRUE(items[0].content_type == "application/octet-stream");
EXPECT_TRUE(files[1].name == "hello");
EXPECT_TRUE(files[1].content == "world");
EXPECT_TRUE(files[1].filename == "");
EXPECT_TRUE(files[1].content_type == "");
EXPECT_TRUE(items[1].name == "hello");
EXPECT_TRUE(items[1].content == "world");
EXPECT_TRUE(items[1].filename == "");
EXPECT_TRUE(items[1].content_type == "");
} else {
std::string body;
content_reader([&](const char *data, size_t data_length) {
@ -9172,7 +9200,7 @@ TEST(MultipartFormDataTest, PutFormDataCustomBoundary) {
Client cli("https://localhost:8080");
cli.enable_server_certificate_verification(false);
MultipartFormDataItemsForClientInput items{
UploadFormDataItems items{
{"document", buffer.str(), "2MB_data", "application/octet-stream"},
{"hello", "world", "", ""},
};
@ -9191,7 +9219,7 @@ TEST(MultipartFormDataTest, PutInvalidBoundaryChars) {
Client cli("https://localhost:8080");
cli.enable_server_certificate_verification(false);
MultipartFormDataItemsForClientInput items{
UploadFormDataItems items{
{"document", buffer.str(), "2MB_data", "application/octet-stream"},
{"hello", "world", "", ""},
};
@ -9208,26 +9236,26 @@ TEST(MultipartFormDataTest, AlternateFilename) {
Server svr;
svr.Post("/test", [&](const Request &req, Response &res) {
ASSERT_EQ(3u, req.files.size());
ASSERT_EQ(2u, req.form.files.size());
ASSERT_EQ(1u, req.form.fields.size());
auto it = req.files.begin();
ASSERT_EQ("file1", it->second.name);
ASSERT_EQ("A.txt", it->second.filename);
ASSERT_EQ("text/plain", it->second.content_type);
ASSERT_EQ("Content of a.txt.\r\n", it->second.content);
// Test files
const auto &file1 = req.form.get_file("file1");
ASSERT_EQ("file1", file1.name);
ASSERT_EQ("A.txt", file1.filename);
ASSERT_EQ("text/plain", file1.content_type);
ASSERT_EQ("Content of a.txt.\r\n", file1.content);
++it;
ASSERT_EQ("file2", it->second.name);
ASSERT_EQ("a.html", it->second.filename);
ASSERT_EQ("text/html", it->second.content_type);
const auto &file2 = req.form.get_file("file2");
ASSERT_EQ("file2", file2.name);
ASSERT_EQ("a.html", file2.filename);
ASSERT_EQ("text/html", file2.content_type);
ASSERT_EQ("<!DOCTYPE html><title>Content of a.html.</title>\r\n",
it->second.content);
file2.content);
++it;
ASSERT_EQ("text", it->second.name);
ASSERT_EQ("", it->second.filename);
ASSERT_EQ("", it->second.content_type);
ASSERT_EQ("text default", it->second.content);
// Test text field
const auto &text = req.form.get_field("text");
ASSERT_EQ("text default", text);
res.set_content("ok", "text/plain");
@ -9276,15 +9304,13 @@ TEST(MultipartFormDataTest, CloseDelimiterWithoutCRLF) {
Server svr;
svr.Post("/test", [&](const Request &req, Response &) {
ASSERT_EQ(2u, req.files.size());
ASSERT_EQ(2u, req.form.fields.size());
auto it = req.files.begin();
ASSERT_EQ("text1", it->second.name);
ASSERT_EQ("text1", it->second.content);
const auto &text1 = req.form.get_field("text1");
ASSERT_EQ("text1", text1);
++it;
ASSERT_EQ("text2", it->second.name);
ASSERT_EQ("text2", it->second.content);
const auto &text2 = req.form.get_field("text2");
ASSERT_EQ("text2", text2);
handled = true;
});
@ -9322,15 +9348,13 @@ TEST(MultipartFormDataTest, ContentLength) {
Server svr;
svr.Post("/test", [&](const Request &req, Response &) {
ASSERT_EQ(2u, req.files.size());
ASSERT_EQ(2u, req.form.fields.size());
auto it = req.files.begin();
ASSERT_EQ("text1", it->second.name);
ASSERT_EQ("text1", it->second.content);
const auto &text1 = req.form.get_field("text1");
ASSERT_EQ("text1", text1);
++it;
ASSERT_EQ("text2", it->second.name);
ASSERT_EQ("text2", it->second.content);
const auto &text2 = req.form.get_field("text2");
ASSERT_EQ("text2", text2);
handled = true;
});
@ -9369,26 +9393,22 @@ TEST(MultipartFormDataTest, AccessPartHeaders) {
Server svr;
svr.Post("/test", [&](const Request &req, Response &) {
ASSERT_EQ(2u, req.files.size());
ASSERT_EQ(2u, req.form.fields.size());
auto it = req.files.begin();
ASSERT_EQ("text1", it->second.name);
ASSERT_EQ("text1", it->second.content);
ASSERT_EQ(1U, it->second.headers.count("Content-Length"));
auto content_length = it->second.headers.find("CONTENT-length");
ASSERT_EQ("5", content_length->second);
ASSERT_EQ(3U, it->second.headers.size());
const auto &text1 = req.form.get_field("text1");
ASSERT_EQ("text1", text1);
// TODO: Add header access for text fields if needed
++it;
ASSERT_EQ("text2", it->second.name);
ASSERT_EQ("text2", it->second.content);
auto &headers = it->second.headers;
ASSERT_EQ(3U, headers.size());
auto custom_header = headers.find("x-whatever");
ASSERT_TRUE(custom_header != headers.end());
ASSERT_NE("customvalue", custom_header->second);
ASSERT_EQ("CustomValue", custom_header->second);
ASSERT_TRUE(headers.find("X-Test") == headers.end()); // text1 header
const auto &text2 = req.form.get_field("text2");
ASSERT_EQ("text2", text2);
// TODO: Header access for text fields needs to be implemented
// auto &headers = it->second.headers;
// ASSERT_EQ(3U, headers.size());
// auto custom_header = headers.find("x-whatever");
// ASSERT_TRUE(custom_header != headers.end());
// ASSERT_NE("customvalue", custom_header->second);
// ASSERT_EQ("CustomValue", custom_header->second);
// ASSERT_TRUE(headers.find("X-Test") == headers.end()); // text1 header
handled = true;
});
@ -9432,11 +9452,10 @@ TEST(MultipartFormDataTest, LargeHeader) {
Server svr;
svr.Post("/test", [&](const Request &req, Response &) {
ASSERT_EQ(1u, req.files.size());
ASSERT_EQ(1u, req.form.fields.size());
auto it = req.files.begin();
ASSERT_EQ("name1", it->second.name);
ASSERT_EQ("text1", it->second.content);
const auto &text = req.form.get_field("name1");
ASSERT_EQ("text1", text);
handled = true;
});