663 lines
23 KiB
Rust
663 lines
23 KiB
Rust
// tests/m8_6_acceptance.rs --- T M8.6 magit-class git status integration.
|
|
|
|
//! Acceptance for the M8.6 deliverable: wiring the M8.5 foldable
|
|
//! section view to actual `git status` output. Spec acceptance
|
|
//! bullets:
|
|
//!
|
|
//! 1. All five canonical sections render correctly on a typical
|
|
//! repository (working tree, staged, recent commits, branches,
|
|
//! stashes).
|
|
//! 2. Refresh after an external commit reflects the new state
|
|
//! within 500 ms.
|
|
//! 3. Empty sections (no stashes, etc.) render as a one-line
|
|
//! placeholder rather than disappearing.
|
|
//!
|
|
//! Plus regressions:
|
|
//!
|
|
//! * Section IDs are stable across refresh; fold-state is preserved.
|
|
//! * Cursor's section is preserved across refresh.
|
|
//! * Manual refresh-status command works.
|
|
//! * The four parser helpers (porcelain v2, log, branches, stashes)
|
|
//! round-trip canonical inputs without invoking git.
|
|
//! * Non-repo path produces a refresh failure but doesn't crash the
|
|
//! package.
|
|
|
|
use std::path::{Path, PathBuf};
|
|
use std::process::Command;
|
|
use std::time::{Duration, Instant};
|
|
|
|
use pmacs::editor::EditorState;
|
|
use pmacs::lua_bindings::PackageInstallOverride;
|
|
use tempfile::TempDir;
|
|
|
|
fn magit_package_path() -> PathBuf {
|
|
let here = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
|
|
here.join("tests").join("fixtures").join("pmacs-magit")
|
|
}
|
|
|
|
fn pump_until<F: Fn(&EditorState) -> bool>(state: &mut EditorState, predicate: F) {
|
|
pump_until_with_deadline(state, predicate, Duration::from_secs(5));
|
|
}
|
|
|
|
fn pump_until_with_deadline<F: Fn(&EditorState) -> bool>(
|
|
state: &mut EditorState,
|
|
predicate: F,
|
|
timeout: Duration,
|
|
) {
|
|
let deadline = Instant::now() + timeout;
|
|
while !predicate(state) {
|
|
assert!(
|
|
Instant::now() < deadline,
|
|
"async pump deadline exceeded after {timeout:?}"
|
|
);
|
|
// M8.6 runs `git` via pmacs.process.spawn; the supervisor's
|
|
// events (stdout/stderr/exited) only show up if we tick
|
|
// both the async runtime AND the process supervisor each
|
|
// iteration --- the editor's main loop does both per pass
|
|
// (editor.rs:897-898), so tests have to as well.
|
|
state.tick_async();
|
|
state.tick_processes();
|
|
std::thread::sleep(Duration::from_millis(2));
|
|
}
|
|
}
|
|
|
|
fn editor_with_magit() -> (EditorState, TempDir, TempDir) {
|
|
let cache = tempfile::tempdir().expect("cache tempdir");
|
|
let user_root = tempfile::tempdir().expect("user-root tempdir");
|
|
let mut state = EditorState::new_with_roots(&crate::iso::roots());
|
|
state.lua_host.reopen_init_phase_for_testing();
|
|
state.lua_host.set_package_install_override(
|
|
PackageInstallOverride::new()
|
|
.with_cache_dir(cache.path().to_path_buf())
|
|
.with_user_install_root(user_root.path().to_path_buf()),
|
|
);
|
|
let pkg = magit_package_path();
|
|
let pkg_str = pkg.display().to_string();
|
|
let install = format!(
|
|
r#"
|
|
pmacs.packages.install_local("{pkg_str}")
|
|
require("pmacs-magit")
|
|
"#
|
|
);
|
|
state
|
|
.lua_host
|
|
.eval(Some("magit-install"), &install)
|
|
.unwrap_or_else(|e| panic!("install_local + require failed: {e}"));
|
|
(state, cache, user_root)
|
|
}
|
|
|
|
/// Build a small git repo for tests: `git init`, set user, commit a
|
|
/// file. Returns the `TempDir` owning the repo.
|
|
fn make_test_repo() -> TempDir {
|
|
let dir = tempfile::tempdir().expect("tempdir");
|
|
git_run(dir.path(), &["init", "-b", "main"]);
|
|
git_run(dir.path(), &["config", "user.email", "test@example.com"]);
|
|
git_run(dir.path(), &["config", "user.name", "Test User"]);
|
|
std::fs::write(dir.path().join("README.md"), b"hello\n").expect("write README");
|
|
git_run(dir.path(), &["add", "README.md"]);
|
|
git_run(dir.path(), &["commit", "-m", "initial commit"]);
|
|
dir
|
|
}
|
|
|
|
fn git_run(cwd: &Path, args: &[&str]) {
|
|
let status = Command::new("git")
|
|
.args(args)
|
|
.current_dir(cwd)
|
|
.status()
|
|
.unwrap_or_else(|e| panic!("git {args:?} failed to spawn: {e}"));
|
|
assert!(status.success(), "git {args:?} returned {status}");
|
|
}
|
|
|
|
fn open_status(state: &mut EditorState, repo_root: &Path) {
|
|
let chunk = format!(
|
|
r#"
|
|
_G.M8_6_OPEN_DONE = nil
|
|
pmacs.async(function()
|
|
require("pmacs-magit").open_status({path:?})
|
|
_G.M8_6_OPEN_DONE = true
|
|
end)
|
|
"#,
|
|
path = repo_root.display().to_string()
|
|
);
|
|
state
|
|
.lua_host
|
|
.eval(Some("open_status"), &chunk)
|
|
.unwrap_or_else(|e| panic!("open_status eval failed: {e}"));
|
|
pump_until(state, |s| {
|
|
s.lua_host
|
|
.lua()
|
|
.globals()
|
|
.get::<bool>("M8_6_OPEN_DONE")
|
|
.unwrap_or(false)
|
|
});
|
|
}
|
|
|
|
fn active_buffer_text(state: &mut EditorState) -> String {
|
|
state
|
|
.lua_host
|
|
.lua()
|
|
.load(
|
|
r"
|
|
local buf = pmacs.window.buffer()
|
|
return buf:slice(0, buf:len())
|
|
",
|
|
)
|
|
.eval::<String>()
|
|
.expect("read active buffer")
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Bullet 1 --- five canonical sections render on a typical repo
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn magit_status_renders_five_sections_on_typical_repo() {
|
|
let repo = make_test_repo();
|
|
// Stash setup goes FIRST: `git stash push` (no paths) stashes
|
|
// every change in the working tree and the index, so anything
|
|
// we set up before stashing gets wiped. Stash now while the
|
|
// tree is clean from make_test_repo().
|
|
std::fs::write(repo.path().join("for-stash.txt"), b"stashed content\n")
|
|
.expect("write stash file");
|
|
git_run(repo.path(), &["add", "for-stash.txt"]);
|
|
git_run(repo.path(), &["stash", "push", "-m", "test-stash"]);
|
|
// After stash push, the tree is clean again (the for-stash.txt
|
|
// change is in the stash entry). Now build the "typical" state
|
|
// we want to render.
|
|
std::fs::write(repo.path().join("README.md"), b"hello\nworld\n").expect("modify README");
|
|
git_run(repo.path(), &["add", "README.md"]); // staged
|
|
std::fs::write(repo.path().join("README.md"), b"hello\nworld\nmore\n").expect("modify again");
|
|
// README.md now has X=M (staged) and Y=M (unstaged).
|
|
std::fs::write(repo.path().join("untracked.txt"), b"new\n").expect("write untracked");
|
|
git_run(repo.path(), &["branch", "feature"]);
|
|
|
|
let (mut state, _c, _u) = editor_with_magit();
|
|
open_status(&mut state, repo.path());
|
|
|
|
let text = active_buffer_text(&mut state);
|
|
// All five canonical sections visible by their stable IDs (the
|
|
// visible header text is "<v|>| > Title (count)").
|
|
for section_title in [
|
|
"Working tree changes",
|
|
"Staged changes",
|
|
"Recent commits",
|
|
"Branches",
|
|
"Stashes",
|
|
] {
|
|
assert!(
|
|
text.contains(section_title),
|
|
"section {section_title:?} must render; got: {text}"
|
|
);
|
|
}
|
|
// The actual content surfaced.
|
|
assert!(
|
|
text.contains("README.md"),
|
|
"modified README must show: {text}"
|
|
);
|
|
assert!(
|
|
text.contains("untracked.txt"),
|
|
"untracked must show: {text}"
|
|
);
|
|
assert!(text.contains("feature"), "feature branch must show: {text}");
|
|
assert!(text.contains("test-stash"), "stash entry must show: {text}");
|
|
assert!(
|
|
text.contains("initial commit"),
|
|
"initial commit must show: {text}"
|
|
);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Bullet 2 --- refresh after external commit reflects new state within 500 ms
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn magit_status_refreshes_after_external_commit_within_500ms() {
|
|
let repo = make_test_repo();
|
|
let (mut state, _c, _u) = editor_with_magit();
|
|
open_status(&mut state, repo.path());
|
|
|
|
// Initial buffer shows "initial commit".
|
|
let initial = active_buffer_text(&mut state);
|
|
assert!(
|
|
initial.contains("initial commit"),
|
|
"initial state must include initial commit; got: {initial}"
|
|
);
|
|
assert!(
|
|
!initial.contains("second commit"),
|
|
"second commit hasn't happened yet"
|
|
);
|
|
|
|
// Externally make a new commit.
|
|
std::fs::write(repo.path().join("README.md"), b"v2\n").expect("modify");
|
|
git_run(repo.path(), &["add", "README.md"]);
|
|
git_run(repo.path(), &["commit", "-m", "second commit"]);
|
|
|
|
// Pump until the polling loop reflects the new commit. Acceptance
|
|
// budget is 500 ms; we use 750 ms to keep the test from being
|
|
// flaky on slow CI while still failing if polling is broken.
|
|
let started = Instant::now();
|
|
pump_until_with_deadline(
|
|
&mut state,
|
|
|s| {
|
|
s.lua_host
|
|
.lua()
|
|
.load(
|
|
r"
|
|
local buf = pmacs.window.buffer()
|
|
local text = buf:slice(0, buf:len())
|
|
return text:find('second commit', 1, true) ~= nil
|
|
",
|
|
)
|
|
.eval::<bool>()
|
|
.unwrap_or(false)
|
|
},
|
|
Duration::from_millis(750),
|
|
);
|
|
let elapsed = started.elapsed();
|
|
// Soft check on latency: the polling cadence is 250 ms, so on
|
|
// a healthy run we settle in well under 500 ms. Anything past
|
|
// 750 ms means the polling loop isn't running --- the deadline
|
|
// above already enforces that.
|
|
assert!(
|
|
elapsed < Duration::from_millis(750),
|
|
"refresh latency {elapsed:?} exceeded 750 ms budget"
|
|
);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Bullet 3 --- empty sections render as one-line placeholder
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn magit_status_empty_sections_render_as_placeholders() {
|
|
// A fresh repo with one initial commit: no working-tree changes,
|
|
// no staged changes, no extra branches, no stashes. Only the
|
|
// "Recent commits" section has real content.
|
|
let repo = make_test_repo();
|
|
let (mut state, _c, _u) = editor_with_magit();
|
|
open_status(&mut state, repo.path());
|
|
|
|
let text = active_buffer_text(&mut state);
|
|
// Every empty section shows its placeholder body.
|
|
assert!(
|
|
text.contains("(no working-tree changes)"),
|
|
"empty working tree must show placeholder: {text}"
|
|
);
|
|
assert!(
|
|
text.contains("(nothing staged)"),
|
|
"empty staged must show placeholder: {text}"
|
|
);
|
|
assert!(
|
|
text.contains("(no stashes)"),
|
|
"empty stashes must show placeholder: {text}"
|
|
);
|
|
// Recent commits has one entry (the initial commit), so its
|
|
// placeholder is NOT shown.
|
|
assert!(
|
|
!text.contains("(no commits yet)"),
|
|
"non-empty Recent commits must not show its placeholder: {text}"
|
|
);
|
|
// Branches has the implicit `main`; placeholder not shown.
|
|
assert!(
|
|
!text.contains("(no branches)"),
|
|
"non-empty Branches must not show its placeholder: {text}"
|
|
);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Regression: section IDs stable across refresh, fold-state preserved
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn magit_status_fold_state_preserved_across_refresh() {
|
|
let repo = make_test_repo();
|
|
let (mut state, _c, _u) = editor_with_magit();
|
|
open_status(&mut state, repo.path());
|
|
|
|
// Collapse "log" (Recent commits) section.
|
|
state
|
|
.lua_host
|
|
.eval(
|
|
Some("collapse-log"),
|
|
r#"
|
|
local te = require("pmacs-magit").__pmacs_magit_test_seam_DO_NOT_USE
|
|
local h = te.active_handle()
|
|
te.fold.toggle(h.fold_state, "log")
|
|
te.repaint_visible(h)
|
|
"#,
|
|
)
|
|
.expect("collapse log");
|
|
|
|
let collapsed = active_buffer_text(&mut state);
|
|
assert!(
|
|
!collapsed.contains("initial commit"),
|
|
"log body must be hidden after collapse: {collapsed}"
|
|
);
|
|
|
|
// Trigger a manual refresh (which produces a new spec and calls
|
|
// update_spec). Fold-state should survive because `log` is a
|
|
// stable ID across refreshes.
|
|
state
|
|
.lua_host
|
|
.eval(
|
|
Some("refresh"),
|
|
r#"pmacs.command.invoke("pmacs-magit.refresh-status")"#,
|
|
)
|
|
.expect("refresh");
|
|
pump_until(&mut state, |s| {
|
|
s.lua_host
|
|
.lua()
|
|
.load(
|
|
r"
|
|
local te = require('pmacs-magit').__pmacs_magit_test_seam_DO_NOT_USE
|
|
local h = te.active_handle()
|
|
return h ~= nil and h.refresh_pending == false
|
|
",
|
|
)
|
|
.eval::<bool>()
|
|
.unwrap_or(false)
|
|
});
|
|
|
|
let after = active_buffer_text(&mut state);
|
|
assert!(
|
|
!after.contains("initial commit"),
|
|
"log section must remain collapsed after refresh: {after}"
|
|
);
|
|
// Verify the fold_state still has "log" collapsed.
|
|
let log_state: String = state
|
|
.lua_host
|
|
.lua()
|
|
.load(
|
|
r#"
|
|
local te = require("pmacs-magit").__pmacs_magit_test_seam_DO_NOT_USE
|
|
local h = te.active_handle()
|
|
return tostring(h.fold_state.log)
|
|
"#,
|
|
)
|
|
.eval()
|
|
.expect("log fold state");
|
|
assert_eq!(log_state, "collapsed");
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Regression: cursor stays on the same section across refresh
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn magit_status_cursor_section_preserved_across_refresh() {
|
|
let repo = make_test_repo();
|
|
let (mut state, _c, _u) = editor_with_magit();
|
|
open_status(&mut state, repo.path());
|
|
|
|
// Move cursor to Section "log" header (section_at would resolve
|
|
// it back to "log"). Sections in default order are working,
|
|
// staged, log, branches, stashes; each takes 2 lines (header +
|
|
// 1-line placeholder body) when empty. Empty repo: working (2
|
|
// lines, header + placeholder), staged (2 lines), so log header
|
|
// is at line 4. Move down 4 times.
|
|
state
|
|
.lua_host
|
|
.eval(
|
|
Some("seek-log"),
|
|
r"for _ = 1, 4 do pmacs.editor.move_down() end",
|
|
)
|
|
.expect("seek log");
|
|
let on_log: String = state
|
|
.lua_host
|
|
.lua()
|
|
.load(
|
|
r#"
|
|
local te = require("pmacs-magit").__pmacs_magit_test_seam_DO_NOT_USE
|
|
local h = te.active_handle()
|
|
local line = pmacs.editor.cursor_line()
|
|
return tostring(te.fold.section_at(h.projection, line))
|
|
"#,
|
|
)
|
|
.eval()
|
|
.expect("on log");
|
|
assert_eq!(on_log, "log", "setup: cursor must be on log section");
|
|
|
|
// Manual refresh.
|
|
state
|
|
.lua_host
|
|
.eval(
|
|
Some("refresh"),
|
|
r#"pmacs.command.invoke("pmacs-magit.refresh-status")"#,
|
|
)
|
|
.expect("refresh");
|
|
pump_until(&mut state, |s| {
|
|
s.lua_host
|
|
.lua()
|
|
.load(
|
|
r"
|
|
local te = require('pmacs-magit').__pmacs_magit_test_seam_DO_NOT_USE
|
|
local h = te.active_handle()
|
|
return h ~= nil and h.refresh_pending == false
|
|
",
|
|
)
|
|
.eval::<bool>()
|
|
.unwrap_or(false)
|
|
});
|
|
|
|
// Cursor should still be on the log section.
|
|
let after: String = state
|
|
.lua_host
|
|
.lua()
|
|
.load(
|
|
r#"
|
|
local te = require("pmacs-magit").__pmacs_magit_test_seam_DO_NOT_USE
|
|
local h = te.active_handle()
|
|
local line = pmacs.editor.cursor_line()
|
|
return tostring(te.fold.section_at(h.projection, line))
|
|
"#,
|
|
)
|
|
.eval()
|
|
.expect("after");
|
|
assert_eq!(after, "log", "cursor must still be on log after refresh");
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Regression: refresh-status command exists + works
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn magit_refresh_status_command_picks_up_new_commit() {
|
|
let repo = make_test_repo();
|
|
let (mut state, _c, _u) = editor_with_magit();
|
|
open_status(&mut state, repo.path());
|
|
|
|
// External change.
|
|
std::fs::write(repo.path().join("README.md"), b"v2\n").expect("modify");
|
|
git_run(repo.path(), &["add", "README.md"]);
|
|
git_run(repo.path(), &["commit", "-m", "manual-refresh-target"]);
|
|
|
|
// Manual refresh (rather than waiting for the polling loop).
|
|
state
|
|
.lua_host
|
|
.eval(
|
|
Some("refresh-now"),
|
|
r#"pmacs.command.invoke("pmacs-magit.refresh-status")"#,
|
|
)
|
|
.expect("refresh-now");
|
|
pump_until(&mut state, |s| {
|
|
s.lua_host
|
|
.lua()
|
|
.load(
|
|
r"
|
|
local buf = pmacs.window.buffer()
|
|
local text = buf:slice(0, buf:len())
|
|
return text:find('manual-refresh-target', 1, true) ~= nil
|
|
",
|
|
)
|
|
.eval::<bool>()
|
|
.unwrap_or(false)
|
|
});
|
|
let text = active_buffer_text(&mut state);
|
|
assert!(text.contains("manual-refresh-target"));
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Regression: open_status validates input
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn magit_open_status_rejects_non_string_repo_root() {
|
|
let (state, _c, _u) = editor_with_magit();
|
|
let msg: String = state
|
|
.lua_host
|
|
.lua()
|
|
.load(
|
|
r#"
|
|
local ok, err = pcall(function()
|
|
require("pmacs-magit").open_status(nil)
|
|
end)
|
|
assert(not ok, "nil repo_root must be rejected")
|
|
return tostring(err)
|
|
"#,
|
|
)
|
|
.eval()
|
|
.expect("nil-repo eval");
|
|
assert!(
|
|
msg.contains("non-empty string"),
|
|
"rejection must explain why: {msg}"
|
|
);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Parser unit tests via the test seam
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn magit_parse_porcelain_v2_basic_inputs() {
|
|
let (state, _c, _u) = editor_with_magit();
|
|
let lua = state.lua_host.lua();
|
|
|
|
// "1" lines: ordinary changed files. "2" lines: rename/copy.
|
|
// "?" lines: untracked. The Lua `"# branch.head main"` literal
|
|
// contains `"#`, which would close a single-hash Rust raw string;
|
|
// bumping to `r##"..."##` lets the literal pass through.
|
|
let json: String = lua
|
|
.load(
|
|
r##"
|
|
local te = require("pmacs-magit").__pmacs_magit_test_seam_DO_NOT_USE
|
|
local input = table.concat({
|
|
"# branch.head main",
|
|
"1 .M N... 100644 100644 100644 abc def README.md",
|
|
"1 M. N... 100644 100644 100644 def 123 staged.txt",
|
|
"? untracked.txt",
|
|
}, "\n") .. "\n"
|
|
local r = te.status.parse_porcelain_v2(input)
|
|
return string.format(
|
|
"branch=%s|staged=%d|unstaged=%d|untracked=%d|first_unstaged=%s",
|
|
r.branch, #r.staged, #r.unstaged, #r.untracked,
|
|
r.unstaged[1] or "(none)"
|
|
)
|
|
"##,
|
|
)
|
|
.eval()
|
|
.expect("porcelain parse");
|
|
// "1 .M ... README.md" -> Y is M (unstaged), X is . (not staged)
|
|
// "1 M. ... staged.txt" -> X is M (staged), Y is . (not unstaged)
|
|
// ? untracked.txt
|
|
assert_eq!(
|
|
json,
|
|
"branch=main|staged=1|unstaged=1|untracked=1|first_unstaged=M README.md"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn magit_parse_log_basic_input() {
|
|
let (state, _c, _u) = editor_with_magit();
|
|
let lua = state.lua_host.lua();
|
|
let result: String = lua
|
|
.load(
|
|
r#"
|
|
local te = require("pmacs-magit").__pmacs_magit_test_seam_DO_NOT_USE
|
|
local input = "abc1234 first commit\ndef5678 second commit\n"
|
|
local entries = te.status.parse_log(input)
|
|
return string.format("%d|%s|%s", #entries,
|
|
entries[1].hash, entries[2].subject)
|
|
"#,
|
|
)
|
|
.eval()
|
|
.expect("log parse");
|
|
assert_eq!(result, "2|abc1234|second commit");
|
|
}
|
|
|
|
#[test]
|
|
fn magit_parse_branches_marks_current() {
|
|
let (state, _c, _u) = editor_with_magit();
|
|
let lua = state.lua_host.lua();
|
|
let result: String = lua
|
|
.load(
|
|
r#"
|
|
local te = require("pmacs-magit").__pmacs_magit_test_seam_DO_NOT_USE
|
|
local input = " feature\n* main\n release\n"
|
|
local r = te.status.parse_branches(input)
|
|
return string.format("current=%s|count=%d|first=%s",
|
|
r.current, #r.all, r.all[1])
|
|
"#,
|
|
)
|
|
.eval()
|
|
.expect("branches parse");
|
|
// `git branch --list` outputs branches in encounter order
|
|
// (alphabetical with the current-branch marker inline), so
|
|
// `all[1]` is whichever branch sorts first --- "feature", not
|
|
// the current one. The current is named separately via
|
|
// `r.current`.
|
|
assert_eq!(result, "current=main|count=3|first=feature");
|
|
}
|
|
|
|
#[test]
|
|
fn magit_parse_stashes_basic_input() {
|
|
let (state, _c, _u) = editor_with_magit();
|
|
let lua = state.lua_host.lua();
|
|
let result: String = lua
|
|
.load(
|
|
r#"
|
|
local te = require("pmacs-magit").__pmacs_magit_test_seam_DO_NOT_USE
|
|
local input = "stash@{0}: WIP on main: abc123 work\nstash@{1}: On main: def quick fix\n"
|
|
local entries = te.status.parse_stashes(input)
|
|
return string.format("%d|%s|%s", #entries, entries[1].ref, entries[2].subject)
|
|
"#,
|
|
)
|
|
.eval()
|
|
.expect("stash parse");
|
|
assert_eq!(result, "2|stash@{0}|On main: def quick fix");
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Regression: build_spec produces stable section IDs
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn magit_build_spec_section_ids_are_stable_canonical_set() {
|
|
let (state, _c, _u) = editor_with_magit();
|
|
let lua = state.lua_host.lua();
|
|
let ids: String = lua
|
|
.load(
|
|
r#"
|
|
local te = require("pmacs-magit").__pmacs_magit_test_seam_DO_NOT_USE
|
|
local spec = te.status.build_spec {
|
|
status = { staged = {}, unstaged = {}, untracked = {} },
|
|
log = {},
|
|
branches = { current = nil, all = {} },
|
|
stashes = {},
|
|
}
|
|
local out = {}
|
|
for _, s in ipairs(spec) do out[#out + 1] = s.id end
|
|
return table.concat(out, ",")
|
|
"#,
|
|
)
|
|
.eval()
|
|
.expect("build_spec ids");
|
|
assert_eq!(ids, "working,staged,log,branches,stashes");
|
|
}
|
|
|
|
// Isolated bootstrap storage roots (see the module docs): an
|
|
// integration test is compiled without `cfg(test)`, so a raw
|
|
// `EditorState::new()` would read the developer's real `init.lua` and
|
|
// write into their real data root.
|
|
#[path = "common/iso.rs"]
|
|
mod iso;
|