Minecon724/dncurrency
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions 1

Fix tests

Browse source
This commit is contained in:
Piotr Wójcik 2024-05-06 00:03:14 +02:00
commit 42f0d465c6
9 changed files with 47 additions and 65 deletions
Download patch file Download diff file Expand all files Collapse all files

1
nano/core_test/active_elections.cpp
View file

@ -437,6 +437,7 @@ TEST (inactive_votes_cache, election_start)
nano::test::system system;
nano::node_config node_config = system.default_config ();
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
node_config.priority_scheduler.enabled = false;
node_config.optimistic_scheduler.enabled = false;
auto & node = *system.add_node (node_config);
nano::block_hash latest (node.latest (nano::dev::genesis_key.pub));

6
nano/core_test/bootstrap.cpp
View file

@ -291,7 +291,7 @@ TEST (bootstrap_processor, process_none)
auto node0 = system.nodes[0];
auto node1 = system.make_disconnected_node ();
bool done = false;
std::atomic<bool> done = false;
node0->observers.socket_connected.add ([&] (nano::transport::socket & socket) {
done = true;
});
@ -1652,10 +1652,6 @@ TEST (bootstrap_processor, multiple_attempts)
auto lazy_attempt (node2->bootstrap_initiator.current_lazy_attempt ());
auto legacy_attempt (node2->bootstrap_initiator.current_attempt ());
ASSERT_TIMELY (5s, lazy_attempt->started && legacy_attempt->started);
// Check that both bootstrap attempts are running & not finished
ASSERT_FALSE (lazy_attempt->stopped);
ASSERT_FALSE (legacy_attempt->stopped);
ASSERT_GE (node2->bootstrap_initiator.attempts.size (), 2);
// Check processed blocks
ASSERT_TIMELY (10s, node2->balance (key2.pub) != 0);
// Check attempts finish

15
nano/core_test/network.cpp
View file

@ -411,7 +411,6 @@ TEST (receivable_processor, send_with_receive)
nano::keypair key2;
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
nano::block_hash latest1 (node1.latest (nano::dev::genesis_key.pub));
system.wallet (1)->insert_adhoc (key2.prv);
nano::block_builder builder;
auto block1 = builder
.send ()
@ -433,6 +432,7 @@ TEST (receivable_processor, send_with_receive)
ASSERT_EQ (0, node1.balance (key2.pub));
ASSERT_EQ (amount - node1.config.receive_minimum.number (), node2.balance (nano::dev::genesis_key.pub));
ASSERT_EQ (0, node2.balance (key2.pub));
system.wallet (1)->insert_adhoc (key2.prv);
ASSERT_TIMELY (10s, node1.balance (key2.pub) == node1.config.receive_minimum.number () && node2.balance (key2.pub) == node1.config.receive_minimum.number ());
ASSERT_EQ (amount - node1.config.receive_minimum.number (), node1.balance (nano::dev::genesis_key.pub));
ASSERT_EQ (node1.config.receive_minimum.number (), node1.balance (key2.pub));
@ -644,9 +644,9 @@ TEST (network, peer_max_tcp_attempts)
// Start TCP attempt
node->network.merge_peer (node2->network.endpoint ());
}
ASSERT_EQ (0, node->network.size ());
ASSERT_TIMELY_EQ (30s, node->network.size (), node->network_params.network.max_peers_per_ip);
ASSERT_FALSE (node->network.tcp_channels.track_reachout (nano::endpoint (node->network.endpoint ().address (), system.get_available_port ())));
ASSERT_EQ (1, node->stats.count (nano::stat::type::tcp, nano::stat::detail::max_per_ip, nano::stat::dir::out));
ASSERT_LE (1, node->stats.count (nano::stat::type::tcp, nano::stat::detail::max_per_ip, nano::stat::dir::out));
}
#endif
@ -896,15 +896,16 @@ TEST (network, cleanup_purge)
node1.network.cleanup (std::chrono::steady_clock::now ());
ASSERT_EQ (0, node1.network.size ());
std::weak_ptr<nano::node> node_w = node1.shared ();
node1.network.tcp_channels.start_tcp (node2->network.endpoint ());
node1.network.merge_peer (node2->network.endpoint ());
ASSERT_TIMELY_EQ (5s, node1.network.size (), 1);
ASSERT_TIMELY_EQ (3s, node1.network.size (), 1);
node1.network.cleanup (test_start);
ASSERT_EQ (1, node1.network.size ());
ASSERT_EQ (0, node1.stats.count (nano::stat::type::tcp_channels_purge));
node1.network.cleanup (std::chrono::steady_clock::now ());
ASSERT_TIMELY_EQ (5s, 0, node1.network.size ());
ASSERT_EQ (1, node1.stats.count (nano::stat::type::tcp_channels_purge, nano::stat::detail::idle));
}
TEST (network, loopback_channel)

