mirrors/jj
1
0
Fork 1
mirror of https://github.com/martinvonz/jj.git synced 2024-12-26 14:00:51 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

transaction: take description at end instead of start

Browse source 
It seems better to have the caller pass the transaction description
when we finish the transaction than when we start it. That way we have
all the information we want to include more readily available.
This commit is contained in:
Martin von Zweigbergk 2023-12-11 21:42:05 -08:00 committed by Martin von Zweigbergk
parent 316ab8efb8
commit 60fae3114e
49 changed files with 589 additions and 651 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
cli/examples/custom-command/main.rs
View file

@ -39,13 +39,13 @@ fn run_custom_command(
CustomCommand::Frobnicate(args) => {
let mut workspace_command = command_helper.workspace_helper(ui)?;
let commit = workspace_command.resolve_single_rev(&args.revision, ui)?;
let mut tx = workspace_command.start_transaction("Frobnicate");
let mut tx = workspace_command.start_transaction();
let new_commit = tx
.mut_repo()
.rewrite_commit(command_helper.settings(), &commit)
.set_description("Frobnicated!")
.write()?;
tx.finish(ui)?;
tx.finish(ui, "Frobnicate")?;
writeln!(
ui.stderr(),
"Frobnicated revision: {}",

55
cli/src/cli_util.rs
View file

@ -628,12 +628,8 @@ impl CommandHelper {
)?;
let base_repo = repo_loader.load_at(&op_heads[0])?;
// TODO: It may be helpful to print each operation we're merging here
let mut tx = start_repo_transaction(
&base_repo,
&self.settings,
&self.string_args,
"resolve concurrent operations",
);
let mut tx =
start_repo_transaction(&base_repo, &self.settings, &self.string_args);
for other_op_head in op_heads.into_iter().skip(1) {
tx.merge_operation(other_op_head)?;
let num_rebased = tx.mut_repo().rebase_descendants(&self.settings)?;
@ -645,7 +641,11 @@ impl CommandHelper {
)?;
}
}
Ok(tx.write().leave_unpublished().operation().clone())
Ok(tx
.write("resolve concurrent operations")
.leave_unpublished()
.operation()
.clone())
},
)
} else {
@ -797,7 +797,7 @@ impl WorkspaceCommandHelper {
#[instrument(skip_all)]
fn import_git_refs_and_head(&mut self, ui: &mut Ui) -> Result<(), CommandError> {
let git_settings = self.settings.git_settings();
let mut tx = self.start_transaction("import git refs");
let mut tx = self.start_transaction();
// Automated import shouldn't fail because of reserved remote name.
let stats = git::import_some_refs(tx.mut_repo(), &git_settings, |ref_name| {
!git::is_reserved_git_remote_ref(ref_name)
@ -829,7 +829,7 @@ impl WorkspaceCommandHelper {
let new_git_head_tree = new_git_head_commit.tree()?;
locked_ws.locked_wc().reset(&new_git_head_tree)?;
tx.mut_repo().rebase_descendants(&self.settings)?;
self.user_repo = ReadonlyUserRepo::new(tx.commit());
self.user_repo = ReadonlyUserRepo::new(tx.commit("import git refs"));
locked_ws.finish(self.user_repo.repo.op_id().clone())?;
}
_ => {
@ -841,7 +841,7 @@ impl WorkspaceCommandHelper {
git"
)?;
}
self.finish_transaction(ui, tx)?;
self.finish_transaction(ui, tx, "import git refs")?;
}
}
writeln!(
@ -1363,12 +1363,8 @@ See https://github.com/martinvonz/jj/blob/main/docs/working-copy.md#stale-workin
})?;
drop(progress);
if new_tree_id != *wc_commit.tree_id() {
let mut tx = start_repo_transaction(
&self.user_repo.repo,
&self.settings,
&self.string_args,
"snapshot working copy",
);
let mut tx =
start_repo_transaction(&self.user_repo.repo, &self.settings, &self.string_args);
let mut_repo = tx.mut_repo();
let commit = mut_repo
.rewrite_commit(&self.settings, &wc_commit)
@ -1390,7 +1386,7 @@ See https://github.com/martinvonz/jj/blob/main/docs/working-copy.md#stale-workin
print_failed_git_export(ui, &failed_branches)?;
}
self.user_repo = ReadonlyUserRepo::new(tx.commit());
self.user_repo = ReadonlyUserRepo::new(tx.commit("snapshot working copy"));
}
locked_ws.finish(self.user_repo.repo.op_id().clone())?;
Ok(())
@ -1428,13 +1424,17 @@ See https://github.com/martinvonz/jj/blob/main/docs/working-copy.md#stale-workin
Ok(())
}
pub fn start_transaction(&mut self, description: &str) -> WorkspaceCommandTransaction {
let tx =
start_repo_transaction(self.repo(), &self.settings, &self.string_args, description);
pub fn start_transaction(&mut self) -> WorkspaceCommandTransaction {
let tx = start_repo_transaction(self.repo(), &self.settings, &self.string_args);
WorkspaceCommandTransaction { helper: self, tx }
}
fn finish_transaction(&mut self, ui: &mut Ui, mut tx: Transaction) -> Result<(), CommandError> {
fn finish_transaction(
&mut self,
ui: &mut Ui,
mut tx: Transaction,
description: impl Into<String>,
) -> Result<(), CommandError> {
if !tx.mut_repo().has_changes() {
writeln!(ui.stderr(), "Nothing changed.")?;
return Ok(());
@ -1465,7 +1465,7 @@ See https://github.com/martinvonz/jj/blob/main/docs/working-copy.md#stale-workin
let failed_branches = git::export_refs(tx.mut_repo())?;
print_failed_git_export(ui, &failed_branches)?;
}
self.user_repo = ReadonlyUserRepo::new(tx.commit());
self.user_repo = ReadonlyUserRepo::new(tx.commit(description));
self.report_repo_changes(ui, &old_repo)?;
if self.may_update_working_copy {
@ -1665,10 +1665,6 @@ impl WorkspaceCommandTransaction<'_> {
self.tx.mut_repo()
}
pub fn set_description(&mut self, description: &str) {
self.tx.set_description(description)
}
pub fn check_out(&mut self, commit: &Commit) -> Result<Commit, CheckOutCommitError> {
let workspace_id = self.helper.workspace_id().to_owned();
let settings = &self.helper.settings;
@ -1755,8 +1751,8 @@ impl WorkspaceCommandTransaction<'_> {
template.format(commit, formatter)
}
pub fn finish(self, ui: &mut Ui) -> Result<(), CommandError> {
self.helper.finish_transaction(ui, self.tx)
pub fn finish(self, ui: &mut Ui, description: impl Into<String>) -> Result<(), CommandError> {
self.helper.finish_transaction(ui, self.tx, description)
}
pub fn into_inner(self) -> Transaction {
@ -1843,9 +1839,8 @@ pub fn start_repo_transaction(
repo: &Arc<ReadonlyRepo>,
settings: &UserSettings,
string_args: &[String],
description: &str,
) -> Transaction {
let mut tx = repo.start_transaction(settings, description);
let mut tx = repo.start_transaction(settings);
// TODO: Either do better shell-escaping here or store the values in some list
// type (which we currently don't have).
let shell_escape = |arg: &String| {

4
cli/src/commands/abandon.rs
View file

@ -58,7 +58,7 @@ pub(crate) fn cmd_abandon(
to_abandon.len() - 1
)
};
let mut tx = workspace_command.start_transaction(&transaction_description);
let mut tx = workspace_command.start_transaction();
for commit in &to_abandon {
tx.mut_repo().record_abandoned_commit(commit.id().clone());
}
@ -86,6 +86,6 @@ pub(crate) fn cmd_abandon(
"Rebased {num_rebased} descendant commits onto parents of abandoned commits"
)?;
}
tx.finish(ui)?;
tx.finish(ui, transaction_description)?;
Ok(())
}

10
cli/src/commands/backout.rs
View file

@ -45,17 +45,17 @@ pub(crate) fn cmd_backout(
let destination = workspace_command.resolve_single_rev(revision_str, ui)?;
parents.push(destination);
}
let mut tx = workspace_command.start_transaction(&format!(
"back out commit {}",
commit_to_back_out.id().hex()
));
let mut tx = workspace_command.start_transaction();
back_out_commit(
command.settings(),
tx.mut_repo(),
&commit_to_back_out,
&parents,
)?;
tx.finish(ui)?;
tx.finish(
ui,
format!("back out commit {}", commit_to_back_out.id().hex()),
)?;
Ok(())
}

50
cli/src/commands/branch.rs
View file

@ -285,16 +285,19 @@ fn cmd_branch_create(
)?;
}
let mut tx = workspace_command.start_transaction(&format!(
"create {} pointing to commit {}",
make_branch_term(branch_names),
target_commit.id().hex()
));
let mut tx = workspace_command.start_transaction();
for branch_name in branch_names {
tx.mut_repo()
.set_local_branch_target(branch_name, RefTarget::normal(target_commit.id().clone()));
}
tx.finish(ui)?;
tx.finish(
ui,
format!(
"create {} pointing to commit {}",
make_branch_term(branch_names),
target_commit.id().hex()
),
)?;
Ok(())
}
@ -339,16 +342,19 @@ fn cmd_branch_set(
)?;
}
let mut tx = workspace_command.start_transaction(&format!(
"point {} to commit {}",
make_branch_term(branch_names),
target_commit.id().hex()
));
let mut tx = workspace_command.start_transaction();
for branch_name in branch_names {
tx.mut_repo()
.set_local_branch_target(branch_name, RefTarget::normal(target_commit.id().clone()));
}
tx.finish(ui)?;
tx.finish(
ui,
format!(
"point {} to commit {}",
make_branch_term(branch_names),
target_commit.id().hex()
),
)?;
Ok(())
}
@ -453,13 +459,12 @@ fn cmd_branch_delete(
}
let name_patterns = [&args.names[..], &args.glob[..]].concat();
let names = find_local_branches(view, &name_patterns)?;
let mut tx =
workspace_command.start_transaction(&format!("delete {}", make_branch_term(&names)));
let mut tx = workspace_command.start_transaction();
for branch_name in names.iter() {
tx.mut_repo()
.set_local_branch_target(branch_name, RefTarget::absent());
}
tx.finish(ui)?;
tx.finish(ui, format!("delete {}", make_branch_term(&names)))?;
if names.len() > 1 {
writeln!(ui.stderr(), "Deleted {} branches.", names.len())?;
}
@ -481,12 +486,11 @@ fn cmd_branch_forget(
}
let name_patterns = [&args.names[..], &args.glob[..]].concat();
let names = find_forgettable_branches(view, &name_patterns)?;
let mut tx =
workspace_command.start_transaction(&format!("forget {}", make_branch_term(&names)));
let mut tx = workspace_command.start_transaction();
for branch_name in names.iter() {
tx.mut_repo().remove_branch(branch_name);
}
tx.finish(ui)?;
tx.finish(ui, format!("forget {}", make_branch_term(&names)))?;
if names.len() > 1 {
writeln!(ui.stderr(), "Forgot {} branches.", names.len())?;
}
@ -508,13 +512,12 @@ fn cmd_branch_track(
names.push(name);
}
}
let mut tx =
workspace_command.start_transaction(&format!("track remote {}", make_branch_term(&names)));
let mut tx = workspace_command.start_transaction();
for name in &names {
tx.mut_repo()
.track_remote_branch(&name.branch, &name.remote);
}
tx.finish(ui)?;
tx.finish(ui, format!("track remote {}", make_branch_term(&names)))?;
if names.len() > 1 {
writeln!(
ui.stderr(),
@ -546,13 +549,12 @@ fn cmd_branch_untrack(
names.push(name);
}
}
let mut tx = workspace_command
.start_transaction(&format!("untrack remote {}", make_branch_term(&names)));
let mut tx = workspace_command.start_transaction();
for name in &names {
tx.mut_repo()
.untrack_remote_branch(&name.branch, &name.remote);
}
tx.finish(ui)?;
tx.finish(ui, format!("untrack remote {}", make_branch_term(&names)))?;
if names.len() > 1 {
writeln!(
ui.stderr(),

5
cli/src/commands/checkout.rs
View file

@ -43,8 +43,7 @@ pub(crate) fn cmd_checkout(
) -> Result<(), CommandError> {
let mut workspace_command = command.workspace_helper(ui)?;
let target = workspace_command.resolve_single_rev(&args.revision, ui)?;
let mut tx =
workspace_command.start_transaction(&format!("check out commit {}", target.id().hex()));
let mut tx = workspace_command.start_transaction();
let commit_builder = tx
.mut_repo()
.new_commit(
@ -55,6 +54,6 @@ pub(crate) fn cmd_checkout(
.set_description(join_message_paragraphs(&args.message_paragraphs));
let new_commit = commit_builder.write()?;
tx.edit(&new_commit).unwrap();
tx.finish(ui)?;
tx.finish(ui, format!("check out commit {}", target.id().hex()))?;
Ok(())
}

23
cli/src/commands/chmod.rs
View file

@ -66,15 +66,7 @@ pub(crate) fn cmd_chmod(
let commit = workspace_command.resolve_single_rev(&args.revision, ui)?;
workspace_command.check_rewritable([&commit])?;
let mut tx = workspace_command.start_transaction(&format!(
"make paths {} in commit {}",
if executable_bit {
"executable"
} else {
"non-executable"
},
commit.id().hex(),
));
let mut tx = workspace_command.start_transaction();
let tree = commit.tree()?;
let store = tree.store();
let mut tree_builder = MergedTreeBuilder::new(commit.tree_id().clone());
@ -119,5 +111,16 @@ pub(crate) fn cmd_chmod(
.rewrite_commit(command.settings(), &commit)
.set_tree_id(new_tree_id)
.write()?;
tx.finish(ui)
tx.finish(
ui,
format!(
"make paths {} in commit {}",
if executable_bit {
"executable"
} else {
"non-executable"
},
commit.id().hex(),
),
)
}

4
cli/src/commands/commit.rs
View file

@ -49,7 +49,7 @@ pub(crate) fn cmd_commit(
.ok_or_else(|| user_error("This command requires a working copy"))?;
let commit = workspace_command.repo().store().get_commit(commit_id)?;
let matcher = workspace_command.matcher_from_values(&args.paths)?;
let mut tx = workspace_command.start_transaction(&format!("commit {}", commit.id().hex()));
let mut tx = workspace_command.start_transaction();
let base_tree = merge_commit_trees(tx.repo(), &commit.parents())?;
let instructions = format!(
"\
@ -117,6 +117,6 @@ new working-copy commit.
tx.mut_repo().edit(workspace_id, &new_wc_commit).unwrap();
}
}
tx.finish(ui)?;
tx.finish(ui, format!("commit {}", commit.id().hex()))?;
Ok(())
}

5
cli/src/commands/describe.rs
View file

@ -77,8 +77,7 @@ pub(crate) fn cmd_describe(
if description == *commit.description() && !args.reset_author {
writeln!(ui.stderr(), "Nothing changed.")?;
} else {
let mut tx =
workspace_command.start_transaction(&format!("describe commit {}", commit.id().hex()));
let mut tx = workspace_command.start_transaction();
let mut commit_builder = tx
.mut_repo()
.rewrite_commit(command.settings(), &commit)
@ -88,7 +87,7 @@ pub(crate) fn cmd_describe(
commit_builder = commit_builder.set_author(new_author);
}
commit_builder.write()?;
tx.finish(ui)?;
tx.finish(ui, format!("describe commit {}", commit.id().hex()))?;
}
Ok(())
}

5
cli/src/commands/diffedit.rs
View file

@ -78,8 +78,7 @@ pub(crate) fn cmd_diffedit(
};
workspace_command.check_rewritable([&target_commit])?;
let mut tx =
workspace_command.start_transaction(&format!("edit commit {}", target_commit.id().hex()));
let mut tx = workspace_command.start_transaction();
let instructions = format!(
"\
You are editing changes in: {}
@ -110,7 +109,7 @@ don't make any changes, then the operation will be aborted.",
if num_rebased > 0 {
writeln!(ui.stderr(), "Rebased {num_rebased} descendant commits")?;
}
tx.finish(ui)?;
tx.finish(ui, format!("edit commit {}", target_commit.id().hex()))?;
}
Ok(())
}

5
cli/src/commands/duplicate.rs
View file

@ -53,8 +53,7 @@ pub(crate) fn cmd_duplicate(
}
let mut duplicated_old_to_new: IndexMap<Commit, Commit> = IndexMap::new();
let mut tx = workspace_command
.start_transaction(&format!("duplicating {} commit(s)", to_duplicate.len()));
let mut tx = workspace_command.start_transaction();
let base_repo = tx.base_repo().clone();
let store = base_repo.store();
let mut_repo = tx.mut_repo();
@ -97,6 +96,6 @@ pub(crate) fn cmd_duplicate(
tx.write_commit_summary(ui.stderr_formatter().as_mut(), new)?;
writeln!(ui.stderr())?;
}
tx.finish(ui)?;
tx.finish(ui, format!("duplicating {} commit(s)", to_duplicate.len()))?;
Ok(())
}

5
cli/src/commands/edit.rs
View file

@ -45,10 +45,9 @@ pub(crate) fn cmd_edit(
if workspace_command.get_wc_commit_id() == Some(new_commit.id()) {
writeln!(ui.stderr(), "Already editing that commit")?;
} else {
let mut tx =
workspace_command.start_transaction(&format!("edit commit {}", new_commit.id().hex()));
let mut tx = workspace_command.start_transaction();
tx.edit(&new_commit)?;
tx.finish(ui)?;
tx.finish(ui, format!("edit commit {}", new_commit.id().hex()))?;
}
Ok(())
}

50
cli/src/commands/git.rs
View file

@ -257,11 +257,10 @@ fn cmd_git_remote_remove(
let mut workspace_command = command.workspace_helper(ui)?;
let repo = workspace_command.repo();
let git_repo = get_git_repo(repo.store())?;
let mut tx =
workspace_command.start_transaction(&format!("remove git remote {}", &args.remote));
let mut tx = workspace_command.start_transaction();
git::remove_remote(tx.mut_repo(), &git_repo, &args.remote)?;
if tx.mut_repo().has_changes() {
tx.finish(ui)
tx.finish(ui, format!("remove git remote {}", &args.remote))
} else {
Ok(()) // Do not print "Nothing changed."
}
@ -275,11 +274,13 @@ fn cmd_git_remote_rename(
let mut workspace_command = command.workspace_helper(ui)?;
let repo = workspace_command.repo();
let git_repo = get_git_repo(repo.store())?;
let mut tx = workspace_command
.start_transaction(&format!("rename git remote {} to {}", &args.old, &args.new));
let mut tx = workspace_command.start_transaction();
git::rename_remote(tx.mut_repo(), &git_repo, &args.old, &args.new)?;
if tx.mut_repo().has_changes() {
tx.finish(ui)
tx.finish(
ui,
format!("rename git remote {} to {}", &args.old, &args.new),
)
} else {
Ok(()) // Do not print "Nothing changed."
}
@ -320,16 +321,13 @@ fn cmd_git_fetch(
} else {
args.remotes.clone()
};
let mut tx = workspace_command.start_transaction(&format!(
"fetch from git remote(s) {}",
remotes.iter().join(",")
));
for remote in remotes {
let mut tx = workspace_command.start_transaction();
for remote in &remotes {
let stats = with_remote_callbacks(ui, |cb| {
git::fetch(
tx.mut_repo(),
&git_repo,
&remote,
remote,
&args.branch,
cb,
&command.settings().git_settings(),
@ -356,7 +354,10 @@ fn cmd_git_fetch(
})?;
print_git_import_stats(ui, &stats.import_stats)?;
}
tx.finish(ui)?;
tx.finish(
ui,
format!("fetch from git remote(s) {}", remotes.iter().join(",")),
)?;
Ok(())
}
@ -505,12 +506,11 @@ fn cmd_git_clone(
.view()
.get_remote_branch(default_branch, remote_name);
if let Some(commit_id) = default_branch_remote_ref.target.as_normal().cloned() {
let mut checkout_tx =
workspace_command.start_transaction("check out git remote's default branch");
let mut checkout_tx = workspace_command.start_transaction();
if let Ok(commit) = checkout_tx.repo().store().get_commit(&commit_id) {
checkout_tx.check_out(&commit)?;
}
checkout_tx.finish(ui)?;
checkout_tx.finish(ui, "check out git remote's default branch")?;
}
}
Ok(())
@ -538,7 +538,7 @@ fn do_git_clone(
let mut workspace_command = command.for_loaded_repo(ui, workspace, repo)?;
maybe_add_gitignore(&workspace_command)?;
git_repo.remote(remote_name, source).unwrap();
let mut fetch_tx = workspace_command.start_transaction("fetch from git remote into empty repo");
let mut fetch_tx = workspace_command.start_transaction();
let stats = with_remote_callbacks(ui, |cb| {
git::fetch(
@ -561,7 +561,7 @@ fn do_git_clone(
}
})?;
print_git_import_stats(ui, &stats.import_stats)?;
fetch_tx.finish(ui)?;
fetch_tx.finish(ui, "fetch from git remote into empty repo")?;
Ok((workspace_command, stats))
}
@ -700,7 +700,7 @@ fn cmd_git_push(
.map(|change_str| workspace_command.resolve_single_rev(change_str, ui))
.try_collect()?;
let mut tx = workspace_command.start_transaction("");
let mut tx = workspace_command.start_transaction();
let tx_description;
let mut branch_updates = vec![];
if args.all {
@ -855,8 +855,6 @@ fn cmd_git_push(
return Ok(());
}
tx.set_description(&tx_description);
let mut new_heads = vec![];
let mut force_pushed_branches = hashset! {};
for (branch_name, update) in &branch_updates {
@ -976,7 +974,7 @@ fn cmd_git_push(
),
_ => user_error(err.to_string()),
})?;
tx.finish(ui)?;
tx.finish(ui, tx_description)?;
Ok(())
}
@ -1088,10 +1086,10 @@ fn cmd_git_import(
_args: &GitImportArgs,
) -> Result<(), CommandError> {
let mut workspace_command = command.workspace_helper(ui)?;
let mut tx = workspace_command.start_transaction("import git refs");
let mut tx = workspace_command.start_transaction();
let stats = git::import_refs(tx.mut_repo(), &command.settings().git_settings())?;
print_git_import_stats(ui, &stats)?;
tx.finish(ui)?;
tx.finish(ui, "import git refs")?;
Ok(())
}
@ -1101,9 +1099,9 @@ fn cmd_git_export(
_args: &GitExportArgs,
) -> Result<(), CommandError> {
let mut workspace_command = command.workspace_helper(ui)?;
let mut tx = workspace_command.start_transaction("export git refs");
let mut tx = workspace_command.start_transaction();
let failed_branches = git::export_refs(tx.mut_repo())?;
tx.finish(ui)?;
tx.finish(ui, "export git refs")?;
print_failed_git_export(ui, &failed_branches)?;
Ok(())
}

4
cli/src/commands/init.rs
View file

@ -86,7 +86,7 @@ pub(crate) fn cmd_init(
git::maybe_add_gitignore(&workspace_command)?;
workspace_command.snapshot(ui)?;
if !workspace_command.working_copy_shared_with_git() {
let mut tx = workspace_command.start_transaction("import git refs");
let mut tx = workspace_command.start_transaction();
let stats = jj_lib::git::import_some_refs(
tx.mut_repo(),
&command.settings().git_settings(),
@ -98,7 +98,7 @@ pub(crate) fn cmd_init(
tx.check_out(&git_head_commit)?;
}
if tx.mut_repo().has_changes() {
tx.finish(ui)?;
tx.finish(ui, "import git refs")?;
}
}
print_trackable_remote_branches(ui, workspace_command.repo().view())?;

15
cli/src/commands/move.rs
View file

@ -66,11 +66,7 @@ pub(crate) fn cmd_move(
}
workspace_command.check_rewritable([&source, &destination])?;
let matcher = workspace_command.matcher_from_values(&args.paths)?;
let mut tx = workspace_command.start_transaction(&format!(
"move changes from {} to {}",
source.id().hex(),
destination.id().hex()
));
let mut tx = workspace_command.start_transaction();
let parent_tree = merge_commit_trees(tx.repo(), &source.parents())?;
let source_tree = source.tree()?;
let instructions = format!(
@ -137,6 +133,13 @@ from the source will be moved into the destination.
.set_tree_id(new_destination_tree.id().clone())
.set_description(description)
.write()?;
tx.finish(ui)?;
tx.finish(
ui,
format!(
"move changes from {} to {}",
source.id().hex(),
destination.id().hex()
),
)?;
Ok(())
}

4
cli/src/commands/new.rs
View file

@ -102,7 +102,7 @@ Please use `jj new 'all:x|y'` instead of `jj new --allow-large-revsets x y`.",
.into_iter()
.collect_vec();
let target_ids = target_commits.iter().map(|c| c.id().clone()).collect_vec();
let mut tx = workspace_command.start_transaction("new empty commit");
let mut tx = workspace_command.start_transaction();
let mut num_rebased;
let new_commit;
if args.insert_before {
@ -206,6 +206,6 @@ Please use `jj new 'all:x|y'` instead of `jj new --allow-large-revsets x y`.",
if num_rebased > 0 {
writeln!(ui.stderr(), "Rebased {num_rebased} descendant commits")?;
}
tx.finish(ui)?;
tx.finish(ui, "new empty commit")?;
Ok(())
}

13
cli/src/commands/next.rs
View file

@ -115,16 +115,17 @@ pub(crate) fn cmd_next(
if edit {
// We're editing, the target must be rewritable.
workspace_command.check_rewritable([target])?;
let mut tx = workspace_command
.start_transaction(&format!("next: {current_short} -> editing {target_short}"));
let mut tx = workspace_command.start_transaction();
tx.edit(target)?;
tx.finish(ui)?;
tx.finish(
ui,
format!("next: {current_short} -> editing {target_short}"),
)?;
return Ok(());
}
let mut tx =
workspace_command.start_transaction(&format!("next: {current_short} -> {target_short}"));
let mut tx = workspace_command.start_transaction();
// Move the working-copy commit to the new parent.
tx.check_out(target)?;
tx.finish(ui)?;
tx.finish(ui, format!("next: {current_short} -> {target_short}"))?;
Ok(())
}

10
cli/src/commands/operation.rs
View file

@ -200,8 +200,7 @@ pub fn cmd_op_undo(
return Err(user_error("Cannot undo a merge operation"));
}
let mut tx =
workspace_command.start_transaction(&format!("undo operation {}", bad_op.id().hex()));
let mut tx = workspace_command.start_transaction();
let repo_loader = tx.base_repo().loader();
let bad_repo = repo_loader.load_at(&bad_op)?;
let parent_repo = repo_loader.load_at(&parent_op)?;
@ -212,7 +211,7 @@ pub fn cmd_op_undo(
&args.what,
);
tx.mut_repo().set_view(new_view);
tx.finish(ui)?;
tx.finish(ui, format!("undo operation {}", bad_op.id().hex()))?;
Ok(())
}
@ -224,15 +223,14 @@ fn cmd_op_restore(
) -> Result<(), CommandError> {
let mut workspace_command = command.workspace_helper(ui)?;
let target_op = workspace_command.resolve_single_op(&args.operation)?;
let mut tx = workspace_command
.start_transaction(&format!("restore to operation {}", target_op.id().hex()));
let mut tx = workspace_command.start_transaction();
let new_view = view_with_desired_portions_restored(
target_op.view()?.store_view(),
tx.base_repo().view().store_view(),
&args.what,
);
tx.mut_repo().set_view(new_view);
tx.finish(ui)?;
tx.finish(ui, format!("restore to operation {}", target_op.id().hex()))?;
Ok(())
}

13
cli/src/commands/prev.rs
View file

@ -109,15 +109,16 @@ pub(crate) fn cmd_prev(
if edit {
// The target must be rewritable if we're editing.
workspace_command.check_rewritable([target])?;
let mut tx = workspace_command
.start_transaction(&format!("prev: {current_short} -> editing {target_short}"));
let mut tx = workspace_command.start_transaction();
tx.edit(target)?;
tx.finish(ui)?;
tx.finish(
ui,
format!("prev: {current_short} -> editing {target_short}"),
)?;
return Ok(());
}
let mut tx =
workspace_command.start_transaction(&format!("prev: {current_short} -> {target_short}"));
let mut tx = workspace_command.start_transaction();
tx.check_out(target)?;
tx.finish(ui)?;
tx.finish(ui, format!("prev: {current_short} -> {target_short}"))?;
Ok(())
}

9
cli/src/commands/rebase.rs
View file

@ -285,7 +285,7 @@ fn rebase_descendants(
} else {
format!("rebase {} commits and their descendants", old_commits.len())
};
let mut tx = workspace_command.start_transaction(&tx_message);
let mut tx = workspace_command.start_transaction();
// `rebase_descendants` takes care of sorting in reverse topological order, so
// no need to do it here.
for old_commit in old_commits {
@ -301,7 +301,7 @@ fn rebase_descendants(
+ tx.mut_repo()
.rebase_descendants_with_options(settings, rebase_options)?;
writeln!(ui.stderr(), "Rebased {num_rebased} commits")?;
tx.finish(ui)?;
tx.finish(ui, tx_message)?;
Ok(())
}
@ -333,8 +333,7 @@ fn rebase_revision(
debug_assert!(workspace_command.check_rewritable(&child_commits).is_ok());
// First, rebase the children of `old_commit`.
let mut tx =
workspace_command.start_transaction(&format!("rebase commit {}", old_commit.id().hex()));
let mut tx = workspace_command.start_transaction();
let mut rebased_commit_ids = HashMap::new();
for child_commit in &child_commits {
let new_child_parent_ids: Vec<CommitId> = child_commit
@ -430,7 +429,7 @@ fn rebase_revision(
commit"
)?;
}
tx.finish(ui)?;
tx.finish(ui, format!("rebase commit {}", old_commit.id().hex()))?;
Ok(())
}

10
cli/src/commands/resolve.rs
View file

@ -95,17 +95,17 @@ pub(crate) fn cmd_resolve(
let (repo_path, _) = conflicts.first().unwrap();
workspace_command.check_rewritable([&commit])?;
let mut tx = workspace_command.start_transaction(&format!(
"Resolve conflicts in commit {}",
commit.id().hex()
));
let mut tx = workspace_command.start_transaction();
let new_tree_id = tx.run_mergetool(ui, &tree, repo_path)?;
let new_commit = tx
.mut_repo()
.rewrite_commit(command.settings(), &commit)
.set_tree_id(new_tree_id)
.write()?;
tx.finish(ui)?;
tx.finish(
ui,
format!("Resolve conflicts in commit {}", commit.id().hex()),
)?;
if !args.quiet {
let new_tree = new_commit.tree()?;

5
cli/src/commands/restore.rs
View file

@ -102,8 +102,7 @@ pub(crate) fn cmd_restore(
if &new_tree_id == to_commit.tree_id() {
writeln!(ui.stderr(), "Nothing changed.")?;
} else {
let mut tx = workspace_command
.start_transaction(&format!("restore into commit {}", to_commit.id().hex()));
let mut tx = workspace_command.start_transaction();
let mut_repo = tx.mut_repo();
let new_commit = mut_repo
.rewrite_commit(command.settings(), &to_commit)
@ -118,7 +117,7 @@ pub(crate) fn cmd_restore(
if num_rebased > 0 {
writeln!(ui.stderr(), "Rebased {num_rebased} descendant commits")?;
}
tx.finish(ui)?;
tx.finish(ui, format!("restore into commit {}", to_commit.id().hex()))?;
}
Ok(())
}

5
cli/src/commands/split.rs
View file

@ -59,8 +59,7 @@ pub(crate) fn cmd_split(
let commit = workspace_command.resolve_single_rev(&args.revision, ui)?;
workspace_command.check_rewritable([&commit])?;
let matcher = workspace_command.matcher_from_values(&args.paths)?;
let mut tx =
workspace_command.start_transaction(&format!("split commit {}", commit.id().hex()));
let mut tx = workspace_command.start_transaction();
let end_tree = commit.tree()?;
let base_tree = merge_commit_trees(tx.repo(), &commit.parents())?;
let interactive = args.interactive || args.paths.is_empty();
@ -152,6 +151,6 @@ don't make any changes, then the operation will be aborted.
write!(ui.stderr(), "\nSecond part: ")?;
tx.write_commit_summary(ui.stderr_formatter().as_mut(), &second_commit)?;
writeln!(ui.stderr())?;
tx.finish(ui)?;
tx.finish(ui, format!("split commit {}", commit.id().hex()))?;
Ok(())
}

5
cli/src/commands/squash.rs
View file

@ -63,8 +63,7 @@ pub(crate) fn cmd_squash(
let parent = &parents[0];
workspace_command.check_rewritable(&parents[..1])?;
let matcher = workspace_command.matcher_from_values(&args.paths)?;
let mut tx =
workspace_command.start_transaction(&format!("squash commit {}", commit.id().hex()));
let mut tx = workspace_command.start_transaction();
let instructions = format!(
"\
You are moving changes from: {}
@ -143,6 +142,6 @@ from the source will be moved into the parent.
.set_parents(vec![new_parent.id().clone()])
.write()?;
}
tx.finish(ui)?;
tx.finish(ui, format!("squash commit {}", commit.id().hex()))?;
Ok(())
}

5
cli/src/commands/unsquash.rs
View file

@ -58,8 +58,7 @@ pub(crate) fn cmd_unsquash(
}
let parent = &parents[0];
workspace_command.check_rewritable(&parents[..1])?;
let mut tx =
workspace_command.start_transaction(&format!("unsquash commit {}", commit.id().hex()));
let mut tx = workspace_command.start_transaction();
let parent_base_tree = merge_commit_trees(tx.repo(), &parent.parents())?;
let new_parent_tree_id;
if args.interactive {
@ -117,6 +116,6 @@ aborted.
.set_parents(vec![new_parent.id().clone()])
.write()?;
}
tx.finish(ui)?;
tx.finish(ui, format!("unsquash commit {}", commit.id().hex()))?;
Ok(())
}

6
cli/src/commands/untrack.rs
View file

@ -42,9 +42,7 @@ pub(crate) fn cmd_untrack(
let store = workspace_command.repo().store().clone();
let matcher = workspace_command.matcher_from_values(&args.paths)?;
let mut tx = workspace_command
.start_transaction("untrack paths")
.into_inner();
let mut tx = workspace_command.start_transaction().into_inner();
let base_ignores = workspace_command.base_ignores();
let (mut locked_ws, wc_commit) = workspace_command.start_working_copy_mutation()?;
// Create a new tree without the unwanted files
@ -100,7 +98,7 @@ Make sure they're ignored, then try again.",
if num_rebased > 0 {
writeln!(ui.stderr(), "Rebased {num_rebased} descendant commits")?;
}
let repo = tx.commit();
let repo = tx.commit("untrack paths");
locked_ws.finish(repo.op_id().clone())?;
Ok(())
}

14
cli/src/commands/workspace.rs
View file

@ -164,10 +164,7 @@ fn cmd_workspace_add(
)?;
let mut new_workspace_command = WorkspaceCommandHelper::new(ui, command, new_workspace, repo)?;
let mut tx = new_workspace_command.start_transaction(&format!(
"Create initial working-copy commit in workspace {}",
&name
));
let mut tx = new_workspace_command.start_transaction();
// If no parent revisions are specified, create a working-copy commit based
// on the parent of the current working-copy commit.
@ -197,7 +194,10 @@ fn cmd_workspace_add(
.write()?;
tx.edit(&new_wc_commit)?;
tx.finish(ui)?;
tx.finish(
ui,
format!("Create initial working-copy commit in workspace {}", &name),
)?;
Ok(())
}
@ -247,9 +247,9 @@ fn cmd_workspace_forget(
// bundle every workspace forget into a single transaction, so that e.g.
// undo correctly restores all of them at once.
let mut tx = workspace_command.start_transaction(&description);
let mut tx = workspace_command.start_transaction();
wss.iter().for_each(|ws| tx.mut_repo().remove_wc_commit(ws));
tx.finish(ui)?;
tx.finish(ui, description)?;
Ok(())
}

9
lib/src/repo.rs
View file

@ -294,10 +294,9 @@ impl ReadonlyRepo {
pub fn start_transaction(
self: &Arc<ReadonlyRepo>,
user_settings: &UserSettings,
description: &str,
) -> Transaction {
let mut_repo = MutableRepo::new(self.clone(), self.readonly_index(), &self.view);
Transaction::new(mut_repo, user_settings, description)
Transaction::new(mut_repo, user_settings)
}
pub fn reload_at_head(
@ -707,12 +706,14 @@ impl RepoLoader {
user_settings: &UserSettings,
) -> Result<Operation, RepoLoaderError> {
let base_repo = self.load_at(&op_heads[0])?;
let mut tx = base_repo.start_transaction(user_settings, "resolve concurrent operations");
let mut tx = base_repo.start_transaction(user_settings);
for other_op_head in op_heads.into_iter().skip(1) {
tx.merge_operation(other_op_head)?;
tx.mut_repo().rebase_descendants(user_settings)?;
}
let merged_repo = tx.write().leave_unpublished();
let merged_repo = tx
.write("resolve concurrent operations")
.leave_unpublished();
Ok(merged_repo.operation().clone())
}

19
lib/src/transaction.rs
View file

@ -35,13 +35,9 @@ pub struct Transaction {
}
impl Transaction {
pub fn new(
mut_repo: MutableRepo,
user_settings: &UserSettings,
description: &str,
) -> Transaction {
pub fn new(mut_repo: MutableRepo, user_settings: &UserSettings) -> Transaction {
let parent_ops = vec![mut_repo.base_repo().operation().clone()];
let op_metadata = create_op_metadata(user_settings, description.to_string());
let op_metadata = create_op_metadata(user_settings, "".to_string());
let end_time = user_settings.operation_timestamp();
Transaction {
mut_repo,
@ -55,10 +51,6 @@ impl Transaction {
self.mut_repo.base_repo()
}
pub fn set_description(&mut self, description: &str) {
self.op_metadata.description = description.to_string();
}
pub fn set_tag(&mut self, key: String, value: String) {
self.op_metadata.tags.insert(key, value);
}
@ -89,14 +81,14 @@ impl Transaction {
}
/// Writes the transaction to the operation store and publishes it.
pub fn commit(self) -> Arc<ReadonlyRepo> {
self.write().publish()
pub fn commit(self, description: impl Into<String>) -> Arc<ReadonlyRepo> {
self.write(description).publish()
}
/// Writes the transaction to the operation store, but does not publish it.
/// That means that a repo can be loaded at the operation, but the
/// operation will not be seen when loading the repo at head.
pub fn write(mut self) -> UnpublishedOperation {
pub fn write(mut self, description: impl Into<String>) -> UnpublishedOperation {
let mut_repo = self.mut_repo;
// TODO: Should we instead just do the rebasing here if necessary?
assert!(
@ -107,6 +99,7 @@ impl Transaction {
let (mut_index, view) = mut_repo.consume();
let view_id = base_repo.op_store().write_view(view.store_view()).unwrap();
self.op_metadata.description = description.into();
self.op_metadata.end_time = self.end_time.unwrap_or_else(Timestamp::now);
let parents = self.parent_ops.iter().map(|op| op.id().clone()).collect();
let store_operation = op_store::Operation {

7
lib/src/workspace.rs
View file

@ -106,16 +106,13 @@ fn init_working_copy(
let working_copy_state_path = jj_dir.join("working_copy");
std::fs::create_dir(&working_copy_state_path).context(&working_copy_state_path)?;
let mut tx = repo.start_transaction(
user_settings,
&format!("add workspace '{}'", workspace_id.as_str()),
);
let mut tx = repo.start_transaction(user_settings);
tx.mut_repo().check_out(
workspace_id.clone(),
user_settings,
&repo.store().root_commit(),
)?;
let repo = tx.commit();
let repo = tx.commit(format!("add workspace '{}'", workspace_id.as_str()));
let working_copy = working_copy_initializer(
repo.store().clone(),

20
lib/tests/test_bad_locking.rs
View file

@ -105,12 +105,12 @@ fn test_bad_locking_children(backend: TestRepoBackend) {
let repo = &test_workspace.repo;
let workspace_root = test_workspace.workspace.workspace_root();
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let initial = create_random_commit(tx.mut_repo(), &settings)
.set_parents(vec![repo.store().root_commit_id().clone()])
.write()
.unwrap();
tx.commit();
tx.commit("test");
// Simulate a write of a commit that happens on one machine
let machine1_root = test_workspace.root_dir().join("machine1");
@ -126,12 +126,12 @@ fn test_bad_locking_children(backend: TestRepoBackend) {
.repo_loader()
.load_at_head(&settings)
.unwrap();
let mut machine1_tx = machine1_repo.start_transaction(&settings, "test");
let mut machine1_tx = machine1_repo.start_transaction(&settings);
let child1 = create_random_commit(machine1_tx.mut_repo(), &settings)
.set_parents(vec![initial.id().clone()])
.write()
.unwrap();
machine1_tx.commit();
machine1_tx.commit("test");
// Simulate a write of a commit that happens on another machine
let machine2_root = test_workspace.root_dir().join("machine2");
@ -147,12 +147,12 @@ fn test_bad_locking_children(backend: TestRepoBackend) {
.repo_loader()
.load_at_head(&settings)
.unwrap();
let mut machine2_tx = machine2_repo.start_transaction(&settings, "test");
let mut machine2_tx = machine2_repo.start_transaction(&settings);
let child2 = create_random_commit(machine2_tx.mut_repo(), &settings)
.set_parents(vec![initial.id().clone()])
.write()
.unwrap();
machine2_tx.commit();
machine2_tx.commit("test");
// Simulate that the distributed file system now has received the changes from
// both machines
@ -186,12 +186,12 @@ fn test_bad_locking_interrupted(backend: TestRepoBackend) {
let test_workspace = TestWorkspace::init_with_backend(&settings, backend);
let repo = &test_workspace.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let initial = create_random_commit(tx.mut_repo(), &settings)
.set_parents(vec![repo.store().root_commit_id().clone()])
.write()
.unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
// Simulate a crash that resulted in the old op-head left in place. We simulate
// it somewhat hackily by copying the .jj/op_heads/ directory before the
@ -200,12 +200,12 @@ fn test_bad_locking_interrupted(backend: TestRepoBackend) {
let op_heads_dir = repo.repo_path().join("op_heads");
let backup_path = test_workspace.root_dir().join("backup");
copy_directory(&op_heads_dir, &backup_path);
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
create_random_commit(tx.mut_repo(), &settings)
.set_parents(vec![initial.id().clone()])
.write()
.unwrap();
let op_id = tx.commit().operation().id().clone();
let op_id = tx.commit("test").operation().id().clone();
copy_directory(&backup_path, &op_heads_dir);
// Reload the repo and check that only the new head is present.

24
lib/tests/test_commit_builder.rs
View file

@ -43,7 +43,7 @@ fn test_initial(backend: TestRepoBackend) {
],
);
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let author_signature = Signature {
name: "author name".to_string(),
email: "author email".to_string(),
@ -75,7 +75,7 @@ fn test_initial(backend: TestRepoBackend) {
assert_eq!(builder.author(), &author_signature);
assert_eq!(builder.committer(), &committer_signature);
let commit = builder.write().unwrap();
tx.commit();
tx.commit("test");
assert_eq!(commit.parents(), vec![store.root_commit()]);
assert_eq!(commit.predecessors(), vec![]);
@ -115,7 +115,7 @@ fn test_rewrite(backend: TestRepoBackend) {
],
);
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let initial_commit = tx
.mut_repo()
.new_commit(
@ -125,7 +125,7 @@ fn test_rewrite(backend: TestRepoBackend) {
)
.write()
.unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
let rewritten_tree = create_tree(
&repo,
@ -143,7 +143,7 @@ fn test_rewrite(backend: TestRepoBackend) {
.build()
.unwrap();
let rewrite_settings = UserSettings::from_config(config);
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let rewritten_commit = tx
.mut_repo()
.rewrite_commit(&rewrite_settings, &initial_commit)
@ -151,7 +151,7 @@ fn test_rewrite(backend: TestRepoBackend) {
.write()
.unwrap();
tx.mut_repo().rebase_descendants(&settings).unwrap();
tx.commit();
tx.commit("test");
assert_eq!(rewritten_commit.parents(), vec![store.root_commit()]);
assert_eq!(
rewritten_commit.predecessors(),
@ -203,7 +203,7 @@ fn test_rewrite_update_missing_user(backend: TestRepoBackend) {
let test_repo = TestRepo::init_with_backend(backend);
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&missing_user_settings, "test");
let mut tx = repo.start_transaction(&missing_user_settings);
let initial_commit = tx
.mut_repo()
.new_commit(
@ -252,15 +252,15 @@ fn test_commit_builder_descendants(backend: TestRepoBackend) {
let repo = &test_repo.repo;
let store = repo.store().clone();
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit1 = graph_builder.initial_commit();
let commit2 = graph_builder.commit_with_parents(&[&commit1]);
let commit3 = graph_builder.commit_with_parents(&[&commit2]);
let repo = tx.commit();
let repo = tx.commit("test");
// Test with for_new_commit()
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
tx.mut_repo()
.new_commit(
&settings,
@ -273,7 +273,7 @@ fn test_commit_builder_descendants(backend: TestRepoBackend) {
assert!(rebaser.rebase_next().unwrap().is_none());
// Test with for_rewrite_from()
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let commit4 = tx
.mut_repo()
.rewrite_commit(&settings, &commit2)
@ -284,7 +284,7 @@ fn test_commit_builder_descendants(backend: TestRepoBackend) {
assert!(rebaser.rebase_next().unwrap().is_none());
// Test with for_rewrite_from() but new change id
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
tx.mut_repo()
.rewrite_commit(&settings, &commit2)
.generate_new_change_id()

8
lib/tests/test_commit_concurrent.rs
View file

@ -54,9 +54,9 @@ fn test_commit_parallel(backend: TestRepoBackend) {
let settings = settings.clone();
let repo = repo.clone();
s.spawn(move || {
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
write_random_commit(tx.mut_repo(), &settings);
tx.commit();
tx.commit("test");
});
}
});
@ -85,9 +85,9 @@ fn test_commit_parallel_instances(backend: TestRepoBackend) {
let settings = settings.clone();
let repo = load_repo_at_head(&settings, repo.repo_path());
s.spawn(move || {
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
write_random_commit(tx.mut_repo(), &settings);
tx.commit();
tx.commit("test");
});
}
});

24
lib/tests/test_default_revset_graph_iterator.rs
View file

@ -64,13 +64,13 @@ fn test_graph_iterator_linearized(skip_transitive_edges: bool) {
// A ~
// |
// root
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.commit_with_parents(&[&commit_a]);
let commit_c = graph_builder.commit_with_parents(&[&commit_a]);
let commit_d = graph_builder.commit_with_parents(&[&commit_b, &commit_c]);
let repo = tx.commit();
let repo = tx.commit("test");
let root_commit = repo.store().root_commit();
let revset = revset_for_commits(repo.as_ref(), &[&commit_a, &commit_d]);
@ -102,7 +102,7 @@ fn test_graph_iterator_virtual_octopus(skip_transitive_edges: bool) {
// A B C A B C
// \|/ ~ ~ ~
// root
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.initial_commit();
@ -110,7 +110,7 @@ fn test_graph_iterator_virtual_octopus(skip_transitive_edges: bool) {
let commit_d = graph_builder.commit_with_parents(&[&commit_a, &commit_b]);
let commit_e = graph_builder.commit_with_parents(&[&commit_b, &commit_c]);
let commit_f = graph_builder.commit_with_parents(&[&commit_d, &commit_e]);
let repo = tx.commit();
let repo = tx.commit("test");
let root_commit = repo.store().root_commit();
let revset = revset_for_commits(repo.as_ref(), &[&commit_a, &commit_b, &commit_c, &commit_f]);
@ -154,14 +154,14 @@ fn test_graph_iterator_simple_fork(skip_transitive_edges: bool) {
// A
// |
// root
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.commit_with_parents(&[&commit_a]);
let commit_c = graph_builder.commit_with_parents(&[&commit_b]);
let commit_d = graph_builder.commit_with_parents(&[&commit_b]);
let commit_e = graph_builder.commit_with_parents(&[&commit_d]);
let repo = tx.commit();
let repo = tx.commit("test");
let root_commit = repo.store().root_commit();
let revset = revset_for_commits(repo.as_ref(), &[&commit_a, &commit_c, &commit_e]);
@ -194,7 +194,7 @@ fn test_graph_iterator_multiple_missing(skip_transitive_edges: bool) {
// a B c ~
// \|/
// root
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.initial_commit();
@ -202,7 +202,7 @@ fn test_graph_iterator_multiple_missing(skip_transitive_edges: bool) {
let commit_d = graph_builder.commit_with_parents(&[&commit_a, &commit_b]);
let commit_e = graph_builder.commit_with_parents(&[&commit_b, &commit_c]);
let commit_f = graph_builder.commit_with_parents(&[&commit_d, &commit_e]);
let repo = tx.commit();
let repo = tx.commit("test");
let root_commit = repo.store().root_commit();
let revset = revset_for_commits(repo.as_ref(), &[&commit_b, &commit_f]);
@ -239,7 +239,7 @@ fn test_graph_iterator_edge_to_ancestor(skip_transitive_edges: bool) {
// a
// |
// root
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.initial_commit();
@ -247,7 +247,7 @@ fn test_graph_iterator_edge_to_ancestor(skip_transitive_edges: bool) {
let commit_d = graph_builder.commit_with_parents(&[&commit_b, &commit_c]);
let commit_e = graph_builder.commit_with_parents(&[&commit_c]);
let commit_f = graph_builder.commit_with_parents(&[&commit_d, &commit_e]);
let repo = tx.commit();
let repo = tx.commit("test");
let revset = revset_for_commits(repo.as_ref(), &[&commit_c, &commit_d, &commit_f]);
let commits = revset
@ -290,7 +290,7 @@ fn test_graph_iterator_edge_escapes_from_(skip_transitive_edges: bool) {
// A
// |
// root
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.commit_with_parents(&[&commit_a]);
@ -302,7 +302,7 @@ fn test_graph_iterator_edge_escapes_from_(skip_transitive_edges: bool) {
let commit_h = graph_builder.commit_with_parents(&[&commit_f]);
let commit_i = graph_builder.commit_with_parents(&[&commit_e, &commit_h]);
let commit_j = graph_builder.commit_with_parents(&[&commit_g, &commit_i]);
let repo = tx.commit();
let repo = tx.commit("test");
let root_commit = repo.store().root_commit();
let revset = revset_for_commits(

246
lib/tests/test_git.rs
View file

@ -106,10 +106,10 @@ fn test_import_refs() {
git_repo.set_head("refs/heads/main").unwrap();
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let stats = git::import_refs(tx.mut_repo(), &git_settings).unwrap();
tx.mut_repo().rebase_descendants(&settings).unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
let view = repo.view();
assert!(stats.abandoned_commits.is_empty());
@ -225,10 +225,10 @@ fn test_import_refs_reimport() {
.reference("refs/tags/my-gpg-key", pgp_key_oid, false, "")
.unwrap();
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let stats = git::import_refs(tx.mut_repo(), &git_settings).unwrap();
tx.mut_repo().rebase_descendants(&settings).unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
assert!(stats.abandoned_commits.is_empty());
let expected_heads = hashset! {
@ -244,19 +244,19 @@ fn test_import_refs_reimport() {
let commit5 = empty_git_commit(&git_repo, "refs/heads/feature2", &[&commit2]);
// Also modify feature2 on the jj side
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let commit6 = create_random_commit(tx.mut_repo(), &settings)
.set_parents(vec![jj_id(&commit2)])
.write()
.unwrap();
tx.mut_repo()
.set_local_branch_target("feature2", RefTarget::normal(commit6.id().clone()));
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let stats = git::import_refs(tx.mut_repo(), &git_settings).unwrap();
tx.mut_repo().rebase_descendants(&settings).unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
assert_eq!(
// The order is unstable just because we import heads from Git repo.
@ -329,7 +329,7 @@ fn test_import_refs_reimport_head_removed() {
let git_repo = get_git_repo(repo);
let commit = empty_git_commit(&git_repo, "refs/heads/main", &[]);
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
git::import_refs(tx.mut_repo(), &git_settings).unwrap();
tx.mut_repo().rebase_descendants(&settings).unwrap();
let commit_id = jj_id(&commit);
@ -356,7 +356,7 @@ fn test_import_refs_reimport_git_head_counts() {
let commit = empty_git_commit(&git_repo, "refs/heads/main", &[]);
git_repo.set_head_detached(commit.id()).unwrap();
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
git::import_refs(tx.mut_repo(), &git_settings).unwrap();
tx.mut_repo().rebase_descendants(&settings).unwrap();
@ -382,7 +382,7 @@ fn test_import_refs_reimport_git_head_without_ref() {
let git_repo = get_git_repo(repo);
// First, HEAD points to commit1.
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let commit1 = write_random_commit(tx.mut_repo(), &settings);
let commit2 = write_random_commit(tx.mut_repo(), &settings);
git_repo.set_head_detached(git_id(&commit1)).unwrap();
@ -416,7 +416,7 @@ fn test_import_refs_reimport_git_head_with_moved_ref() {
let git_repo = get_git_repo(repo);
// First, both HEAD and main point to commit1.
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let commit1 = write_random_commit(tx.mut_repo(), &settings);
let commit2 = write_random_commit(tx.mut_repo(), &settings);
git_repo
@ -469,10 +469,10 @@ fn test_import_refs_reimport_with_deleted_remote_ref() {
commit_remote_and_local.id(),
);
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
git::import_refs(tx.mut_repo(), &git_settings).unwrap();
tx.mut_repo().rebase_descendants(&settings).unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
let expected_heads = hashset! {
jj_id(&commit_main),
@ -525,10 +525,10 @@ fn test_import_refs_reimport_with_deleted_remote_ref() {
delete_git_ref(&git_repo, "refs/remotes/origin/feature-remote-only");
delete_git_ref(&git_repo, "refs/remotes/origin/feature-remote-and-local");
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
git::import_refs(tx.mut_repo(), &git_settings).unwrap();
tx.mut_repo().rebase_descendants(&settings).unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
let view = repo.view();
// The local branches were indeed deleted
@ -585,10 +585,10 @@ fn test_import_refs_reimport_with_moved_remote_ref() {
commit_remote_and_local.id(),
);
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
git::import_refs(tx.mut_repo(), &git_settings).unwrap();
tx.mut_repo().rebase_descendants(&settings).unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
let expected_heads = hashset! {
jj_id(&commit_main),
@ -651,10 +651,10 @@ fn test_import_refs_reimport_with_moved_remote_ref() {
&[&commit_base],
);
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
git::import_refs(tx.mut_repo(), &git_settings).unwrap();
tx.mut_repo().rebase_descendants(&settings).unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
let view = repo.view();
assert_eq!(view.branches().count(), 3);
@ -718,10 +718,10 @@ fn test_import_refs_reimport_with_moved_untracked_remote_ref() {
let remote_ref_name = "refs/remotes/origin/feature";
let commit_base = empty_git_commit(&git_repo, remote_ref_name, &[]);
let commit_remote_t0 = empty_git_commit(&git_repo, remote_ref_name, &[&commit_base]);
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
git::import_refs(tx.mut_repo(), &git_settings).unwrap();
tx.mut_repo().rebase_descendants(&settings).unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
let view = repo.view();
assert_eq!(*view.heads(), hashset! { jj_id(&commit_remote_t0) });
@ -738,10 +738,10 @@ fn test_import_refs_reimport_with_moved_untracked_remote_ref() {
// Move the reference remotely and fetch the changes.
delete_git_ref(&git_repo, remote_ref_name);
let commit_remote_t1 = empty_git_commit(&git_repo, remote_ref_name, &[&commit_base]);
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
git::import_refs(tx.mut_repo(), &git_settings).unwrap();
tx.mut_repo().rebase_descendants(&settings).unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
let view = repo.view();
// commit_remote_t0 should be abandoned, but commit_base shouldn't because
@ -768,7 +768,7 @@ fn test_import_refs_reimport_git_head_with_fixed_ref() {
let git_repo = get_git_repo(repo);
// First, both HEAD and main point to commit1.
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let commit1 = write_random_commit(tx.mut_repo(), &settings);
let commit2 = write_random_commit(tx.mut_repo(), &settings);
git_repo
@ -803,7 +803,7 @@ fn test_import_refs_reimport_all_from_root_removed() {
let git_repo = get_git_repo(repo);
let commit = empty_git_commit(&git_repo, "refs/heads/main", &[]);
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
git::import_refs(tx.mut_repo(), &git_settings).unwrap();
tx.mut_repo().rebase_descendants(&settings).unwrap();
// Test the setup
@ -834,7 +834,7 @@ fn test_import_refs_reimport_abandoning_disabled() {
let commit1 = empty_git_commit(&git_repo, "refs/heads/main", &[]);
let commit2 = empty_git_commit(&git_repo, "refs/heads/delete-me", &[&commit1]);
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
git::import_refs(tx.mut_repo(), &git_settings).unwrap();
tx.mut_repo().rebase_descendants(&settings).unwrap();
// Test the setup
@ -861,12 +861,12 @@ fn test_import_refs_reimport_conflicted_remote_branch() {
let commit1 = empty_git_commit(&git_repo, "refs/heads/commit1", &[]);
git_ref(&git_repo, "refs/remotes/origin/main", commit1.id());
let mut tx1 = repo.start_transaction(&settings, "test");
let mut tx1 = repo.start_transaction(&settings);
git::import_refs(tx1.mut_repo(), &git_settings).unwrap();
let commit2 = empty_git_commit(&git_repo, "refs/heads/commit2", &[]);
git_ref(&git_repo, "refs/remotes/origin/main", commit2.id());
let mut tx2 = repo.start_transaction(&settings, "test");
let mut tx2 = repo.start_transaction(&settings);
git::import_refs(tx2.mut_repo(), &git_settings).unwrap();
// Remote branch can diverge by concurrent operations (like `jj git fetch`)
@ -884,9 +884,9 @@ fn test_import_refs_reimport_conflicted_remote_branch() {
);
// The conflict can be resolved by importing the current Git state
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
git::import_refs(tx.mut_repo(), &git_settings).unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
assert_eq!(
repo.view().get_git_ref("refs/remotes/origin/main"),
&RefTarget::normal(jj_id(&commit2)),
@ -910,7 +910,7 @@ fn test_import_refs_reserved_remote_name() {
empty_git_commit(&git_repo, "refs/remotes/git/main", &[]);
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let result = git::import_refs(tx.mut_repo(), &git_settings);
assert_matches!(result, Err(GitImportError::RemoteReservedForLocalGitRepo));
}
@ -943,7 +943,7 @@ fn test_import_some_refs() {
}
// Import branches feature1, feature2, and feature3.
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
git::import_some_refs(tx.mut_repo(), &git_settings, |ref_name| {
get_remote_branch(ref_name)
.map(|branch| branch.starts_with("feature"))
@ -951,7 +951,7 @@ fn test_import_some_refs() {
})
.unwrap();
tx.mut_repo().rebase_descendants(&settings).unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
// There are two heads, feature2 and feature4.
let view = repo.view();
@ -1022,13 +1022,13 @@ fn test_import_some_refs() {
delete_git_ref(&git_repo, "refs/remotes/origin/feature1");
delete_git_ref(&git_repo, "refs/remotes/origin/feature3");
delete_git_ref(&git_repo, "refs/remotes/origin/feature4");
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
git::import_some_refs(tx.mut_repo(), &git_settings, |ref_name| {
get_remote_branch(ref_name) == Some("feature2")
})
.unwrap();
tx.mut_repo().rebase_descendants(&settings).unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
// feature2 and feature4 will still be heads, and all four branches should be
// present.
@ -1038,14 +1038,14 @@ fn test_import_some_refs() {
// Import feature1: this should cause the branch to be deleted, but the
// corresponding commit should stay because it is reachable from feature2.
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
git::import_some_refs(tx.mut_repo(), &git_settings, |ref_name| {
get_remote_branch(ref_name) == Some("feature1")
})
.unwrap();
// No descendant should be rewritten.
assert_eq!(tx.mut_repo().rebase_descendants(&settings).unwrap(), 0);
let repo = tx.commit();
let repo = tx.commit("test");
// feature2 and feature4 should still be the heads, and all three branches
// feature2, feature3, and feature3 should exist.
@ -1055,14 +1055,14 @@ fn test_import_some_refs() {
// Import feature3: this should cause the branch to be deleted, but
// feature4 should be left alone even though it is no longer in git.
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
git::import_some_refs(tx.mut_repo(), &git_settings, |ref_name| {
get_remote_branch(ref_name) == Some("feature3")
})
.unwrap();
// No descendant should be rewritten
assert_eq!(tx.mut_repo().rebase_descendants(&settings).unwrap(), 0);
let repo = tx.commit();
let repo = tx.commit("test");
// feature2 and feature4 should still be the heads, and both branches
// should exist.
@ -1071,14 +1071,14 @@ fn test_import_some_refs() {
assert_eq!(*view.heads(), expected_heads);
// Import feature4: both the head and the branch will disappear.
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
git::import_some_refs(tx.mut_repo(), &git_settings, |ref_name| {
get_remote_branch(ref_name) == Some("feature4")
})
.unwrap();
// No descendant should be rewritten
assert_eq!(tx.mut_repo().rebase_descendants(&settings).unwrap(), 0);
let repo = tx.commit();
let repo = tx.commit("test");
// feature2 should now be the only head and only branch.
let view = repo.view();
@ -1148,14 +1148,12 @@ fn test_import_refs_empty_git_repo() {
let test_data = GitRepoData::create();
let git_settings = GitSettings::default();
let heads_before = test_data.repo.view().heads().clone();
let mut tx = test_data
.repo
.start_transaction(&test_data.settings, "test");
let mut tx = test_data.repo.start_transaction(&test_data.settings);
git::import_refs(tx.mut_repo(), &git_settings).unwrap();
tx.mut_repo()
.rebase_descendants(&test_data.settings)
.unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
assert_eq!(*repo.view().heads(), heads_before);
assert_eq!(repo.view().branches().count(), 0);
assert_eq!(repo.view().tags().len(), 0);
@ -1183,7 +1181,7 @@ fn test_import_refs_missing_git_commit() {
// Missing commit is ancestor of ref
git_repo.set_head("refs/heads/unborn").unwrap();
fs::rename(&object_file, &backup_object_file).unwrap();
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let result = git::import_refs(tx.mut_repo(), &git_settings);
assert_matches!(
result,
@ -1200,7 +1198,7 @@ fn test_import_refs_missing_git_commit() {
.delete()
.unwrap();
git_repo.set_head_detached(commit2.id()).unwrap();
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let result = git::import_refs(tx.mut_repo(), &git_settings);
assert_matches!(
result,
@ -1218,7 +1216,7 @@ fn test_import_refs_missing_git_commit() {
.unwrap();
git_repo.set_head("refs/heads/unborn").unwrap();
fs::rename(&object_file, &backup_object_file).unwrap();
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let result = git::import_refs(tx.mut_repo(), &git_settings);
assert!(result.is_ok());
@ -1232,7 +1230,7 @@ fn test_import_refs_missing_git_commit() {
.unwrap();
git_repo.set_head_detached(commit1.id()).unwrap();
fs::rename(&object_file, &backup_object_file).unwrap();
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let result = git::import_refs(tx.mut_repo(), &git_settings);
assert!(result.is_ok());
}
@ -1252,14 +1250,12 @@ fn test_import_refs_detached_head() {
.unwrap();
test_data.git_repo.set_head_detached(commit1.id()).unwrap();
let mut tx = test_data
.repo
.start_transaction(&test_data.settings, "test");
let mut tx = test_data.repo.start_transaction(&test_data.settings);
git::import_refs(tx.mut_repo(), &git_settings).unwrap();
tx.mut_repo()
.rebase_descendants(&test_data.settings)
.unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
let expected_heads = hashset! { jj_id(&commit1) };
assert_eq!(*repo.view().heads(), expected_heads);
@ -1276,9 +1272,7 @@ fn test_export_refs_no_detach() {
let git_repo = test_data.git_repo;
let commit1 = empty_git_commit(&git_repo, "refs/heads/main", &[]);
git_repo.set_head("refs/heads/main").unwrap();
let mut tx = test_data
.repo
.start_transaction(&test_data.settings, "test");
let mut tx = test_data.repo.start_transaction(&test_data.settings);
let mut_repo = tx.mut_repo();
git::import_refs(mut_repo, &git_settings).unwrap();
mut_repo.rebase_descendants(&test_data.settings).unwrap();
@ -1308,9 +1302,7 @@ fn test_export_refs_branch_changed() {
.unwrap();
git_repo.set_head("refs/heads/feature").unwrap();
let mut tx = test_data
.repo
.start_transaction(&test_data.settings, "test");
let mut tx = test_data.repo.start_transaction(&test_data.settings);
let mut_repo = tx.mut_repo();
git::import_refs(mut_repo, &git_settings).unwrap();
mut_repo.rebase_descendants(&test_data.settings).unwrap();
@ -1347,9 +1339,7 @@ fn test_export_refs_current_branch_changed() {
let git_repo = test_data.git_repo;
let commit1 = empty_git_commit(&git_repo, "refs/heads/main", &[]);
git_repo.set_head("refs/heads/main").unwrap();
let mut tx = test_data
.repo
.start_transaction(&test_data.settings, "test");
let mut tx = test_data.repo.start_transaction(&test_data.settings);
let mut_repo = tx.mut_repo();
git::import_refs(mut_repo, &git_settings).unwrap();
mut_repo.rebase_descendants(&test_data.settings).unwrap();
@ -1384,9 +1374,7 @@ fn test_export_refs_unborn_git_branch() {
let git_settings = GitSettings::default();
let git_repo = test_data.git_repo;
git_repo.set_head("refs/heads/main").unwrap();
let mut tx = test_data
.repo
.start_transaction(&test_data.settings, "test");
let mut tx = test_data.repo.start_transaction(&test_data.settings);
let mut_repo = tx.mut_repo();
git::import_refs(mut_repo, &git_settings).unwrap();
mut_repo.rebase_descendants(&test_data.settings).unwrap();
@ -1422,9 +1410,7 @@ fn test_export_import_sequence() {
let test_data = GitRepoData::create();
let git_settings = GitSettings::default();
let git_repo = test_data.git_repo;
let mut tx = test_data
.repo
.start_transaction(&test_data.settings, "test");
let mut tx = test_data.repo.start_transaction(&test_data.settings);
let mut_repo = tx.mut_repo();
let commit_a = write_random_commit(mut_repo, &test_data.settings);
let commit_b = write_random_commit(mut_repo, &test_data.settings);
@ -1479,9 +1465,7 @@ fn test_import_export_non_tracking_branch() {
let git_repo = test_data.git_repo;
let commit_main_t0 = empty_git_commit(&git_repo, "refs/remotes/origin/main", &[]);
let mut tx = test_data
.repo
.start_transaction(&test_data.settings, "test");
let mut tx = test_data.repo.start_transaction(&test_data.settings);
let mut_repo = tx.mut_repo();
git::import_refs(mut_repo, &git_settings).unwrap();
@ -1563,9 +1547,7 @@ fn test_export_conflicts() {
// We skip export of conflicted branches
let test_data = GitRepoData::create();
let git_repo = test_data.git_repo;
let mut tx = test_data
.repo
.start_transaction(&test_data.settings, "test");
let mut tx = test_data.repo.start_transaction(&test_data.settings);
let mut_repo = tx.mut_repo();
let commit_a = write_random_commit(mut_repo, &test_data.settings);
let commit_b = write_random_commit(mut_repo, &test_data.settings);
@ -1623,9 +1605,7 @@ fn test_export_conflicts() {
fn test_export_branch_on_root_commit() {
// We skip export of branches pointing to the root commit
let test_data = GitRepoData::create();
let mut tx = test_data
.repo
.start_transaction(&test_data.settings, "test");
let mut tx = test_data.repo.start_transaction(&test_data.settings);
let mut_repo = tx.mut_repo();
mut_repo.set_local_branch_target(
"on_root",
@ -1642,9 +1622,7 @@ fn test_export_partial_failure() {
// Check that we skip branches that fail to export
let test_data = GitRepoData::create();
let git_repo = test_data.git_repo;
let mut tx = test_data
.repo
.start_transaction(&test_data.settings, "test");
let mut tx = test_data.repo.start_transaction(&test_data.settings);
let mut_repo = tx.mut_repo();
let commit_a = write_random_commit(mut_repo, &test_data.settings);
let target = RefTarget::normal(commit_a.id().clone());
@ -1729,9 +1707,7 @@ fn test_export_reexport_transitions() {
// Test exporting after making changes on the jj side, or the git side, or both
let test_data = GitRepoData::create();
let git_repo = test_data.git_repo;
let mut tx = test_data
.repo
.start_transaction(&test_data.settings, "test");
let mut tx = test_data.repo.start_transaction(&test_data.settings);
let mut_repo = tx.mut_repo();
let commit_a = write_random_commit(mut_repo, &test_data.settings);
let commit_b = write_random_commit(mut_repo, &test_data.settings);
@ -1869,9 +1845,7 @@ fn test_export_reexport_transitions() {
fn test_export_undo_reexport() {
let test_data = GitRepoData::create();
let git_repo = test_data.git_repo;
let mut tx = test_data
.repo
.start_transaction(&test_data.settings, "test");
let mut tx = test_data.repo.start_transaction(&test_data.settings);
let mut_repo = tx.mut_repo();
// Initial export
@ -1922,7 +1896,7 @@ fn test_reset_head_to_root() {
Workspace::init_external_git(&settings, &workspace_root, &workspace_root.join(".git"))
.unwrap();
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let root_commit_id = repo.store().root_commit_id();
@ -2005,9 +1979,7 @@ fn test_fetch_empty_repo() {
let test_data = GitRepoData::create();
let git_settings = GitSettings::default();
let mut tx = test_data
.repo
.start_transaction(&test_data.settings, "test");
let mut tx = test_data.repo.start_transaction(&test_data.settings);
let stats = git::fetch(
tx.mut_repo(),
&test_data.git_repo,
@ -2030,9 +2002,7 @@ fn test_fetch_initial_commit() {
let git_settings = GitSettings::default();
let initial_git_commit = empty_git_commit(&test_data.origin_repo, "refs/heads/main", &[]);
let mut tx = test_data
.repo
.start_transaction(&test_data.settings, "test");
let mut tx = test_data.repo.start_transaction(&test_data.settings);
let stats = git::fetch(
tx.mut_repo(),
&test_data.git_repo,
@ -2045,7 +2015,7 @@ fn test_fetch_initial_commit() {
// No default branch because the origin repo's HEAD wasn't set
assert_eq!(stats.default_branch, None);
assert!(stats.import_stats.abandoned_commits.is_empty());
let repo = tx.commit();
let repo = tx.commit("test");
// The initial commit is visible after git::fetch().
let view = repo.view();
assert!(view.heads().contains(&jj_id(&initial_git_commit)));
@ -2079,9 +2049,7 @@ fn test_fetch_success() {
let git_settings = GitSettings::default();
let initial_git_commit = empty_git_commit(&test_data.origin_repo, "refs/heads/main", &[]);
let mut tx = test_data
.repo
.start_transaction(&test_data.settings, "test");
let mut tx = test_data.repo.start_transaction(&test_data.settings);
git::fetch(
tx.mut_repo(),
&test_data.git_repo,
@ -2091,7 +2059,7 @@ fn test_fetch_success() {
&git_settings,
)
.unwrap();
test_data.repo = tx.commit();
test_data.repo = tx.commit("test");
test_data.origin_repo.set_head("refs/heads/main").unwrap();
let new_git_commit = empty_git_commit(
@ -2104,9 +2072,7 @@ fn test_fetch_success() {
.reference("refs/tags/v1.0", new_git_commit.id(), false, "")
.unwrap();
let mut tx = test_data
.repo
.start_transaction(&test_data.settings, "test");
let mut tx = test_data.repo.start_transaction(&test_data.settings);
let stats = git::fetch(
tx.mut_repo(),
&test_data.git_repo,
@ -2119,7 +2085,7 @@ fn test_fetch_success() {
// The default branch is "main"
assert_eq!(stats.default_branch, Some("main".to_string()));
assert!(stats.import_stats.abandoned_commits.is_empty());
let repo = tx.commit();
let repo = tx.commit("test");
// The new commit is visible after we fetch again
let view = repo.view();
assert!(view.heads().contains(&jj_id(&new_git_commit)));
@ -2160,9 +2126,7 @@ fn test_fetch_prune_deleted_ref() {
let git_settings = GitSettings::default();
let commit = empty_git_commit(&test_data.origin_repo, "refs/heads/main", &[]);
let mut tx = test_data
.repo
.start_transaction(&test_data.settings, "test");
let mut tx = test_data.repo.start_transaction(&test_data.settings);
git::fetch(
tx.mut_repo(),
&test_data.git_repo,
@ -2201,9 +2165,7 @@ fn test_fetch_no_default_branch() {
let git_settings = GitSettings::default();
let initial_git_commit = empty_git_commit(&test_data.origin_repo, "refs/heads/main", &[]);
let mut tx = test_data
.repo
.start_transaction(&test_data.settings, "test");
let mut tx = test_data.repo.start_transaction(&test_data.settings);
git::fetch(
tx.mut_repo(),
&test_data.git_repo,
@ -2247,9 +2209,7 @@ fn test_fetch_empty_refspecs() {
empty_git_commit(&test_data.origin_repo, "refs/heads/main", &[]);
// Base refspecs shouldn't be respected
let mut tx = test_data
.repo
.start_transaction(&test_data.settings, "test");
let mut tx = test_data.repo.start_transaction(&test_data.settings);
git::fetch(
tx.mut_repo(),
&test_data.git_repo,
@ -2275,9 +2235,7 @@ fn test_fetch_empty_refspecs() {
fn test_fetch_no_such_remote() {
let test_data = GitRepoData::create();
let git_settings = GitSettings::default();
let mut tx = test_data
.repo
.start_transaction(&test_data.settings, "test");
let mut tx = test_data.repo.start_transaction(&test_data.settings);
let result = git::fetch(
tx.mut_repo(),
&test_data.git_repo,
@ -2332,7 +2290,7 @@ fn set_up_push_repos(settings: &UserSettings, temp_dir: &TempDir) -> PushTestSet
.store()
.get_commit(&jj_id(&initial_git_commit))
.unwrap();
let mut tx = jj_repo.start_transaction(settings, "test");
let mut tx = jj_repo.start_transaction(settings);
let new_commit = create_random_commit(tx.mut_repo(), settings)
.set_parents(vec![initial_commit.id().clone()])
.write()
@ -2351,7 +2309,7 @@ fn set_up_push_repos(settings: &UserSettings, temp_dir: &TempDir) -> PushTestSet
state: RemoteRefState::Tracking,
},
);
let jj_repo = tx.commit();
let jj_repo = tx.commit("test");
PushTestSetup {
source_repo_dir,
jj_repo,
@ -2366,7 +2324,7 @@ fn test_push_branches_success() {
let temp_dir = testutils::new_temp_dir();
let mut setup = set_up_push_repos(&settings, &temp_dir);
let clone_repo = get_git_repo(&setup.jj_repo);
let mut tx = setup.jj_repo.start_transaction(&settings, "test");
let mut tx = setup.jj_repo.start_transaction(&settings);
let targets = GitBranchPushTargets {
branch_updates: vec![(
@ -2420,8 +2378,8 @@ fn test_push_branches_success() {
);
// Check that the repo view reflects the changes in the Git repo
setup.jj_repo = tx.commit();
let mut tx = setup.jj_repo.start_transaction(&settings, "test");
setup.jj_repo = tx.commit("test");
let mut tx = setup.jj_repo.start_transaction(&settings);
git::import_refs(tx.mut_repo(), &GitSettings::default()).unwrap();
assert!(!tx.mut_repo().has_changes());
}
@ -2432,7 +2390,7 @@ fn test_push_branches_deletion() {
let temp_dir = testutils::new_temp_dir();
let mut setup = set_up_push_repos(&settings, &temp_dir);
let clone_repo = get_git_repo(&setup.jj_repo);
let mut tx = setup.jj_repo.start_transaction(&settings, "test");
let mut tx = setup.jj_repo.start_transaction(&settings);
let source_repo = git2::Repository::open(&setup.source_repo_dir).unwrap();
// Test the setup
@ -2473,8 +2431,8 @@ fn test_push_branches_deletion() {
assert!(view.get_remote_branch("main", "origin").is_absent());
// Check that the repo view reflects the changes in the Git repo
setup.jj_repo = tx.commit();
let mut tx = setup.jj_repo.start_transaction(&settings, "test");
setup.jj_repo = tx.commit("test");
let mut tx = setup.jj_repo.start_transaction(&settings);
git::import_refs(tx.mut_repo(), &GitSettings::default()).unwrap();
assert!(!tx.mut_repo().has_changes());
}
@ -2485,7 +2443,7 @@ fn test_push_branches_mixed_deletion_and_addition() {
let temp_dir = testutils::new_temp_dir();
let mut setup = set_up_push_repos(&settings, &temp_dir);
let clone_repo = get_git_repo(&setup.jj_repo);
let mut tx = setup.jj_repo.start_transaction(&settings, "test");
let mut tx = setup.jj_repo.start_transaction(&settings);
let targets = GitBranchPushTargets {
branch_updates: vec![
@ -2543,8 +2501,8 @@ fn test_push_branches_mixed_deletion_and_addition() {
);
// Check that the repo view reflects the changes in the Git repo
setup.jj_repo = tx.commit();
let mut tx = setup.jj_repo.start_transaction(&settings, "test");
setup.jj_repo = tx.commit("test");
let mut tx = setup.jj_repo.start_transaction(&settings);
git::import_refs(tx.mut_repo(), &GitSettings::default()).unwrap();
assert!(!tx.mut_repo().has_changes());
}
@ -2554,10 +2512,10 @@ fn test_push_branches_not_fast_forward() {
let settings = testutils::user_settings();
let temp_dir = testutils::new_temp_dir();
let mut setup = set_up_push_repos(&settings, &temp_dir);
let mut tx = setup.jj_repo.start_transaction(&settings, "test");
let mut tx = setup.jj_repo.start_transaction(&settings);
let new_commit = write_random_commit(tx.mut_repo(), &settings);
setup.jj_repo = tx.commit();
let mut tx = setup.jj_repo.start_transaction(&settings, "test");
setup.jj_repo = tx.commit("test");
let mut tx = setup.jj_repo.start_transaction(&settings);
let targets = GitBranchPushTargets {
branch_updates: vec![(
@ -2584,10 +2542,10 @@ fn test_push_branches_not_fast_forward_with_force() {
let settings = testutils::user_settings();
let temp_dir = testutils::new_temp_dir();
let mut setup = set_up_push_repos(&settings, &temp_dir);
let mut tx = setup.jj_repo.start_transaction(&settings, "test");
let mut tx = setup.jj_repo.start_transaction(&settings);
let new_commit = write_random_commit(tx.mut_repo(), &settings);
setup.jj_repo = tx.commit();
let mut tx = setup.jj_repo.start_transaction(&settings, "test");
setup.jj_repo = tx.commit("test");
let mut tx = setup.jj_repo.start_transaction(&settings);
let targets = GitBranchPushTargets {
branch_updates: vec![(
@ -2709,10 +2667,10 @@ fn test_bulk_update_extra_on_import_refs() {
.count()
};
let import_refs = |repo: &Arc<ReadonlyRepo>| {
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
git::import_refs(tx.mut_repo(), &git_settings).unwrap();
tx.mut_repo().rebase_descendants(&settings).unwrap();
tx.commit()
tx.commit("test")
};
// Extra metadata table shouldn't be created per read_commit() call. The number
@ -2748,14 +2706,14 @@ fn test_rewrite_imported_commit() {
// Import git commit, which generates change id from the commit id.
let git_commit = empty_git_commit(&git_repo, "refs/heads/main", &[]);
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
git::import_refs(tx.mut_repo(), &git_settings).unwrap();
tx.mut_repo().rebase_descendants(&settings).unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
let imported_commit = repo.store().get_commit(&jj_id(&git_commit)).unwrap();
// Try to create identical commit with different change id.
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let authored_commit = tx
.mut_repo()
.new_commit(
@ -2768,7 +2726,7 @@ fn test_rewrite_imported_commit() {
.set_description(imported_commit.description())
.write()
.unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
// Imported commit shouldn't be reused, and the timestamp of the authored
// commit should be adjusted to create new commit.
@ -2807,12 +2765,12 @@ fn test_concurrent_write_commit() {
let sender = sender.clone();
s.spawn(move || {
barrier.wait();
let mut tx = repo.start_transaction(settings, &format!("writer {i}"));
let mut tx = repo.start_transaction(settings);
let commit = create_rooted_commit(tx.mut_repo(), settings)
.set_description("racy commit")
.write()
.unwrap();
tx.commit();
tx.commit(format!("writer {i}"));
sender
.send((commit.id().clone(), commit.change_id().clone()))
.unwrap();
@ -2892,12 +2850,12 @@ fn test_concurrent_read_write_commit() {
let barrier = barrier.clone();
s.spawn(move || {
barrier.wait();
let mut tx = repo.start_transaction(settings, &format!("writer {i}"));
let mut tx = repo.start_transaction(settings);
let commit = create_rooted_commit(tx.mut_repo(), settings)
.set_description(format!("commit {i}"))
.write()
.unwrap();
tx.commit();
tx.commit(format!("writer {i}"));
assert_eq!(commit.id(), commit_id);
});
}
@ -2918,7 +2876,7 @@ fn test_concurrent_read_write_commit() {
}
repo = repo.reload_at_head(settings).unwrap();
let git_backend = get_git_backend(&repo);
let mut tx = repo.start_transaction(settings, &format!("reader {i}"));
let mut tx = repo.start_transaction(settings);
pending_commit_ids = pending_commit_ids
.into_iter()
.filter_map(|commit_id| {
@ -2938,7 +2896,7 @@ fn test_concurrent_read_write_commit() {
})
.collect_vec();
if tx.mut_repo().has_changes() {
tx.commit();
tx.commit(format!("reader {i}"));
}
thread::yield_now();
}

4
lib/tests/test_id_prefix.rs
View file

@ -29,7 +29,7 @@ fn test_id_prefix() {
let root_commit_id = repo.store().root_commit_id();
let root_change_id = repo.store().root_change_id();
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut create_commit = |parent_id: &CommitId| {
let signature = Signature {
name: "Some One".to_string(),
@ -54,7 +54,7 @@ fn test_id_prefix() {
for _ in 0..25 {
commits.push(create_commit(commits.last().unwrap().id()));
}
let repo = tx.commit();
let repo = tx.commit("test");
// Print the commit IDs and change IDs for reference
let commit_prefixes = commits

40
lib/tests/test_index.rs
View file

@ -81,7 +81,7 @@ fn test_index_commits_standard_cases() {
// o root
let root_commit_id = repo.store().root_commit_id();
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.commit_with_parents(&[&commit_a]);
@ -91,7 +91,7 @@ fn test_index_commits_standard_cases() {
let commit_f = graph_builder.commit_with_parents(&[&commit_b, &commit_e]);
let commit_g = graph_builder.commit_with_parents(&[&commit_f]);
let commit_h = graph_builder.commit_with_parents(&[&commit_e]);
let repo = tx.commit();
let repo = tx.commit("test");
let index = as_readonly_composite(&repo);
// There should be the root commit, plus 8 more
@ -138,7 +138,7 @@ fn test_index_commits_criss_cross() {
// Create a long chain of criss-crossed merges. If they were traversed without
// keeping track of visited nodes, it would be 2^50 visits, so if this test
// finishes in reasonable time, we know that we don't do a naive traversal.
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let mut left_commits = vec![graph_builder.initial_commit()];
let mut right_commits = vec![graph_builder.initial_commit()];
@ -150,7 +150,7 @@ fn test_index_commits_criss_cross() {
left_commits.push(new_left);
right_commits.push(new_right);
}
let repo = tx.commit();
let repo = tx.commit("test");
let index = as_readonly_composite(&repo);
// There should the root commit, plus 2 for each generation
@ -275,16 +275,16 @@ fn test_index_commits_previous_operations() {
// |/
// o root
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.commit_with_parents(&[&commit_a]);
let commit_c = graph_builder.commit_with_parents(&[&commit_b]);
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
tx.mut_repo().remove_head(commit_c.id());
let repo = tx.commit();
let repo = tx.commit("test");
// Delete index from disk
let index_operations_dir = repo.repo_path().join("index").join("operations");
@ -323,24 +323,24 @@ fn test_index_commits_incremental() {
// o root
let root_commit = repo.store().root_commit();
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let commit_a = child_commit(tx.mut_repo(), &settings, &root_commit)
.write()
.unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
let index = as_readonly_composite(&repo);
// There should be the root commit, plus 1 more
assert_eq!(index.num_commits(), 1 + 1);
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let commit_b = child_commit(tx.mut_repo(), &settings, &commit_a)
.write()
.unwrap();
let commit_c = child_commit(tx.mut_repo(), &settings, &commit_b)
.write()
.unwrap();
tx.commit();
tx.commit("test");
let repo = load_repo_at_head(&settings, repo.repo_path());
let index = as_readonly_composite(&repo);
@ -374,17 +374,17 @@ fn test_index_commits_incremental_empty_transaction() {
// o root
let root_commit = repo.store().root_commit();
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let commit_a = child_commit(tx.mut_repo(), &settings, &root_commit)
.write()
.unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
let index = as_readonly_composite(&repo);
// There should be the root commit, plus 1 more
assert_eq!(index.num_commits(), 1 + 1);
repo.start_transaction(&settings, "test").commit();
repo.start_transaction(&settings).commit("test");
let repo = load_repo_at_head(&settings, repo.repo_path());
let index = as_readonly_composite(&repo);
@ -416,15 +416,15 @@ fn test_index_commits_incremental_already_indexed() {
// o root
let root_commit = repo.store().root_commit();
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let commit_a = child_commit(tx.mut_repo(), &settings, &root_commit)
.write()
.unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
assert!(repo.index().has_id(commit_a.id()));
assert_eq!(as_readonly_composite(&repo).num_commits(), 1 + 1);
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
mut_repo.add_head(&commit_a);
assert_eq!(as_mutable_composite(mut_repo).num_commits(), 1 + 1);
@ -436,11 +436,11 @@ fn create_n_commits(
repo: &Arc<ReadonlyRepo>,
num_commits: i32,
) -> Arc<ReadonlyRepo> {
let mut tx = repo.start_transaction(settings, "test");
let mut tx = repo.start_transaction(settings);
for _ in 0..num_commits {
write_random_commit(tx.mut_repo(), settings);
}
tx.commit()
tx.commit("test")
}
fn as_readonly_composite(repo: &Arc<ReadonlyRepo>) -> CompositeIndex<'_> {

8
lib/tests/test_init.rs
View file

@ -43,7 +43,7 @@ fn test_init_local() {
assert_eq!(workspace.workspace_root(), &canonical);
// Just test that we can write a commit to the store
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
write_random_commit(tx.mut_repo(), &settings);
}
@ -71,7 +71,7 @@ fn test_init_internal_git() {
);
// Just test that we can write a commit to the store
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
write_random_commit(tx.mut_repo(), &settings);
}
@ -96,7 +96,7 @@ fn test_init_colocated_git() {
);
// Just test that we can write a commit to the store
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
write_random_commit(tx.mut_repo(), &settings);
}
@ -134,7 +134,7 @@ fn test_init_external_git() {
);
// Just test that we can write a commit to the store
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
write_random_commit(tx.mut_repo(), &settings);
}

8
lib/tests/test_load_repo.rs
View file

@ -21,13 +21,13 @@ fn test_load_at_operation() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "add commit");
let mut tx = repo.start_transaction(&settings);
let commit = write_random_commit(tx.mut_repo(), &settings);
let repo = tx.commit();
let repo = tx.commit("add commit");
let mut tx = repo.start_transaction(&settings, "remove commit");
let mut tx = repo.start_transaction(&settings);
tx.mut_repo().remove_head(commit.id());
tx.commit();
tx.commit("remove commit");
// If we load the repo at head, we should not see the commit since it was
// removed

8
lib/tests/test_local_working_copy.rs
View file

@ -159,9 +159,9 @@ fn test_checkout_file_transitions(backend: TestRepoBackend) {
return;
}
Kind::GitSubmodule => {
let mut tx = repo.start_transaction(settings, "test");
let mut tx = repo.start_transaction(settings);
let id = write_random_commit(tx.mut_repo(), settings).id().clone();
tx.commit();
tx.commit("test");
Merge::normal(TreeValue::GitSubmodule(id))
}
};
@ -847,9 +847,9 @@ fn test_gitsubmodule() {
},
);
let mut tx = repo.start_transaction(&settings, "create submodule commit");
let mut tx = repo.start_transaction(&settings);
let submodule_id = write_random_commit(tx.mut_repo(), &settings).id().clone();
tx.commit();
tx.commit("create submodule commit");
tree_builder.set(
submodule_path.to_owned(),

4
lib/tests/test_merge_trees.rs
View file

@ -551,7 +551,7 @@ fn test_simplify_conflict_after_resolving_parent() {
// rebase C2 (the rebased C) onto the resolved conflict. C3 should not have
// a conflict since it changed an unrelated line.
let path = RepoPath::from_internal_string("dir/file");
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let tree_a = create_tree(repo, &[(path, "abc\ndef\nghi\n")]);
let commit_a = tx
.mut_repo()
@ -601,7 +601,7 @@ fn test_simplify_conflict_after_resolving_parent() {
.unwrap();
let commit_c3 = rebase_commit(&settings, tx.mut_repo(), &commit_c2, &[commit_b3]).unwrap();
tx.mut_repo().rebase_descendants(&settings).unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
// The conflict should now be resolved.
let tree_c2 = commit_c3.tree().unwrap();

126
lib/tests/test_mut_repo.rs
View file

@ -27,14 +27,14 @@ fn test_edit() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let wc_commit = write_random_commit(tx.mut_repo(), &settings);
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let ws_id = WorkspaceId::default();
tx.mut_repo().edit(ws_id.clone(), &wc_commit).unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
assert_eq!(repo.view().get_wc_commit_id(&ws_id), Some(wc_commit.id()));
}
@ -45,11 +45,11 @@ fn test_checkout() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let wc_commit_parent = write_random_commit(tx.mut_repo(), &settings);
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let ws_id = WorkspaceId::default();
let wc_commit = tx
.mut_repo()
@ -58,7 +58,7 @@ fn test_checkout() {
assert_eq!(wc_commit.tree_id(), wc_commit_parent.tree_id());
assert_eq!(wc_commit.parents().len(), 1);
assert_eq!(wc_commit.parents()[0].id(), wc_commit_parent.id());
let repo = tx.commit();
let repo = tx.commit("test");
assert_eq!(repo.view().get_wc_commit_id(&ws_id), Some(wc_commit.id()));
}
@ -70,14 +70,14 @@ fn test_checkout_previous_not_empty() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let old_wc_commit = write_random_commit(mut_repo, &settings);
let ws_id = WorkspaceId::default();
mut_repo.edit(ws_id.clone(), &old_wc_commit).unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let new_wc_commit = write_random_commit(mut_repo, &settings);
mut_repo.edit(ws_id, &new_wc_commit).unwrap();
@ -93,7 +93,7 @@ fn test_checkout_previous_empty() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let old_wc_commit = mut_repo
.new_commit(
@ -105,9 +105,9 @@ fn test_checkout_previous_empty() {
.unwrap();
let ws_id = WorkspaceId::default();
mut_repo.edit(ws_id.clone(), &old_wc_commit).unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let new_wc_commit = write_random_commit(mut_repo, &settings);
mut_repo.edit(ws_id, &new_wc_commit).unwrap();
@ -123,7 +123,7 @@ fn test_checkout_previous_empty_with_description() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let old_wc_commit = mut_repo
.new_commit(
@ -136,9 +136,9 @@ fn test_checkout_previous_empty_with_description() {
.unwrap();
let ws_id = WorkspaceId::default();
mut_repo.edit(ws_id.clone(), &old_wc_commit).unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let new_wc_commit = write_random_commit(mut_repo, &settings);
mut_repo.edit(ws_id, &new_wc_commit).unwrap();
@ -154,7 +154,7 @@ fn test_checkout_previous_empty_with_local_branch() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let old_wc_commit = mut_repo
.new_commit(
@ -167,9 +167,9 @@ fn test_checkout_previous_empty_with_local_branch() {
mut_repo.set_local_branch_target("b", RefTarget::normal(old_wc_commit.id().clone()));
let ws_id = WorkspaceId::default();
mut_repo.edit(ws_id.clone(), &old_wc_commit).unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let new_wc_commit = write_random_commit(mut_repo, &settings);
mut_repo.edit(ws_id, &new_wc_commit).unwrap();
@ -185,7 +185,7 @@ fn test_checkout_previous_empty_non_head() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let old_wc_commit = mut_repo
.new_commit(
@ -205,9 +205,9 @@ fn test_checkout_previous_empty_non_head() {
.unwrap();
let ws_id = WorkspaceId::default();
mut_repo.edit(ws_id.clone(), &old_wc_commit).unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let new_wc_commit = write_random_commit(mut_repo, &settings);
mut_repo.edit(ws_id, &new_wc_commit).unwrap();
@ -226,16 +226,16 @@ fn test_edit_initial() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let wc_commit = write_random_commit(tx.mut_repo(), &settings);
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let workspace_id = WorkspaceId::new("new-workspace".to_string());
tx.mut_repo()
.edit(workspace_id.clone(), &wc_commit)
.unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
assert_eq!(
repo.view().get_wc_commit_id(&workspace_id),
Some(wc_commit.id())
@ -252,18 +252,18 @@ fn test_add_head_success() {
// Create a commit outside of the repo by using a temporary transaction. Then
// add that as a head.
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let new_commit = write_random_commit(tx.mut_repo(), &settings);
drop(tx);
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
assert!(!mut_repo.view().heads().contains(new_commit.id()));
assert!(!mut_repo.index().has_id(new_commit.id()));
mut_repo.add_head(&new_commit);
assert!(mut_repo.view().heads().contains(new_commit.id()));
assert!(mut_repo.index().has_id(new_commit.id()));
let repo = tx.commit();
let repo = tx.commit("test");
assert!(repo.view().heads().contains(new_commit.id()));
assert!(repo.index().has_id(new_commit.id()));
}
@ -276,15 +276,15 @@ fn test_add_head_ancestor() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit1 = graph_builder.initial_commit();
let commit2 = graph_builder.commit_with_parents(&[&commit1]);
let commit3 = graph_builder.commit_with_parents(&[&commit2]);
let repo = tx.commit();
let repo = tx.commit("test");
assert_eq!(repo.view().heads(), &hashset! {commit3.id().clone()});
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
mut_repo.add_head(&commit1);
assert_eq!(repo.view().heads(), &hashset! {commit3.id().clone()});
@ -298,13 +298,13 @@ fn test_add_head_not_immediate_child() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let initial = write_random_commit(tx.mut_repo(), &settings);
let repo = tx.commit();
let repo = tx.commit("test");
// Create some commits outside of the repo by using a temporary transaction.
// Then add one of them as a head.
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let rewritten = create_random_commit(tx.mut_repo(), &settings)
.set_change_id(initial.change_id().clone())
.set_predecessors(vec![initial.id().clone()])
@ -317,7 +317,7 @@ fn test_add_head_not_immediate_child() {
drop(tx);
assert_eq!(repo.view().heads(), &hashset! {initial.id().clone()});
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
mut_repo.add_head(&child);
assert_eq!(
@ -338,14 +338,14 @@ fn test_remove_head() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit1 = graph_builder.initial_commit();
let commit2 = graph_builder.commit_with_parents(&[&commit1]);
let commit3 = graph_builder.commit_with_parents(&[&commit2]);
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
assert!(mut_repo.view().heads().contains(commit3.id()));
mut_repo.remove_head(commit3.id());
@ -356,7 +356,7 @@ fn test_remove_head() {
assert!(mut_repo.index().has_id(commit1.id()));
assert!(mut_repo.index().has_id(commit2.id()));
assert!(mut_repo.index().has_id(commit3.id()));
let repo = tx.commit();
let repo = tx.commit("test");
let heads = repo.view().heads().clone();
assert!(!heads.contains(commit3.id()));
assert!(!heads.contains(commit2.id()));
@ -374,16 +374,16 @@ fn test_add_public_head() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let commit1 = write_random_commit(tx.mut_repo(), &settings);
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
assert!(!mut_repo.view().public_heads().contains(commit1.id()));
mut_repo.add_public_head(&commit1);
assert!(mut_repo.view().public_heads().contains(commit1.id()));
let repo = tx.commit();
let repo = tx.commit("test");
assert!(repo.view().public_heads().contains(commit1.id()));
}
@ -395,19 +395,19 @@ fn test_add_public_head_ancestor() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit1 = graph_builder.initial_commit();
let commit2 = graph_builder.commit_with_parents(&[&commit1]);
tx.mut_repo().add_public_head(&commit2);
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
assert!(!mut_repo.view().public_heads().contains(commit1.id()));
mut_repo.add_public_head(&commit1);
assert!(!mut_repo.view().public_heads().contains(commit1.id()));
let repo = tx.commit();
let repo = tx.commit("test");
assert!(!repo.view().public_heads().contains(commit1.id()));
}
@ -419,18 +419,18 @@ fn test_remove_public_head() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let commit1 = write_random_commit(mut_repo, &settings);
mut_repo.add_public_head(&commit1);
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
assert!(mut_repo.view().public_heads().contains(commit1.id()));
mut_repo.remove_public_head(commit1.id());
assert!(!mut_repo.view().public_heads().contains(commit1.id()));
let repo = tx.commit();
let repo = tx.commit("test");
assert!(!repo.view().public_heads().contains(commit1.id()));
}
@ -447,7 +447,7 @@ fn test_has_changed() {
state: RemoteRefState::Tracking, // doesn't matter
};
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let commit1 = write_random_commit(mut_repo, &settings);
let commit2 = write_random_commit(mut_repo, &settings);
@ -459,12 +459,12 @@ fn test_has_changed() {
.unwrap();
mut_repo.set_local_branch_target("main", RefTarget::normal(commit1.id().clone()));
mut_repo.set_remote_branch("main", "origin", normal_remote_ref(commit1.id()));
let repo = tx.commit();
let repo = tx.commit("test");
// Test the setup
assert_eq!(repo.view().heads(), &hashset! {commit1.id().clone()});
assert_eq!(repo.view().public_heads(), &hashset! {commit1.id().clone()});
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
mut_repo.add_public_head(&commit1);
@ -524,16 +524,16 @@ fn test_rebase_descendants_simple() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit1 = graph_builder.initial_commit();
let commit2 = graph_builder.commit_with_parents(&[&commit1]);
let commit3 = graph_builder.commit_with_parents(&[&commit2]);
let commit4 = graph_builder.commit_with_parents(&[&commit1]);
let commit5 = graph_builder.commit_with_parents(&[&commit4]);
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let mut graph_builder = CommitGraphBuilder::new(&settings, mut_repo);
let commit6 = graph_builder.commit_with_parents(&[&commit1]);
@ -561,14 +561,14 @@ fn test_rebase_descendants_conflicting_rewrite() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit1 = graph_builder.initial_commit();
let commit2 = graph_builder.commit_with_parents(&[&commit1]);
let _commit3 = graph_builder.commit_with_parents(&[&commit2]);
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let mut graph_builder = CommitGraphBuilder::new(&settings, mut_repo);
let commit4 = graph_builder.commit_with_parents(&[&commit1]);
@ -592,7 +592,7 @@ fn test_rename_remote() {
let settings = testutils::user_settings();
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let commit = write_random_commit(mut_repo, &settings);
let remote_ref = RemoteRef {

32
lib/tests/test_operations.rs
View file

@ -36,9 +36,9 @@ fn test_unpublished_operation() {
let op_id0 = repo.op_id().clone();
assert_eq!(list_dir(&op_heads_dir), vec![repo.op_id().hex()]);
let mut tx1 = repo.start_transaction(&settings, "transaction 1");
let mut tx1 = repo.start_transaction(&settings);
write_random_commit(tx1.mut_repo(), &settings);
let unpublished_op = tx1.write();
let unpublished_op = tx1.write("transaction 1");
let op_id1 = unpublished_op.operation().id().clone();
assert_ne!(op_id1, op_id0);
assert_eq!(list_dir(&op_heads_dir), vec![op_id0.hex()]);
@ -58,16 +58,16 @@ fn test_consecutive_operations() {
let op_id0 = repo.op_id().clone();
assert_eq!(list_dir(&op_heads_dir), vec![repo.op_id().hex()]);
let mut tx1 = repo.start_transaction(&settings, "transaction 1");
let mut tx1 = repo.start_transaction(&settings);
write_random_commit(tx1.mut_repo(), &settings);
let op_id1 = tx1.commit().operation().id().clone();
let op_id1 = tx1.commit("transaction 1").operation().id().clone();
assert_ne!(op_id1, op_id0);
assert_eq!(list_dir(&op_heads_dir), vec![op_id1.hex()]);
let repo = repo.reload_at_head(&settings).unwrap();
let mut tx2 = repo.start_transaction(&settings, "transaction 2");
let mut tx2 = repo.start_transaction(&settings);
write_random_commit(tx2.mut_repo(), &settings);
let op_id2 = tx2.commit().operation().id().clone();
let op_id2 = tx2.commit("transaction 2").operation().id().clone();
assert_ne!(op_id2, op_id0);
assert_ne!(op_id2, op_id1);
assert_eq!(list_dir(&op_heads_dir), vec![op_id2.hex()]);
@ -90,17 +90,17 @@ fn test_concurrent_operations() {
let op_id0 = repo.op_id().clone();
assert_eq!(list_dir(&op_heads_dir), vec![repo.op_id().hex()]);
let mut tx1 = repo.start_transaction(&settings, "transaction 1");
let mut tx1 = repo.start_transaction(&settings);
write_random_commit(tx1.mut_repo(), &settings);
let op_id1 = tx1.commit().operation().id().clone();
let op_id1 = tx1.commit("transaction 1").operation().id().clone();
assert_ne!(op_id1, op_id0);
assert_eq!(list_dir(&op_heads_dir), vec![op_id1.hex()]);
// After both transactions have committed, we should have two op-heads on disk,
// since they were run in parallel.
let mut tx2 = repo.start_transaction(&settings, "transaction 2");
let mut tx2 = repo.start_transaction(&settings);
write_random_commit(tx2.mut_repo(), &settings);
let op_id2 = tx2.commit().operation().id().clone();
let op_id2 = tx2.commit("transaction 2").operation().id().clone();
assert_ne!(op_id2, op_id0);
assert_ne!(op_id2, op_id1);
let mut actual_heads_on_disk = list_dir(&op_heads_dir);
@ -130,16 +130,16 @@ fn test_isolation() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let initial = create_random_commit(tx.mut_repo(), &settings)
.set_parents(vec![repo.store().root_commit_id().clone()])
.write()
.unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx1 = repo.start_transaction(&settings, "transaction 1");
let mut tx1 = repo.start_transaction(&settings);
let mut_repo1 = tx1.mut_repo();
let mut tx2 = repo.start_transaction(&settings, "transaction 2");
let mut tx2 = repo.start_transaction(&settings);
let mut_repo2 = tx2.mut_repo();
assert_heads(repo.as_ref(), vec![initial.id()]);
@ -166,12 +166,12 @@ fn test_isolation() {
assert_heads(mut_repo2, vec![rewrite2.id()]);
// The base repo and tx2 don't see the commits from tx1.
tx1.commit();
tx1.commit("transaction 1");
assert_heads(repo.as_ref(), vec![initial.id()]);
assert_heads(mut_repo2, vec![rewrite2.id()]);
// The base repo still doesn't see the commits after both transactions commit.
tx2.commit();
tx2.commit("transaction 2");
assert_heads(repo.as_ref(), vec![initial.id()]);
// After reload, the base repo sees both rewrites.
let repo = repo.reload_at_head(&settings).unwrap();

4
lib/tests/test_refs.rs
View file

@ -32,7 +32,7 @@ fn test_merge_ref_targets() {
// | 2
// |/
// 1
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit1 = graph_builder.initial_commit();
let commit2 = graph_builder.commit_with_parents(&[&commit1]);
@ -41,7 +41,7 @@ fn test_merge_ref_targets() {
let commit5 = graph_builder.commit_with_parents(&[&commit1]);
let commit6 = graph_builder.commit_with_parents(&[&commit5]);
let commit7 = graph_builder.commit_with_parents(&[&commit5]);
let repo = tx.commit();
let repo = tx.commit("test");
let target1 = RefTarget::normal(commit1.id().clone());
let target2 = RefTarget::normal(commit2.id().clone());

82
lib/tests/test_revset.rs
View file

@ -88,7 +88,7 @@ fn test_resolve_symbol_commit_id() {
let test_repo = TestRepo::init_with_backend(TestRepoBackend::Git);
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let signature = Signature {
name: "test".to_string(),
@ -114,7 +114,7 @@ fn test_resolve_symbol_commit_id() {
.unwrap();
commits.push(commit);
}
let repo = tx.commit();
let repo = tx.commit("test");
// Test the test setup
assert_eq!(
@ -233,7 +233,7 @@ fn test_resolve_symbol_change_id(readonly: bool) {
git_commit_ids.push(git_commit_id);
}
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
git::import_refs(tx.mut_repo(), &git_settings).unwrap();
// Test the test setup
@ -260,7 +260,7 @@ fn test_resolve_symbol_change_id(readonly: bool) {
let _readonly_repo;
let repo: &dyn Repo = if readonly {
_readonly_repo = tx.commit();
_readonly_repo = tx.commit("test");
_readonly_repo.as_ref()
} else {
tx.mut_repo()
@ -339,7 +339,7 @@ fn test_resolve_working_copy() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let commit1 = write_random_commit(mut_repo, &settings);
@ -392,7 +392,7 @@ fn test_resolve_symbol_branches() {
let normal_tracking_remote_ref =
|id: &CommitId| tracking_remote_ref(RefTarget::normal(id.clone()));
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let commit1 = write_random_commit(mut_repo, &settings);
@ -616,7 +616,7 @@ fn test_resolve_symbol_tags() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let commit1 = write_random_commit(mut_repo, &settings);
@ -664,7 +664,7 @@ fn test_resolve_symbol_git_head() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let commit1 = write_random_commit(mut_repo, &settings);
@ -708,7 +708,7 @@ fn test_resolve_symbol_git_refs() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
// Create some commits and refs to work with and so the repo is not empty
@ -839,7 +839,7 @@ fn test_evaluate_expression_root_and_checkout() {
let test_workspace = TestWorkspace::init(&settings);
let repo = &test_workspace.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let root_commit = repo.store().root_commit();
@ -868,7 +868,7 @@ fn test_evaluate_expression_heads() {
let repo = &test_repo.repo;
let root_commit = repo.store().root_commit();
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let mut graph_builder = CommitGraphBuilder::new(&settings, mut_repo);
let commit1 = graph_builder.initial_commit();
@ -933,7 +933,7 @@ fn test_evaluate_expression_roots() {
let repo = &test_repo.repo;
let root_commit = repo.store().root_commit();
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let mut graph_builder = CommitGraphBuilder::new(&settings, mut_repo);
let commit1 = graph_builder.initial_commit();
@ -988,7 +988,7 @@ fn test_evaluate_expression_parents() {
let repo = &test_workspace.repo;
let root_commit = repo.store().root_commit();
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let mut graph_builder = CommitGraphBuilder::new(&settings, mut_repo);
let commit1 = graph_builder.initial_commit();
@ -1069,7 +1069,7 @@ fn test_evaluate_expression_children() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let commit1 = write_random_commit(mut_repo, &settings);
@ -1156,7 +1156,7 @@ fn test_evaluate_expression_ancestors() {
let repo = &test_repo.repo;
let root_commit = repo.store().root_commit();
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let mut graph_builder = CommitGraphBuilder::new(&settings, mut_repo);
let commit1 = graph_builder.initial_commit();
@ -1242,7 +1242,7 @@ fn test_evaluate_expression_range() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let mut graph_builder = CommitGraphBuilder::new(&settings, mut_repo);
let commit1 = graph_builder.initial_commit();
@ -1324,7 +1324,7 @@ fn test_evaluate_expression_dag_range() {
let repo = &test_repo.repo;
let root_commit_id = repo.store().root_commit_id().clone();
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let mut graph_builder = CommitGraphBuilder::new(&settings, mut_repo);
let commit1 = graph_builder.initial_commit();
@ -1434,7 +1434,7 @@ fn test_evaluate_expression_connected() {
let repo = &test_repo.repo;
let root_commit_id = repo.store().root_commit_id().clone();
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let mut graph_builder = CommitGraphBuilder::new(&settings, mut_repo);
let commit1 = graph_builder.initial_commit();
@ -1509,7 +1509,7 @@ fn test_evaluate_expression_descendants() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let root_commit_id = repo.store().root_commit_id().clone();
@ -1619,7 +1619,7 @@ fn test_evaluate_expression_all() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let root_commit_id = repo.store().root_commit_id().clone();
let mut graph_builder = CommitGraphBuilder::new(&settings, mut_repo);
@ -1646,7 +1646,7 @@ fn test_evaluate_expression_visible_heads() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let mut graph_builder = CommitGraphBuilder::new(&settings, mut_repo);
let commit1 = graph_builder.initial_commit();
@ -1665,7 +1665,7 @@ fn test_evaluate_expression_git_refs() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let commit1 = write_random_commit(mut_repo, &settings);
@ -1724,7 +1724,7 @@ fn test_evaluate_expression_git_head() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let commit1 = write_random_commit(mut_repo, &settings);
@ -1744,7 +1744,7 @@ fn test_evaluate_expression_branches() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let commit1 = write_random_commit(mut_repo, &settings);
@ -1828,7 +1828,7 @@ fn test_evaluate_expression_remote_branches() {
};
let normal_remote_ref = |id: &CommitId| remote_ref(RefTarget::normal(id.clone()));
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let commit1 = write_random_commit(mut_repo, &settings);
@ -1959,7 +1959,7 @@ fn test_evaluate_expression_latest() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let mut write_commit_with_committer_timestamp = |sec: i64| {
@ -2042,7 +2042,7 @@ fn test_evaluate_expression_merges() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let mut graph_builder = CommitGraphBuilder::new(&settings, mut_repo);
let commit1 = graph_builder.initial_commit();
@ -2069,7 +2069,7 @@ fn test_evaluate_expression_description() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let commit1 = create_random_commit(mut_repo, &settings)
@ -2114,7 +2114,7 @@ fn test_evaluate_expression_author() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let timestamp = Timestamp {
@ -2187,7 +2187,7 @@ fn test_evaluate_expression_mine() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let timestamp = Timestamp {
@ -2255,7 +2255,7 @@ fn test_evaluate_expression_committer() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let timestamp = Timestamp {
@ -2321,7 +2321,7 @@ fn test_evaluate_expression_union() {
let repo = &test_repo.repo;
let root_commit = repo.store().root_commit();
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let mut graph_builder = CommitGraphBuilder::new(&settings, mut_repo);
let commit1 = graph_builder.initial_commit();
@ -2393,7 +2393,7 @@ fn test_evaluate_expression_intersection() {
let repo = &test_repo.repo;
let root_commit = repo.store().root_commit();
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let mut graph_builder = CommitGraphBuilder::new(&settings, mut_repo);
let commit1 = graph_builder.initial_commit();
@ -2432,7 +2432,7 @@ fn test_evaluate_expression_difference() {
let repo = &test_repo.repo;
let root_commit = repo.store().root_commit();
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let mut graph_builder = CommitGraphBuilder::new(&settings, mut_repo);
let commit1 = graph_builder.initial_commit();
@ -2517,7 +2517,7 @@ fn test_evaluate_expression_filter_combinator() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let root_commit_id = repo.store().root_commit_id();
@ -2580,7 +2580,7 @@ fn test_evaluate_expression_file() {
let test_workspace = TestWorkspace::init(&settings);
let repo = &test_workspace.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let added_clean_clean = RepoPath::from_internal_string("added_clean_clean");
@ -2688,7 +2688,7 @@ fn test_evaluate_expression_conflict() {
let test_workspace = TestWorkspace::init(&settings);
let repo = &test_workspace.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
// Create a few trees, including one with a conflict in `file1`
@ -2739,7 +2739,7 @@ fn test_reverse_graph_iterator() {
// A
// |
// root
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.commit_with_parents(&[&commit_a]);
@ -2747,7 +2747,7 @@ fn test_reverse_graph_iterator() {
let commit_d = graph_builder.commit_with_parents(&[&commit_c]);
let commit_e = graph_builder.commit_with_parents(&[&commit_c]);
let commit_f = graph_builder.commit_with_parents(&[&commit_d, &commit_e]);
let repo = tx.commit();
let repo = tx.commit("test");
let revset = revset_for_commits(
repo.as_ref(),
@ -2788,7 +2788,7 @@ fn test_change_id_index() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let root_commit = repo.store().root_commit();
let mut commit_number = 0;
@ -2894,7 +2894,7 @@ fn test_no_such_revision_suggestion() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let commit = write_random_commit(mut_repo, &settings);

110
lib/tests/test_rewrite.rs
View file

@ -78,7 +78,7 @@ fn test_rebase_descendants_sideways() {
// | B
// |/
// A
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.commit_with_parents(&[&commit_a]);
@ -133,7 +133,7 @@ fn test_rebase_descendants_forward() {
// |/
// B
// A
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.commit_with_parents(&[&commit_a]);
@ -186,7 +186,7 @@ fn test_rebase_descendants_reorder() {
// |/
// B
// A
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.commit_with_parents(&[&commit_a]);
@ -232,7 +232,7 @@ fn test_rebase_descendants_backward() {
// C
// B
// A
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.commit_with_parents(&[&commit_a]);
@ -273,7 +273,7 @@ fn test_rebase_descendants_chain_becomes_branchy() {
// B E
// |/
// A
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.commit_with_parents(&[&commit_a]);
@ -320,7 +320,7 @@ fn test_rebase_descendants_internal_merge() {
// | B
// |/
// A
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.commit_with_parents(&[&commit_a]);
@ -370,7 +370,7 @@ fn test_rebase_descendants_external_merge() {
// | B
// |/
// A
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.commit_with_parents(&[&commit_a]);
@ -416,7 +416,7 @@ fn test_rebase_descendants_abandon() {
// |/
// B
// A
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.commit_with_parents(&[&commit_a]);
@ -457,7 +457,7 @@ fn test_rebase_descendants_abandon_no_descendants() {
// C
// B
// A
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.commit_with_parents(&[&commit_a]);
@ -494,7 +494,7 @@ fn test_rebase_descendants_abandon_and_replace() {
// E B
// |/
// A
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.commit_with_parents(&[&commit_a]);
@ -532,7 +532,7 @@ fn test_rebase_descendants_abandon_degenerate_merge() {
// B C
// |/
// A
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.commit_with_parents(&[&commit_a]);
@ -571,7 +571,7 @@ fn test_rebase_descendants_abandon_widen_merge() {
// B C D
// \|/
// A
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.commit_with_parents(&[&commit_a]);
@ -614,7 +614,7 @@ fn test_rebase_descendants_multiple_sideways() {
// | |/
// |/
// A
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.commit_with_parents(&[&commit_a]);
@ -660,7 +660,7 @@ fn test_rebase_descendants_multiple_swap() {
// B D
// |/
// A
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.commit_with_parents(&[&commit_a]);
@ -691,7 +691,7 @@ fn test_rebase_descendants_multiple_no_descendants() {
// B C
// |/
// A
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.commit_with_parents(&[&commit_a]);
@ -744,7 +744,7 @@ fn test_rebase_descendants_divergent_rewrite() {
// | B2
// |/
// A
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.commit_with_parents(&[&commit_a]);
@ -802,7 +802,7 @@ fn test_rebase_descendants_repeated() {
// | B2
// |/
// A
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.commit_with_parents(&[&commit_a]);
@ -866,7 +866,7 @@ fn test_rebase_descendants_contents() {
// | B
// |/
// A
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let path1 = RepoPath::from_internal_string("file1");
let tree1 = create_tree(repo, &[(path1, "content")]);
let commit_a = tx
@ -937,15 +937,15 @@ fn test_rebase_descendants_basic_branch_update() {
// B main B2 main
// | => |
// A A
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.commit_with_parents(&[&commit_a]);
tx.mut_repo()
.set_local_branch_target("main", RefTarget::normal(commit_b.id().clone()));
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let commit_b2 = tx
.mut_repo()
.rewrite_commit(&settings, &commit_b)
@ -979,16 +979,16 @@ fn test_rebase_descendants_branch_move_two_steps() {
// B B2 B2
// |/ |
// A A
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.commit_with_parents(&[&commit_a]);
let commit_c = graph_builder.commit_with_parents(&[&commit_b]);
tx.mut_repo()
.set_local_branch_target("main", RefTarget::normal(commit_c.id().clone()));
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let commit_b2 = tx
.mut_repo()
.rewrite_commit(&settings, &commit_b)
@ -1026,7 +1026,7 @@ fn test_rebase_descendants_basic_branch_update_with_non_local_branch() {
// B main main@origin v1 | B main@origin v1
// | => |/
// A A
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.commit_with_parents(&[&commit_a]);
@ -1040,9 +1040,9 @@ fn test_rebase_descendants_basic_branch_update_with_non_local_branch() {
.set_remote_branch("main", "origin", commit_b_remote_ref.clone());
tx.mut_repo()
.set_tag_target("v1", RefTarget::normal(commit_b.id().clone()));
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let commit_b2 = tx
.mut_repo()
.rewrite_commit(&settings, &commit_b)
@ -1083,15 +1083,15 @@ fn test_rebase_descendants_update_branch_after_abandon() {
// B main
// | => A main
// A
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.commit_with_parents(&[&commit_a]);
tx.mut_repo()
.set_local_branch_target("main", RefTarget::normal(commit_b.id().clone()));
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
tx.mut_repo().record_abandoned_commit(commit_b.id().clone());
tx.mut_repo().rebase_descendants(&settings).unwrap();
assert_eq!(
@ -1119,15 +1119,15 @@ fn test_rebase_descendants_update_branches_after_divergent_rewrite() {
// B main |/B2 main?
// | => |/
// A A
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.commit_with_parents(&[&commit_a]);
tx.mut_repo()
.set_local_branch_target("main", RefTarget::normal(commit_b.id().clone()));
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let commit_b2 = tx
.mut_repo()
.rewrite_commit(&settings, &commit_b)
@ -1183,7 +1183,7 @@ fn test_rebase_descendants_rewrite_updates_branch_conflict() {
// Branch "main" is a conflict removing commit A and adding commits B and C.
// A gets rewritten as A2 and A3. B gets rewritten as B2 and B2. The branch
// should become a conflict removing A and B, and adding B2, B3, C.
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.initial_commit();
@ -1195,9 +1195,9 @@ fn test_rebase_descendants_rewrite_updates_branch_conflict() {
[commit_b.id().clone(), commit_c.id().clone()],
),
);
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let commit_a2 = tx
.mut_repo()
.rewrite_commit(&settings, &commit_a)
@ -1264,7 +1264,7 @@ fn test_rebase_descendants_rewrite_resolves_branch_conflict() {
// would result in a conflict removing A and adding B2 and C. However, since C
// is a descendant of A, and B2 is a descendant of C, the conflict gets
// resolved to B2.
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.commit_with_parents(&[&commit_a]);
@ -1276,9 +1276,9 @@ fn test_rebase_descendants_rewrite_resolves_branch_conflict() {
[commit_b.id().clone(), commit_c.id().clone()],
),
);
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let commit_b2 = tx
.mut_repo()
.rewrite_commit(&settings, &commit_b)
@ -1308,7 +1308,7 @@ fn test_rebase_descendants_branch_delete_modify_abandon() {
// leaves the branch pointing to "-A+B". We now abandon B. That should
// result in the branch pointing to "-A+A=0", so the branch should
// be deleted.
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let commit_a = graph_builder.initial_commit();
let commit_b = graph_builder.commit_with_parents(&[&commit_a]);
@ -1316,9 +1316,9 @@ fn test_rebase_descendants_branch_delete_modify_abandon() {
"main",
RefTarget::from_legacy_form([commit_a.id().clone()], [commit_b.id().clone()]),
);
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
tx.mut_repo().record_abandoned_commit(commit_b.id().clone());
tx.mut_repo().rebase_descendants(&settings).unwrap();
assert_eq!(tx.mut_repo().get_local_branch("main"), RefTarget::absent());
@ -1336,7 +1336,7 @@ fn test_rebase_descendants_update_checkout() {
// C B
// |/
// A
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let commit_a = write_random_commit(tx.mut_repo(), &settings);
let commit_b = create_random_commit(tx.mut_repo(), &settings)
.set_parents(vec![commit_a.id().clone()])
@ -1354,9 +1354,9 @@ fn test_rebase_descendants_update_checkout() {
tx.mut_repo()
.set_wc_commit(ws3_id.clone(), commit_a.id().clone())
.unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let commit_c = tx
.mut_repo()
.rewrite_commit(&settings, &commit_b)
@ -1364,7 +1364,7 @@ fn test_rebase_descendants_update_checkout() {
.write()
.unwrap();
tx.mut_repo().rebase_descendants(&settings).unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
// Workspaces 1 and 2 had B checked out, so they get updated to C. Workspace 3
// had A checked out, so it doesn't get updated.
@ -1385,7 +1385,7 @@ fn test_rebase_descendants_update_checkout_abandoned() {
// B
// |
// A
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let commit_a = write_random_commit(tx.mut_repo(), &settings);
let commit_b = create_random_commit(tx.mut_repo(), &settings)
.set_parents(vec![commit_a.id().clone()])
@ -1403,12 +1403,12 @@ fn test_rebase_descendants_update_checkout_abandoned() {
tx.mut_repo()
.set_wc_commit(ws3_id.clone(), commit_a.id().clone())
.unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
tx.mut_repo().record_abandoned_commit(commit_b.id().clone());
tx.mut_repo().rebase_descendants(&settings).unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
// Workspaces 1 and 2 had B checked out, so they get updated to the same new
// commit on top of C. Workspace 3 had A checked out, so it doesn't get updated.
@ -1438,7 +1438,7 @@ fn test_rebase_descendants_update_checkout_abandoned_merge() {
// B C
// |/
// A
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let commit_a = write_random_commit(tx.mut_repo(), &settings);
let commit_b = create_random_commit(tx.mut_repo(), &settings)
.set_parents(vec![commit_a.id().clone()])
@ -1456,12 +1456,12 @@ fn test_rebase_descendants_update_checkout_abandoned_merge() {
tx.mut_repo()
.set_wc_commit(workspace_id.clone(), commit_d.id().clone())
.unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
tx.mut_repo().record_abandoned_commit(commit_d.id().clone());
tx.mut_repo().rebase_descendants(&settings).unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
let new_checkout_id = repo.view().get_wc_commit_id(&workspace_id).unwrap();
let checkout = repo.store().get_commit(new_checkout_id).unwrap();
@ -1510,7 +1510,7 @@ fn test_empty_commit_option(empty: EmptyBehaviour) {
// | \|/
// | B
// A__/
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let create_fixed_tree = |paths: &[&str]| {
let content_map = paths

24
lib/tests/test_signing.rs
View file

@ -53,7 +53,7 @@ fn manual(backend: TestRepoBackend) {
let settings = settings.clone();
let repo = repo.clone();
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let commit1 = create_random_commit(tx.mut_repo(), &settings)
.set_sign_behavior(SignBehavior::Own)
.write()
@ -63,7 +63,7 @@ fn manual(backend: TestRepoBackend) {
.set_author(someone_else())
.write()
.unwrap();
tx.commit();
tx.commit("test");
let commit1 = repo.store().get_commit(commit1.id()).unwrap();
assert_eq!(commit1.verification().unwrap(), good_verification());
@ -83,14 +83,14 @@ fn keep_on_rewrite(backend: TestRepoBackend) {
let settings = settings.clone();
let repo = repo.clone();
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let commit = create_random_commit(tx.mut_repo(), &settings)
.set_sign_behavior(SignBehavior::Own)
.write()
.unwrap();
tx.commit();
tx.commit("test");
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let rewritten = mut_repo.rewrite_commit(&settings, &commit).write().unwrap();
@ -109,14 +109,14 @@ fn manual_drop_on_rewrite(backend: TestRepoBackend) {
let settings = settings.clone();
let repo = repo.clone();
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let commit = create_random_commit(tx.mut_repo(), &settings)
.set_sign_behavior(SignBehavior::Own)
.write()
.unwrap();
tx.commit();
tx.commit("test");
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let rewritten = mut_repo
.rewrite_commit(&settings, &commit)
@ -139,13 +139,13 @@ fn forced(backend: TestRepoBackend) {
let settings = settings.clone();
let repo = repo.clone();
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let commit = create_random_commit(tx.mut_repo(), &settings)
.set_sign_behavior(SignBehavior::Force)
.set_author(someone_else())
.write()
.unwrap();
tx.commit();
tx.commit("test");
let commit = repo.store().get_commit(commit.id()).unwrap();
assert_eq!(commit.verification().unwrap(), good_verification());
@ -162,9 +162,9 @@ fn configured(backend: TestRepoBackend) {
let settings = settings.clone();
let repo = repo.clone();
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let commit = write_random_commit(tx.mut_repo(), &settings);
tx.commit();
tx.commit("test");
let commit = repo.store().get_commit(commit.id()).unwrap();
assert_eq!(commit.verification().unwrap(), good_verification());

88
lib/tests/test_view.rs
View file

@ -42,13 +42,13 @@ fn test_heads_fork() {
let settings = testutils::user_settings();
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let initial = graph_builder.initial_commit();
let child1 = graph_builder.commit_with_parents(&[&initial]);
let child2 = graph_builder.commit_with_parents(&[&initial]);
let repo = tx.commit();
let repo = tx.commit("test");
assert_eq!(
*repo.view().heads(),
@ -64,14 +64,14 @@ fn test_heads_merge() {
let settings = testutils::user_settings();
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo());
let initial = graph_builder.initial_commit();
let child1 = graph_builder.commit_with_parents(&[&initial]);
let child2 = graph_builder.commit_with_parents(&[&initial]);
let merge = graph_builder.commit_with_parents(&[&child1, &child2]);
let repo = tx.commit();
let repo = tx.commit("test");
assert_eq!(*repo.view().heads(), hashset! {merge.id().clone()});
}
@ -83,7 +83,7 @@ fn test_merge_views_heads() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let head_unchanged = write_random_commit(mut_repo, &settings);
let head_remove_tx1 = write_random_commit(mut_repo, &settings);
@ -94,9 +94,9 @@ fn test_merge_views_heads() {
mut_repo.add_public_head(&public_head_remove_tx1);
let public_head_remove_tx2 = write_random_commit(mut_repo, &settings);
mut_repo.add_public_head(&public_head_remove_tx2);
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx1 = repo.start_transaction(&settings, "test");
let mut tx1 = repo.start_transaction(&settings);
tx1.mut_repo().remove_head(head_remove_tx1.id());
tx1.mut_repo()
.remove_public_head(public_head_remove_tx1.id());
@ -104,7 +104,7 @@ fn test_merge_views_heads() {
let public_head_add_tx1 = write_random_commit(tx1.mut_repo(), &settings);
tx1.mut_repo().add_public_head(&public_head_add_tx1);
let mut tx2 = repo.start_transaction(&settings, "test");
let mut tx2 = repo.start_transaction(&settings);
tx2.mut_repo().remove_head(head_remove_tx2.id());
tx2.mut_repo()
.remove_public_head(public_head_remove_tx2.id());
@ -148,7 +148,7 @@ fn test_merge_views_checkout() {
// Workspace 5 gets deleted in tx2 and modified in tx1.
// Workspace 6 gets added in tx1.
// Workspace 7 gets added in tx2.
let mut initial_tx = repo.start_transaction(&settings, "test");
let mut initial_tx = repo.start_transaction(&settings);
let commit1 = write_random_commit(initial_tx.mut_repo(), &settings);
let commit2 = write_random_commit(initial_tx.mut_repo(), &settings);
let commit3 = write_random_commit(initial_tx.mut_repo(), &settings);
@ -179,9 +179,9 @@ fn test_merge_views_checkout() {
.mut_repo()
.set_wc_commit(ws5_id.clone(), commit1.id().clone())
.unwrap();
let repo = initial_tx.commit();
let repo = initial_tx.commit("test");
let mut tx1 = repo.start_transaction(&settings, "test");
let mut tx1 = repo.start_transaction(&settings);
tx1.mut_repo()
.set_wc_commit(ws1_id.clone(), commit2.id().clone())
.unwrap();
@ -196,7 +196,7 @@ fn test_merge_views_checkout() {
.set_wc_commit(ws6_id.clone(), commit2.id().clone())
.unwrap();
let mut tx2 = repo.start_transaction(&settings, "test");
let mut tx2 = repo.start_transaction(&settings);
tx2.mut_repo()
.set_wc_commit(ws1_id.clone(), commit3.id().clone())
.unwrap();
@ -232,7 +232,7 @@ fn test_merge_views_branches() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let main_branch_local_tx0 = write_random_commit(mut_repo, &settings);
let main_branch_origin_tx0 = write_random_commit(mut_repo, &settings);
@ -260,9 +260,9 @@ fn test_merge_views_branches() {
"feature",
RefTarget::normal(feature_branch_local_tx0.id().clone()),
);
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx1 = repo.start_transaction(&settings, "test");
let mut tx1 = repo.start_transaction(&settings);
let main_branch_local_tx1 = write_random_commit(tx1.mut_repo(), &settings);
tx1.mut_repo().set_local_branch_target(
"main",
@ -274,7 +274,7 @@ fn test_merge_views_branches() {
RefTarget::normal(feature_branch_tx1.id().clone()),
);
let mut tx2 = repo.start_transaction(&settings, "test");
let mut tx2 = repo.start_transaction(&settings);
let main_branch_local_tx2 = write_random_commit(tx2.mut_repo(), &settings);
let main_branch_origin_tx2 = write_random_commit(tx2.mut_repo(), &settings);
let main_branch_origin_tx2_remote_ref = RemoteRef {
@ -324,15 +324,15 @@ fn test_merge_views_tags() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let v1_tx0 = write_random_commit(mut_repo, &settings);
mut_repo.set_tag_target("v1.0", RefTarget::normal(v1_tx0.id().clone()));
let v2_tx0 = write_random_commit(mut_repo, &settings);
mut_repo.set_tag_target("v2.0", RefTarget::normal(v2_tx0.id().clone()));
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx1 = repo.start_transaction(&settings, "test");
let mut tx1 = repo.start_transaction(&settings);
let v1_tx1 = write_random_commit(tx1.mut_repo(), &settings);
tx1.mut_repo()
.set_tag_target("v1.0", RefTarget::normal(v1_tx1.id().clone()));
@ -340,7 +340,7 @@ fn test_merge_views_tags() {
tx1.mut_repo()
.set_tag_target("v2.0", RefTarget::normal(v2_tx1.id().clone()));
let mut tx2 = repo.start_transaction(&settings, "test");
let mut tx2 = repo.start_transaction(&settings);
let v1_tx2 = write_random_commit(tx2.mut_repo(), &settings);
tx2.mut_repo()
.set_tag_target("v1.0", RefTarget::normal(v1_tx2.id().clone()));
@ -368,7 +368,7 @@ fn test_merge_views_git_refs() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&settings, "test");
let mut tx = repo.start_transaction(&settings);
let mut_repo = tx.mut_repo();
let main_branch_tx0 = write_random_commit(mut_repo, &settings);
mut_repo.set_git_ref_target(
@ -380,9 +380,9 @@ fn test_merge_views_git_refs() {
"refs/heads/feature",
RefTarget::normal(feature_branch_tx0.id().clone()),
);
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx1 = repo.start_transaction(&settings, "test");
let mut tx1 = repo.start_transaction(&settings);
let main_branch_tx1 = write_random_commit(tx1.mut_repo(), &settings);
tx1.mut_repo().set_git_ref_target(
"refs/heads/main",
@ -394,7 +394,7 @@ fn test_merge_views_git_refs() {
RefTarget::normal(feature_branch_tx1.id().clone()),
);
let mut tx2 = repo.start_transaction(&settings, "test");
let mut tx2 = repo.start_transaction(&settings);
let main_branch_tx2 = write_random_commit(tx2.mut_repo(), &settings);
tx2.mut_repo().set_git_ref_target(
"refs/heads/main",
@ -424,18 +424,18 @@ fn test_merge_views_git_heads() {
let test_repo = TestRepo::init();
let repo = &test_repo.repo;
let mut tx0 = repo.start_transaction(&settings, "test");
let mut tx0 = repo.start_transaction(&settings);
let tx0_head = write_random_commit(tx0.mut_repo(), &settings);
tx0.mut_repo()
.set_git_head_target(RefTarget::normal(tx0_head.id().clone()));
let repo = tx0.commit();
let repo = tx0.commit("test");
let mut tx1 = repo.start_transaction(&settings, "test");
let mut tx1 = repo.start_transaction(&settings);
let tx1_head = write_random_commit(tx1.mut_repo(), &settings);
tx1.mut_repo()
.set_git_head_target(RefTarget::normal(tx1_head.id().clone()));
let mut tx2 = repo.start_transaction(&settings, "test");
let mut tx2 = repo.start_transaction(&settings);
let tx2_head = write_random_commit(tx2.mut_repo(), &settings);
tx2.mut_repo()
.set_git_head_target(RefTarget::normal(tx2_head.id().clone()));
@ -455,11 +455,11 @@ fn test_merge_views_divergent() {
let settings = testutils::user_settings();
let test_repo = TestRepo::init();
let mut tx = test_repo.repo.start_transaction(&settings, "test");
let mut tx = test_repo.repo.start_transaction(&settings);
let commit_a = write_random_commit(tx.mut_repo(), &settings);
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx1 = repo.start_transaction(&settings, "test");
let mut tx1 = repo.start_transaction(&settings);
let commit_a2 = tx1
.mut_repo()
.rewrite_commit(&settings, &commit_a)
@ -468,7 +468,7 @@ fn test_merge_views_divergent() {
.unwrap();
tx1.mut_repo().rebase_descendants(&settings).unwrap();
let mut tx2 = repo.start_transaction(&settings, "test");
let mut tx2 = repo.start_transaction(&settings);
let commit_a3 = tx2
.mut_repo()
.rewrite_commit(&settings, &commit_a)
@ -494,17 +494,17 @@ fn test_merge_views_child_on_rewritten(child_first: bool) {
let settings = testutils::user_settings();
let test_repo = TestRepo::init();
let mut tx = test_repo.repo.start_transaction(&settings, "test");
let mut tx = test_repo.repo.start_transaction(&settings);
let commit_a = write_random_commit(tx.mut_repo(), &settings);
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx1 = repo.start_transaction(&settings, "test");
let mut tx1 = repo.start_transaction(&settings);
let commit_b = create_random_commit(tx1.mut_repo(), &settings)
.set_parents(vec![commit_a.id().clone()])
.write()
.unwrap();
let mut tx2 = repo.start_transaction(&settings, "test");
let mut tx2 = repo.start_transaction(&settings);
let commit_a2 = tx2
.mut_repo()
.rewrite_commit(&settings, &commit_a)
@ -540,22 +540,22 @@ fn test_merge_views_child_on_rewritten_divergent(on_rewritten: bool, child_first
let settings = testutils::user_settings();
let test_repo = TestRepo::init();
let mut tx = test_repo.repo.start_transaction(&settings, "test");
let mut tx = test_repo.repo.start_transaction(&settings);
let commit_a2 = write_random_commit(tx.mut_repo(), &settings);
let commit_a3 = create_random_commit(tx.mut_repo(), &settings)
.set_change_id(commit_a2.change_id().clone())
.write()
.unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx1 = repo.start_transaction(&settings, "test");
let mut tx1 = repo.start_transaction(&settings);
let parent = if on_rewritten { &commit_a2 } else { &commit_a3 };
let commit_b = create_random_commit(tx1.mut_repo(), &settings)
.set_parents(vec![parent.id().clone()])
.write()
.unwrap();
let mut tx2 = repo.start_transaction(&settings, "test");
let mut tx2 = repo.start_transaction(&settings);
let commit_a4 = tx2
.mut_repo()
.rewrite_commit(&settings, &commit_a2)
@ -596,21 +596,21 @@ fn test_merge_views_child_on_abandoned(child_first: bool) {
let settings = testutils::user_settings();
let test_repo = TestRepo::init();
let mut tx = test_repo.repo.start_transaction(&settings, "test");
let mut tx = test_repo.repo.start_transaction(&settings);
let commit_a = write_random_commit(tx.mut_repo(), &settings);
let commit_b = create_random_commit(tx.mut_repo(), &settings)
.set_parents(vec![commit_a.id().clone()])
.write()
.unwrap();
let repo = tx.commit();
let repo = tx.commit("test");
let mut tx1 = repo.start_transaction(&settings, "test");
let mut tx1 = repo.start_transaction(&settings);
let commit_c = create_random_commit(tx1.mut_repo(), &settings)
.set_parents(vec![commit_b.id().clone()])
.write()
.unwrap();
let mut tx2 = repo.start_transaction(&settings, "test");
let mut tx2 = repo.start_transaction(&settings);
tx2.mut_repo()
.record_abandoned_commit(commit_b.id().clone());
tx2.mut_repo().rebase_descendants(&settings).unwrap();

2
lib/testutils/src/lib.rs
View file

@ -241,7 +241,7 @@ pub fn commit_transactions(settings: &UserSettings, txs: Vec<Transaction>) -> Ar
let repo_loader = txs[0].base_repo().loader();
let mut op_ids = vec![];
for tx in txs {
op_ids.push(tx.commit().op_id().clone());
op_ids.push(tx.commit("test").op_id().clone());
std::thread::sleep(std::time::Duration::from_millis(1));
}
let repo = repo_loader.load_at_head(settings).unwrap();