diff options
| author | DanConwayDev <DanConwayDev@protonmail.com> | 2024-08-05 09:36:08 +0100 |
|---|---|---|
| committer | DanConwayDev <DanConwayDev@protonmail.com> | 2024-08-05 09:36:08 +0100 |
| commit | 05801e572cad050eeec557643064f7e8aa026aaa (patch) | |
| tree | 7873334b9737e5bab4f057bf90b80c07444aaafa /tests | |
| parent | 9e513861143ccb89248c16847ac330d90946e26e (diff) | |
test(remote): refactor `push` tests
to:
1. test helper response (ok printed) seperately
2. make failing tests end and print failure rather than hanging
3. remove `async_run_test` function when it isn't needed
Diffstat (limited to 'tests')
| -rw-r--r-- | tests/git_remote_helper.rs | 1262 |
1 files changed, 649 insertions, 613 deletions
diff --git a/tests/git_remote_helper.rs b/tests/git_remote_helper.rs index 6efc00a..93f81dc 100644 --- a/tests/git_remote_helper.rs +++ b/tests/git_remote_helper.rs | |||
| @@ -600,695 +600,656 @@ mod push { | |||
| 600 | 600 | ||
| 601 | use super::*; | 601 | use super::*; |
| 602 | 602 | ||
| 603 | mod git_server_updated { | 603 | #[tokio::test] |
| 604 | #[serial] | ||
| 605 | async fn updates_branch_on_git_server() -> Result<()> { | ||
| 606 | let git_repo = prep_git_repo()?; | ||
| 607 | let source_git_repo = GitTestRepo::recreate_as_bare(&git_repo)?; | ||
| 604 | 608 | ||
| 605 | use super::*; | 609 | std::fs::write(git_repo.dir.join("commit.md"), "some content")?; |
| 610 | let main_commit_id = git_repo.stage_and_commit("commit.md")?; | ||
| 606 | 611 | ||
| 607 | async fn async_run_test() -> Result<()> { | 612 | git_repo.create_branch("vnext")?; |
| 608 | let git_repo = prep_git_repo()?; | 613 | git_repo.checkout("vnext")?; |
| 609 | let source_git_repo = GitTestRepo::recreate_as_bare(&git_repo)?; | 614 | std::fs::write(git_repo.dir.join("vnext.md"), "some content")?; |
| 615 | let vnext_commit_id = git_repo.stage_and_commit("vnext.md")?; | ||
| 610 | 616 | ||
| 611 | std::fs::write(git_repo.dir.join("commit.md"), "some content")?; | 617 | let events = vec![ |
| 612 | let main_commit_id = git_repo.stage_and_commit("commit.md")?; | 618 | generate_test_key_1_metadata_event("fred"), |
| 613 | 619 | generate_test_key_1_relay_list_event(), | |
| 614 | git_repo.create_branch("vnext")?; | 620 | generate_repo_ref_event_with_git_server(vec![ |
| 615 | git_repo.checkout("vnext")?; | 621 | source_git_repo.dir.to_str().unwrap().to_string(), |
| 616 | std::fs::write(git_repo.dir.join("vnext.md"), "some content")?; | 622 | ]), |
| 617 | let vnext_commit_id = git_repo.stage_and_commit("vnext.md")?; | 623 | ]; |
| 624 | // fallback (51,52) user write (53, 55) repo (55, 56) blaster (57) | ||
| 625 | let (mut r51, mut r52, mut r53, mut r55, mut r56, mut r57) = ( | ||
| 626 | Relay::new(8051, None, None), | ||
| 627 | Relay::new(8052, None, None), | ||
| 628 | Relay::new(8053, None, None), | ||
| 629 | Relay::new(8055, None, None), | ||
| 630 | Relay::new(8056, None, None), | ||
| 631 | Relay::new(8057, None, None), | ||
| 632 | ); | ||
| 633 | r51.events = events.clone(); | ||
| 634 | r55.events = events; | ||
| 618 | 635 | ||
| 619 | let events = vec![ | 636 | let cli_tester_handle = std::thread::spawn(move || -> Result<()> { |
| 620 | generate_test_key_1_metadata_event("fred"), | 637 | assert_ne!( |
| 621 | generate_test_key_1_relay_list_event(), | 638 | source_git_repo.get_tip_of_local_branch("main")?, |
| 622 | generate_repo_ref_event_with_git_server(vec![ | 639 | main_commit_id |
| 623 | source_git_repo.dir.to_str().unwrap().to_string(), | ||
| 624 | ]), | ||
| 625 | ]; | ||
| 626 | // fallback (51,52) user write (53, 55) repo (55, 56) blaster (57) | ||
| 627 | let (mut r51, mut r52, mut r53, mut r55, mut r56, mut r57) = ( | ||
| 628 | Relay::new(8051, None, None), | ||
| 629 | Relay::new(8052, None, None), | ||
| 630 | Relay::new(8053, None, None), | ||
| 631 | Relay::new(8055, None, None), | ||
| 632 | Relay::new(8056, None, None), | ||
| 633 | Relay::new(8057, None, None), | ||
| 634 | ); | 640 | ); |
| 635 | r51.events = events.clone(); | ||
| 636 | r55.events = events; | ||
| 637 | 641 | ||
| 638 | let cli_tester_handle = std::thread::spawn(move || -> Result<()> { | 642 | let mut p = cli_tester_after_fetch(&git_repo)?; |
| 639 | assert_ne!( | 643 | p.send_line("push refs/heads/main:refs/heads/main")?; |
| 640 | source_git_repo.get_tip_of_local_branch("main")?, | 644 | p.send_line("push refs/heads/vnext:refs/heads/vnext")?; |
| 641 | main_commit_id | 645 | p.send_line("")?; |
| 642 | ); | 646 | p.expect_eventually("\r\n\r\n")?; |
| 643 | 647 | p.exit()?; | |
| 644 | let mut p = cli_tester_after_fetch(&git_repo)?; | 648 | for p in [51, 52, 53, 55, 56, 57] { |
| 645 | p.send_line("push refs/heads/main:refs/heads/main")?; | 649 | relay::shutdown_relay(8000 + p)?; |
| 646 | p.send_line("push refs/heads/vnext:refs/heads/vnext")?; | 650 | } |
| 647 | p.send_line("")?; | ||
| 648 | p.expect("ok refs/heads/main\r\n")?; | ||
| 649 | p.expect("ok refs/heads/vnext\r\n")?; | ||
| 650 | p.expect("\r\n")?; | ||
| 651 | |||
| 652 | assert_eq!( | ||
| 653 | source_git_repo.get_tip_of_local_branch("main")?, | ||
| 654 | main_commit_id | ||
| 655 | ); | ||
| 656 | 651 | ||
| 657 | assert_eq!( | 652 | assert_eq!( |
| 658 | source_git_repo.get_tip_of_local_branch("vnext")?, | 653 | source_git_repo.get_tip_of_local_branch("main")?, |
| 659 | vnext_commit_id | 654 | main_commit_id |
| 660 | ); | 655 | ); |
| 661 | 656 | ||
| 662 | p.exit()?; | 657 | assert_eq!( |
| 663 | for p in [51, 52, 53, 55, 56, 57] { | 658 | source_git_repo.get_tip_of_local_branch("vnext")?, |
| 664 | relay::shutdown_relay(8000 + p)?; | 659 | vnext_commit_id |
| 665 | } | ||
| 666 | Ok(()) | ||
| 667 | }); | ||
| 668 | // launch relays | ||
| 669 | let _ = join!( | ||
| 670 | r51.listen_until_close(), | ||
| 671 | r52.listen_until_close(), | ||
| 672 | r53.listen_until_close(), | ||
| 673 | r55.listen_until_close(), | ||
| 674 | r56.listen_until_close(), | ||
| 675 | r57.listen_until_close(), | ||
| 676 | ); | 660 | ); |
| 677 | cli_tester_handle.join().unwrap()?; | ||
| 678 | Ok(()) | ||
| 679 | } | ||
| 680 | 661 | ||
| 681 | #[tokio::test] | 662 | Ok(()) |
| 682 | #[serial] | 663 | }); |
| 683 | async fn push_updates_ref_on_git_server() -> Result<()> { | 664 | // launch relays |
| 684 | async_run_test().await | 665 | let _ = join!( |
| 685 | } | 666 | r51.listen_until_close(), |
| 667 | r52.listen_until_close(), | ||
| 668 | r53.listen_until_close(), | ||
| 669 | r55.listen_until_close(), | ||
| 670 | r56.listen_until_close(), | ||
| 671 | r57.listen_until_close(), | ||
| 672 | ); | ||
| 673 | cli_tester_handle.join().unwrap()?; | ||
| 674 | Ok(()) | ||
| 686 | } | 675 | } |
| 687 | mod remote_refs_updated { | ||
| 688 | 676 | ||
| 689 | use super::*; | 677 | #[tokio::test] |
| 678 | #[serial] | ||
| 679 | async fn remote_refs_updated_in_local_git() -> Result<()> { | ||
| 680 | let git_repo = prep_git_repo()?; | ||
| 681 | let source_git_repo = GitTestRepo::recreate_as_bare(&git_repo)?; | ||
| 690 | 682 | ||
| 691 | async fn async_run_test() -> Result<()> { | 683 | std::fs::write(git_repo.dir.join("commit.md"), "some content")?; |
| 692 | let git_repo = prep_git_repo()?; | 684 | let main_commit_id = git_repo.stage_and_commit("commit.md")?; |
| 693 | let source_git_repo = GitTestRepo::recreate_as_bare(&git_repo)?; | ||
| 694 | 685 | ||
| 695 | std::fs::write(git_repo.dir.join("commit.md"), "some content")?; | 686 | git_repo.create_branch("vnext")?; |
| 696 | let main_commit_id = git_repo.stage_and_commit("commit.md")?; | 687 | git_repo.checkout("vnext")?; |
| 688 | std::fs::write(git_repo.dir.join("vnext.md"), "some content")?; | ||
| 689 | let vnext_commit_id = git_repo.stage_and_commit("vnext.md")?; | ||
| 697 | 690 | ||
| 698 | git_repo.create_branch("vnext")?; | 691 | let events = vec![ |
| 699 | git_repo.checkout("vnext")?; | 692 | generate_test_key_1_metadata_event("fred"), |
| 700 | std::fs::write(git_repo.dir.join("vnext.md"), "some content")?; | 693 | generate_test_key_1_relay_list_event(), |
| 701 | let vnext_commit_id = git_repo.stage_and_commit("vnext.md")?; | 694 | generate_repo_ref_event_with_git_server(vec![ |
| 695 | source_git_repo.dir.to_str().unwrap().to_string(), | ||
| 696 | ]), | ||
| 697 | ]; | ||
| 698 | // fallback (51,52) user write (53, 55) repo (55, 56) blaster (57) | ||
| 699 | let (mut r51, mut r52, mut r53, mut r55, mut r56, mut r57) = ( | ||
| 700 | Relay::new(8051, None, None), | ||
| 701 | Relay::new(8052, None, None), | ||
| 702 | Relay::new(8053, None, None), | ||
| 703 | Relay::new(8055, None, None), | ||
| 704 | Relay::new(8056, None, None), | ||
| 705 | Relay::new(8057, None, None), | ||
| 706 | ); | ||
| 707 | r51.events = events.clone(); | ||
| 708 | r55.events = events; | ||
| 702 | 709 | ||
| 703 | let events = vec![ | 710 | let cli_tester_handle = std::thread::spawn(move || -> Result<()> { |
| 704 | generate_test_key_1_metadata_event("fred"), | 711 | assert_ne!( |
| 705 | generate_test_key_1_relay_list_event(), | 712 | source_git_repo.get_tip_of_local_branch("main")?, |
| 706 | generate_repo_ref_event_with_git_server(vec![ | 713 | main_commit_id |
| 707 | source_git_repo.dir.to_str().unwrap().to_string(), | ||
| 708 | ]), | ||
| 709 | ]; | ||
| 710 | // fallback (51,52) user write (53, 55) repo (55, 56) blaster (57) | ||
| 711 | let (mut r51, mut r52, mut r53, mut r55, mut r56, mut r57) = ( | ||
| 712 | Relay::new(8051, None, None), | ||
| 713 | Relay::new(8052, None, None), | ||
| 714 | Relay::new(8053, None, None), | ||
| 715 | Relay::new(8055, None, None), | ||
| 716 | Relay::new(8056, None, None), | ||
| 717 | Relay::new(8057, None, None), | ||
| 718 | ); | 714 | ); |
| 719 | r51.events = events.clone(); | ||
| 720 | r55.events = events; | ||
| 721 | |||
| 722 | let cli_tester_handle = std::thread::spawn(move || -> Result<()> { | ||
| 723 | assert_ne!( | ||
| 724 | source_git_repo.get_tip_of_local_branch("main")?, | ||
| 725 | main_commit_id | ||
| 726 | ); | ||
| 727 | 715 | ||
| 728 | let mut p = cli_tester_after_fetch(&git_repo)?; | 716 | let mut p = cli_tester_after_fetch(&git_repo)?; |
| 729 | p.send_line("push refs/heads/main:refs/heads/main")?; | 717 | p.send_line("push refs/heads/main:refs/heads/main")?; |
| 730 | p.send_line("push refs/heads/vnext:refs/heads/vnext")?; | 718 | p.send_line("push refs/heads/vnext:refs/heads/vnext")?; |
| 731 | p.send_line("")?; | 719 | p.send_line("")?; |
| 732 | p.expect("ok refs/heads/main\r\n")?; | 720 | p.expect_eventually("\r\n\r\n")?; |
| 733 | p.expect("ok refs/heads/vnext\r\n")?; | 721 | p.exit()?; |
| 734 | p.expect("\r\n")?; | 722 | for p in [51, 52, 53, 55, 56, 57] { |
| 735 | 723 | relay::shutdown_relay(8000 + p)?; | |
| 736 | assert_eq!( | 724 | } |
| 737 | git_repo | ||
| 738 | .git_repo | ||
| 739 | .find_reference("refs/remotes/nostr/main")? | ||
| 740 | .peel_to_commit()? | ||
| 741 | .id(), | ||
| 742 | main_commit_id, | ||
| 743 | ); | ||
| 744 | 725 | ||
| 745 | assert_eq!( | 726 | assert_eq!( |
| 746 | git_repo | 727 | git_repo |
| 747 | .git_repo | 728 | .git_repo |
| 748 | .find_reference("refs/remotes/nostr/vnext")? | 729 | .find_reference("refs/remotes/nostr/main")? |
| 749 | .peel_to_commit()? | 730 | .peel_to_commit()? |
| 750 | .id(), | 731 | .id(), |
| 751 | vnext_commit_id | 732 | main_commit_id, |
| 752 | ); | 733 | ); |
| 753 | 734 | ||
| 754 | p.exit()?; | 735 | assert_eq!( |
| 755 | for p in [51, 52, 53, 55, 56, 57] { | 736 | git_repo |
| 756 | relay::shutdown_relay(8000 + p)?; | 737 | .git_repo |
| 757 | } | 738 | .find_reference("refs/remotes/nostr/vnext")? |
| 758 | Ok(()) | 739 | .peel_to_commit()? |
| 759 | }); | 740 | .id(), |
| 760 | // launch relays | 741 | vnext_commit_id |
| 761 | let _ = join!( | ||
| 762 | r51.listen_until_close(), | ||
| 763 | r52.listen_until_close(), | ||
| 764 | r53.listen_until_close(), | ||
| 765 | r55.listen_until_close(), | ||
| 766 | r56.listen_until_close(), | ||
| 767 | r57.listen_until_close(), | ||
| 768 | ); | 742 | ); |
| 769 | cli_tester_handle.join().unwrap()?; | ||
| 770 | Ok(()) | ||
| 771 | } | ||
| 772 | 743 | ||
| 773 | #[tokio::test] | 744 | p.exit()?; |
| 774 | #[serial] | 745 | for p in [51, 52, 53, 55, 56, 57] { |
| 775 | async fn push_updates_refs() -> Result<()> { | 746 | relay::shutdown_relay(8000 + p)?; |
| 776 | async_run_test().await | 747 | } |
| 777 | } | 748 | Ok(()) |
| 749 | }); | ||
| 750 | // launch relays | ||
| 751 | let _ = join!( | ||
| 752 | r51.listen_until_close(), | ||
| 753 | r52.listen_until_close(), | ||
| 754 | r53.listen_until_close(), | ||
| 755 | r55.listen_until_close(), | ||
| 756 | r56.listen_until_close(), | ||
| 757 | r57.listen_until_close(), | ||
| 758 | ); | ||
| 759 | cli_tester_handle.join().unwrap()?; | ||
| 760 | Ok(()) | ||
| 778 | } | 761 | } |
| 779 | mod no_existing_state_event { | ||
| 780 | use super::*; | ||
| 781 | 762 | ||
| 782 | mod state_on_git_server_published_in_nostr_state_event { | 763 | #[tokio::test] |
| 764 | #[serial] | ||
| 765 | async fn prints_git_helper_ok_respose() -> Result<()> { | ||
| 766 | let git_repo = prep_git_repo()?; | ||
| 767 | let source_git_repo = GitTestRepo::recreate_as_bare(&git_repo)?; | ||
| 768 | |||
| 769 | std::fs::write(git_repo.dir.join("commit.md"), "some content")?; | ||
| 770 | let main_commit_id = git_repo.stage_and_commit("commit.md")?; | ||
| 771 | |||
| 772 | git_repo.create_branch("vnext")?; | ||
| 773 | git_repo.checkout("vnext")?; | ||
| 774 | std::fs::write(git_repo.dir.join("vnext.md"), "some content")?; | ||
| 775 | git_repo.stage_and_commit("vnext.md")?; | ||
| 783 | 776 | ||
| 784 | use super::*; | 777 | let events = vec![ |
| 778 | generate_test_key_1_metadata_event("fred"), | ||
| 779 | generate_test_key_1_relay_list_event(), | ||
| 780 | generate_repo_ref_event_with_git_server(vec![ | ||
| 781 | source_git_repo.dir.to_str().unwrap().to_string(), | ||
| 782 | ]), | ||
| 783 | ]; | ||
| 784 | // fallback (51,52) user write (53, 55) repo (55, 56) blaster (57) | ||
| 785 | let (mut r51, mut r52, mut r53, mut r55, mut r56, mut r57) = ( | ||
| 786 | Relay::new(8051, None, None), | ||
| 787 | Relay::new(8052, None, None), | ||
| 788 | Relay::new(8053, None, None), | ||
| 789 | Relay::new(8055, None, None), | ||
| 790 | Relay::new(8056, None, None), | ||
| 791 | Relay::new(8057, None, None), | ||
| 792 | ); | ||
| 793 | r51.events = events.clone(); | ||
| 794 | r55.events = events; | ||
| 785 | 795 | ||
| 786 | async fn async_run_test() -> Result<()> { | 796 | let cli_tester_handle = std::thread::spawn(move || -> Result<()> { |
| 787 | let git_repo = prep_git_repo()?; | 797 | assert_ne!( |
| 788 | let source_git_repo = GitTestRepo::recreate_as_bare(&git_repo)?; | 798 | source_git_repo.get_tip_of_local_branch("main")?, |
| 799 | main_commit_id | ||
| 800 | ); | ||
| 789 | 801 | ||
| 790 | std::fs::write(git_repo.dir.join("commit.md"), "some content")?; | 802 | let mut p = cli_tester_after_fetch(&git_repo)?; |
| 791 | let main_commit_id = git_repo.stage_and_commit("commit.md")?; | 803 | p.send_line("push refs/heads/main:refs/heads/main")?; |
| 804 | p.send_line("push refs/heads/vnext:refs/heads/vnext")?; | ||
| 805 | p.send_line("")?; | ||
| 806 | p.expect("ok refs/heads/main\r\n")?; | ||
| 807 | p.expect("ok refs/heads/vnext\r\n")?; | ||
| 808 | p.expect("\r\n")?; | ||
| 809 | p.exit()?; | ||
| 810 | for p in [51, 52, 53, 55, 56, 57] { | ||
| 811 | relay::shutdown_relay(8000 + p)?; | ||
| 812 | } | ||
| 813 | Ok(()) | ||
| 814 | }); | ||
| 815 | // launch relays | ||
| 816 | let _ = join!( | ||
| 817 | r51.listen_until_close(), | ||
| 818 | r52.listen_until_close(), | ||
| 819 | r53.listen_until_close(), | ||
| 820 | r55.listen_until_close(), | ||
| 821 | r56.listen_until_close(), | ||
| 822 | r57.listen_until_close(), | ||
| 823 | ); | ||
| 824 | cli_tester_handle.join().unwrap()?; | ||
| 825 | Ok(()) | ||
| 826 | } | ||
| 792 | 827 | ||
| 793 | git_repo.create_branch("vnext")?; | 828 | #[tokio::test] |
| 794 | git_repo.checkout("vnext")?; | 829 | #[serial] |
| 795 | std::fs::write(git_repo.dir.join("vnext.md"), "some content")?; | 830 | async fn when_no_existing_state_event_state_on_git_server_published_in_nostr_state_event() |
| 796 | let vnext_commit_id = git_repo.stage_and_commit("vnext.md")?; | 831 | -> Result<()> { |
| 832 | let git_repo = prep_git_repo()?; | ||
| 833 | let source_git_repo = GitTestRepo::recreate_as_bare(&git_repo)?; | ||
| 797 | 834 | ||
| 798 | let events = vec![ | 835 | std::fs::write(git_repo.dir.join("commit.md"), "some content")?; |
| 799 | generate_test_key_1_metadata_event("fred"), | 836 | let main_commit_id = git_repo.stage_and_commit("commit.md")?; |
| 800 | generate_test_key_1_relay_list_event(), | ||
| 801 | generate_repo_ref_event_with_git_server(vec![ | ||
| 802 | source_git_repo.dir.to_str().unwrap().to_string(), | ||
| 803 | ]), | ||
| 804 | ]; | ||
| 805 | // fallback (51,52) user write (53, 55) repo (55, 56) blaster (57) | ||
| 806 | let (mut r51, mut r52, mut r53, mut r55, mut r56, mut r57) = ( | ||
| 807 | Relay::new(8051, None, None), | ||
| 808 | Relay::new(8052, None, None), | ||
| 809 | Relay::new(8053, None, None), | ||
| 810 | Relay::new(8055, None, None), | ||
| 811 | Relay::new(8056, None, None), | ||
| 812 | Relay::new(8057, None, None), | ||
| 813 | ); | ||
| 814 | r51.events = events.clone(); | ||
| 815 | r55.events = events; | ||
| 816 | |||
| 817 | let cli_tester_handle = std::thread::spawn(move || -> Result<()> { | ||
| 818 | let mut p = cli_tester_after_fetch(&git_repo)?; | ||
| 819 | p.send_line("push refs/heads/main:refs/heads/main")?; | ||
| 820 | p.send_line("push refs/heads/vnext:refs/heads/vnext")?; | ||
| 821 | p.send_line("")?; | ||
| 822 | p.expect("ok refs/heads/main\r\n")?; | ||
| 823 | p.expect("ok refs/heads/vnext\r\n")?; | ||
| 824 | p.expect("\r\n")?; | ||
| 825 | |||
| 826 | p.exit()?; | ||
| 827 | for p in [51, 52, 53, 55, 56, 57] { | ||
| 828 | relay::shutdown_relay(8000 + p)?; | ||
| 829 | } | ||
| 830 | Ok(()) | ||
| 831 | }); | ||
| 832 | // launch relays | ||
| 833 | let _ = join!( | ||
| 834 | r51.listen_until_close(), | ||
| 835 | r52.listen_until_close(), | ||
| 836 | r53.listen_until_close(), | ||
| 837 | r55.listen_until_close(), | ||
| 838 | r56.listen_until_close(), | ||
| 839 | r57.listen_until_close(), | ||
| 840 | ); | ||
| 841 | cli_tester_handle.join().unwrap()?; | ||
| 842 | 837 | ||
| 843 | let state_event = r56 | 838 | git_repo.create_branch("vnext")?; |
| 844 | .events | 839 | git_repo.checkout("vnext")?; |
| 845 | .iter() | 840 | std::fs::write(git_repo.dir.join("vnext.md"), "some content")?; |
| 846 | .find(|e| e.kind().eq(&STATE_KIND)) | 841 | let vnext_commit_id = git_repo.stage_and_commit("vnext.md")?; |
| 847 | .context("state event not created")?; | ||
| 848 | 842 | ||
| 849 | assert_eq!( | 843 | let events = vec![ |
| 850 | state_event.identifier(), | 844 | generate_test_key_1_metadata_event("fred"), |
| 851 | generate_repo_ref_event().identifier(), | 845 | generate_test_key_1_relay_list_event(), |
| 852 | ); | 846 | generate_repo_ref_event_with_git_server(vec![ |
| 853 | // println!("{:#?}", state_event); | 847 | source_git_repo.dir.to_str().unwrap().to_string(), |
| 854 | assert_eq!( | 848 | ]), |
| 855 | state_event | 849 | ]; |
| 856 | .tags | 850 | // fallback (51,52) user write (53, 55) repo (55, 56) blaster (57) |
| 857 | .iter() | 851 | let (mut r51, mut r52, mut r53, mut r55, mut r56, mut r57) = ( |
| 858 | .filter(|t| t.kind().to_string().as_str().ne("d")) | 852 | Relay::new(8051, None, None), |
| 859 | .map(|t| t.as_vec().to_vec()) | 853 | Relay::new(8052, None, None), |
| 860 | .collect::<HashSet<Vec<String>>>(), | 854 | Relay::new(8053, None, None), |
| 861 | HashSet::from([ | 855 | Relay::new(8055, None, None), |
| 862 | vec!["HEAD".to_string(), "ref: refs/heads/main".to_string()], | 856 | Relay::new(8056, None, None), |
| 863 | vec!["refs/heads/main".to_string(), main_commit_id.to_string()], | 857 | Relay::new(8057, None, None), |
| 864 | vec!["refs/heads/vnext".to_string(), vnext_commit_id.to_string()], | 858 | ); |
| 865 | ]), | 859 | r51.events = events.clone(); |
| 866 | ); | 860 | r55.events = events; |
| 867 | Ok(()) | ||
| 868 | } | ||
| 869 | 861 | ||
| 870 | #[tokio::test] | 862 | let cli_tester_handle = std::thread::spawn(move || -> Result<()> { |
| 871 | #[serial] | 863 | let mut p = cli_tester_after_fetch(&git_repo)?; |
| 872 | async fn state_event_reflects_git_server_state() -> Result<()> { | 864 | p.send_line("push refs/heads/main:refs/heads/main")?; |
| 873 | async_run_test().await | 865 | p.send_line("push refs/heads/vnext:refs/heads/vnext")?; |
| 866 | p.send_line("")?; | ||
| 867 | p.expect_eventually("\r\n\r\n")?; | ||
| 868 | p.exit()?; | ||
| 869 | for p in [51, 52, 53, 55, 56, 57] { | ||
| 870 | relay::shutdown_relay(8000 + p)?; | ||
| 874 | } | 871 | } |
| 875 | } | 872 | Ok(()) |
| 873 | }); | ||
| 874 | // launch relays | ||
| 875 | let _ = join!( | ||
| 876 | r51.listen_until_close(), | ||
| 877 | r52.listen_until_close(), | ||
| 878 | r53.listen_until_close(), | ||
| 879 | r55.listen_until_close(), | ||
| 880 | r56.listen_until_close(), | ||
| 881 | r57.listen_until_close(), | ||
| 882 | ); | ||
| 883 | cli_tester_handle.join().unwrap()?; | ||
| 884 | |||
| 885 | let state_event = r56 | ||
| 886 | .events | ||
| 887 | .iter() | ||
| 888 | .find(|e| e.kind().eq(&STATE_KIND)) | ||
| 889 | .context("state event not created")?; | ||
| 890 | |||
| 891 | assert_eq!( | ||
| 892 | state_event.identifier(), | ||
| 893 | generate_repo_ref_event().identifier(), | ||
| 894 | ); | ||
| 895 | // println!("{:#?}", state_event); | ||
| 896 | assert_eq!( | ||
| 897 | state_event | ||
| 898 | .tags | ||
| 899 | .iter() | ||
| 900 | .filter(|t| t.kind().to_string().as_str().ne("d")) | ||
| 901 | .map(|t| t.as_vec().to_vec()) | ||
| 902 | .collect::<HashSet<Vec<String>>>(), | ||
| 903 | HashSet::from([ | ||
| 904 | vec!["HEAD".to_string(), "ref: refs/heads/main".to_string()], | ||
| 905 | vec!["refs/heads/main".to_string(), main_commit_id.to_string()], | ||
| 906 | vec!["refs/heads/vnext".to_string(), vnext_commit_id.to_string()], | ||
| 907 | ]), | ||
| 908 | ); | ||
| 909 | Ok(()) | ||
| 876 | } | 910 | } |
| 877 | mod existing_state_event { | ||
| 878 | use super::*; | ||
| 879 | 911 | ||
| 880 | mod state_on_git_server_published_in_nostr_state_event { | 912 | #[tokio::test] |
| 913 | #[serial] | ||
| 914 | async fn existing_state_event_published_in_nostr_state_event() -> Result<()> { | ||
| 915 | let (state_event, source_git_repo) = generate_repo_with_state_event().await?; | ||
| 881 | 916 | ||
| 882 | use super::*; | 917 | let git_repo = prep_git_repo()?; |
| 918 | let example_branch_commit_id = git_repo.get_tip_of_local_branch("main")?.to_string(); // same as example | ||
| 883 | 919 | ||
| 884 | async fn async_run_test() -> Result<()> { | 920 | std::fs::write(git_repo.dir.join("new.md"), "some content")?; |
| 885 | let (state_event, source_git_repo) = generate_repo_with_state_event().await?; | 921 | let main_commit_id = git_repo.stage_and_commit("new.md")?; |
| 922 | git_repo.create_branch("vnext")?; | ||
| 923 | git_repo.checkout("vnext")?; | ||
| 924 | std::fs::write(git_repo.dir.join("more.md"), "some content")?; | ||
| 925 | let vnext_commit_id = git_repo.stage_and_commit("more.md")?; | ||
| 886 | 926 | ||
| 887 | let git_repo = prep_git_repo()?; | 927 | let events = vec![ |
| 888 | let example_branch_commit_id = | 928 | generate_test_key_1_metadata_event("fred"), |
| 889 | git_repo.get_tip_of_local_branch("main")?.to_string(); // same as example | 929 | generate_test_key_1_relay_list_event(), |
| 930 | generate_repo_ref_event_with_git_server(vec![ | ||
| 931 | source_git_repo.dir.to_str().unwrap().to_string(), | ||
| 932 | ]), | ||
| 933 | state_event.clone(), | ||
| 934 | ]; | ||
| 890 | 935 | ||
| 891 | std::fs::write(git_repo.dir.join("new.md"), "some content")?; | 936 | // fallback (51,52) user write (53, 55) repo (55, 56) blaster (57) |
| 892 | let main_commit_id = git_repo.stage_and_commit("new.md")?; | 937 | let (mut r51, mut r52, mut r53, mut r55, mut r56, mut r57) = ( |
| 893 | git_repo.create_branch("vnext")?; | 938 | Relay::new(8051, None, None), |
| 894 | git_repo.checkout("vnext")?; | 939 | Relay::new(8052, None, None), |
| 895 | std::fs::write(git_repo.dir.join("more.md"), "some content")?; | 940 | Relay::new(8053, None, None), |
| 896 | let vnext_commit_id = git_repo.stage_and_commit("more.md")?; | 941 | Relay::new(8055, None, None), |
| 942 | Relay::new(8056, None, None), | ||
| 943 | Relay::new(8057, None, None), | ||
| 944 | ); | ||
| 945 | r51.events = events.clone(); | ||
| 946 | r55.events = events; | ||
| 897 | 947 | ||
| 898 | let events = vec![ | 948 | let cli_tester_handle = std::thread::spawn(move || -> Result<()> { |
| 899 | generate_test_key_1_metadata_event("fred"), | 949 | let mut p = cli_tester_after_fetch(&git_repo)?; |
| 900 | generate_test_key_1_relay_list_event(), | 950 | p.send_line("push refs/heads/main:refs/heads/main")?; |
| 901 | generate_repo_ref_event_with_git_server(vec![ | 951 | p.send_line("push refs/heads/vnext:refs/heads/vnext")?; |
| 902 | source_git_repo.dir.to_str().unwrap().to_string(), | 952 | p.send_line("")?; |
| 903 | ]), | 953 | p.expect_eventually("\r\n\r\n")?; |
| 904 | state_event.clone(), | 954 | p.exit()?; |
| 905 | ]; | 955 | for p in [51, 52, 53, 55, 56, 57] { |
| 906 | 956 | relay::shutdown_relay(8000 + p)?; | |
| 907 | // fallback (51,52) user write (53, 55) repo (55, 56) blaster (57) | 957 | } |
| 908 | let (mut r51, mut r52, mut r53, mut r55, mut r56, mut r57) = ( | 958 | // local refs updated |
| 909 | Relay::new(8051, None, None), | 959 | assert_eq!( |
| 910 | Relay::new(8052, None, None), | 960 | git_repo |
| 911 | Relay::new(8053, None, None), | 961 | .git_repo |
| 912 | Relay::new(8055, None, None), | 962 | .find_reference("refs/remotes/nostr/main")? |
| 913 | Relay::new(8056, None, None), | 963 | .peel_to_commit()? |
| 914 | Relay::new(8057, None, None), | 964 | .id(), |
| 915 | ); | 965 | main_commit_id, |
| 916 | r51.events = events.clone(); | 966 | ); |
| 917 | r55.events = events; | ||
| 918 | |||
| 919 | let cli_tester_handle = std::thread::spawn(move || -> Result<()> { | ||
| 920 | let mut p = cli_tester_after_fetch(&git_repo)?; | ||
| 921 | p.send_line("push refs/heads/main:refs/heads/main")?; | ||
| 922 | p.send_line("push refs/heads/vnext:refs/heads/vnext")?; | ||
| 923 | p.send_line("")?; | ||
| 924 | p.expect("ok refs/heads/main\r\n")?; | ||
| 925 | p.expect("ok refs/heads/vnext\r\n")?; | ||
| 926 | p.expect("\r\n")?; | ||
| 927 | p.exit()?; | ||
| 928 | // local refs updated | ||
| 929 | assert_eq!( | ||
| 930 | git_repo | ||
| 931 | .git_repo | ||
| 932 | .find_reference("refs/remotes/nostr/main")? | ||
| 933 | .peel_to_commit()? | ||
| 934 | .id(), | ||
| 935 | main_commit_id, | ||
| 936 | ); | ||
| 937 | |||
| 938 | assert_eq!( | ||
| 939 | git_repo | ||
| 940 | .git_repo | ||
| 941 | .find_reference("refs/remotes/nostr/vnext")? | ||
| 942 | .peel_to_commit()? | ||
| 943 | .id(), | ||
| 944 | vnext_commit_id | ||
| 945 | ); | ||
| 946 | for p in [51, 52, 53, 55, 56, 57] { | ||
| 947 | relay::shutdown_relay(8000 + p)?; | ||
| 948 | } | ||
| 949 | Ok(()) | ||
| 950 | }); | ||
| 951 | // launch relays | ||
| 952 | let _ = join!( | ||
| 953 | r51.listen_until_close(), | ||
| 954 | r52.listen_until_close(), | ||
| 955 | r53.listen_until_close(), | ||
| 956 | r55.listen_until_close(), | ||
| 957 | r56.listen_until_close(), | ||
| 958 | r57.listen_until_close(), | ||
| 959 | ); | ||
| 960 | 967 | ||
| 961 | cli_tester_handle.join().unwrap()?; | 968 | assert_eq!( |
| 969 | git_repo | ||
| 970 | .git_repo | ||
| 971 | .find_reference("refs/remotes/nostr/vnext")? | ||
| 972 | .peel_to_commit()? | ||
| 973 | .id(), | ||
| 974 | vnext_commit_id | ||
| 975 | ); | ||
| 976 | Ok(()) | ||
| 977 | }); | ||
| 978 | // launch relays | ||
| 979 | let _ = join!( | ||
| 980 | r51.listen_until_close(), | ||
| 981 | r52.listen_until_close(), | ||
| 982 | r53.listen_until_close(), | ||
| 983 | r55.listen_until_close(), | ||
| 984 | r56.listen_until_close(), | ||
| 985 | r57.listen_until_close(), | ||
| 986 | ); | ||
| 962 | 987 | ||
| 963 | // git_server updated | 988 | cli_tester_handle.join().unwrap()?; |
| 964 | assert_eq!( | ||
| 965 | source_git_repo.get_tip_of_local_branch("main")?, | ||
| 966 | main_commit_id | ||
| 967 | ); | ||
| 968 | 989 | ||
| 969 | assert_eq!( | 990 | // git_server updated |
| 970 | source_git_repo.get_tip_of_local_branch("vnext")?, | 991 | assert_eq!( |
| 971 | vnext_commit_id | 992 | source_git_repo.get_tip_of_local_branch("main")?, |
| 972 | ); | 993 | main_commit_id |
| 994 | ); | ||
| 973 | 995 | ||
| 974 | // state annoucement updated | 996 | assert_eq!( |
| 975 | let state_event = r56 | 997 | source_git_repo.get_tip_of_local_branch("vnext")?, |
| 976 | .events | 998 | vnext_commit_id |
| 977 | .iter() | 999 | ); |
| 978 | .find(|e| e.kind().eq(&STATE_KIND)) | ||
| 979 | .context("state event not created")?; | ||
| 980 | 1000 | ||
| 981 | // println!("{:#?}", state_event); | 1001 | // state annoucement updated |
| 982 | assert_eq!( | 1002 | let state_event = r56 |
| 983 | state_event | 1003 | .events |
| 984 | .tags | 1004 | .iter() |
| 985 | .iter() | 1005 | .find(|e| e.kind().eq(&STATE_KIND)) |
| 986 | .filter(|t| t.kind().to_string().as_str().ne("d")) | 1006 | .context("state event not created")?; |
| 987 | .map(|t| t.as_vec().to_vec()) | ||
| 988 | .collect::<HashSet<Vec<String>>>(), | ||
| 989 | HashSet::from([ | ||
| 990 | vec!["HEAD".to_string(), "ref: refs/heads/main".to_string()], | ||
| 991 | vec!["refs/heads/main".to_string(), main_commit_id.to_string()], | ||
| 992 | vec![ | ||
| 993 | "refs/heads/example-branch".to_string(), | ||
| 994 | example_branch_commit_id.to_string() | ||
| 995 | ], | ||
| 996 | vec!["refs/heads/vnext".to_string(), vnext_commit_id.to_string()], | ||
| 997 | ]), | ||
| 998 | ); | ||
| 999 | Ok(()) | ||
| 1000 | } | ||
| 1001 | 1007 | ||
| 1002 | #[tokio::test] | 1008 | // println!("{:#?}", state_event); |
| 1003 | #[serial] | 1009 | assert_eq!( |
| 1004 | async fn state_event_reflects_updated_with_pushed_changes() -> Result<()> { | 1010 | state_event |
| 1005 | async_run_test().await | 1011 | .tags |
| 1006 | } | 1012 | .iter() |
| 1007 | } | 1013 | .filter(|t| t.kind().to_string().as_str().ne("d")) |
| 1014 | .map(|t| t.as_vec().to_vec()) | ||
| 1015 | .collect::<HashSet<Vec<String>>>(), | ||
| 1016 | HashSet::from([ | ||
| 1017 | vec!["HEAD".to_string(), "ref: refs/heads/main".to_string()], | ||
| 1018 | vec!["refs/heads/main".to_string(), main_commit_id.to_string()], | ||
| 1019 | vec![ | ||
| 1020 | "refs/heads/example-branch".to_string(), | ||
| 1021 | example_branch_commit_id.to_string() | ||
| 1022 | ], | ||
| 1023 | vec!["refs/heads/vnext".to_string(), vnext_commit_id.to_string()], | ||
| 1024 | ]), | ||
| 1025 | ); | ||
| 1026 | Ok(()) | ||
| 1008 | } | 1027 | } |
| 1009 | } | 1028 | } |
| 1010 | mod delete_one_branch { | 1029 | mod delete_one_branch { |
| 1011 | 1030 | ||
| 1012 | use super::*; | 1031 | use super::*; |
| 1013 | 1032 | ||
| 1014 | mod git_server_updated { | 1033 | #[tokio::test] |
| 1015 | 1034 | #[serial] | |
| 1016 | use super::*; | 1035 | async fn deletes_branch_on_git_server() -> Result<()> { |
| 1036 | let git_repo = prep_git_repo()?; | ||
| 1017 | 1037 | ||
| 1018 | async fn async_run_test() -> Result<()> { | 1038 | git_repo.create_branch("vnext")?; |
| 1019 | let git_repo = prep_git_repo()?; | 1039 | git_repo.checkout("vnext")?; |
| 1040 | std::fs::write(git_repo.dir.join("vnext.md"), "some content")?; | ||
| 1041 | let vnext_commit_id = git_repo.stage_and_commit("vnext.md")?; | ||
| 1020 | 1042 | ||
| 1021 | git_repo.create_branch("vnext")?; | 1043 | let source_git_repo = GitTestRepo::recreate_as_bare(&git_repo)?; |
| 1022 | git_repo.checkout("vnext")?; | ||
| 1023 | std::fs::write(git_repo.dir.join("vnext.md"), "some content")?; | ||
| 1024 | let vnext_commit_id = git_repo.stage_and_commit("vnext.md")?; | ||
| 1025 | 1044 | ||
| 1026 | let source_git_repo = GitTestRepo::recreate_as_bare(&git_repo)?; | 1045 | let events = vec![ |
| 1046 | generate_test_key_1_metadata_event("fred"), | ||
| 1047 | generate_test_key_1_relay_list_event(), | ||
| 1048 | generate_repo_ref_event_with_git_server(vec![ | ||
| 1049 | source_git_repo.dir.to_str().unwrap().to_string(), | ||
| 1050 | ]), | ||
| 1051 | ]; | ||
| 1052 | // fallback (51,52) user write (53, 55) repo (55, 56) blaster (57) | ||
| 1053 | let (mut r51, mut r52, mut r53, mut r55, mut r56, mut r57) = ( | ||
| 1054 | Relay::new(8051, None, None), | ||
| 1055 | Relay::new(8052, None, None), | ||
| 1056 | Relay::new(8053, None, None), | ||
| 1057 | Relay::new(8055, None, None), | ||
| 1058 | Relay::new(8056, None, None), | ||
| 1059 | Relay::new(8057, None, None), | ||
| 1060 | ); | ||
| 1061 | r51.events = events.clone(); | ||
| 1062 | r55.events = events; | ||
| 1027 | 1063 | ||
| 1028 | let events = vec![ | 1064 | let cli_tester_handle = std::thread::spawn(move || -> Result<()> { |
| 1029 | generate_test_key_1_metadata_event("fred"), | 1065 | assert_eq!( |
| 1030 | generate_test_key_1_relay_list_event(), | 1066 | source_git_repo |
| 1031 | generate_repo_ref_event_with_git_server(vec![ | 1067 | .git_repo |
| 1032 | source_git_repo.dir.to_str().unwrap().to_string(), | 1068 | .find_reference("refs/heads/vnext")? |
| 1033 | ]), | 1069 | .peel_to_commit()? |
| 1034 | ]; | 1070 | .id(), |
| 1035 | // fallback (51,52) user write (53, 55) repo (55, 56) blaster (57) | 1071 | vnext_commit_id |
| 1036 | let (mut r51, mut r52, mut r53, mut r55, mut r56, mut r57) = ( | ||
| 1037 | Relay::new(8051, None, None), | ||
| 1038 | Relay::new(8052, None, None), | ||
| 1039 | Relay::new(8053, None, None), | ||
| 1040 | Relay::new(8055, None, None), | ||
| 1041 | Relay::new(8056, None, None), | ||
| 1042 | Relay::new(8057, None, None), | ||
| 1043 | ); | 1072 | ); |
| 1044 | r51.events = events.clone(); | ||
| 1045 | r55.events = events; | ||
| 1046 | 1073 | ||
| 1047 | let cli_tester_handle = std::thread::spawn(move || -> Result<()> { | 1074 | let mut p = cli_tester_after_fetch(&git_repo)?; |
| 1048 | assert_eq!( | 1075 | p.send_line("push :refs/heads/vnext")?; |
| 1049 | source_git_repo | 1076 | p.send_line("")?; |
| 1050 | .git_repo | 1077 | p.expect_eventually("\r\n\r\n")?; |
| 1051 | .find_reference("refs/heads/vnext")? | 1078 | p.exit()?; |
| 1052 | .peel_to_commit()? | 1079 | for p in [51, 52, 53, 55, 56, 57] { |
| 1053 | .id(), | 1080 | relay::shutdown_relay(8000 + p)?; |
| 1054 | vnext_commit_id | 1081 | } |
| 1055 | ); | ||
| 1056 | 1082 | ||
| 1057 | let mut p = cli_tester_after_fetch(&git_repo)?; | 1083 | assert!( |
| 1058 | p.send_line("push :refs/heads/vnext")?; | 1084 | source_git_repo |
| 1059 | p.send_line("")?; | 1085 | .git_repo |
| 1060 | p.expect("ok refs/heads/vnext\r\n")?; | 1086 | .find_reference("refs/heads/vnext") |
| 1061 | p.expect("\r\n")?; | 1087 | .is_err() |
| 1062 | |||
| 1063 | assert!( | ||
| 1064 | source_git_repo | ||
| 1065 | .git_repo | ||
| 1066 | .find_reference("refs/heads/vnext") | ||
| 1067 | .is_err() | ||
| 1068 | ); | ||
| 1069 | // p.exit()?; | ||
| 1070 | for p in [51, 52, 53, 55, 56, 57] { | ||
| 1071 | relay::shutdown_relay(8000 + p)?; | ||
| 1072 | } | ||
| 1073 | Ok(()) | ||
| 1074 | }); | ||
| 1075 | // launch relays | ||
| 1076 | let _ = join!( | ||
| 1077 | r51.listen_until_close(), | ||
| 1078 | r52.listen_until_close(), | ||
| 1079 | r53.listen_until_close(), | ||
| 1080 | r55.listen_until_close(), | ||
| 1081 | r56.listen_until_close(), | ||
| 1082 | r57.listen_until_close(), | ||
| 1083 | ); | 1088 | ); |
| 1084 | cli_tester_handle.join().unwrap()?; | ||
| 1085 | Ok(()) | 1089 | Ok(()) |
| 1086 | } | 1090 | }); |
| 1087 | 1091 | // launch relays | |
| 1088 | #[tokio::test] | 1092 | let _ = join!( |
| 1089 | #[serial] | 1093 | r51.listen_until_close(), |
| 1090 | async fn push_deletes_branch_on_git_server() -> Result<()> { | 1094 | r52.listen_until_close(), |
| 1091 | async_run_test().await | 1095 | r53.listen_until_close(), |
| 1092 | } | 1096 | r55.listen_until_close(), |
| 1097 | r56.listen_until_close(), | ||
| 1098 | r57.listen_until_close(), | ||
| 1099 | ); | ||
| 1100 | cli_tester_handle.join().unwrap()?; | ||
| 1101 | Ok(()) | ||
| 1093 | } | 1102 | } |
| 1094 | mod remote_refs_updated { | ||
| 1095 | 1103 | ||
| 1096 | use super::*; | 1104 | #[tokio::test] |
| 1105 | #[serial] | ||
| 1106 | async fn remote_refs_updated_in_local_git() -> Result<()> { | ||
| 1107 | let git_repo = prep_git_repo()?; | ||
| 1097 | 1108 | ||
| 1098 | async fn async_run_test() -> Result<()> { | 1109 | git_repo.create_branch("vnext")?; |
| 1099 | let git_repo = prep_git_repo()?; | 1110 | git_repo.checkout("vnext")?; |
| 1111 | std::fs::write(git_repo.dir.join("vnext.md"), "some content")?; | ||
| 1112 | let vnext_commit_id = git_repo.stage_and_commit("vnext.md")?; | ||
| 1100 | 1113 | ||
| 1101 | git_repo.create_branch("vnext")?; | 1114 | let source_git_repo = GitTestRepo::recreate_as_bare(&git_repo)?; |
| 1102 | git_repo.checkout("vnext")?; | ||
| 1103 | std::fs::write(git_repo.dir.join("vnext.md"), "some content")?; | ||
| 1104 | let vnext_commit_id = git_repo.stage_and_commit("vnext.md")?; | ||
| 1105 | 1115 | ||
| 1106 | let source_git_repo = GitTestRepo::recreate_as_bare(&git_repo)?; | 1116 | git_repo |
| 1117 | .git_repo | ||
| 1118 | .reference("refs/remotes/nostr/vnext", vnext_commit_id, true, "")?; | ||
| 1107 | 1119 | ||
| 1108 | git_repo.git_repo.reference( | 1120 | let events = vec![ |
| 1109 | "refs/remotes/nostr/vnext", | 1121 | generate_test_key_1_metadata_event("fred"), |
| 1110 | vnext_commit_id, | 1122 | generate_test_key_1_relay_list_event(), |
| 1111 | true, | 1123 | generate_repo_ref_event_with_git_server(vec![ |
| 1112 | "", | 1124 | source_git_repo.dir.to_str().unwrap().to_string(), |
| 1113 | )?; | 1125 | ]), |
| 1126 | ]; | ||
| 1127 | // fallback (51,52) user write (53, 55) repo (55, 56) blaster (57) | ||
| 1128 | let (mut r51, mut r52, mut r53, mut r55, mut r56, mut r57) = ( | ||
| 1129 | Relay::new(8051, None, None), | ||
| 1130 | Relay::new(8052, None, None), | ||
| 1131 | Relay::new(8053, None, None), | ||
| 1132 | Relay::new(8055, None, None), | ||
| 1133 | Relay::new(8056, None, None), | ||
| 1134 | Relay::new(8057, None, None), | ||
| 1135 | ); | ||
| 1136 | r51.events = events.clone(); | ||
| 1137 | r55.events = events; | ||
| 1114 | 1138 | ||
| 1115 | let events = vec![ | 1139 | let cli_tester_handle = std::thread::spawn(move || -> Result<()> { |
| 1116 | generate_test_key_1_metadata_event("fred"), | 1140 | assert_eq!( |
| 1117 | generate_test_key_1_relay_list_event(), | 1141 | git_repo |
| 1118 | generate_repo_ref_event_with_git_server(vec![ | 1142 | .git_repo |
| 1119 | source_git_repo.dir.to_str().unwrap().to_string(), | 1143 | .find_reference("refs/remotes/nostr/vnext")? |
| 1120 | ]), | 1144 | .peel_to_commit()? |
| 1121 | ]; | 1145 | .id(), |
| 1122 | // fallback (51,52) user write (53, 55) repo (55, 56) blaster (57) | 1146 | vnext_commit_id |
| 1123 | let (mut r51, mut r52, mut r53, mut r55, mut r56, mut r57) = ( | ||
| 1124 | Relay::new(8051, None, None), | ||
| 1125 | Relay::new(8052, None, None), | ||
| 1126 | Relay::new(8053, None, None), | ||
| 1127 | Relay::new(8055, None, None), | ||
| 1128 | Relay::new(8056, None, None), | ||
| 1129 | Relay::new(8057, None, None), | ||
| 1130 | ); | 1147 | ); |
| 1131 | r51.events = events.clone(); | ||
| 1132 | r55.events = events; | ||
| 1133 | |||
| 1134 | let cli_tester_handle = std::thread::spawn(move || -> Result<()> { | ||
| 1135 | assert_eq!( | ||
| 1136 | git_repo | ||
| 1137 | .git_repo | ||
| 1138 | .find_reference("refs/remotes/nostr/vnext")? | ||
| 1139 | .peel_to_commit()? | ||
| 1140 | .id(), | ||
| 1141 | vnext_commit_id | ||
| 1142 | ); | ||
| 1143 | |||
| 1144 | let mut p = cli_tester_after_fetch(&git_repo)?; | ||
| 1145 | p.send_line("push :refs/heads/vnext")?; | ||
| 1146 | p.send_line("")?; | ||
| 1147 | // let res = p.expect_eventually("\r\n\r\n")?; | ||
| 1148 | // println!("{res}"); | ||
| 1149 | p.expect("ok refs/heads/vnext\r\n")?; | ||
| 1150 | p.expect("\r\n")?; | ||
| 1151 | |||
| 1152 | assert!( | ||
| 1153 | git_repo | ||
| 1154 | .git_repo | ||
| 1155 | .find_reference("refs/remotes/nostr/vnext") | ||
| 1156 | .is_err() | ||
| 1157 | ); | ||
| 1158 | 1148 | ||
| 1159 | p.exit()?; | 1149 | let mut p = cli_tester_after_fetch(&git_repo)?; |
| 1160 | for p in [51, 52, 53, 55, 56, 57] { | 1150 | p.send_line("push :refs/heads/vnext")?; |
| 1161 | relay::shutdown_relay(8000 + p)?; | 1151 | p.send_line("")?; |
| 1162 | } | 1152 | p.expect_eventually("\r\n\r\n")?; |
| 1163 | Ok(()) | 1153 | p.exit()?; |
| 1164 | }); | 1154 | for p in [51, 52, 53, 55, 56, 57] { |
| 1165 | // launch relays | 1155 | relay::shutdown_relay(8000 + p)?; |
| 1166 | let _ = join!( | 1156 | } |
| 1167 | r51.listen_until_close(), | 1157 | assert!( |
| 1168 | r52.listen_until_close(), | 1158 | git_repo |
| 1169 | r53.listen_until_close(), | 1159 | .git_repo |
| 1170 | r55.listen_until_close(), | 1160 | .find_reference("refs/remotes/nostr/vnext") |
| 1171 | r56.listen_until_close(), | 1161 | .is_err() |
| 1172 | r57.listen_until_close(), | ||
| 1173 | ); | 1162 | ); |
| 1174 | cli_tester_handle.join().unwrap()?; | ||
| 1175 | Ok(()) | 1163 | Ok(()) |
| 1176 | } | 1164 | }); |
| 1177 | 1165 | // launch relays | |
| 1178 | #[tokio::test] | 1166 | let _ = join!( |
| 1179 | #[serial] | 1167 | r51.listen_until_close(), |
| 1180 | async fn push_remotes_refs() -> Result<()> { | 1168 | r52.listen_until_close(), |
| 1181 | async_run_test().await | 1169 | r53.listen_until_close(), |
| 1182 | } | 1170 | r55.listen_until_close(), |
| 1171 | r56.listen_until_close(), | ||
| 1172 | r57.listen_until_close(), | ||
| 1173 | ); | ||
| 1174 | cli_tester_handle.join().unwrap()?; | ||
| 1175 | Ok(()) | ||
| 1183 | } | 1176 | } |
| 1184 | mod existing_state_event { | ||
| 1185 | use super::*; | ||
| 1186 | |||
| 1187 | mod state_on_git_server_published_in_nostr_state_event { | ||
| 1188 | |||
| 1189 | use super::*; | ||
| 1190 | |||
| 1191 | async fn async_run_test() -> Result<()> { | ||
| 1192 | let (state_event, source_git_repo) = generate_repo_with_state_event().await?; | ||
| 1193 | 1177 | ||
| 1194 | let git_repo = prep_git_repo()?; | 1178 | #[tokio::test] |
| 1195 | let main_commit_id = git_repo.get_tip_of_local_branch("main")?.to_string(); // same as example | 1179 | #[serial] |
| 1180 | async fn prints_git_helper_ok_respose() -> Result<()> { | ||
| 1181 | let git_repo = prep_git_repo()?; | ||
| 1196 | 1182 | ||
| 1197 | let events = vec![ | 1183 | git_repo.create_branch("vnext")?; |
| 1198 | generate_test_key_1_metadata_event("fred"), | 1184 | git_repo.checkout("vnext")?; |
| 1199 | generate_test_key_1_relay_list_event(), | 1185 | std::fs::write(git_repo.dir.join("vnext.md"), "some content")?; |
| 1200 | generate_repo_ref_event_with_git_server(vec![ | 1186 | let vnext_commit_id = git_repo.stage_and_commit("vnext.md")?; |
| 1201 | source_git_repo.dir.to_str().unwrap().to_string(), | ||
| 1202 | ]), | ||
| 1203 | state_event.clone(), | ||
| 1204 | ]; | ||
| 1205 | |||
| 1206 | // fallback (51,52) user write (53, 55) repo (55, 56) blaster (57) | ||
| 1207 | let (mut r51, mut r52, mut r53, mut r55, mut r56, mut r57) = ( | ||
| 1208 | Relay::new(8051, None, None), | ||
| 1209 | Relay::new(8052, None, None), | ||
| 1210 | Relay::new(8053, None, None), | ||
| 1211 | Relay::new(8055, None, None), | ||
| 1212 | Relay::new(8056, None, None), | ||
| 1213 | Relay::new(8057, None, None), | ||
| 1214 | ); | ||
| 1215 | r51.events = events.clone(); | ||
| 1216 | r55.events = events; | ||
| 1217 | |||
| 1218 | let cli_tester_handle = std::thread::spawn(move || -> Result<()> { | ||
| 1219 | let mut p = cli_tester_after_fetch(&git_repo)?; | ||
| 1220 | p.send_line("push :refs/heads/example-branch")?; | ||
| 1221 | p.send_line("")?; | ||
| 1222 | p.expect("ok refs/heads/example-branch\r\n")?; | ||
| 1223 | p.expect("\r\n")?; | ||
| 1224 | p.exit()?; | ||
| 1225 | for p in [51, 52, 53, 55, 56, 57] { | ||
| 1226 | relay::shutdown_relay(8000 + p)?; | ||
| 1227 | } | ||
| 1228 | Ok(()) | ||
| 1229 | }); | ||
| 1230 | // launch relays | ||
| 1231 | let _ = join!( | ||
| 1232 | r51.listen_until_close(), | ||
| 1233 | r52.listen_until_close(), | ||
| 1234 | r53.listen_until_close(), | ||
| 1235 | r55.listen_until_close(), | ||
| 1236 | r56.listen_until_close(), | ||
| 1237 | r57.listen_until_close(), | ||
| 1238 | ); | ||
| 1239 | 1187 | ||
| 1240 | cli_tester_handle.join().unwrap()?; | 1188 | let source_git_repo = GitTestRepo::recreate_as_bare(&git_repo)?; |
| 1241 | 1189 | ||
| 1242 | let state_event = r56 | 1190 | git_repo |
| 1243 | .events | 1191 | .git_repo |
| 1244 | .iter() | 1192 | .reference("refs/remotes/nostr/vnext", vnext_commit_id, true, "")?; |
| 1245 | .find(|e| e.kind().eq(&STATE_KIND)) | ||
| 1246 | .context("state event not created")?; | ||
| 1247 | 1193 | ||
| 1248 | // println!("{:#?}", state_event); | 1194 | let events = vec![ |
| 1249 | assert_eq!( | 1195 | generate_test_key_1_metadata_event("fred"), |
| 1250 | state_event | 1196 | generate_test_key_1_relay_list_event(), |
| 1251 | .tags | 1197 | generate_repo_ref_event_with_git_server(vec![ |
| 1252 | .iter() | 1198 | source_git_repo.dir.to_str().unwrap().to_string(), |
| 1253 | .filter(|t| t.kind().to_string().as_str().ne("d")) | 1199 | ]), |
| 1254 | .map(|t| t.as_vec().to_vec()) | 1200 | ]; |
| 1255 | .collect::<HashSet<Vec<String>>>(), | 1201 | // fallback (51,52) user write (53, 55) repo (55, 56) blaster (57) |
| 1256 | HashSet::from([ | 1202 | let (mut r51, mut r52, mut r53, mut r55, mut r56, mut r57) = ( |
| 1257 | vec!["HEAD".to_string(), "ref: refs/heads/main".to_string()], | 1203 | Relay::new(8051, None, None), |
| 1258 | vec!["refs/heads/main".to_string(), main_commit_id.to_string()], | 1204 | Relay::new(8052, None, None), |
| 1259 | ]), | 1205 | Relay::new(8053, None, None), |
| 1260 | ); | 1206 | Relay::new(8055, None, None), |
| 1261 | Ok(()) | 1207 | Relay::new(8056, None, None), |
| 1262 | } | 1208 | Relay::new(8057, None, None), |
| 1209 | ); | ||
| 1210 | r51.events = events.clone(); | ||
| 1211 | r55.events = events; | ||
| 1263 | 1212 | ||
| 1264 | #[tokio::test] | 1213 | let cli_tester_handle = std::thread::spawn(move || -> Result<()> { |
| 1265 | #[serial] | 1214 | let mut p = cli_tester_after_fetch(&git_repo)?; |
| 1266 | async fn state_event_reflects_deleted_branch() -> Result<()> { | 1215 | p.send_line("push :refs/heads/vnext")?; |
| 1267 | async_run_test().await | 1216 | p.send_line("")?; |
| 1217 | // let res = p.expect_eventually("\r\n\r\n")?; | ||
| 1218 | // println!("{res}"); | ||
| 1219 | p.expect("ok refs/heads/vnext\r\n")?; | ||
| 1220 | p.expect("\r\n")?; | ||
| 1221 | p.exit()?; | ||
| 1222 | for p in [51, 52, 53, 55, 56, 57] { | ||
| 1223 | relay::shutdown_relay(8000 + p)?; | ||
| 1268 | } | 1224 | } |
| 1269 | } | 1225 | Ok(()) |
| 1226 | }); | ||
| 1227 | // launch relays | ||
| 1228 | let _ = join!( | ||
| 1229 | r51.listen_until_close(), | ||
| 1230 | r52.listen_until_close(), | ||
| 1231 | r53.listen_until_close(), | ||
| 1232 | r55.listen_until_close(), | ||
| 1233 | r56.listen_until_close(), | ||
| 1234 | r57.listen_until_close(), | ||
| 1235 | ); | ||
| 1236 | cli_tester_handle.join().unwrap()?; | ||
| 1237 | Ok(()) | ||
| 1270 | } | 1238 | } |
| 1271 | } | ||
| 1272 | 1239 | ||
| 1273 | mod pushes_to_all_git_servers_listed { | 1240 | #[tokio::test] |
| 1274 | use super::*; | 1241 | #[serial] |
| 1275 | async fn async_run_test() -> Result<()> { | 1242 | async fn existing_state_event_updated_with_branch_deleted_and_ok_printed() -> Result<()> { |
| 1276 | let (state_event, source_git_repo) = generate_repo_with_state_event().await?; | 1243 | let (state_event, source_git_repo) = generate_repo_with_state_event().await?; |
| 1277 | let second_source_git_repo = GitTestRepo::duplicate(&source_git_repo)?; | ||
| 1278 | |||
| 1279 | // uppdate announcement with extra git server | ||
| 1280 | 1244 | ||
| 1281 | let git_repo = prep_git_repo()?; | 1245 | let git_repo = prep_git_repo()?; |
| 1282 | 1246 | let main_commit_id = git_repo.get_tip_of_local_branch("main")?.to_string(); // same as example | |
| 1283 | std::fs::write(git_repo.dir.join("new.md"), "some content")?; | ||
| 1284 | let main_commit_id = git_repo.stage_and_commit("new.md")?; | ||
| 1285 | 1247 | ||
| 1286 | let events = vec![ | 1248 | let events = vec![ |
| 1287 | generate_test_key_1_metadata_event("fred"), | 1249 | generate_test_key_1_metadata_event("fred"), |
| 1288 | generate_test_key_1_relay_list_event(), | 1250 | generate_test_key_1_relay_list_event(), |
| 1289 | generate_repo_ref_event_with_git_server(vec![ | 1251 | generate_repo_ref_event_with_git_server(vec![ |
| 1290 | source_git_repo.dir.to_str().unwrap().to_string(), | 1252 | source_git_repo.dir.to_str().unwrap().to_string(), |
| 1291 | second_source_git_repo.dir.to_str().unwrap().to_string(), | ||
| 1292 | ]), | 1253 | ]), |
| 1293 | state_event.clone(), | 1254 | state_event.clone(), |
| 1294 | ]; | 1255 | ]; |
| @@ -1307,9 +1268,9 @@ mod push { | |||
| 1307 | 1268 | ||
| 1308 | let cli_tester_handle = std::thread::spawn(move || -> Result<()> { | 1269 | let cli_tester_handle = std::thread::spawn(move || -> Result<()> { |
| 1309 | let mut p = cli_tester_after_fetch(&git_repo)?; | 1270 | let mut p = cli_tester_after_fetch(&git_repo)?; |
| 1310 | p.send_line("push refs/heads/main:refs/heads/main")?; | 1271 | p.send_line("push :refs/heads/example-branch")?; |
| 1311 | p.send_line("")?; | 1272 | p.send_line("")?; |
| 1312 | p.expect("ok refs/heads/main\r\n")?; | 1273 | p.expect("ok refs/heads/example-branch\r\n")?; |
| 1313 | p.expect("\r\n")?; | 1274 | p.expect("\r\n")?; |
| 1314 | p.exit()?; | 1275 | p.exit()?; |
| 1315 | for p in [51, 52, 53, 55, 56, 57] { | 1276 | for p in [51, 52, 53, 55, 56, 57] { |
| @@ -1329,23 +1290,98 @@ mod push { | |||
| 1329 | 1290 | ||
| 1330 | cli_tester_handle.join().unwrap()?; | 1291 | cli_tester_handle.join().unwrap()?; |
| 1331 | 1292 | ||
| 1332 | // git_server updated | 1293 | let state_event = r56 |
| 1333 | assert_eq!( | 1294 | .events |
| 1334 | source_git_repo.get_tip_of_local_branch("main")?, | 1295 | .iter() |
| 1335 | main_commit_id | 1296 | .find(|e| e.kind().eq(&STATE_KIND)) |
| 1336 | ); | 1297 | .context("state event not created")?; |
| 1298 | |||
| 1299 | // println!("{:#?}", state_event); | ||
| 1337 | assert_eq!( | 1300 | assert_eq!( |
| 1338 | second_source_git_repo.get_tip_of_local_branch("main")?, | 1301 | state_event |
| 1339 | main_commit_id | 1302 | .tags |
| 1303 | .iter() | ||
| 1304 | .filter(|t| t.kind().to_string().as_str().ne("d")) | ||
| 1305 | .map(|t| t.as_vec().to_vec()) | ||
| 1306 | .collect::<HashSet<Vec<String>>>(), | ||
| 1307 | HashSet::from([ | ||
| 1308 | vec!["HEAD".to_string(), "ref: refs/heads/main".to_string()], | ||
| 1309 | vec!["refs/heads/main".to_string(), main_commit_id.to_string()], | ||
| 1310 | ]), | ||
| 1340 | ); | 1311 | ); |
| 1341 | |||
| 1342 | Ok(()) | 1312 | Ok(()) |
| 1343 | } | 1313 | } |
| 1314 | } | ||
| 1344 | 1315 | ||
| 1345 | #[tokio::test] | 1316 | #[tokio::test] |
| 1346 | #[serial] | 1317 | #[serial] |
| 1347 | async fn second_git_server_uptodate() -> Result<()> { | 1318 | async fn pushes_to_all_git_servers_listed_and_ok_printed() -> Result<()> { |
| 1348 | async_run_test().await | 1319 | let (state_event, source_git_repo) = generate_repo_with_state_event().await?; |
| 1349 | } | 1320 | let second_source_git_repo = GitTestRepo::duplicate(&source_git_repo)?; |
| 1321 | |||
| 1322 | // uppdate announcement with extra git server | ||
| 1323 | |||
| 1324 | let git_repo = prep_git_repo()?; | ||
| 1325 | |||
| 1326 | std::fs::write(git_repo.dir.join("new.md"), "some content")?; | ||
| 1327 | let main_commit_id = git_repo.stage_and_commit("new.md")?; | ||
| 1328 | |||
| 1329 | let events = vec![ | ||
| 1330 | generate_test_key_1_metadata_event("fred"), | ||
| 1331 | generate_test_key_1_relay_list_event(), | ||
| 1332 | generate_repo_ref_event_with_git_server(vec![ | ||
| 1333 | source_git_repo.dir.to_str().unwrap().to_string(), | ||
| 1334 | second_source_git_repo.dir.to_str().unwrap().to_string(), | ||
| 1335 | ]), | ||
| 1336 | state_event.clone(), | ||
| 1337 | ]; | ||
| 1338 | |||
| 1339 | // fallback (51,52) user write (53, 55) repo (55, 56) blaster (57) | ||
| 1340 | let (mut r51, mut r52, mut r53, mut r55, mut r56, mut r57) = ( | ||
| 1341 | Relay::new(8051, None, None), | ||
| 1342 | Relay::new(8052, None, None), | ||
| 1343 | Relay::new(8053, None, None), | ||
| 1344 | Relay::new(8055, None, None), | ||
| 1345 | Relay::new(8056, None, None), | ||
| 1346 | Relay::new(8057, None, None), | ||
| 1347 | ); | ||
| 1348 | r51.events = events.clone(); | ||
| 1349 | r55.events = events; | ||
| 1350 | |||
| 1351 | let cli_tester_handle = std::thread::spawn(move || -> Result<()> { | ||
| 1352 | let mut p = cli_tester_after_fetch(&git_repo)?; | ||
| 1353 | p.send_line("push refs/heads/main:refs/heads/main")?; | ||
| 1354 | p.send_line("")?; | ||
| 1355 | p.expect("ok refs/heads/main\r\n")?; | ||
| 1356 | p.expect("\r\n")?; | ||
| 1357 | p.exit()?; | ||
| 1358 | for p in [51, 52, 53, 55, 56, 57] { | ||
| 1359 | relay::shutdown_relay(8000 + p)?; | ||
| 1360 | } | ||
| 1361 | Ok(()) | ||
| 1362 | }); | ||
| 1363 | // launch relays | ||
| 1364 | let _ = join!( | ||
| 1365 | r51.listen_until_close(), | ||
| 1366 | r52.listen_until_close(), | ||
| 1367 | r53.listen_until_close(), | ||
| 1368 | r55.listen_until_close(), | ||
| 1369 | r56.listen_until_close(), | ||
| 1370 | r57.listen_until_close(), | ||
| 1371 | ); | ||
| 1372 | |||
| 1373 | cli_tester_handle.join().unwrap()?; | ||
| 1374 | |||
| 1375 | // git_server updated | ||
| 1376 | assert_eq!( | ||
| 1377 | source_git_repo.get_tip_of_local_branch("main")?, | ||
| 1378 | main_commit_id | ||
| 1379 | ); | ||
| 1380 | assert_eq!( | ||
| 1381 | second_source_git_repo.get_tip_of_local_branch("main")?, | ||
| 1382 | main_commit_id | ||
| 1383 | ); | ||
| 1384 | |||
| 1385 | Ok(()) | ||
| 1350 | } | 1386 | } |
| 1351 | } | 1387 | } |