Skip to content

Commit 22781cb

Browse files
azarovhazarovh
authored
Merge pull request #1260 from mintlayer/fix/p2p_rework_test_node_methods
Improve methods names in p2p/sync/TestNode
2 parents f6d3f44 + ee5bb1d commit 22781cb

File tree

10 files changed

+301
-351
lines changed

10 files changed

+301
-351
lines changed

‎p2p/src/sync/tests/ban_scores.rs

Lines changed: 6 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -131,17 +131,15 @@ async fn receive_header_with_invalid_parent_block(#[case] seed: Seed) {
131131
.build()
132132
.await;
133133

134-
let peer_id = PeerId::new();
135-
node.connect_peer(peer_id, protocol_version).await;
134+
let peer = node.connect_peer(PeerId::new(), protocol_version).await;
136135

137-
node.send_message(
138-
peer_id,
139-
SyncMessage::HeaderList(HeaderList::new(vec![valid_child_block.header().clone()])),
140-
)
136+
peer.send_message(SyncMessage::HeaderList(HeaderList::new(vec![
137+
valid_child_block.header().clone(),
138+
])))
141139
.await;
142140

143-
let (adjusted_peer_id, ban_score_delta) = node.adjust_peer_score_event().await;
144-
assert_eq!(adjusted_peer_id, peer_id);
141+
let (adjusted_peer_id, ban_score_delta) = node.receive_adjust_peer_score_event().await;
142+
assert_eq!(adjusted_peer_id, peer.get_id());
145143
assert_eq!(ban_score_delta, 100);
146144

147145
node.join_subsystem_manager().await;

‎p2p/src/sync/tests/block_announcement.rs

Lines changed: 58 additions & 70 deletions
Original file line numberDiff line numberDiff line change
@@ -97,26 +97,25 @@ async fn single_header_with_unknown_prev_block_v1(#[case] seed: Seed) {
9797
.build()
9898
.await;
9999

100-
let peer = PeerId::new();
101-
node.connect_peer(peer, protocol_version).await;
100+
let peer = node.connect_peer(PeerId::new(), protocol_version).await;
102101

103102
// The first attempt to send an unconnected header should trigger HeaderListRequest.
104-
node.send_headers(peer, vec![block_2.header().clone()]).await;
103+
peer.send_headers(vec![block_2.header().clone()]).await;
105104

106105
// Note: we call assert_no_peer_manager_event twice; the last call is needed to make sure
107106
// that the event is caught even if it's late; the first one just allows the test to fail
108107
// faster if the event is not late.
109108
node.assert_no_peer_manager_event().await;
110-
let (sent_to, message) = node.message().await;
111-
assert_eq!(sent_to, peer);
109+
let (sent_to, message) = node.get_sent_message().await;
110+
assert_eq!(sent_to, peer.get_id());
112111
assert!(matches!(message, SyncMessage::HeaderListRequest(_)));
113112
node.assert_no_peer_manager_event().await;
114113

115114
// The second attempt to send an unconnected header should increase the ban score.
116-
node.send_headers(peer, vec![block_2.header().clone()]).await;
115+
peer.send_headers(vec![block_2.header().clone()]).await;
117116

118117
node.assert_peer_score_adjustment(
119-
peer,
118+
peer.get_id(),
120119
P2pError::ProtocolError(ProtocolError::DisconnectedHeaders).ban_score(),
121120
)
122121
.await;
@@ -186,35 +185,34 @@ async fn single_header_with_unknown_prev_block_with_intermittent_connected_heade
186185
.build()
187186
.await;
188187

189-
let peer = PeerId::new();
190-
node.connect_peer(peer, protocol_version).await;
188+
let peer = node.connect_peer(PeerId::new(), protocol_version).await;
191189

192190
// The first attempt to send an unconnected header should trigger HeaderListRequest.
193-
node.send_headers(peer, vec![block_2.header().clone()]).await;
191+
peer.send_headers(vec![block_2.header().clone()]).await;
194192

195193
node.assert_no_peer_manager_event().await;
196-
let (sent_to, message) = node.message().await;
197-
assert_eq!(sent_to, peer);
194+
let (sent_to, message) = node.get_sent_message().await;
195+
assert_eq!(sent_to, peer.get_id());
198196
assert!(matches!(message, SyncMessage::HeaderListRequest(_)));
199197
node.assert_no_peer_manager_event().await;
200198

201199
// Send a header with a known parent, the node should ask for blocks
202-
node.send_headers(peer, vec![block_11.header().clone()]).await;
200+
peer.send_headers(vec![block_11.header().clone()]).await;
203201

204202
node.assert_no_peer_manager_event().await;
205-
let (sent_to, message) = node.message().await;
206-
assert_eq!(sent_to, peer);
203+
let (sent_to, message) = node.get_sent_message().await;
204+
assert_eq!(sent_to, peer.get_id());
207205
assert!(matches!(message, SyncMessage::BlockListRequest(_)));
208206
node.assert_no_peer_manager_event().await;
209207

210208
// The second attempt to send an unconnected header should again trigger HeaderListRequest,
211209
// because a correct header list message was received between the attempts and the counter
212210
// for the unconnected headers has been reset.
213-
node.send_headers(peer, vec![block_2.header().clone()]).await;
211+
peer.send_headers(vec![block_2.header().clone()]).await;
214212

215213
node.assert_no_peer_manager_event().await;
216-
let (sent_to, message) = node.message().await;
217-
assert_eq!(sent_to, peer);
214+
let (sent_to, message) = node.get_sent_message().await;
215+
assert_eq!(sent_to, peer.get_id());
218216
assert!(matches!(message, SyncMessage::HeaderListRequest(_)));
219217
node.assert_no_peer_manager_event().await;
220218

@@ -248,14 +246,13 @@ async fn single_header_with_unknown_prev_block_v2(#[case] seed: Seed) {
248246
.build()
249247
.await;
250248

251-
let peer = PeerId::new();
252-
node.connect_peer(peer, protocol_version).await;
249+
let peer = node.connect_peer(PeerId::new(), protocol_version).await;
253250

254251
// Sending even 1 unconnected header should lead to ban score increase.
255-
node.send_headers(peer, vec![block_2.header().clone()]).await;
252+
peer.send_headers(vec![block_2.header().clone()]).await;
256253

257254
node.assert_peer_score_adjustment(
258-
peer,
255+
peer.get_id(),
259256
P2pError::ProtocolError(ProtocolError::DisconnectedHeaders).ban_score(),
260257
)
261258
.await;
@@ -275,8 +272,7 @@ async fn invalid_timestamp() {
275272
.build()
276273
.await;
277274

278-
let peer = PeerId::new();
279-
node.connect_peer(peer, protocol_version).await;
275+
let peer = node.connect_peer(PeerId::new(), protocol_version).await;
280276

281277
let block = Block::new(
282278
Vec::new(),
@@ -286,14 +282,13 @@ async fn invalid_timestamp() {
286282
BlockReward::new(Vec::new()),
287283
)
288284
.unwrap();
289-
node.send_message(
290-
peer,
291-
SyncMessage::HeaderList(HeaderList::new(vec![block.header().clone()])),
292-
)
293-
.await;
285+
peer.send_message(SyncMessage::HeaderList(HeaderList::new(vec![block
286+
.header()
287+
.clone()])))
288+
.await;
294289

295-
let (adjusted_peer, score) = node.adjust_peer_score_event().await;
296-
assert_eq!(peer, adjusted_peer);
290+
let (adjusted_peer, score) = node.receive_adjust_peer_score_event().await;
291+
assert_eq!(peer.get_id(), adjusted_peer);
297292
assert_eq!(
298293
score,
299294
P2pError::ChainstateError(ChainstateError::ProcessBlockError(
@@ -327,8 +322,7 @@ async fn invalid_consensus_data() {
327322
.build()
328323
.await;
329324

330-
let peer = PeerId::new();
331-
node.connect_peer(peer, protocol_version).await;
325+
let peer = node.connect_peer(PeerId::new(), protocol_version).await;
332326

333327
let block = Block::new(
334328
Vec::new(),
@@ -338,14 +332,13 @@ async fn invalid_consensus_data() {
338332
BlockReward::new(Vec::new()),
339333
)
340334
.unwrap();
341-
node.send_message(
342-
peer,
343-
SyncMessage::HeaderList(HeaderList::new(vec![block.header().clone()])),
344-
)
345-
.await;
335+
peer.send_message(SyncMessage::HeaderList(HeaderList::new(vec![block
336+
.header()
337+
.clone()])))
338+
.await;
346339

347-
let (adjusted_peer, score) = node.adjust_peer_score_event().await;
348-
assert_eq!(peer, adjusted_peer);
340+
let (adjusted_peer, score) = node.receive_adjust_peer_score_event().await;
341+
assert_eq!(peer.get_id(), adjusted_peer);
349342
assert_eq!(
350343
score,
351344
P2pError::ChainstateError(ChainstateError::ProcessBlockError(
@@ -388,17 +381,16 @@ async fn multiple_headers_with_unknown_prev_block(#[case] seed: Seed) {
388381
.build()
389382
.await;
390383

391-
let peer = PeerId::new();
392-
node.connect_peer(peer, protocol_version).await;
384+
let peer = node.connect_peer(PeerId::new(), protocol_version).await;
393385

394-
node.send_headers(
395-
peer,
396-
vec![orphan_block1.header().clone(), orphan_block2.header().clone()],
397-
)
386+
peer.send_headers(vec![
387+
orphan_block1.header().clone(),
388+
orphan_block2.header().clone(),
389+
])
398390
.await;
399391

400392
node.assert_peer_score_adjustment(
401-
peer,
393+
peer.get_id(),
402394
P2pError::ProtocolError(ProtocolError::DisconnectedHeaders).ban_score(),
403395
)
404396
.await;
@@ -430,17 +422,15 @@ async fn valid_block(#[case] seed: Seed) {
430422
.build()
431423
.await;
432424

433-
let peer = PeerId::new();
434-
node.connect_peer(peer, protocol_version).await;
425+
let peer = node.connect_peer(PeerId::new(), protocol_version).await;
435426

436-
node.send_message(
437-
peer,
438-
SyncMessage::HeaderList(HeaderList::new(vec![block.header().clone()])),
439-
)
440-
.await;
427+
peer.send_message(SyncMessage::HeaderList(HeaderList::new(vec![block
428+
.header()
429+
.clone()])))
430+
.await;
441431

442-
let (sent_to, message) = node.message().await;
443-
assert_eq!(sent_to, peer);
432+
let (sent_to, message) = node.get_sent_message().await;
433+
assert_eq!(sent_to, peer.get_id());
444434
assert_eq!(
445435
message,
446436
SyncMessage::BlockListRequest(BlockListRequest::new(vec![block.get_id()]))
@@ -479,8 +469,7 @@ async fn best_known_header_is_considered(#[case] seed: Seed) {
479469
.build()
480470
.await;
481471

482-
let peer = PeerId::new();
483-
node.connect_peer(peer, protocol_version).await;
472+
let peer = node.connect_peer(PeerId::new(), protocol_version).await;
484473

485474
// Simulate the initial header exchange; make the peer send the node a locator containing
486475
// the node's tip, so that it responds with an empty header list.
@@ -489,15 +478,14 @@ async fn best_known_header_is_considered(#[case] seed: Seed) {
489478
{
490479
let locator = node.get_locator_from_height(1.into()).await;
491480

492-
node.send_message(
493-
peer,
494-
SyncMessage::HeaderListRequest(HeaderListRequest::new(locator)),
495-
)
481+
peer.send_message(SyncMessage::HeaderListRequest(HeaderListRequest::new(
482+
locator,
483+
)))
496484
.await;
497485

498486
log::debug!("Expecting initial header response");
499-
let (sent_to, message) = node.message().await;
500-
assert_eq!(sent_to, peer);
487+
let (sent_to, message) = node.get_sent_message().await;
488+
assert_eq!(sent_to, peer.get_id());
501489
assert_eq!(
502490
message,
503491
SyncMessage::HeaderList(HeaderList::new(Vec::new()))
@@ -518,8 +506,8 @@ async fn best_known_header_is_considered(#[case] seed: Seed) {
518506
.await;
519507

520508
log::debug!("Expecting first announcement");
521-
let (sent_to, message) = node.message().await;
522-
assert_eq!(sent_to, peer);
509+
let (sent_to, message) = node.get_sent_message().await;
510+
assert_eq!(sent_to, peer.get_id());
523511
assert_eq!(
524512
message,
525513
SyncMessage::HeaderList(HeaderList::new(headers.clone()))
@@ -546,8 +534,8 @@ async fn best_known_header_is_considered(#[case] seed: Seed) {
546534
.await;
547535

548536
log::debug!("Expecting second announcement");
549-
let (sent_to, message) = node.message().await;
550-
assert_eq!(sent_to, peer);
537+
let (sent_to, message) = node.get_sent_message().await;
538+
assert_eq!(sent_to, peer.get_id());
551539
assert_eq!(
552540
message,
553541
SyncMessage::HeaderList(HeaderList::new(headers.clone()))
@@ -570,8 +558,8 @@ async fn best_known_header_is_considered(#[case] seed: Seed) {
570558
.await;
571559

572560
log::debug!("Expecting third announcement");
573-
let (sent_to, message) = node.message().await;
574-
assert_eq!(sent_to, peer);
561+
let (sent_to, message) = node.get_sent_message().await;
562+
assert_eq!(sent_to, peer.get_id());
575563
assert_eq!(
576564
message,
577565
SyncMessage::HeaderList(HeaderList::new(reorg_headers))

0 commit comments

Comments
 (0)