2
nano/core_test/node.cpp
View file

@ -276,7 +276,6 @@ TEST (node, auto_bootstrap)
node1->start ();
system.nodes.push_back (node1);
ASSERT_NE (nullptr, nano::test::establish_tcp (system, *node1, node0->network.endpoint ()));
ASSERT_TIMELY (10s, node1->bootstrap_initiator.in_progress ());
ASSERT_TIMELY_EQ (10s, node1->balance (key2.pub), node0->config.receive_minimum.number ());
ASSERT_TIMELY (10s, !node1->bootstrap_initiator.in_progress ());
ASSERT_TRUE (node1->block_or_pruned_exists (send1->hash ()));
@ -322,7 +321,6 @@ TEST (node, auto_bootstrap_age)
node1->start ();
system.nodes.push_back (node1);
ASSERT_NE (nullptr, nano::test::establish_tcp (system, *node1, node0->network.endpoint ()));
ASSERT_TIMELY (10s, node1->bootstrap_initiator.in_progress ());
// 4 bootstraps with frontiers age
ASSERT_TIMELY (10s, node0->stats.count (nano::stat::type::bootstrap, nano::stat::detail::initiate_legacy_age, nano::stat::dir::out) >= 3);
// More attempts with frontiers age

9
nano/core_test/peer_container.cpp
View file

@ -215,6 +215,10 @@ TEST (peer_container, list_fanout)
TEST (peer_container, reachout)
{
nano::test::system system;
nano::node_config node_config = system.default_config ();
// Disable automatic reachout
node_config.network.cached_peer_reachout = 0s;
node_config.network.peer_reachout = 0s;
nano::node_flags node_flags;
auto & node1 = *system.add_node (node_flags);
auto outer_node1 = nano::test::add_outer_node (system);
@ -222,6 +226,7 @@ TEST (peer_container, reachout)
// Make sure having been contacted by them already indicates we shouldn't reach out
ASSERT_FALSE (node1.network.track_reachout (outer_node1->network.endpoint ()));
auto outer_node2 = nano::test::add_outer_node (system);
auto outer_node2_endpoint = outer_node2->network.endpoint ();
ASSERT_TRUE (node1.network.track_reachout (outer_node2->network.endpoint ()));
ASSERT_NE (nullptr, nano::test::establish_tcp (system, node1, outer_node2->network.endpoint ()));
// Reaching out to them once should signal we shouldn't reach out again.
@ -230,9 +235,11 @@ TEST (peer_container, reachout)
node1.network.cleanup (std::chrono::steady_clock::now () - std::chrono::seconds (10));
ASSERT_FALSE (node1.network.track_reachout (outer_node2->network.endpoint ()));
// Make sure we purge old items
outer_node1->stop ();
outer_node2->stop ();
node1.network.cleanup (std::chrono::steady_clock::now () + std::chrono::seconds (10));
ASSERT_TIMELY (5s, node1.network.empty ());
ASSERT_TRUE (node1.network.track_reachout (outer_node2->network.endpoint ()));
ASSERT_TRUE (node1.network.track_reachout (outer_node2_endpoint));
}
// This test is similar to network.filter_invalid_version_using with the difference that

32
nano/core_test/request_aggregator.cpp
View file

