Commit 169c7799 authored by knowledge4igor's avatar knowledge4igor

Fix problems in http_server_test and test refactoring

parent a7ed13fa
...@@ -44,118 +44,93 @@ struct SlowHandlerOnSpecialPage : public Http::Handler { ...@@ -44,118 +44,93 @@ struct SlowHandlerOnSpecialPage : public Http::Handler {
int delay_; int delay_;
}; };
TEST(http_server_test, client_disconnection_on_timeout_from_single_threaded_server) {
const std::string address = "localhost:9095";
Http::Endpoint server(address);
auto flags = Tcp::Options::InstallSignalHandler | Tcp::Options::ReuseAddr;
auto server_opts = Http::Endpoint::options().flags(flags);
server.init(server_opts);
const int SEVEN_SECONDS_DELAY = 6;
server.setHandler(Http::make_handler<HelloHandlerWithDelay>(SEVEN_SECONDS_DELAY));
server.serveThreaded();
int clientLogicFunc(int response_size, const std::string& server_page, int wait_seconds) {
Http::Client client; Http::Client client;
client.init(); client.init();
std::vector<Async::Promise<Http::Response>> responses; std::vector<Async::Promise<Http::Response>> responses;
auto rb = client.get(address); auto rb = client.get(server_page);
auto response = rb.send(); int counter = 0;
bool done = false; for (int i = 0; i < response_size; ++i)
response.then([&](Http::Response rsp) { {
if (rsp.code() == Http::Code::Ok) auto response = rb.send();
done = true; response.then([&](Http::Response rsp) {
}, Async::IgnoreException); if (rsp.code() == Http::Code::Ok)
responses.push_back(std::move(response)); ++counter;
}, Async::IgnoreException);
responses.push_back(std::move(response));
}
auto sync = Async::whenAll(responses.begin(), responses.end()); auto sync = Async::whenAll(responses.begin(), responses.end());
Async::Barrier<std::vector<Http::Response>> barrier(sync); Async::Barrier<std::vector<Http::Response>> barrier(sync);
barrier.wait_for(std::chrono::seconds(5)); barrier.wait_for(std::chrono::seconds(wait_seconds));
server.shutdown();
client.shutdown(); client.shutdown();
ASSERT_FALSE(done); return counter;
} }
TEST(http_server_test, client_multiple_requests_disconnection_on_timeout_from_single_threaded_server) { TEST(http_server_test, client_disconnection_on_timeout_from_single_threaded_server) {
const std::string address = "localhost:9096"; const std::string server_address = "localhost:9095";
Http::Endpoint server(address); Http::Endpoint server(server_address);
auto flags = Tcp::Options::InstallSignalHandler | Tcp::Options::ReuseAddr; auto flags = Tcp::Options::InstallSignalHandler | Tcp::Options::ReuseAddr;
auto server_opts = Http::Endpoint::options().flags(flags); auto server_opts = Http::Endpoint::options().flags(flags);
server.init(server_opts); server.init(server_opts);
const int SEVEN_SECONDS_DELAY = 6; const int SIX_SECONDS_DELAY = 6;
server.setHandler(Http::make_handler<HelloHandlerWithDelay>(SEVEN_SECONDS_DELAY)); server.setHandler(Http::make_handler<HelloHandlerWithDelay>(SIX_SECONDS_DELAY));
server.serveThreaded(); server.serveThreaded();
Http::Client client; const int CLIENT_REQUEST_SIZE = 1;
client.init(); int counter = clientLogicFunc(CLIENT_REQUEST_SIZE, server_address, SIX_SECONDS_DELAY);
std::vector<Async::Promise<Http::Response>> responses;
auto rb = client.get(address);
int counter = 0;
const int RESPONSE_SIZE = 3;
for (int i = 0; i < RESPONSE_SIZE; ++i)
{
auto response = rb.send();
response.then([&](Http::Response rsp) {
if (rsp.code() == Http::Code::Ok)
++counter;
}, Async::IgnoreException);
responses.push_back(std::move(response));
}
auto sync = Async::whenAll(responses.begin(), responses.end());
Async::Barrier<std::vector<Http::Response>> barrier(sync);
barrier.wait_for(std::chrono::seconds(5));
server.shutdown(); server.shutdown();
client.shutdown();
ASSERT_EQ(counter, 0); ASSERT_EQ(counter, 0);
} }
TEST(http_server_test, multiple_client_with_requests_to_multithreaded_server) { TEST(http_server_test, client_multiple_requests_disconnection_on_timeout_from_single_threaded_server) {
const std::string address = "localhost:9097"; const std::string server_address = "localhost:9096";
Http::Endpoint server(address); Http::Endpoint server(server_address);
auto flags = Tcp::Options::InstallSignalHandler | Tcp::Options::ReuseAddr; auto flags = Tcp::Options::InstallSignalHandler | Tcp::Options::ReuseAddr;
auto server_opts = Http::Endpoint::options().flags(flags).threads(3); auto server_opts = Http::Endpoint::options().flags(flags);
server.init(server_opts); server.init(server_opts);
server.setHandler(Http::make_handler<HelloHandlerWithDelay>());
const int SIX_SECONDS_DELAY = 6;
server.setHandler(Http::make_handler<HelloHandlerWithDelay>(SIX_SECONDS_DELAY));
server.serveThreaded(); server.serveThreaded();
auto client_logic = [&address](int response_size) { const int CLIENT_REQUEST_SIZE = 3;
Http::Client client; int counter = clientLogicFunc(CLIENT_REQUEST_SIZE, server_address, SIX_SECONDS_DELAY);
client.init();
std::vector<Async::Promise<Http::Response>> responses; server.shutdown();
auto rb = client.get(address);
int counter = 0;
for (int i = 0; i < response_size; ++i)
{
auto response = rb.send();
response.then([&](Http::Response rsp) {
if (rsp.code() == Http::Code::Ok)
++counter;
}, Async::IgnoreException);
responses.push_back(std::move(response));
}
auto sync = Async::whenAll(responses.begin(), responses.end()); ASSERT_EQ(counter, 0);
Async::Barrier<std::vector<Http::Response>> barrier(sync); }
barrier.wait_for(std::chrono::seconds(5));
client.shutdown(); TEST(http_server_test, multiple_client_with_requests_to_multithreaded_server) {
const std::string server_address = "localhost:9097";
return counter; Http::Endpoint server(server_address);
}; auto flags = Tcp::Options::InstallSignalHandler | Tcp::Options::ReuseAddr;
auto server_opts = Http::Endpoint::options().flags(flags).threads(3);
server.init(server_opts);
server.setHandler(Http::make_handler<HelloHandlerWithDelay>());
server.serveThreaded();
const int SIX_SECONDS_TIMOUT = 6;
const int FIRST_CLIENT_REQUEST_SIZE = 4; const int FIRST_CLIENT_REQUEST_SIZE = 4;
std::future<int> result1(std::async(client_logic, FIRST_CLIENT_REQUEST_SIZE)); std::future<int> result1(std::async(clientLogicFunc,
FIRST_CLIENT_REQUEST_SIZE,
server_address,
SIX_SECONDS_TIMOUT));
const int SECOND_CLIENT_REQUEST_SIZE = 5; const int SECOND_CLIENT_REQUEST_SIZE = 5;
std::future<int> result2(std::async(client_logic, SECOND_CLIENT_REQUEST_SIZE)); std::future<int> result2(std::async(clientLogicFunc,
SECOND_CLIENT_REQUEST_SIZE,
server_address,
SIX_SECONDS_TIMOUT));
int res1 = result1.get(); int res1 = result1.get();
int res2 = result2.get(); int res2 = result2.get();
...@@ -167,46 +142,26 @@ TEST(http_server_test, multiple_client_with_requests_to_multithreaded_server) { ...@@ -167,46 +142,26 @@ TEST(http_server_test, multiple_client_with_requests_to_multithreaded_server) {
} }
TEST(http_server_test, multiple_client_with_different_requests_to_multithreaded_server) { TEST(http_server_test, multiple_client_with_different_requests_to_multithreaded_server) {
const std::string address = "localhost:9098"; const std::string server_address = "localhost:9098";
Http::Endpoint server(address); Http::Endpoint server(server_address);
auto flags = Tcp::Options::InstallSignalHandler | Tcp::Options::ReuseAddr; auto flags = Tcp::Options::InstallSignalHandler | Tcp::Options::ReuseAddr;
auto server_opts = Http::Endpoint::options().flags(flags).threads(3); auto server_opts = Http::Endpoint::options().flags(flags).threads(3);
server.init(server_opts); server.init(server_opts);
const int SEVEN_SECONDS_DELAY = 6; const int SIX_SECONDS_DELAY = 6;
server.setHandler(Http::make_handler<SlowHandlerOnSpecialPage>(SEVEN_SECONDS_DELAY)); server.setHandler(Http::make_handler<SlowHandlerOnSpecialPage>(SIX_SECONDS_DELAY));
server.serveThreaded(); server.serveThreaded();
auto client_logic = [&address](int response_size, const std::string& page) {
Http::Client client;
client.init();
std::vector<Async::Promise<Http::Response>> responses;
auto rb = client.get(address + page);
int counter = 0;
for (int i = 0; i < response_size; ++i)
{
auto response = rb.send();
response.then([&](Http::Response rsp) {
if (rsp.code() == Http::Code::Ok)
++counter;
}, Async::IgnoreException);
responses.push_back(std::move(response));
}
auto sync = Async::whenAll(responses.begin(), responses.end());
Async::Barrier<std::vector<Http::Response>> barrier(sync);
barrier.wait_for(std::chrono::seconds(5));
client.shutdown();
return counter;
};
const int FIRST_CLIENT_REQUEST_SIZE = 1; const int FIRST_CLIENT_REQUEST_SIZE = 1;
std::future<int> result1(std::async(client_logic, FIRST_CLIENT_REQUEST_SIZE, SPECIAL_PAGE)); std::future<int> result1(std::async(clientLogicFunc,
const int SECOND_CLIENT_REQUEST_SIZE = 2; FIRST_CLIENT_REQUEST_SIZE,
std::future<int> result2(std::async(client_logic, SECOND_CLIENT_REQUEST_SIZE, "")); server_address + SPECIAL_PAGE,
SIX_SECONDS_DELAY / 2));
const int SECOND_CLIENT_REQUEST_SIZE = 3;
std::future<int> result2(std::async(clientLogicFunc,
SECOND_CLIENT_REQUEST_SIZE,
server_address,
SIX_SECONDS_DELAY * 2));
int res1 = result1.get(); int res1 = result1.get();
int res2 = result2.get(); int res2 = result2.get();
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment