3 files changed, 447 insertions, 173 deletions

diff --git a/src/git.rs b/src/git.rs
index eaea512..0794788 100644
--- a/src/git.rs
+++ b/src/git.rs
@@ -39,6 +39,7 @@ pub trait RepoActions {
     fn get_main_or_master_branch(&self) -> Result<(&str, Sha1Hash)>;
     fn get_checked_out_branch_name(&self) -> Result<String>;
     fn get_tip_of_branch(&self, branch_name: &str) -> Result<Sha1Hash>;
+    fn get_commit_or_tip_of_reference(&self, reference: &str) -> Result<Sha1Hash>;
     fn get_root_commit(&self) -> Result<Sha1Hash>;
     fn does_commit_exist(&self, commit: &str) -> Result<bool>;
     fn get_head_commit(&self) -> Result<Sha1Hash>;
@@ -215,6 +216,21 @@ impl RepoActions for Repo {
         Ok(oid_to_sha1(&branch.into_reference().peel_to_commit()?.id()))
     }
 
+    fn get_commit_or_tip_of_reference(&self, sha1_or_reference: &str) -> Result<Sha1Hash> {
+        let oid = {
+            if let Ok(oid) = Oid::from_str(sha1_or_reference) {
+                self.git_repo.find_commit(oid)?;
+                oid
+            } else {
+                self.git_repo
+                    .find_reference(sha1_or_reference)?
+                    .peel_to_commit()?
+                    .id()
+            }
+        };
+        Ok(oid_to_sha1(&oid))
+    }
+
     fn get_root_commit(&self) -> Result<Sha1Hash> {
         let mut revwalk = self
             .git_repo
diff --git a/src/git_remote_helper.rs b/src/git_remote_helper.rs
index 13d6c03..6f645da 100644
--- a/src/git_remote_helper.rs
+++ b/src/git_remote_helper.rs
@@ -78,6 +78,7 @@ async fn main() -> Result<()> {
     let stdin = io::stdin();
     let mut line = String::new();
 
+    let mut list_outputs = None;
     loop {
         let tokens = read_line(&stdin, &mut line)?;
 
@@ -105,14 +106,15 @@ async fn main() -> Result<()> {
                     &stdin,
                     refspec,
                     &client,
+                    list_outputs.clone(),
                 )
                 .await?;
             }
             ["list"] => {
-                list(&git_repo, &repo_ref, false).await?;
+                list_outputs = Some(list(&git_repo, &repo_ref, false).await?);
             }
             ["list", "for-push"] => {
-                list(&git_repo, &repo_ref, true).await?;
+                list_outputs = Some(list(&git_repo, &repo_ref, true).await?);
             }
             [] => {
                 return Ok(());
@@ -351,6 +353,7 @@ fn fetch_from_git_server(
     Ok(())
 }
 
+#[allow(clippy::too_many_lines)]
 async fn push(
     git_repo: &Repo,
     repo_ref: &RepoRef,
@@ -359,56 +362,63 @@ async fn push(
     initial_refspec: &str,
     #[cfg(test)] client: &crate::client::MockConnect,
     #[cfg(not(test))] client: &Client,
+    list_outputs: Option<HashMap<String, HashMap<String, String>>>,
 ) -> Result<()> {
-    // TODO check
-    // bail!(
-    //     "git server {} tip for branch {} conflicts with nostr and local branch.
-    // to resolve either:\r\n  1. pull from that git server and resolve\r\n  2.
-    // force push your branch to the git server before pushing to nostr remote"
-    // )?;
-
-    // if no state events - create from first git server listed
-    let refspecs = get_refspecs_from_push_batch(stdin, initial_refspec)?;
-    let git_server_url = repo_ref
-        .git_server
-        .first()
-        .context("no git server listed in nostr repository announcement")?;
-    let mut git_server_remote = git_repo.git_repo.remote_anonymous(git_server_url)?;
-
-    let auth = GitAuthenticator::default();
-    let git_config = git_repo.git_repo.config()?;
-    let mut push_options = git2::PushOptions::new();
-    let mut remote_callbacks = git2::RemoteCallbacks::new();
-    remote_callbacks.credentials(auth.credentials(&git_config));
-    remote_callbacks.push_update_reference(|name, error| {
-        if let Some(error) = error {
-            println!("error {name} {error}");
+    let mut refspecs = get_refspecs_from_push_batch(stdin, initial_refspec)?;
+
+    let term = console::Term::stderr();
+
+    let list_outputs = match list_outputs {
+        Some(outputs) => outputs,
+        _ => list_from_remotes(&term, git_repo, &repo_ref.git_server)?,
+    };
+
+    let nostr_state = get_state_from_cache(git_repo.get_path()?, repo_ref).await;
+
+    let existing_state = {
+        // if no state events - create from first git server listed
+        if let Ok(nostr_state) = &nostr_state {
+            nostr_state.state.clone()
+        } else if let Some(url) = repo_ref
+            .git_server
+            .iter()
+            .find(|&url| list_outputs.contains_key(url))
+        {
+            list_outputs.get(url).unwrap().to_owned()
         } else {
-            if let Some(refspec) = refspecs
-                .iter()
-                .find(|r| r.contains(format!(":{name}").as_str()))
-            {
-                if let Err(e) =
-                    update_remote_refs_pushed(&git_repo.git_repo, refspec, nostr_remote_url)
-                        .context("could not update remote_ref locally")
-                {
-                    return Err(git2::Error::from_str(e.to_string().as_str()));
-                }
-            }
-            println!("ok {name}",);
+            bail!(
+                "cannot connect to git servers: {}",
+                repo_ref.git_server.join(" ")
+            );
+        }
+    };
+
+    let (rejected_refspecs, remote_refspecs) = create_rejected_refspecs_and_remotes_refspecs(
+        &term,
+        git_repo,
+        &refspecs,
+        &existing_state,
+        &list_outputs,
+    )?;
+
+    refspecs.retain(|refspec| {
+        if let Some(rejected) = rejected_refspecs.get(&refspec.to_string()) {
+            let (_, to) = refspec_to_from_to(refspec).unwrap();
+            println!("error {to} {} out of sync with nostr", rejected.join(" "));
+            false
+        } else {
+            true
         }
-        Ok(())
     });
-    push_options.remote_callbacks(remote_callbacks);
-    git_server_remote.push(&refspecs, Some(&mut push_options))?;
-    git_server_remote.disconnect()?;
 
-    // TODO check whether push was succesful before proceeding - geting outcome from
-    // callback isn't straightforward
+    if refspecs.is_empty() {
+        // all refspecs rejected
+        println!();
+        return Ok(());
+    }
 
-    let new_state = generate_updated_state(git_repo, repo_ref, &refspecs).await?;
+    let new_state = generate_updated_state(git_repo, &existing_state, &refspecs)?;
 
-    // TODO enable interactive login
     let (signer, user_ref) = login::launch(
         git_repo,
         &None,
@@ -420,8 +430,12 @@ async fn push(
         true,
     )
     .await?;
+
     let new_repo_state = RepoState::build(repo_ref.identifier.clone(), new_state, &signer).await?;
 
+    // TODO check whether tip of each branch pushed is on at least one git server
+    // before broadcasting the nostr state
+
     send_events(
         client,
         git_repo.get_path()?,
@@ -433,71 +447,218 @@ async fn push(
     )
     .await?;
 
-    // silently push to any other git servers
-    for (i, git_server_url) in repo_ref.git_server.iter().enumerate() {
-        // we have already pushed to the first one
-        if i.gt(&0) {
-            if let Ok(mut git_server_remote) = git_repo.git_repo.remote_anonymous(git_server_url) {
+    for refspec in &refspecs {
+        let (_, to) = refspec_to_from_to(refspec)?;
+        println!("ok {to}");
+        update_remote_refs_pushed(&git_repo.git_repo, refspec, nostr_remote_url)
+            .context("could not update remote_ref locally")?;
+    }
+
+    // TODO make async - check gitlib2 callbacks work async
+    let git_config = git_repo.git_repo.config()?;
+    for (git_server_url, refspecs) in remote_refspecs {
+        if !refspecs.is_empty() {
+            if let Ok(mut git_server_remote) = git_repo.git_repo.remote_anonymous(&git_server_url) {
                 let auth = GitAuthenticator::default();
-                let git_config = git_repo.git_repo.config()?;
                 let mut push_options = git2::PushOptions::new();
                 let mut remote_callbacks = git2::RemoteCallbacks::new();
                 remote_callbacks.credentials(auth.credentials(&git_config));
+                remote_callbacks.push_update_reference(|name, error| {
+                    if let Some(error) = error {
+                        term.write_line(
+                            format!("WARNING: error pushing {name} to {git_server_url} {error}")
+                                .as_str(),
+                        )
+                        .unwrap();
+                    }
+                    Ok(())
+                });
                 push_options.remote_callbacks(remote_callbacks);
                 let _ = git_server_remote.push(&refspecs, Some(&mut push_options));
                 let _ = git_server_remote.disconnect();
             }
         }
     }
-    // todo report on errors
-
     println!();
     Ok(())
 }
 
-async fn generate_updated_state(
+type HashMapUrlRefspecs = HashMap<String, Vec<String>>;
+
+#[allow(clippy::too_many_lines)]
+fn create_rejected_refspecs_and_remotes_refspecs(
+    term: &console::Term,
     git_repo: &Repo,
-    repo_ref: &RepoRef,
     refspecs: &Vec<String>,
-) -> Result<HashMap<String, String>> {
-    let new_state = {
-        if let Ok(mut repo_state) = get_state_from_cache(git_repo.get_path()?, repo_ref).await {
-            for refspec in refspecs {
-                let (from, to) = refspec_to_from_to(refspec)?;
-                if from.is_empty() {
-                    // delete
-                    repo_state.state.remove(to);
-                } else {
-                    // add or update
-                    repo_state.state.insert(
-                        to.to_string(),
-                        reference_to_ref_value(&git_repo.git_repo, to).unwrap(),
-                    );
+    nostr_state: &HashMap<String, String>,
+    list_outputs: &HashMap<String, HashMap<String, String>>,
+) -> Result<(HashMapUrlRefspecs, HashMapUrlRefspecs)> {
+    let mut refspecs_for_remotes = HashMap::new();
+
+    let mut rejected_refspecs: HashMapUrlRefspecs = HashMap::new();
+
+    for (url, remote_state) in list_outputs {
+        let mut refspecs_for_remote = vec![];
+        for refspec in refspecs {
+            let (from, to) = refspec_to_from_to(refspec)?;
+            let nostr_value = nostr_state.get(to);
+            let remote_value = remote_state.get(to);
+            if from.is_empty() {
+                if remote_value.is_some() {
+                    // delete remote branch
+                    refspecs_for_remote.push(refspec.clone());
                 }
+                continue;
             }
-            repo_state.state
-        } else {
-            let mut state = HashMap::new();
-            let git_server_url = repo_ref
-                .git_server
-                .first()
-                .context("no git server listed in nostr repository announcement")?;
-            let mut git_server_remote = git_repo.git_repo.remote_anonymous(git_server_url)?;
-            git_server_remote.connect(git2::Direction::Fetch)?;
-            for head in git_server_remote.list()? {
-                state.insert(
-                    head.name().to_string(),
-                    if let Some(symbolic_ref) = head.symref_target() {
-                        format!("ref: {symbolic_ref}")
+            let from_tip = git_repo.get_commit_or_tip_of_reference(from)?;
+            if let Some(nostr_value) = nostr_value {
+                if let Some(remote_value) = remote_value {
+                    if nostr_value.eq(remote_value) {
+                        // in sync - existing branch at same state
+                        let is_remote_tip_ancestor_of_commit = if let Ok(remote_value_tip) =
+                            git_repo.get_commit_or_tip_of_reference(remote_value)
+                        {
+                            if let Ok((_, behind)) =
+                                git_repo.get_commits_ahead_behind(&remote_value_tip, &from_tip)
+                            {
+                                behind.is_empty()
+                            } else {
+                                false
+                            }
+                        } else {
+                            false
+                        };
+                        if is_remote_tip_ancestor_of_commit {
+                            refspecs_for_remote.push(refspec.clone());
+                        } else {
+                            // this is a force push so we need to force push to git server too
+                            if refspec.starts_with('+') {
+                                refspecs_for_remote.push(refspec.clone());
+                            } else {
+                                refspecs_for_remote.push(format!("+{refspec}"));
+                            }
+                        }
+                        // TODO do we need to force push to this remote?
+                    } else if let Ok(remote_value_tip) =
+                        git_repo.get_commit_or_tip_of_reference(remote_value)
+                    {
+                        if from_tip.eq(&remote_value_tip) {
+                            // remote already at correct state
+                            term.write_line(
+                                format!("{to} already at pushed commit state on {url}").as_str(),
+                            )?;
+                        }
+                        let (_, behind) =
+                            git_repo.get_commits_ahead_behind(&remote_value_tip, &from_tip)?;
+                        if behind.is_empty() {
+                            // can soft push
+                            refspecs_for_remote.push(refspec.clone());
+                        } else {
+                            // cant soft push
+                            rejected_refspecs
+                                .entry(refspec.to_string())
+                                .and_modify(|a| a.push(url.to_string()))
+                                .or_insert(vec![url.to_string()]);
+                            term.write_line(
+                                format!("ERROR: {to} on {url} conflicts with nostr and is {} behind local branch. either:\r\n  1. pull from that git server and resolve\r\n  2. force push your branch to the git server before pushing to nostr remote", behind.len()).as_str(),
+                            )?;
+                        };
                     } else {
-                        head.oid().to_string()
-                    },
-                );
+                        // remote_value oid is not present locally
+                        // TODO can we download the remote reference?
+
+                        // cant soft push
+                        rejected_refspecs
+                            .entry(refspec.to_string())
+                            .and_modify(|a| a.push(url.to_string()))
+                            .or_insert(vec![url.to_string()]);
+                        term.write_line(
+                            format!("ERROR: {to} on {url} conflicts with nostr and is not an ancestor of local branch. either:\r\n  1. pull from that git server and resolve\r\n  2. force push your branch to the git server before pushing to nostr remote").as_str(),
+                        )?;
+                    }
+                } else {
+                    // existing nostr branch not on remote
+                    // report - creating new branch
+                    term.write_line(format!("pushing {to} as new branch on {url}").as_str())?;
+                    refspecs_for_remote.push(refspec.clone());
+                }
+            } else if let Some(remote_value) = remote_value {
+                // new to nostr but on remote
+                if let Ok(remote_value_tip) = git_repo.get_commit_or_tip_of_reference(remote_value)
+                {
+                    let (_, behind) =
+                        git_repo.get_commits_ahead_behind(&remote_value_tip, &from_tip)?;
+                    if behind.is_empty() {
+                        // can soft push
+                        refspecs_for_remote.push(refspec.clone());
+                    } else {
+                        // cant soft push
+                        rejected_refspecs
+                            .entry(refspec.to_string())
+                            .and_modify(|a| a.push(url.to_string()))
+                            .or_insert(vec![url.to_string()]);
+                        term.write_line(
+                                    format!("ERROR: {to} not on nostr but on {url} is {} behind local branch. either:\r\n  1. pull from that git server and resolve\r\n  2. force push your branch to the git server before pushing to nostr remote", behind.len()).as_str(),
+                                )?;
+                    }
+                } else {
+                    // havn't fetched oid from remote
+                    // TODO fetch oid from remote
+                    // cant soft push
+                    rejected_refspecs
+                        .entry(refspec.to_string())
+                        .and_modify(|a| a.push(url.to_string()))
+                        .or_insert(vec![url.to_string()]);
+                    term.write_line(
+                        format!("ERROR: {to} not on nostr but on {url} is not an ancestor of local branch. either:\r\n  1. pull from that git server and resolve\r\n  2. force push your branch to the git server before pushing to nostr remote").as_str(),
+                    )?;
+                }
+            } else {
+                // in sync - new branch
+                refspecs_for_remote.push(refspec.clone());
             }
-            git_server_remote.disconnect()?;
-            state
         }
-    };
+        refspecs_for_remotes.insert(url.to_string(), refspecs_for_remote);
+    }
+
+    // remove rejected refspecs so they dont get pushed to some remotes
+    let mut remotes_refspecs_without_rejected = HashMap::new();
+    for (url, value) in &refspecs_for_remotes {
+        remotes_refspecs_without_rejected.insert(
+            url.to_string(),
+            value
+                .iter()
+                .filter(|refspec| !rejected_refspecs.contains_key(*refspec))
+                .cloned()
+                .collect(),
+        );
+    }
+    Ok((rejected_refspecs, remotes_refspecs_without_rejected))
+}
+
+fn generate_updated_state(
+    git_repo: &Repo,
+    existing_state: &HashMap<String, String>,
+    refspecs: &Vec<String>,
+) -> Result<HashMap<String, String>> {
+    let mut new_state = existing_state.clone();
+
+    for refspec in refspecs {
+        let (from, to) = refspec_to_from_to(refspec)?;
+        if from.is_empty() {
+            // delete
+            new_state.remove(to);
+        } else {
+            // add or update
+            new_state.insert(
+                to.to_string(),
+                git_repo
+                    .get_commit_or_tip_of_reference(from)
+                    .unwrap()
+                    .to_string(),
+            );
+        }
+    }
     Ok(new_state)
 }
 
diff --git a/tests/git_remote_helper.rs b/tests/git_remote_helper.rs
index 5a6c5f5..f2fa95f 100644
--- a/tests/git_remote_helper.rs
+++ b/tests/git_remote_helper.rs
@@ -64,6 +64,19 @@ fn cli_tester_after_fetch(git_repo: &GitTestRepo) -> Result<CliTester> {
     Ok(p)
 }
 
+/// git runs `list for-push` before `push`. in `push` we use the git server
+/// remote refs downloaded by `list` to assess how to push to git servers.
+/// we are therefore running it this way in our tests
+fn cli_tester_after_nostr_fetch_and_sent_list_for_push_responds(
+    git_repo: &GitTestRepo,
+) -> Result<CliTester> {
+    let mut p = cli_tester_after_fetch(git_repo)?;
+
+    p.send_line("list for-push")?;
+    p.expect_eventually_and_print("\r\n\r\n")?;
+    Ok(p)
+}
+
 async fn generate_repo_with_state_event() -> Result<(nostr::Event, GitTestRepo)> {
     let git_repo = prep_git_repo()?;
     git_repo.create_branch("example-branch")?;
@@ -93,12 +106,11 @@ async fn generate_repo_with_state_event() -> Result<(nostr::Event, GitTestRepo)>
     r55.events = events;
 
     let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
-        let mut p = cli_tester_after_fetch(&git_repo)?;
+        let mut p = cli_tester_after_nostr_fetch_and_sent_list_for_push_responds(&git_repo)?;
         p.send_line("push refs/heads/main:refs/heads/main")?;
         p.send_line("")?;
-        p.expect("ok refs/heads/main\r\n")?;
-        p.expect("\r\n")?;
-
+        // p.expect("ok refs/heads/main\r\n")?;
+        p.expect_eventually_and_print("\r\n\r\n")?;
         p.exit()?;
         for p in [51, 52, 53, 55, 56, 57] {
             relay::shutdown_relay(8000 + p)?;
@@ -574,19 +586,12 @@ mod push {
 
     use super::*;
 
-    /// git runs `list for-push` before `push`. in `push` we use the git server
-    /// remote refs downloaded by `list` to assess how to push to git servers.
-    /// we are therefore running it this way in our tests
-    fn cli_tester_after_nostr_fetch_and_sent_list_for_push_responds(
-        git_repo: &GitTestRepo,
-    ) -> Result<CliTester> {
-        let mut p = cli_tester_after_fetch(git_repo)?;
-
-        p.send_line("list for-push")?;
-        p.expect_eventually_and_print("\r\n\r\n")?;
-        Ok(p)
+    #[tokio::test]
+    #[serial]
+    async fn new_branch_when_no_state_event_exists() -> Result<()> {
+        generate_repo_with_state_event().await?;
+        Ok(())
     }
-
     mod two_branches_in_batch_one_added_one_updated {
 
         use super::*;
@@ -861,7 +866,7 @@ mod push {
                 p.send_line("push refs/heads/main:refs/heads/main")?;
                 p.send_line("push refs/heads/vnext:refs/heads/vnext")?;
                 p.send_line("")?;
-                p.expect_eventually("\r\n\r\n")?;
+                p.expect_eventually_and_print("\r\n\r\n")?;
                 p.exit()?;
                 for p in [51, 52, 53, 55, 56, 57] {
                     relay::shutdown_relay(8000 + p)?;
@@ -1073,7 +1078,7 @@ mod push {
                     cli_tester_after_nostr_fetch_and_sent_list_for_push_responds(&git_repo)?;
                 p.send_line("push :refs/heads/vnext")?;
                 p.send_line("")?;
-                p.expect_eventually("\r\n\r\n")?;
+                p.expect_eventually_and_print("\r\n\r\n")?;
                 p.exit()?;
                 for p in [51, 52, 53, 55, 56, 57] {
                     relay::shutdown_relay(8000 + p)?;
@@ -1238,80 +1243,172 @@ mod push {
             Ok(())
         }
 
-        #[tokio::test]
-        #[serial]
-        async fn existing_state_event_updated_with_branch_deleted_and_ok_printed() -> Result<()> {
-            let (state_event, source_git_repo) = generate_repo_with_state_event().await?;
+        mod when_existing_state_event {
+            use super::*;
 
-            let git_repo = prep_git_repo()?;
-            let main_commit_id = git_repo.get_tip_of_local_branch("main")?.to_string(); // same as example
+            #[tokio::test]
+            #[serial]
+            async fn state_event_updated_and_branch_deleted_and_ok_printed() -> Result<()> {
+                let (state_event, source_git_repo) = generate_repo_with_state_event().await?;
 
-            let events = vec![
-                generate_test_key_1_metadata_event("fred"),
-                generate_test_key_1_relay_list_event(),
-                generate_repo_ref_event_with_git_server(vec![
-                    source_git_repo.dir.to_str().unwrap().to_string(),
-                ]),
-                state_event.clone(),
-            ];
+                let git_repo = prep_git_repo()?;
+                let main_commit_id = git_repo.get_tip_of_local_branch("main")?.to_string(); // same as example
 
-            // 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, None),
-                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),
-            );
-            r51.events = events.clone();
-            r55.events = events;
+                let events = vec![
+                    generate_test_key_1_metadata_event("fred"),
+                    generate_test_key_1_relay_list_event(),
+                    generate_repo_ref_event_with_git_server(vec![
+                        source_git_repo.dir.to_str().unwrap().to_string(),
+                    ]),
+                    state_event.clone(),
+                ];
 
-            let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
-                let mut p =
-                    cli_tester_after_nostr_fetch_and_sent_list_for_push_responds(&git_repo)?;
-                p.send_line("push :refs/heads/example-branch")?;
-                p.send_line("")?;
-                p.expect("ok refs/heads/example-branch\r\n")?;
-                p.expect("\r\n")?;
-                p.exit()?;
-                for p in [51, 52, 53, 55, 56, 57] {
-                    relay::shutdown_relay(8000 + p)?;
-                }
-                Ok(())
-            });
-            // launch relays
-            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(),
-            );
+                // 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, None),
+                    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),
+                );
+                r51.events = events.clone();
+                r55.events = events;
 
-            cli_tester_handle.join().unwrap()?;
+                let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
+                    let mut p =
+                        cli_tester_after_nostr_fetch_and_sent_list_for_push_responds(&git_repo)?;
+                    p.send_line("push :refs/heads/example-branch")?;
+                    p.send_line("")?;
+                    p.expect("ok refs/heads/example-branch\r\n")?;
+                    p.expect("\r\n")?;
+                    p.exit()?;
+                    for p in [51, 52, 53, 55, 56, 57] {
+                        relay::shutdown_relay(8000 + p)?;
+                    }
+                    Ok(())
+                });
+                // launch relays
+                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(),
+                );
 
-            let state_event = r56
-                .events
-                .iter()
-                .find(|e| e.kind().eq(&STATE_KIND))
-                .context("state event not created")?;
+                cli_tester_handle.join().unwrap()?;
 
-            // println!("{:#?}", state_event);
-            assert_eq!(
-                state_event
-                    .tags
+                let state_event = r56
+                    .events
                     .iter()
-                    .filter(|t| t.kind().to_string().as_str().ne("d"))
-                    .map(|t| t.as_vec().to_vec())
-                    .collect::<HashSet<Vec<String>>>(),
-                HashSet::from([
-                    vec!["HEAD".to_string(), "ref: refs/heads/main".to_string()],
-                    vec!["refs/heads/main".to_string(), main_commit_id.to_string()],
-                ]),
-            );
-            Ok(())
+                    .find(|e| e.kind().eq(&STATE_KIND))
+                    .context("state event not created")?;
+
+                // println!("{:#?}", state_event);
+                assert_eq!(
+                    state_event
+                        .tags
+                        .iter()
+                        .filter(|t| t.kind().to_string().as_str().ne("d"))
+                        .map(|t| t.as_vec().to_vec())
+                        .collect::<HashSet<Vec<String>>>(),
+                    HashSet::from([
+                        vec!["HEAD".to_string(), "ref: refs/heads/main".to_string()],
+                        vec!["refs/heads/main".to_string(), main_commit_id.to_string()],
+                    ]),
+                );
+                Ok(())
+            }
+
+            mod already_deleted_on_git_server {
+                use super::*;
+
+                #[tokio::test]
+                #[serial]
+                async fn existing_state_event_updated_and_ok_printed() -> Result<()> {
+                    let (state_event, source_git_repo) = generate_repo_with_state_event().await?;
+
+                    {
+                        // delete branch on git server
+                        let tmp_repo = GitTestRepo::clone_repo(&source_git_repo)?;
+                        let mut remote = tmp_repo.git_repo.find_remote("origin")?;
+                        remote.push(&[":refs/heads/example-branch"], None)?;
+                    }
+
+                    let git_repo = prep_git_repo()?;
+                    let main_commit_id = git_repo.get_tip_of_local_branch("main")?.to_string(); // same as example
+
+                    let events = vec![
+                        generate_test_key_1_metadata_event("fred"),
+                        generate_test_key_1_relay_list_event(),
+                        generate_repo_ref_event_with_git_server(vec![
+                            source_git_repo.dir.to_str().unwrap().to_string(),
+                        ]),
+                        state_event.clone(),
+                    ];
+
+                    // 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, None),
+                        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),
+                    );
+                    r51.events = events.clone();
+                    r55.events = events;
+
+                    let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
+                        let mut p = cli_tester_after_nostr_fetch_and_sent_list_for_push_responds(
+                            &git_repo,
+                        )?;
+                        p.send_line("push :refs/heads/example-branch")?;
+                        p.send_line("")?;
+                        p.expect("ok refs/heads/example-branch\r\n")?;
+                        p.expect("\r\n")?;
+                        p.exit()?;
+                        for p in [51, 52, 53, 55, 56, 57] {
+                            relay::shutdown_relay(8000 + p)?;
+                        }
+                        Ok(())
+                    });
+                    // launch relays
+                    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()?;
+
+                    let state_event = r56
+                        .events
+                        .iter()
+                        .find(|e| e.kind().eq(&STATE_KIND))
+                        .context("state event not created")?;
+
+                    // println!("{:#?}", state_event);
+                    assert_eq!(
+                        state_event
+                            .tags
+                            .iter()
+                            .filter(|t| t.kind().to_string().as_str().ne("d"))
+                            .map(|t| t.as_vec().to_vec())
+                            .collect::<HashSet<Vec<String>>>(),
+                        HashSet::from([
+                            vec!["HEAD".to_string(), "ref: refs/heads/main".to_string()],
+                            vec!["refs/heads/main".to_string(), main_commit_id.to_string()],
+                        ]),
+                    );
+                    Ok(())
+                }
+            }
         }
     }