ok/jj
1
0
Fork 0
forked from mirrors/jj
Code Pull requests Activity
jj/lib/tests/test_diff_summary.rs

275 lines
8.2 KiB
Rust
Raw Normal View History

copyright: change from "Google LLC" to "The Jujutsu Authors" Let's acknowledge everyone's contributions by replacing "Google LLC" in the copyright header by "The Jujutsu Authors". If I understand correctly, it won't have any legal effect, but maybe it still helps reduce concerns from contributors (though I haven't heard any concerns). Google employees can read about Google's policy at go/releasing/contributions#copyright.
2022-11-26 23:57:50 +00:00
// Copyright 2020 The Jujutsu Authors
import commit 0f15be02bf4012c116636913562691a0aaa7aed2 from my hg repo
2020-12-12 08:00:42 +00:00
//
// 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.
cargo: rename crates from `jujutsu`/`jujutsu-lib` to `jj-cli`/`jj-lib` Almost everyone calls the project "jj", and there seeems to be consensus that we should rename the crates. I originally wanted the crates to be called `jj` and `jj-lib`, but `jj` was already taken. `jj-cli` is probably at least as good for it anyway. Once we've published a 0.8.0 under the new names, we'll release 0.7.1 versions under the old names with pointers to the new crates names.
2023-06-28 14:12:40 +00:00
use jj_lib::matchers::{EverythingMatcher, FilesMatcher};
tests: make `create_tree()` return `MergedTree` I think most tests want a `MergedTree`, so this makes `create_tree()` return that. I kept the old function as `create_single_tree()`. That's now only used in `test_merge_trees` and `test_merged_tree`. I also consistently imported the functions now, something I've considered doing for a long time.
2023-08-28 14:55:48 +00:00
use jj_lib::merged_tree::DiffSummary;
repo_path: add stub RepoPathBuf type, update callers Most RepoPath::from_internal_string() callers will be migrated to the function that returns &RepoPath, and cloning &RepoPath won't work.
2023-11-26 07:12:36 +00:00
use jj_lib::repo_path::{RepoPath, RepoPathBuf};
test: use test backend in most remaining tests too I don't think the backend should matter for any of these tests, so let's test with only one, and let's make that the strictest one - the new test backend. This reduces the number of tests by 74 (from 974 to 900), but saves no measurable run time.
2023-09-19 12:49:42 +00:00
use testutils::{create_tree, TestRepo};
import commit 0f15be02bf4012c116636913562691a0aaa7aed2 from my hg repo
2020-12-12 08:00:42 +00:00
repo_path: add stub RepoPathBuf type, update callers Most RepoPath::from_internal_string() callers will be migrated to the function that returns &RepoPath, and cloning &RepoPath won't work.
2023-11-26 07:12:36 +00:00
fn to_owned_path_vec(paths: &[&RepoPath]) -> Vec<RepoPathBuf> {
paths.iter().map(|&path| path.to_owned()).collect()
}
test: use test backend in most remaining tests too I don't think the backend should matter for any of these tests, so let's test with only one, and let's make that the strictest one - the new test backend. This reduces the number of tests by 74 (from 974 to 900), but saves no measurable run time.
2023-09-19 12:49:42 +00:00
#[test]
fn test_types() {
let test_repo = TestRepo::init();
tests: don't create workspaces in diff-summary tests
2022-02-05 23:29:05 +00:00
let repo = &test_repo.repo;
import commit 0f15be02bf4012c116636913562691a0aaa7aed2 from my hg repo
2020-12-12 08:00:42 +00:00
repo_path: split RepoPath into owned and borrowed types This enables cheap str-to-RepoPath cast, which is useful when sorting and filtering a large Vec<(String, _)> list by using matcher for example. It will also eliminate temporary allocation by repo_path.parent().
2023-11-26 10:21:46 +00:00
let clean_path = RepoPath::from_internal_string("clean");
let modified_path = RepoPath::from_internal_string("modified");
let added_path = RepoPath::from_internal_string("added");
let removed_path = RepoPath::from_internal_string("removed");
import commit 0f15be02bf4012c116636913562691a0aaa7aed2 from my hg repo
2020-12-12 08:00:42 +00:00
tests: make `create_tree()` return `MergedTree` I think most tests want a `MergedTree`, so this makes `create_tree()` return that. I kept the old function as `create_single_tree()`. That's now only used in `test_merge_trees` and `test_merged_tree`. I also consistently imported the functions now, something I've considered doing for a long time.
2023-08-28 14:55:48 +00:00
let tree1 = create_tree(
testutils: make init_repo return a struct, including a Workspace This is a fairly mechanical change; I'll do some minor cleanups in later commits.
2021-11-21 07:46:54 +00:00
repo,
import commit 0f15be02bf4012c116636913562691a0aaa7aed2 from my hg repo
2020-12-12 08:00:42 +00:00
&[
repo_path: add stub RepoPathBuf type, update callers Most RepoPath::from_internal_string() callers will be migrated to the function that returns &RepoPath, and cloning &RepoPath won't work.
2023-11-26 07:12:36 +00:00
(clean_path, "clean"),
(modified_path, "contents before"),
(removed_path, "removed contents"),
import commit 0f15be02bf4012c116636913562691a0aaa7aed2 from my hg repo
2020-12-12 08:00:42 +00:00
],
);
tests: make `create_tree()` return `MergedTree` I think most tests want a `MergedTree`, so this makes `create_tree()` return that. I kept the old function as `create_single_tree()`. That's now only used in `test_merge_trees` and `test_merged_tree`. I also consistently imported the functions now, something I've considered doing for a long time.
2023-08-28 14:55:48 +00:00
let tree2 = create_tree(
testutils: make init_repo return a struct, including a Workspace This is a fairly mechanical change; I'll do some minor cleanups in later commits.
2021-11-21 07:46:54 +00:00
repo,
import commit 0f15be02bf4012c116636913562691a0aaa7aed2 from my hg repo
2020-12-12 08:00:42 +00:00
&[
repo_path: add stub RepoPathBuf type, update callers Most RepoPath::from_internal_string() callers will be migrated to the function that returns &RepoPath, and cloning &RepoPath won't work.
2023-11-26 07:12:36 +00:00
(clean_path, "clean"),
(modified_path, "contents after"),
(added_path, "added contents"),
import commit 0f15be02bf4012c116636913562691a0aaa7aed2 from my hg repo
2020-12-12 08:00:42 +00:00
],
);
assert_eq!(
merged_tree: propagate backend errors in diff iterator I want to fix error propagation before I start using async in this code. This makes the diff iterator propagate errors from reading tree objects. Errors include the path and don't stop the iteration. The idea is that we should be able to show the user an error inline in diff output if we failed to read a tree. That's going to be especially useful for backends that can return `BackendError::AccessDenied`. That error variant doesn't yet exist, but I plan to add it, and use it in Google's internal backend.
2023-09-07 18:35:59 +00:00
tree1.diff_summary(&tree2, &EverythingMatcher).unwrap(),
import commit 0f15be02bf4012c116636913562691a0aaa7aed2 from my hg repo
2020-12-12 08:00:42 +00:00
DiffSummary {
repo_path: add stub RepoPathBuf type, update callers Most RepoPath::from_internal_string() callers will be migrated to the function that returns &RepoPath, and cloning &RepoPath won't work.
2023-11-26 07:12:36 +00:00
modified: to_owned_path_vec(&[modified_path]),
added: to_owned_path_vec(&[added_path]),
removed: to_owned_path_vec(&[removed_path]),
import commit 0f15be02bf4012c116636913562691a0aaa7aed2 from my hg repo
2020-12-12 08:00:42 +00:00
}
);
}
test: use test backend in most remaining tests too I don't think the backend should matter for any of these tests, so let's test with only one, and let's make that the strictest one - the new test backend. This reduces the number of tests by 74 (from 974 to 900), but saves no measurable run time.
2023-09-19 12:49:42 +00:00
#[test]
fn test_tree_file_transition() {
let test_repo = TestRepo::init();
tests: don't create workspaces in diff-summary tests
2022-02-05 23:29:05 +00:00
let repo = &test_repo.repo;
import commit 0f15be02bf4012c116636913562691a0aaa7aed2 from my hg repo
2020-12-12 08:00:42 +00:00
repo_path: split RepoPath into owned and borrowed types This enables cheap str-to-RepoPath cast, which is useful when sorting and filtering a large Vec<(String, _)> list by using matcher for example. It will also eliminate temporary allocation by repo_path.parent().
2023-11-26 10:21:46 +00:00
let dir_file_path = RepoPath::from_internal_string("dir/file");
let dir_path = RepoPath::from_internal_string("dir");
import commit 0f15be02bf4012c116636913562691a0aaa7aed2 from my hg repo
2020-12-12 08:00:42 +00:00
repo_path: add stub RepoPathBuf type, update callers Most RepoPath::from_internal_string() callers will be migrated to the function that returns &RepoPath, and cloning &RepoPath won't work.
2023-11-26 07:12:36 +00:00
let tree1 = create_tree(repo, &[(dir_file_path, "contents")]);
let tree2 = create_tree(repo, &[(dir_path, "contents")]);
import commit 0f15be02bf4012c116636913562691a0aaa7aed2 from my hg repo
2020-12-12 08:00:42 +00:00
assert_eq!(
merged_tree: propagate backend errors in diff iterator I want to fix error propagation before I start using async in this code. This makes the diff iterator propagate errors from reading tree objects. Errors include the path and don't stop the iteration. The idea is that we should be able to show the user an error inline in diff output if we failed to read a tree. That's going to be especially useful for backends that can return `BackendError::AccessDenied`. That error variant doesn't yet exist, but I plan to add it, and use it in Google's internal backend.
2023-09-07 18:35:59 +00:00
tree1.diff_summary(&tree2, &EverythingMatcher).unwrap(),
import commit 0f15be02bf4012c116636913562691a0aaa7aed2 from my hg repo
2020-12-12 08:00:42 +00:00
DiffSummary {
modified: vec![],
repo_path: add stub RepoPathBuf type, update callers Most RepoPath::from_internal_string() callers will be migrated to the function that returns &RepoPath, and cloning &RepoPath won't work.
2023-11-26 07:12:36 +00:00
added: to_owned_path_vec(&[dir_path]),
removed: to_owned_path_vec(&[dir_file_path]),
import commit 0f15be02bf4012c116636913562691a0aaa7aed2 from my hg repo
2020-12-12 08:00:42 +00:00
}
);
assert_eq!(
merged_tree: propagate backend errors in diff iterator I want to fix error propagation before I start using async in this code. This makes the diff iterator propagate errors from reading tree objects. Errors include the path and don't stop the iteration. The idea is that we should be able to show the user an error inline in diff output if we failed to read a tree. That's going to be especially useful for backends that can return `BackendError::AccessDenied`. That error variant doesn't yet exist, but I plan to add it, and use it in Google's internal backend.
2023-09-07 18:35:59 +00:00
tree2.diff_summary(&tree1, &EverythingMatcher).unwrap(),
import commit 0f15be02bf4012c116636913562691a0aaa7aed2 from my hg repo
2020-12-12 08:00:42 +00:00
DiffSummary {
modified: vec![],
repo_path: add stub RepoPathBuf type, update callers Most RepoPath::from_internal_string() callers will be migrated to the function that returns &RepoPath, and cloning &RepoPath won't work.
2023-11-26 07:12:36 +00:00
added: to_owned_path_vec(&[dir_file_path]),
removed: to_owned_path_vec(&[dir_path]),
import commit 0f15be02bf4012c116636913562691a0aaa7aed2 from my hg repo
2020-12-12 08:00:42 +00:00
}
);
}
test: use test backend in most remaining tests too I don't think the backend should matter for any of these tests, so let's test with only one, and let's make that the strictest one - the new test backend. This reduces the number of tests by 74 (from 974 to 900), but saves no measurable run time.
2023-09-19 12:49:42 +00:00
#[test]
fn test_sorting() {
let test_repo = TestRepo::init();
tests: don't create workspaces in diff-summary tests
2022-02-05 23:29:05 +00:00
let repo = &test_repo.repo;
import commit 0f15be02bf4012c116636913562691a0aaa7aed2 from my hg repo
2020-12-12 08:00:42 +00:00
repo_path: split RepoPath into owned and borrowed types This enables cheap str-to-RepoPath cast, which is useful when sorting and filtering a large Vec<(String, _)> list by using matcher for example. It will also eliminate temporary allocation by repo_path.parent().
2023-11-26 10:21:46 +00:00
let a_path = RepoPath::from_internal_string("a");
let b_path = RepoPath::from_internal_string("b");
let f_a_path = RepoPath::from_internal_string("f/a");
let f_b_path = RepoPath::from_internal_string("f/b");
let f_f_a_path = RepoPath::from_internal_string("f/f/a");
let f_f_b_path = RepoPath::from_internal_string("f/f/b");
let n_path = RepoPath::from_internal_string("n");
let s_b_path = RepoPath::from_internal_string("s/b");
let z_path = RepoPath::from_internal_string("z");
import commit 0f15be02bf4012c116636913562691a0aaa7aed2 from my hg repo
2020-12-12 08:00:42 +00:00
tests: make `create_tree()` return `MergedTree` I think most tests want a `MergedTree`, so this makes `create_tree()` return that. I kept the old function as `create_single_tree()`. That's now only used in `test_merge_trees` and `test_merged_tree`. I also consistently imported the functions now, something I've considered doing for a long time.
2023-08-28 14:55:48 +00:00
let tree1 = create_tree(
testutils: make init_repo return a struct, including a Workspace This is a fairly mechanical change; I'll do some minor cleanups in later commits.
2021-11-21 07:46:54 +00:00
repo,
import commit 0f15be02bf4012c116636913562691a0aaa7aed2 from my hg repo
2020-12-12 08:00:42 +00:00
&[
repo_path: add stub RepoPathBuf type, update callers Most RepoPath::from_internal_string() callers will be migrated to the function that returns &RepoPath, and cloning &RepoPath won't work.
2023-11-26 07:12:36 +00:00
(a_path, "before"),
(f_a_path, "before"),
(f_f_a_path, "before"),
import commit 0f15be02bf4012c116636913562691a0aaa7aed2 from my hg repo
2020-12-12 08:00:42 +00:00
],
);
tests: make `create_tree()` return `MergedTree` I think most tests want a `MergedTree`, so this makes `create_tree()` return that. I kept the old function as `create_single_tree()`. That's now only used in `test_merge_trees` and `test_merged_tree`. I also consistently imported the functions now, something I've considered doing for a long time.
2023-08-28 14:55:48 +00:00
let tree2 = create_tree(
testutils: make init_repo return a struct, including a Workspace This is a fairly mechanical change; I'll do some minor cleanups in later commits.
2021-11-21 07:46:54 +00:00
repo,
import commit 0f15be02bf4012c116636913562691a0aaa7aed2 from my hg repo
2020-12-12 08:00:42 +00:00
&[
repo_path: add stub RepoPathBuf type, update callers Most RepoPath::from_internal_string() callers will be migrated to the function that returns &RepoPath, and cloning &RepoPath won't work.
2023-11-26 07:12:36 +00:00
(a_path, "after"),
(b_path, "after"),
(f_a_path, "after"),
(f_b_path, "after"),
(f_f_a_path, "after"),
(f_f_b_path, "after"),
(n_path, "after"),
(s_b_path, "after"),
(z_path, "after"),
import commit 0f15be02bf4012c116636913562691a0aaa7aed2 from my hg repo
2020-12-12 08:00:42 +00:00
],
);
assert_eq!(
merged_tree: propagate backend errors in diff iterator I want to fix error propagation before I start using async in this code. This makes the diff iterator propagate errors from reading tree objects. Errors include the path and don't stop the iteration. The idea is that we should be able to show the user an error inline in diff output if we failed to read a tree. That's going to be especially useful for backends that can return `BackendError::AccessDenied`. That error variant doesn't yet exist, but I plan to add it, and use it in Google's internal backend.
2023-09-07 18:35:59 +00:00
tree1.diff_summary(&tree2, &EverythingMatcher).unwrap(),
import commit 0f15be02bf4012c116636913562691a0aaa7aed2 from my hg repo
2020-12-12 08:00:42 +00:00
DiffSummary {
repo_path: add stub RepoPathBuf type, update callers Most RepoPath::from_internal_string() callers will be migrated to the function that returns &RepoPath, and cloning &RepoPath won't work.
2023-11-26 07:12:36 +00:00
modified: to_owned_path_vec(&[a_path, f_a_path, f_f_a_path]),
added: to_owned_path_vec(&[b_path, f_b_path, f_f_b_path, n_path, s_b_path, z_path]),
removed: vec![],
import commit 0f15be02bf4012c116636913562691a0aaa7aed2 from my hg repo
2020-12-12 08:00:42 +00:00
}
);
assert_eq!(
merged_tree: propagate backend errors in diff iterator I want to fix error propagation before I start using async in this code. This makes the diff iterator propagate errors from reading tree objects. Errors include the path and don't stop the iteration. The idea is that we should be able to show the user an error inline in diff output if we failed to read a tree. That's going to be especially useful for backends that can return `BackendError::AccessDenied`. That error variant doesn't yet exist, but I plan to add it, and use it in Google's internal backend.
2023-09-07 18:35:59 +00:00
tree2.diff_summary(&tree1, &EverythingMatcher).unwrap(),
import commit 0f15be02bf4012c116636913562691a0aaa7aed2 from my hg repo
2020-12-12 08:00:42 +00:00
DiffSummary {
repo_path: add stub RepoPathBuf type, update callers Most RepoPath::from_internal_string() callers will be migrated to the function that returns &RepoPath, and cloning &RepoPath won't work.
2023-11-26 07:12:36 +00:00
modified: to_owned_path_vec(&[a_path, f_a_path, f_f_a_path]),
import commit 0f15be02bf4012c116636913562691a0aaa7aed2 from my hg repo
2020-12-12 08:00:42 +00:00
added: vec![],
repo_path: add stub RepoPathBuf type, update callers Most RepoPath::from_internal_string() callers will be migrated to the function that returns &RepoPath, and cloning &RepoPath won't work.
2023-11-26 07:12:36 +00:00
removed: to_owned_path_vec(&[b_path, f_b_path, f_f_b_path, n_path, s_b_path, z_path]),
import commit 0f15be02bf4012c116636913562691a0aaa7aed2 from my hg repo
2020-12-12 08:00:42 +00:00
}
);
}
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
test: use test backend in most remaining tests too I don't think the backend should matter for any of these tests, so let's test with only one, and let's make that the strictest one - the new test backend. This reduces the number of tests by 74 (from 974 to 900), but saves no measurable run time.
2023-09-19 12:49:42 +00:00
#[test]
fn test_matcher_dir_file_transition() {
let test_repo = TestRepo::init();
tests: don't create workspaces in diff-summary tests
2022-02-05 23:29:05 +00:00
let repo = &test_repo.repo;
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
repo_path: split RepoPath into owned and borrowed types This enables cheap str-to-RepoPath cast, which is useful when sorting and filtering a large Vec<(String, _)> list by using matcher for example. It will also eliminate temporary allocation by repo_path.parent().
2023-11-26 10:21:46 +00:00
let a_path = RepoPath::from_internal_string("a");
let a_a_path = RepoPath::from_internal_string("a/a");
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
repo_path: add stub RepoPathBuf type, update callers Most RepoPath::from_internal_string() callers will be migrated to the function that returns &RepoPath, and cloning &RepoPath won't work.
2023-11-26 07:12:36 +00:00
let tree1 = create_tree(repo, &[(a_path, "before")]);
let tree2 = create_tree(repo, &[(a_a_path, "after")]);
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
matchers: make Files/PrefixMatcher constructors accept slice of borrowed paths RepoPath will become slice type (like str), and it doesn't make sense to require &[RepoPathBuf] here.
2023-11-26 08:42:12 +00:00
let matcher = FilesMatcher::new([&a_path]);
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
assert_eq!(
merged_tree: propagate backend errors in diff iterator I want to fix error propagation before I start using async in this code. This makes the diff iterator propagate errors from reading tree objects. Errors include the path and don't stop the iteration. The idea is that we should be able to show the user an error inline in diff output if we failed to read a tree. That's going to be especially useful for backends that can return `BackendError::AccessDenied`. That error variant doesn't yet exist, but I plan to add it, and use it in Google's internal backend.
2023-09-07 18:35:59 +00:00
tree1.diff_summary(&tree2, &matcher).unwrap(),
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
DiffSummary {
modified: vec![],
added: vec![],
repo_path: add stub RepoPathBuf type, update callers Most RepoPath::from_internal_string() callers will be migrated to the function that returns &RepoPath, and cloning &RepoPath won't work.
2023-11-26 07:12:36 +00:00
removed: to_owned_path_vec(&[a_path]),
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
}
);
assert_eq!(
merged_tree: propagate backend errors in diff iterator I want to fix error propagation before I start using async in this code. This makes the diff iterator propagate errors from reading tree objects. Errors include the path and don't stop the iteration. The idea is that we should be able to show the user an error inline in diff output if we failed to read a tree. That's going to be especially useful for backends that can return `BackendError::AccessDenied`. That error variant doesn't yet exist, but I plan to add it, and use it in Google's internal backend.
2023-09-07 18:35:59 +00:00
tree2.diff_summary(&tree1, &matcher).unwrap(),
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
DiffSummary {
modified: vec![],
repo_path: add stub RepoPathBuf type, update callers Most RepoPath::from_internal_string() callers will be migrated to the function that returns &RepoPath, and cloning &RepoPath won't work.
2023-11-26 07:12:36 +00:00
added: to_owned_path_vec(&[a_path]),
removed: vec![],
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
}
);
repo_path: add stub RepoPathBuf type, update callers Most RepoPath::from_internal_string() callers will be migrated to the function that returns &RepoPath, and cloning &RepoPath won't work.
2023-11-26 07:12:36 +00:00
let matcher = FilesMatcher::new([a_a_path]);
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
assert_eq!(
merged_tree: propagate backend errors in diff iterator I want to fix error propagation before I start using async in this code. This makes the diff iterator propagate errors from reading tree objects. Errors include the path and don't stop the iteration. The idea is that we should be able to show the user an error inline in diff output if we failed to read a tree. That's going to be especially useful for backends that can return `BackendError::AccessDenied`. That error variant doesn't yet exist, but I plan to add it, and use it in Google's internal backend.
2023-09-07 18:35:59 +00:00
tree1.diff_summary(&tree2, &matcher).unwrap(),
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
DiffSummary {
modified: vec![],
repo_path: add stub RepoPathBuf type, update callers Most RepoPath::from_internal_string() callers will be migrated to the function that returns &RepoPath, and cloning &RepoPath won't work.
2023-11-26 07:12:36 +00:00
added: to_owned_path_vec(&[a_a_path]),
removed: vec![],
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
}
);
assert_eq!(
merged_tree: propagate backend errors in diff iterator I want to fix error propagation before I start using async in this code. This makes the diff iterator propagate errors from reading tree objects. Errors include the path and don't stop the iteration. The idea is that we should be able to show the user an error inline in diff output if we failed to read a tree. That's going to be especially useful for backends that can return `BackendError::AccessDenied`. That error variant doesn't yet exist, but I plan to add it, and use it in Google's internal backend.
2023-09-07 18:35:59 +00:00
tree2.diff_summary(&tree1, &matcher).unwrap(),
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
DiffSummary {
modified: vec![],
added: vec![],
repo_path: add stub RepoPathBuf type, update callers Most RepoPath::from_internal_string() callers will be migrated to the function that returns &RepoPath, and cloning &RepoPath won't work.
2023-11-26 07:12:36 +00:00
removed: to_owned_path_vec(&[a_a_path]),
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
}
);
repo_path: add stub RepoPathBuf type, update callers Most RepoPath::from_internal_string() callers will be migrated to the function that returns &RepoPath, and cloning &RepoPath won't work.
2023-11-26 07:12:36 +00:00
let matcher = FilesMatcher::new([a_path, a_a_path]);
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
assert_eq!(
merged_tree: propagate backend errors in diff iterator I want to fix error propagation before I start using async in this code. This makes the diff iterator propagate errors from reading tree objects. Errors include the path and don't stop the iteration. The idea is that we should be able to show the user an error inline in diff output if we failed to read a tree. That's going to be especially useful for backends that can return `BackendError::AccessDenied`. That error variant doesn't yet exist, but I plan to add it, and use it in Google's internal backend.
2023-09-07 18:35:59 +00:00
tree1.diff_summary(&tree2, &matcher).unwrap(),
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
DiffSummary {
modified: vec![],
repo_path: add stub RepoPathBuf type, update callers Most RepoPath::from_internal_string() callers will be migrated to the function that returns &RepoPath, and cloning &RepoPath won't work.
2023-11-26 07:12:36 +00:00
added: to_owned_path_vec(&[a_a_path]),
removed: to_owned_path_vec(&[a_path]),
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
}
);
assert_eq!(
merged_tree: propagate backend errors in diff iterator I want to fix error propagation before I start using async in this code. This makes the diff iterator propagate errors from reading tree objects. Errors include the path and don't stop the iteration. The idea is that we should be able to show the user an error inline in diff output if we failed to read a tree. That's going to be especially useful for backends that can return `BackendError::AccessDenied`. That error variant doesn't yet exist, but I plan to add it, and use it in Google's internal backend.
2023-09-07 18:35:59 +00:00
tree2.diff_summary(&tree1, &matcher).unwrap(),
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
DiffSummary {
modified: vec![],
repo_path: add stub RepoPathBuf type, update callers Most RepoPath::from_internal_string() callers will be migrated to the function that returns &RepoPath, and cloning &RepoPath won't work.
2023-11-26 07:12:36 +00:00
added: to_owned_path_vec(&[a_path]),
removed: to_owned_path_vec(&[a_a_path]),
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
}
);
}
test: use test backend in most remaining tests too I don't think the backend should matter for any of these tests, so let's test with only one, and let's make that the strictest one - the new test backend. This reduces the number of tests by 74 (from 974 to 900), but saves no measurable run time.
2023-09-19 12:49:42 +00:00
#[test]
fn test_matcher_normal_cases() {
let test_repo = TestRepo::init();
tests: don't create workspaces in diff-summary tests
2022-02-05 23:29:05 +00:00
let repo = &test_repo.repo;
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
repo_path: split RepoPath into owned and borrowed types This enables cheap str-to-RepoPath cast, which is useful when sorting and filtering a large Vec<(String, _)> list by using matcher for example. It will also eliminate temporary allocation by repo_path.parent().
2023-11-26 10:21:46 +00:00
let a_path = RepoPath::from_internal_string("a");
let dir1_a_path = RepoPath::from_internal_string("dir1/a");
let dir2_b_path = RepoPath::from_internal_string("dir2/b");
let z_path = RepoPath::from_internal_string("z");
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
repo_path: add stub RepoPathBuf type, update callers Most RepoPath::from_internal_string() callers will be migrated to the function that returns &RepoPath, and cloning &RepoPath won't work.
2023-11-26 07:12:36 +00:00
let tree1 = create_tree(repo, &[(a_path, "before"), (dir1_a_path, "before")]);
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
// File "a" gets modified
// File "dir1/a" gets modified
// File "dir2/b" gets created
// File "z" gets created
tests: make `create_tree()` return `MergedTree` I think most tests want a `MergedTree`, so this makes `create_tree()` return that. I kept the old function as `create_single_tree()`. That's now only used in `test_merge_trees` and `test_merged_tree`. I also consistently imported the functions now, something I've considered doing for a long time.
2023-08-28 14:55:48 +00:00
let tree2 = create_tree(
testutils: make init_repo return a struct, including a Workspace This is a fairly mechanical change; I'll do some minor cleanups in later commits.
2021-11-21 07:46:54 +00:00
repo,
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
&[
repo_path: add stub RepoPathBuf type, update callers Most RepoPath::from_internal_string() callers will be migrated to the function that returns &RepoPath, and cloning &RepoPath won't work.
2023-11-26 07:12:36 +00:00
(a_path, "after"),
(dir1_a_path, "after"),
(dir2_b_path, "after"),
(z_path, "after"),
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
],
);
repo_path: add stub RepoPathBuf type, update callers Most RepoPath::from_internal_string() callers will be migrated to the function that returns &RepoPath, and cloning &RepoPath won't work.
2023-11-26 07:12:36 +00:00
let matcher = FilesMatcher::new([a_path, z_path]);
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
assert_eq!(
merged_tree: propagate backend errors in diff iterator I want to fix error propagation before I start using async in this code. This makes the diff iterator propagate errors from reading tree objects. Errors include the path and don't stop the iteration. The idea is that we should be able to show the user an error inline in diff output if we failed to read a tree. That's going to be especially useful for backends that can return `BackendError::AccessDenied`. That error variant doesn't yet exist, but I plan to add it, and use it in Google's internal backend.
2023-09-07 18:35:59 +00:00
tree1.diff_summary(&tree2, &matcher).unwrap(),
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
DiffSummary {
repo_path: add stub RepoPathBuf type, update callers Most RepoPath::from_internal_string() callers will be migrated to the function that returns &RepoPath, and cloning &RepoPath won't work.
2023-11-26 07:12:36 +00:00
modified: to_owned_path_vec(&[a_path]),
added: to_owned_path_vec(&[z_path]),
removed: vec![],
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
}
);
assert_eq!(
merged_tree: propagate backend errors in diff iterator I want to fix error propagation before I start using async in this code. This makes the diff iterator propagate errors from reading tree objects. Errors include the path and don't stop the iteration. The idea is that we should be able to show the user an error inline in diff output if we failed to read a tree. That's going to be especially useful for backends that can return `BackendError::AccessDenied`. That error variant doesn't yet exist, but I plan to add it, and use it in Google's internal backend.
2023-09-07 18:35:59 +00:00
tree2.diff_summary(&tree1, &matcher).unwrap(),
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
DiffSummary {
repo_path: add stub RepoPathBuf type, update callers Most RepoPath::from_internal_string() callers will be migrated to the function that returns &RepoPath, and cloning &RepoPath won't work.
2023-11-26 07:12:36 +00:00
modified: to_owned_path_vec(&[a_path]),
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
added: vec![],
repo_path: add stub RepoPathBuf type, update callers Most RepoPath::from_internal_string() callers will be migrated to the function that returns &RepoPath, and cloning &RepoPath won't work.
2023-11-26 07:12:36 +00:00
removed: to_owned_path_vec(&[z_path]),
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
}
);
repo_path: add stub RepoPathBuf type, update callers Most RepoPath::from_internal_string() callers will be migrated to the function that returns &RepoPath, and cloning &RepoPath won't work.
2023-11-26 07:12:36 +00:00
let matcher = FilesMatcher::new([dir1_a_path, dir2_b_path]);
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
assert_eq!(
merged_tree: propagate backend errors in diff iterator I want to fix error propagation before I start using async in this code. This makes the diff iterator propagate errors from reading tree objects. Errors include the path and don't stop the iteration. The idea is that we should be able to show the user an error inline in diff output if we failed to read a tree. That's going to be especially useful for backends that can return `BackendError::AccessDenied`. That error variant doesn't yet exist, but I plan to add it, and use it in Google's internal backend.
2023-09-07 18:35:59 +00:00
tree1.diff_summary(&tree2, &matcher).unwrap(),
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
DiffSummary {
repo_path: add stub RepoPathBuf type, update callers Most RepoPath::from_internal_string() callers will be migrated to the function that returns &RepoPath, and cloning &RepoPath won't work.
2023-11-26 07:12:36 +00:00
modified: to_owned_path_vec(&[dir1_a_path]),
added: to_owned_path_vec(&[dir2_b_path]),
removed: vec![],
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
}
);
assert_eq!(
merged_tree: propagate backend errors in diff iterator I want to fix error propagation before I start using async in this code. This makes the diff iterator propagate errors from reading tree objects. Errors include the path and don't stop the iteration. The idea is that we should be able to show the user an error inline in diff output if we failed to read a tree. That's going to be especially useful for backends that can return `BackendError::AccessDenied`. That error variant doesn't yet exist, but I plan to add it, and use it in Google's internal backend.
2023-09-07 18:35:59 +00:00
tree2.diff_summary(&tree1, &matcher).unwrap(),
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
DiffSummary {
repo_path: add stub RepoPathBuf type, update callers Most RepoPath::from_internal_string() callers will be migrated to the function that returns &RepoPath, and cloning &RepoPath won't work.
2023-11-26 07:12:36 +00:00
modified: to_owned_path_vec(&[dir1_a_path]),
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
added: vec![],
repo_path: add stub RepoPathBuf type, update callers Most RepoPath::from_internal_string() callers will be migrated to the function that returns &RepoPath, and cloning &RepoPath won't work.
2023-11-26 07:12:36 +00:00
removed: to_owned_path_vec(&[dir2_b_path]),
tree: support filtering diff by matcher This change teaches `Tree::diff()` to filter by a matcher. It only filters the result so far; it does not restrict the tree walk to what `Matcher::visit()` says is necessary yet. It also doesn't teach the CLI to create a matcher and pass it in.
2021-06-05 21:29:40 +00:00
}
);
}
Copy permalink