Drops are backed up and restored as drops (refs #280) 9041db4e4d92

- **Drops are backed up (#280):** an owner's backups now include its drops, each copied like a repository and restored as a drop (secret or public, with its title and description); Admin › Backups counts them with the repositories they cover.

        sqlx::query_as("SELECT owner, COUNT(*) FROM repositories GROUP BY owner ORDER BY owner").fetch_all(pool).await?;

        let repos = db::repos::list_with_drops(pool).await?.iter().filter(|r| r.owner == s.owner && included(&s, r, false)).count() as i64;

}

/// A repository's name as one key segment: a drop's `drops/ID` becomes

/// `drops~ID` (#280), so a run's manifests and records stay one level deep;

/// the files inside keep the real name, which restore uses.

fn key_name(name: &str) -> String {

    name.replace('/', "~")

    // Its repositories and drops (#280), but those left out (§5).

        db::repos::list_with_drops(&app.db).await?.into_iter().filter(|r| r.owner == s.owner && included(s, r, by_hand)).collect();

                    let key = format!("runs/{at}/repos/{kind}-{}.json", key_name(&row.name));

                tokio::task::block_in_place(|| {

                    dest.put(&format!("runs/{at}/records/{}.json", key_name(&row.name)), &serde_json::to_vec(&r)?)

                })?;

/// oxygenhub#280: an owner's drops are in its backups, and come back as

/// drops: their kind, secrecy and title with their store.

async fn drops_are_backed_up_and_restored_as_drops() {

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

    let h = hub(store.path()).await;

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

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

    let id = "0123456789abcdef01234567";

    let name = RepoName::drop("andy", id).unwrap();

    h.app.repos.create(&name, None).unwrap();

    db::repos::create_drop(&h.app.db, "andy", id, "Notes", "a secret drop", hub_api::Visibility::Private).await.unwrap();

    let mut s = Setting::off("andy", "user");

    s.every = "hourly".into();

    s.target = store.path().display().to_string();

    backups::save(&h.app.db, &s).await.unwrap();

    let run = backups::run(&h.app, "andy", "now").await.unwrap();

    assert_eq!(run.status, "ok", "{}", run.detail);

    let dest = Directory { root: store.path().join("andy") };

    let repos = dest.list(&format!("runs/{}/repos", run.at)).unwrap();

    assert!(repos.contains(&format!("repos-drops~{id}.json")), "the drop's manifest, one level deep: {repos:?}");

    assert!(dest.list(&format!("runs/{}/records", run.at)).unwrap().contains(&format!("drops~{id}.json")));

    let (overview, _) = backups::overview(&h.app.db).await.unwrap();

    assert_eq!(overview[0].repos, 2, "the repository and the drop");

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

    let fresh = hub(empty.path()).await;

    db::accounts::create_account(&fresh.app.db, "andy", "[email protected]", "x", "salt", false).await.unwrap();

    let dest: Arc<dyn Destination> = Arc::new(Directory { root: store.path().join("andy") });

    let done = backups::restore_into_hub(&fresh.app, dest, None).await.unwrap();

    assert!(done.contains(&format!("andy/drops/{id} (repos)")), "{done:?}");

    assert!(fresh.app.repos.exists(&name), "the drop's store");

    let back = db::repos::drop_by_id(&fresh.app.db, id).await.unwrap().expect("the drop's row");

    assert!(back.is_drop() && back.visibility == "private" && back.title == "Notes", "{back:?}");

    assert!(db::repos::list(&fresh.app.db).await.unwrap().iter().all(|r| !r.is_drop()), "still no drop among repositories");

}

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

For each repository the owner has (a user's own, or an organisation's), and each of its drops (#280: a drop is a small repository of its own, kept as `repos-drops~ID` and `records/drops~ID` so its name stays one key deep, and restored as a drop, secret or public, with its title):