@ -100,28 +100,28 @@ TEST (request_aggregator, one_update)
.work (*node.work_generate_blocking (key1.pub))
.build ();
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.ledger.tx_begin_write (), receive1));
std::vector<std::pair<nano::block_hash, nano::root>> request;
request.emplace_back (send2->hash (), send2->root ());
auto client = std::make_shared<nano::transport::socket> (node);
std::shared_ptr<nano::transport::channel> dummy_channel = std::make_shared<nano::transport::channel_tcp> (node, client);
node.aggregator.request (request, dummy_channel);
request.clear ();
request.emplace_back (receive1->hash (), receive1->root ());
auto dummy_channel = nano::test::fake_channel (node);
std::vector<std::pair<nano::block_hash, nano::root>> request1{ { send2->hash (), send2->root () } };
node.aggregator.request (request1, dummy_channel);
// Update the pool of requests with another hash
node.aggregator.request (request, dummy_channel);
std::vector<std::pair<nano::block_hash, nano::root>> request2{ { receive1->hash (), receive1->root () } };
node.aggregator.request (request2, dummy_channel);
// In the ledger but no vote generated yet
ASSERT_TIMELY (3s, 0 < node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_generated_votes))
ASSERT_TRUE (node.aggregator.empty ());
ASSERT_TIMELY_EQ (3s, 2, node.stats.count (nano::stat::type::aggregator, nano::stat::detail::aggregator_accepted));
ASSERT_TIMELY_EQ (3s, 0, node.stats.count (nano::stat::type::aggregator, nano::stat::detail::aggregator_dropped));
ASSERT_TIMELY_EQ (3s, 0, node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_unknown));
ASSERT_TIMELY_EQ (3s, 2, node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_generated_hashes));
size_t count = 0;
ASSERT_TIMELY_EQ (3s, 1, (count = node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_generated_votes)));
ASSERT_TIMELY_EQ (3s, 0, node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_cached_hashes));
ASSERT_TIMELY_EQ (3s, 0, node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_cached_votes));
ASSERT_TIMELY_EQ (3s, 0, node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_cannot_vote));
ASSERT_TIMELY_EQ (3s, 1, node.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::out));
ASSERT_EQ (0, node.stats.count (nano::stat::type::aggregator, nano::stat::detail::aggregator_dropped));
ASSERT_EQ (0, node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_unknown));
ASSERT_TIMELY (3s, 0 < node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_generated_votes));
ASSERT_EQ (0, node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_cached_hashes));
ASSERT_EQ (0, node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_cached_votes));
ASSERT_EQ (0, node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_cannot_vote));
}
TEST (request_aggregator, two)

36
nano/core_test/socket.cpp
View file

