feat(init): add customisation and defaults

- allow more cli input options
- allow customisation of more fields in interface
- change default identifer from shorthand root commit to short name
- defaults to existing repo event (users or other) or maintainers.yaml

1 files changed, 41 insertions, 219 deletions

diff --git a/tests/init.rs b/tests/init.rs
index 1ad3810..d733643 100644
--- a/tests/init.rs
+++ b/tests/init.rs
@@ -8,10 +8,40 @@ fn expect_msgs_first(p: &mut CliTester) -> Result<()> {
     p.expect("logged in as fred\r\n")?;
     // // p.expect("searching for existing claims on repository...\r\n")?;
     p.expect("maintainers.yaml created. commit and push.\r\n")?;
+    p.expect("this enables existing contributors to automatically fetch your repo event (instead of one from a pubkey pretending to be the maintainer) publishing repostory reference...\r\n")?;
     p.expect("publishing repostory reference...\r\n")?;
     Ok(())
 }
 
+fn get_cli_args() -> Vec<&'static str> {
+    vec![
+        "--nsec",
+        TEST_KEY_1_NSEC,
+        "--password",
+        TEST_PASSWORD,
+        "--disable-cli-spinners",
+        "init",
+        "--title",
+        "example-name",
+        "--identifier",
+        "example-identifier",
+        "--description",
+        "example-description",
+        "--web",
+        "https://exampleproject.xyz",
+        "https://gitworkshop.dev/123",
+        "--relays",
+        "ws://localhost:8055",
+        "ws://localhost:8056",
+        "--clone-url",
+        "https://git.myhosting.com/my-repo.git",
+        "--earliest-unique-commit",
+        "9ee507fc4357d7ee16a5d8901bedcd103f23c17d",
+        "--other-maintainers",
+        TEST_KEY_1_NPUB,
+    ]
+}
+
 mod when_repo_not_previously_claimed {
     use super::*;
 
@@ -29,27 +59,7 @@ mod when_repo_not_previously_claimed {
         }
 
         fn cli_tester_init(git_repo: &GitTestRepo) -> CliTester {
-            CliTester::new_from_dir(
-                &git_repo.dir,
-                [
-                    "--nsec",
-                    TEST_KEY_1_NSEC,
-                    "--password",
-                    TEST_PASSWORD,
-                    "--disable-cli-spinners",
-                    "init",
-                    "--title",
-                    "example-name",
-                    "--description",
-                    "example-description",
-                    "--web",
-                    "https://exampleproject.xyz",
-                    "https://gitworkshop.dev/123",
-                    "--relays",
-                    "ws://localhost:8055",
-                    "ws://localhost:8056",
-                ],
-            )
+            CliTester::new_from_dir(&git_repo.dir, get_cli_args())
         }
 
         async fn prep_run_init() -> Result<(
@@ -259,13 +269,12 @@ mod when_repo_not_previously_claimed {
             }
         }
 
-        mod tags {
+        mod tags_as_specified_in_args {
             use super::*;
 
             #[tokio::test]
             #[serial]
-            async fn d_replaceable_event_identifier_defaults_to_root_commit_id_shorthand()
-            -> Result<()> {
+            async fn d_replaceable_event_identifier() -> Result<()> {
                 let (_, _, r53, r55, r56, r57) = prep_run_init().await?;
                 for relay in [&r53, &r55, &r56, &r57] {
                     let event: &nostr::Event = relay
@@ -275,10 +284,9 @@ mod when_repo_not_previously_claimed {
                         .unwrap();
 
                     assert!(
-                        event
-                            .tags
-                            .iter()
-                            .any(|t| t.as_vec()[0].eq("d") && t.as_vec()[1].eq("9ee507f"))
+                        event.tags.iter().any(
+                            |t| t.as_vec()[0].eq("d") && t.as_vec()[1].eq("example-identifier")
+                        )
                     );
                 }
                 Ok(())
@@ -286,7 +294,7 @@ mod when_repo_not_previously_claimed {
 
             #[tokio::test]
             #[serial]
-            async fn root_commit_as_reference() -> Result<()> {
+            async fn earliest_unique_commit_as_reference() -> Result<()> {
                 let (_, _, r53, r55, r56, r57) = prep_run_init().await?;
                 for relay in [&r53, &r55, &r56, &r57] {
                     let event: &nostr::Event = relay
@@ -352,7 +360,7 @@ mod when_repo_not_previously_claimed {
 
                     assert!(
                         event.tags.iter().any(|t| t.as_vec()[0].eq("clone")
-                            && t.as_vec()[1].eq("https://localhost:1000"))
+                            && t.as_vec()[1].eq("https://git.myhosting.com/my-repo.git")) /* todo check it defaults to origin */
                     );
                 }
                 Ok(())
@@ -404,7 +412,7 @@ mod when_repo_not_previously_claimed {
 
             #[tokio::test]
             #[serial]
-            async fn current_user_in_maintainers() -> Result<()> {
+            async fn maintainers() -> Result<()> {
                 let (_, _, r53, r55, r56, r57) = prep_run_init().await?;
                 for relay in [&r53, &r55, &r56, &r57] {
                     let event: &nostr::Event = relay
@@ -498,192 +506,6 @@ mod when_repo_not_previously_claimed {
             }
         }
     }
-
-    mod when_repo_relays_not_specified {
-        use futures::join;
-        use test_utils::relay::Relay;
-
-        use super::*;
-
-        fn prep_git_repo() -> Result<GitTestRepo> {
-            let test_repo = GitTestRepo::default();
-            test_repo.populate()?;
-            test_repo.add_remote("origin", "https://localhost:1000")?;
-            Ok(test_repo)
-        }
-
-        fn cli_tester_init(git_repo: &GitTestRepo) -> CliTester {
-            CliTester::new_from_dir(
-                &git_repo.dir,
-                [
-                    "--nsec",
-                    TEST_KEY_1_NSEC,
-                    "--password",
-                    TEST_PASSWORD,
-                    "--disable-cli-spinners",
-                    "init",
-                    "--title",
-                    "example-name",
-                    "--description",
-                    "example-description",
-                    "--web",
-                    "https://exampleproject.xyz",
-                    "https://gitworkshop.dev/123",
-                ],
-            )
-        }
-
-        async fn prep_run_init() -> Result<(
-            Relay<'static>,
-            Relay<'static>,
-            Relay<'static>,
-            Relay<'static>,
-            Relay<'static>,
-            Relay<'static>,
-        )> {
-            let git_repo = prep_git_repo()?;
-            // fallback (51,52) user write (53, 55) repo (55, 56) blaster (57)
-            let (mut r51, mut r52, mut r53, mut r55, mut r56, mut r57) = (
-                Relay::new(
-                    8051,
-                    None,
-                    Some(&|relay, client_id, subscription_id, _| -> Result<()> {
-                        relay.respond_events(
-                            client_id,
-                            &subscription_id,
-                            &vec![
-                                generate_test_key_1_metadata_event("fred"),
-                                generate_test_key_1_relay_list_event(),
-                            ],
-                        )?;
-                        Ok(())
-                    }),
-                ),
-                Relay::new(8052, None, None),
-                Relay::new(8053, None, None),
-                Relay::new(8055, None, None),
-                Relay::new(8056, None, None),
-                Relay::new(8057, None, None),
-            );
-
-            // // check relay had the right number of events
-            let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
-                let mut p = cli_tester_init(&git_repo);
-                p.expect_end_eventually()?;
-                for p in [51, 52, 53, 55, 56, 57] {
-                    relay::shutdown_relay(8000 + p)?;
-                }
-                Ok(())
-            });
-
-            // launch relay
-            let _ = join!(
-                r51.listen_until_close(),
-                r52.listen_until_close(),
-                r53.listen_until_close(),
-                r55.listen_until_close(),
-                r56.listen_until_close(),
-                r57.listen_until_close(),
-            );
-            cli_tester_handle.join().unwrap()?;
-            Ok((r51, r52, r53, r55, r56, r57))
-        }
-
-        mod tags {
-            use super::*;
-
-            #[tokio::test]
-            #[serial]
-            async fn relays_match_user_write_relays() -> Result<()> {
-                let (_, _, r53, r55, _, _) = prep_run_init().await?;
-                for relay in [&r53, &r55] {
-                    let event: &nostr::Event = relay
-                        .events
-                        .iter()
-                        .find(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
-                        .unwrap();
-
-                    assert!(event.tags.iter().any(|t| t.as_vec()[0].eq("relays")
-                        && t.as_vec()[1].eq("ws://localhost:8053")
-                        && t.as_vec()[2].eq("ws://localhost:8055")));
-                }
-                Ok(())
-            }
-        }
-
-        mod cli_ouput {
-            use super::*;
-
-            async fn run_test_async() -> Result<()> {
-                let git_repo = prep_git_repo()?;
-
-                // fallback (51,52) user write (53, 55) repo (55, 56) blaster (57)
-                let (mut r51, mut r52, mut r53, mut r55, mut r56, mut r57) = (
-                    Relay::new(
-                        8051,
-                        None,
-                        Some(&|relay, client_id, subscription_id, _| -> Result<()> {
-                            relay.respond_events(
-                                client_id,
-                                &subscription_id,
-                                &vec![
-                                    generate_test_key_1_metadata_event("fred"),
-                                    generate_test_key_1_relay_list_event(),
-                                ],
-                            )?;
-                            Ok(())
-                        }),
-                    ),
-                    Relay::new(8052, None, None),
-                    Relay::new(8053, None, None),
-                    Relay::new(8055, None, None),
-                    Relay::new(8056, None, None),
-                    Relay::new(8057, None, None),
-                );
-
-                // // check relay had the right number of events
-                let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
-                    let mut p = cli_tester_init(&git_repo);
-                    expect_msgs_first(&mut p)?;
-                    relay::expect_send_with_progress(
-                        &mut p,
-                        vec![
-                            (" [my-relay] [repo-relay] ws://localhost:8053", true, ""),
-                            (" [my-relay] [repo-relay] ws://localhost:8055", true, ""),
-                            (" [default] ws://localhost:8051", true, ""),
-                            (" [default] ws://localhost:8052", true, ""),
-                            (" [default] ws://localhost:8057", true, ""),
-                        ],
-                        1,
-                    )?;
-                    p.expect_end_with_whitespace()?;
-                    for p in [51, 52, 53, 55, 56, 57] {
-                        relay::shutdown_relay(8000 + p)?;
-                    }
-                    Ok(())
-                });
-
-                // launch relay
-                let _ = join!(
-                    r51.listen_until_close(),
-                    r52.listen_until_close(),
-                    r53.listen_until_close(),
-                    r55.listen_until_close(),
-                    r56.listen_until_close(),
-                    r57.listen_until_close(),
-                );
-                cli_tester_handle.join().unwrap()?;
-                Ok(())
-            }
-
-            #[tokio::test]
-            #[serial]
-            async fn check_cli_output() -> Result<()> {
-                run_test_async().await?;
-                Ok(())
-            }
-        }
-    }
+    // TODO: cli caputuring input
 }
-
-// TODO: when_updating_existing_repoistory
+// TODO: when_updating_existing_repoistory correct defaults are used