268 lines
13 KiB
Python
268 lines
13 KiB
Python
from __future__ import annotations
|
|
|
|
import os
|
|
import unittest
|
|
from contextlib import nullcontext
|
|
from pathlib import Path
|
|
from tempfile import TemporaryDirectory
|
|
from unittest.mock import patch
|
|
|
|
from grouping import expand_range, prompt_group_ranges, range_completions, run
|
|
from tools.filesystem import remove_empty_dirs
|
|
|
|
|
|
class GroupingTests(unittest.TestCase):
|
|
def test_first_endpoint_completion_accepts_files_folders_and_quotes(self) -> None:
|
|
with TemporaryDirectory() as temporary:
|
|
root = Path(temporary)
|
|
(root / "A photo.jpg").touch()
|
|
(root / "A folder").mkdir()
|
|
for prefix in (str(root / "A"), '"' + str(root / "A")):
|
|
candidates = range_completions(prefix)
|
|
self.assertEqual(len(candidates), 2)
|
|
self.assertEqual(
|
|
{expand_range(candidate)[1][0] for candidate in candidates},
|
|
{root / "A photo.jpg", root / "A folder"},
|
|
)
|
|
|
|
def test_second_endpoint_completes_only_same_type_siblings(self) -> None:
|
|
with TemporaryDirectory() as temporary:
|
|
root = Path(temporary)
|
|
for name in ("A photo.jpg", "B photo.jpg", "C photo.jpg"):
|
|
(root / name).touch()
|
|
for name in ("A folder", "C folder"):
|
|
(root / name).mkdir()
|
|
prefix = f'"{root / "C photo.jpg"}" '
|
|
candidates = range_completions(prefix)
|
|
self.assertEqual(len(candidates), 3)
|
|
self.assertEqual(range_completions(prefix + '"A ph'), [candidates[0]])
|
|
self.assertEqual([p.name for p in expand_range(candidates[0])[1]],
|
|
["A photo.jpg", "B photo.jpg", "C photo.jpg"])
|
|
folder_candidates = range_completions(f'"{root / "C folder"}" ')
|
|
self.assertEqual(len(folder_candidates), 2)
|
|
self.assertTrue(all(p.is_dir() for p in expand_range(folder_candidates[0])[1]))
|
|
self.assertEqual(range_completions(prefix + '"B photo.jpg" "third'), [])
|
|
|
|
@unittest.skipIf(os.name == "nt", "Unix absolute and home-directory paths")
|
|
def test_absolute_second_endpoint_completes_parent_then_sibling(self) -> None:
|
|
with TemporaryDirectory() as temporary:
|
|
root = Path(temporary)
|
|
(root / "A.jpg").touch()
|
|
(root / "B.jpg").touch()
|
|
prefix = f'"{root / "B.jpg"}" '
|
|
directory = str(root) + "/"
|
|
self.assertEqual(range_completions(prefix + "/"), [prefix + directory])
|
|
self.assertEqual(range_completions(prefix + directory),
|
|
[prefix + str(root / "A.jpg"), prefix + str(root / "B.jpg")])
|
|
self.assertEqual(range_completions(prefix + "/elsewhere/"), [])
|
|
with patch.dict("os.environ", {"HOME": str(root.parent)}):
|
|
completed = range_completions(prefix + "~")
|
|
self.assertEqual(len(completed), 1)
|
|
candidates = range_completions(completed[0])
|
|
self.assertEqual([p.name for p in expand_range(candidates[0])[1]], ["A.jpg", "B.jpg"])
|
|
|
|
def run_interactive(self, *lines: str) -> int:
|
|
with (
|
|
patch("grouping.prompt_input", side_effect=[*lines, ""]),
|
|
patch("grouping.path_completion", return_value=nullcontext()),
|
|
patch("builtins.print"),
|
|
):
|
|
return run(["grouping.py"])
|
|
|
|
def test_file_range_is_inclusive_sorted_and_skips_folders(self) -> None:
|
|
with TemporaryDirectory() as temporary:
|
|
root = Path(temporary)
|
|
for name in ("D.jpg", "C.jpg", "a.jpg", "B.jpg"):
|
|
(root / name).touch()
|
|
(root / "BB-folder").mkdir()
|
|
parent, paths = expand_range(f'"{root / "a.jpg"}" C.jpg')
|
|
self.assertEqual(parent, root)
|
|
self.assertEqual([path.name for path in paths], ["a.jpg", "B.jpg", "C.jpg"])
|
|
self.assertEqual(expand_range(f'"{root / "C.jpg"}" a.jpg')[1], paths)
|
|
self.assertEqual(expand_range(f'"{root / "a.jpg"}" "{root / "C.jpg"}"')[1], paths)
|
|
|
|
def test_folder_range_skips_files_and_single_folder_uses_parent(self) -> None:
|
|
with TemporaryDirectory() as temporary:
|
|
root = Path(temporary)
|
|
for name in ("A folder", "B folder", "C folder"):
|
|
(root / name).mkdir()
|
|
(root / "B.jpg").touch()
|
|
parent, paths = expand_range(f'"{root / "A folder"}" "C folder"')
|
|
self.assertEqual(parent, root)
|
|
self.assertEqual([path.name for path in paths], ["A folder", "B folder", "C folder"])
|
|
self.assertEqual(expand_range(f'"{root / "A folder"}"'), (root, [root / "A folder"]))
|
|
|
|
def test_invalid_ranges_are_rejected(self) -> None:
|
|
with TemporaryDirectory() as temporary:
|
|
root = Path(temporary)
|
|
(root / "A.jpg").touch()
|
|
(root / "folder").mkdir()
|
|
(root / "folder" / "B.jpg").touch()
|
|
for line in (
|
|
f'"{root / "A.jpg"}" folder',
|
|
f'"{root / "A.jpg"}" folder/B.jpg',
|
|
f'"{root / "A.jpg"}" missing.jpg',
|
|
f'"{root / "A.jpg"}',
|
|
f'"{root / "A.jpg"}" B C',
|
|
):
|
|
with self.subTest(line=line), self.assertRaises(ValueError):
|
|
expand_range(line)
|
|
|
|
def test_wildcard_matches_zero_or_more_characters_and_folders(self) -> None:
|
|
with TemporaryDirectory() as temporary:
|
|
root = Path(temporary)
|
|
for name in ("Trip .jpg", "Trip A.jpg", "Trip AB.jpg", "Other.jpg"):
|
|
(root / name).touch()
|
|
(root / "Trip folder").mkdir()
|
|
parent, paths = expand_range(f'"{root / "Trip *.jpg"}"')
|
|
self.assertEqual(parent, root)
|
|
self.assertEqual([p.name for p in paths], ["Trip .jpg", "Trip A.jpg", "Trip AB.jpg"])
|
|
self.assertEqual(len(expand_range(f'"{root / "Trip *"}"')[1]), 4)
|
|
(root / "[photo]1.jpg").touch()
|
|
(root / "p1.jpg").touch()
|
|
self.assertEqual(expand_range(f'"{root / "[photo]*.jpg"}"')[1], [root / "[photo]1.jpg"])
|
|
|
|
def test_wildcard_directory_components_use_common_parent(self) -> None:
|
|
with TemporaryDirectory() as temporary:
|
|
root = Path(temporary)
|
|
for name in ("Trip1", "Trip2"):
|
|
(root / name).mkdir()
|
|
(root / name / "A.jpg").touch()
|
|
parent, paths = expand_range(f'"{root}/Trip*/A.jpg"')
|
|
self.assertEqual(parent, root)
|
|
self.assertEqual(paths, [root / "Trip1" / "A.jpg", root / "Trip2" / "A.jpg"])
|
|
|
|
def test_invalid_wildcards_do_not_become_ranges_or_counts(self) -> None:
|
|
with TemporaryDirectory() as temporary:
|
|
root = Path(temporary)
|
|
(root / "A.jpg").touch()
|
|
for line in (
|
|
f'"{root / "*.jpg"}" A.jpg',
|
|
f'"{root / "A.jpg"}" *.jpg',
|
|
f'"{root / "*.jpg"}" 2',
|
|
f'"{root / "missing*"}"',
|
|
):
|
|
with self.subTest(line=line), self.assertRaises(ValueError):
|
|
expand_range(line)
|
|
|
|
def test_count_includes_start_and_skips_other_type(self) -> None:
|
|
with TemporaryDirectory() as temporary:
|
|
root = Path(temporary)
|
|
for name in ("A.jpg", "b.jpg", "C.jpg", "D.jpg"):
|
|
(root / name).touch()
|
|
for name in ("A folder", "B folder", "C folder"):
|
|
(root / name).mkdir()
|
|
self.assertEqual(expand_range(f'"{root / "b.jpg"}" 2'), (root, [root / "b.jpg", root / "C.jpg"]))
|
|
self.assertEqual(expand_range(f'"{root / "D.jpg"}" 1'), (root, [root / "D.jpg"]))
|
|
self.assertEqual(expand_range(f'"{root / "A folder"}" 2')[1], [root / "A folder", root / "B folder"])
|
|
for count in ("0", "-1", "3", "1.5"):
|
|
with self.subTest(count=count), self.assertRaises(ValueError):
|
|
expand_range(f'"{root / "C.jpg"}" {count}')
|
|
(root / "2").touch()
|
|
self.assertEqual(range_completions(f'"{root / "A.jpg"}" 2'), [])
|
|
self.assertEqual(expand_range(f'"{root / "A.jpg"}" "{root / "2"}"')[1], [root / "2", root / "A.jpg"])
|
|
|
|
def test_wildcards_and_counts_combine_into_one_group(self) -> None:
|
|
with TemporaryDirectory() as temporary:
|
|
root = Path(temporary)
|
|
for name in ("A.jpg", "B.jpg", "C.jpg", "D.jpg"):
|
|
(root / name).write_bytes(name.encode())
|
|
(root / "Extra" / "empty").mkdir(parents=True)
|
|
(root / "Extra" / "E.jpg").touch()
|
|
self.assertEqual(self.run_interactive(
|
|
f'"{root / "A.jpg"}" 99',
|
|
f'"{root / "A.jpg"}" 2',
|
|
f'"{root / "B*"}"',
|
|
f'"{root / "Extra*"}"',
|
|
), 0)
|
|
self.assertEqual(sorted(p.name for p in (root / "A-E").iterdir()), ["A.jpg", "B.jpg", "E.jpg"])
|
|
self.assertEqual((root / "C.jpg").read_bytes(), b"C.jpg")
|
|
self.assertEqual((root / "D.jpg").read_bytes(), b"D.jpg")
|
|
self.assertFalse((root / "Extra").exists())
|
|
|
|
def test_prompt_lists_all_input_forms(self) -> None:
|
|
with (
|
|
patch("grouping.prompt_input", return_value=""),
|
|
patch("grouping.path_completion", return_value=nullcontext()),
|
|
patch("builtins.print") as output,
|
|
):
|
|
self.assertEqual(prompt_group_ranges(), ([], None))
|
|
instructions = "\n".join(call.args[0] for call in output.call_args_list)
|
|
for form in ("One file or folder", "Wildcard", "Inclusive range", "Five files", "Quote", "Tab", "empty"):
|
|
self.assertIn(form, instructions)
|
|
|
|
def test_overlapping_ranges_group_once_after_blank_line(self) -> None:
|
|
with TemporaryDirectory() as temporary:
|
|
root = Path(temporary)
|
|
for name in ("A.jpg", "B.jpg", "C.jpg", "D.jpg"):
|
|
(root / name).write_bytes(name.encode())
|
|
self.assertEqual(self.run_interactive(
|
|
f'"{root / "missing.jpg"}"',
|
|
f'"{root / "A.jpg"}" B.jpg',
|
|
f'"{root / "B.jpg"}" C.jpg',
|
|
), 0)
|
|
group = root / "A-C"
|
|
self.assertEqual(sorted(path.name for path in group.iterdir()), ["A.jpg", "B.jpg", "C.jpg"])
|
|
self.assertEqual((root / "D.jpg").read_bytes(), b"D.jpg")
|
|
self.assertEqual((group / "B.jpg").read_bytes(), b"B.jpg")
|
|
|
|
def test_recursive_folders_flatten_with_collision_suffixes_and_cleanup(self) -> None:
|
|
with TemporaryDirectory() as temporary:
|
|
root = Path(temporary)
|
|
for folder in ("A", "B", "C"):
|
|
(root / folder / "nested" / "empty").mkdir(parents=True)
|
|
(root / "A" / "nested" / "photo.jpg").write_bytes(b"first")
|
|
(root / "C" / "photo.jpg").write_bytes(b"second")
|
|
self.assertEqual(self.run_interactive(f'"{root / "A"}" C'), 0)
|
|
group = root / "photo-photo"
|
|
self.assertEqual(set(path.name for path in group.iterdir()), {"photo.jpg", "photo-1.jpg"})
|
|
self.assertEqual({path.read_bytes() for path in group.iterdir()}, {b"first", b"second"})
|
|
self.assertEqual(list(root.iterdir()), [group])
|
|
|
|
def test_empty_only_folder_selection_still_gets_removed(self) -> None:
|
|
with TemporaryDirectory() as temporary:
|
|
root = Path(temporary)
|
|
(root / "A" / "empty" / "leaf").mkdir(parents=True)
|
|
self.assertEqual(self.run_interactive(f'"{root / "A"}"'), 0)
|
|
self.assertEqual(list(root.iterdir()), [])
|
|
|
|
def test_existing_group_is_reused_without_renaming_its_own_files(self) -> None:
|
|
with TemporaryDirectory() as temporary:
|
|
root = Path(temporary)
|
|
target = root / "A-C"
|
|
target.mkdir()
|
|
(target / "A.jpg").write_bytes(b"existing")
|
|
(root / "C.jpg").write_bytes(b"new")
|
|
self.assertEqual(self.run_interactive(f'"{target}"', f'"{root / "C.jpg"}"'), 0)
|
|
self.assertEqual(sorted(path.name for path in target.iterdir()), ["A.jpg", "C.jpg"])
|
|
self.assertEqual((target / "A.jpg").read_bytes(), b"existing")
|
|
|
|
def test_command_line_folder_keeps_existing_working_directory_rule(self) -> None:
|
|
with TemporaryDirectory() as temporary:
|
|
root = Path(temporary)
|
|
nested = root / "nested"
|
|
nested.mkdir()
|
|
(nested / "photo.jpg").touch()
|
|
(nested / "notes.txt").touch()
|
|
with patch("builtins.print"):
|
|
self.assertEqual(run(["grouping.py", str(root)]), 0)
|
|
self.assertEqual(
|
|
sorted(path.name for path in (root / "notes-photo").iterdir()),
|
|
["notes.txt", "photo.jpg"],
|
|
)
|
|
self.assertFalse(nested.exists())
|
|
|
|
def test_cleanup_keeps_any_remaining_files_and_their_parents(self) -> None:
|
|
with TemporaryDirectory() as temporary:
|
|
root = Path(temporary)
|
|
(root / "selected" / "empty" / "leaf").mkdir(parents=True)
|
|
notes = root / "selected" / "notes.txt"
|
|
notes.write_bytes(b"keep")
|
|
remove_empty_dirs([root / "selected"], {root})
|
|
self.assertEqual(notes.read_bytes(), b"keep")
|
|
self.assertFalse((root / "selected" / "empty").exists())
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|