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:
authorDanConwayDev <DanConwayDev@protonmail.com>2024-02-13 06:27:34 +0000
committerDanConwayDev <DanConwayDev@protonmail.com>2024-02-13 06:27:34 +0000
commit3112576195aef212622d27ad9164336796c1953e (patch)
tree0e897bcb8309c2d4c8f33d7c1590c2dcc0577508 /tests
parent9cd3e43b899b23b7f6e75276fa3d19bf9550f8fd (diff)
feat(prs-create)!: pr to nip34-like cover letter
up the pr event type to a nip34-like cover letter format this sets the building blocks in place to enable simplier clients to use the 'cover letter' feature in `git format-patch` to create the experience as a pr event
Diffstat (limited to 'tests')
-rw-r--r--tests/prs_create.rs219
1 files changed, 123 insertions, 96 deletions
diff --git a/tests/prs_create.rs b/tests/prs_create.rs
index 8db45d7..6272ccd 100644
--- a/tests/prs_create.rs
+++ b/tests/prs_create.rs
@@ -141,6 +141,15 @@ fn cli_message_creating_patches() -> Result<()> {
141 Ok(()) 141 Ok(())
142} 142}
143 143
144fn is_cover_letter(event: &nostr::Event) -> bool {
145 event.kind.as_u64().eq(&PR_KIND) && event.iter_tags().any(|t| t.as_vec()[1].eq("cover-letter"))
146}
147
148fn is_patch(event: &nostr::Event) -> bool {
149 event.kind.as_u64().eq(&PATCH_KIND)
150 && !event.iter_tags().any(|t| t.as_vec()[1].eq("cover-letter"))
151}
152
144mod sends_pr_and_2_patches_to_3_relays { 153mod sends_pr_and_2_patches_to_3_relays {
145 use futures::join; 154 use futures::join;
146 use test_utils::relay::Relay; 155 use test_utils::relay::Relay;
@@ -258,11 +267,7 @@ mod sends_pr_and_2_patches_to_3_relays {
258 let (_, _, r53, r55, r56) = prep_run_create_pr().await?; 267 let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
259 for relay in [&r53, &r55, &r56] { 268 for relay in [&r53, &r55, &r56] {
260 assert_eq!( 269 assert_eq!(
261 relay 270 relay.events.iter().filter(|e| is_cover_letter(e)).count(),
262 .events
263 .iter()
264 .filter(|e| e.kind.as_u64().eq(&PR_KIND))
265 .count(),
266 1, 271 1,
267 ); 272 );
268 } 273 }
@@ -275,11 +280,7 @@ mod sends_pr_and_2_patches_to_3_relays {
275 let (_, _, r53, r55, _) = prep_run_create_pr().await?; 280 let (_, _, r53, r55, _) = prep_run_create_pr().await?;
276 for relay in [&r53, &r55] { 281 for relay in [&r53, &r55] {
277 assert_eq!( 282 assert_eq!(
278 relay 283 relay.events.iter().filter(|e| is_cover_letter(e)).count(),
279 .events
280 .iter()
281 .filter(|e| e.kind.as_u64().eq(&PR_KIND))
282 .count(),
283 1, 284 1,
284 ); 285 );
285 } 286 }
@@ -292,12 +293,8 @@ mod sends_pr_and_2_patches_to_3_relays {
292 let (_, _, _, r55, r56) = prep_run_create_pr().await?; 293 let (_, _, _, r55, r56) = prep_run_create_pr().await?;
293 for relay in [&r55, &r56] { 294 for relay in [&r55, &r56] {
294 assert_eq!( 295 assert_eq!(
295 relay 296 relay.events.iter().filter(|e| is_cover_letter(e)).count(),
296 .events 297 1
297 .iter()
298 .filter(|e| e.kind.as_u64().eq(&PR_KIND))
299 .count(),
300 1,
301 ); 298 );
302 } 299 }
303 Ok(()) 300 Ok(())
@@ -309,11 +306,7 @@ mod sends_pr_and_2_patches_to_3_relays {
309 let (r51, r52, _, _, _) = prep_run_create_pr().await?; 306 let (r51, r52, _, _, _) = prep_run_create_pr().await?;
310 for relay in [&r51, &r52] { 307 for relay in [&r51, &r52] {
311 assert_eq!( 308 assert_eq!(
312 relay 309 relay.events.iter().filter(|e| is_cover_letter(e)).count(),
313 .events
314 .iter()
315 .filter(|e| e.kind.as_u64().eq(&PR_KIND))
316 .count(),
317 0, 310 0,
318 ); 311 );
319 } 312 }
@@ -325,14 +318,7 @@ mod sends_pr_and_2_patches_to_3_relays {
325 async fn only_2_patch_kind_events_sent_to_each_relay() -> Result<()> { 318 async fn only_2_patch_kind_events_sent_to_each_relay() -> Result<()> {
326 let (_, _, r53, r55, r56) = prep_run_create_pr().await?; 319 let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
327 for relay in [&r53, &r55, &r56] { 320 for relay in [&r53, &r55, &r56] {
328 assert_eq!( 321 assert_eq!(relay.events.iter().filter(|e| is_patch(e)).count(), 2,);
329 relay
330 .events
331 .iter()
332 .filter(|e| e.kind.as_u64().eq(&PATCH_KIND))
333 .count(),
334 2,
335 );
336 } 322 }
337 Ok(()) 323 Ok(())
338 } 324 }
@@ -343,11 +329,8 @@ mod sends_pr_and_2_patches_to_3_relays {
343 { 329 {
344 let (_, _, r53, r55, r56) = prep_run_create_pr().await?; 330 let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
345 for relay in [&r53, &r55, &r56] { 331 for relay in [&r53, &r55, &r56] {
346 let patch_events: Vec<&nostr::Event> = relay 332 let patch_events: Vec<&nostr::Event> =
347 .events 333 relay.events.iter().filter(|e| is_patch(e)).collect();
348 .iter()
349 .filter(|e| e.kind.as_u64().eq(&PATCH_KIND))
350 .collect();
351 334
352 assert_eq!( 335 assert_eq!(
353 patch_events[0].content, 336 patch_events[0].content,
@@ -410,21 +393,19 @@ mod sends_pr_and_2_patches_to_3_relays {
410 393
411 #[tokio::test] 394 #[tokio::test]
412 #[serial] 395 #[serial]
413 async fn pr_tags_repo_commit() -> Result<()> { 396 async fn root_commit_as_r() -> Result<()> {
414 let (_, _, r53, r55, r56) = prep_run_create_pr().await?; 397 let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
415 let root_commit = GitTestRepo::default().initial_commit()?;
416
417 for relay in [&r53, &r55, &r56] { 398 for relay in [&r53, &r55, &r56] {
418 let pr_event: &nostr::Event = relay 399 let pr_event: &nostr::Event =
419 .events 400 relay.events.iter().find(|e| is_cover_letter(e)).unwrap();
420 .iter()
421 .find(|e| e.kind.as_u64().eq(&PR_KIND))
422 .unwrap();
423 401
424 // root commit 'r' tag 402 assert_eq!(
425 assert!( 403 pr_event
426 pr_event.tags.iter().any(|t| t.as_vec()[0].eq("r") 404 .iter_tags()
427 && t.as_vec()[1].eq(&format!("r-{}", root_commit))) 405 .find(|t| t.as_vec()[0].eq("r"))
406 .unwrap()
407 .as_vec()[1],
408 "9ee507fc4357d7ee16a5d8901bedcd103f23c17d"
428 ); 409 );
429 } 410 }
430 Ok(()) 411 Ok(())
@@ -432,23 +413,55 @@ mod sends_pr_and_2_patches_to_3_relays {
432 413
433 #[tokio::test] 414 #[tokio::test]
434 #[serial] 415 #[serial]
435 async fn pr_tags_title_as_name() -> Result<()> { 416 async fn a_tag_for_repo_event() -> Result<()> {
436 let (_, _, r53, r55, r56) = prep_run_create_pr().await?; 417 let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
437 for relay in [&r53, &r55, &r56] { 418 for relay in [&r53, &r55, &r56] {
438 let pr_event: &nostr::Event = relay 419 let pr_event: &nostr::Event =
439 .events 420 relay.events.iter().find(|e| is_cover_letter(e)).unwrap();
440 .iter() 421 assert!(pr_event.iter_tags().any(|t| t.as_vec()[0].eq("a")
441 .find(|e| e.kind.as_u64().eq(&PR_KIND)) 422 && t.as_vec()[1].eq(&format!(
442 .unwrap(); 423 "{REPOSITORY_KIND}:{TEST_KEY_1_PUBKEY_HEX}:{}",
424 generate_repo_ref_event().identifier().unwrap()
425 ))));
426 }
427 Ok(())
428 }
443 429
444 assert_eq!( 430 #[tokio::test]
431 #[serial]
432 async fn p_tags_for_maintainers() -> Result<()> {
433 let maintainers = &generate_repo_ref_event()
434 .iter_tags()
435 .find(|t| t.as_vec()[0].eq(&"maintainers"))
436 .unwrap()
437 .as_vec()
438 .clone()[1..];
439 let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
440 for relay in [&r53, &r55, &r56] {
441 for m in maintainers {
442 let pr_event: &nostr::Event =
443 relay.events.iter().find(|e| is_cover_letter(e)).unwrap();
444 assert!(
445 pr_event
446 .iter_tags()
447 .any(|t| { t.as_vec()[0].eq("p") && t.as_vec()[1].eq(m) })
448 );
449 }
450 }
451 Ok(())
452 }
453
454 #[tokio::test]
455 #[serial]
456 async fn t_tag_cover_letter() -> Result<()> {
457 let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
458 for relay in [&r53, &r55, &r56] {
459 let pr_event: &nostr::Event =
460 relay.events.iter().find(|e| is_cover_letter(e)).unwrap();
461 assert!(
445 pr_event 462 pr_event
446 .tags 463 .iter_tags()
447 .iter() 464 .any(|t| { t.as_vec()[0].eq("t") && t.as_vec()[1].eq(&"cover-letter") })
448 .find(|t| t.as_vec()[0].eq("name"))
449 .unwrap()
450 .as_vec()[1],
451 "exampletitle"
452 ); 465 );
453 } 466 }
454 Ok(()) 467 Ok(())
@@ -456,23 +469,15 @@ mod sends_pr_and_2_patches_to_3_relays {
456 469
457 #[tokio::test] 470 #[tokio::test]
458 #[serial] 471 #[serial]
459 async fn pr_tags_description() -> Result<()> { 472 async fn t_tag_root() -> Result<()> {
460 let (_, _, r53, r55, r56) = prep_run_create_pr().await?; 473 let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
461 for relay in [&r53, &r55, &r56] { 474 for relay in [&r53, &r55, &r56] {
462 let pr_event: &nostr::Event = relay 475 let pr_event: &nostr::Event =
463 .events 476 relay.events.iter().find(|e| is_cover_letter(e)).unwrap();
464 .iter() 477 assert!(
465 .find(|e| e.kind.as_u64().eq(&PR_KIND))
466 .unwrap();
467
468 assert_eq!(
469 pr_event 478 pr_event
470 .tags 479 .iter_tags()
471 .iter() 480 .any(|t| { t.as_vec()[0].eq("t") && t.as_vec()[1].eq(&"root") })
472 .find(|t| t.as_vec()[0].eq("description"))
473 .unwrap()
474 .as_vec()[1],
475 "exampledescription"
476 ); 481 );
477 } 482 }
478 Ok(()) 483 Ok(())
@@ -483,17 +488,13 @@ mod sends_pr_and_2_patches_to_3_relays {
483 async fn pr_tags_branch_name() -> Result<()> { 488 async fn pr_tags_branch_name() -> Result<()> {
484 let (_, _, r53, r55, r56) = prep_run_create_pr().await?; 489 let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
485 for relay in [&r53, &r55, &r56] { 490 for relay in [&r53, &r55, &r56] {
486 let pr_event: &nostr::Event = relay 491 let pr_event: &nostr::Event =
487 .events 492 relay.events.iter().find(|e| is_cover_letter(e)).unwrap();
488 .iter()
489 .find(|e| e.kind.as_u64().eq(&PR_KIND))
490 .unwrap();
491 493
492 // branch-name tag 494 // branch-name tag
493 assert_eq!( 495 assert_eq!(
494 pr_event 496 pr_event
495 .tags 497 .iter_tags()
496 .iter()
497 .find(|t| t.as_vec()[0].eq("branch-name")) 498 .find(|t| t.as_vec()[0].eq("branch-name"))
498 .unwrap() 499 .unwrap()
499 .as_vec()[1], 500 .as_vec()[1],
@@ -509,12 +510,7 @@ mod sends_pr_and_2_patches_to_3_relays {
509 510
510 async fn prep() -> Result<nostr::Event> { 511 async fn prep() -> Result<nostr::Event> {
511 let (_, _, r53, _, _) = prep_run_create_pr().await?; 512 let (_, _, r53, _, _) = prep_run_create_pr().await?;
512 Ok(r53 513 Ok(r53.events.iter().find(|e| is_patch(e)).unwrap().clone())
513 .events
514 .iter()
515 .find(|e| e.kind.as_u64().eq(&PATCH_KIND))
516 .unwrap()
517 .clone())
518 } 514 }
519 515
520 #[tokio::test] 516 #[tokio::test]
@@ -561,6 +557,39 @@ mod sends_pr_and_2_patches_to_3_relays {
561 557
562 #[tokio::test] 558 #[tokio::test]
563 #[serial] 559 #[serial]
560 async fn p_tags_for_maintainers() -> Result<()> {
561 let maintainers = &generate_repo_ref_event()
562 .iter_tags()
563 .find(|t| t.as_vec()[0].eq(&"maintainers"))
564 .unwrap()
565 .as_vec()
566 .clone()[1..];
567 for m in maintainers {
568 assert!(
569 prep()
570 .await?
571 .iter_tags()
572 .any(|t| { t.as_vec()[0].eq("p") && t.as_vec()[1].eq(m) })
573 );
574 }
575 Ok(())
576 }
577
578 #[tokio::test]
579 #[serial]
580 async fn a_tag_for_repo_event() -> Result<()> {
581 assert!(prep().await?.tags.iter().any(|t| {
582 t.as_vec()[0].eq("a")
583 && t.as_vec()[1].eq(&format!(
584 "{REPOSITORY_KIND}:{TEST_KEY_1_PUBKEY_HEX}:{}",
585 generate_repo_ref_event().identifier().unwrap()
586 ))
587 }));
588 Ok(())
589 }
590
591 #[tokio::test]
592 #[serial]
564 async fn description_with_commit_message() -> Result<()> { 593 async fn description_with_commit_message() -> Result<()> {
565 assert_eq!( 594 assert_eq!(
566 prep() 595 prep()
@@ -612,18 +641,11 @@ mod sends_pr_and_2_patches_to_3_relays {
612 async fn patch_tags_pr_event_as_root() -> Result<()> { 641 async fn patch_tags_pr_event_as_root() -> Result<()> {
613 let (_, _, r53, r55, r56) = prep_run_create_pr().await?; 642 let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
614 for relay in [&r53, &r55, &r56] { 643 for relay in [&r53, &r55, &r56] {
615 let patch_events: Vec<&nostr::Event> = relay 644 let patch_events: Vec<&nostr::Event> =
616 .events 645 relay.events.iter().filter(|e| is_patch(e)).collect();
617 .iter()
618 .filter(|e| e.kind.as_u64().eq(&PATCH_KIND))
619 .collect();
620 646
621 let most_recent_patch = patch_events[0]; 647 let most_recent_patch = patch_events[0];
622 let pr_event = relay 648 let pr_event = relay.events.iter().find(|e| is_cover_letter(e)).unwrap();
623 .events
624 .iter()
625 .find(|e| e.kind.as_u64().eq(&PR_KIND))
626 .unwrap();
627 649
628 let root_event_tag = most_recent_patch 650 let root_event_tag = most_recent_patch
629 .tags 651 .tags
@@ -892,3 +914,8 @@ mod sends_pr_and_2_patches_to_3_relays {
892 } 914 }
893 } 915 }
894} 916}
917
918mod without_cover_letter {
919 use super::*;
920 // TODO
921}
generated by cgit v1.2.3 (git 2.39.1) at 2026-06-05 00:12:39 +0000