Mirror/Crow
1
0
Fork 0
mirror of https://github.com/CrowCpp/Crow.git synced 2024-06-07 21:10:44 +00:00
Code Issues Packages Projects Releases Wiki Activity
5a8c12a9ff
Crow/tests/unittest.cpp

1330 lines
33 KiB
C++
Raw Blame History

#define CATCH_CONFIG_MAIN
#define CROW_LOG_LEVEL 0
#include <sys/stat.h>
#include <iostream>
#include <sstream>
#include <vector>
#include "catch.hpp"
#include "crow.h"
using namespace std;
using namespace crow;
#define LOCALHOST_ADDRESS "127.0.0.1"
TEST_CASE("Rule")
{
TaggedRule<> r("/http/");
r.name("abc");
// empty handler - fail to validate
try {
r.validate();
FAIL_CHECK("empty handler should fail to validate");
} catch (runtime_error& e) {
}
int x = 0;
// registering handler
r([&x] {
x = 1;
return "";
});
r.validate();
response res;
// executing handler
REQUIRE(0 == x);
r.handle(request(), res, routing_params());
REQUIRE(1 == x);
// registering handler with request argument
r([&x](const crow::request&) {
x = 2;
return "";
});
r.validate();
// executing handler
REQUIRE(1 == x);
r.handle(request(), res, routing_params());
REQUIRE(2 == x);
}
TEST_CASE("ParameterTagging")
{
static_assert(black_magic::is_valid("<int><int><int>"), "valid url");
static_assert(!black_magic::is_valid("<int><int<<int>"), "invalid url");
static_assert(!black_magic::is_valid("nt>"), "invalid url");
REQUIRE(1 == black_magic::get_parameter_tag("<int>"));
REQUIRE(2 == black_magic::get_parameter_tag("<uint>"));
REQUIRE(3 == black_magic::get_parameter_tag("<float>"));
REQUIRE(3 == black_magic::get_parameter_tag("<double>"));
REQUIRE(4 == black_magic::get_parameter_tag("<str>"));
REQUIRE(4 == black_magic::get_parameter_tag("<string>"));
REQUIRE(5 == black_magic::get_parameter_tag("<path>"));
REQUIRE(6 * 6 + 6 + 1 == black_magic::get_parameter_tag("<int><int><int>"));
REQUIRE(6 * 6 + 6 + 2 == black_magic::get_parameter_tag("<uint><int><int>"));
REQUIRE(6 * 6 + 6 * 3 + 2 ==
black_magic::get_parameter_tag("<uint><double><int>"));
// url definition parsed in compile time, build into *one number*, and given
// to template argument
static_assert(
std::is_same<black_magic::S<uint64_t, double, int64_t>,
black_magic::arguments<6 * 6 + 6 * 3 + 2>::type>::value,
"tag to type container");
}
TEST_CASE("PathRouting")
{
SimpleApp app;
CROW_ROUTE(app, "/file")
([] { return "file"; });
CROW_ROUTE(app, "/path/")
([] { return "path"; });
app.validate();
{
request req;
response res;
req.url = "/file";
app.handle(req, res);
REQUIRE(200 == res.code);
}
{
request req;
response res;
req.url = "/file/";
app.handle(req, res);
REQUIRE(404 == res.code);
}
{
request req;
response res;
req.url = "/path";
app.handle(req, res);
REQUIRE(404 != res.code);
}
{
request req;
response res;
req.url = "/path/";
app.handle(req, res);
REQUIRE(200 == res.code);
}
}
TEST_CASE("RoutingTest")
{
SimpleApp app;
int A{};
uint32_t B{};
double C{};
string D{};
string E{};
CROW_ROUTE(app, "/0/<uint>")
([&](uint32_t b) {
B = b;
return "OK";
});
CROW_ROUTE(app, "/1/<int>/<uint>")
([&](int a, uint32_t b) {
A = a;
B = b;
return "OK";
});
CROW_ROUTE(app, "/4/<int>/<uint>/<double>/<string>")
([&](int a, uint32_t b, double c, string d) {
A = a;
B = b;
C = c;
D = d;
return "OK";
});
CROW_ROUTE(app, "/5/<int>/<uint>/<double>/<string>/<path>")
([&](int a, uint32_t b, double c, string d, string e) {
A = a;
B = b;
C = c;
D = d;
E = e;
return "OK";
});
app.validate();
// app.debug_print();
{
request req;
response res;
req.url = "/-1";
app.handle(req, res);
REQUIRE(404 == res.code);
}
{
request req;
response res;
req.url = "/0/1001999";
app.handle(req, res);
REQUIRE(200 == res.code);
REQUIRE(1001999 == B);
}
{
request req;
response res;
req.url = "/1/-100/1999";
app.handle(req, res);
REQUIRE(200 == res.code);
REQUIRE(-100 == A);
REQUIRE(1999 == B);
}
{
request req;
response res;
req.url = "/4/5000/3/-2.71828/hellhere";
req.add_header("TestHeader", "Value");
app.handle(req, res);
REQUIRE(200 == res.code);
REQUIRE(5000 == A);
REQUIRE(3 == B);
REQUIRE(-2.71828 == C);
REQUIRE("hellhere" == D);
}
{
request req;
response res;
req.url = "/5/-5/999/3.141592/hello_there/a/b/c/d";
req.add_header("TestHeader", "Value");
app.handle(req, res);
REQUIRE(200 == res.code);
REQUIRE(-5 == A);
REQUIRE(999 == B);
REQUIRE(3.141592 == C);
REQUIRE("hello_there" == D);
REQUIRE("a/b/c/d" == E);
}
}
TEST_CASE("simple_response_routing_params")
{
REQUIRE(100 == response(100).code);
REQUIRE(200 == response("Hello there").code);
REQUIRE(500 == response(500, "Internal Error?").code);
routing_params rp;
rp.int_params.push_back(1);
rp.int_params.push_back(5);
rp.uint_params.push_back(2);
rp.double_params.push_back(3);
rp.string_params.push_back("hello");
REQUIRE(1 == rp.get<int64_t>(0));
REQUIRE(5 == rp.get<int64_t>(1));
REQUIRE(2 == rp.get<uint64_t>(0));
REQUIRE(3 == rp.get<double>(0));
REQUIRE("hello" == rp.get<string>(0));
}
TEST_CASE("handler_with_response")
{
SimpleApp app;
CROW_ROUTE(app, "/")([](const crow::request&, crow::response&) {});
}
TEST_CASE("http_method")
{
SimpleApp app;
CROW_ROUTE(app, "/").methods("POST"_method,
"GET"_method)([](const request& req) {
if (req.method == "GET"_method)
return "2";
else
return "1";
});
CROW_ROUTE(app, "/get_only")
.methods("GET"_method)([](const request& /*req*/) { return "get"; });
CROW_ROUTE(app, "/post_only")
.methods("POST"_method)([](const request& /*req*/) { return "post"; });
CROW_ROUTE(app, "/patch_only")
.methods("PATCH"_method)([](const request& /*req*/) { return "patch"; });
CROW_ROUTE(app, "/purge_only")
.methods("PURGE"_method)([](const request& /*req*/) { return "purge"; });
app.validate();
app.debug_print();
// cannot have multiple handlers for the same url
// CROW_ROUTE(app, "/")
//.methods("GET"_method)
//([]{ return "2"; });
{
request req;
response res;
req.url = "/";
app.handle(req, res);
REQUIRE("2" == res.body);
}
{
request req;
response res;
req.url = "/";
req.method = "POST"_method;
app.handle(req, res);
REQUIRE("1" == res.body);
}
{
request req;
response res;
req.url = "/get_only";
app.handle(req, res);
REQUIRE("get" == res.body);
}
{
request req;
response res;
req.url = "/patch_only";
req.method = "PATCH"_method;
app.handle(req, res);
REQUIRE("patch" == res.body);
}
{
request req;
response res;
req.url = "/purge_only";
req.method = "PURGE"_method;
app.handle(req, res);
REQUIRE("purge" == res.body);
}
{
request req;
response res;
req.url = "/get_only";
req.method = "POST"_method;
app.handle(req, res);
REQUIRE("get" != res.body);
}
{
request req;
response res;
req.url = "/get_only";
req.method = "POST"_method;
app.handle(req, res);
REQUIRE(405 == res.code);
}
}
TEST_CASE("server_handling_error_request")
{
static char buf[2048];
SimpleApp app;
CROW_ROUTE(app, "/")([] { return "A"; });
// Server<SimpleApp> server(&app, LOCALHOST_ADDRESS, 45451);
// auto _ = async(launch::async, [&]{server.run();});
auto _ = async(launch::async,
[&] { app.bindaddr(LOCALHOST_ADDRESS).port(45451).run(); });
app.wait_for_server_start();
std::string sendmsg = "POX";
asio::io_service is;
{
asio::ip::tcp::socket c(is);
c.connect(asio::ip::tcp::endpoint(
asio::ip::address::from_string(LOCALHOST_ADDRESS), 45451));
c.send(asio::buffer(sendmsg));
try {
c.receive(asio::buffer(buf, 2048));
FAIL_CHECK();
} catch (std::exception& e) {
// std::cerr << e.what() << std::endl;
}
}
app.stop();
}
TEST_CASE("multi_server")
{
static char buf[2048];
SimpleApp app1, app2;
CROW_ROUTE(app1, "/").methods("GET"_method,
"POST"_method)([] { return "A"; });
CROW_ROUTE(app2, "/").methods("GET"_method,
"POST"_method)([] { return "B"; });
auto _ = async(launch::async,
[&] { app1.bindaddr(LOCALHOST_ADDRESS).port(45451).run(); });
auto _2 = async(launch::async,
[&] { app2.bindaddr(LOCALHOST_ADDRESS).port(45452).run(); });
app1.wait_for_server_start();
app2.wait_for_server_start();
std::string sendmsg =
"POST /\r\nContent-Length:3\r\nX-HeaderTest: 123\r\n\r\nA=B\r\n";
asio::io_service is;
{
asio::ip::tcp::socket c(is);
c.connect(asio::ip::tcp::endpoint(
asio::ip::address::from_string(LOCALHOST_ADDRESS), 45451));
c.send(asio::buffer(sendmsg));
size_t recved = c.receive(asio::buffer(buf, 2048));
REQUIRE('A' == buf[recved - 1]);
}
{
asio::ip::tcp::socket c(is);
c.connect(asio::ip::tcp::endpoint(
asio::ip::address::from_string(LOCALHOST_ADDRESS), 45452));
for (auto ch : sendmsg) {
char buf[1] = {ch};
c.send(asio::buffer(buf));
}
size_t recved = c.receive(asio::buffer(buf, 2048));
REQUIRE('B' == buf[recved - 1]);
}
app1.stop();
app2.stop();
}
TEST_CASE("json_read")
{
{
const char* json_error_tests[] = {
"{} 3",
"{{}",
"{3}",
"3.4.5",
"+3",
"3-2",
"00",
"03",
"1e3e3",
"1e+.3",
"nll",
"f",
"t",
"{\"x\":3,}",
"{\"x\"}",
"{\"x\":3 q}",
"{\"x\":[3 4]}",
"{\"x\":[\"",
"{\"x\":[[], 4],\"y\",}",
"{\"x\":[3",
"{\"x\":[ null, false, true}",
};
for (auto s : json_error_tests) {
auto x = json::load(s);
if (x) {
FAIL_CHECK(std::string("should fail to parse ") + s);
return;
}
}
}
auto x = json::load(R"({"message":"hello, world"})");
if (!x) FAIL_CHECK("fail to parse");
REQUIRE("hello, world" == x["message"]);
REQUIRE(1 == x.size());
REQUIRE(false == x.has("mess"));
REQUIRE_THROWS(x["mess"]);
// TODO returning false is better than exception
// ASSERT_THROW(3 == x["message"]);
REQUIRE(12 == x["message"].size());
std::string s =
R"({"int":3, "ints" :[1,2,3,4,5], "bigint":1234567890 })";
auto y = json::load(s);
REQUIRE(3 == y["int"]);
REQUIRE(3.0 == y["int"]);
REQUIRE(3.01 != y["int"]);
REQUIRE(5 == y["ints"].size());
REQUIRE(1 == y["ints"][0]);
REQUIRE(2 == y["ints"][1]);
REQUIRE(3 == y["ints"][2]);
REQUIRE(4 == y["ints"][3]);
REQUIRE(5 == y["ints"][4]);
REQUIRE(1u == y["ints"][0]);
REQUIRE(1.f == y["ints"][0]);
int q = (int)y["ints"][1];
REQUIRE(2 == q);
q = y["ints"][2].i();
REQUIRE(3 == q);
REQUIRE(1234567890 == y["bigint"]);
std::string s2 = R"({"bools":[true, false], "doubles":[1.2, -3.4]})";
auto z = json::load(s2);
REQUIRE(2 == z["bools"].size());
REQUIRE(2 == z["doubles"].size());
REQUIRE(true == z["bools"][0].b());
REQUIRE(false == z["bools"][1].b());
REQUIRE(1.2 == z["doubles"][0].d());
REQUIRE(-3.4 == z["doubles"][1].d());
std::string s3 = R"({"uint64": 18446744073709551615})";
auto z1 = json::load(s3);
REQUIRE(18446744073709551615ull == z1["uint64"].u());
std::ostringstream os;
os << z1["uint64"];
REQUIRE("18446744073709551615" == os.str());
}
TEST_CASE("json_read_real")
{
vector<std::string> v{"0.036303908355795146",
"0.18320417789757412",
"0.05319940476190476",
"0.15224702380952382",
"0",
"0.3296201145552561",
"0.47921580188679247",
"0.05873511904761905",
"0.1577827380952381",
"0.4996841307277628",
"0.6425412735849056",
"0.052113095238095236",
"0.12830357142857143",
"0.7871041105121294",
"0.954220013477089",
"0.05869047619047619",
"0.1625",
"0.8144794474393531",
"0.9721613881401617",
"0.1399404761904762",
"0.24470238095238095",
"0.04527459568733154",
"0.2096950808625337",
"0.35267857142857145",
"0.42791666666666667",
"0.855731974393531",
"0.9352467991913747",
"0.3816220238095238",
"0.4282886904761905",
"0.39414167789757415",
"0.5316079851752021",
"0.3809375",
"0.4571279761904762",
"0.03522995283018868",
"0.1915641846361186",
"0.6164136904761904",
"0.7192708333333333",
"0.05675117924528302",
"0.21308541105121293",
"0.7045386904761904",
"0.8016815476190476"};
for (auto x : v) {
CROW_LOG_DEBUG << x;
REQUIRE(json::load(x).d() == boost::lexical_cast<double>(x));
}
auto ret = json::load(
R"---({"balloons":[{"mode":"ellipse","left":0.036303908355795146,"right":0.18320417789757412,"top":0.05319940476190476,"bottom":0.15224702380952382,"index":"0"},{"mode":"ellipse","left":0.3296201145552561,"right":0.47921580188679247,"top":0.05873511904761905,"bottom":0.1577827380952381,"index":"1"},{"mode":"ellipse","left":0.4996841307277628,"right":0.6425412735849056,"top":0.052113095238095236,"bottom":0.12830357142857143,"index":"2"},{"mode":"ellipse","left":0.7871041105121294,"right":0.954220013477089,"top":0.05869047619047619,"bottom":0.1625,"index":"3"},{"mode":"ellipse","left":0.8144794474393531,"right":0.9721613881401617,"top":0.1399404761904762,"bottom":0.24470238095238095,"index":"4"},{"mode":"ellipse","left":0.04527459568733154,"right":0.2096950808625337,"top":0.35267857142857145,"bottom":0.42791666666666667,"index":"5"},{"mode":"ellipse","left":0.855731974393531,"right":0.9352467991913747,"top":0.3816220238095238,"bottom":0.4282886904761905,"index":"6"},{"mode":"ellipse","left":0.39414167789757415,"right":0.5316079851752021,"top":0.3809375,"bottom":0.4571279761904762,"index":"7"},{"mode":"ellipse","left":0.03522995283018868,"right":0.1915641846361186,"top":0.6164136904761904,"bottom":0.7192708333333333,"index":"8"},{"mode":"ellipse","left":0.05675117924528302,"right":0.21308541105121293,"top":0.7045386904761904,"bottom":0.8016815476190476,"index":"9"}]})---");
REQUIRE(ret);
}
TEST_CASE("json_read_unescaping")
{
{
auto x = json::load(R"({"data":"\ud55c\n\t\r"})");
if (!x) {
FAIL_CHECK("fail to parse");
return;
}
REQUIRE(6 == x["data"].size());
REQUIRE("한\n\t\r" == x["data"]);
}
{
// multiple r_string instance
auto x = json::load(R"({"data":"\ud55c\n\t\r"})");
auto a = x["data"].s();
auto b = x["data"].s();
REQUIRE(6 == a.size());
REQUIRE(6 == b.size());
REQUIRE(6 == x["data"].size());
}
}
TEST_CASE("json_write")
{
json::wvalue x;
x["message"] = "hello world";
REQUIRE(R"({"message":"hello world"})" == json::dump(x));
x["message"] = std::string("string value");
REQUIRE(R"({"message":"string value"})" == json::dump(x));
x["message"]["x"] = 3;
REQUIRE(R"({"message":{"x":3}})" == json::dump(x));
x["message"]["y"] = 5;
REQUIRE((R"({"message":{"x":3,"y":5}})" == json::dump(x) ||
R"({"message":{"y":5,"x":3}})" == json::dump(x)));
x["message"] = 5.5;
REQUIRE(R"({"message":5.5})" == json::dump(x));
x["message"] = 1234567890;
REQUIRE(R"({"message":1234567890})" == json::dump(x));
json::wvalue y;
y["scores"][0] = 1;
y["scores"][1] = "king";
y["scores"][2] = 3.5;
REQUIRE(R"({"scores":[1,"king",3.5]})" == json::dump(y));
y["scores"][2][0] = "real";
y["scores"][2][1] = false;
y["scores"][2][2] = true;
REQUIRE(R"({"scores":[1,"king",["real",false,true]]})" == json::dump(y));
y["scores"]["a"]["b"]["c"] = nullptr;
REQUIRE(R"({"scores":{"a":{"b":{"c":null}}}})" == json::dump(y));
y["scores"] = std::vector<int>{1, 2, 3};
REQUIRE(R"({"scores":[1,2,3]})" == json::dump(y));
}
TEST_CASE("json_copy_r_to_w_to_r")
{
json::rvalue r = json::load(
R"({"smallint":2,"bigint":2147483647,"fp":23.43,"fpsc":2.343e1,"str":"a string","trueval":true,"falseval":false,"nullval":null,"listval":[1,2,"foo","bar"],"obj":{"member":23,"other":"baz"}})");
json::wvalue w{r};
json::rvalue x =
json::load(json::dump(w)); // why no copy-ctor wvalue -> rvalue?
REQUIRE(2 == x["smallint"]);
REQUIRE(2147483647 == x["bigint"]);
REQUIRE(23.43 == x["fp"]);
REQUIRE(23.43 == x["fpsc"]);
REQUIRE("a string" == x["str"]);
REQUIRE(x["trueval"].b());
REQUIRE_FALSE(x["falseval"].b());
REQUIRE(json::type::Null == x["nullval"].t());
REQUIRE(4u == x["listval"].size());
REQUIRE(1 == x["listval"][0]);
REQUIRE(2 == x["listval"][1]);
REQUIRE("foo" == x["listval"][2]);
REQUIRE("bar" == x["listval"][3]);
REQUIRE(23 == x["obj"]["member"]);
REQUIRE("member" == x["obj"]["member"].key());
REQUIRE("baz" == x["obj"]["other"]);
REQUIRE("other" == x["obj"]["other"].key());
}
TEST_CASE("template_basic")
{
auto t = crow::mustache::compile(R"---(attack of {{name}})---");
crow::mustache::context ctx;
ctx["name"] = "killer tomatoes";
auto result = t.render(ctx);
REQUIRE("attack of killer tomatoes" == result);
}
TEST_CASE("template_load")
{
crow::mustache::set_base(".");
ofstream("test.mustache") << R"---(attack of {{name}})---";
auto t = crow::mustache::load("test.mustache");
crow::mustache::context ctx;
ctx["name"] = "killer tomatoes";
auto result = t.render(ctx);
REQUIRE("attack of killer tomatoes" == result);
unlink("test.mustache");
}
TEST_CASE("black_magic")
{
using namespace black_magic;
static_assert(
std::is_same<void, last_element_type<int, char, void>::type>::value,
"last_element_type");
static_assert(std::is_same<char, pop_back<int, char, void>::rebind<
last_element_type>::type>::value,
"pop_back");
static_assert(
std::is_same<int, pop_back<int, char, void>::rebind<pop_back>::rebind<
last_element_type>::type>::value,
"pop_back");
}
struct NullMiddleware
{
struct context
{};
template <typename AllContext>
void before_handle(request&, response&, context&, AllContext&)
{}
template <typename AllContext>
void after_handle(request&, response&, context&, AllContext&)
{}
};
struct NullSimpleMiddleware
{
struct context
{};
void before_handle(request& /*req*/, response& /*res*/, context& /*ctx*/) {}
void after_handle(request& /*req*/, response& /*res*/, context& /*ctx*/) {}
};
TEST_CASE("middleware_simple")
{
App<NullMiddleware, NullSimpleMiddleware> app;
decltype(app)::server_t server(&app, LOCALHOST_ADDRESS, 45451);
CROW_ROUTE(app, "/")
([&](const crow::request& req) {
app.get_context<NullMiddleware>(req);
app.get_context<NullSimpleMiddleware>(req);
return "";
});
}
struct IntSettingMiddleware
{
struct context
{
int val;
};
template <typename AllContext>
void before_handle(request&, response&, context& ctx, AllContext&)
{
ctx.val = 1;
}
template <typename AllContext>
void after_handle(request&, response&, context& ctx, AllContext&)
{
ctx.val = 2;
}
};
std::vector<std::string> test_middleware_context_vector;
struct FirstMW
{
struct context
{
std::vector<string> v;
};
void before_handle(request& /*req*/, response& /*res*/, context& ctx)
{
ctx.v.push_back("1 before");
}
void after_handle(request& /*req*/, response& /*res*/, context& ctx)
{
ctx.v.push_back("1 after");
test_middleware_context_vector = ctx.v;
}
};
struct SecondMW
{
struct context
{};
template <typename AllContext>
void before_handle(request& req, response& res, context&, AllContext& all_ctx)
{
all_ctx.template get<FirstMW>().v.push_back("2 before");
if (req.url == "/break") res.end();
}
template <typename AllContext>
void after_handle(request&, response&, context&, AllContext& all_ctx)
{
all_ctx.template get<FirstMW>().v.push_back("2 after");
}
};
struct ThirdMW
{
struct context
{};
template <typename AllContext>
void before_handle(request&, response&, context&, AllContext& all_ctx)
{
all_ctx.template get<FirstMW>().v.push_back("3 before");
}
template <typename AllContext>
void after_handle(request&, response&, context&, AllContext& all_ctx)
{
all_ctx.template get<FirstMW>().v.push_back("3 after");
}
};
TEST_CASE("middleware_context")
{
static char buf[2048];
// SecondMW depends on FirstMW (it uses all_ctx.get<FirstMW>)
// so it leads to compile error if we remove FirstMW from definition
// App<IntSettingMiddleware, SecondMW> app;
// or change the order of FirstMW and SecondMW
// App<IntSettingMiddleware, SecondMW, FirstMW> app;
App<IntSettingMiddleware, FirstMW, SecondMW, ThirdMW> app;
int x{};
CROW_ROUTE(app, "/")
([&](const request& req) {
{
auto& ctx = app.get_context<IntSettingMiddleware>(req);
x = ctx.val;
}
{
auto& ctx = app.get_context<FirstMW>(req);
ctx.v.push_back("handle");
}
return "";
});
CROW_ROUTE(app, "/break")
([&](const request& req) {
{
auto& ctx = app.get_context<FirstMW>(req);
ctx.v.push_back("handle");
}
return "";
});
auto _ = async(launch::async,
[&] { app.bindaddr(LOCALHOST_ADDRESS).port(45451).run(); });
app.wait_for_server_start();
std::string sendmsg = "GET /\r\n\r\n";
asio::io_service is;
{
asio::ip::tcp::socket c(is);
c.connect(asio::ip::tcp::endpoint(
asio::ip::address::from_string(LOCALHOST_ADDRESS), 45451));
c.send(asio::buffer(sendmsg));
c.receive(asio::buffer(buf, 2048));
c.close();
}
{
auto& out = test_middleware_context_vector;
REQUIRE(1 == x);
REQUIRE(7 == out.size());
REQUIRE("1 before" == out[0]);
REQUIRE("2 before" == out[1]);
REQUIRE("3 before" == out[2]);
REQUIRE("handle" == out[3]);
REQUIRE("3 after" == out[4]);
REQUIRE("2 after" == out[5]);
REQUIRE("1 after" == out[6]);
}
std::string sendmsg2 = "GET /break\r\n\r\n";
{
asio::ip::tcp::socket c(is);
c.connect(asio::ip::tcp::endpoint(
asio::ip::address::from_string(LOCALHOST_ADDRESS), 45451));
c.send(asio::buffer(sendmsg2));
c.receive(asio::buffer(buf, 2048));
c.close();
}
{
auto& out = test_middleware_context_vector;
REQUIRE(4 == out.size());
REQUIRE("1 before" == out[0]);
REQUIRE("2 before" == out[1]);
REQUIRE("2 after" == out[2]);
REQUIRE("1 after" == out[3]);
}
app.stop();
}
TEST_CASE("middleware_cookieparser")
{
static char buf[2048];
App<CookieParser> app;
std::string value1;
std::string value2;
std::string value3;
std::string value4;
CROW_ROUTE(app, "/")
([&](const request& req) {
{
auto& ctx = app.get_context<CookieParser>(req);
value1 = ctx.get_cookie("key1");
value2 = ctx.get_cookie("key2");
value3 = ctx.get_cookie("key3");
value4 = ctx.get_cookie("key4");
}
return "";
});
auto _ = async(launch::async,
[&] { app.bindaddr(LOCALHOST_ADDRESS).port(45451).run(); });
app.wait_for_server_start();
std::string sendmsg =
"GET /\r\nCookie: key1=value1; key2=\"val=ue2\"; key3=\"val\"ue3\"; "
"key4=\"val\"ue4\"\r\n\r\n";
asio::io_service is;
{
asio::ip::tcp::socket c(is);
c.connect(asio::ip::tcp::endpoint(
asio::ip::address::from_string(LOCALHOST_ADDRESS), 45451));
c.send(asio::buffer(sendmsg));
c.receive(asio::buffer(buf, 2048));
c.close();
}
{
REQUIRE("value1" == value1);
REQUIRE("val=ue2" == value2);
REQUIRE("val\"ue3" == value3);
REQUIRE("val\"ue4" == value4);
}
app.stop();
}
TEST_CASE("bug_quick_repeated_request")
{
static char buf[2048];
SimpleApp app;
CROW_ROUTE(app, "/")([&] { return "hello"; });
auto _ = async(launch::async,
[&] { app.bindaddr(LOCALHOST_ADDRESS).port(45451).run(); });
app.wait_for_server_start();
std::string sendmsg = "GET / HTTP/1.1\r\nHost: localhost\r\n\r\n";
asio::io_service is;
{
std::vector<std::future<void>> v;
for (int i = 0; i < 5; i++) {
v.push_back(async(launch::async, [&] {
asio::ip::tcp::socket c(is);
c.connect(asio::ip::tcp::endpoint(
asio::ip::address::from_string(LOCALHOST_ADDRESS), 45451));
for (int j = 0; j < 5; j++) {
c.send(asio::buffer(sendmsg));
size_t received = c.receive(asio::buffer(buf, 2048));
REQUIRE("hello" == std::string(buf + received - 5, buf + received));
}
c.close();
}));
}
}
app.stop();
}
TEST_CASE("simple_url_params")
{
static char buf[2048];
SimpleApp app;
query_string last_url_params;
CROW_ROUTE(app, "/params")
([&last_url_params](const crow::request& req) {
last_url_params = std::move(req.url_params);
return "OK";
});
/// params?h=1&foo=bar&lol&count[]=1&count[]=4&pew=5.2
auto _ = async(launch::async,
[&] { app.bindaddr(LOCALHOST_ADDRESS).port(45451).run(); });
app.wait_for_server_start();
asio::io_service is;
std::string sendmsg;
// check empty params
sendmsg = "GET /params\r\n\r\n";
{
asio::ip::tcp::socket c(is);
c.connect(asio::ip::tcp::endpoint(
asio::ip::address::from_string(LOCALHOST_ADDRESS), 45451));
c.send(asio::buffer(sendmsg));
c.receive(asio::buffer(buf, 2048));
c.close();
stringstream ss;
ss << last_url_params;
REQUIRE("[ ]" == ss.str());
}
// check single presence
sendmsg = "GET /params?foobar\r\n\r\n";
{
asio::ip::tcp::socket c(is);
c.connect(asio::ip::tcp::endpoint(
asio::ip::address::from_string(LOCALHOST_ADDRESS), 45451));
c.send(asio::buffer(sendmsg));
c.receive(asio::buffer(buf, 2048));
c.close();
REQUIRE(last_url_params.get("missing") == nullptr);
REQUIRE(last_url_params.get("foobar") != nullptr);
REQUIRE(last_url_params.get_list("missing").empty());
}
// check multiple presence
sendmsg = "GET /params?foo&bar&baz\r\n\r\n";
{
asio::ip::tcp::socket c(is);
c.connect(asio::ip::tcp::endpoint(
asio::ip::address::from_string(LOCALHOST_ADDRESS), 45451));
c.send(asio::buffer(sendmsg));
c.receive(asio::buffer(buf, 2048));
c.close();
REQUIRE(last_url_params.get("missing") == nullptr);
REQUIRE(last_url_params.get("foo") != nullptr);
REQUIRE(last_url_params.get("bar") != nullptr);
REQUIRE(last_url_params.get("baz") != nullptr);
}
// check single value
sendmsg = "GET /params?hello=world\r\n\r\n";
{
asio::ip::tcp::socket c(is);
c.connect(asio::ip::tcp::endpoint(
asio::ip::address::from_string(LOCALHOST_ADDRESS), 45451));
c.send(asio::buffer(sendmsg));
c.receive(asio::buffer(buf, 2048));
c.close();
REQUIRE(string(last_url_params.get("hello")) == "world");
}
// check multiple value
sendmsg = "GET /params?hello=world&left=right&up=down\r\n\r\n";
{
asio::ip::tcp::socket c(is);
c.connect(asio::ip::tcp::endpoint(
asio::ip::address::from_string(LOCALHOST_ADDRESS), 45451));
c.send(asio::buffer(sendmsg));
c.receive(asio::buffer(buf, 2048));
c.close();
REQUIRE(string(last_url_params.get("hello")) == "world");
REQUIRE(string(last_url_params.get("left")) == "right");
REQUIRE(string(last_url_params.get("up")) == "down");
}
// check multiple value, multiple types
sendmsg = "GET /params?int=100&double=123.45&boolean=1\r\n\r\n";
{
asio::ip::tcp::socket c(is);
c.connect(asio::ip::tcp::endpoint(
asio::ip::address::from_string(LOCALHOST_ADDRESS), 45451));
c.send(asio::buffer(sendmsg));
c.receive(asio::buffer(buf, 2048));
c.close();
REQUIRE(boost::lexical_cast<int>(last_url_params.get("int")) == 100);
REQUIRE(boost::lexical_cast<double>(last_url_params.get("double")) ==
123.45);
REQUIRE(boost::lexical_cast<bool>(last_url_params.get("boolean")));
}
// check single array value
sendmsg = "GET /params?tmnt[]=leonardo\r\n\r\n";
{
asio::ip::tcp::socket c(is);
c.connect(asio::ip::tcp::endpoint(
asio::ip::address::from_string(LOCALHOST_ADDRESS), 45451));
c.send(asio::buffer(sendmsg));
c.receive(asio::buffer(buf, 2048));
c.close();
REQUIRE(last_url_params.get("tmnt") == nullptr);
REQUIRE(last_url_params.get_list("tmnt").size() == 1);
REQUIRE(string(last_url_params.get_list("tmnt")[0]) == "leonardo");
}
// check multiple array value
sendmsg =
"GET /params?tmnt[]=leonardo&tmnt[]=donatello&tmnt[]=raphael\r\n\r\n";
{
asio::ip::tcp::socket c(is);
c.connect(asio::ip::tcp::endpoint(
asio::ip::address::from_string(LOCALHOST_ADDRESS), 45451));
c.send(asio::buffer(sendmsg));
c.receive(asio::buffer(buf, 2048));
c.close();
REQUIRE(last_url_params.get_list("tmnt").size() == 3);
REQUIRE(string(last_url_params.get_list("tmnt")[0]) == "leonardo");
REQUIRE(string(last_url_params.get_list("tmnt")[1]) == "donatello");
REQUIRE(string(last_url_params.get_list("tmnt")[2]) == "raphael");
}
app.stop();
}
TEST_CASE("route_dynamic")
{
SimpleApp app;
int x = 1;
app.route_dynamic("/")([&] {
x = 2;
return "";
});
app.route_dynamic("/set4")([&](const request&) {
x = 4;
return "";
});
app.route_dynamic("/set5")([&](const request&, response& res) {
x = 5;
res.end();
});
app.route_dynamic("/set_int/<int>")([&](int y) {
x = y;
return "";
});
try {
app.route_dynamic("/invalid_test/<double>/<path>")([]() { return ""; });
FAIL_CHECK();
} catch (std::exception&) {
}
// app is in an invalid state when route_dynamic throws an exception.
try {
app.validate();
FAIL_CHECK();
} catch (std::exception&) {
}
{
request req;
response res;
req.url = "/";
app.handle(req, res);
REQUIRE(x == 2);
}
{
request req;
response res;
req.url = "/set_int/42";
app.handle(req, res);
REQUIRE(x == 42);
}
{
request req;
response res;
req.url = "/set5";
app.handle(req, res);
REQUIRE(x == 5);
}
{
request req;
response res;
req.url = "/set4";
app.handle(req, res);
REQUIRE(x == 4);
}
}
TEST_CASE("send_file")
{
SimpleApp app;
CROW_ROUTE(app, "/jpg")
([](const crow::request&, crow::response& res) {
res.set_static_file_info("tests/img/cat.jpg");
res.end();
});
CROW_ROUTE(app, "/jpg2")
([](const crow::request&, crow::response& res) {
res.set_static_file_info(
"tests/img/cat2.jpg"); // This file is nonexistent on purpose
res.end();
});
app.validate();
{
request req;
response res;
req.url = "/jpg";
app.handle(req, res);
struct stat statbuf;
stat("tests/img/cat.jpg", &statbuf);
REQUIRE(200 == res.code);
REQUIRE("image/jpeg" == res.headers.find("Content-Type")->second);
REQUIRE(to_string(statbuf.st_size) ==
res.headers.find("Content-Length")->second);
}
{
request req;
response res;
req.url = "/jpg2";
app.handle(req, res);
REQUIRE(404 == res.code);
}
}
TEST_CASE("multipart")
{
std::string test_string = "--CROW-BOUNDARY\r\nContent-Disposition: form-data; name=\"hello\"\r\n\r\nworld\r\n--CROW-BOUNDARY\r\nContent-Disposition: form-data; name=\"world\"\r\n\r\nhello\r\n--CROW-BOUNDARY\r\nContent-Disposition: form-data; name=\"multiline\"\r\n\r\ntext\ntext\ntext\r\n--CROW-BOUNDARY--\r\n";
SimpleApp app;
CROW_ROUTE(app, "/multipart")
([](const crow::request& req, crow::response& res)
{
multipart::message msg(req);
res.add_header("Content-Type", "multipart/form-data; boundary=CROW-BOUNDARY");
res.body = msg.dump();
res.end();
});
app.validate();
{
request req;
response res;
req.url = "/multipart";
req.add_header("Content-Type", "multipart/form-data; boundary=CROW-BOUNDARY");
req.body = test_string;
app.handle(req, res);
REQUIRE(test_string == res.body);
}
}
TEST_CASE("stream_response")
{
static char buf[2048];
static char buf2[16384];
SimpleApp app;
CROW_ROUTE(app, "/test")
([](const crow::request&, crow::response& res)
{
std::string keyword_ = "hello";
std::string key_response;
for (unsigned int i = 0; i<1000000; i++)
key_response += keyword_;
res.body = key_response;
res.end();
});
app.validate();
auto _ = async(launch::async,
[&] { app.bindaddr(LOCALHOST_ADDRESS).port(45451).run(); });
app.wait_for_server_start();
asio::io_service is;
std::string sendmsg;
sendmsg = "GET /test\r\n\r\n";
{
std::string keyword_ = "hello";
std::string key_response;
for (unsigned int i = 0; i<1000000; i++)
key_response += keyword_;
asio::ip::tcp::socket c(is);
c.connect(asio::ip::tcp::endpoint(
asio::ip::address::from_string(LOCALHOST_ADDRESS), 45451));
c.send(asio::buffer(sendmsg));
c.receive(asio::buffer(buf, 2048));
for (unsigned int i = 0; i<305; i++)
c.receive(asio::buffer(buf2, 16384));
//c.close();
CHECK(key_response.substr(4997070, 50) == std::string(buf2).substr(16334, 50));
}
app.stop();
}
Reference in New Issue View Git Blame Copy Permalink