logos-messaging/logos-messaging-nim
1
0
Fork 0
mirror of https://github.com/logos-messaging/logos-messaging-nim.git synced 2026-07-02 06:19:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix: remove hardcoded ports in tests (#3998)

Browse Source 
* Remove hardcoded ports in tests
* Promote getPorts to a public helper in net/net_config.nim
* Make 0.0.0.0:0 a default argument for newTestWakuNode
This commit is contained in:
Fabiana Cecin 2026-06-30 14:59:27 -03:00 committed by GitHub
parent a45b785141
commit 7b6d5d542c
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
33 changed files with 412 additions and 670 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
logos_delivery/waku/net/auto_port.nim
View File

@ -9,7 +9,7 @@ const
AutoPortMax = 59000'u16
AutoPortAttemptTimeout = chronos.seconds(30)
proc getAutoPort*(): uint16 =
proc getAutoPort(): uint16 =
var rng = initRand()
uint16(rng.rand(AutoPortMin.int .. AutoPortMax.int))

30
logos_delivery/waku/net/net_config.nim
View File

@ -1,7 +1,9 @@
{.push raises: [].}
import
std/[options, sequtils, strutils, net], results, libp2p/[multiaddress, multicodec]
std/[options, sequtils, strutils, net],
results,
libp2p/[multiaddress, multicodec, wire]
import ../../waku/waku_core/peers
import ../waku_enr
@ -74,6 +76,32 @@ proc isWsAddress*(ma: MultiAddress): bool =
proc isQuicAddress*(ma: MultiAddress): bool =
return ma.hasProtocol("quic-v1")
proc isP2pTcpAddress*(ma: MultiAddress): bool =
return ma.hasProtocol("tcp") and not ma.isWsAddress()
proc getPorts*(
listenAddrs: seq[MultiAddress]
): Result[tuple[tcpPort, websocketPort, quicPort: Option[Port]], string] =
var tcpPort, websocketPort, quicPort = none(Port)
for a in listenAddrs:
if a.isWsAddress():
if websocketPort.isNone():
let wsAddress = initTAddress(a).valueOr:
return err("getPorts wsAddr error:" & $error)
websocketPort = some(wsAddress.port)
elif a.isQuicAddress():
if quicPort.isNone():
let quicAddress = initTAddress(a).valueOr:
return err("getPorts quicAddr error:" & $error)
quicPort = some(quicAddress.port)
elif tcpPort.isNone():
let tcpAddress = initTAddress(a).valueOr:
return err("getPorts tcpAddr error:" & $error)
tcpPort = some(tcpAddress.port)
return ok((tcpPort: tcpPort, websocketPort: websocketPort, quicPort: quicPort))
proc containsWsAddress(extMultiAddrs: seq[MultiAddress]): bool =
return extMultiAddrs.filterIt(it.isWsAddress()).len > 0

24
logos_delivery/waku/waku.nim
View File

