fix(init): add missing identifier to yaml

add missing or updated identifier to maintainers.yaml

as we were not checking whether it has changed or added

also update if relays do not match

1 files changed, 95 insertions, 3 deletions

diff --git a/tests/init.rs b/tests/init.rs
index afd3848..896cef8 100644
--- a/tests/init.rs
+++ b/tests/init.rs
@@ -272,9 +272,101 @@ mod when_repo_not_previously_claimed {
 
             #[tokio::test]
             #[serial]
-            async fn contains_maintainers_and_relays() -> Result<()> {
-                async_run_test().await?;
-                Ok(())
+            async fn contains_identifier_maintainers_and_relays() -> Result<()> {
+                async_run_test().await
+            }
+            mod updates_existing_with_missing_identifier {
+                use std::io::Write;
+
+                use super::*;
+                async fn async_run_test() -> 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 yaml_path = git_repo.dir.join("maintainers.yaml");
+                        let mut file = std::fs::File::create(&yaml_path)
+                            .expect("cannot create maintainers.yaml file");
+                        write!(
+                            file,
+                            "\
+                            maintainers:\n\
+                            - {TEST_KEY_1_NPUB}\n\
+                            relays:\n\
+                            - ws://localhost:8055\n\
+                            - ws://localhost:8056\n\
+                            "
+                        )?;
+
+                        let mut p = cli_tester_init(&git_repo);
+                        p.expect_end_eventually()?;
+
+                        assert!(yaml_path.exists());
+
+                        let mut file = fs::File::open(yaml_path).expect("no such file");
+                        let mut file_contents = "".to_string();
+                        let _ = file.read_to_string(&mut file_contents);
+
+                        for p in [51, 52, 53, 55, 56, 57] {
+                            relay::shutdown_relay(8000 + p)?;
+                        }
+                        assert_eq!(
+                            file_contents,
+                            format!(
+                                "\
+                            identifier: example-identifier\n\
+                            maintainers:\n\
+                            - {TEST_KEY_1_NPUB}\n\
+                            relays:\n\
+                            - ws://localhost:8055\n\
+                            - ws://localhost:8056\n\
+                            "
+                            ),
+                        );
+                        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 adds_missing_identifier() -> Result<()> {
+                    async_run_test().await
+                }
             }
         }