jj/lib/tests/test_commit_builder.rs

305 lines
10 KiB
Rust
Raw Normal View History

// Copyright 2020 The Jujutsu Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
use jj_lib::backend::{ChangeId, MillisSinceEpoch, Signature, Timestamp};
use jj_lib::matchers::EverythingMatcher;
use jj_lib::merged_tree::DiffSummary;
use jj_lib::repo::Repo;
use jj_lib::repo_path::{RepoPath, RepoPathBuf};
use jj_lib::settings::UserSettings;
use test_case::test_case;
use testutils::{assert_rebased_onto, create_tree, CommitGraphBuilder, TestRepo, TestRepoBackend};
fn to_owned_path_vec(paths: &[&RepoPath]) -> Vec<RepoPathBuf> {
paths.iter().map(|&path| path.to_owned()).collect()
}
#[test_case(TestRepoBackend::Local ; "local backend")]
#[test_case(TestRepoBackend::Git ; "git backend")]
fn test_initial(backend: TestRepoBackend) {
let settings = testutils::user_settings();
let test_repo = TestRepo::init_with_backend(backend);
let repo = &test_repo.repo;
let store = repo.store();
let root_file_path = RepoPath::from_internal_string("file");
let dir_file_path = RepoPath::from_internal_string("dir/file");
let tree = create_tree(
repo,
&[
(root_file_path, "file contents"),
(dir_file_path, "dir/file contents"),
],
);
let mut tx = repo.start_transaction(&settings);
let author_signature = Signature {
name: "author name".to_string(),
email: "author email".to_string(),
timestamp: Timestamp {
timestamp: MillisSinceEpoch(1000),
tz_offset: 60,
},
};
let committer_signature = Signature {
name: "committer name".to_string(),
email: "committer email".to_string(),
timestamp: Timestamp {
timestamp: MillisSinceEpoch(2000),
tz_offset: -60,
},
};
let change_id = ChangeId::new(vec![100u8; 16]);
let builder = tx
.mut_repo()
.new_commit(&settings, vec![store.root_commit_id().clone()], tree.id())
.set_change_id(change_id.clone())
.set_description("description")
.set_author(author_signature.clone())
.set_committer(committer_signature.clone());
assert_eq!(builder.parents(), &[store.root_commit_id().clone()]);
assert_eq!(builder.predecessors(), &[]);
assert_eq!(builder.tree_id(), &tree.id());
assert_eq!(builder.change_id(), &change_id);
assert_eq!(builder.author(), &author_signature);
assert_eq!(builder.committer(), &committer_signature);
let commit = builder.write().unwrap();
tx.commit("test");
assert_eq!(commit.parents(), vec![store.root_commit()]);
assert_eq!(commit.predecessors(), vec![]);
assert_eq!(commit.description(), "description");
assert_eq!(commit.author(), &author_signature);
assert_eq!(commit.committer(), &committer_signature);
assert_eq!(
store
.root_commit()
.tree()
.unwrap()
.diff_summary(&commit.tree().unwrap(), &EverythingMatcher)
.unwrap(),
DiffSummary {
modified: vec![],
added: to_owned_path_vec(&[dir_file_path, root_file_path]),
removed: vec![],
}
);
}
#[test_case(TestRepoBackend::Local ; "local backend")]
#[test_case(TestRepoBackend::Git ; "git backend")]
fn test_rewrite(backend: TestRepoBackend) {
let settings = testutils::user_settings();
let test_repo = TestRepo::init_with_backend(backend);
let repo = &test_repo.repo;
let store = repo.store().clone();
let root_file_path = RepoPath::from_internal_string("file");
let dir_file_path = RepoPath::from_internal_string("dir/file");
let initial_tree = create_tree(
repo,
&[
(root_file_path, "file contents"),
(dir_file_path, "dir/file contents"),
],
);
let mut tx = repo.start_transaction(&settings);
let initial_commit = tx
.mut_repo()
.new_commit(
&settings,
vec![store.root_commit_id().clone()],
initial_tree.id(),
)
.write()
.unwrap();
let repo = tx.commit("test");
let rewritten_tree = create_tree(
&repo,
&[
(root_file_path, "file contents"),
(dir_file_path, "updated dir/file contents"),
],
);
let config = config::Config::builder()
.set_override("user.name", "Rewrite User")
.unwrap()
.set_override("user.email", "rewrite.user@example.com")
.unwrap()
.build()
.unwrap();
let rewrite_settings = UserSettings::from_config(config);
let mut tx = repo.start_transaction(&settings);
let rewritten_commit = tx
.mut_repo()
.rewrite_commit(&rewrite_settings, &initial_commit)
.set_tree_id(rewritten_tree.id().clone())
.write()
.unwrap();
tx.mut_repo().rebase_descendants(&settings).unwrap();
tx.commit("test");
assert_eq!(rewritten_commit.parents(), vec![store.root_commit()]);
assert_eq!(
rewritten_commit.predecessors(),
vec![initial_commit.clone()]
);
assert_eq!(rewritten_commit.author().name, settings.user_name());
assert_eq!(rewritten_commit.author().email, settings.user_email());
assert_eq!(
rewritten_commit.committer().name,
rewrite_settings.user_name()
);
assert_eq!(
rewritten_commit.committer().email,
rewrite_settings.user_email()
);
assert_eq!(
store
.root_commit()
.tree()
.unwrap()
.diff_summary(&rewritten_commit.tree().unwrap(), &EverythingMatcher)
.unwrap(),
DiffSummary {
modified: vec![],
added: to_owned_path_vec(&[dir_file_path, root_file_path]),
removed: vec![],
}
);
assert_eq!(
initial_commit
.tree()
.unwrap()
.diff_summary(&rewritten_commit.tree().unwrap(), &EverythingMatcher)
.unwrap(),
DiffSummary {
modified: to_owned_path_vec(&[dir_file_path]),
added: vec![],
removed: vec![],
}
);
}
// An author field with an empty name/email should get filled in on rewrite
#[test_case(TestRepoBackend::Local ; "local backend")]
#[test_case(TestRepoBackend::Git ; "git backend")]
fn test_rewrite_update_missing_user(backend: TestRepoBackend) {
let missing_user_settings =
UserSettings::from_config(config::Config::builder().build().unwrap());
let test_repo = TestRepo::init_with_backend(backend);
let repo = &test_repo.repo;
let mut tx = repo.start_transaction(&missing_user_settings);
let initial_commit = tx
.mut_repo()
.new_commit(
&missing_user_settings,
vec![repo.store().root_commit_id().clone()],
repo.store().empty_merged_tree_id(),
)
.write()
.unwrap();
assert_eq!(initial_commit.author().name, "");
assert_eq!(initial_commit.author().email, "");
assert_eq!(initial_commit.committer().name, "");
assert_eq!(initial_commit.committer().email, "");
let config = config::Config::builder()
.set_override("user.name", "Configured User")
.unwrap()
.set_override("user.email", "configured.user@example.com")
.unwrap()
.build()
.unwrap();
let settings = UserSettings::from_config(config);
let rewritten_commit = tx
.mut_repo()
.rewrite_commit(&settings, &initial_commit)
.write()
.unwrap();
assert_eq!(rewritten_commit.author().name, "Configured User");
assert_eq!(
rewritten_commit.author().email,
"configured.user@example.com"
);
assert_eq!(rewritten_commit.committer().name, "Configured User");
assert_eq!(
rewritten_commit.committer().email,
"configured.user@example.com"
);
}
#[test_case(TestRepoBackend::Local ; "local backend")]
// #[test_case(TestRepoBackend::Git ; "git backend")]
fn test_commit_builder_descendants(backend: TestRepoBackend) {
let settings = testutils::user_settings();
let test_repo = TestRepo::init_with_backend(backend);
let repo = &test_repo.repo;
let store = repo.store().clone();
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("test");
// Test with for_new_commit()
let mut tx = repo.start_transaction(&settings);
tx.mut_repo()
.new_commit(
&settings,
vec![store.root_commit_id().clone()],
store.empty_merged_tree_id(),
)
.write()
.unwrap();
let rebase_map = tx
.mut_repo()
.rebase_descendants_return_map(&settings)
.unwrap();
assert_eq!(rebase_map.len(), 0);
// Test with for_rewrite_from()
let mut tx = repo.start_transaction(&settings);
let commit4 = tx
.mut_repo()
.rewrite_commit(&settings, &commit2)
.write()
.unwrap();
let rebase_map = tx
.mut_repo()
.rebase_descendants_return_map(&settings)
.unwrap();
assert_rebased_onto(tx.mut_repo(), &rebase_map, &commit3, &[commit4.id()]);
assert_eq!(rebase_map.len(), 1);
// Test with for_rewrite_from() but new change id
let mut tx = repo.start_transaction(&settings);
tx.mut_repo()
.rewrite_commit(&settings, &commit2)
.generate_new_change_id()
.write()
.unwrap();
let rebase_map = tx
.mut_repo()
.rebase_descendants_return_map(&settings)
.unwrap();
assert!(rebase_map.is_empty());
}