A landed proposal runs its target's pipeline f7bcee49bf24

    // ...and its pipeline runs, as a push of the same heads would start it

    // (#197): without the run a consumer following it when green would wait

    // for a state that never runs.

    crate::flow::on_push(app, row, &p.target, &state, &loaded.heads, &me.username).await;

            let st = finish(h_app, id, serde_json::json!({ "exit_code": 0, "duration_ms": 10, "receipt": receipt(&name, &ph, 0) })).await;

            // A run started in the background (a bump, a landing's run, #197)

            // may supersede the one this job belongs to between its claim and

            // its finish; then, and only then, the hub refuses the finish.

            if st == StatusCode::CONFLICT {

                let job = db::flow::job(&h_app.db, id).await.unwrap().unwrap();

                assert_eq!(job.status, "cancelled", "refused only because a newer run cancelled it");

                continue;

            }

            assert_eq!(st, StatusCode::NO_CONTENT);

}

/// #197: landing a proposal moves its target as a push does, so the

/// target's pipeline runs on the landed state.

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

async fn a_landed_proposal_runs_its_targets_pipeline() {

    let h = hub().await;

    create(&h.app, "andy", "demo").await;

    let url = format!("{}/andy/demo", h.base);

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

    let mut c = client(&url, work.path());

    write(work.path(), ".flow/pipeline.kdl", &pipeline(""));

    write(work.path(), "test.sh", "echo ok\n");

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

    c.commit("Add a pipeline", &[]).unwrap();

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

    assert_eq!(runs_of(&h.app, "andy", "demo").await.len(), 1);

    c.bookmark_create("feature", None).unwrap();

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

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

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

    c.commit("More", &[]).unwrap();

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

    let runs_before =

        db::flow::runs(&h.app.db, db::repos::get(&h.app.db, "andy", "demo").await.unwrap().unwrap().id, 10, None).await.unwrap().len();

    let andy = db::accounts::create_account(&h.app.db, "andy", "[email protected]", "x", "salt", true).await.unwrap();

    let row = db::repos::get(&h.app.db, "andy", "demo").await.unwrap().unwrap();

    db::proposals::create(

        &h.app.db,

        db::proposals::NewProposal {

            repo_id: row.id,

            title: "More",

            body: "",

            author_id: Some(andy.id),

            author: "andy",

            draft: false,

            target: "main",

            source_kind: "bookmark",

            source_repo_id: Some(row.id),

            source_bookmark: "feature",

            source_changes: "",

        },

    )

    .await

    .unwrap();

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

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

    let mut runs = vec![];

    for _ in 0..100 {

        runs = db::flow::runs(&h.app.db, row.id, 10, None).await.unwrap();

        if runs.len() > runs_before {

            break;

        }

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

    }

    let landed = runs.iter().find(|r| r.bookmark == "main" && r.state == state).expect("a run of the landed state on main");

    assert_eq!((landed.trigger.as_str(), landed.actor.as_str()), ("push", "andy"));