Say which bookmark pull pulled, and which are left behind 7d9dab131937

/// oxygen#29 (metalgear, rstar-api): after a proposal landed on the hub,

/// moving `main` to a change this clone had pushed on another bookmark,

/// the first `pull` said "Already up to date" while `main` was behind.

#[test]

fn pull_takes_a_remote_move_to_changes_already_here() {

    hermetic();

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

    let root = dir.path();

    let origin_path = root.join("origin");

    let origin = Repo::init(&origin_path).unwrap();

    let url = origin_path.to_string_lossy().to_string();

    let mut b = Repo::clone(&url, &root.join("b")).unwrap();

    write(&root.join("b"), "base.txt", b"base\n");

    b.commit("base", &[]).unwrap();

    assert!(b.push("origin", false).unwrap()[0].ok);

    // A feature bookmark with one change, pushed.

    b.bookmark_create("feat", None).unwrap();

    b.bookmark_switch("feat", false).unwrap();

    write(&root.join("b"), "x.txt", b"x\n");

    let x = b.commit("x", &[]).unwrap();

    assert!(b.push("origin", false).unwrap()[0].ok);

    b.bookmark_switch("main", false).unwrap();

    // The remote lands it: its main moves to the feature's state.

    let feat = origin

        .store()

        .get_state(&origin.view().unwrap().bookmarks["feat"])

        .unwrap()

        .heads;

    origin.bookmark_set("main", &feat).unwrap();

    let r = b.pull("origin").unwrap();

    assert!(r.changed, "{r:?}");

    assert!(r.heads.contains(&x) || b.load_state(&r.heads).unwrap().contains(&x));

    let main = b

        .bookmarks()

        .unwrap()

        .into_iter()

        .find(|m| m.name == "main")

        .unwrap();

    assert_eq!(main.behind, Some(0), "{main:?}");

}

/// Pull acts on the current bookmark only: name the others the fetch

/// found behind their remote, which is easy to take for the current one

/// (oxygen#29).

fn others_behind(repo: &oxy_core::repo::Repo, remote: &str) {

    let Ok(bookmarks) = repo.bookmarks() else {

        return;

    };

    for b in bookmarks {

        let Some(n) = b.behind.filter(|n| *n > 0) else {

            continue;

        };

        if b.current {

            continue;

        }

        println!(

            "  {} {}",

            ui::note(),

            ui::dim(format!(

                "{} is {} behind {remote}/{}: oxy bookmark switch {} then oxy pull to take {}",

                b.name,

                plural(n, "change"),

                b.name,

                b.name,

                if n == 1 { "it" } else { "them" }

            ))

        );

    }

}

                ("bookmark", json::s(&repo.config.bookmark)),

            ui::dim(format!(

                "{} is up to date with {remote}.",

                repo.config.bookmark

            ))

        others_behind(&repo, &remote);

    others_behind(&repo, &remote);

/// oxygen#29: pull acts on the current bookmark; a pull on a feature

/// bookmark said only "Already up to date" while main was behind.

#[test]

fn pull_names_its_bookmark_and_the_others_left_behind() {

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

    let home = tmp.path().join("home");

    std::fs::create_dir_all(&home).unwrap();

    let origin = tmp.path().join("origin");

    assert_eq!(

        oxy(tmp.path(), &home, &["init", origin.to_str().unwrap()]).0,

        0

    );

    let (a, b) = (tmp.path().join("a"), tmp.path().join("b"));

    for d in [&a, &b] {

        assert_eq!(

            oxy(

                tmp.path(),

                &home,

                &["clone", origin.to_str().unwrap(), d.to_str().unwrap()]

            )

            .0,

            0

        );

    }

    write(&a, "one.txt", "one\n");

    assert_eq!(oxy(&a, &home, &["commit", "-m", "one"]).0, 0);

    assert_eq!(oxy(&a, &home, &["push"]).0, 0);

    assert_eq!(oxy(&b, &home, &["pull"]).0, 0);

    assert_eq!(oxy(&b, &home, &["bookmark", "create", "feat"]).0, 0);

    assert_eq!(oxy(&b, &home, &["bookmark", "switch", "feat"]).0, 0);

    assert_eq!(oxy(&b, &home, &["push", "-b", "feat"]).0, 0);

    write(&a, "two.txt", "two\n");

    assert_eq!(oxy(&a, &home, &["commit", "-m", "two"]).0, 0);

    assert_eq!(oxy(&a, &home, &["push"]).0, 0);

    let (code, out, err) = oxy(&b, &home, &["pull"]);

    assert_eq!(code, 0, "{err}");

    let out = String::from_utf8_lossy(&out);

    assert!(out.contains("feat is up to date with origin"), "{out}");

    assert!(out.contains("main is 1 change behind origin/main"), "{out}");

}