//! oxygen#162: a subrepo pin moved by work inside the subrepo is a change

//! the parent's next commit records; `oxy status` and `oxy commit` say so,

//! and say when a subrepo holds uncommitted edits of its own.

use std::path::Path;

use std::process::Command;

fn oxy(dir: &Path, home: &Path, args: &[&str]) -> (i32, String) {

    let out = Command::new(env!("CARGO_BIN_EXE_oxy"))

        .arg("--plain")

        .args(args)

        .current_dir(dir)

        .env("OXY_HOME", home)

        .env("NO_COLOR", "1")

        .output()

        .unwrap();

    let text = format!(

        "{}{}",

        String::from_utf8_lossy(&out.stdout),

        String::from_utf8_lossy(&out.stderr)

    );

    (out.status.code().unwrap_or(-1), text)

}

fn ok(dir: &Path, home: &Path, args: &[&str]) -> String {

    let (code, out) = oxy(dir, home, args);

    assert_eq!(code, 0, "oxy {args:?}: {out}");

    out

}

#[test]

fn moved_pins_and_edits_inside_subrepos_are_named() {

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

    let t = tmp.path();

    let home = t.join("home");

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

    ok(

        t,

        &home,

        &[

            "identity",

            "create",

            "--name",

            "Ada",

            "--email",

            "[email protected]",

        ],

    );

    // The subrepo's own repository, with one change.

    let lib = t.join("lib");

    ok(t, &home, &["init", lib.to_str().unwrap()]);

    std::fs::write(lib.join("lib.txt"), "one\n").unwrap();

    ok(&lib, &home, &["commit", "-m", "lib one"]);

    // The parent pins it.

    let app = t.join("app");

    ok(t, &home, &["init", app.to_str().unwrap()]);

    std::fs::write(app.join("app.txt"), "app\n").unwrap();

    ok(

        &app,

        &home,

        &["submodule", "add", lib.to_str().unwrap(), "deps/lib"],

    );

    ok(&app, &home, &["commit", "-m", "app with lib"]);

    let quiet = ok(&app, &home, &["status"]);

    assert!(!quiet.contains("Subrepo pins"), "{quiet}");

    // Edits inside the subrepo, not committed there: named, not a pin move.

    let inner = app.join("deps/lib");

    std::fs::write(inner.join("lib.txt"), "two\n").unwrap();

    let st = ok(&app, &home, &["status"]);

    assert!(

        st.contains("Subrepo pins") && st.contains("uncommitted edits inside it"),

        "{st}"

    );

    assert!(!st.contains("pin moved"), "{st}");

    // Committed inside: the pin has moved, and a bare commit says it records it.

    ok(&inner, &home, &["commit", "-m", "lib two"]);

    let st = ok(&app, &home, &["status"]);

    assert!(st.contains("deps/lib") && st.contains("pin moved"), "{st}");

    std::fs::write(app.join("app.txt"), "app 2\n").unwrap();

    let by_path = ok(&app, &home, &["commit", "-m", "app only", "app.txt"]);

    assert!(

        !by_path.contains("recorded subrepo"),

        "a commit by path leaves the pin out: {by_path}"

    );

    let bare = ok(&app, &home, &["commit", "-m", "everything"]);

    assert!(

        bare.contains("recorded subrepo deps/lib's pin moving") && bare.contains("a pin bump"),

        "{bare}"

    );

    let after = ok(&app, &home, &["status"]);

    assert!(!after.contains("Subrepo pins"), "recorded: {after}");

}