test_pathbridge.py

#!/usr/bin/env python3
"""
Comprehensive test suite for PathBridge.

Tests cover:
- Path format detection
- Windows to WSL conversion
- WSL to Windows conversion
- Auto-detection and conversion
- Batch processing
- Edge cases and error handling
- Path info functionality

Run: python test_pathbridge.py
"""

import unittest
import sys
from pathlib import Path

# Add parent directory to path for imports
sys.path.insert(0, str(Path(__file__).parent))

from pathbridge import PathBridge, normalize_target


class TestPathFormatDetection(unittest.TestCase):
    """Test path format detection."""
    
    def setUp(self):
        """Set up test fixtures."""
        self.pb = PathBridge()
    
    def test_detect_windows_backslash(self):
        """Test detection of Windows paths with backslashes."""
        self.assertEqual(self.pb.detect_format("C:\\Users\\logan"), "windows")
        self.assertEqual(self.pb.detect_format("D:\\BEACON_HQ\\file.txt"), "windows")
    
    def test_detect_windows_forward_slash(self):
        """Test detection of Windows paths with forward slashes."""
        self.assertEqual(self.pb.detect_format("C:/Users/logan"), "windows")
        self.assertEqual(self.pb.detect_format("D:/BEACON_HQ/file.txt"), "windows")
    
    def test_detect_windows_lowercase_drive(self):
        """Test detection of Windows paths with lowercase drive letters."""
        self.assertEqual(self.pb.detect_format("c:\\Users\\logan"), "windows")
        self.assertEqual(self.pb.detect_format("d:/BEACON_HQ"), "windows")
    
    def test_detect_wsl_paths(self):
        """Test detection of WSL mount paths."""
        self.assertEqual(self.pb.detect_format("/mnt/c/Users/logan"), "wsl")
        self.assertEqual(self.pb.detect_format("/mnt/d/BEACON_HQ/file.txt"), "wsl")
    
    def test_detect_unix_paths(self):
        """Test detection of pure Unix paths."""
        self.assertEqual(self.pb.detect_format("/home/user/file.txt"), "unix")
        self.assertEqual(self.pb.detect_format("/opt/software/bin"), "unix")
        self.assertEqual(self.pb.detect_format("/etc/config"), "unix")
    
    def test_detect_empty_or_none(self):
        """Test detection of empty or None paths."""
        self.assertEqual(self.pb.detect_format(""), "unknown")
        self.assertEqual(self.pb.detect_format(None), "unknown")
    
    def test_detect_relative_paths(self):
        """Test detection of relative paths."""
        # Relative paths with backslashes are assumed Windows
        self.assertEqual(self.pb.detect_format("folder\\file.txt"), "windows")
        # Relative paths with forward slashes are assumed Unix
        self.assertEqual(self.pb.detect_format("folder/file.txt"), "unix")
    
    def test_detect_unc_paths(self):
        """Test detection of UNC network paths."""
        self.assertEqual(self.pb.detect_format("\\\\server\\share"), "windows")
        self.assertEqual(self.pb.detect_format("\\\\192.168.1.1\\folder"), "windows")


class TestWindowsToWSLConversion(unittest.TestCase):
    """Test Windows to WSL path conversion."""
    
    def setUp(self):
        """Set up test fixtures."""
        self.pb = PathBridge()
    
    def test_convert_simple_path(self):
        """Test conversion of simple Windows path."""
        result = self.pb.windows_to_wsl("D:\\BEACON_HQ\\file.txt")
        self.assertEqual(result, "/mnt/d/BEACON_HQ/file.txt")
    
    def test_convert_root_drive(self):
        """Test conversion of drive root."""
        result = self.pb.windows_to_wsl("C:\\")
        # Root drive converts to mount point (trailing slash stripped from rest)
        self.assertEqual(result, "/mnt/c")
    
    def test_convert_drive_only(self):
        """Test conversion of drive letter only."""
        result = self.pb.windows_to_wsl("D:")
        self.assertEqual(result, "/mnt/d")
    
    def test_convert_forward_slashes(self):
        """Test conversion of Windows path with forward slashes."""
        result = self.pb.windows_to_wsl("D:/BEACON_HQ/file.txt")
        self.assertEqual(result, "/mnt/d/BEACON_HQ/file.txt")
    
    def test_convert_deep_path(self):
        """Test conversion of deeply nested path."""
        result = self.pb.windows_to_wsl("C:\\Users\\logan\\OneDrive\\Documents\\AutoProjects\\PathBridge")
        self.assertEqual(result, "/mnt/c/Users/logan/OneDrive/Documents/AutoProjects/PathBridge")
    
    def test_convert_path_with_spaces(self):
        """Test conversion of path with spaces."""
        result = self.pb.windows_to_wsl("D:\\My Documents\\My File.txt")
        self.assertEqual(result, "/mnt/d/My Documents/My File.txt")
    
    def test_convert_lowercase_drive(self):
        """Test conversion preserves lowercase to lowercase mount."""
        result = self.pb.windows_to_wsl("d:\\folder")
        self.assertEqual(result, "/mnt/d/folder")
    
    def test_convert_empty_path(self):
        """Test conversion of empty path."""
        result = self.pb.windows_to_wsl("")
        self.assertEqual(result, "")


