oxy-server: a host can add a note to a reference a push moved (closes #148) 642fa213de80

- **A server can add a note to a reference a push moved (#148).** `oxy-server`'s `Backend` has a `push_notes` step: each note is added to that accepted reference's result, which `oxy push` shows in place of "updated". OxygenHub will use it to say when a push moves the bookmark of a proposal that has already landed (oxygenhub#329).

    /// Notes for the pusher on references this push moved: each

    /// `(reference, note)` is added to that accepted reference's result,

    /// which a client shows beside it (`Pushed origin/x - note`). For a

    /// push that did what the pusher may not expect, say moving the

    /// bookmark of a proposal that has landed (oxygenhub#329, #148). Called

    /// before [`Backend::after_push`], which sees the notes.

    fn push_notes(

        &self,

        _name: &str,

        _report: &oxy_core::repo::PushReport,

        _headers: &HeaderMap,

    ) -> Vec<(String, String)> {

        Vec::new()

    }

                }

                for (reference, note) in self.backend.push_notes(name, &report, headers) {

                    if let Some(r) = report

                        .results

                        .iter_mut()

                        .find(|r| r.ok && r.name == reference)

                    {

                        r.reason = if r.reason.is_empty() {

                            note

                        } else {

                            format!("{}; {note}", r.reason)

                        };

                    }

/// A host adds a note to a reference a push moved (`Backend::push_notes`):

/// the client gets it as that reference's result, accepted as before,

/// and the host's `after_push` sees it too; a reference with no note

/// says nothing more.

#[test]

fn a_host_adds_a_note_to_an_accepted_reference() {

    use axum::extract::{Path as AxPath, State};

    use axum::http::{HeaderMap, Method};

    use axum::response::Response;

    use oxy_core::repo::PushReport;

    use oxy_server::{Access, Backend, DirBackend, Endpoint, Failure, Server};

    use std::sync::{Arc, Mutex};

    struct Noting(DirBackend, Arc<Mutex<Vec<String>>>);

    impl Backend for Noting {

        fn open(&self, name: &str) -> Result<Repo, Failure> {

            self.0.open(name)

        }

        fn authorize(

            &self,

            name: &str,

            access: Access,

            headers: &HeaderMap,

        ) -> Result<(), Failure> {

            self.0.authorize(name, access, headers)

        }

        fn push_notes(

            &self,

            _name: &str,

            report: &PushReport,

            _headers: &HeaderMap,

        ) -> Vec<(String, String)> {

            report

                .updated

                .iter()

                .filter(|u| u.name == "feature")

                .map(|u| (u.name.clone(), "its proposal #3 has landed".to_string()))

                .collect()

        }

        fn after_push(&self, _name: &str, report: &PushReport, _headers: &HeaderMap) {

            let mut seen = self.1.lock().unwrap();

            seen.extend(report.results.iter().map(|r| r.reason.clone()));

        }

    }

    async fn route(

        State(server): State<Arc<Server>>,

        AxPath((repo, endpoint)): AxPath<(String, String)>,

        method: Method,

        headers: HeaderMap,

        body: axum::body::Bytes,

    ) -> Response {

        let e = Endpoint::parse(&endpoint).unwrap();

        server.handle(repo, e, &method, &headers, body).await

    }

    hermetic();

    let dir = tempfile::tempdir().unwrap();

    let root = dir.path();

    let served = root.join("served");

    Repo::init_bare_unbound(&served.join("lib")).unwrap();

    let seen = Arc::new(Mutex::new(Vec::new()));

    let server = Server::new(Noting(

        DirBackend {

            root: served.clone(),

            tokens: vec![],

        },

        seen.clone(),

    ));

    let listener = TcpListener::bind("127.0.0.1:0").unwrap();

    let port = listener.local_addr().unwrap().port();

    std::thread::spawn(move || {

        let rt = tokio::runtime::Builder::new_multi_thread()

            .enable_all()

            .build()

            .unwrap();

        rt.block_on(async move {

            listener.set_nonblocking(true).unwrap();

            let app = axum::Router::new()

                .route("/{repo}/oxy/v1/{endpoint}", axum::routing::any(route))

                .with_state(server);

            axum::serve(tokio::net::TcpListener::from_std(listener).unwrap(), app)

                .await

                .unwrap();

        });

    });

    std::thread::sleep(std::time::Duration::from_millis(50));

    let url = format!("http://127.0.0.1:{port}/lib");

    let work = root.join("work");

    let mut local = Repo::init(&work).unwrap();

    local.config.set("remote.origin.url", &url).unwrap();

    local.save_config().unwrap();

    write(&work, "a.txt", b"one\n");

    local.snapshot("test").unwrap();

    let base = local.commit("a", &[]).unwrap();

    let results = local.push("origin", false).unwrap();

    assert!(

        results.iter().all(|r| r.ok && r.reason.is_empty()),

        "{results:?}"

    );

    local.bookmark_create("feature", Some(&[base])).unwrap();

    local.bookmark_switch("feature", false).unwrap();

    write(&work, "a.txt", b"one\ntwo\n");

    local.snapshot("test").unwrap();

    local.commit("two", &[]).unwrap();

    let results = local.push_bookmark("origin", "feature", false).unwrap();

    let feature = results.iter().find(|r| r.name == "feature").unwrap();

    assert!(feature.ok, "{results:?}");

    assert_eq!(feature.reason, "its proposal #3 has landed");

    assert!(seen

        .lock()

        .unwrap()

        .iter()

        .any(|r| r == "its proposal #3 has landed"));

}

text, several lines perhaps, the client shows as it is; spec §16.4; and `push_notes`, with which a host adds a note to a reference the push moved, which the client shows in place of "updated", #148), so a hub with `owner/name` paths and its own accounts