khodo/ligo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Formatting
publish / publish (push) Successful in 27m34s
Details

Browse Source
This commit is contained in:
khodowany
2026-09-14 23:54:56 -05:00
parent 6914712d20
commit 4170d3a003
26 changed files with 668 additions and 621 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/test.cpp
+202 -200
View File
@@ -45,6 +45,7 @@
#include <test.hpp>
BOOST_AUTO_TEST_CASE(ligo_asserts_follow_build_type) {
#if defined(LIGO_EXPECT_NDEBUG) && !defined(NDEBUG)
BOOST_FAIL("release-style builds must define NDEBUG");
@@ -54,14 +55,13 @@ BOOST_AUTO_TEST_CASE(ligo_asserts_follow_build_type) {
#endif
}
namespace {
auto test_network_failure(boost::system::error_code const& error) -> modulus::error {
auto test_network_failure(boost::system::error_code const &error) -> modulus::error {
return ligo::detail::make_error(ligo::detail::error_unavailable, error.message());
}
auto run_two_threads(boost::asio::io_context& io) -> void {
auto run_two_threads(boost::asio::io_context &io) -> void {
auto first = std::thread{[&] {
io.run();
}};
@@ -72,7 +72,7 @@ auto run_two_threads(boost::asio::io_context& io) -> void {
second.join();
}
auto start_io_threads(boost::asio::io_context& io) -> std::vector<std::thread> {
auto start_io_threads(boost::asio::io_context &io) -> std::vector<std::thread> {
auto threads = std::vector<std::thread>{};
threads.emplace_back([&] {
io.run();
@@ -83,8 +83,8 @@ auto start_io_threads(boost::asio::io_context& io) -> std::vector<std::thread> {
return threads;
}
auto join_io_threads(std::vector<std::thread>& threads) -> void {
for (auto& thread : threads) {
auto join_io_threads(std::vector<std::thread> &threads) -> void {
for (auto &thread : threads) {
thread.join();
}
}
@@ -239,7 +239,7 @@ auto test_dtls_server_verify_client_config() -> ligo::security_config {
};
}
auto http_client_call(std::string host, std::uint16_t port, ligo::http::request const& request, ligo::http::client_options options = {}) -> boost::asio::awaitable<std::expected<boost::json::value, modulus::error>> {
auto http_client_call(std::string host, std::uint16_t port, ligo::http::request const &request, ligo::http::client_options options = {}) -> boost::asio::awaitable<std::expected<boost::json::value, modulus::error>> {
auto client = ligo::http::client{
{
.host = std::move(host),
@@ -250,21 +250,21 @@ auto http_client_call(std::string host, std::uint16_t port, ligo::http::request
return client.call(request);
}
auto http_client_call_selected(ligo::http::server& server, ligo::http::request const& request, ligo::http::client_options options = {}) -> boost::asio::awaitable<std::expected<boost::json::value, modulus::error>> {
auto http_client_call_selected(ligo::http::server &server, ligo::http::request const &request, ligo::http::client_options options = {}) -> boost::asio::awaitable<std::expected<boost::json::value, modulus::error>> {
return http_client_call("127.0.0.1", server.selected_port(), request, options);
}
auto http_client_call_selected_and_stop_impl(ligo::http::server& server, std::shared_ptr<ligo::http::request const> request, ligo::http::client_options options) -> boost::asio::awaitable<std::expected<boost::json::value, modulus::error>> {
auto http_client_call_selected_and_stop_impl(ligo::http::server &server, std::shared_ptr<ligo::http::request const> request, ligo::http::client_options options) -> boost::asio::awaitable<std::expected<boost::json::value, modulus::error>> {
auto result = co_await http_client_call_selected(server, *request, options);
server.stop();
co_return result;
}
auto http_client_call_selected_and_stop(ligo::http::server& server, ligo::http::request const& request, ligo::http::client_options options = {}) -> boost::asio::awaitable<std::expected<boost::json::value, modulus::error>> {
auto http_client_call_selected_and_stop(ligo::http::server &server, ligo::http::request const &request, ligo::http::client_options options = {}) -> boost::asio::awaitable<std::expected<boost::json::value, modulus::error>> {
return http_client_call_selected_and_stop_impl(server, std::make_shared<ligo::http::request const>(request), options);
}
auto http_async_stop_after(ligo::http::server& server, std::chrono::milliseconds delay, std::chrono::milliseconds timeout) -> boost::asio::awaitable<std::expected<void, modulus::error>> {
auto http_async_stop_after(ligo::http::server &server, std::chrono::milliseconds delay, std::chrono::milliseconds timeout) -> boost::asio::awaitable<std::expected<void, modulus::error>> {
auto timer = boost::asio::steady_timer{co_await boost::asio::this_coro::executor};
timer.expires_after(delay);
co_await timer.async_wait(boost::asio::as_tuple(boost::asio::use_awaitable));
@@ -315,7 +315,7 @@ auto raw_http_post(std::uint16_t port, std::string target, std::string body) ->
co_return modulus::success(std::move(value));
}
auto raw_http_post_selected_and_stop(ligo::http::server& server, std::string target, std::string body) -> boost::asio::awaitable<std::expected<boost::json::value, modulus::error>> {
auto raw_http_post_selected_and_stop(ligo::http::server &server, std::string target, std::string body) -> boost::asio::awaitable<std::expected<boost::json::value, modulus::error>> {
auto result = co_await raw_http_post(server.selected_port(), std::move(target), std::move(body));
server.stop();
co_return result;
@@ -357,13 +357,13 @@ auto raw_http_get(std::uint16_t port, std::string target) -> boost::asio::awaita
co_return modulus::success(std::move(response));
}
auto raw_http_get_selected_and_stop(ligo::http::server& server, std::string target) -> boost::asio::awaitable<std::expected<boost::beast::http::response<boost::beast::http::string_body>, modulus::error>> {
auto raw_http_get_selected_and_stop(ligo::http::server &server, std::string target) -> boost::asio::awaitable<std::expected<boost::beast::http::response<boost::beast::http::string_body>, modulus::error>> {
auto result = co_await raw_http_get(server.selected_port(), std::move(target));
server.stop();
co_return result;
}
auto tcp_client_call(std::string host, std::uint16_t port, ligo::tcp::request const& request, ligo::tcp::client_options options = {}) -> boost::asio::awaitable<std::expected<boost::json::value, modulus::error>> {
auto tcp_client_call(std::string host, std::uint16_t port, ligo::tcp::request const &request, ligo::tcp::client_options options = {}) -> boost::asio::awaitable<std::expected<boost::json::value, modulus::error>> {
auto client = ligo::tcp::client{
{
.host = std::move(host),
@@ -374,21 +374,21 @@ auto tcp_client_call(std::string host, std::uint16_t port, ligo::tcp::request co
return client.call(request);
}
auto tcp_client_call_selected(ligo::tcp::server& server, ligo::tcp::request const& request, ligo::tcp::client_options options = {}) -> boost::asio::awaitable<std::expected<boost::json::value, modulus::error>> {
auto tcp_client_call_selected(ligo::tcp::server &server, ligo::tcp::request const &request, ligo::tcp::client_options options = {}) -> boost::asio::awaitable<std::expected<boost::json::value, modulus::error>> {
return tcp_client_call("127.0.0.1", server.selected_port(), request, options);
}
auto tcp_client_call_selected_and_stop_impl(ligo::tcp::server& server, std::shared_ptr<ligo::tcp::request const> request, ligo::tcp::client_options options) -> boost::asio::awaitable<std::expected<boost::json::value, modulus::error>> {
auto tcp_client_call_selected_and_stop_impl(ligo::tcp::server &server, std::shared_ptr<ligo::tcp::request const> request, ligo::tcp::client_options options) -> boost::asio::awaitable<std::expected<boost::json::value, modulus::error>> {
auto result = co_await tcp_client_call_selected(server, *request, options);
server.stop();
co_return result;
}
auto tcp_client_call_selected_and_stop(ligo::tcp::server& server, ligo::tcp::request const& request, ligo::tcp::client_options options = {}) -> boost::asio::awaitable<std::expected<boost::json::value, modulus::error>> {
auto tcp_client_call_selected_and_stop(ligo::tcp::server &server, ligo::tcp::request const &request, ligo::tcp::client_options options = {}) -> boost::asio::awaitable<std::expected<boost::json::value, modulus::error>> {
return tcp_client_call_selected_and_stop_impl(server, std::make_shared<ligo::tcp::request const>(request), options);
}
auto tcp_async_stop_after(ligo::tcp::server& server, std::chrono::milliseconds delay, std::chrono::milliseconds timeout) -> boost::asio::awaitable<std::expected<void, modulus::error>> {
auto tcp_async_stop_after(ligo::tcp::server &server, std::chrono::milliseconds delay, std::chrono::milliseconds timeout) -> boost::asio::awaitable<std::expected<void, modulus::error>> {
auto timer = boost::asio::steady_timer{co_await boost::asio::this_coro::executor};
timer.expires_after(delay);
co_await timer.async_wait(boost::asio::as_tuple(boost::asio::use_awaitable));
@@ -405,31 +405,32 @@ auto accept_and_hold(std::shared_ptr<boost::asio::ip::tcp::acceptor> acceptor, s
co_await timer.async_wait(boost::asio::as_tuple(boost::asio::use_awaitable));
}
auto make_udp_socket(boost::asio::io_context& io) -> std::unique_ptr<boost::asio::ip::udp::socket> {
auto make_udp_socket(boost::asio::io_context &io) -> std::unique_ptr<boost::asio::ip::udp::socket> {
return std::make_unique<boost::asio::ip::udp::socket>(io, boost::asio::ip::udp::endpoint{
boost::asio::ip::udp::v4(),
0,
});
boost::asio::ip::udp::v4(),
0,
});
}
auto udp_client_adopt(std::unique_ptr<boost::asio::ip::udp::socket> socket, boost::asio::ip::udp::endpoint peer, ligo::udp_reliability_config config = {}, std::uint64_t session_id = 1) -> std::expected<ligo::udp::client, modulus::error> {
return ligo::udp::client::adopt(std::move(socket), std::move(peer), {
.reliability = config,
.session_id = session_id,
});
.reliability = config,
.session_id = session_id,
});
}
auto udp_client_bind(boost::asio::io_context& io, boost::asio::ip::udp::endpoint local, boost::asio::ip::udp::endpoint peer, ligo::udp_reliability_config config = {}, std::uint64_t session_id = 1) -> std::expected<ligo::udp::client, modulus::error> {
auto udp_client_bind(boost::asio::io_context &io, boost::asio::ip::udp::endpoint local, boost::asio::ip::udp::endpoint peer, ligo::udp_reliability_config config = {}, std::uint64_t session_id = 1) -> std::expected<ligo::udp::client, modulus::error> {
return ligo::udp::client::bind(io, {
.local = std::move(local),
.peer = std::move(peer),
}, {
.reliability = config,
.session_id = session_id,
});
.local = std::move(local),
.peer = std::move(peer),
},
{
.reliability = config,
.session_id = session_id,
});
}
auto config_http_tcp_calls_and_stop(ligo::http::server& http_server, ligo::tcp::server& tcp_server) -> boost::asio::awaitable<std::expected<boost::json::value, modulus::error>> {
auto config_http_tcp_calls_and_stop(ligo::http::server &http_server, ligo::tcp::server &tcp_server) -> boost::asio::awaitable<std::expected<boost::json::value, modulus::error>> {
auto tcp_payload = boost::json::object{};
tcp_payload["ok"] = true;
auto tcp_request = std::make_shared<ligo::tcp::request>();
@@ -471,8 +472,9 @@ BOOST_AUTO_TEST_CASE(ligo_config_drives_http_tcp_and_udp_setup) {
udp_server_socket->local_endpoint().port(),
};
auto config_text = std::string{
"{\"endpoints\":[",
}+ "{\"name\":\"http\",\"protocol\":\"http\",\"bind\":\"127.0.0.1:0\",\"timeout_ms\":1000}," + "{\"name\":\"tcp\",\"protocol\":\"tcp\",\"bind\":\"127.0.0.1:0\",\"timeout_ms\":1000}," + "{\"name\":\"udp-client\",\"protocol\":\"udp\",\"bind\":\"127.0.0.1:" + std::to_string(udp_client_endpoint.port()) + "\",\"connect\":\"127.0.0.1:" + std::to_string(udp_server_endpoint.port()) + "\",\"udp\":{\"resend_interval_ms\":5,\"max_in_flight\":2,\"session_timeout_ms\":1000}}," + "{\"name\":\"udp-server\",\"protocol\":\"udp\",\"bind\":\"127.0.0.1:" + std::to_string(udp_server_endpoint.port()) + "\",\"connect\":\"127.0.0.1:" + std::to_string(udp_client_endpoint.port()) + "\",\"udp\":{\"resend_interval_ms\":5,\"max_in_flight\":2,\"session_timeout_ms\":1000}}" + "]}";
"{\"endpoints\":[",
} +
"{\"name\":\"http\",\"protocol\":\"http\",\"bind\":\"127.0.0.1:0\",\"timeout_ms\":1000}," + "{\"name\":\"tcp\",\"protocol\":\"tcp\",\"bind\":\"127.0.0.1:0\",\"timeout_ms\":1000}," + "{\"name\":\"udp-client\",\"protocol\":\"udp\",\"bind\":\"127.0.0.1:" + std::to_string(udp_client_endpoint.port()) + "\",\"connect\":\"127.0.0.1:" + std::to_string(udp_server_endpoint.port()) + "\",\"udp\":{\"resend_interval_ms\":5,\"max_in_flight\":2,\"session_timeout_ms\":1000}}," + "{\"name\":\"udp-server\",\"protocol\":\"udp\",\"bind\":\"127.0.0.1:" + std::to_string(udp_server_endpoint.port()) + "\",\"connect\":\"127.0.0.1:" + std::to_string(udp_client_endpoint.port()) + "\",\"udp\":{\"resend_interval_ms\":5,\"max_in_flight\":2,\"session_timeout_ms\":1000}}" + "]}";
auto configs = ligo::parse_endpoint_configs(boost::json::parse(config_text));
BOOST_REQUIRE(configs);
BOOST_REQUIRE((configs->size()) == (4u));
@@ -625,8 +627,7 @@ BOOST_AUTO_TEST_CASE(ligo_http_post_round_trip_dispatches_json_handler) {
{
.target = "/echo",
.payload = boost::json::parse(R"json({"ok":true})json"),
}
),
}),
boost::asio::use_future);
io.run();
auto result = future.get();
@@ -690,8 +691,7 @@ BOOST_AUTO_TEST_CASE(ligo_http_tls_post_round_trip_dispatches_json_handler) {
{
.timeout = std::chrono::milliseconds{1000},
.security = test_tls_client_config(),
}
),
}),
boost::asio::use_future);
io.run();
auto result = future.get();
@@ -764,9 +764,10 @@ BOOST_AUTO_TEST_CASE(ligo_http_get_round_trip_dispatches_method_and_route) {
};
BOOST_REQUIRE(server.start());
auto future = boost::asio::co_spawn(io, http_client_call_selected_and_stop(server, {
.method = ligo::http::method::GET,
.target = "/method",
}), boost::asio::use_future);
.method = ligo::http::method::GET,
.target = "/method",
}),
boost::asio::use_future);
io.run();
auto result = future.get();
BOOST_REQUIRE(result);
@@ -786,9 +787,10 @@ BOOST_AUTO_TEST_CASE(ligo_http_missing_route_returns_status) {
};
BOOST_REQUIRE(server.start());
auto future = boost::asio::co_spawn(io, http_client_call_selected_and_stop(server, {
.target = "/missing",
.payload = boost::json::object{},
}), boost::asio::use_future);
.target = "/missing",
.payload = boost::json::object{},
}),
boost::asio::use_future);
io.run();
auto result = future.get();
BOOST_CHECK(!(result));
@@ -811,9 +813,10 @@ BOOST_AUTO_TEST_CASE(ligo_http_handler_failure_returns_status) {
};
BOOST_REQUIRE(server.start());
auto future = boost::asio::co_spawn(io, http_client_call_selected_and_stop(server, {
.target = "/boom",
.payload = boost::json::object{},
}), boost::asio::use_future);
.target = "/boom",
.payload = boost::json::object{},
}),
boost::asio::use_future);
io.run();
auto result = future.get();
BOOST_CHECK(!(result));
@@ -895,8 +898,7 @@ BOOST_AUTO_TEST_CASE(ligo_http_client_rejects_oversized_response_body) {
{
.timeout = std::chrono::milliseconds{1000},
.max_body_size = 32,
}
),
}),
boost::asio::use_future);
io.run();
auto result = future.get();
@@ -932,11 +934,12 @@ BOOST_AUTO_TEST_CASE(ligo_http_concurrent_client_calls_succeed) {
auto payload = boost::json::object{};
payload["index"] = index;
futures.push_back(boost::asio::co_spawn(io, client.call({
.target = "/echo",
.payload = std::move(payload),
}), boost::asio::use_future));
.target = "/echo",
.payload = std::move(payload),
}),
boost::asio::use_future));
}
for (auto& future : futures) {
for (auto &future : futures) {
auto result = future.get();
BOOST_REQUIRE(result);
BOOST_CHECK(result->is_object());
@@ -971,8 +974,7 @@ BOOST_AUTO_TEST_CASE(ligo_http_async_stop_cancels_active_session) {
},
{
.timeout = std::chrono::milliseconds{200},
}
),
}),
boost::asio::use_future);
auto stopped = boost::asio::co_spawn(io, http_async_stop_after(server, std::chrono::milliseconds{5}, std::chrono::milliseconds{200}), boost::asio::use_future);
run_two_threads(io);
@@ -1002,8 +1004,7 @@ BOOST_AUTO_TEST_CASE(ligo_tcp_round_trip_dispatches_json_handler) {
{
.route = "echo",
.payload = boost::json::parse(R"json({"ok":true})json"),
}
),
}),
boost::asio::use_future);
io.run();
auto result = future.get();
@@ -1043,8 +1044,7 @@ BOOST_AUTO_TEST_CASE(ligo_tcp_tls_round_trip_dispatches_json_handler) {
{
.timeout = std::chrono::milliseconds{1000},
.security = test_tls_client_config(),
}
),
}),
boost::asio::use_future);
io.run();
auto result = future.get();
@@ -1085,12 +1085,11 @@ BOOST_AUTO_TEST_CASE(ligo_tcp_tls_verified_peer_succeeds) {
{
.timeout = std::chrono::milliseconds{1000},
.security = test_tls_verified_client_config("localhost"),
}
),
}),
boost::asio::use_future);
auto stopper = boost::asio::steady_timer{io};
stopper.expires_after(std::chrono::milliseconds{200});
stopper.async_wait([&server](boost::system::error_code const&) {
stopper.async_wait([&server](boost::system::error_code const &) {
server.stop();
});
io.run();
@@ -1132,12 +1131,11 @@ BOOST_AUTO_TEST_CASE(ligo_tcp_tls_hostname_mismatch_fails) {
{
.timeout = std::chrono::milliseconds{1000},
.security = test_tls_verified_client_config("wrong.local"),
}
),
}),
boost::asio::use_future);
auto stopper = boost::asio::steady_timer{io};
stopper.expires_after(std::chrono::milliseconds{200});
stopper.async_wait([&server](boost::system::error_code const&) {
stopper.async_wait([&server](boost::system::error_code const &) {
server.stop();
});
io.run();
@@ -1204,9 +1202,10 @@ BOOST_AUTO_TEST_CASE(ligo_tcp_missing_route_returns_status) {
};
BOOST_REQUIRE(server.start());
auto future = boost::asio::co_spawn(io, tcp_client_call_selected_and_stop(server, {
.route = "missing",
.payload = boost::json::object{},
}), boost::asio::use_future);
.route = "missing",
.payload = boost::json::object{},
}),
boost::asio::use_future);
io.run();
auto result = future.get();
BOOST_CHECK(!(result));
@@ -1229,9 +1228,10 @@ BOOST_AUTO_TEST_CASE(ligo_tcp_handler_failure_returns_status) {
};
BOOST_REQUIRE(server.start());
auto future = boost::asio::co_spawn(io, tcp_client_call_selected_and_stop(server, {
.route = "boom",
.payload = boost::json::object{},
}), boost::asio::use_future);
.route = "boom",
.payload = boost::json::object{},
}),
boost::asio::use_future);
io.run();
auto result = future.get();
BOOST_CHECK(!(result));
@@ -1241,9 +1241,10 @@ BOOST_AUTO_TEST_CASE(ligo_tcp_handler_failure_returns_status) {
BOOST_AUTO_TEST_CASE(ligo_tcp_connection_refused_returns_unavailable) {
auto io = boost::asio::io_context{};
auto future = boost::asio::co_spawn(io, tcp_client_call("127.0.0.1", 9, {
.route = "echo",
.payload = boost::json::object{},
}), boost::asio::use_future);
.route = "echo",
.payload = boost::json::object{},
}),
boost::asio::use_future);
io.run();
auto result = future.get();
BOOST_CHECK(!(result));
@@ -1253,9 +1254,9 @@ BOOST_AUTO_TEST_CASE(ligo_tcp_connection_refused_returns_unavailable) {
BOOST_AUTO_TEST_CASE(ligo_tcp_stalled_peer_times_out) {
auto io = boost::asio::io_context{};
auto acceptor = std::make_shared<boost::asio::ip::tcp::acceptor>(io, boost::asio::ip::tcp::endpoint{
boost::asio::ip::tcp::v4(),
0,
});
boost::asio::ip::tcp::v4(),
0,
});
auto held_socket = std::make_shared<boost::asio::ip::tcp::socket>(io);
boost::asio::co_spawn(io, accept_and_hold(acceptor, held_socket, std::chrono::milliseconds{50}), boost::asio::detached);
auto future = boost::asio::co_spawn(
@@ -1269,8 +1270,7 @@ BOOST_AUTO_TEST_CASE(ligo_tcp_stalled_peer_times_out) {
},
{
.timeout = std::chrono::milliseconds{20},
}
),
}),
boost::asio::use_future);
io.run();
auto result = future.get();
@@ -1306,11 +1306,12 @@ BOOST_AUTO_TEST_CASE(ligo_tcp_concurrent_client_calls_succeed) {
auto payload = boost::json::object{};
payload["index"] = index;
futures.push_back(boost::asio::co_spawn(io, client.call({
.route = "echo",
.payload = std::move(payload),
}), boost::asio::use_future));
.route = "echo",
.payload = std::move(payload),
}),
boost::asio::use_future));
}
for (auto& future : futures) {
for (auto &future : futures) {
auto result = future.get();
BOOST_REQUIRE(result);
BOOST_CHECK(result->is_object());
@@ -1345,8 +1346,7 @@ BOOST_AUTO_TEST_CASE(ligo_tcp_async_stop_cancels_active_session) {
},
{
.timeout = std::chrono::milliseconds{200},
}
),
}),
boost::asio::use_future);
auto stopped = boost::asio::co_spawn(io, tcp_async_stop_after(server, std::chrono::milliseconds{5}, std::chrono::milliseconds{200}), boost::asio::use_future);
run_two_threads(io);
@@ -1357,9 +1357,9 @@ BOOST_AUTO_TEST_CASE(ligo_tcp_async_stop_cancels_active_session) {
BOOST_AUTO_TEST_CASE(ligo_tcp_connect_returns_connected_socket) {
auto io = boost::asio::io_context{};
auto acceptor = std::make_shared<boost::asio::ip::tcp::acceptor>(io, boost::asio::ip::tcp::endpoint{
boost::asio::ip::tcp::v4(),
0,
});
boost::asio::ip::tcp::v4(),
0,
});
auto held_socket = std::make_shared<boost::asio::ip::tcp::socket>(io);
boost::asio::co_spawn(io, accept_and_hold(acceptor, held_socket, std::chrono::milliseconds{10}), boost::asio::detached);
auto result = boost::asio::co_spawn(
@@ -1372,8 +1372,7 @@ BOOST_AUTO_TEST_CASE(ligo_tcp_connect_returns_connected_socket) {
},
{
.timeout = std::chrono::milliseconds{1000},
}
),
}),
boost::asio::use_future);
io.run();
auto socket = result.get();
@@ -1386,9 +1385,9 @@ BOOST_AUTO_TEST_CASE(ligo_tcp_connect_returns_connected_socket) {
BOOST_AUTO_TEST_CASE(ligo_net_connect_returns_connected_socket) {
auto io = boost::asio::io_context{};
auto acceptor = std::make_shared<boost::asio::ip::tcp::acceptor>(io, boost::asio::ip::tcp::endpoint{
boost::asio::ip::tcp::v4(),
0,
});
boost::asio::ip::tcp::v4(),
0,
});
auto held_socket = std::make_shared<boost::asio::ip::tcp::socket>(io);
boost::asio::co_spawn(io, accept_and_hold(acceptor, held_socket, std::chrono::milliseconds{10}), boost::asio::detached);
auto result = boost::asio::co_spawn(
@@ -1401,8 +1400,7 @@ BOOST_AUTO_TEST_CASE(ligo_net_connect_returns_connected_socket) {
},
{
.timeout = std::chrono::milliseconds{1000},
}
),
}),
boost::asio::use_future);
io.run();
auto socket = result.get();
@@ -1415,9 +1413,9 @@ BOOST_AUTO_TEST_CASE(ligo_net_connect_returns_connected_socket) {
BOOST_AUTO_TEST_CASE(ligo_net_listener_accept_returns_socket) {
auto io = boost::asio::io_context{};
auto listener_result = ligo::net::listener::bind(io.get_executor(), {
.host = "127.0.0.1",
.port = 0,
});
.host = "127.0.0.1",
.port = 0,
});
BOOST_REQUIRE(listener_result);
auto listener = std::move(*listener_result);
BOOST_CHECK((listener.selected_port()) != (0));
@@ -1432,8 +1430,7 @@ BOOST_AUTO_TEST_CASE(ligo_net_listener_accept_returns_socket) {
},
{
.timeout = std::chrono::milliseconds{1000},
}
),
}),
boost::asio::use_future);
io.run();
auto accepted_socket = accepted.get();
@@ -1451,9 +1448,9 @@ BOOST_AUTO_TEST_CASE(ligo_net_listener_accept_returns_socket) {
BOOST_AUTO_TEST_CASE(ligo_net_byte_stream_round_trips_over_tcp) {
auto io = boost::asio::io_context{};
auto listener_result = ligo::net::listener::bind(io.get_executor(), {
.host = "127.0.0.1",
.port = 0,
});
.host = "127.0.0.1",
.port = 0,
});
BOOST_REQUIRE(listener_result);
auto listener = std::move(*listener_result);
auto accepted = boost::asio::co_spawn(io, listener.async_accept(), boost::asio::use_future);
@@ -1467,8 +1464,7 @@ BOOST_AUTO_TEST_CASE(ligo_net_byte_stream_round_trips_over_tcp) {
},
{
.timeout = std::chrono::milliseconds{1000},
}
),
}),
boost::asio::use_future);
io.run();
auto accepted_socket = accepted.get();
@@ -1499,14 +1495,16 @@ BOOST_AUTO_TEST_CASE(ligo_net_byte_stream_round_trips_over_tcp) {
BOOST_AUTO_TEST_CASE(ligo_net_listener_tls_accept_rejects_non_tls_security_modes) {
auto io = boost::asio::io_context{};
auto listener_result = ligo::net::listener::bind(io.get_executor(), {
.host = "127.0.0.1",
.port = 0,
});
.host = "127.0.0.1",
.port = 0,
});
BOOST_REQUIRE(listener_result);
auto listener = std::move(*listener_result);
auto none = boost::asio::co_spawn(io, listener.async_accept_tls_configured({
.mode = ligo::security_mode::NONE,
}, std::chrono::milliseconds{1000}), boost::asio::use_future);
.mode = ligo::security_mode::NONE,
},
std::chrono::milliseconds{1000}),
boost::asio::use_future);
io.run();
auto result = none.get();
BOOST_CHECK(!result);
@@ -1517,9 +1515,9 @@ BOOST_AUTO_TEST_CASE(ligo_net_listener_tls_accept_rejects_non_tls_security_modes
BOOST_AUTO_TEST_CASE(ligo_net_listener_tls_handshake_succeeds) {
auto io = boost::asio::io_context{};
auto listener_result = ligo::net::listener::bind(io.get_executor(), {
.host = "127.0.0.1",
.port = 0,
});
.host = "127.0.0.1",
.port = 0,
});
BOOST_REQUIRE(listener_result);
auto listener = std::move(*listener_result);
auto accepted = boost::asio::co_spawn(io, listener.async_accept_tls_handshaken(test_tls_server_config(), std::chrono::milliseconds{1000}), boost::asio::use_future);
@@ -1534,8 +1532,7 @@ BOOST_AUTO_TEST_CASE(ligo_net_listener_tls_handshake_succeeds) {
{
.timeout = std::chrono::milliseconds{1000},
},
test_tls_client_config()
),
test_tls_client_config()),
boost::asio::use_future);
io.run();
auto accepted_socket = accepted.get();
@@ -1565,8 +1562,7 @@ BOOST_AUTO_TEST_CASE(ligo_tcp_raw_connect_rejects_secure_modes) {
.security = {
.mode = ligo::security_mode::TLS,
},
}
),
}),
boost::asio::use_future);
io.run();
auto result = future.get();
@@ -1589,8 +1585,7 @@ BOOST_AUTO_TEST_CASE(ligo_tcp_tls_connect_rejects_non_tls_security_modes) {
},
{
.mode = ligo::security_mode::NONE,
}
),
}),
boost::asio::use_future);
auto dtls = boost::asio::co_spawn(
io,
@@ -1605,8 +1600,7 @@ BOOST_AUTO_TEST_CASE(ligo_tcp_tls_connect_rejects_non_tls_security_modes) {
},
{
.mode = ligo::security_mode::DTLS,
}
),
}),
boost::asio::use_future);
io.run();
auto none_result = none.get();
@@ -1685,15 +1679,15 @@ BOOST_AUTO_TEST_CASE(ligo_udp_dtls_reliable_round_trip_succeeds) {
.session_timeout = std::chrono::milliseconds{1000},
};
auto client_result = ligo::udp::client::adopt(std::move(client_socket), server_endpoint, {
.reliability = config,
.security = test_dtls_client_config(),
.session_id = 142,
});
.reliability = config,
.security = test_dtls_client_config(),
.session_id = 142,
});
auto server_result = ligo::udp::server::adopt(std::move(server_socket), client_endpoint, {
.reliability = config,
.security = test_dtls_server_config(),
.session_id = 142,
});
.reliability = config,
.security = test_dtls_server_config(),
.session_id = 142,
});
BOOST_REQUIRE(client_result);
BOOST_REQUIRE(server_result);
auto client = std::move(*client_result);
@@ -1726,15 +1720,15 @@ BOOST_AUTO_TEST_CASE(ligo_udp_dtls_verified_peer_succeeds) {
.session_timeout = std::chrono::milliseconds{1000},
};
auto client_result = ligo::udp::client::adopt(std::move(client_socket), server_endpoint, {
.reliability = config,
.security = test_dtls_verified_client_config("localhost"),
.session_id = 143,
});
.reliability = config,
.security = test_dtls_verified_client_config("localhost"),
.session_id = 143,
});
auto server_result = ligo::udp::server::adopt(std::move(server_socket), client_endpoint, {
.reliability = config,
.security = test_dtls_server_config(),
.session_id = 143,
});
.reliability = config,
.security = test_dtls_server_config(),
.session_id = 143,
});
BOOST_REQUIRE(client_result);
BOOST_REQUIRE(server_result);
auto client = std::move(*client_result);
@@ -1767,15 +1761,15 @@ BOOST_AUTO_TEST_CASE(ligo_udp_dtls_server_peer_verification_succeeds_with_client
.session_timeout = std::chrono::milliseconds{1000},
};
auto client_result = ligo::udp::client::adopt(std::move(client_socket), server_endpoint, {
.reliability = config,
.security = test_dtls_identified_client_config(),
.session_id = 145,
});
.reliability = config,
.security = test_dtls_identified_client_config(),
.session_id = 145,
});
auto server_result = ligo::udp::server::adopt(std::move(server_socket), client_endpoint, {
.reliability = config,
.security = test_dtls_server_verify_client_config(),
.session_id = 145,
});
.reliability = config,
.security = test_dtls_server_verify_client_config(),
.session_id = 145,
});
BOOST_REQUIRE(client_result);
BOOST_REQUIRE(server_result);
auto client = std::move(*client_result);
@@ -1808,15 +1802,15 @@ BOOST_AUTO_TEST_CASE(ligo_udp_dtls_server_peer_verification_fails_without_client
.session_timeout = std::chrono::milliseconds{100},
};
auto client_result = ligo::udp::client::adopt(std::move(client_socket), server_endpoint, {
.reliability = config,
.security = test_dtls_client_config(),
.session_id = 146,
});
.reliability = config,
.security = test_dtls_client_config(),
.session_id = 146,
});
auto server_result = ligo::udp::server::adopt(std::move(server_socket), client_endpoint, {
.reliability = config,
.security = test_dtls_server_verify_client_config(),
.session_id = 146,
});
.reliability = config,
.security = test_dtls_server_verify_client_config(),
.session_id = 146,
});
BOOST_REQUIRE(client_result);
BOOST_REQUIRE(server_result);
auto client = std::move(*client_result);
@@ -1825,7 +1819,7 @@ BOOST_AUTO_TEST_CASE(ligo_udp_dtls_server_peer_verification_fails_without_client
auto received = boost::asio::co_spawn(io, server.receive(), boost::asio::use_future);
auto stopper = boost::asio::steady_timer{io};
stopper.expires_after(std::chrono::milliseconds{200});
stopper.async_wait([&client, &server](boost::system::error_code const&) {
stopper.async_wait([&client, &server](boost::system::error_code const &) {
client.close();
server.close();
});
@@ -1854,19 +1848,19 @@ BOOST_AUTO_TEST_CASE(ligo_udp_dtls_untrusted_peer_fails) {
.session_timeout = std::chrono::milliseconds{100},
};
auto client_result = ligo::udp::client::adopt(std::move(client_socket), server_endpoint, {
.reliability = config,
.security = {
.mode = ligo::security_mode::DTLS,
.verify = ligo::verify_mode::PEER,
.peer_name = "localhost",
},
.session_id = 144,
});
.reliability = config,
.security = {
.mode = ligo::security_mode::DTLS,
.verify = ligo::verify_mode::PEER,
.peer_name = "localhost",
},
.session_id = 144,
});
auto server_result = ligo::udp::server::adopt(std::move(server_socket), client_endpoint, {
.reliability = config,
.security = test_dtls_server_config(),
.session_id = 144,
});
.reliability = config,
.security = test_dtls_server_config(),
.session_id = 144,
});
BOOST_REQUIRE(client_result);
BOOST_REQUIRE(server_result);
auto client = std::move(*client_result);
@@ -1875,7 +1869,7 @@ BOOST_AUTO_TEST_CASE(ligo_udp_dtls_untrusted_peer_fails) {
auto received = boost::asio::co_spawn(io, server.receive(), boost::asio::use_future);
auto stopper = boost::asio::steady_timer{io};
stopper.expires_after(std::chrono::milliseconds{200});
stopper.async_wait([&client, &server](boost::system::error_code const&) {
stopper.async_wait([&client, &server](boost::system::error_code const &) {
client.close();
server.close();
});
@@ -1893,16 +1887,17 @@ BOOST_AUTO_TEST_CASE(ligo_udp_dtls_server_requires_identity) {
9,
};
auto server = ligo::udp::server::bind(io.get_executor(), {
.local = {
boost::asio::ip::udp::v4(),
0,
},
.peer = peer,
}, {
.security = {
.mode = ligo::security_mode::DTLS,
},
});
.local = {
boost::asio::ip::udp::v4(),
0,
},
.peer = peer,
},
{
.security = {
.mode = ligo::security_mode::DTLS,
},
});
BOOST_CHECK(!server);
BOOST_CHECK((server.error().code()) == (ligo::detail::error_invalid_argument));
}
@@ -1996,9 +1991,10 @@ BOOST_AUTO_TEST_CASE(ligo_udp_wrong_session_times_out) {
.session_timeout = std::chrono::milliseconds{20},
};
auto channel_result = udp_client_bind(io, boost::asio::ip::udp::endpoint{
boost::asio::ip::udp::v4(),
0,
}, receiver_endpoint, config, 7);
boost::asio::ip::udp::v4(),
0,
},
receiver_endpoint, config, 7);
BOOST_REQUIRE(channel_result);
auto channel = std::move(*channel_result);
auto future = boost::asio::co_spawn(io, channel.send(boost::json::object{}), boost::asio::use_future);
@@ -2022,9 +2018,10 @@ BOOST_AUTO_TEST_CASE(ligo_udp_oversized_payload_returns_invalid_argument) {
receiver.local_endpoint().port(),
};
auto channel_result = udp_client_bind(io, boost::asio::ip::udp::endpoint{
boost::asio::ip::udp::v4(),
0,
}, receiver_endpoint);
boost::asio::ip::udp::v4(),
0,
},
receiver_endpoint);
BOOST_REQUIRE(channel_result);
auto channel = std::move(*channel_result);
auto payload = boost::json::value{
@@ -2051,15 +2048,16 @@ BOOST_AUTO_TEST_CASE(ligo_udp_close_wakes_pending_receive) {
right_socket.local_endpoint().port(),
};
auto channel_result = udp_client_bind(io, boost::asio::ip::udp::endpoint{
boost::asio::ip::udp::v4(),
0,
}, right_endpoint);
boost::asio::ip::udp::v4(),
0,
},
right_endpoint);
BOOST_REQUIRE(channel_result);
auto channel = std::move(*channel_result);
auto received = boost::asio::co_spawn(io, channel.receive(), boost::asio::use_future);
auto timer = boost::asio::steady_timer{io};
timer.expires_after(std::chrono::milliseconds{5});
timer.async_wait([&channel](boost::system::error_code const&) {
timer.async_wait([&channel](boost::system::error_code const &) {
channel.close();
});
io.run();
@@ -2082,9 +2080,10 @@ BOOST_AUTO_TEST_CASE(ligo_udp_async_close_drains_pending_receive) {
right_socket.local_endpoint().port(),
};
auto channel_result = udp_client_bind(io, boost::asio::ip::udp::endpoint{
boost::asio::ip::udp::v4(),
0,
}, right_endpoint);
boost::asio::ip::udp::v4(),
0,
},
right_endpoint);
BOOST_REQUIRE(channel_result);
auto channel = std::move(*channel_result);
auto received = boost::asio::co_spawn(io, channel.receive(), boost::asio::use_future);
@@ -2115,9 +2114,10 @@ BOOST_AUTO_TEST_CASE(ligo_udp_async_close_drains_pending_send) {
.session_timeout = std::chrono::milliseconds{1000},
};
auto channel_result = udp_client_bind(io, boost::asio::ip::udp::endpoint{
boost::asio::ip::udp::v4(),
0,
}, receiver_endpoint, config, 171);
boost::asio::ip::udp::v4(),
0,
},
receiver_endpoint, config, 171);
BOOST_REQUIRE(channel_result);
auto channel = std::move(*channel_result);
auto sent = boost::asio::co_spawn(io, channel.send(boost::json::object{}), boost::asio::use_future);
@@ -2143,9 +2143,10 @@ BOOST_AUTO_TEST_CASE(ligo_udp_async_close_moved_from_channel_is_ok) {
right_socket.local_endpoint().port(),
};
auto channel_result = udp_client_bind(io, boost::asio::ip::udp::endpoint{
boost::asio::ip::udp::v4(),
0,
}, right_endpoint);
boost::asio::ip::udp::v4(),
0,
},
right_endpoint);
BOOST_REQUIRE(channel_result);
auto channel = std::move(*channel_result);
auto moved = std::move(channel);
@@ -2169,9 +2170,10 @@ BOOST_AUTO_TEST_CASE(ligo_udp_async_close_rejects_invalid_timeout) {
right_socket.local_endpoint().port(),
};
auto channel_result = udp_client_bind(io, boost::asio::ip::udp::endpoint{
boost::asio::ip::udp::v4(),
0,
}, right_endpoint);
boost::asio::ip::udp::v4(),
0,
},
right_endpoint);
BOOST_REQUIRE(channel_result);
auto channel = std::move(*channel_result);
auto closed = boost::asio::co_spawn(io, channel.async_close(std::chrono::milliseconds{0}), boost::asio::use_future);