Land now, over the checks 2a8b621676b4

/// `{"over_checks": "reason"}` lands over required checks that have not

/// passed, for maintainers (#261).

    body: axum::body::Bytes,

    let over_checks: Option<String> = if body.iter().all(u8::is_ascii_whitespace) {

        None

    } else {

        serde_json::from_slice::<serde_json::Value>(&body)

            .map_err(|_| ApiError(StatusCode::BAD_REQUEST, "the body is JSON: {} or {\"over_checks\": \"reason\"}".into()))?

            .get("over_checks")

            .and_then(|v| v.as_str())

            .map(String::from)

    };

    let need = if over_checks.is_some() { Access::Maintain } else { Access::Write };

    let (repo, row, _) = reach(&app, &c, &owner, &name, need).await?;

    match crate::web::proposals::land_as(&app, &repo, &row, &me, number, &via, false, over_checks.as_deref()).await {

    match crate::web::proposals::land_as(app, &cname, consumer, &me, bump.number, via, true, None).await {

    /// The required-checks blocker, also in `blockers`: the one a

    /// maintainer may land over with a reason (#261).

    pub checks_blocker: Option<String>,

        return Ok(Verdict { reviews, approvals, blockers, checks_blocker: None, depends_on: vec![], requirements });

    let mut checks_blocker = None;

            let b = format!("required checks not passed on the projected state: {}", missing.join(", "));

            checks_blocker = Some(b.clone());

            blockers.push(b);

    Ok(Verdict { reviews, approvals, blockers, checks_blocker, depends_on, requirements })

    can_land_over_checks: bool,

    // Checks alone in the way: a maintainer may land over them (#261).

    let can_land_over_checks = role >= Role::Maintain && p.is_open() && v.checks_blocker.is_some() && v.blockers.len() == 1;

        can_land_over_checks,

#[derive(serde::Deserialize)]

pub struct LandForm {

    #[serde(rename = "_csrf")]

    csrf: String,

    /// Why it lands over its required checks (#261), for maintainers.

    #[serde(default)]

    over_checks: Option<String>,

}

    Form(f): Form<LandForm>,

    let need = if f.over_checks.is_some() { Access::Maintain } else { Access::Write };

    let (repo, row, _) = lookup_role(&app, &shell, &viewer, &owner, &name, need).await?;

    match land_as(&app, &repo, &row, &me.account, number, "web", false, f.over_checks.as_deref()).await {

/// key rather than `me`'s delegation (Diffusion's auto-land).

/// `over_checks`, a reason, lands over required checks that have not

/// passed (#261): the caller has checked `me` maintains the repository;

/// every other blocker still holds. Returns the new state.

#[allow(clippy::too_many_arguments)]

    over_checks: Option<&str>,

    }

    let reason = over_checks.map(str::trim);

    if reason == Some("") {

        return Err(refused("Landing over checks needs a reason: say why it can't wait for them".into()));

    let blocking: Vec<&String> = v.blockers.iter().filter(|b| !(reason.is_some() && v.checks_blocker.as_ref() == Some(*b))).collect();

    if !blocking.is_empty() {

        let list: Vec<&str> = blocking.iter().map(|b| b.as_str()).collect();

        return Err(refused(format!("Cannot land: {}", list.join("; "))));

    // Only when the checks were in the way does the landing say so.

    let over = reason.filter(|_| v.checks_blocker.is_some());

    let via_owned = match over {

        Some(r) => format!("{via}, over checks: {r}"),

        None => via.to_string(),

    };

    let via = via_owned.as_str();

    if let (Some(r), Some(checks)) = (over, &v.checks_blocker) {

        accounts::audit(&app.db, Some(me), "proposal.land_over_checks", &format!("{owner}/{name}#{number}"), &format!("{r} ({checks})"))

            .await

            .ok();

    }

    let state = oxygenhub::web::proposals::land_as(&h.app, &repo, &row, &andy, 1, "web", false, None).await.ok().expect("landed");

/// Landing over checks (#261): with required checks not passed, a

/// maintainer may land now with a reason, recorded and audited; a writer

/// may not, nor anyone without a reason.

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

async fn a_maintainer_lands_over_checks_with_a_reason() {

    let h = hub().await;

    let app = &h.app;

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

    let bob = register(app, "bob").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 row = db::repos::get(&app.db, "andy", "demo").await.unwrap().unwrap();

    let bob_id = db::accounts::account_by_name(&app.db, "bob").await.unwrap().unwrap().id;

    db::accounts::set_collaborator(&app.db, row.id, Some(bob_id), None, "write").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(), "b.txt", b"b\n");

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

    client.commit("the fix", &[]).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 r = post(

        app,

        "/andy/demo/proposals/new",

        Some(&andy),

        &format!("_csrf={}&title=Fix&body=&target=main&source=feature", csrf_of(&preview.body)),

    )

    .await;

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

    db::hooks::set_required_checks(&app.db, row.id, &["flow/test".to_string()]).await.unwrap();

    // The checks block it; the maintainer is offered landing over them.

    let page = get(app, "/andy/demo/proposal/1", Some(&andy)).await;

    assert!(page.body.contains("required checks not passed") && page.body.contains("Land now, over the checks"), "{}", page.body);

    let csrf = csrf_of(&page.body);

    let r = act(app, "/andy/demo/proposal/1/land", Some(&andy), &format!("_csrf={csrf}")).await;

    assert!(r.body.contains("Cannot land: required checks not passed"), "plain land is refused: {}", r.body);

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

    // A writer is not offered it and cannot do it.

    let bob_page = get(app, "/andy/demo/proposal/1", Some(&bob)).await;

    assert!(!bob_page.body.contains("Land now, over the checks"));

    let r = post(app, "/andy/demo/proposal/1/land", Some(&bob), &format!("_csrf={}&over_checks=please", csrf_of(&bob_page.body))).await;

    assert_eq!(r.status, StatusCode::NOT_FOUND, "a writer cannot land over checks");

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

    // No reason, no landing.

    let r = act(app, "/andy/demo/proposal/1/land", Some(&andy), &format!("_csrf={csrf}&over_checks=+")).await;

    assert!(r.body.contains("needs a reason"), "{}", r.body);

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

    // With one: landed, and it says so.

    let r = act(app, "/andy/demo/proposal/1/land", Some(&andy), &format!("_csrf={csrf}&over_checks=the+runners+are+down")).await;

    assert!(r.body.contains("over checks: the runners are down"), "the landing says so: {}", r.body);

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

    assert_eq!(p.state, "landed");

    assert!(p.landed_via.contains("over checks: the runners are down"), "{}", p.landed_via);

    let audit = db::accounts::audit_rows(&app.db, 20).await.unwrap();

    assert!(audit

        .iter()

        .any(|a| a.action == "proposal.land_over_checks" && a.detail.contains("the runners are down") && a.detail.contains("flow/test")));

}

    Land {

        number: i64,

        /// Land before its required checks pass, saying why (maintainers;

        /// recorded and audited, #261)

        #[arg(long, value_name = "REASON")]

        over_checks: Option<String>,

    },

        ProposalCmd::Land { number, over_checks } => {

            let body = match &over_checks {

                Some(r) => serde_json::json!({ "over_checks": r }),

                None => serde_json::json!({}),

            };

            let p: Proposal = c.send("POST", &format!("{base}/proposals/{number}/land"), &body)?;

**Landing over checks** (oxygenhub#261). When required checks are the only thing in the way (pending or failed on the projected state, for instance with the runners down and the fix in this very proposal), a repository maintainer or admin may land now with a reason: *Land now, over the checks* on the proposal (a reason field, and a confirmation), `POST /repos/{owner}/{name}/proposals/{n}/land` with `{"over_checks": "REASON"}`, or `oh proposal land N --over-checks REASON`. Only the checks are passed over: approvals, code owners, changes requested, drafts, dependencies and the trust policy still apply, a writer is refused, and an empty reason is refused. How it landed says so ("web, over checks: the runners are down"), on the proposal, its timeline and the pushes page, and it is audited (`proposal.land_over_checks`, with the reason and the checks that had not passed).

    {% if can_land_over_checks && hub_can_land %}<details class="land-over"><summary class="small">Land now, over the checks</summary>

      <form method="post" action="{{ repo.url }}/proposal/{{ p.number }}/land" data-confirm="Land #{{ p.number }} before its required checks pass?"><input type="hidden" name="_csrf" value="{{ shell.csrf }}">

        <label for="over-checks" class="small">Why it can't wait for them (shown on the proposal, and audited)</label>

        <input type="text" id="over-checks" name="over_checks" required maxlength="300" placeholder="the runners are down; this is the fix">

        <button type="submit" class="danger-btn" data-busy="LANDING">LAND OVER CHECKS</button>

      </form></details>{% endif %}

/* Landing over required checks (#261): behind a toggle, with its reason. */

details.land-over { margin-top: 10px; }

details.land-over > summary { cursor: pointer; color: var(--mute); }

details.land-over form { display: flex; flex-direction: column; gap: 6px; margin-top: 6px; }