devcheck-python/test_checker.py at main · ayushman-ece/devcheck-python · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
"""Unit tests for the EnvironmentChecker class in checker.py."""

import sys
import unittest
from pathlib import Path
from unittest.mock import MagicMock, patch

sys.path.insert(0, str(Path(__file__).resolve().parent.parent))

from checker import EnvironmentChecker
from tool import ToolStatus


class TestEnvironmentChecker(unittest.TestCase):
    """Tests covering tool detection, version parsing, and error handling."""

    def setUp(self) -> None:
        self.definitions = [
            {"name": "FakeTool", "commands": ["faketool"], "version_args": ["--version"]},
        ]
        self.checker = EnvironmentChecker(self.definitions)

    @patch("checker.shutil.which", return_value=None)
    def test_tool_not_installed(self, mock_which) -> None:
        result = self.checker.check_tool(self.definitions[0])
        self.assertEqual(result.status, ToolStatus.NOT_INSTALLED)
        self.assertIsNone(result.version)
        self.assertIsNone(result.path)

    @patch("checker.subprocess.run")
    @patch("checker.shutil.which", return_value="/usr/bin/faketool")
    def test_tool_installed_with_version(self, mock_which, mock_run) -> None:
        mock_completed = MagicMock()
        mock_completed.stdout = "faketool version 1.2.3"
        mock_completed.stderr = ""
        mock_run.return_value = mock_completed

        result = self.checker.check_tool(self.definitions[0])
        self.assertEqual(result.status, ToolStatus.INSTALLED)
        self.assertEqual(result.version, "1.2.3")
        self.assertEqual(result.path, "/usr/bin/faketool")

    @patch("checker.subprocess.run")
    @patch("checker.shutil.which", return_value="/usr/bin/faketool")
    def test_tool_installed_but_version_unavailable(self, mock_which, mock_run) -> None:
        mock_completed = MagicMock()
        mock_completed.stdout = ""
        mock_completed.stderr = ""
        mock_run.return_value = mock_completed

        result = self.checker.check_tool(self.definitions[0])
        self.assertEqual(result.status, ToolStatus.VERSION_UNAVAILABLE)
        self.assertEqual(result.path, "/usr/bin/faketool")

    @patch("checker.subprocess.run", side_effect=PermissionError())
    @patch("checker.shutil.which", return_value="/usr/bin/faketool")
    def test_permission_error_is_handled_gracefully(self, mock_which, mock_run) -> None:
        result = self.checker.check_tool(self.definitions[0])
        self.assertEqual(result.status, ToolStatus.VERSION_UNAVAILABLE)
        self.assertIn("Permission denied", result.error)

    @patch("checker.subprocess.run")
    @patch("checker.shutil.which", return_value="/usr/bin/faketool")
    def test_timeout_is_handled_gracefully(self, mock_which, mock_run) -> None:
        import subprocess

        mock_run.side_effect = subprocess.TimeoutExpired(cmd="faketool", timeout=5)
        result = self.checker.check_tool(self.definitions[0])
        self.assertEqual(result.status, ToolStatus.VERSION_UNAVAILABLE)
        self.assertIn("timed out", result.error)

    def test_check_tool_by_name_unknown_returns_none(self) -> None:
        result = self.checker.check_tool_by_name("NotARealTool")
        self.assertIsNone(result)

    @patch("checker.shutil.which", return_value=None)
    def test_check_tool_by_name_is_case_insensitive(self, mock_which) -> None:
        result = self.checker.check_tool_by_name("faketool")
        self.assertIsNotNone(result)
        self.assertEqual(result.name, "FakeTool")

    @patch("checker.shutil.which", return_value=None)
    def test_scan_all_returns_one_result_per_tool(self, mock_which) -> None:
        results = self.checker.scan_all()
        self.assertEqual(len(results), 1)
        self.assertEqual(results[0].name, "FakeTool")

    def test_list_tool_names(self) -> None:
        self.assertEqual(self.checker.list_tool_names(), ["FakeTool"])


if __name__ == "__main__":
    unittest.main()