A fork starts green where upstream proved the same state: a job with no pass of its own reuses one from the repositories it was forked from, public or the fork owner's, and says whose (refs #296) 42cd46c9b09e

- **A fork starts green where upstream proved the same state (#296, first slice).** Pass reuse (#265) looked in the repository's own runs only. A push's job with no pass of its own on that state now reuses one from the repositories it was forked from, nearest first (up to five up): the same state is the same changes, so upstream's receipt stands for it. Only from an upstream that is public or has the fork's owner. The run page says whose pass it was and links to it, and its check reads "passed in OWNER/NAME run #N on this state, reused".

    /// The run whose pass this job reused (#265), if it did: in this

    /// repository, or in the one [`Job::reused_repo`] names (#296).

        self.error.strip_prefix("reused from ")?.rsplit_once("run #")?.1.parse().ok()

    /// The repository (`owner/name`) whose pass this job reused, when not

    /// its own: a fork reusing what upstream proved (#296).

    pub fn reused_repo(&self) -> Option<&str> {

        let rest = self.error.strip_prefix("reused from ")?;

        let (repo, n) = rest.rsplit_once(" run #")?;

        n.parse::<i64>().ok()?;

        Some(repo).filter(|r| !r.is_empty())

    }

    /// The repository it passed in, `owner/name`, when not this one (#296).

    pub repo: Option<String>,

        match &self.repo {

            Some(r) => format!("reused from {r} run #{}", self.run_number),

            None => format!("reused from run #{}", self.run_number),

        }

        repo: None,

}

/// How far up a fork's line [`passed_upstream`] looks.

const UPSTREAM_DEPTH: usize = 5;

/// A pass of job `name` with this spec and sandbox on `state` in a

/// repository `repo` was forked from, nearest first (#296): the same state

/// is the same changes, so what upstream proved holds for the fork. Only

/// from an upstream that is public or has the fork's owner, so a private

/// repository's receipts never show in another owner's fork.

pub async fn passed_upstream(

    pool: &Pool,

    repo: &super::repos::RepoRow,

    state: &str,

    name: &str,

    spec: &str,

    sandbox: &str,

) -> sqlx::Result<Option<Reused>> {

    let mut parent = repo.forked_from;

    for _ in 0..UPSTREAM_DEPTH {

        let Some(id) = parent else { break };

        let Some(up) = super::repos::get_by_id(pool, id).await? else { break };

        parent = up.forked_from;

        if !(up.visibility == "public" || up.owner == repo.owner) {

            continue;

        }

        if let Some(mut r) = passed_on_state(pool, up.id, state, name, spec, sandbox).await? {

            r.repo = Some(format!("{}/{}", up.owner, up.name));

            return Ok(Some(r));

        }

    }

    Ok(None)

                    // A fork starts green where upstream proved this state (#296).

                    if j.reused.is_none() && row.forked_from.is_some() {

                        j.reused =

                            fdb::passed_upstream(&app.db, row, state, &j.name, &j.spec, &j.sandbox).await.map_err(|e| e.to_string())?;

                    }

            "passed" => match (j.reused_from(), j.reused_repo()) {

                (Some(n), Some(r)) => format!("passed in {r} run #{n} on this state, reused"),

                (Some(n), None) => format!("passed in run #{n} on this state, reused"),

                (None, _) => format!("passed in {}", duration(&j)),

/// oxygenhub#296: a fork starts green where upstream proved the same state:

/// its push reuses upstream's passes, says whose, and links to them; never

/// a private upstream's when the fork has another owner.

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

async fn a_fork_reuses_what_upstream_proved() {

    let h = hub().await;

    for who in ["andy", "bob"] {

        db::accounts::create_account(&h.app.db, who, &format!("{who}@example.com"), "x", "salt", true).await.unwrap();

    }

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

    create(&h.app, "bob", "game").await;

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

    let fork = db::repos::get(&h.app.db, "bob", "game").await.unwrap().unwrap();

    db::repos::set_forked_from(&h.app.db, fork.id, up.id).await.unwrap();

    // Flow on for the fork (the test hub allows andy's repositories only).

    sqlx::query("UPDATE repositories SET flow = 'on' WHERE id = $1").bind(fork.id).execute(&h.app.db).await.unwrap();

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

    let mut c = client(&format!("{}/andy/game", h.base), work.path());

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

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

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

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

    let first = runs_of(&h.app, "andy", "game").await.remove(0);

    sqlx::query("UPDATE flow_jobs SET status = 'passed', exit_code = 0, receipt_hash = 'r-' || name WHERE run_id = $1")

        .bind(first.id)

        .execute(&h.app.db)

        .await

        .unwrap();

    // The same changes pushed to the fork: the same state.

    c.config.set("remote.origin.url", &format!("{}/bob/game", h.base)).unwrap();

    c.save_config().unwrap();

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

    let run = runs_of(&h.app, "bob", "game").await.remove(0);

    assert_eq!(run.state, first.state);

    let jobs = db::flow::jobs(&h.app.db, run.id).await.unwrap();

    for j in &jobs {

        assert_eq!((j.status.as_str(), j.reused_from(), j.reused_repo()), ("passed", Some(first.number), Some("andy/game")), "{j:?}");

        assert_eq!(j.receipt_hash, format!("r-{}", j.name));

    }

    let (_, page) = call(&h.app, "GET", &format!("/bob/game/flow/{}", run.number), None, None).await;

    assert!(page.contains(&format!("href=\"/andy/game/flow/{}\">andy/game run #{}</a>", first.number, first.number)), "{page}");

    let checks = db::hooks::checks_for_state(&h.app.db, fork.id, &run.state).await.unwrap();

    assert!(checks.iter().any(|c| c.summary.contains("passed in andy/game run #")), "{checks:?}");

    // A private upstream of another owner: a new fork runs its own.

    sqlx::query("UPDATE repositories SET visibility = 'private' WHERE id = $1").bind(up.id).execute(&h.app.db).await.unwrap();

    create(&h.app, "bob", "game2").await;

    let fork2 = db::repos::get(&h.app.db, "bob", "game2").await.unwrap().unwrap();

    db::repos::set_forked_from(&h.app.db, fork2.id, up.id).await.unwrap();

    sqlx::query("UPDATE repositories SET flow = 'on' WHERE id = $1").bind(fork2.id).execute(&h.app.db).await.unwrap();

    c.config.set("remote.origin.url", &format!("{}/bob/game2", h.base)).unwrap();

    c.save_config().unwrap();

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

    let run2 = runs_of(&h.app, "bob", "game2").await.remove(0);

    assert_eq!(run2.state, first.state);

    let jobs = db::flow::jobs(&h.app.db, run2.id).await.unwrap();

    assert!(jobs.iter().all(|j| j.status == "queued" && j.reused_from().is_none()), "{jobs:?}");

}

  {% if l.j.status == "passed" %}{% if let Some(n) = l.j.reused_from() %}{% if let Some(up) = l.j.reused_repo() %}<p class="small mute pad" data-reused>Not run again: this job, with the same spec and sandbox, passed on this very state upstream, in <a href="/{{ up }}/flow/{{ n }}">{{ up }} run #{{ n }}</a>; the same state is the same changes, so that pass's receipt stands for it here.</p>{% else %}<p class="small mute pad" data-reused>Not run again: this job, with the same spec and sandbox, passed on this very state in <a href="{{ repo.url }}/flow/{{ n }}">run #{{ n }}</a>, whose log it would repeat; that pass's receipt stands for it here.</p>{% endif %}{% endif %}{% endif %}