feat(remote): `push` handle out-of-sync servers

1. don't attempt to push to a remote which is already up-to-date
2. don't attempt to delete branch on remote if it is already deleted
3. only push when out of sync if remote tip is ancestor of pushed
   commit
4. force push to remote if user force pushed and remote is in sync
   with nostr

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(())
+                }
+            }
         }
     }