class TestWSLToWindowsConversion(unittest.TestCase):
    """Test WSL to Windows path conversion."""
    
    def setUp(self):
        """Set up test fixtures."""
        self.pb = PathBridge()
    
    def test_convert_simple_path(self):
        """Test conversion of simple WSL path."""
        result = self.pb.wsl_to_windows("/mnt/d/BEACON_HQ/file.txt")
        self.assertEqual(result, "D:\\BEACON_HQ\\file.txt")
    
    def test_convert_root_mount(self):
        """Test conversion of mount root."""
        result = self.pb.wsl_to_windows("/mnt/c/")
        self.assertEqual(result, "C:\\")
    
    def test_convert_mount_only(self):
        """Test conversion of mount point only."""
        result = self.pb.wsl_to_windows("/mnt/d")
        self.assertEqual(result, "D:")
    
    def test_convert_deep_path(self):
        """Test conversion of deeply nested path."""
        result = self.pb.wsl_to_windows("/mnt/c/Users/logan/OneDrive/Documents/AutoProjects")
        self.assertEqual(result, "C:\\Users\\logan\\OneDrive\\Documents\\AutoProjects")
    
    def test_convert_path_with_spaces(self):
        """Test conversion of path with spaces."""
        result = self.pb.wsl_to_windows("/mnt/d/My Documents/My File.txt")
        self.assertEqual(result, "D:\\My Documents\\My File.txt")
    
    def test_convert_non_mount_path(self):
        """Test conversion of non-mount Unix path."""
        result = self.pb.wsl_to_windows("/home/user/file.txt")
        # Non-mount paths just get slashes converted
        self.assertEqual(result, "\\home\\user\\file.txt")
    
    def test_convert_empty_path(self):
        """Test conversion of empty path."""
        result = self.pb.wsl_to_windows("")
        self.assertEqual(result, "")


class TestAutoConversion(unittest.TestCase):
    """Test automatic path conversion (no target specified)."""
    
    def setUp(self):
        """Set up test fixtures."""
        self.pb = PathBridge()
    
    def test_auto_convert_windows_to_wsl(self):
        """Test auto-conversion from Windows to WSL."""
        result = self.pb.convert("D:\\BEACON_HQ\\file.txt")
        self.assertEqual(result, "/mnt/d/BEACON_HQ/file.txt")
    
    def test_auto_convert_wsl_to_windows(self):
        """Test auto-conversion from WSL to Windows."""
        result = self.pb.convert("/mnt/d/BEACON_HQ/file.txt")
        self.assertEqual(result, "D:\\BEACON_HQ\\file.txt")
    
    def test_auto_convert_unix_unchanged(self):
        """Test Unix paths stay unchanged in auto mode."""
        result = self.pb.convert("/home/user/file.txt")
        self.assertEqual(result, "/home/user/file.txt")


class TestTargetedConversion(unittest.TestCase):
    """Test conversion with explicit target format."""
    
    def setUp(self):
        """Set up test fixtures."""
        self.pb = PathBridge()
    
    def test_force_wsl_from_windows(self):
        """Test forcing WSL output from Windows path."""
        result = self.pb.convert("D:\\BEACON_HQ", target="wsl")
        self.assertEqual(result, "/mnt/d/BEACON_HQ")
    
    def test_force_windows_from_wsl(self):
        """Test forcing Windows output from WSL path."""
        result = self.pb.convert("/mnt/d/BEACON_HQ", target="windows")
        self.assertEqual(result, "D:\\BEACON_HQ")
    
    def test_force_windows_from_windows(self):
        """Test forcing Windows output from Windows path (no change)."""
        result = self.pb.convert("D:\\BEACON_HQ", target="windows")
        self.assertEqual(result, "D:\\BEACON_HQ")
    
    def test_force_wsl_from_wsl(self):
        """Test forcing WSL output from WSL path (no change)."""
        result = self.pb.convert("/mnt/d/BEACON_HQ", target="wsl")
        self.assertEqual(result, "/mnt/d/BEACON_HQ")


