upleb.uk

Public git repos — served from a NIP-34 GRASP relay at git.upleb.uk

summaryrefslogtreecommitdiff
path: root/tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests')
-rw-r--r--tests/init.rs112
-rw-r--r--tests/push.rs2
-rw-r--r--tests/send.rs14
3 files changed, 85 insertions, 43 deletions
diff --git a/tests/init.rs b/tests/init.rs
index 56ce332..6db2554 100644
--- a/tests/init.rs
+++ b/tests/init.rs
@@ -58,10 +58,11 @@ mod when_repo_not_previously_claimed {
58 Relay<'static>, 58 Relay<'static>,
59 Relay<'static>, 59 Relay<'static>,
60 Relay<'static>, 60 Relay<'static>,
61 Relay<'static>,
61 )> { 62 )> {
62 let git_repo = prep_git_repo()?; 63 let git_repo = prep_git_repo()?;
63 // fallback (51,52) user write (53, 55) repo (55, 56) 64 // fallback (51,52) user write (53, 55) repo (55, 56) blaster (57)
64 let (mut r51, mut r52, mut r53, mut r55, mut r56) = ( 65 let (mut r51, mut r52, mut r53, mut r55, mut r56, mut r57) = (
65 Relay::new( 66 Relay::new(
66 8051, 67 8051,
67 None, 68 None,
@@ -81,13 +82,14 @@ mod when_repo_not_previously_claimed {
81 Relay::new(8053, None, None), 82 Relay::new(8053, None, None),
82 Relay::new(8055, None, None), 83 Relay::new(8055, None, None),
83 Relay::new(8056, None, None), 84 Relay::new(8056, None, None),
85 Relay::new(8057, None, None),
84 ); 86 );
85 87
86 // // check relay had the right number of events 88 // // check relay had the right number of events
87 let cli_tester_handle = std::thread::spawn(move || -> Result<()> { 89 let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
88 let mut p = cli_tester_init(&git_repo); 90 let mut p = cli_tester_init(&git_repo);
89 p.expect_end_eventually()?; 91 p.expect_end_eventually()?;
90 for p in [51, 52, 53, 55, 56] { 92 for p in [51, 52, 53, 55, 56, 57] {
91 relay::shutdown_relay(8000 + p)?; 93 relay::shutdown_relay(8000 + p)?;
92 } 94 }
93 Ok(()) 95 Ok(())
@@ -100,9 +102,10 @@ mod when_repo_not_previously_claimed {
100 r53.listen_until_close(), 102 r53.listen_until_close(),
101 r55.listen_until_close(), 103 r55.listen_until_close(),
102 r56.listen_until_close(), 104 r56.listen_until_close(),
105 r57.listen_until_close(),
103 ); 106 );
104 cli_tester_handle.join().unwrap()?; 107 cli_tester_handle.join().unwrap()?;
105 Ok((r51, r52, r53, r55, r56)) 108 Ok((r51, r52, r53, r55, r56, r57))
106 } 109 }
107 110
108 mod sent_to_correct_relays { 111 mod sent_to_correct_relays {
@@ -111,7 +114,7 @@ mod when_repo_not_previously_claimed {
111 #[tokio::test] 114 #[tokio::test]
112 #[serial] 115 #[serial]
113 async fn only_1_repository_kind_event_sent_to_user_relays() -> Result<()> { 116 async fn only_1_repository_kind_event_sent_to_user_relays() -> Result<()> {
114 let (_, _, r53, r55, _) = prep_run_init().await?; 117 let (_, _, r53, r55, _, _) = prep_run_init().await?;
115 for relay in [&r53, &r55] { 118 for relay in [&r53, &r55] {
116 assert_eq!( 119 assert_eq!(
117 relay 120 relay
@@ -128,7 +131,7 @@ mod when_repo_not_previously_claimed {
128 #[tokio::test] 131 #[tokio::test]
129 #[serial] 132 #[serial]
130 async fn only_1_repository_kind_event_sent_to_specified_repo_relays() -> Result<()> { 133 async fn only_1_repository_kind_event_sent_to_specified_repo_relays() -> Result<()> {
131 let (_, _, _, r55, r56) = prep_run_init().await?; 134 let (_, _, _, r55, r56, _) = prep_run_init().await?;
132 for relay in [&r55, &r56] { 135 for relay in [&r55, &r56] {
133 assert_eq!( 136 assert_eq!(
134 relay 137 relay
@@ -144,8 +147,8 @@ mod when_repo_not_previously_claimed {
144 147
145 #[tokio::test] 148 #[tokio::test]
146 #[serial] 149 #[serial]
147 async fn event_not_sent_to_fallback_relay() -> Result<()> { 150 async fn only_1_repository_kind_event_sent_to_fallback_relays() -> Result<()> {
148 let (r51, r52, _, _, _) = prep_run_init().await?; 151 let (r51, r52, _, _, _, _) = prep_run_init().await?;
149 for relay in [&r51, &r52] { 152 for relay in [&r51, &r52] {
150 assert_eq!( 153 assert_eq!(
151 relay 154 relay
@@ -153,11 +156,25 @@ mod when_repo_not_previously_claimed {
153 .iter() 156 .iter()
154 .filter(|e| e.kind.as_u64().eq(&REPOSITORY_KIND)) 157 .filter(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
155 .count(), 158 .count(),
156 0, 159 1,
157 ); 160 );
158 } 161 }
159 Ok(()) 162 Ok(())
160 } 163 }
164
165 #[tokio::test]
166 #[serial]
167 async fn only_1_repository_kind_event_sent_to_blaster_relays() -> Result<()> {
168 let (_, _, _, _, _, r57) = prep_run_init().await?;
169 assert_eq!(
170 r57.events
171 .iter()
172 .filter(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
173 .count(),
174 1,
175 );
176 Ok(())
177 }
161 } 178 }
162 179
163 mod yaml_file { 180 mod yaml_file {
@@ -167,8 +184,8 @@ mod when_repo_not_previously_claimed {
167 184
168 async fn async_run_test() -> Result<()> { 185 async fn async_run_test() -> Result<()> {
169 let git_repo = prep_git_repo()?; 186 let git_repo = prep_git_repo()?;
170 // fallback (51,52) user write (53, 55) repo (55, 56) 187 // fallback (51,52) user write (53, 55) repo (55, 56) blaster (57)
171 let (mut r51, mut r52, mut r53, mut r55, mut r56) = ( 188 let (mut r51, mut r52, mut r53, mut r55, mut r56, mut r57) = (
172 Relay::new( 189 Relay::new(
173 8051, 190 8051,
174 None, 191 None,
@@ -188,6 +205,7 @@ mod when_repo_not_previously_claimed {
188 Relay::new(8053, None, None), 205 Relay::new(8053, None, None),
189 Relay::new(8055, None, None), 206 Relay::new(8055, None, None),
190 Relay::new(8056, None, None), 207 Relay::new(8056, None, None),
208 Relay::new(8057, None, None),
191 ); 209 );
192 210
193 // // check relay had the right number of events 211 // // check relay had the right number of events
@@ -214,7 +232,7 @@ mod when_repo_not_previously_claimed {
214 " 232 "
215 ), 233 ),
216 ); 234 );
217 for p in [51, 52, 53, 55, 56] { 235 for p in [51, 52, 53, 55, 56, 57] {
218 relay::shutdown_relay(8000 + p)?; 236 relay::shutdown_relay(8000 + p)?;
219 } 237 }
220 Ok(()) 238 Ok(())
@@ -227,6 +245,7 @@ mod when_repo_not_previously_claimed {
227 r53.listen_until_close(), 245 r53.listen_until_close(),
228 r55.listen_until_close(), 246 r55.listen_until_close(),
229 r56.listen_until_close(), 247 r56.listen_until_close(),
248 r57.listen_until_close(),
230 ); 249 );
231 cli_tester_handle.join().unwrap()?; 250 cli_tester_handle.join().unwrap()?;
232 Ok(()) 251 Ok(())
@@ -247,8 +266,8 @@ mod when_repo_not_previously_claimed {
247 #[serial] 266 #[serial]
248 async fn d_replaceable_event_identifier_defaults_to_root_commit_id_shorthand() 267 async fn d_replaceable_event_identifier_defaults_to_root_commit_id_shorthand()
249 -> Result<()> { 268 -> Result<()> {
250 let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_init())?; 269 let (_, _, r53, r55, r56, r57) = prep_run_init().await?;
251 for relay in [&r53, &r55, &r56] { 270 for relay in [&r53, &r55, &r56, &r57] {
252 let event: &nostr::Event = relay 271 let event: &nostr::Event = relay
253 .events 272 .events
254 .iter() 273 .iter()
@@ -268,8 +287,8 @@ mod when_repo_not_previously_claimed {
268 #[tokio::test] 287 #[tokio::test]
269 #[serial] 288 #[serial]
270 async fn root_commit_as_reference() -> Result<()> { 289 async fn root_commit_as_reference() -> Result<()> {
271 let (_, _, r53, r55, r56) = prep_run_init().await?; 290 let (_, _, r53, r55, r56, r57) = prep_run_init().await?;
272 for relay in [&r53, &r55, &r56] { 291 for relay in [&r53, &r55, &r56, &r57] {
273 let event: &nostr::Event = relay 292 let event: &nostr::Event = relay
274 .events 293 .events
275 .iter() 294 .iter()
@@ -285,8 +304,8 @@ mod when_repo_not_previously_claimed {
285 #[tokio::test] 304 #[tokio::test]
286 #[serial] 305 #[serial]
287 async fn name() -> Result<()> { 306 async fn name() -> Result<()> {
288 let (_, _, r53, r55, r56) = prep_run_init().await?; 307 let (_, _, r53, r55, r56, r57) = prep_run_init().await?;
289 for relay in [&r53, &r55, &r56] { 308 for relay in [&r53, &r55, &r56, &r57] {
290 let event: &nostr::Event = relay 309 let event: &nostr::Event = relay
291 .events 310 .events
292 .iter() 311 .iter()
@@ -306,8 +325,8 @@ mod when_repo_not_previously_claimed {
306 #[tokio::test] 325 #[tokio::test]
307 #[serial] 326 #[serial]
308 async fn description() -> Result<()> { 327 async fn description() -> Result<()> {
309 let (_, _, r53, r55, r56) = prep_run_init().await?; 328 let (_, _, r53, r55, r56, r57) = prep_run_init().await?;
310 for relay in [&r53, &r55, &r56] { 329 for relay in [&r53, &r55, &r56, &r57] {
311 let event: &nostr::Event = relay 330 let event: &nostr::Event = relay
312 .events 331 .events
313 .iter() 332 .iter()
@@ -323,8 +342,8 @@ mod when_repo_not_previously_claimed {
323 #[tokio::test] 342 #[tokio::test]
324 #[serial] 343 #[serial]
325 async fn git_server() -> Result<()> { 344 async fn git_server() -> Result<()> {
326 let (_, _, r53, r55, r56) = prep_run_init().await?; 345 let (_, _, r53, r55, r56, r57) = prep_run_init().await?;
327 for relay in [&r53, &r55, &r56] { 346 for relay in [&r53, &r55, &r56, &r57] {
328 let event: &nostr::Event = relay 347 let event: &nostr::Event = relay
329 .events 348 .events
330 .iter() 349 .iter()
@@ -342,8 +361,8 @@ mod when_repo_not_previously_claimed {
342 #[tokio::test] 361 #[tokio::test]
343 #[serial] 362 #[serial]
344 async fn relays() -> Result<()> { 363 async fn relays() -> Result<()> {
345 let (_, _, r53, r55, r56) = prep_run_init().await?; 364 let (_, _, r53, r55, r56, r57) = prep_run_init().await?;
346 for relay in [&r53, &r55, &r56] { 365 for relay in [&r53, &r55, &r56, &r57] {
347 let event: &nostr::Event = relay 366 let event: &nostr::Event = relay
348 .events 367 .events
349 .iter() 368 .iter()
@@ -364,8 +383,8 @@ mod when_repo_not_previously_claimed {
364 #[tokio::test] 383 #[tokio::test]
365 #[serial] 384 #[serial]
366 async fn web() -> Result<()> { 385 async fn web() -> Result<()> {
367 let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_init())?; 386 let (_, _, r53, r55, r56, r57) = prep_run_init().await?;
368 for relay in [&r53, &r55, &r56] { 387 for relay in [&r53, &r55, &r56, &r57] {
369 let event: &nostr::Event = relay 388 let event: &nostr::Event = relay
370 .events 389 .events
371 .iter() 390 .iter()
@@ -383,11 +402,11 @@ mod when_repo_not_previously_claimed {
383 Ok(()) 402 Ok(())
384 } 403 }
385 404
386 #[test] 405 #[tokio::test]
387 #[serial] 406 #[serial]
388 fn current_user_in_maintainers() -> Result<()> { 407 async fn current_user_in_maintainers() -> Result<()> {
389 let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_init())?; 408 let (_, _, r53, r55, r56, r57) = prep_run_init().await?;
390 for relay in [&r53, &r55, &r56] { 409 for relay in [&r53, &r55, &r56, &r57] {
391 let event: &nostr::Event = relay 410 let event: &nostr::Event = relay
392 .events 411 .events
393 .iter() 412 .iter()
@@ -411,7 +430,8 @@ mod when_repo_not_previously_claimed {
411 async fn run_test_async() -> Result<()> { 430 async fn run_test_async() -> Result<()> {
412 let git_repo = prep_git_repo()?; 431 let git_repo = prep_git_repo()?;
413 432
414 let (mut r51, mut r52, mut r53, mut r55, mut r56) = ( 433 // fallback (51,52) user write (53, 55) repo (55, 56) blaster (57)
434 let (mut r51, mut r52, mut r53, mut r55, mut r56, mut r57) = (
415 Relay::new( 435 Relay::new(
416 8051, 436 8051,
417 None, 437 None,
@@ -431,6 +451,7 @@ mod when_repo_not_previously_claimed {
431 Relay::new(8053, None, None), 451 Relay::new(8053, None, None),
432 Relay::new(8055, None, None), 452 Relay::new(8055, None, None),
433 Relay::new(8056, None, None), 453 Relay::new(8056, None, None),
454 Relay::new(8057, None, None),
434 ); 455 );
435 456
436 // // check relay had the right number of events 457 // // check relay had the right number of events
@@ -443,11 +464,14 @@ mod when_repo_not_previously_claimed {
443 (" [my-relay] [repo-relay] ws://localhost:8055", true, ""), 464 (" [my-relay] [repo-relay] ws://localhost:8055", true, ""),
444 (" [my-relay] ws://localhost:8053", true, ""), 465 (" [my-relay] ws://localhost:8053", true, ""),
445 (" [repo-relay] ws://localhost:8056", true, ""), 466 (" [repo-relay] ws://localhost:8056", true, ""),
467 (" [default] ws://localhost:8051", true, ""),
468 (" [default] ws://localhost:8052", true, ""),
469 (" [default] ws://localhost:8057", true, ""),
446 ], 470 ],
447 1, 471 1,
448 )?; 472 )?;
449 p.expect_end_with_whitespace()?; 473 p.expect_end_with_whitespace()?;
450 for p in [51, 52, 53, 55, 56] { 474 for p in [51, 52, 53, 55, 56, 57] {
451 relay::shutdown_relay(8000 + p)?; 475 relay::shutdown_relay(8000 + p)?;
452 } 476 }
453 Ok(()) 477 Ok(())
@@ -460,6 +484,7 @@ mod when_repo_not_previously_claimed {
460 r53.listen_until_close(), 484 r53.listen_until_close(),
461 r55.listen_until_close(), 485 r55.listen_until_close(),
462 r56.listen_until_close(), 486 r56.listen_until_close(),
487 r57.listen_until_close(),
463 ); 488 );
464 cli_tester_handle.join().unwrap()?; 489 cli_tester_handle.join().unwrap()?;
465 Ok(()) 490 Ok(())
@@ -514,10 +539,11 @@ mod when_repo_not_previously_claimed {
514 Relay<'static>, 539 Relay<'static>,
515 Relay<'static>, 540 Relay<'static>,
516 Relay<'static>, 541 Relay<'static>,
542 Relay<'static>,
517 )> { 543 )> {
518 let git_repo = prep_git_repo()?; 544 let git_repo = prep_git_repo()?;
519 // fallback (51,52) user write (53, 55) repo (55, 56) 545 // fallback (51,52) user write (53, 55) repo (55, 56) blaster (57)
520 let (mut r51, mut r52, mut r53, mut r55, mut r56) = ( 546 let (mut r51, mut r52, mut r53, mut r55, mut r56, mut r57) = (
521 Relay::new( 547 Relay::new(
522 8051, 548 8051,
523 None, 549 None,
@@ -537,13 +563,14 @@ mod when_repo_not_previously_claimed {
537 Relay::new(8053, None, None), 563 Relay::new(8053, None, None),
538 Relay::new(8055, None, None), 564 Relay::new(8055, None, None),
539 Relay::new(8056, None, None), 565 Relay::new(8056, None, None),
566 Relay::new(8057, None, None),
540 ); 567 );
541 568
542 // // check relay had the right number of events 569 // // check relay had the right number of events
543 let cli_tester_handle = std::thread::spawn(move || -> Result<()> { 570 let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
544 let mut p = cli_tester_init(&git_repo); 571 let mut p = cli_tester_init(&git_repo);
545 p.expect_end_eventually()?; 572 p.expect_end_eventually()?;
546 for p in [51, 52, 53, 55, 56] { 573 for p in [51, 52, 53, 55, 56, 57] {
547 relay::shutdown_relay(8000 + p)?; 574 relay::shutdown_relay(8000 + p)?;
548 } 575 }
549 Ok(()) 576 Ok(())
@@ -556,9 +583,10 @@ mod when_repo_not_previously_claimed {
556 r53.listen_until_close(), 583 r53.listen_until_close(),
557 r55.listen_until_close(), 584 r55.listen_until_close(),
558 r56.listen_until_close(), 585 r56.listen_until_close(),
586 r57.listen_until_close(),
559 ); 587 );
560 cli_tester_handle.join().unwrap()?; 588 cli_tester_handle.join().unwrap()?;
561 Ok((r51, r52, r53, r55, r56)) 589 Ok((r51, r52, r53, r55, r56, r57))
562 } 590 }
563 591
564 mod tags { 592 mod tags {
@@ -567,7 +595,7 @@ mod when_repo_not_previously_claimed {
567 #[tokio::test] 595 #[tokio::test]
568 #[serial] 596 #[serial]
569 async fn relays_match_user_write_relays() -> Result<()> { 597 async fn relays_match_user_write_relays() -> Result<()> {
570 let (_, _, r53, r55, _) = prep_run_init().await?; 598 let (_, _, r53, r55, _, _) = prep_run_init().await?;
571 for relay in [&r53, &r55] { 599 for relay in [&r53, &r55] {
572 let event: &nostr::Event = relay 600 let event: &nostr::Event = relay
573 .events 601 .events
@@ -589,7 +617,8 @@ mod when_repo_not_previously_claimed {
589 async fn run_test_async() -> Result<()> { 617 async fn run_test_async() -> Result<()> {
590 let git_repo = prep_git_repo()?; 618 let git_repo = prep_git_repo()?;
591 619
592 let (mut r51, mut r52, mut r53, mut r55, mut r56) = ( 620 // fallback (51,52) user write (53, 55) repo (55, 56) blaster (57)
621 let (mut r51, mut r52, mut r53, mut r55, mut r56, mut r57) = (
593 Relay::new( 622 Relay::new(
594 8051, 623 8051,
595 None, 624 None,
@@ -609,6 +638,7 @@ mod when_repo_not_previously_claimed {
609 Relay::new(8053, None, None), 638 Relay::new(8053, None, None),
610 Relay::new(8055, None, None), 639 Relay::new(8055, None, None),
611 Relay::new(8056, None, None), 640 Relay::new(8056, None, None),
641 Relay::new(8057, None, None),
612 ); 642 );
613 643
614 // // check relay had the right number of events 644 // // check relay had the right number of events
@@ -620,11 +650,14 @@ mod when_repo_not_previously_claimed {
620 vec![ 650 vec![
621 (" [my-relay] [repo-relay] ws://localhost:8053", true, ""), 651 (" [my-relay] [repo-relay] ws://localhost:8053", true, ""),
622 (" [my-relay] [repo-relay] ws://localhost:8055", true, ""), 652 (" [my-relay] [repo-relay] ws://localhost:8055", true, ""),
653 (" [default] ws://localhost:8051", true, ""),
654 (" [default] ws://localhost:8052", true, ""),
655 (" [default] ws://localhost:8057", true, ""),
623 ], 656 ],
624 1, 657 1,
625 )?; 658 )?;
626 p.expect_end_with_whitespace()?; 659 p.expect_end_with_whitespace()?;
627 for p in [51, 52, 53, 55, 56] { 660 for p in [51, 52, 53, 55, 56, 57] {
628 relay::shutdown_relay(8000 + p)?; 661 relay::shutdown_relay(8000 + p)?;
629 } 662 }
630 Ok(()) 663 Ok(())
@@ -637,6 +670,7 @@ mod when_repo_not_previously_claimed {
637 r53.listen_until_close(), 670 r53.listen_until_close(),
638 r55.listen_until_close(), 671 r55.listen_until_close(),
639 r56.listen_until_close(), 672 r56.listen_until_close(),
673 r57.listen_until_close(),
640 ); 674 );
641 cli_tester_handle.join().unwrap()?; 675 cli_tester_handle.join().unwrap()?;
642 Ok(()) 676 Ok(())
diff --git a/tests/push.rs b/tests/push.rs
index 9791d9d..409b36f 100644
--- a/tests/push.rs
+++ b/tests/push.rs
@@ -366,6 +366,8 @@ mod when_branch_is_checked_out {
366 (" [my-relay] [repo-relay] ws://localhost:8055", true, ""), 366 (" [my-relay] [repo-relay] ws://localhost:8055", true, ""),
367 (" [my-relay] ws://localhost:8053", true, ""), 367 (" [my-relay] ws://localhost:8053", true, ""),
368 (" [repo-relay] ws://localhost:8056", true, ""), 368 (" [repo-relay] ws://localhost:8056", true, ""),
369 (" [default] ws://localhost:8051", true, ""),
370 (" [default] ws://localhost:8052", true, ""),
369 ], 371 ],
370 1, 372 1,
371 )?; 373 )?;
diff --git a/tests/send.rs b/tests/send.rs
index a109918..b202d54 100644
--- a/tests/send.rs
+++ b/tests/send.rs
@@ -309,12 +309,12 @@ mod sends_cover_letter_and_2_patches_to_3_relays {
309 309
310 #[tokio::test] 310 #[tokio::test]
311 #[serial] 311 #[serial]
312 async fn pr_not_sent_to_fallback_relay() -> Result<()> { 312 async fn only_1_pr_kind_event_sent_to_fallback_relays() -> Result<()> {
313 let (r51, r52, _, _, _) = prep_run_create_pr(true).await?; 313 let (r51, r52, _, _, _) = prep_run_create_pr(true).await?;
314 for relay in [&r51, &r52] { 314 for relay in [&r51, &r52] {
315 assert_eq!( 315 assert_eq!(
316 relay.events.iter().filter(|e| is_cover_letter(e)).count(), 316 relay.events.iter().filter(|e| is_cover_letter(e)).count(),
317 0, 317 1,
318 ); 318 );
319 } 319 }
320 Ok(()) 320 Ok(())
@@ -323,8 +323,8 @@ mod sends_cover_letter_and_2_patches_to_3_relays {
323 #[tokio::test] 323 #[tokio::test]
324 #[serial] 324 #[serial]
325 async fn only_2_patch_kind_events_sent_to_each_relay() -> Result<()> { 325 async fn only_2_patch_kind_events_sent_to_each_relay() -> Result<()> {
326 let (_, _, r53, r55, r56) = prep_run_create_pr(true).await?; 326 let (r51, r52, r53, r55, r56) = prep_run_create_pr(true).await?;
327 for relay in [&r53, &r55, &r56] { 327 for relay in [&r51, &r52, &r53, &r55, &r56] {
328 assert_eq!(relay.events.iter().filter(|e| is_patch(e)).count(), 2,); 328 assert_eq!(relay.events.iter().filter(|e| is_patch(e)).count(), 2,);
329 } 329 }
330 Ok(()) 330 Ok(())
@@ -757,6 +757,8 @@ mod sends_cover_letter_and_2_patches_to_3_relays {
757 (" [my-relay] [repo-relay] ws://localhost:8055", true, ""), 757 (" [my-relay] [repo-relay] ws://localhost:8055", true, ""),
758 (" [my-relay] ws://localhost:8053", true, ""), 758 (" [my-relay] ws://localhost:8053", true, ""),
759 (" [repo-relay] ws://localhost:8056", true, ""), 759 (" [repo-relay] ws://localhost:8056", true, ""),
760 (" [default] ws://localhost:8051", true, ""),
761 (" [default] ws://localhost:8052", true, ""),
760 ], 762 ],
761 3, 763 3,
762 )?; 764 )?;
@@ -930,6 +932,8 @@ mod sends_cover_letter_and_2_patches_to_3_relays {
930 false, 932 false,
931 "error: Payment Required", 933 "error: Payment Required",
932 ), 934 ),
935 (" [default] ws://localhost:8051", true, ""),
936 (" [default] ws://localhost:8052", true, ""),
933 ], 937 ],
934 3, 938 3,
935 )?; 939 )?;
@@ -1016,6 +1020,8 @@ mod sends_2_patches_without_cover_letter {
1016 (" [my-relay] [repo-relay] ws://localhost:8055", true, ""), 1020 (" [my-relay] [repo-relay] ws://localhost:8055", true, ""),
1017 (" [my-relay] ws://localhost:8053", true, ""), 1021 (" [my-relay] ws://localhost:8053", true, ""),
1018 (" [repo-relay] ws://localhost:8056", true, ""), 1022 (" [repo-relay] ws://localhost:8056", true, ""),
1023 (" [default] ws://localhost:8051", true, ""),
1024 (" [default] ws://localhost:8052", true, ""),
1019 ], 1025 ],
1020 2, 1026 2,
1021 )?; 1027 )?;
generated by cgit v1.2.3 (git 2.39.1) at 2026-06-05 00:58:20 +0000