relink.py: Now supports multiple source_root dirs.

Author: samsrabin

relink.py

@@ -228,17 +228,23 @@ def replace_files_with_symlinks(
 
 def validate_directory(path):
     """
-    Validate that the path exists and is a directory.
+    Validate that one or more paths exist and are directories.
 
     Args:
-        path (str): The path to validate.
+        path (str or list): The path to validate, or a list of such paths.
 
     Returns:
-        str: The absolute path if valid.
+        str or list: The absolute path(s) if valid.
 
     Raises:
-        argparse.ArgumentTypeError: If path doesn't exist or is not a directory.
+        argparse.ArgumentTypeError: If a path doesn't exist or is not a directory.
     """
+    if isinstance(path, list):
+        result = []
+        for item in path:
+            result.append(validate_directory(item))
+        return result
+
     if not os.path.exists(path):
         raise argparse.ArgumentTypeError(f"Directory '{path}' does not exist")
     if not os.path.isdir(path):
@@ -261,11 +267,10 @@ def parse_arguments():
     )
     parser.add_argument(
         "source_root",
-        nargs="?",
-        type=validate_directory,
+        nargs="*",
         default=DEFAULT_SOURCE_ROOT,
         help=(
-            f"The root of the directory tree to search for files (default: {DEFAULT_SOURCE_ROOT})"
+            f"One or more directories to search for files (default: {DEFAULT_SOURCE_ROOT})"
         ),
     )
     parser.add_argument(
@@ -347,13 +352,14 @@ def main():
     start_time = time.time()
 
     # --- Execution ---
-    replace_files_with_symlinks(
-        args.source_root,
-        args.target_root,
-        my_username,
-        inputdata_root=args.inputdata_root,
-        dry_run=args.dry_run,
-    )
+    for item in args.source_root:
+        replace_files_with_symlinks(
+            item,
+            args.target_root,
+            my_username,
+            inputdata_root=args.inputdata_root,
+            dry_run=args.dry_run,
+        )
 
     if args.timing:
         elapsed_time = time.time() - start_time

tests/relink/test_args.py

@@ -54,7 +54,7 @@ def test_custom_source_root(self, mock_default_dirs, tmp_path):
         custom_source.mkdir()
         with patch("sys.argv", ["relink.py", str(custom_source)]):
             args = relink.parse_arguments()
-            assert args.source_root == str(custom_source.resolve())
+            assert args.source_root == [str(custom_source.resolve())]
             assert args.target_root == target_dir
 
     def test_custom_target_root(self, mock_default_dirs, tmp_path):
@@ -83,7 +83,7 @@ def test_both_custom_paths(self, tmp_path):
             ],
         ):
             args = relink.parse_arguments()
-            assert args.source_root == str(source_path.resolve())
+            assert args.source_root == [str(source_path.resolve())]
             assert args.target_root == str(target_path.resolve())
 
     def test_verbose_flag(self, mock_default_dirs):  # pylint: disable=unused-argument
@@ -171,6 +171,49 @@ def test_timing_default(self, mock_default_dirs):
             args = relink.parse_arguments()
             assert args.timing is False
 