class TestBatchConversion(unittest.TestCase):
    """Test batch path conversion."""
    
    def setUp(self):
        """Set up test fixtures."""
        self.pb = PathBridge()
    
    def test_batch_convert_windows_paths(self):
        """Test batch conversion of Windows paths."""
        paths = ["D:\\folder1", "D:\\folder2", "C:\\Users"]
        results = self.pb.convert_batch(paths)
        expected = ["/mnt/d/folder1", "/mnt/d/folder2", "/mnt/c/Users"]
        self.assertEqual(results, expected)
    
    def test_batch_convert_wsl_paths(self):
        """Test batch conversion of WSL paths."""
        paths = ["/mnt/d/folder1", "/mnt/c/Users"]
        results = self.pb.convert_batch(paths)
        expected = ["D:\\folder1", "C:\\Users"]
        self.assertEqual(results, expected)
    
    def test_batch_convert_mixed_paths(self):
        """Test batch conversion of mixed path formats."""
        paths = ["D:\\folder", "/mnt/c/Users"]
        results = self.pb.convert_batch(paths)
        # Each path converts to its opposite
        expected = ["/mnt/d/folder", "C:\\Users"]
        self.assertEqual(results, expected)
    
    def test_batch_convert_empty_list(self):
        """Test batch conversion of empty list."""
        results = self.pb.convert_batch([])
        self.assertEqual(results, [])
    
    def test_batch_skips_empty_strings(self):
        """Test batch conversion skips empty strings."""
        paths = ["D:\\folder", "", "C:\\Users"]
        results = self.pb.convert_batch(paths)
        expected = ["/mnt/d/folder", "/mnt/c/Users"]
        self.assertEqual(results, expected)


class TestPathInfo(unittest.TestCase):
    """Test path information retrieval."""
    
    def setUp(self):
        """Set up test fixtures."""
        self.pb = PathBridge()
    
    def test_info_windows_path(self):
        """Test info for Windows path."""
        info = self.pb.get_info("D:\\BEACON_HQ\\file.txt")
        self.assertEqual(info['format'], 'windows')
        self.assertEqual(info['original'], 'D:\\BEACON_HQ\\file.txt')
        self.assertEqual(info['windows'], 'D:\\BEACON_HQ\\file.txt')
        self.assertEqual(info['wsl'], '/mnt/d/BEACON_HQ/file.txt')
    
    def test_info_wsl_path(self):
        """Test info for WSL path."""
        info = self.pb.get_info("/mnt/d/BEACON_HQ/file.txt")
        self.assertEqual(info['format'], 'wsl')
        self.assertEqual(info['original'], '/mnt/d/BEACON_HQ/file.txt')
        self.assertEqual(info['wsl'], '/mnt/d/BEACON_HQ/file.txt')
        self.assertEqual(info['windows'], 'D:\\BEACON_HQ\\file.txt')
    
    def test_info_unix_path(self):
        """Test info for Unix path."""
        info = self.pb.get_info("/home/user/file.txt")
        self.assertEqual(info['format'], 'unix')
        self.assertEqual(info['unix'], '/home/user/file.txt')
        self.assertEqual(info['wsl'], '/home/user/file.txt')


class TestEdgeCases(unittest.TestCase):
    """Test edge cases and special scenarios."""
    
    def setUp(self):
        """Set up test fixtures."""
        self.pb = PathBridge()
    
    def test_path_with_trailing_slash(self):
        """Test paths with trailing slashes."""
        result = self.pb.convert("D:\\BEACON_HQ\\")
        self.assertEqual(result, "/mnt/d/BEACON_HQ/")
    
    def test_path_with_double_slashes(self):
        """Test paths with double slashes."""
        result = self.pb.convert("D:\\\\folder")
        # Double backslash becomes single slash (normalized)
        self.assertEqual(result, "/mnt/d/folder")
    
    def test_path_with_special_characters(self):
        """Test paths with special characters."""
        result = self.pb.convert("D:\\folder-name_123")
        self.assertEqual(result, "/mnt/d/folder-name_123")
    
    def test_path_with_dots(self):
        """Test paths with dots (relative references)."""
        result = self.pb.convert("D:\\folder\\..\\other")
        self.assertEqual(result, "/mnt/d/folder/../other")
    
    def test_all_drive_letters(self):
        """Test various drive letters."""
        for letter in "ABCDEFGHIJKLMNOPQRSTUVWXYZ":
            result = self.pb.convert(f"{letter}:\\folder")
            expected = f"/mnt/{letter.lower()}/folder"
            self.assertEqual(result, expected)
    
    def test_whitespace_handling(self):
        """Test handling of whitespace around paths."""
        result = self.pb.convert("  D:\\folder  ")
        self.assertEqual(result, "/mnt/d/folder")


