Proposals: mark landed when their work reaches the target by push ac713df7b38b

                    crate::web::proposals::settle_after_push(&app, &row, bookmark, &actor).await;

    /// Whether its source has any changes at all (#141): an open proposal

    /// whose source has changes, none of them missing from the target, was

    /// landed by some other route.

    pub source_has_changes: bool,

            let source_has_changes = match &source {

                Source::Changes(h) | Source::Bookmark(h) | Source::Fork { heads: h, .. } => !h.is_empty(),

            };

                source_has_changes,

    // Landed by another route (#141): `oxy proposal land` from a client (a

    // repository with a trust policy needs it), or the work merged and

    // pushed by hand. Everything it proposes is in its target, so it is

    // landed, not open with nothing to land.

    let mut loaded = loaded;

    if loaded.row.is_open()

        && loaded.source_has_changes

        && loaded.hashes.is_empty()

        && pdb::set_landed(&app.db, loaded.row.id, &loaded.target_state, "", "push").await.is_ok()

    {

        loaded.row.state = "landed".into();

        loaded.row.landed_via = "push".into();

        loaded.row.landed_state = loaded.target_state.clone();

        return Ok(loaded);

    }

}

/// After a push moved `bookmark`: open proposals into it whose work it now

/// holds are marked landed, by the pusher (#141).

pub async fn settle_after_push(app: &Shared, row: &db::repos::RepoRow, bookmark: &str, actor: &str) {

    let Some(repo) = RepoName::new(&row.owner, &row.name) else { return };

    let Ok(open) = pdb::list(&app.db, row.id, &["open", "draft"]).await else { return };

    for p in open.into_iter().filter(|p| p.target == bookmark) {

        let id = p.id;

        if let Ok(l) = load(app, &repo, p).await {

            if l.row.state == "landed" && l.row.landed_by.is_empty() {

                pdb::set_landed(&app.db, id, &l.target_state, actor, "push").await.ok();

            }

        }

    }

/// #141: a proposal whose work reaches its target another way (a client's

/// `oxy proposal land`, as a trust policy needs, or a merge pushed by hand)

/// is marked landed by that push, not left open with nothing to land.

#[tokio::test(flavor = "multi_thread")]

async fn a_proposal_landed_by_a_push_is_marked_landed() {

    let h = hub().await;

    let app = &h.app;

    let andy = register(app, "andy").await;

    let repo = RepoName::parse("andy/demo").unwrap();

    app.repos.create(&repo, None).unwrap();

    db::repos::create(&app.db, "andy", "demo", "", hub_api::Visibility::Public).await.unwrap();

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

    let mut client = Repo::init(work.path()).unwrap();

    client.create_identity("Andy McCall", "[email protected]", oxy_core::repo::IdentityScope::User).unwrap();

    client.config.set("remote.origin.url", &format!("{}/andy/demo", h.base)).unwrap();

    client.config.set("remote.origin.token", "site").unwrap();

    client.save_config().unwrap();

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

    client.snapshot("t").unwrap();

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

    assert!(client.push("origin", false).unwrap().iter().all(|r| r.ok));

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

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

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

    client.snapshot("t").unwrap();

    let feat = client.commit("add two", &[]).unwrap();

    assert!(client.push_bookmark("origin", "feature", false).unwrap().iter().all(|r| r.ok));

    let preview = get(app, "/andy/demo/proposals/new?source=feature&target=main", Some(&andy)).await;

    let csrf = csrf_of(&preview.body);

    let r = post(app, "/andy/demo/proposals/new", Some(&andy), &format!("_csrf={csrf}&title=Two&body=&target=main&source=feature")).await;

    assert_eq!(r.status, StatusCode::SEE_OTHER, "{}", r.body);

    assert_eq!(db::proposals::get(&app.db, 1, 1).await.unwrap().unwrap().state, "open");

    // The work goes onto main by a push, not by the Land button.

    client.bookmark_set("main", &[feat]).unwrap();

    assert!(client.push_bookmark("origin", "main", false).unwrap().iter().all(|r| r.ok));

    let mut p = db::proposals::get(&app.db, 1, 1).await.unwrap().unwrap();

    for _ in 0..100 {

        if p.state == "landed" {

            break;

        }

        tokio::time::sleep(std::time::Duration::from_millis(50)).await;

        p = db::proposals::get(&app.db, 1, 1).await.unwrap().unwrap();

    }

    assert_eq!((p.state.as_str(), p.landed_via.as_str()), ("landed", "push"), "{p:?}");

}