upleb.uk

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

summaryrefslogtreecommitdiff
path: root/tests/init.rs
diff options
context:
space:
mode:
Diffstat (limited to 'tests/init.rs')
-rw-r--r--tests/init.rs655
1 files changed, 655 insertions, 0 deletions
diff --git a/tests/init.rs b/tests/init.rs
new file mode 100644
index 0000000..56ce332
--- /dev/null
+++ b/tests/init.rs
@@ -0,0 +1,655 @@
1use anyhow::Result;
2use serial_test::serial;
3use test_utils::{git::GitTestRepo, *};
4
5fn expect_msgs_first(p: &mut CliTester) -> Result<()> {
6 p.expect("searching for your details...\r\n")?;
7 p.expect("\r")?;
8 p.expect("logged in as fred\r\n")?;
9 // // p.expect("searching for existing claims on repository...\r\n")?;
10 p.expect("maintainers.yaml created. commit and push.\r\n")?;
11 p.expect("publishing repostory reference...\r\n")?;
12 Ok(())
13}
14
15mod when_repo_not_previously_claimed {
16 use super::*;
17
18 mod when_repo_relays_specified_as_arguments {
19 use futures::join;
20 use test_utils::relay::Relay;
21
22 use super::*;
23
24 fn prep_git_repo() -> Result<GitTestRepo> {
25 let test_repo = GitTestRepo::default();
26 test_repo.populate()?;
27 test_repo.add_remote("origin", "https://localhost:1000")?;
28 Ok(test_repo)
29 }
30
31 fn cli_tester_init(git_repo: &GitTestRepo) -> CliTester {
32 CliTester::new_from_dir(
33 &git_repo.dir,
34 [
35 "--nsec",
36 TEST_KEY_1_NSEC,
37 "--password",
38 TEST_PASSWORD,
39 "--disable-cli-spinners",
40 "init",
41 "--title",
42 "example-name",
43 "--description",
44 "example-description",
45 "--web",
46 "https://exampleproject.xyz",
47 "https://gitworkshop.dev/123",
48 "--relays",
49 "ws://localhost:8055",
50 "ws://localhost:8056",
51 ],
52 )
53 }
54
55 async fn prep_run_init() -> Result<(
56 Relay<'static>,
57 Relay<'static>,
58 Relay<'static>,
59 Relay<'static>,
60 Relay<'static>,
61 )> {
62 let git_repo = prep_git_repo()?;
63 // fallback (51,52) user write (53, 55) repo (55, 56)
64 let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
65 Relay::new(
66 8051,
67 None,
68 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
69 relay.respond_events(
70 client_id,
71 &subscription_id,
72 &vec![
73 generate_test_key_1_metadata_event("fred"),
74 generate_test_key_1_relay_list_event(),
75 ],
76 )?;
77 Ok(())
78 }),
79 ),
80 Relay::new(8052, None, None),
81 Relay::new(8053, None, None),
82 Relay::new(8055, None, None),
83 Relay::new(8056, None, None),
84 );
85
86 // // check relay had the right number of events
87 let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
88 let mut p = cli_tester_init(&git_repo);
89 p.expect_end_eventually()?;
90 for p in [51, 52, 53, 55, 56] {
91 relay::shutdown_relay(8000 + p)?;
92 }
93 Ok(())
94 });
95
96 // launch relay
97 let _ = join!(
98 r51.listen_until_close(),
99 r52.listen_until_close(),
100 r53.listen_until_close(),
101 r55.listen_until_close(),
102 r56.listen_until_close(),
103 );
104 cli_tester_handle.join().unwrap()?;
105 Ok((r51, r52, r53, r55, r56))
106 }
107
108 mod sent_to_correct_relays {
109 use super::*;
110
111 #[tokio::test]
112 #[serial]
113 async fn only_1_repository_kind_event_sent_to_user_relays() -> Result<()> {
114 let (_, _, r53, r55, _) = prep_run_init().await?;
115 for relay in [&r53, &r55] {
116 assert_eq!(
117 relay
118 .events
119 .iter()
120 .filter(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
121 .count(),
122 1,
123 );
124 }
125 Ok(())
126 }
127
128 #[tokio::test]
129 #[serial]
130 async fn only_1_repository_kind_event_sent_to_specified_repo_relays() -> Result<()> {
131 let (_, _, _, r55, r56) = prep_run_init().await?;
132 for relay in [&r55, &r56] {
133 assert_eq!(
134 relay
135 .events
136 .iter()
137 .filter(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
138 .count(),
139 1,
140 );
141 }
142 Ok(())
143 }
144
145 #[tokio::test]
146 #[serial]
147 async fn event_not_sent_to_fallback_relay() -> Result<()> {
148 let (r51, r52, _, _, _) = prep_run_init().await?;
149 for relay in [&r51, &r52] {
150 assert_eq!(
151 relay
152 .events
153 .iter()
154 .filter(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
155 .count(),
156 0,
157 );
158 }
159 Ok(())
160 }
161 }
162
163 mod yaml_file {
164 use std::{fs, io::Read};
165
166 use super::*;
167
168 async fn async_run_test() -> Result<()> {
169 let git_repo = prep_git_repo()?;
170 // fallback (51,52) user write (53, 55) repo (55, 56)
171 let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
172 Relay::new(
173 8051,
174 None,
175 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
176 relay.respond_events(
177 client_id,
178 &subscription_id,
179 &vec![
180 generate_test_key_1_metadata_event("fred"),
181 generate_test_key_1_relay_list_event(),
182 ],
183 )?;
184 Ok(())
185 }),
186 ),
187 Relay::new(8052, None, None),
188 Relay::new(8053, None, None),
189 Relay::new(8055, None, None),
190 Relay::new(8056, None, None),
191 );
192
193 // // check relay had the right number of events
194 let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
195 let mut p = cli_tester_init(&git_repo);
196 p.expect_end_eventually()?;
197
198 let yaml_path = git_repo.dir.join("maintainers.yaml");
199
200 assert!(yaml_path.exists());
201
202 let mut file = fs::File::open(yaml_path).expect("no such file");
203 let mut file_contents = "".to_string();
204 let _ = file.read_to_string(&mut file_contents);
205 assert_eq!(
206 file_contents,
207 format!(
208 "\
209 maintainers:\n\
210 - {TEST_KEY_1_NPUB}\n\
211 relays:\n\
212 - ws://localhost:8055\n\
213 - ws://localhost:8056\n\
214 "
215 ),
216 );
217 for p in [51, 52, 53, 55, 56] {
218 relay::shutdown_relay(8000 + p)?;
219 }
220 Ok(())
221 });
222
223 // launch relay
224 let _ = join!(
225 r51.listen_until_close(),
226 r52.listen_until_close(),
227 r53.listen_until_close(),
228 r55.listen_until_close(),
229 r56.listen_until_close(),
230 );
231 cli_tester_handle.join().unwrap()?;
232 Ok(())
233 }
234
235 #[tokio::test]
236 #[serial]
237 async fn contains_maintainers_and_relays() -> Result<()> {
238 async_run_test().await?;
239 Ok(())
240 }
241 }
242
243 mod tags {
244 use super::*;
245
246 #[tokio::test]
247 #[serial]
248 async fn d_replaceable_event_identifier_defaults_to_root_commit_id_shorthand()
249 -> Result<()> {
250 let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_init())?;
251 for relay in [&r53, &r55, &r56] {
252 let event: &nostr::Event = relay
253 .events
254 .iter()
255 .find(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
256 .unwrap();
257
258 assert!(
259 event
260 .tags
261 .iter()
262 .any(|t| t.as_vec()[0].eq("d") && t.as_vec()[1].eq("9ee507f"))
263 );
264 }
265 Ok(())
266 }
267
268 #[tokio::test]
269 #[serial]
270 async fn root_commit_as_reference() -> Result<()> {
271 let (_, _, r53, r55, r56) = prep_run_init().await?;
272 for relay in [&r53, &r55, &r56] {
273 let event: &nostr::Event = relay
274 .events
275 .iter()
276 .find(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
277 .unwrap();
278
279 assert!(event.tags.iter().any(|t| t.as_vec()[0].eq("r")
280 && t.as_vec()[1].eq("9ee507fc4357d7ee16a5d8901bedcd103f23c17d")));
281 }
282 Ok(())
283 }
284
285 #[tokio::test]
286 #[serial]
287 async fn name() -> Result<()> {
288 let (_, _, r53, r55, r56) = prep_run_init().await?;
289 for relay in [&r53, &r55, &r56] {
290 let event: &nostr::Event = relay
291 .events
292 .iter()
293 .find(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
294 .unwrap();
295
296 assert!(
297 event
298 .tags
299 .iter()
300 .any(|t| t.as_vec()[0].eq("name") && t.as_vec()[1].eq("example-name"))
301 );
302 }
303 Ok(())
304 }
305
306 #[tokio::test]
307 #[serial]
308 async fn description() -> Result<()> {
309 let (_, _, r53, r55, r56) = prep_run_init().await?;
310 for relay in [&r53, &r55, &r56] {
311 let event: &nostr::Event = relay
312 .events
313 .iter()
314 .find(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
315 .unwrap();
316
317 assert!(event.tags.iter().any(|t| t.as_vec()[0].eq("description")
318 && t.as_vec()[1].eq("example-description")));
319 }
320 Ok(())
321 }
322
323 #[tokio::test]
324 #[serial]
325 async fn git_server() -> Result<()> {
326 let (_, _, r53, r55, r56) = prep_run_init().await?;
327 for relay in [&r53, &r55, &r56] {
328 let event: &nostr::Event = relay
329 .events
330 .iter()
331 .find(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
332 .unwrap();
333
334 assert!(
335 event.tags.iter().any(|t| t.as_vec()[0].eq("clone")
336 && t.as_vec()[1].eq("https://localhost:1000"))
337 );
338 }
339 Ok(())
340 }
341
342 #[tokio::test]
343 #[serial]
344 async fn relays() -> Result<()> {
345 let (_, _, r53, r55, r56) = prep_run_init().await?;
346 for relay in [&r53, &r55, &r56] {
347 let event: &nostr::Event = relay
348 .events
349 .iter()
350 .find(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
351 .unwrap();
352 let relays_tag = event
353 .tags
354 .iter()
355 .find(|t| t.as_vec()[0].eq("relays"))
356 .unwrap()
357 .as_vec();
358 assert_eq!(relays_tag[1], "ws://localhost:8055",);
359 assert_eq!(relays_tag[2], "ws://localhost:8056",);
360 }
361 Ok(())
362 }
363
364 #[tokio::test]
365 #[serial]
366 async fn web() -> Result<()> {
367 let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_init())?;
368 for relay in [&r53, &r55, &r56] {
369 let event: &nostr::Event = relay
370 .events
371 .iter()
372 .find(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
373 .unwrap();
374 let web_tag = event
375 .tags
376 .iter()
377 .find(|t| t.as_vec()[0].eq("web"))
378 .unwrap()
379 .as_vec();
380 assert_eq!(web_tag[1], "https://exampleproject.xyz",);
381 assert_eq!(web_tag[2], "https://gitworkshop.dev/123",);
382 }
383 Ok(())
384 }
385
386 #[test]
387 #[serial]
388 fn current_user_in_maintainers() -> Result<()> {
389 let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_init())?;
390 for relay in [&r53, &r55, &r56] {
391 let event: &nostr::Event = relay
392 .events
393 .iter()
394 .find(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
395 .unwrap();
396 let maintainers_tag = event
397 .tags
398 .iter()
399 .find(|t| t.as_vec()[0].eq("maintainers"))
400 .unwrap()
401 .as_vec();
402 assert_eq!(maintainers_tag[1], TEST_KEY_1_KEYS.public_key().to_string());
403 }
404 Ok(())
405 }
406 }
407
408 mod cli_ouput {
409 use super::*;
410
411 async fn run_test_async() -> Result<()> {
412 let git_repo = prep_git_repo()?;
413
414 let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
415 Relay::new(
416 8051,
417 None,
418 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
419 relay.respond_events(
420 client_id,
421 &subscription_id,
422 &vec![
423 generate_test_key_1_metadata_event("fred"),
424 generate_test_key_1_relay_list_event(),
425 ],
426 )?;
427 Ok(())
428 }),
429 ),
430 Relay::new(8052, None, None),
431 Relay::new(8053, None, None),
432 Relay::new(8055, None, None),
433 Relay::new(8056, None, None),
434 );
435
436 // // check relay had the right number of events
437 let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
438 let mut p = cli_tester_init(&git_repo);
439 expect_msgs_first(&mut p)?;
440 relay::expect_send_with_progress(
441 &mut p,
442 vec![
443 (" [my-relay] [repo-relay] ws://localhost:8055", true, ""),
444 (" [my-relay] ws://localhost:8053", true, ""),
445 (" [repo-relay] ws://localhost:8056", true, ""),
446 ],
447 1,
448 )?;
449 p.expect_end_with_whitespace()?;
450 for p in [51, 52, 53, 55, 56] {
451 relay::shutdown_relay(8000 + p)?;
452 }
453 Ok(())
454 });
455
456 // launch relay
457 let _ = join!(
458 r51.listen_until_close(),
459 r52.listen_until_close(),
460 r53.listen_until_close(),
461 r55.listen_until_close(),
462 r56.listen_until_close(),
463 );
464 cli_tester_handle.join().unwrap()?;
465 Ok(())
466 }
467
468 #[tokio::test]
469 #[serial]
470 async fn check_cli_output() -> Result<()> {
471 run_test_async().await?;
472 Ok(())
473 }
474 }
475 }
476
477 mod when_repo_relays_not_specified {
478 use futures::join;
479 use test_utils::relay::Relay;
480
481 use super::*;
482
483 fn prep_git_repo() -> Result<GitTestRepo> {
484 let test_repo = GitTestRepo::default();
485 test_repo.populate()?;
486 test_repo.add_remote("origin", "https://localhost:1000")?;
487 Ok(test_repo)
488 }
489
490 fn cli_tester_init(git_repo: &GitTestRepo) -> CliTester {
491 CliTester::new_from_dir(
492 &git_repo.dir,
493 [
494 "--nsec",
495 TEST_KEY_1_NSEC,
496 "--password",
497 TEST_PASSWORD,
498 "--disable-cli-spinners",
499 "init",
500 "--title",
501 "example-name",
502 "--description",
503 "example-description",
504 "--web",
505 "https://exampleproject.xyz",
506 "https://gitworkshop.dev/123",
507 ],
508 )
509 }
510
511 async fn prep_run_init() -> Result<(
512 Relay<'static>,
513 Relay<'static>,
514 Relay<'static>,
515 Relay<'static>,
516 Relay<'static>,
517 )> {
518 let git_repo = prep_git_repo()?;
519 // fallback (51,52) user write (53, 55) repo (55, 56)
520 let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
521 Relay::new(
522 8051,
523 None,
524 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
525 relay.respond_events(
526 client_id,
527 &subscription_id,
528 &vec![
529 generate_test_key_1_metadata_event("fred"),
530 generate_test_key_1_relay_list_event(),
531 ],
532 )?;
533 Ok(())
534 }),
535 ),
536 Relay::new(8052, None, None),
537 Relay::new(8053, None, None),
538 Relay::new(8055, None, None),
539 Relay::new(8056, None, None),
540 );
541
542 // // check relay had the right number of events
543 let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
544 let mut p = cli_tester_init(&git_repo);
545 p.expect_end_eventually()?;
546 for p in [51, 52, 53, 55, 56] {
547 relay::shutdown_relay(8000 + p)?;
548 }
549 Ok(())
550 });
551
552 // launch relay
553 let _ = join!(
554 r51.listen_until_close(),
555 r52.listen_until_close(),
556 r53.listen_until_close(),
557 r55.listen_until_close(),
558 r56.listen_until_close(),
559 );
560 cli_tester_handle.join().unwrap()?;
561 Ok((r51, r52, r53, r55, r56))
562 }
563
564 mod tags {
565 use super::*;
566
567 #[tokio::test]
568 #[serial]
569 async fn relays_match_user_write_relays() -> Result<()> {
570 let (_, _, r53, r55, _) = prep_run_init().await?;
571 for relay in [&r53, &r55] {
572 let event: &nostr::Event = relay
573 .events
574 .iter()
575 .find(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
576 .unwrap();
577
578 assert!(event.tags.iter().any(|t| t.as_vec()[0].eq("relays")
579 && t.as_vec()[1].eq("ws://localhost:8053")
580 && t.as_vec()[2].eq("ws://localhost:8055")));
581 }
582 Ok(())
583 }
584 }
585
586 mod cli_ouput {
587 use super::*;
588
589 async fn run_test_async() -> Result<()> {
590 let git_repo = prep_git_repo()?;
591
592 let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
593 Relay::new(
594 8051,
595 None,
596 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
597 relay.respond_events(
598 client_id,
599 &subscription_id,
600 &vec![
601 generate_test_key_1_metadata_event("fred"),
602 generate_test_key_1_relay_list_event(),
603 ],
604 )?;
605 Ok(())
606 }),
607 ),
608 Relay::new(8052, None, None),
609 Relay::new(8053, None, None),
610 Relay::new(8055, None, None),
611 Relay::new(8056, None, None),
612 );
613
614 // // check relay had the right number of events
615 let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
616 let mut p = cli_tester_init(&git_repo);
617 expect_msgs_first(&mut p)?;
618 relay::expect_send_with_progress(
619 &mut p,
620 vec![
621 (" [my-relay] [repo-relay] ws://localhost:8053", true, ""),
622 (" [my-relay] [repo-relay] ws://localhost:8055", true, ""),
623 ],
624 1,
625 )?;
626 p.expect_end_with_whitespace()?;
627 for p in [51, 52, 53, 55, 56] {
628 relay::shutdown_relay(8000 + p)?;
629 }
630 Ok(())
631 });
632
633 // launch relay
634 let _ = join!(
635 r51.listen_until_close(),
636 r52.listen_until_close(),
637 r53.listen_until_close(),
638 r55.listen_until_close(),
639 r56.listen_until_close(),
640 );
641 cli_tester_handle.join().unwrap()?;
642 Ok(())
643 }
644
645 #[tokio::test]
646 #[serial]
647 async fn check_cli_output() -> Result<()> {
648 run_test_async().await?;
649 Ok(())
650 }
651 }
652 }
653}
654
655// TODO: when_updating_existing_repoistory
generated by cgit v1.2.3 (git 2.39.1) at 2026-06-05 02:18:05 +0000