fluencelabs/rust-libp2p
1
0
Fork 0
mirror of https://github.com/fluencelabs/rust-libp2p synced 2025-05-12 02:47:15 +00:00
Code Issues Projects Releases Wiki Activity

fix(kad): rewrite tests to be less flaky

Browse Source 
Not sure why but these tests have recently been quite flaky and are blocking several PRs.

Pull-Request: #4634.
This commit is contained in:
Thomas Eizinger 2023-10-13 15:18:19 +11:00 committed by GitHub
parent 497f393987
commit 7120529c6d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 53 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

110
protocols/kad/tests/client_mode.rs
View File

@ -2,8 +2,10 @@ use libp2p_identify as identify;
use libp2p_identity as identity;
use libp2p_kad::store::MemoryStore;
use libp2p_kad::{Behaviour, Config, Event, Mode};
use libp2p_swarm::Swarm;
use libp2p_swarm::{Swarm, SwarmEvent};
use libp2p_swarm_test::SwarmExt;
use Event::*;
use MyBehaviourEvent::*;
#[async_std::test]
async fn server_gets_added_to_routing_table_by_client() {
@ -16,16 +18,16 @@ async fn server_gets_added_to_routing_table_by_client() {
client.connect(&mut server).await;
let server_peer_id = *server.local_peer_id();
async_std::task::spawn(server.loop_on_next());
match libp2p_swarm_test::drive(&mut client, &mut server).await {
(
[MyBehaviourEvent::Identify(_), MyBehaviourEvent::Identify(_), MyBehaviourEvent::Kad(Event::RoutingUpdated { peer, .. })],
[MyBehaviourEvent::Identify(_), MyBehaviourEvent::Identify(_)],
) => {
assert_eq!(peer, server_peer_id)
}
other => panic!("Unexpected events: {other:?}"),
}
let peer = client
.wait(|e| match e {
SwarmEvent::Behaviour(Kad(RoutingUpdated { peer, .. })) => Some(peer),
_ => None,
})
.await;
assert_eq!(peer, server_peer_id);
}
#[async_std::test]
@ -41,12 +43,10 @@ async fn two_servers_add_each_other_to_routing_table() {
let server1_peer_id = *server1.local_peer_id();
let server2_peer_id = *server2.local_peer_id();
use Event::*;
use MyBehaviourEvent::*;
match libp2p_swarm_test::drive(&mut server1, &mut server2).await {
(
[Identify(_), Identify(_), Kad(RoutingUpdated { peer: peer1, .. })],
[Identify(_), Identify(_), Kad(RoutingUpdated { peer: peer1, .. })]
| [Identify(_), Kad(RoutingUpdated { peer: peer1, .. }), Identify(_)],
[Identify(_), Identify(_)],
) => {
assert_eq!(peer1, server2_peer_id);
@ -57,19 +57,16 @@ async fn two_servers_add_each_other_to_routing_table() {
server1.listen().await;
server2.connect(&mut server1).await;
match libp2p_swarm_test::drive(&mut server2, &mut server1).await {
(
[Identify(_), Kad(RoutingUpdated { peer: peer2, .. }), Identify(_)],
[Identify(_), Identify(_)],
)
| (
[Identify(_), Identify(_), Kad(RoutingUpdated { peer: peer2, .. })],
[Identify(_), Identify(_)],
) => {
assert_eq!(peer2, server1_peer_id);
}
other => panic!("Unexpected events: {other:?}"),
}
async_std::task::spawn(server1.loop_on_next());
let peer = server2
.wait(|e| match e {
SwarmEvent::Behaviour(Kad(RoutingUpdated { peer, .. })) => Some(peer),
_ => None,
})
.await;
assert_eq!(peer, server1_peer_id);
}
#[async_std::test]
@ -85,17 +82,12 @@ async fn adding_an_external_addresses_activates_server_mode_on_existing_connecti
// Remove memory address to simulate a server that doesn't know its external address.
server.remove_external_address(&memory_addr);
client.dial(memory_addr.clone()).unwrap();
use MyBehaviourEvent::*;
// Do the usual identify send/receive dance.
match libp2p_swarm_test::drive(&mut client, &mut server).await {
([Identify(_), Identify(_)], [Identify(_), Identify(_)]) => {}
other => panic!("Unexpected events: {other:?}"),
}
use Event::*;
// Server learns its external address (this could be through AutoNAT or some other mechanism).
server.add_external_address(memory_addr);
@ -125,34 +117,38 @@ async fn set_client_to_server_mode() {
let server_peer_id = *server.local_peer_id();
match libp2p_swarm_test::drive(&mut client, &mut server).await {
(
[MyBehaviourEvent::Identify(_), MyBehaviourEvent::Identify(_), MyBehaviourEvent::Kad(Event::RoutingUpdated { peer, .. })],
[MyBehaviourEvent::Identify(_), MyBehaviourEvent::Identify(identify::Event::Received { info, .. })],
) => {
assert_eq!(peer, server_peer_id);
assert!(info
.protocols
.iter()
.all(|proto| libp2p_kad::PROTOCOL_NAME.ne(proto)))
}
other => panic!("Unexpected events: {other:?}"),
}
let client_event = client.wait(|e| match e {
SwarmEvent::Behaviour(Kad(RoutingUpdated { peer, .. })) => Some(peer),
_ => None,
});
let server_event = server.wait(|e| match e {
SwarmEvent::Behaviour(Identify(identify::Event::Received { info, .. })) => Some(info),
_ => None,
});
let (peer, info) = futures::future::join(client_event, server_event).await;
assert_eq!(peer, server_peer_id);
assert!(info
.protocols
.iter()
.all(|proto| libp2p_kad::PROTOCOL_NAME.ne(proto)));
client.behaviour_mut().kad.set_mode(Some(Mode::Server));
match libp2p_swarm_test::drive(&mut client, &mut server).await {
(
[MyBehaviourEvent::Identify(_)],
[MyBehaviourEvent::Identify(identify::Event::Received { info, .. }), MyBehaviourEvent::Kad(_)],
) => {
assert!(info
.protocols
.iter()
.any(|proto| libp2p_kad::PROTOCOL_NAME.eq(proto)))
}
other => panic!("Unexpected events: {other:?}"),
}
async_std::task::spawn(client.loop_on_next());
let info = server
.wait(|e| match e {
SwarmEvent::Behaviour(Identify(identify::Event::Received { info, .. })) => Some(info),
_ => None,
})
.await;
assert!(info
.protocols
.iter()
.any(|proto| libp2p_kad::PROTOCOL_NAME.eq(proto)));
}
#[derive(libp2p_swarm::NetworkBehaviour)]