class TestErrorHandling(unittest.TestCase):
    """Test error handling."""
    
    def setUp(self):
        """Set up test fixtures."""
        self.pb = PathBridge()
    
    def test_convert_empty_raises(self):
        """Test that converting empty path raises ValueError."""
        with self.assertRaises(ValueError):
            self.pb.convert("")
    
    def test_convert_none_raises(self):
        """Test that converting None raises ValueError."""
        with self.assertRaises(ValueError):
            self.pb.convert(None)


class TestCustomMappings(unittest.TestCase):
    """Test custom drive mappings."""
    
    def test_custom_mapping_windows_to_wsl(self):
        """Test custom mapping for Windows to WSL."""
        custom = {"X": "/custom/mount"}
        pb = PathBridge(custom_mappings=custom)
        result = pb.windows_to_wsl("X:\\folder\\file.txt")
        self.assertEqual(result, "/custom/mount/folder/file.txt")
    
    def test_custom_mapping_wsl_to_windows(self):
        """Test custom mapping for WSL to Windows."""
        custom = {"X": "/custom/mount"}
        pb = PathBridge(custom_mappings=custom)
        result = pb.wsl_to_windows("/custom/mount/folder/file.txt")
        self.assertEqual(result, "X:\\folder\\file.txt")


class TestNormalizeTarget(unittest.TestCase):
    """Test target format normalization."""
    
    def test_normalize_windows(self):
        """Test normalizing 'windows' and 'win'."""
        self.assertEqual(normalize_target("windows"), "windows")
        self.assertEqual(normalize_target("win"), "windows")
        self.assertEqual(normalize_target("WINDOWS"), "windows")
        self.assertEqual(normalize_target("WIN"), "windows")
    
    def test_normalize_wsl(self):
        """Test normalizing 'wsl'."""
        self.assertEqual(normalize_target("wsl"), "wsl")
        self.assertEqual(normalize_target("WSL"), "wsl")
    
    def test_normalize_unix(self):
        """Test normalizing 'unix'."""
        self.assertEqual(normalize_target("unix"), "unix")
        self.assertEqual(normalize_target("UNIX"), "unix")
    
    def test_normalize_none(self):
        """Test normalizing None."""
        self.assertEqual(normalize_target(None), None)
    
    def test_normalize_invalid(self):
        """Test normalizing invalid target."""
        self.assertEqual(normalize_target("invalid"), None)


def run_tests():
    """Run all tests with nice output."""
    print("=" * 70)
    print("TESTING: PathBridge v1.0")
    print("Universal Path Translator")
    print("=" * 70)
    
    # Create test suite
    loader = unittest.TestLoader()
    suite = unittest.TestSuite()
    
    # Add all test classes
    suite.addTests(loader.loadTestsFromTestCase(TestPathFormatDetection))
    suite.addTests(loader.loadTestsFromTestCase(TestWindowsToWSLConversion))
    suite.addTests(loader.loadTestsFromTestCase(TestWSLToWindowsConversion))
    suite.addTests(loader.loadTestsFromTestCase(TestAutoConversion))
    suite.addTests(loader.loadTestsFromTestCase(TestTargetedConversion))
    suite.addTests(loader.loadTestsFromTestCase(TestBatchConversion))
    suite.addTests(loader.loadTestsFromTestCase(TestPathInfo))
    suite.addTests(loader.loadTestsFromTestCase(TestEdgeCases))
    suite.addTests(loader.loadTestsFromTestCase(TestErrorHandling))
    suite.addTests(loader.loadTestsFromTestCase(TestCustomMappings))
    suite.addTests(loader.loadTestsFromTestCase(TestNormalizeTarget))
    
    # Run tests
    runner = unittest.TextTestRunner(verbosity=2)
    result = runner.run(suite)
    
    # Summary
    print("\n" + "=" * 70)
    print(f"RESULTS: {result.testsRun} tests")
    passed = result.testsRun - len(result.failures) - len(result.errors)
    print(f"[OK] Passed: {passed}")
    if result.failures:
        print(f"[X] Failed: {len(result.failures)}")
    if result.errors:
        print(f"[X] Errors: {len(result.errors)}")
    print(f"Pass Rate: {passed / result.testsRun * 100:.1f}%")
    print("=" * 70)
    
    return 0 if result.wasSuccessful() else 1


if __name__ == "__main__":
    sys.exit(run_tests())