A pass on the same state is reused from any repository on the hub, public or with the same owner, after the fork line (refs #296) 91c306aa4706

- **A pass on the same state is reused from any repository on the hub (#296).** After the repository's own runs and the line it was forked from, a push's job with no pass of its own on that state reuses one from any other repository holding the same state, public or with the same owner, newest first: a state is its changes, so whoever proved it, the proof holds. The run page and the check say whose pass it was.

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

/// repository on the hub (#296): a state is its changes, so whoever proved

/// it, the proof holds here. Only from a repository that is public or has

/// this one's owner, newest first. After [`passed_upstream`], which

/// prefers the repository's own line.

pub async fn passed_elsewhere(

    pool: &Pool,

    repo: &super::repos::RepoRow,

    state: &str,

    name: &str,

    spec: &str,

    sandbox: &str,

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

    #[derive(FromRow)]

    struct Pass {

        owner: String,

        name: String,

        number: i64,

        receipt: String,

        receipt_hash: String,

        receipt_attest: String,

        receipt_signer: String,

        receipt_note: String,

    }

    let pass: Option<Pass> = sqlx::query_as(

        "SELECT o.owner, o.name, r.number, j.receipt, j.receipt_hash, j.receipt_attest, j.receipt_signer, j.receipt_note \

         FROM flow_jobs j JOIN flow_runs r ON r.id = j.run_id JOIN repositories o ON o.id = r.repo_id \

         WHERE r.state = $1 AND j.name = $2 AND j.spec = $3 AND j.sandbox = $4 AND j.status = 'passed' \

           AND o.id <> $5 AND (o.visibility = 'public' OR o.owner = $6) \

         ORDER BY j.id DESC LIMIT 1",

    )

    .bind(state)

    .bind(name)

    .bind(spec)

    .bind(sandbox)

    .bind(repo.id)

    .bind(&repo.owner)

    .fetch_optional(pool)

    .await?;

    Ok(pass.map(|p| Reused {

        repo: Some(format!("{}/{}", p.owner, p.name)),

        run_number: p.number,

        receipt: p.receipt,

        receipt_hash: p.receipt_hash,

        receipt_attest: p.receipt_attest,

        receipt_signer: p.receipt_signer,

        receipt_note: p.receipt_note,

    }))

}

                    // A fork starts green where upstream proved this state, and

                    // any repository where another on the hub did (#296).

                    if j.reused.is_none() {

                        j.reused =

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

                    }

    // Any repository on the hub holding the same state, not only forks:

    // carol's, which no one forked, starts green from a public pass.

    for who in ["carol"] {

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

    }

    let push_to = |owner: &'static str, name: &'static str| {

        let (app, base) = (h.app.clone(), h.base.clone());

        let path = work.path().to_path_buf();

        async move {

            create(&app, owner, name).await;

            let r = db::repos::get(&app.db, owner, name).await.unwrap().unwrap();

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

            let mut c = Repo::open(&path).unwrap();

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

            c.save_config().unwrap();

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

            let run = runs_of(&app, owner, name).await.remove(0);

            db::flow::jobs(&app.db, run.id).await.unwrap()

        }

    };

    let jobs = push_to("carol", "tetris-clone").await;

    assert!(jobs.iter().all(|j| j.status == "passed" && j.reused_repo().is_some()), "{jobs:?}");

    // Every repository holding those passes private, and none of them

    // carol's: her next repository runs its own.

    sqlx::query("UPDATE repositories SET visibility = 'private' WHERE owner IN ('andy', 'bob')").execute(&h.app.db).await.unwrap();

    sqlx::query("UPDATE repositories SET visibility = 'private' WHERE owner = 'carol'").execute(&h.app.db).await.unwrap();

    sqlx::query("DELETE FROM flow_jobs WHERE run_id IN (SELECT id FROM flow_runs WHERE repo_id IN (SELECT id FROM repositories WHERE owner = 'carol'))")

        .execute(&h.app.db)

        .await

        .unwrap();

    let jobs = push_to("carol", "another").await;