upleb.uk

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

summaryrefslogtreecommitdiff
path: root/tests/claim.rs
diff options
context:
space:
mode:
authorDanConwayDev <DanConwayDev@protonmail.com>2024-02-14 08:54:27 +0000
committerDanConwayDev <DanConwayDev@protonmail.com>2024-02-14 08:54:27 +0000
commit62d7f2fb26f2843fa8f7ff8b988bac14e5f756e2 (patch)
treea647093fbe3b84fad628345c7514496232f1cf77 /tests/claim.rs
parentc0847f928c32adb0b4dfc3b73ee77fa3cdb5ec21 (diff)
feat!: move `claim` > `init`
this aligns with gitstr and is more intuative the idea behind using claim to indicate that it is only for maintainersto do is valid but its too confusing
Diffstat (limited to 'tests/claim.rs')
-rw-r--r--tests/claim.rs655
1 files changed, 0 insertions, 655 deletions
diff --git a/tests/claim.rs b/tests/claim.rs
deleted file mode 100644
index fa7adcc..0000000
--- a/tests/claim.rs
+++ /dev/null
@@ -1,655 +0,0 @@
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_claim(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 "claim",
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_claim() -> 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_claim(&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_claim().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_claim().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_claim().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_claim(&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_claim())?;
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_claim().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_claim().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_claim().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_claim().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_claim().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_claim())?;
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_claim())?;
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_claim(&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_claim(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 "claim",
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_claim() -> 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_claim(&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_claim().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_claim(&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 05:19:41 +0000