@ -8,7 +8,6 @@ import
chronos,
libp2p/protocols/connectivity/relay/relay,
libp2p/protocols/connectivity/relay/client,
libp2p/wire,
libp2p/crypto/crypto,
libp2p/protocols/pubsub/gossipsub,
libp2p/protocols/ping,
@ -251,29 +250,6 @@ proc new*(
ok(waku)
proc getPorts(
listenAddrs: seq[MultiAddress]
): Result[tuple[tcpPort, websocketPort, quicPort: Option[Port]], string] =
var tcpPort, websocketPort, quicPort = none(Port)
for a in listenAddrs:
if a.isWsAddress():
if websocketPort.isNone():
let wsAddress = initTAddress(a).valueOr:
return err("getPorts wsAddr error:" & $error)
websocketPort = some(wsAddress.port)
elif a.isQuicAddress():
if quicPort.isNone():
let quicAddress = initTAddress(a).valueOr:
return err("getPorts quicAddr error:" & $error)
quicPort = some(quicAddress.port)
elif tcpPort.isNone():
let tcpAddress = initTAddress(a).valueOr:
return err("getPorts tcpAddr error:" & $error)
tcpPort = some(tcpAddress.port)
return ok((tcpPort: tcpPort, websocketPort: websocketPort, quicPort: quicPort))
proc getRunningNetConfig(waku: Waku): Future[Result[NetConfig, string]] {.async.} =
let conf = waku.conf
let (tcpPort, websocketPort, quicPort) = getPorts(

3
tests/api/test_api_health.nim
View File

@ -79,8 +79,7 @@ suite "LM API health checking":
asyncSetup:
lockNewGlobalBrokerContext:
serviceNode =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
serviceNode = newTestWakuNode(generateSecp256k1Key())
(await serviceNode.mountRelay()).isOkOr:
raiseAssert error
serviceNode.mountMetadata(3, @[0'u16]).isOkOr:

6
tests/api/test_api_receive.nim
View File

@ -113,8 +113,7 @@ proc setupNetwork(testTopic: ContentTopic): Future[TestNetwork] {.async.} =
# store node: archive + store + relay, subscribed to the shard
var storeNode: WakuNode
lockNewGlobalBrokerContext:
storeNode =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
storeNode = newTestWakuNode(generateSecp256k1Key())
storeNode.mountMetadata(3, toSeq(0'u16 ..< numShards)).expect(
"Failed to mount metadata on storeNode"
)
@ -132,8 +131,7 @@ proc setupNetwork(testTopic: ContentTopic): Future[TestNetwork] {.async.} =
# publisher: relay, connected to the store so its messages get archived
var publisher: WakuNode
lockNewGlobalBrokerContext:
publisher =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
publisher = newTestWakuNode(generateSecp256k1Key())
publisher.mountMetadata(3, toSeq(0'u16 ..< numShards)).expect(
"Failed to mount metadata on publisher"
)

18
tests/api/test_api_send.nim
View File

@ -152,8 +152,7 @@ suite "Waku API - Send":
asyncSetup:
lockNewGlobalBrokerContext:
relayNode1 =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
relayNode1 = newTestWakuNode(generateSecp256k1Key())
relayNode1.mountMetadata(3, @[0'u16]).isOkOr:
raiseAssert "Failed to mount metadata: " & error
(await relayNode1.mountRelay()).isOkOr:
@ -162,8 +161,7 @@ suite "Waku API - Send":
await relayNode1.start()
lockNewGlobalBrokerContext:
relayNode2 =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
relayNode2 = newTestWakuNode(generateSecp256k1Key())
relayNode2.mountMetadata(3, @[0'u16]).isOkOr:
raiseAssert "Failed to mount metadata: " & error
(await relayNode2.mountRelay()).isOkOr:
@ -172,8 +170,7 @@ suite "Waku API - Send":
await relayNode2.start()
lockNewGlobalBrokerContext:
lightpushNode =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
lightpushNode = newTestWakuNode(generateSecp256k1Key())
lightpushNode.mountMetadata(3, @[0'u16]).isOkOr:
raiseAssert "Failed to mount metadata: " & error
(await lightpushNode.mountRelay()).isOkOr:
@ -184,8 +181,7 @@ suite "Waku API - Send":
await lightpushNode.start()
lockNewGlobalBrokerContext:
storeNode =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
storeNode = newTestWakuNode(generateSecp256k1Key())
storeNode.mountMetadata(3, @[0'u16]).isOkOr:
raiseAssert "Failed to mount metadata: " & error
(await storeNode.mountRelay()).isOkOr:
@ -461,8 +457,7 @@ suite "Waku API - Send":
asyncTest "Send fails with event":
var fakeLightpushNode: WakuNode
lockNewGlobalBrokerContext:
fakeLightpushNode =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
fakeLightpushNode = newTestWakuNode(generateSecp256k1Key())
fakeLightpushNode.mountMetadata(3, @[0'u16]).isOkOr:
raiseAssert "Failed to mount metadata: " & error
(await fakeLightpushNode.mountRelay()).isOkOr:
@ -519,8 +514,7 @@ suite "Waku API - Send":
## missing Sent event is the signal that delivery could not be validated.
var isolatedStoreNode: WakuNode
lockNewGlobalBrokerContext:
isolatedStoreNode =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
isolatedStoreNode = newTestWakuNode(generateSecp256k1Key())
isolatedStoreNode.mountMetadata(3, @[0'u16]).isOkOr:
raiseAssert "Failed to mount metadata: " & error
(await isolatedStoreNode.mountRelay()).isOkOr:

21
tests/api/test_api_subscription.nim
View File

@ -95,8 +95,7 @@ proc setupNetwork(
var net = TestNetwork()
lockNewGlobalBrokerContext:
net.publisher =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
net.publisher = newTestWakuNode(generateSecp256k1Key())
net.publisher.mountMetadata(3, toSeq(0'u16 ..< numShards)).expect(
"Failed to mount metadata"
)
@ -122,8 +121,7 @@ proc setupNetwork(
if mode == cli_args.WakuMode.Edge:
lockNewGlobalBrokerContext:
net.meshBuddy =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
net.meshBuddy = newTestWakuNode(generateSecp256k1Key())
net.meshBuddy.mountMetadata(3, toSeq(0'u16 ..< numShards)).expect(
"Failed to mount metadata on meshBuddy"
)
@ -623,8 +621,7 @@ suite "Messaging API, SubscriptionManager":
var publisher: WakuNode
lockNewGlobalBrokerContext:
publisher =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
publisher = newTestWakuNode(generateSecp256k1Key())
publisher.mountMetadata(3, toSeq(0'u16 ..< numShards)).expect(
"Failed to mount metadata on publisher"
)
@ -642,8 +639,7 @@ suite "Messaging API, SubscriptionManager":
var meshBuddy: WakuNode
lockNewGlobalBrokerContext:
meshBuddy =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
meshBuddy = newTestWakuNode(generateSecp256k1Key())
meshBuddy.mountMetadata(3, toSeq(0'u16 ..< numShards)).expect(
"Failed to mount metadata on meshBuddy"
)
@ -734,8 +730,7 @@ suite "Messaging API, SubscriptionManager":
var publisher: WakuNode
lockNewGlobalBrokerContext:
publisher =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
publisher = newTestWakuNode(generateSecp256k1Key())
publisher.mountMetadata(3, toSeq(0'u16 ..< numShards)).expect(
"Failed to mount metadata on publisher"
)
@ -753,8 +748,7 @@ suite "Messaging API, SubscriptionManager":
var meshBuddy: WakuNode
lockNewGlobalBrokerContext:
meshBuddy =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
meshBuddy = newTestWakuNode(generateSecp256k1Key())
meshBuddy.mountMetadata(3, toSeq(0'u16 ..< numShards)).expect(
"Failed to mount metadata on meshBuddy"
)
@ -772,8 +766,7 @@ suite "Messaging API, SubscriptionManager":
var sparePeer: WakuNode
lockNewGlobalBrokerContext:
sparePeer =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
sparePeer = newTestWakuNode(generateSecp256k1Key())
sparePeer.mountMetadata(3, toSeq(0'u16 ..< numShards)).expect(
"Failed to mount metadata on sparePeer"
)

2
tests/factory/test_node_factory.nim
View File

@ -171,7 +171,7 @@ suite "Auto-port retry":
discard
let nodeKey = generateSecp256k1Key()
let node = newTestWakuNode(nodeKey, parseIpAddress("0.0.0.0"), Port(0))
let node = newTestWakuNode(nodeKey)
await node.start()
defer:
await node.stop()

3
tests/node/test_all.nim
View File

@ -7,4 +7,5 @@ import
./test_wakunode_peer_exchange,
./test_wakunode_store,
./test_wakunode_peer_manager,
./test_wakunode_health_monitor
./test_wakunode_health_monitor,
./test_wakunode_restart

29
tests/node/test_wakunode_filter.nim
View File

@ -68,12 +68,9 @@ suite "Waku Filter - End to End":
serverKey = generateSecp256k1Key()
clientKey = generateSecp256k1Key()
server = newTestWakuNode(
serverKey, parseIpAddress("0.0.0.0"), Port(23450), maxConnections = 300
)
client = newTestWakuNode(clientKey, parseIpAddress("0.0.0.0"), Port(23451))
clientClone = newTestWakuNode(clientKey, parseIpAddress("0.0.0.0"), Port(23451))
# Used for testing client restarts
server = newTestWakuNode(serverKey, maxConnections = 300)
client = newTestWakuNode(clientKey)
clientClone = newTestWakuNode(clientKey) # Used for testing client restarts
await allFutures(server.start(), client.start())
@ -157,7 +154,7 @@ suite "Waku Filter - End to End":
# Given a server node with Relay without Filter
let
serverKey = generateSecp256k1Key()
server = newTestWakuNode(serverKey, parseIpAddress("0.0.0.0"), Port(0))
server = newTestWakuNode(serverKey)
await server.start()
(await server.mountRelay()).isOkOr:
@ -192,7 +189,7 @@ suite "Waku Filter - End to End":
## This line above causes the test to fail. I think ConnManager
## is not prepare for restarts and maybe we don't need that restart feature.
client = newTestWakuNode(clientKey, parseIpAddress("0.0.0.0"), Port(23451))
client = newTestWakuNode(clientKey)
await client.start() # Mimic restart by starting the clone
# pushHandlerFuture = newFuture[(string, WakuMessage)]()
@ -587,9 +584,7 @@ suite "Waku Filter - End to End":
var peers = newSeq[WakuNode](MaxFilterPeers)
for index in 0 ..< MaxFilterPeers:
peers[index] = newTestWakuNode(
generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(23551 + index)
)
peers[index] = newTestWakuNode(generateSecp256k1Key())
await peers[index].start()
await peers[index].mountFilterClient()
@ -740,15 +735,9 @@ suite "Waku Filter - End to End":
peerManager = server.peerManager
let
client1 = newTestWakuNode(
generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(23552)
)
client2 = newTestWakuNode(
generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(23553)
)
client3 = newTestWakuNode(
generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(23554)
)
client1 = newTestWakuNode(generateSecp256k1Key())
client2 = newTestWakuNode(generateSecp256k1Key())
client3 = newTestWakuNode(generateSecp256k1Key())
filterSubscribeRequest = createRequest(
filterSubscribeType = FilterSubscribeType.SUBSCRIBE,
pubsubTopic = some(DefaultPubsubTopic),

22
tests/node/test_wakunode_legacy_lightpush.nim
View File

@ -36,8 +36,8 @@ suite "Waku Legacy Lightpush - End To End":
serverKey = generateSecp256k1Key()
clientKey = generateSecp256k1Key()
server = newTestWakuNode(serverKey, parseIpAddress("0.0.0.0"), Port(0))
client = newTestWakuNode(clientKey, parseIpAddress("0.0.0.0"), Port(0))
server = newTestWakuNode(serverKey)
client = newTestWakuNode(clientKey)
await allFutures(server.start(), client.start())
await server.start()
@ -59,8 +59,7 @@ suite "Waku Legacy Lightpush - End To End":
suite "Assessment of Message Relaying Mechanisms":
asyncTest "Via 11/WAKU2-RELAY from Relay/Full Node":
# Given a light lightpush client
let lightpushClient =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
let lightpushClient = newTestWakuNode(generateSecp256k1Key())
lightpushClient.mountLegacyLightpushClient()
# When the client publishes a message
@ -111,8 +110,8 @@ suite "RLN Proofs as a Lightpush Service":
serverKey = generateSecp256k1Key()
clientKey = generateSecp256k1Key()
server = newTestWakuNode(serverKey, parseIpAddress("0.0.0.0"), Port(0))
client = newTestWakuNode(clientKey, parseIpAddress("0.0.0.0"), Port(0))
server = newTestWakuNode(serverKey)
client = newTestWakuNode(clientKey)
anvilProc = runAnvil(stateFile = some(DEFAULT_ANVIL_STATE_PATH))
manager = waitFor setupOnchainGroupManager(deployContracts = false)
@ -159,8 +158,7 @@ suite "RLN Proofs as a Lightpush Service":
suite "Lightpush attaching RLN proofs":
asyncTest "Message is published when RLN enabled":
# Given a light lightpush client
let lightpushClient =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
let lightpushClient = newTestWakuNode(generateSecp256k1Key())
lightpushClient.mountLegacyLightPushClient()
# When the client publishes a message
@ -180,11 +178,11 @@ suite "Waku Legacy Lightpush message delivery":
## Setup
let
lightNodeKey = generateSecp256k1Key()
lightNode = newTestWakuNode(lightNodeKey, parseIpAddress("0.0.0.0"), Port(0))
lightNode = newTestWakuNode(lightNodeKey)
bridgeNodeKey = generateSecp256k1Key()
bridgeNode = newTestWakuNode(bridgeNodeKey, parseIpAddress("0.0.0.0"), Port(0))
bridgeNode = newTestWakuNode(bridgeNodeKey)
destNodeKey = generateSecp256k1Key()
destNode = newTestWakuNode(destNodeKey, parseIpAddress("0.0.0.0"), Port(0))
destNode = newTestWakuNode(destNodeKey)
await allFutures(destNode.start(), bridgeNode.start(), lightNode.start())
@ -234,7 +232,7 @@ suite "Waku Legacy Lightpush mounting behavior":
## Given a node without Relay mounted
let
key = generateSecp256k1Key()
node = newTestWakuNode(key, parseIpAddress("0.0.0.0"), Port(0))
node = newTestWakuNode(key)
# Do not mount Relay on purpose
check node.wakuRelay.isNil()

22
tests/node/test_wakunode_lightpush.nim
View File

@ -33,8 +33,8 @@ suite "Waku Lightpush - End To End":
serverKey = generateSecp256k1Key()
clientKey = generateSecp256k1Key()
server = newTestWakuNode(serverKey, parseIpAddress("0.0.0.0"), Port(0))
client = newTestWakuNode(clientKey, parseIpAddress("0.0.0.0"), Port(0))
server = newTestWakuNode(serverKey)
client = newTestWakuNode(clientKey)
await allFutures(server.start(), client.start())
await server.start()
@ -55,8 +55,7 @@ suite "Waku Lightpush - End To End":
suite "Assessment of Message Relaying Mechanisms":
asyncTest "Via 11/WAKU2-RELAY from Relay/Full Node":
# Given a light lightpush client
let lightpushClient =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
let lightpushClient = newTestWakuNode(generateSecp256k1Key())
lightpushClient.mountLightpushClient()
# When the client publishes a message
@ -108,8 +107,8 @@ suite "RLN Proofs as a Lightpush Service":
serverKey = generateSecp256k1Key()
clientKey = generateSecp256k1Key()
server = newTestWakuNode(serverKey, parseIpAddress("0.0.0.0"), Port(0))
client = newTestWakuNode(clientKey, parseIpAddress("0.0.0.0"), Port(0))
server = newTestWakuNode(serverKey)
client = newTestWakuNode(clientKey)
anvilProc = runAnvil(stateFile = some(DEFAULT_ANVIL_STATE_PATH))
manager = waitFor setupOnchainGroupManager(deployContracts = false)
@ -156,8 +155,7 @@ suite "RLN Proofs as a Lightpush Service":
suite "Lightpush attaching RLN proofs":
asyncTest "Message is published when RLN enabled":
# Given a light lightpush client
let lightpushClient =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
let lightpushClient = newTestWakuNode(generateSecp256k1Key())
lightpushClient.mountLightPushClient()
# When the client publishes a message
@ -177,11 +175,11 @@ suite "Waku Lightpush message delivery":
## Setup
let
lightNodeKey = generateSecp256k1Key()
lightNode = newTestWakuNode(lightNodeKey, parseIpAddress("0.0.0.0"), Port(0))
lightNode = newTestWakuNode(lightNodeKey)
bridgeNodeKey = generateSecp256k1Key()
bridgeNode = newTestWakuNode(bridgeNodeKey, parseIpAddress("0.0.0.0"), Port(0))
bridgeNode = newTestWakuNode(bridgeNodeKey)
destNodeKey = generateSecp256k1Key()
destNode = newTestWakuNode(destNodeKey, parseIpAddress("0.0.0.0"), Port(0))
destNode = newTestWakuNode(destNodeKey)
await allFutures(destNode.start(), bridgeNode.start(), lightNode.start())
@ -233,7 +231,7 @@ suite "Waku Lightpush mounting behavior":
## Given a node without Relay mounted
let
key = generateSecp256k1Key()
node = newTestWakuNode(key, parseIpAddress("0.0.0.0"), Port(0))
node = newTestWakuNode(key)
# Do not mount Relay on purpose
check node.wakuRelay.isNil()

74
tests/node/test_wakunode_peer_exchange.nim
View File

@ -187,74 +187,28 @@ suite "Waku Peer Exchange with discv5":
lightpush = false, filter = false, store = false, relay = true
)
bindIp = parseIpAddress("0.0.0.0")
extIp = parseIpAddress("127.0.0.1")
nodeKey1 = generateSecp256k1Key()
nodeTcpPort1 = Port(64010)
nodeUdpPort1 = Port(9000)
node1 = newTestWakuNode(
nodeKey1,
bindIp,
nodeTcpPort1,
some(extIp),
wakuFlags = some(flags),
discv5UdpPort = some(nodeUdpPort1),
)
node1 = newTestWakuNode(nodeKey1, bindIp, Port(0), wakuFlags = some(flags))
nodeKey2 = generateSecp256k1Key()
nodeTcpPort2 = Port(64012)
nodeUdpPort2 = Port(9002)
node2 = newTestWakuNode(
nodeKey2,
bindIp,
nodeTcpPort2,
some(extIp),
wakuFlags = some(flags),
discv5UdpPort = some(nodeUdpPort2),
)
node2 = newTestWakuNode(nodeKey2, bindIp, Port(0), wakuFlags = some(flags))
nodeKey3 = generateSecp256k1Key()
nodeTcpPort3 = Port(64014)
nodeUdpPort3 = Port(9004)
node3 = newTestWakuNode(
nodeKey3,
bindIp,
nodeTcpPort3,
some(extIp),
wakuFlags = some(flags),
discv5UdpPort = some(nodeUdpPort3),
)
# discv5
let conf1 = WakuDiscoveryV5Config(
discv5Config: none(DiscoveryConfig),
address: bindIp,
port: nodeUdpPort1,
privateKey: keys.PrivateKey(nodeKey1.skkey),
bootstrapRecords: @[],
autoupdateRecord: true,
)
let disc1 =
WakuDiscoveryV5.new(node1.rng, conf1, some(node1.enr), some(node1.peerManager))
let conf2 = WakuDiscoveryV5Config(
discv5Config: none(DiscoveryConfig),
address: bindIp,
port: nodeUdpPort2,
privateKey: keys.PrivateKey(nodeKey2.skkey),
bootstrapRecords: @[disc1.protocol.getRecord()],
autoupdateRecord: true,
)
let disc2 =
WakuDiscoveryV5.new(node2.rng, conf2, some(node2.enr), some(node2.peerManager))
node3 = newTestWakuNode(nodeKey3, bindIp, Port(0), wakuFlags = some(flags))
await allFutures(node1.start(), node2.start(), node3.start())
let resultDisc1StartRes = await disc1.start()
assert resultDisc1StartRes.isOk(), resultDisc1StartRes.error
let resultDisc2StartRes = await disc2.start()
assert resultDisc2StartRes.isOk(), resultDisc2StartRes.error
let disc1 = (
await startDiscv5WithAutoPort(node1, keys.PrivateKey(nodeKey1.skkey), bindIp)
).valueOr:
raiseAssert "disc1: " & error
let disc2 = (
await startDiscv5WithAutoPort(
node2, keys.PrivateKey(nodeKey2.skkey), bindIp, @[disc1.protocol.getRecord()]
)
).valueOr:
raiseAssert "disc2: " & error
## When
var attempts = 10

4
tests/node/test_wakunode_peer_manager.nim
View File

@ -63,9 +63,9 @@ suite "Peer Manager":
serverKey = generateSecp256k1Key()
clientKey = generateSecp256k1Key()
server = newTestWakuNode(serverKey, listenIp, Port(3000))
server = newTestWakuNode(serverKey, listenIp, Port(0))
serverPeerStore = server.peerManager.switch.peerStore
client = newTestWakuNode(clientKey, listenIp, Port(3001))
client = newTestWakuNode(clientKey, listenIp, Port(0))
clientPeerStore = client.peerManager.switch.peerStore
await allFutures(server.start(), client.start())

10
tests/node/test_wakunode_relay_rln.nim
View File

@ -116,8 +116,8 @@ suite "Waku RlnRelay - End to End - Static":
serverKey = generateSecp256k1Key()
clientKey = generateSecp256k1Key()
server = newTestWakuNode(serverKey, parseIpAddress("0.0.0.0"), Port(0))
client = newTestWakuNode(clientKey, parseIpAddress("0.0.0.0"), Port(0))
server = newTestWakuNode(serverKey)
client = newTestWakuNode(clientKey)
await allFutures(server.start(), client.start())
@ -198,7 +198,7 @@ suite "Waku RlnRelay - End to End - Static":
asyncTest "rln-relay-max-message-limit testing":
let
nodekey = generateSecp256k1Key()
node = newTestWakuNode(nodekey, parseIpAddress("0.0.0.0"), Port(0))
node = newTestWakuNode(nodekey)
await node.mountRelay(@[DefaultRelayShard])
@ -384,8 +384,8 @@ suite "Waku RlnRelay - End to End - OnChain":
serverKey = generateSecp256k1Key()
clientKey = generateSecp256k1Key()
server = newTestWakuNode(serverKey, parseIpAddress("0.0.0.0"), Port(0))
client = newTestWakuNode(clientKey, parseIpAddress("0.0.0.0"), Port(0))
server = newTestWakuNode(serverKey)
client = newTestWakuNode(clientKey)
await allFutures(server.start(), client.start())

6
tests/node/test_wakunode_restart.nim
View File

@ -11,10 +11,8 @@ suite "WakuNode - restart (#3979)":
asyncTest "start -> stop -> start re-opens the listener promptly":
## A restart must not block on the relay-reconnect backoff.
let
node1 =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
node2 =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
node1 = newTestWakuNode(generateSecp256k1Key())
node2 = newTestWakuNode(generateSecp256k1Key())
(await node1.mountRelay()).isOkOr:
raiseAssert "mountRelay node1: " & error

31
tests/node/test_wakunode_store.nim
View File

@ -69,8 +69,8 @@ suite "Waku Store - End to End - Sorted Archive":
serverKey = generateSecp256k1Key()
clientKey = generateSecp256k1Key()
server = newTestWakuNode(serverKey, parseIpAddress("0.0.0.0"), Port(0))
client = newTestWakuNode(clientKey, parseIpAddress("0.0.0.0"), Port(0))
server = newTestWakuNode(serverKey)
client = newTestWakuNode(clientKey)
archiveDriver = newArchiveDriverWithMessages(pubsubTopic, messages)
let mountArchiveResult = server.mountArchive(archiveDriver)
@ -473,8 +473,7 @@ suite "Waku Store - End to End - Sorted Archive":
pubsubTopic, archiveMessages.mapIt(it.message.get())
)
otherServerKey = generateSecp256k1Key()
otherServer =
newTestWakuNode(otherServerKey, parseIpAddress("0.0.0.0"), Port(0))
otherServer = newTestWakuNode(otherServerKey)
mountOtherArchiveResult =
otherServer.mountArchive(otherArchiveDriverWithMessages)
assert mountOtherArchiveResult.isOk()
@ -564,8 +563,8 @@ suite "Waku Store - End to End - Unsorted Archive":
serverKey = generateSecp256k1Key()
clientKey = generateSecp256k1Key()
server = newTestWakuNode(serverKey, parseIpAddress("0.0.0.0"), Port(0))
client = newTestWakuNode(clientKey, parseIpAddress("0.0.0.0"), Port(0))
server = newTestWakuNode(serverKey)
client = newTestWakuNode(clientKey)
let
unsortedArchiveDriverWithMessages =
@ -781,8 +780,8 @@ suite "Waku Store - End to End - Unsorted Archive without provided Timestamp":
serverKey = generateSecp256k1Key()
clientKey = generateSecp256k1Key()
server = newTestWakuNode(serverKey, parseIpAddress("0.0.0.0"), Port(0))
client = newTestWakuNode(clientKey, parseIpAddress("0.0.0.0"), Port(0))
server = newTestWakuNode(serverKey)
client = newTestWakuNode(clientKey)
let
unsortedArchiveDriverWithMessages =
@ -930,8 +929,8 @@ suite "Waku Store - End to End - Archive with Multiple Topics":
serverKey = generateSecp256k1Key()
clientKey = generateSecp256k1Key()
server = newTestWakuNode(serverKey, parseIpAddress("0.0.0.0"), Port(0))
client = newTestWakuNode(clientKey, parseIpAddress("0.0.0.0"), Port(0))
server = newTestWakuNode(serverKey)
client = newTestWakuNode(clientKey)
let archiveDriver = newSqliteArchiveDriver().put(pubsubTopic, messages[0 ..< 6]).put(
pubsubTopicB, messages[6 ..< 10]
@ -1179,8 +1178,7 @@ suite "Waku Store - End to End - Archive with Multiple Topics":
# And a server node with the ephemeral archive
let
ephemeralServerKey = generateSecp256k1Key()
ephemeralServer =
newTestWakuNode(ephemeralServerKey, parseIpAddress("0.0.0.0"), Port(0))
ephemeralServer = newTestWakuNode(ephemeralServerKey)
mountEphemeralArchiveResult =
ephemeralServer.mountArchive(ephemeralArchiveDriver)
assert mountEphemeralArchiveResult.isOk()
@ -1219,8 +1217,7 @@ suite "Waku Store - End to End - Archive with Multiple Topics":
# And a server node with the mixed archive
let
mixedServerKey = generateSecp256k1Key()
mixedServer =
newTestWakuNode(mixedServerKey, parseIpAddress("0.0.0.0"), Port(0))
mixedServer = newTestWakuNode(mixedServerKey)
mountMixedArchiveResult = mixedServer.mountArchive(mixedArchiveDriver)
assert mountMixedArchiveResult.isOk()
@ -1246,8 +1243,7 @@ suite "Waku Store - End to End - Archive with Multiple Topics":
# And a server node with the empty archive
let
emptyServerKey = generateSecp256k1Key()
emptyServer =
newTestWakuNode(emptyServerKey, parseIpAddress("0.0.0.0"), Port(0))
emptyServer = newTestWakuNode(emptyServerKey)
mountEmptyArchiveResult = emptyServer.mountArchive(emptyArchiveDriver)
assert mountEmptyArchiveResult.isOk()
@ -1286,8 +1282,7 @@ suite "Waku Store - End to End - Archive with Multiple Topics":
# And a server node with the voluminous archive
let
voluminousServerKey = generateSecp256k1Key()
voluminousServer =
newTestWakuNode(voluminousServerKey, parseIpAddress("0.0.0.0"), Port(0))
voluminousServer = newTestWakuNode(voluminousServerKey)
mountVoluminousArchiveResult =
voluminousServer.mountArchive(voluminousArchiveDriverWithMessages)
assert mountVoluminousArchiveResult.isOk()

137
tests/test_peer_manager.nim
View File

@ -2,11 +2,13 @@
import
std/[sequtils, times, sugar, net, options],
results,
testutils/unittests,
chronos,
json_rpc/rpcserver,
json_rpc/rpcclient,
eth/keys,
eth/p2p/discoveryv5/enr,
eth/common/eth_types,
libp2p/[builders, switch, multiaddress],
libp2p/protobuf/minprotobuf,
@ -34,12 +36,17 @@ import
./testlib/wakucore,
./testlib/wakunode
proc syncToBoundPort(node: WakuNode, key: keys.PrivateKey) =
let addrs = node.switch.peerInfo.listenAddrs
node.switch.peerInfo.addrs = addrs
node.announcedAddresses = addrs
node.enr.update(key, tcpPort = Opt.some(node.boundTcpPort())).isOkOr:
raiseAssert "failed to sync node ENR to bound tcp port: " & $error
procSuite "Peer Manager":
asyncTest "connectPeer() works":
# Create 2 nodes
let nodes = toSeq(0 ..< 2).mapIt(
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
)
let nodes = toSeq(0 ..< 2).mapIt(newTestWakuNode(generateSecp256k1Key()))
await allFutures(nodes.mapIt(it.start()))
let connOk =
@ -55,9 +62,7 @@ procSuite "Peer Manager":
Connectedness.Connected
asyncTest "Peer manager tracks active store request state":
let nodes = toSeq(0 ..< 2).mapIt(
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
)
let nodes = toSeq(0 ..< 2).mapIt(newTestWakuNode(generateSecp256k1Key()))
await allFutures(nodes.mapIt(it.start()))
await allFutures(nodes.mapIt(it.mountRelay()))
@ -94,9 +99,7 @@ procSuite "Peer Manager":
asyncTest "dialPeer() works":
# Create 2 nodes
let nodes = toSeq(0 ..< 2).mapIt(
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
)
let nodes = toSeq(0 ..< 2).mapIt(newTestWakuNode(generateSecp256k1Key()))
await allFutures(nodes.mapIt(it.start()))
await allFutures(nodes.mapIt(it.mountRelay()))
@ -129,9 +132,7 @@ procSuite "Peer Manager":
asyncTest "dialPeer() fails gracefully":
# Create 2 nodes and start them
let nodes = toSeq(0 ..< 2).mapIt(
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
)
let nodes = toSeq(0 ..< 2).mapIt(newTestWakuNode(generateSecp256k1Key()))
await allFutures(nodes.mapIt(it.start()))
await allFutures(nodes.mapIt(it.mountRelay()))
@ -158,7 +159,7 @@ procSuite "Peer Manager":
asyncTest "Adding, selecting and filtering peers work":
let
node = newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
node = newTestWakuNode(generateSecp256k1Key())
# Create filter peer
filterLoc = MultiAddress.init("/ip4/127.0.0.1/tcp/0").tryGet()
@ -190,9 +191,7 @@ procSuite "Peer Manager":
asyncTest "Peer manager keeps track of connections":
# Create 2 nodes
let nodes = toSeq(0 ..< 2).mapIt(
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
)
let nodes = toSeq(0 ..< 2).mapIt(newTestWakuNode(generateSecp256k1Key()))
await allFutures(nodes.mapIt(it.start()))
await allFutures(nodes.mapIt(it.mountRelay()))
@ -243,9 +242,7 @@ procSuite "Peer Manager":
asyncTest "Peer manager updates failed peers correctly":
# Create 2 nodes
let nodes = toSeq(0 ..< 2).mapIt(
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
)
let nodes = toSeq(0 ..< 2).mapIt(newTestWakuNode(generateSecp256k1Key()))
await allFutures(nodes.mapIt(it.start()))
await allFutures(nodes.mapIt(it.mountRelay()))
@ -311,13 +308,13 @@ procSuite "Peer Manager":
node1 = newTestWakuNode(
generateSecp256k1Key(),
getPrimaryIPAddr(),
Port(44048),
Port(0),
peerStorage = storage,
quicEnabled = false,
)
node2 = newTestWakuNode(
generateSecp256k1Key(), getPrimaryIPAddr(), Port(34023), quicEnabled = false
)
node2Key = generateSecp256k1Key()
node2 =
newTestWakuNode(node2Key, getPrimaryIPAddr(), Port(0), quicEnabled = false)
node1.mountMetadata(0, @[0'u16]).expect("Mounted Waku Metadata")
node2.mountMetadata(0, @[0'u16]).expect("Mounted Waku Metadata")
@ -330,6 +327,8 @@ procSuite "Peer Manager":
(await node2.mountRelay()).isOkOr:
assert false, "Failed to mount relay"
node2.syncToBoundPort(keys.PrivateKey(node2Key.skkey))
let peerInfo2 = node2.switch.peerInfo
var remotePeerInfo2 = peerInfo2.toRemotePeerInfo()
remotePeerInfo2.enr = some(node2.enr)
@ -354,7 +353,7 @@ procSuite "Peer Manager":
let node3 = newTestWakuNode(
generateSecp256k1Key(),
parseIpAddress("127.0.0.1"),
Port(56037),
Port(0),
peerStorage = storage,
quicEnabled = false,
)
@ -392,13 +391,13 @@ procSuite "Peer Manager":
node1 = newTestWakuNode(
generateSecp256k1Key(),
getPrimaryIPAddr(),
Port(44048),
Port(0),
peerStorage = storage,
quicEnabled = false,
)
node2 = newTestWakuNode(
generateSecp256k1Key(), getPrimaryIPAddr(), Port(34023), quicEnabled = false
)
node2Key = generateSecp256k1Key()
node2 =
newTestWakuNode(node2Key, getPrimaryIPAddr(), Port(0), quicEnabled = false)
node1.mountMetadata(0, @[0'u16]).expect("Mounted Waku Metadata")
node2.mountMetadata(0, @[0'u16]).expect("Mounted Waku Metadata")
@ -411,6 +410,8 @@ procSuite "Peer Manager":
(await node2.mountRelay()).isOkOr:
assert false, "Failed to mount relay"
node2.syncToBoundPort(keys.PrivateKey(node2Key.skkey))
let peerInfo2 = node2.switch.peerInfo
var remotePeerInfo2 = peerInfo2.toRemotePeerInfo()
remotePeerInfo2.enr = some(node2.enr)
@ -435,7 +436,7 @@ procSuite "Peer Manager":
let node3 = newTestWakuNode(
generateSecp256k1Key(),
parseIpAddress("127.0.0.1"),
Port(56037),
Port(0),
peerStorage = storage,
quicEnabled = false,
)
@ -525,14 +526,8 @@ procSuite "Peer Manager":
let
database = SqliteDatabase.new(":memory:")[]
storage = WakuPeerStorage.new(database)[]
node1 = newTestWakuNode(
generateSecp256k1Key(),
parseIpAddress("0.0.0.0"),
Port(0),
peerStorage = storage,
)
node2 =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
node1 = newTestWakuNode(generateSecp256k1Key(), peerStorage = storage)
node2 = newTestWakuNode(generateSecp256k1Key())
peerInfo2 = node2.switch.peerInfo
betaCodec = "/vac/waku/relay/2.0.0-beta2"
stableCodec = "/vac/waku/relay/2.0.0"
@ -559,9 +554,7 @@ procSuite "Peer Manager":
node1.peerManager.switch.peerStore.connectedness(peerInfo2.peerId) == Connected
# Simulate restart by initialising a new node using the same storage
let node3 = newTestWakuNode(
generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0), peerStorage = storage
)
let node3 = newTestWakuNode(generateSecp256k1Key(), peerStorage = storage)
(await node3.mountRelay()).isOkOr:
assert false, "Failed to mount relay"
@ -595,8 +588,6 @@ procSuite "Peer Manager":
let nodes = toSeq(0 ..< 4).mapIt(
newTestWakuNode(
nodeKey = generateSecp256k1Key(),
bindIp = parseIpAddress("0.0.0.0"),
bindPort = Port(0),
wakuFlags = some(CapabilitiesBitfield.init(@[Relay])),
)
)
@ -668,8 +659,6 @@ procSuite "Peer Manager":
let nodes = toSeq(0 ..< 4).mapIt(
newTestWakuNode(
nodeKey = generateSecp256k1Key(),
bindIp = parseIpAddress("0.0.0.0"),
bindPort = Port(0),
wakuFlags = some(CapabilitiesBitfield.init(@[Relay])),
)
)
@ -747,9 +736,7 @@ procSuite "Peer Manager":
asyncTest "Peer store keeps track of incoming connections":
# Create 4 nodes
let nodes = toSeq(0 ..< 4).mapIt(
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
)
let nodes = toSeq(0 ..< 4).mapIt(newTestWakuNode(generateSecp256k1Key()))
# Start them
await allFutures(nodes.mapIt(it.start()))
@ -842,7 +829,7 @@ procSuite "Peer Manager":
let basePeerId = "16Uiu2HAm7QGEZKujdSbbo1aaQyfDPQ6Bw3ybQnj6fruH5Dxwd7D"
let
node = newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
node = newTestWakuNode(generateSecp256k1Key())
peers = toSeq(1 .. 4)
.mapIt(parsePeerInfo("/ip4/0.0.0.0/tcp/30300/p2p/" & basePeerId & $it))
.filterIt(it.isOk())
@ -880,9 +867,7 @@ procSuite "Peer Manager":
asyncTest "connectedPeers() returns expected number of connections per protocol":
# Create 4 nodes
let nodes = toSeq(0 ..< 4).mapIt(
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
)
let nodes = toSeq(0 ..< 4).mapIt(newTestWakuNode(generateSecp256k1Key()))
# Start them with relay + filter
await allFutures(nodes.mapIt(it.start()))
@ -935,9 +920,7 @@ procSuite "Peer Manager":
asyncTest "getNumStreams() returns expected number of connections per protocol":
# Create 2 nodes
let nodes = toSeq(0 ..< 2).mapIt(
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
)
let nodes = toSeq(0 ..< 2).mapIt(newTestWakuNode(generateSecp256k1Key()))
# Start them with relay + filter
await allFutures(nodes.mapIt(it.start()))
@ -1210,9 +1193,7 @@ procSuite "Peer Manager":
asyncTest "colocationLimit is enforced by pruneConnsByIp()":
# Create 5 nodes
let nodes = toSeq(0 ..< 5).mapIt(
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
)
let nodes = toSeq(0 ..< 5).mapIt(newTestWakuNode(generateSecp256k1Key()))
# Start them with relay + filter
await allFutures(nodes.mapIt(it.start()))
@ -1275,25 +1256,13 @@ procSuite "Peer Manager":
# Create 3 nodes with different shards
let nodes = @[
newTestWakuNode(
generateSecp256k1Key(),
parseIpAddress("0.0.0.0"),
Port(0),
clusterId = clusterId,
subscribeShards = @[shardId0],
generateSecp256k1Key(), clusterId = clusterId, subscribeShards = @[shardId0]
),
newTestWakuNode(
generateSecp256k1Key(),
parseIpAddress("0.0.0.0"),
Port(0),
clusterId = clusterId,
subscribeShards = @[shardId1],
generateSecp256k1Key(), clusterId = clusterId, subscribeShards = @[shardId1]
),
newTestWakuNode(
generateSecp256k1Key(),
parseIpAddress("0.0.0.0"),
Port(0),
clusterId = clusterId,
subscribeShards = @[shardId0],
generateSecp256k1Key(), clusterId = clusterId, subscribeShards = @[shardId0]
),
]
@ -1399,18 +1368,12 @@ procSuite "Peer Manager":
asyncTest "selectPeer() handles invalid pubsub topic gracefully":
## Given: A peer manager with valid peers
let node = newTestWakuNode(
generateSecp256k1Key(),
parseIpAddress("0.0.0.0"),
Port(0),
clusterId = 0,
subscribeShards = @[0'u16],
)
let node =
newTestWakuNode(generateSecp256k1Key(), clusterId = 0, subscribeShards = @[0'u16])
await node.start()
# Add a peer
let peer =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
let peer = newTestWakuNode(generateSecp256k1Key())
await peer.start()
discard await peer.mountRelay()
@ -1443,22 +1406,14 @@ procSuite "Peer Manager":
shardId1 = 1.uint16
let node = newTestWakuNode(
generateSecp256k1Key(),
parseIpAddress("0.0.0.0"),
Port(0),
clusterId = clusterId,
subscribeShards = @[shardId0],
generateSecp256k1Key(), clusterId = clusterId, subscribeShards = @[shardId0]
)
await node.start()
discard await node.mountRelay()
# Create peer with ENR containing shard 0
let peer = newTestWakuNode(
generateSecp256k1Key(),
parseIpAddress("0.0.0.0"),
Port(0),
clusterId = clusterId,
subscribeShards = @[shardId0],
generateSecp256k1Key(), clusterId = clusterId, subscribeShards = @[shardId0]
)
await peer.start()
discard await peer.mountRelay()

22
tests/test_waku_dnsdisc.nim
View File

@ -17,25 +17,22 @@ import
logos_delivery/waku/discovery/waku_dnsdisc,
./testlib/common,
./testlib/wakucore,
./testlib/wakunode
./testlib/wakunode,
./waku_enr/utils
suite "Waku DNS Discovery":
asyncTest "Waku DNS Discovery end-to-end":
## Tests integrated DNS discovery, from building
## the tree to connecting to discovered nodes
# Create nodes and ENR. These will be added to the discoverable list
let
bindIp = parseIpAddress("0.0.0.0")
bindIp = parseIpAddress("127.0.0.1")
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(nodeKey1, bindIp, Port(63500))
enr1 = node1.enr
node1 = newTestWakuNode(nodeKey1, bindIp, Port(0))
nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, bindIp, Port(63502))
enr2 = node2.enr
node2 = newTestWakuNode(nodeKey2, bindIp, Port(0))
nodeKey3 = generateSecp256k1Key()
node3 = newTestWakuNode(nodeKey3, bindIp, Port(63503))
enr3 = node3.enr
node3 = newTestWakuNode(nodeKey3, bindIp, Port(0))
(await node1.mountRelay()).isOkOr:
assert false, "Failed to mount relay"
@ -45,6 +42,11 @@ suite "Waku DNS Discovery":
assert false, "Failed to mount relay"
await allFutures([node1.start(), node2.start(), node3.start()])
let
enr1 = newTestEnrRecord(nodeKey1, $bindIp, uint16(node1.boundTcpPort()), 0)
enr2 = newTestEnrRecord(nodeKey2, $bindIp, uint16(node2.boundTcpPort()), 0)
enr3 = newTestEnrRecord(nodeKey3, $bindIp, uint16(node3.boundTcpPort()), 0)
# Build and sign tree
var tree = buildTree(
1, # Seq no
@ -76,7 +78,7 @@ suite "Waku DNS Discovery":
let
nodeKey4 = generateSecp256k1Key()
node4 = newTestWakuNode(nodeKey4, bindIp, Port(63504))
node4 = newTestWakuNode(nodeKey4, bindIp, Port(0))
(await node4.mountRelay()).isOkOr:
assert false, "Failed to mount relay"

4
tests/test_waku_keepalive.nim
View File

@ -20,9 +20,9 @@ suite "Waku Keepalive":
asyncTest "handle ping keepalives":
let
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(nodeKey1, parseIpAddress("0.0.0.0"), Port(0))
node1 = newTestWakuNode(nodeKey1)
nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, parseIpAddress("0.0.0.0"), Port(0))
node2 = newTestWakuNode(nodeKey2)
var completionFut = newFuture[bool]()

24
tests/test_waku_metadata.nim
View File

@ -29,18 +29,8 @@ procSuite "Waku Metadata Protocol":
asyncTest "request() returns the supported metadata of the peer":
let clusterId = 10.uint16
let
node1 = newTestWakuNode(
generateSecp256k1Key(),
parseIpAddress("0.0.0.0"),
Port(0),
clusterId = clusterId,
)
node2 = newTestWakuNode(
generateSecp256k1Key(),
parseIpAddress("0.0.0.0"),
Port(0),
clusterId = clusterId,
)
node1 = newTestWakuNode(generateSecp256k1Key(), clusterId = clusterId)
node2 = newTestWakuNode(generateSecp256k1Key(), clusterId = clusterId)
# Mount metadata protocol on both nodes before starting
discard node1.mountMetadata(clusterId, @[])
@ -89,15 +79,9 @@ procSuite "Waku Metadata Protocol":
configuredShards = @[uint16(0), uint16(1)]
let node1 = newTestWakuNode(
generateSecp256k1Key(),
parseIpAddress("0.0.0.0"),
Port(0),
clusterId = clusterId,
subscribeShards = configuredShards,
)
let node2 = newTestWakuNode(
generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0), clusterId = clusterId
generateSecp256k1Key(), clusterId = clusterId, subscribeShards = configuredShards
)
let node2 = newTestWakuNode(generateSecp256k1Key(), clusterId = clusterId)
# Mount metadata with configured shards on node1
discard node1.mountMetadata(clusterId, configuredShards)

31
tests/test_waku_rendezvous.nim
View File

@ -22,24 +22,9 @@ procSuite "Waku Rendezvous":
asyncTest "Simple remote test":
let
clusterId = 10.uint16
node1 = newTestWakuNode(
generateSecp256k1Key(),
parseIpAddress("0.0.0.0"),
Port(0),
clusterId = clusterId,
)
node2 = newTestWakuNode(
generateSecp256k1Key(),
parseIpAddress("0.0.0.0"),
Port(0),
clusterId = clusterId,
)
node3 = newTestWakuNode(
generateSecp256k1Key(),
parseIpAddress("0.0.0.0"),
Port(0),
clusterId = clusterId,
)
node1 = newTestWakuNode(generateSecp256k1Key(), clusterId = clusterId)
node2 = newTestWakuNode(generateSecp256k1Key(), clusterId = clusterId)
node3 = newTestWakuNode(generateSecp256k1Key(), clusterId = clusterId)
await allFutures(
[
@ -90,11 +75,7 @@ procSuite "Waku Rendezvous":
configuredShards = @[RelayShard(clusterId: clusterId, shardId: 0)]
let node = newTestWakuNode(
generateSecp256k1Key(),
parseIpAddress("0.0.0.0"),
Port(0),
clusterId = clusterId,
subscribeShards = @[0'u16],
generateSecp256k1Key(), clusterId = clusterId, subscribeShards = @[0'u16]
)
## When: Node mounts rendezvous with configured shards (before relay)
@ -122,9 +103,7 @@ procSuite "Waku Rendezvous":
RelayShard(clusterId: clusterId, shardId: 1),
]
let lightClient = newTestWakuNode(
generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0), clusterId = clusterId
)
let lightClient = newTestWakuNode(generateSecp256k1Key(), clusterId = clusterId)
## When: Node mounts rendezvous with configured shards (no relay mounted)
await lightClient.mountRendezvous(clusterId, configuredShards)

54
tests/test_wakunode.nim
View File

@ -27,9 +27,9 @@ suite "WakuNode":
asyncTest "Protocol matcher works as expected":
let
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(nodeKey1, parseIpAddress("0.0.0.0"), Port(61000))
node1 = newTestWakuNode(nodeKey1)
nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, parseIpAddress("0.0.0.0"), Port(61002))
node2 = newTestWakuNode(nodeKey2)
shard = DefaultRelayShard
contentTopic = ContentTopic("/waku/2/default-content/proto")
payload = "hello world".toBytes()
@ -94,16 +94,9 @@ suite "WakuNode":
let
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(
nodeKey1, parseIpAddress("0.0.0.0"), Port(61020), nameResolver = resolver
)
node1 = newTestWakuNode(nodeKey1, nameResolver = resolver)
nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, parseIpAddress("0.0.0.0"), Port(61022))
# Construct DNS multiaddr for node2
let
node2PeerId = $(node2.switch.peerInfo.peerId)
node2Dns4Addr = "/dns4/localhost/tcp/61022/p2p/" & node2PeerId
node2 = newTestWakuNode(nodeKey2)
(await node1.mountRelay()).isOkOr:
assert false, "Failed to mount relay"
@ -112,6 +105,12 @@ suite "WakuNode":
await allFutures([node1.start(), node2.start()])
# Construct DNS multiaddr for node2
let
node2PeerId = $(node2.switch.peerInfo.peerId)
node2Dns4Addr =
"/dns4/localhost/tcp/" & $node2.boundTcpPort() & "/p2p/" & node2PeerId
await node1.connectToNodes(@[node2Dns4Addr])
check:
@ -171,8 +170,6 @@ suite "WakuNode":
# gibberish
discard newTestWakuNode(
nodeKey1,
parseIpAddress("0.0.0.0"),
bindPort = Port(61004),
wsBindPort = Port(8000),
wssEnabled = true,
secureKey = "../../waku/node/key_dummy.txt",
@ -221,7 +218,7 @@ suite "WakuNode":
let
nodeKey = generateSecp256k1Key()
bindIp = parseIpAddress("0.0.0.0")
bindPort = Port(61006)
bindPort = Port(0)
extIp = some(getPrimaryIPAddr())
extPort = some(Port(61008))
node =
@ -247,8 +244,7 @@ suite "WakuNode":
test "toRemotePeerInfo sorts quic-v1 addresses first":
let
nodeKey = generateSecp256k1Key()
node =
newTestWakuNode(nodeKey, parseIpAddress("0.0.0.0"), Port(0), quicEnabled = true)
node = newTestWakuNode(nodeKey, quicEnabled = true)
# peerinfo path
let fromPeerInfo = node.switch.peerInfo.toRemotePeerInfo()
@ -266,13 +262,9 @@ suite "WakuNode":
asyncTest "Dual-stack nodes connect over QUIC":
let
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(
nodeKey1, parseIpAddress("0.0.0.0"), Port(0), quicEnabled = true
)
node1 = newTestWakuNode(nodeKey1, quicEnabled = true)
nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(
nodeKey2, parseIpAddress("0.0.0.0"), Port(0), quicEnabled = true
)
node2 = newTestWakuNode(nodeKey2, quicEnabled = true)
await allFutures(node1.start(), node2.start())
@ -374,16 +366,11 @@ suite "WakuNode":
let
# node with custom agent string
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(
nodeKey1,
parseIpAddress("0.0.0.0"),
Port(61014),
agentString = some(expectedAgentString1),
)
node1 = newTestWakuNode(nodeKey1, agentString = some(expectedAgentString1))
# node with default agent string from libp2p
nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, parseIpAddress("0.0.0.0"), Port(61016))
node2 = newTestWakuNode(nodeKey2)
await node1.start()
(await node1.mountRelay()).isOkOr:
@ -417,16 +404,11 @@ suite "WakuNode":
let
# node with custom multiaddress
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(
nodeKey1,
parseIpAddress("0.0.0.0"),
Port(61018),
extMultiAddrs = @[expectedMultiaddress1],
)
node1 = newTestWakuNode(nodeKey1, extMultiAddrs = @[expectedMultiaddress1])
# node with default multiaddress
nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, parseIpAddress("0.0.0.0"), Port(61020))
node2 = newTestWakuNode(nodeKey2)
await node1.start()
(await node1.mountRelay()).isOkOr:

11
tests/testlib/wakunode.nim
View File

@ -51,8 +51,8 @@ proc defaultTestWakuConf*(): WakuConf =
proc newTestWakuNode*(
nodeKey: crypto.PrivateKey,
bindIp: IpAddress,
bindPort: Port,
bindIp: IpAddress = parseIpAddress("0.0.0.0"),
bindPort: Port = Port(0),
extIp = none(IpAddress),
extPort = none(Port),
extMultiAddrs = newSeq[MultiAddress](),
@ -170,3 +170,10 @@ proc newTestWakuNode*(
)
return builder.build().get()
proc boundTcpPort*(node: WakuNode): Port =
let ports = getPorts(node.switch.peerInfo.listenAddrs).valueOr:
raiseAssert "getPorts failed: " & error
if ports.tcpPort.isNone():
raiseAssert "no tcp listen address in " & $node.switch.peerInfo.listenAddrs
ports.tcpPort.get()

3
tests/waku_core/test_published_address.nim
View File

@ -5,8 +5,7 @@ import ../testlib/wakucore, ../testlib/wakunode
suite "Waku Core - Published Address":
test "Test IP 0.0.0.0":
let node =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
let node = newTestWakuNode(generateSecp256k1Key())
check:
($node.announcedAddresses).contains("127.0.0.1")

175
tests/waku_discv5/test_waku_discv5.nim
View File

@ -19,6 +19,7 @@ import
waku_core/codecs,
waku_enr,
discovery/waku_discv5,
net/auto_port,
waku_enr/capabilities,
factory/conf_builder/conf_builder,
waku,
@ -179,51 +180,57 @@ suite "Waku Discovery v5":
suite "findRandomPeers":
proc buildNode(
tcpPort: uint16,
udpPort: uint16,
bindIp: string = "0.0.0.0",
extIp: string = "127.0.0.1",
indices: seq[uint64] = @[],
recordFlags: Option[CapabilitiesBitfield] = none(CapabilitiesBitfield),
bootstrapRecords: seq[waku_enr.Record] = @[],
): (WakuDiscoveryV5, Record) {.raises: [ValueError, LPError].} =
let
privKey = generateSecp256k1Key()
record = newTestEnrRecord(
privKey = privKey,
extIp = extIp,
tcpPort = tcpPort,
udpPort = udpPort,
indices = indices,
flags = recordFlags,
)
node = discv5_utils.newTestDiscv5(
privKey = privKey,
bindIp = bindIp,
tcpPort = tcpPort,
udpPort = udpPort,
record = record,
bootstrapRecords = bootstrapRecords,
)
): Future[Result[(WakuDiscoveryV5, waku_enr.Record), string]] {.async.} =
let privKey = generateSecp256k1Key()
proc attempt(
p: Port
): Future[Result[(WakuDiscoveryV5, waku_enr.Record), string]] {.
async: (raises: [])
.} =
let (node, record) =
try:
let record = newTestEnrRecord(
privKey = privKey,
extIp = extIp,
tcpPort = tcpPort,
udpPort = uint16(p),
indices = indices,
flags = recordFlags,
)
(
discv5_utils.newTestDiscv5(
privKey = privKey,
bindIp = bindIp,
tcpPort = tcpPort,
udpPort = uint16(p),
record = record,
bootstrapRecords = bootstrapRecords,
),
record,
)
except CatchableError as e:
return err("could not build discv5 node: " & e.msg)
(await node.start()).isOkOr:
return err(error)
ok((node, record))
(node, record)
return await tryWithAutoPort[(WakuDiscoveryV5, waku_enr.Record)](Port(0), attempt)
asyncTest "find random peers without predicate":
# Given 3 nodes
let
(node1, record1) = buildNode(tcpPort = 61500u16, udpPort = 9000u16)
(node2, record2) = buildNode(tcpPort = 61502u16, udpPort = 9002u16)
(node3, record3) = buildNode(
tcpPort = 61504u16, udpPort = 9004u16, bootstrapRecords = @[record1, record2]
)
let res1 = await node1.start()
assertResultOk res1
let res2 = await node2.start()
assertResultOk res2
let res3 = await node3.start()
assertResultOk res3
let (node1, record1) = (await buildNode(tcpPort = 61500u16)).valueOr:
raiseAssert "node1: " & error
let (node2, record2) = (await buildNode(tcpPort = 61502u16)).valueOr:
raiseAssert "node2: " & error
let (node3, record3) = (
await buildNode(tcpPort = 61504u16, bootstrapRecords = @[record1, record2])
).valueOr:
raiseAssert "node3: " & error
await sleepAsync(FUTURE_TIMEOUT)
@ -254,45 +261,39 @@ suite "Waku Discovery v5":
return capabilities.get().supportsCapability(Capabilities.Store)
# Given 4 nodes
let
(node3, record3) = buildNode(
let (node3, record3) = (
await buildNode(
tcpPort = 61504u16,
udpPort = 9004u16,
recordFlags =
some(CapabilitiesBitfield.init(Capabilities.Relay, Capabilities.Filter)),
)
(node4, record4) = buildNode(
).valueOr:
raiseAssert "node3: " & error
let (node4, record4) = (
await buildNode(
tcpPort = 61506u16,
udpPort = 9006u16,
recordFlags =
some(CapabilitiesBitfield.init(Capabilities.Relay, Capabilities.Store)),
)
(node2, record2) = buildNode(
).valueOr:
raiseAssert "node4: " & error
let (node2, record2) = (
await buildNode(
tcpPort = 61502u16,
udpPort = 9002u16,
recordFlags =
some(CapabilitiesBitfield.init(Capabilities.Relay, Capabilities.Store)),
bootstrapRecords = @[record3, record4],
)
(node1, record1) = buildNode(
).valueOr:
raiseAssert "node2: " & error
let (node1, record1) = (
await buildNode(
tcpPort = 61500u16,
udpPort = 9000u16,
recordFlags = some(CapabilitiesBitfield.init(Capabilities.Relay)),
bootstrapRecords = @[record2],
)
# Start nodes' discoveryV5 protocols
let res1 = await node1.start()
assertResultOk res1
let res2 = await node2.start()
assertResultOk res2
let res3 = await node3.start()
assertResultOk res3
let res4 = await node4.start()
assertResultOk res4
).valueOr:
raiseAssert "node1: " & error
await sleepAsync(FUTURE_TIMEOUT)
@ -312,46 +313,40 @@ suite "Waku Discovery v5":
## Setup
# Records
let
(node3, record3) = buildNode(
let (node3, record3) = (
await buildNode(
tcpPort = 61504u16,
udpPort = 9004u16,
recordFlags =
some(CapabilitiesBitfield.init(Capabilities.Relay, Capabilities.Filter)),
)
(node4, record4) = buildNode(
).valueOr:
raiseAssert "node3: " & error
let (node4, record4) = (
await buildNode(
tcpPort = 61506u16,
udpPort = 9006u16,
recordFlags =
some(CapabilitiesBitfield.init(Capabilities.Relay, Capabilities.Store)),
)
(node2, record2) = buildNode(
).valueOr:
raiseAssert "node4: " & error
let (node2, record2) = (
await buildNode(
tcpPort = 61502u16,
udpPort = 9002u16,
recordFlags =
some(CapabilitiesBitfield.init(Capabilities.Relay, Capabilities.Store)),
bootstrapRecords = @[record3, record4],
)
let (node1, record1) = buildNode(
tcpPort = 61500u16,
udpPort = 9000u16,
recordFlags = some(CapabilitiesBitfield.init(Capabilities.Relay)),
indices = @[0u64, 0u64, 1u64, 0u64, 0u64],
bootstrapRecords = @[record2],
)
# Start nodes' discoveryV5 protocols
let res1 = await node1.start()
assertResultOk res1
let res2 = await node2.start()
assertResultOk res2
let res3 = await node3.start()
assertResultOk res3
let res4 = await node4.start()
assertResultOk res4
).valueOr:
raiseAssert "node2: " & error
let (node1, record1) = (
await buildNode(
tcpPort = 61500u16,
recordFlags = some(CapabilitiesBitfield.init(Capabilities.Relay)),
indices = @[0u64, 0u64, 1u64, 0u64, 0u64],
bootstrapRecords = @[record2],
)
).valueOr:
raiseAssert "node1: " & error
## leave some time for discv5 to act
await sleepAsync(chronos.seconds(10))
@ -425,7 +420,7 @@ suite "Waku Discovery v5":
confBuilder.withNodeKey(libp2p_keys.PrivateKey.random(Secp256k1, myRng)[])
confBuilder.discv5Conf.withEnabled(true)
confBuilder.discv5Conf.withUdpPort(9000.Port)
confBuilder.discv5Conf.withUdpPort(Port(0))
let conf = confBuilder.build().valueOr:
raiseAssert error
@ -437,8 +432,8 @@ suite "Waku Discovery v5":
confBuilder.withNodeKey(crypto.PrivateKey.random(Secp256k1, myRng)[])
confBuilder.discv5Conf.withBootstrapNodes(@[waku0.node.enr.toURI()])
confBuilder.discv5Conf.withEnabled(true)
confBuilder.discv5Conf.withUdpPort(9001.Port)
confBuilder.withP2pTcpPort(60001.Port)
confBuilder.discv5Conf.withUdpPort(Port(0))
confBuilder.withP2pTcpPort(Port(0))
let conf1 = confBuilder.build().valueOr:
raiseAssert error
@ -452,8 +447,8 @@ suite "Waku Discovery v5":
await waku1.node.mountRendezvous(conf.clusterId)
confBuilder.discv5Conf.withBootstrapNodes(@[waku1.node.enr.toURI()])
confBuilder.withP2pTcpPort(60003.Port)
confBuilder.discv5Conf.withUdpPort(9003.Port)
confBuilder.withP2pTcpPort(Port(0))
confBuilder.discv5Conf.withUdpPort(Port(0))
confBuilder.withNodeKey(crypto.PrivateKey.random(Secp256k1, myRng)[])
let conf2 = confBuilder.build().valueOr:

9
tests/waku_filter_v2/test_waku_client.nim
View File

@ -2257,12 +2257,9 @@ suite "Waku Filter - End to End":
contentTopic = DefaultContentTopic
contentTopicSeq = @[contentTopic]
client =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(23450))
server =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(23451))
client2nd =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(23452))
client = newTestWakuNode(generateSecp256k1Key())
server = newTestWakuNode(generateSecp256k1Key())
client2nd = newTestWakuNode(generateSecp256k1Key())
await allFutures(server.start(), client.start(), client2nd.start())

134
tests/waku_peer_exchange/test_protocol.nim
View File

@ -40,76 +40,31 @@ suite "Waku Peer Exchange":
lightpush = false, filter = false, store = false, relay = true
)
bindIp = parseIpAddress("0.0.0.0")
extIp = parseIpAddress("127.0.0.1")
nodeKey1 = generateSecp256k1Key()
nodeTcpPort1 = Port(64010)
nodeUdpPort1 = Port(9000)
node1 = newTestWakuNode(
nodeKey1,
bindIp,
nodeTcpPort1,
some(extIp),
wakuFlags = some(flags),
discv5UdpPort = some(nodeUdpPort1),
)
node1 = newTestWakuNode(nodeKey1, bindIp, Port(0), wakuFlags = some(flags))
nodeKey2 = generateSecp256k1Key()
nodeTcpPort2 = Port(64012)
nodeUdpPort2 = Port(9002)
node2 = newTestWakuNode(
nodeKey2,
bindIp,
nodeTcpPort2,
some(extIp),
wakuFlags = some(flags),
discv5UdpPort = some(nodeUdpPort2),
)
node2 = newTestWakuNode(nodeKey2, bindIp, Port(0), wakuFlags = some(flags))
nodeKey3 = generateSecp256k1Key()
nodeTcpPort3 = Port(64014)
nodeUdpPort3 = Port(9004)
node3 = newTestWakuNode(
nodeKey3,
bindIp,
nodeTcpPort3,
some(extIp),
wakuFlags = some(flags),
discv5UdpPort = some(nodeUdpPort3),
)
# discv5
let conf1 = WakuDiscoveryV5Config(
discv5Config: none(DiscoveryConfig),
address: bindIp,
port: nodeUdpPort1,
privateKey: keys.PrivateKey(nodeKey1.skkey),
bootstrapRecords: @[],
autoupdateRecord: true,
)
let disc1 = WakuDiscoveryV5.new(
node1.rng, conf1, some(node1.enr), some(node1.peerManager)
)
let conf2 = WakuDiscoveryV5Config(
discv5Config: none(DiscoveryConfig),
address: bindIp,
port: nodeUdpPort2,
privateKey: keys.PrivateKey(nodeKey2.skkey),
bootstrapRecords: @[disc1.protocol.getRecord()],
autoupdateRecord: true,
)
let disc2 = WakuDiscoveryV5.new(
node2.rng, conf2, some(node2.enr), some(node2.peerManager)
)
node3 = newTestWakuNode(nodeKey3, bindIp, Port(0), wakuFlags = some(flags))
await allFutures(node1.start(), node2.start(), node3.start())
let resultDisc1StartRes = await disc1.start()
assert resultDisc1StartRes.isOk(), resultDisc1StartRes.error
let resultDisc2StartRes = await disc2.start()
assert resultDisc2StartRes.isOk(), resultDisc2StartRes.error
let disc1 = (
await startDiscv5WithAutoPort(node1, keys.PrivateKey(nodeKey1.skkey), bindIp)
).valueOr:
raiseAssert "disc1: " & error
let disc2 = (
await startDiscv5WithAutoPort(
node2,
keys.PrivateKey(nodeKey2.skkey),
bindIp,
@[disc1.protocol.getRecord()],
)
).valueOr:
raiseAssert "disc2: " & error
## When
var attempts = 10
@ -142,14 +97,10 @@ suite "Waku Peer Exchange":
asyncTest "Request returns some discovered peers":
let
node1 =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
node2 =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
node3 =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
node4 =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
node1 = newTestWakuNode(generateSecp256k1Key())
node2 = newTestWakuNode(generateSecp256k1Key())
node3 = newTestWakuNode(generateSecp256k1Key())
node4 = newTestWakuNode(generateSecp256k1Key())
# Start and mount peer exchange
await allFutures([node1.start(), node2.start(), node3.start(), node4.start()])
@ -199,10 +150,8 @@ suite "Waku Peer Exchange":
asyncTest "Request fails gracefully":
let
node1 =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
node2 =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
node1 = newTestWakuNode(generateSecp256k1Key())
node2 = newTestWakuNode(generateSecp256k1Key())
# Start and mount peer exchange
await allFutures([node1.start(), node2.start()])
@ -276,12 +225,9 @@ suite "Waku Peer Exchange":
asyncTest "Request 0 peers, with 1 peer in PeerExchange":
# Given two valid nodes with PeerExchange
let
node1 =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
node2 =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
node3 =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
node1 = newTestWakuNode(generateSecp256k1Key())
node2 = newTestWakuNode(generateSecp256k1Key())
node3 = newTestWakuNode(generateSecp256k1Key())
# Start and mount peer exchange
await allFutures([node1.start(), node2.start(), node3.start()])
@ -308,10 +254,8 @@ suite "Waku Peer Exchange":
asyncTest "Request with invalid peer info":
# Given two valid nodes with PeerExchange
let
node1 =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
node2 =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
node1 = newTestWakuNode(generateSecp256k1Key())
node2 = newTestWakuNode(generateSecp256k1Key())
# Start and mount peer exchange
await allFutures([node1.start(), node2.start()])
@ -329,9 +273,7 @@ suite "Waku Peer Exchange":
asyncTest "Connections are closed after response is sent":
# Create 3 nodes
let nodes = toSeq(0 ..< 3).mapIt(
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
)
let nodes = toSeq(0 ..< 3).mapIt(newTestWakuNode(generateSecp256k1Key()))
await allFutures(nodes.mapIt(it.start()))
await allFutures(nodes.mapIt(it.mountPeerExchange()))
@ -356,12 +298,9 @@ suite "Waku Peer Exchange":
suite "Protocol Handler":
asyncTest "Works as expected":
let
node1 =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
node2 =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
node3 =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
node1 = newTestWakuNode(generateSecp256k1Key())
node2 = newTestWakuNode(generateSecp256k1Key())
node3 = newTestWakuNode(generateSecp256k1Key())
# Start and mount peer exchange
await allFutures([node1.start(), node2.start(), node3.start()])
@ -398,12 +337,9 @@ suite "Waku Peer Exchange":
asyncTest "RateLimit as expected":
let
node1 =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
node2 =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
node3 =
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
node1 = newTestWakuNode(generateSecp256k1Key())
node2 = newTestWakuNode(generateSecp256k1Key())
node3 = newTestWakuNode(generateSecp256k1Key())
# Start and mount peer exchange
await allFutures([node1.start(), node2.start(), node3.start()])

31
tests/waku_peer_exchange/utils.nim
View File

@ -1,7 +1,8 @@
{.used.}
import
std/options,
std/[options, net],
results,
testutils/unittests,
chronos,
libp2p/switch,
@ -14,6 +15,7 @@ import
logos_delivery/waku/[
waku_node,
discovery/waku_discv5,
net/auto_port,
waku_peer_exchange,
waku_peer_exchange/rpc,
waku_peer_exchange/protocol,
@ -23,6 +25,33 @@ import
],
../testlib/[futures, wakucore, assertions]
proc startDiscv5WithAutoPort*(
node: WakuNode,
key: keys.PrivateKey,
bindIp: IpAddress,
bootstrapRecords: seq[enr.Record] = @[],
): Future[Result[WakuDiscoveryV5, string]] {.async.} =
proc attempt(
p: Port
): Future[Result[WakuDiscoveryV5, string]] {.async: (raises: []).} =
var record = node.enr
record.update(key, udpPort = Opt.some(p)).isOkOr:
return err("could not set discv5 udp port in enr: " & $error)
let conf = WakuDiscoveryV5Config(
discv5Config: none(DiscoveryConfig),
address: bindIp,
port: p,
privateKey: key,
bootstrapRecords: bootstrapRecords,
autoupdateRecord: true,
)
let wd = WakuDiscoveryV5.new(node.rng, conf, some(record), some(node.peerManager))
(await wd.start()).isOkOr:
return err(error)
return ok(wd)
return await tryWithAutoPort[WakuDiscoveryV5](Port(0), attempt)
proc dialForPeerExchange*(
client: WakuNode,
peerInfo: RemotePeerInfo,

69
tests/waku_relay/test_wakunode_relay.nim
View File

@ -24,7 +24,7 @@ suite "WakuNode - Relay":
asyncTest "Relay protocol is started correctly":
let
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(nodeKey1, parseIpAddress("0.0.0.0"), Port(0))
node1 = newTestWakuNode(nodeKey1)
# Relay protocol starts if mounted after node start
@ -39,7 +39,7 @@ suite "WakuNode - Relay":
let
nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, parseIpAddress("0.0.0.0"), Port(0))
node2 = newTestWakuNode(nodeKey2)
(await node2.mountRelay()).isOkOr:
assert false, "Failed to mount relay"
@ -59,11 +59,11 @@ suite "WakuNode - Relay":
asyncTest "Messages are correctly relayed":
let
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(nodeKey1, parseIpAddress("0.0.0.0"), Port(0))
node1 = newTestWakuNode(nodeKey1)
nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, parseIpAddress("0.0.0.0"), Port(0))
node2 = newTestWakuNode(nodeKey2)
nodeKey3 = generateSecp256k1Key()
node3 = newTestWakuNode(nodeKey3, parseIpAddress("0.0.0.0"), Port(0))
node3 = newTestWakuNode(nodeKey3)
shard = DefaultRelayShard
contentTopic = ContentTopic("/waku/2/default-content/proto")
payload = "hello world".toBytes()
@ -134,13 +134,13 @@ suite "WakuNode - Relay":
let
# publisher node
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(nodeKey1, parseIpAddress("0.0.0.0"), Port(0))
node1 = newTestWakuNode(nodeKey1)
# Relay node
nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, parseIpAddress("0.0.0.0"), Port(0))
node2 = newTestWakuNode(nodeKey2)
# Subscriber
nodeKey3 = generateSecp256k1Key()
node3 = newTestWakuNode(nodeKey3, parseIpAddress("0.0.0.0"), Port(0))
node3 = newTestWakuNode(nodeKey3)
shard = DefaultRelayShard
contentTopic1 = ContentTopic("/waku/2/default-content/proto")
@ -238,9 +238,7 @@ suite "WakuNode - Relay":
# TODO: Add a function to validate the WakuMessage integrity
xasyncTest "Stats of peer sending wrong WakuMessages are updated":
# Create 2 nodes
let nodes = toSeq(0 .. 1).mapIt(
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
)
let nodes = toSeq(0 .. 1).mapIt(newTestWakuNode(generateSecp256k1Key()))
# Start all the nodes and mount relay with
await allFutures(nodes.mapIt(it.start()))
@ -278,21 +276,9 @@ suite "WakuNode - Relay":
asyncTest "Messages are relayed between two websocket nodes":
let
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(
nodeKey1,
parseIpAddress("0.0.0.0"),
bindPort = Port(0),
wsBindPort = Port(0),
wsEnabled = true,
)
node1 = newTestWakuNode(nodeKey1, wsBindPort = Port(0), wsEnabled = true)
nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(
nodeKey2,
parseIpAddress("0.0.0.0"),
bindPort = Port(0),
wsBindPort = Port(0),
wsEnabled = true,
)
node2 = newTestWakuNode(nodeKey2, wsBindPort = Port(0), wsEnabled = true)
shard = DefaultRelayShard
contentTopic = ContentTopic("/waku/2/default-content/proto")
payload = "hello world".toBytes()
@ -342,13 +328,7 @@ suite "WakuNode - Relay":
asyncTest "Messages are relayed between nodes with multiple transports (TCP and Websockets)":
let
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(
nodeKey1,
parseIpAddress("0.0.0.0"),
bindPort = Port(0),
wsBindPort = Port(0),
wsEnabled = true,
)
node1 = newTestWakuNode(nodeKey1, wsBindPort = Port(0), wsEnabled = true)
nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, parseIpAddress("0.0.0.0"), bindPort = Port(0))
shard = DefaultRelayShard
@ -406,12 +386,7 @@ suite "WakuNode - Relay":
)
nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(
nodeKey2,
parseIpAddress("0.0.0.0"),
bindPort = Port(0),
wsBindPort = Port(0),
wsEnabled = true,
quicEnabled = false,
nodeKey2, wsBindPort = Port(0), wsEnabled = true, quicEnabled = false
)
shard = DefaultRelayShard
contentTopic = ContentTopic("/waku/2/default-content/proto")
@ -469,8 +444,6 @@ suite "WakuNode - Relay":
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(
nodeKey1,
parseIpAddress("0.0.0.0"),
bindPort = Port(0),
wsBindPort = Port(0),
wssEnabled = true,
secureKey = KEY_PATH,
@ -529,21 +502,13 @@ suite "WakuNode - Relay":
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(
nodeKey1,
parseIpAddress("0.0.0.0"),
bindPort = Port(0),
wsBindPort = Port(0),
wssEnabled = true,
secureKey = KEY_PATH,
secureCert = CERT_PATH,
)
nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(
nodeKey2,
parseIpAddress("0.0.0.0"),
bindPort = Port(0),
wsBindPort = Port(0),
wsEnabled = true,
)
node2 = newTestWakuNode(nodeKey2, wsBindPort = Port(0), wsEnabled = true)
let
shard = DefaultRelayShard
@ -594,9 +559,7 @@ suite "WakuNode - Relay":
asyncTest "Bad peers with low reputation are disconnected":
# Create 5 nodes
let nodes = toSeq(0 ..< 5).mapIt(
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
)
let nodes = toSeq(0 ..< 5).mapIt(newTestWakuNode(generateSecp256k1Key()))
await allFutures(nodes.mapIt(it.start()))
await allFutures(nodes.mapIt(it.mountRelay()))
@ -657,7 +620,7 @@ suite "WakuNode - Relay":
## Setup
let
nodeKey = generateSecp256k1Key()
node = newTestWakuNode(nodeKey, parseIpAddress("0.0.0.0"), Port(0))
node = newTestWakuNode(nodeKey)
await node.start()
(await node.mountRelay()).isOkOr:

28
tests/waku_rln_relay/test_wakunode_rln_relay.nim
View File

@ -44,7 +44,7 @@ procSuite "WakuNode - RLN relay":
# set up three nodes
lockNewGlobalBrokerContext:
let nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(nodeKey1, parseIpAddress("0.0.0.0"), Port(0))
node1 = newTestWakuNode(nodeKey1)
(await node1.mountRelay()).isOkOr:
assert false, "Failed to mount relay"
@ -68,7 +68,7 @@ procSuite "WakuNode - RLN relay":
lockNewGlobalBrokerContext:
# Relay node
let nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, parseIpAddress("0.0.0.0"), Port(0))
node2 = newTestWakuNode(nodeKey2)
(await node2.mountRelay()).isOkOr:
assert false, "Failed to mount relay"
@ -86,7 +86,7 @@ procSuite "WakuNode - RLN relay":
lockNewGlobalBrokerContext:
# Subscriber
let nodeKey3 = generateSecp256k1Key()
node3 = newTestWakuNode(nodeKey3, parseIpAddress("0.0.0.0"), Port(0))
node3 = newTestWakuNode(nodeKey3)
(await node3.mountRelay()).isOkOr:
assert false, "Failed to mount relay"
@ -160,7 +160,7 @@ procSuite "WakuNode - RLN relay":
var node1, node2, node3: WakuNode
lockNewGlobalBrokerContext:
let nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(nodeKey1, parseIpAddress("0.0.0.0"), Port(0))
node1 = newTestWakuNode(nodeKey1)
(await node1.mountRelay()).isOkOr:
assert false, "Failed to mount relay"
let wakuRlnConfig1 =
@ -177,7 +177,7 @@ procSuite "WakuNode - RLN relay":
info "Updated root for node", node = 1, rootUpdated = rootUpdated1
lockNewGlobalBrokerContext:
let nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, parseIpAddress("0.0.0.0"), Port(0))
node2 = newTestWakuNode(nodeKey2)
(await node2.mountRelay()).isOkOr:
assert false, "Failed to mount relay"
let wakuRlnConfig2 =
@ -194,7 +194,7 @@ procSuite "WakuNode - RLN relay":
info "Updated root for node", node = 2, rootUpdated = rootUpdated2
lockNewGlobalBrokerContext:
let nodeKey3 = generateSecp256k1Key()
node3 = newTestWakuNode(nodeKey3, parseIpAddress("0.0.0.0"), Port(0))
node3 = newTestWakuNode(nodeKey3)
(await node3.mountRelay()).isOkOr:
assert false, "Failed to mount relay"
let wakuRlnConfig3 =
@ -307,7 +307,7 @@ procSuite "WakuNode - RLN relay":
lockNewGlobalBrokerContext:
# publisher node
let nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(nodeKey1, parseIpAddress("0.0.0.0"), Port(0))
node1 = newTestWakuNode(nodeKey1)
(await node1.mountRelay()).isOkOr:
assert false, "Failed to mount relay"
@ -329,7 +329,7 @@ procSuite "WakuNode - RLN relay":
lockNewGlobalBrokerContext:
# Relay node
let nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, parseIpAddress("0.0.0.0"), Port(0))
node2 = newTestWakuNode(nodeKey2)
(await node2.mountRelay()).isOkOr:
assert false, "Failed to mount relay"
# mount rlnrelay in off-chain mode
@ -345,7 +345,7 @@ procSuite "WakuNode - RLN relay":
lockNewGlobalBrokerContext:
# Subscriber
let nodeKey3 = generateSecp256k1Key()
node3 = newTestWakuNode(nodeKey3, parseIpAddress("0.0.0.0"), Port(0))
node3 = newTestWakuNode(nodeKey3)
(await node3.mountRelay()).isOkOr:
assert false, "Failed to mount relay"
@ -418,7 +418,7 @@ procSuite "WakuNode - RLN relay":
lockNewGlobalBrokerContext:
# publisher node
let nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(nodeKey1, parseIpAddress("0.0.0.0"), Port(0))
node1 = newTestWakuNode(nodeKey1)
(await node1.mountRelay()).isOkOr:
assert false, "Failed to mount relay"
@ -441,7 +441,7 @@ procSuite "WakuNode - RLN relay":
lockNewGlobalBrokerContext:
# Relay node
let nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, parseIpAddress("0.0.0.0"), Port(0))
node2 = newTestWakuNode(nodeKey2)
(await node2.mountRelay()).isOkOr:
assert false, "Failed to mount relay"
@ -459,7 +459,7 @@ procSuite "WakuNode - RLN relay":
lockNewGlobalBrokerContext:
# Subscriber
let nodeKey3 = generateSecp256k1Key()
node3 = newTestWakuNode(nodeKey3, parseIpAddress("0.0.0.0"), Port(0))
node3 = newTestWakuNode(nodeKey3)
(await node3.mountRelay()).isOkOr:
assert false, "Failed to mount relay"
@ -590,7 +590,7 @@ procSuite "WakuNode - RLN relay":
epochSizeSec: uint64 = 5 # This means rlnMaxEpochGap = 4
lockNewGlobalBrokerContext:
let nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(nodeKey1, parseIpAddress("0.0.0.0"), Port(0))
node1 = newTestWakuNode(nodeKey1)
(await node1.mountRelay()).isOkOr:
assert false, "Failed to mount relay"
let wakuRlnConfig1 =
@ -609,7 +609,7 @@ procSuite "WakuNode - RLN relay":
info "Updated root for node1", rootUpdated1
lockNewGlobalBrokerContext:
let nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, parseIpAddress("0.0.0.0"), Port(0))
node2 = newTestWakuNode(nodeKey2)
(await node2.mountRelay()).isOkOr:
assert false, "Failed to mount relay"
let wakuRlnConfig2 =

31
tests/waku_store/test_wakunode_store.nim
View File

@ -66,9 +66,9 @@ procSuite "WakuNode - Store":
## Setup
let
serverKey = generateSecp256k1Key()
server = newTestWakuNode(serverKey, parseIpAddress("0.0.0.0"), Port(0))
server = newTestWakuNode(serverKey)
clientKey = generateSecp256k1Key()
client = newTestWakuNode(clientKey, parseIpAddress("0.0.0.0"), Port(0))
client = newTestWakuNode(clientKey)
waitFor allFutures(client.start(), server.start())
@ -101,9 +101,9 @@ procSuite "WakuNode - Store":
## Setup
let
serverKey = generateSecp256k1Key()
server = newTestWakuNode(serverKey, parseIpAddress("0.0.0.0"), Port(0))
server = newTestWakuNode(serverKey)
clientKey = generateSecp256k1Key()
client = newTestWakuNode(clientKey, parseIpAddress("0.0.0.0"), Port(0))
client = newTestWakuNode(clientKey)
waitFor allFutures(client.start(), server.start())
@ -157,9 +157,9 @@ procSuite "WakuNode - Store":
## Setup
let
serverKey = generateSecp256k1Key()
server = newTestWakuNode(serverKey, parseIpAddress("0.0.0.0"), Port(0))
server = newTestWakuNode(serverKey)
clientKey = generateSecp256k1Key()
client = newTestWakuNode(clientKey, parseIpAddress("0.0.0.0"), Port(0))
client = newTestWakuNode(clientKey)
waitFor allFutures(client.start(), server.start())
@ -214,12 +214,11 @@ procSuite "WakuNode - Store":
## Setup
let
filterSourceKey = generateSecp256k1Key()
filterSource =
newTestWakuNode(filterSourceKey, parseIpAddress("0.0.0.0"), Port(0))
filterSource = newTestWakuNode(filterSourceKey)
serverKey = generateSecp256k1Key()
server = newTestWakuNode(serverKey, parseIpAddress("0.0.0.0"), Port(0))
server = newTestWakuNode(serverKey)
clientKey = generateSecp256k1Key()
client = newTestWakuNode(clientKey, parseIpAddress("0.0.0.0"), Port(0))
client = newTestWakuNode(clientKey)
waitFor allFutures(client.start(), server.start(), filterSource.start())
@ -289,9 +288,9 @@ procSuite "WakuNode - Store":
## Setup
let
serverKey = generateSecp256k1Key()
server = newTestWakuNode(serverKey, parseIpAddress("0.0.0.0"), Port(0))
server = newTestWakuNode(serverKey)
clientKey = generateSecp256k1Key()
client = newTestWakuNode(clientKey, parseIpAddress("0.0.0.0"), Port(0))
client = newTestWakuNode(clientKey)
waitFor allFutures(client.start(), server.start())
@ -332,9 +331,9 @@ procSuite "WakuNode - Store":
## Setup
let
serverKey = generateSecp256k1Key()
server = newTestWakuNode(serverKey, parseIpAddress("0.0.0.0"), Port(0))
server = newTestWakuNode(serverKey)
clientKey = generateSecp256k1Key()
client = newTestWakuNode(clientKey, parseIpAddress("0.0.0.0"), Port(0))
client = newTestWakuNode(clientKey)
waitFor allFutures(client.start(), server.start())
@ -382,9 +381,9 @@ procSuite "WakuNode - Store":
## Setup
let
serverKey = generateSecp256k1Key()
server = newTestWakuNode(serverKey, parseIpAddress("0.0.0.0"), Port(0))
server = newTestWakuNode(serverKey)
clientKey = generateSecp256k1Key()
client = newTestWakuNode(clientKey, parseIpAddress("0.0.0.0"), Port(0))
client = newTestWakuNode(clientKey)
waitFor allFutures(client.start(), server.start())

12
tests/wakunode2/test_validators.nim
View File

@ -21,9 +21,7 @@ import
suite "WakuNode2 - Validators":
asyncTest "Spam protected topic accepts signed messages":
# Create 5 nodes
let nodes = toSeq(0 ..< 5).mapIt(
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
)
let nodes = toSeq(0 ..< 5).mapIt(newTestWakuNode(generateSecp256k1Key()))
# Protected shard and key to sign
let spamProtectedShard = RelayShard(clusterId: 0, shardId: 7)
@ -108,9 +106,7 @@ suite "WakuNode2 - Validators":
asyncTest "Spam protected topic rejects non-signed/wrongly-signed/no-timestamp messages":
# Create 5 nodes
let nodes = toSeq(0 ..< 5).mapIt(
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
)
let nodes = toSeq(0 ..< 5).mapIt(newTestWakuNode(generateSecp256k1Key()))
# Protected shard and key to sign
let spamProtectedShard = RelayShard(clusterId: 0, shardId: 7)
@ -260,9 +256,7 @@ suite "WakuNode2 - Validators":
asyncTest "Spam protected topic rejects a spammer node":
# Create 5 nodes
let nodes = toSeq(0 ..< 5).mapIt(
newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
)
let nodes = toSeq(0 ..< 5).mapIt(newTestWakuNode(generateSecp256k1Key()))
# Protected shard and key to sign
let spamProtectedShard = RelayShard(clusterId: 0, shardId: 7)