@ -11,6 +11,7 @@
#include <boost/asio/read.hpp>
#include <future>
#include <map>
#include <memory>
#include <utility>
@ -27,8 +28,6 @@ TEST (socket, max_connections)
nano::inactive_node inactivenode (nano::unique_path (), node_flags);
auto node = inactivenode.node;
nano::thread_runner runner{ node->io_ctx_shared, nano::default_logger (), 1 };
auto server_port = system.get_available_port ();
// successful incoming connections are stored in server_sockets to keep them alive (server side)
@ -135,8 +134,6 @@ TEST (socket, max_connections_per_ip)
auto node = inactivenode.node;
ASSERT_FALSE (node->flags.disable_max_peers_per_ip);
nano::thread_runner runner{ node->io_ctx_shared, nano::default_logger (), 1 };
auto server_port = system.get_available_port ();
const auto max_ip_connections = node->network_params.network.max_peers_per_ip;
@ -252,8 +249,6 @@ TEST (socket, max_connections_per_subnetwork)
ASSERT_TRUE (node->flags.disable_max_peers_per_ip);
ASSERT_FALSE (node->flags.disable_max_peers_per_subnetwork);
nano::thread_runner runner{ node->io_ctx_shared, nano::default_logger (), 1 };
auto server_port = system.get_available_port ();
boost::asio::ip::tcp::endpoint listen_endpoint{ boost::asio::ip::address_v6::any (), server_port };
@ -311,8 +306,6 @@ TEST (socket, disabled_max_peers_per_ip)
ASSERT_TRUE (node->flags.disable_max_peers_per_ip);
nano::thread_runner runner{ node->io_ctx_shared, nano::default_logger (), 1 };
auto server_port = system.get_available_port ();
const auto max_ip_connections = node->network_params.network.max_peers_per_ip;
@ -370,9 +363,10 @@ TEST (socket, disconnection_of_silent_connections)
auto node = system.add_node (config);
// On a connection, a server data socket is created. The shared pointer guarantees the object's lifecycle until the end of this test.
std::shared_ptr<nano::transport::socket> server_data_socket;
node->tcp_listener.connection_accepted.add ([&server_data_socket] (auto const & socket, auto const & server) {
server_data_socket = socket;
std::promise<std::shared_ptr<nano::transport::socket>> server_data_socket_promise;
std::future<std::shared_ptr<nano::transport::socket>> server_data_socket_future = server_data_socket_promise.get_future ();
node->tcp_listener.connection_accepted.add ([&server_data_socket_promise] (auto const & socket, auto const & server) {
server_data_socket_promise.set_value (socket);
});
boost::asio::ip::tcp::endpoint dst_endpoint{ boost::asio::ip::address_v6::loopback (), node->tcp_listener.endpoint ().port () };
@ -386,8 +380,10 @@ TEST (socket, disconnection_of_silent_connections)
connected = true;
});
ASSERT_TIMELY (4s, connected);
// Checking the connection was closed.
ASSERT_TIMELY (10s, server_data_socket != nullptr);
ASSERT_TIMELY (10s, server_data_socket_future.wait_for (0s) == std::future_status::ready);
auto server_data_socket = server_data_socket_future.get ();
ASSERT_TIMELY (10s, server_data_socket->is_closed ());
// Just to ensure the disconnection wasn't due to the timer timeout.
@ -405,8 +401,6 @@ TEST (socket, drop_policy)
nano::inactive_node inactivenode (nano::unique_path (), node_flags);
auto node = inactivenode.node;
nano::thread_runner runner{ node->io_ctx_shared, nano::default_logger (), 1 };
std::vector<std::shared_ptr<nano::transport::socket>> connections;
auto func = [&] (size_t total_message_count, nano::transport::buffer_drop_policy drop_policy) {
@ -454,12 +448,10 @@ TEST (socket, drop_policy)
// The stats are accumulated from before
ASSERT_EQ (1, node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_write_no_socket_drop, nano::stat::dir::out));
ASSERT_EQ (1, node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_write_drop, nano::stat::dir::out));
node->stop ();
runner.abort ();
runner.join ();
}
// This is abusing the socket class, it's interfering with the normal node lifetimes and as a result deadlocks
// TEST (socket, DISABLED_concurrent_writes)
TEST (socket, concurrent_writes)
{
nano::test::system system;
@ -471,10 +463,6 @@ TEST (socket, concurrent_writes)
nano::inactive_node inactivenode (nano::unique_path (), node_flags);
auto node = inactivenode.node;
// This gives more realistic execution than using system#poll, allowing writes to
// queue up and drain concurrently.
nano::thread_runner runner{ node->io_ctx_shared, nano::default_logger (), 1 };
constexpr size_t max_connections = 4;
constexpr size_t client_count = max_connections;
constexpr size_t message_count = 4;
@ -567,10 +555,6 @@ TEST (socket, concurrent_writes)
ASSERT_TIMELY_EQ (10s, completed_reads, total_message_count);
node->stop ();
runner.abort ();
runner.join ();
for (auto & t : client_threads)
{
t.join ();

6
nano/qt_test/qt.cpp
View file

@ -83,13 +83,7 @@ TEST (wallet, status_with_peer)
};
// Because of the wallet "vulnerable" message, this won't be the message displayed.
// However, it will still be part of the status set.
ASSERT_FALSE (wallet_has (nano_qt::status_types::synchronizing));
system.deadline_set (25s);
while (!wallet_has (nano_qt::status_types::synchronizing))
{
test_application->processEvents ();
ASSERT_NO_ERROR (system.poll ());
}
system.nodes[0]->network.cleanup (std::chrono::steady_clock::now () + std::chrono::seconds (5));
while (wallet_has (nano_qt::status_types::synchronizing))
{

5
nano/rpc_test/rpc.cpp
View file

@ -6453,7 +6453,8 @@ TEST (rpc, epoch_upgrade_multithreaded)
}
}
TEST (rpc, account_lazy_start)
// FIXME: This test is testing legacy bootstrap, the current behavior is different
TEST (rpc, DISABLED_account_lazy_start)
{
nano::test::system system{};
nano::node_flags node_flags{};
@ -6650,7 +6651,7 @@ TEST (rpc, receive_pruned)
wallet2->insert_adhoc (key1.prv);
auto send1 (wallet1->send_action (nano::dev::genesis_key.pub, key1.pub, node2->config.receive_minimum.number (), *node2->work_generate_blocking (nano::dev::genesis->hash ())));
ASSERT_TIMELY (5s, node2->balance (nano::dev::genesis_key.pub) != nano::dev::constants.genesis_amount);
ASSERT_TIMELY (10s, !node2->store.account.exists (node2->store.tx_begin_read (), key1.pub));
ASSERT_TIMELY (10s, node2->store.account.exists (node2->store.tx_begin_read (), key1.pub));
// Send below minimum receive amount
auto send2 (wallet1->send_action (nano::dev::genesis_key.pub, key1.pub, node2->config.receive_minimum.number () - 1, *node2->work_generate_blocking (send1->hash ())));
// Extra send frontier