+    def test_multiple_source_roots(self, mock_default_dirs, tmp_path):
+        """Test that multiple source root arguments are parsed correctly."""
+        _, target_dir = mock_default_dirs
+        source1 = tmp_path / "source1"
+        source2 = tmp_path / "source2"
+        source3 = tmp_path / "source3"
+        source1.mkdir()
+        source2.mkdir()
+        source3.mkdir()
+
+        with patch("sys.argv", ["relink.py", str(source1), str(source2), str(source3)]):
+            args = relink.parse_arguments()
+            assert len(args.source_root) == 3
+            assert str(source1.resolve()) in args.source_root
+            assert str(source2.resolve()) in args.source_root
+            assert str(source3.resolve()) in args.source_root
+            assert args.target_root == target_dir
+
+    def test_multiple_source_roots_with_target(self, tmp_path):
+        """Test multiple source roots with custom target root."""
+        source1 = tmp_path / "source1"
+        source2 = tmp_path / "source2"
+        target = tmp_path / "target"
+        source1.mkdir()
+        source2.mkdir()
+        target.mkdir()
+
+        with patch(
+            "sys.argv",
+            [
+                "relink.py",
+                str(source1),
+                str(source2),
+                "--target-root",
+                str(target),
+            ],
+        ):
+            args = relink.parse_arguments()
+            assert len(args.source_root) == 2
+            assert str(source1.resolve()) in args.source_root
+            assert str(source2.resolve()) in args.source_root
+            assert args.target_root == str(target.resolve())
+
 
 class TestValidateDirectory:
     """Test suite for validate_directory function."""
@@ -232,6 +275,29 @@ def test_symlink_to_directory(self, tmp_path):
         # Verify it's still a symlink
         assert os.path.islink(result)
 
+    def test_list_with_invalid_directory(self, tmp_path):
+        """Test that a list with one invalid directory raises error."""
+        dir1 = tmp_path / "dir1"
+        dir1.mkdir()
+        nonexistent = tmp_path / "nonexistent"
+
+        with pytest.raises(argparse.ArgumentTypeError) as exc_info:
+            relink.validate_directory([str(dir1), str(nonexistent)])
+
+        assert "does not exist" in str(exc_info.value)
+
+    def test_list_with_file_instead_of_directory(self, tmp_path):
+        """Test that a list containing a file raises error."""
+        dir1 = tmp_path / "dir1"
+        dir1.mkdir()
+        file1 = tmp_path / "file.txt"
+        file1.write_text("content")
+
+        with pytest.raises(argparse.ArgumentTypeError) as exc_info:
+            relink.validate_directory([str(dir1), str(file1)])
+
+        assert "not a directory" in str(exc_info.value)
+
 
 class TestProcessArgs:
     """Test suite for process_args function."""

tests/relink/test_cmdline.py

@@ -96,3 +96,55 @@ def test_command_line_execution_actual_run(mock_dirs):
 
     # Verify success messages in output
     assert "Created symbolic link:" in result.stdout
+
+
+def test_command_line_multiple_source_dirs(tmp_path):
+    """Test executing relink.py with multiple source directories."""
+    # Create multiple source directories
+    source1 = tmp_path / "source1"
+    source2 = tmp_path / "source2"
+    target_dir = tmp_path / "target"
+    source1.mkdir()
+    source2.mkdir()
+    target_dir.mkdir()
+
+    # Create files in each source directory
+    source1_file = source1 / "file1.txt"
+    source2_file = source2 / "file2.txt"
+    target1_file = target_dir / "file1.txt"
+    target2_file = target_dir / "file2.txt"
+
+    source1_file.write_text("source1 content")
+    source2_file.write_text("source2 content")
+    target1_file.write_text("target1 content")
+    target2_file.write_text("target2 content")
+
+    # Get the path to relink.py
+    relink_script = os.path.join(
+        os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
+        "relink.py",
+    )
+
+    # Build the command with multiple source directories
+    command = [
+        sys.executable,
+        relink_script,
+        str(source1),
+        str(source2),
+        "--target-root",
+        str(target_dir),
+        "--inputdata-root",
+        str(tmp_path),
+    ]
+
+    # Execute the command
+    result = subprocess.run(command, capture_output=True, text=True, check=False)
+
+    # Verify the command executed successfully
+    assert result.returncode == 0, f"Command failed with stderr: {result.stderr}"
+
+    # Verify both files were converted to symlinks
+    assert source1_file.is_symlink()
+    assert source2_file.is_symlink()
+    assert os.readlink(str(source1_file)) == str(target1_file)
+    assert os.readlink(str(source2_file)) == str(target2_file)