vacp2p/nim-libp2p
1
0
Fork 0
mirror of https://github.com/vacp2p/nim-libp2p.git synced 2025-03-03 17:40:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

review comment fix

Browse Source
This commit is contained in:
shashankshampi 2024-10-22 10:58:42 +05:30
parent 44dd7d1c3c
commit d80abe09ae
1 changed files with 28 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

84
tests/pubsub/testgossipmembership.nim
View File

@ -216,88 +216,60 @@ suite "GossipSub Topic Membership Tests":
await gossipSub.switch.stop()
# Test for verifying peers leaving a topic using `LEAVE(topic)`
asyncTest "handle LEAVE topic and mesh is updated":
let topic = "test-leave-topic"
# Initialize the GossipSub system and simulate peer connections
let (gossipSub, conns) = setupGossipSub(topic, 5)
# Simulate peer joining the topic using commonSubscribe
commonSubscribe(@[gossipSub], topic, voidTopicHandler)
# Now simulate peer leaving the topic using commonUnsubscribe
commonUnsubscribe(@[gossipSub], topic, voidTopicHandler)
# Check that peers are removed from the mesh but the topic remains in gossipsub
check topic notin gossipSub.mesh
check topic in gossipSub.gossipsub
await allFuturesThrowing(conns.mapIt(it.close()))
await gossipSub.switch.stop()
# Test the behavior when multiple peers join and leave a topic simultaneously.
asyncTest "multiple peers join and leave topic simultaneously":
let
numberOfNodes = 6
topic = "foobar"
nodes = generateNodes(numberOfNodes, gossip = true)
nodesFut = await allFinished(nodes.mapIt(it.switch.start()))
var nodes = newSeq[TestGossipSub]()
# Subscribe all nodes to the topic
await subscribeNodes(nodes)
for node in nodes:
node.subscribe(topic, voidTopicHandler)
# Initialize each node and start the switch
for i in 0 ..< numberOfNodes:
let (gossipSub, _) = setupGossipSub(topic, 5)
nodes.add(gossipSub) # Add the gossipSub instance to the sequence
await gossipSub.switch.start()
# Subscribe all nodes to the topic using the commonSubscribe method
commonSubscribe(nodes, topic, voidTopicHandler)
# Allow time for subscription propagation
await sleepAsync(2 * DURATION_TIMEOUT)
# Ensure each node is subscribed by checking the gossipsub field
# Ensure that all nodes are subscribed to the topic
for i in 0 ..< numberOfNodes:
let currentGossip = GossipSub(nodes[i]) # Rename to 'currentGossip'
doAssert currentGossip.gossipsub.hasKey(topic),
"Node is not subscribed to the topic"
# Print mesh status before connecting nodes
echo "Initial mesh size:"
for i in 0 ..< numberOfNodes:
let currentGossip = GossipSub(nodes[i]) # Rename to 'currentGossip'
echo "Node ", i, " mesh size: ", currentGossip.mesh.getOrDefault(topic).len
# Connect all nodes to each other and ensure subscription propagation
for x in 0 ..< numberOfNodes:
for y in 0 ..< numberOfNodes:
if x != y:
await waitSub(nodes[x], nodes[y], topic)
let currentGossip = nodes[i]
doAssert currentGossip.gossipsub.hasKey(topic), "Node is not subscribed to the topic"
# Allow time for mesh stabilization
await sleepAsync(2 * DURATION_TIMEOUT)
# Print mesh status after stabilization
echo "Mesh size after connecting:"
# Print the mesh size for all nodes before unsubscription
for i in 0 ..< numberOfNodes:
let currentGossip = GossipSub(nodes[i]) # Rename to 'currentGossip'
let currentGossip = nodes[i]
echo "Node ", i, " mesh size: ", currentGossip.mesh.getOrDefault(topic).len
# Expected number of peers in the mesh
let expectedNumberOfPeers = numberOfNodes - 1
for i in 0 ..< numberOfNodes:
let currentGossip = GossipSub(nodes[i]) # Rename to 'currentGossip'
let currentGossip = nodes[i]
check:
currentGossip.gossipsub[topic].len == expectedNumberOfPeers
currentGossip.mesh[topic].len == expectedNumberOfPeers
currentGossip.fanout.len == 0
# Simulate unsubscription of 3 peers
let firstNodeGossip = GossipSub(nodes[0]) # Initialize for the first node
let peersToUnsubscribe = firstNodeGossip.mesh[topic].toSeq()[0 .. 2]
for peer in peersToUnsubscribe:
firstNodeGossip.unsubscribe(topic, voidTopicHandler)
echo "Unsubscribing peer: ", peer.peerId
let peersToUnsubscribe = nodes[0].mesh[topic].toSeq()[0 .. 2]
# Unsubscribe these peers from all the nodes
for node in nodes:
for peer in peersToUnsubscribe:
node.unsubscribe(topic, voidTopicHandler)
echo "Unsubscribing peer: ", peer.peerId
# Allow time for heartbeat to adjust the mesh
await sleepAsync(3 * DURATION_TIMEOUT) # Increased delay for mesh stabilization
await sleepAsync(3 * DURATION_TIMEOUT)
# Check mesh status again, expecting remaining peers
# Check the mesh size for the first node after unsubscription
let firstNodeGossip = nodes[0]
echo "Mesh size after unsubscription: ",
firstNodeGossip.mesh.getOrDefault(topic).len
doAssert firstNodeGossip.mesh.getOrDefault(topic).len == 3,
@ -305,8 +277,8 @@ suite "GossipSub Topic Membership Tests":
# Assert that unsubscribed peers are no longer in the mesh
for peer in peersToUnsubscribe:
doAssert not firstNodeGossip.mesh[topic].contains(peer),
"Unsubscribed peer should not be in the mesh"
for node in nodes:
doAssert not node.mesh[topic].contains(peer),
"Unsubscribed peer should not be in the mesh"
# Cleanup: stop all nodes
await allFuturesThrowing(nodes.mapIt(allFutures(it.switch.stop())))