skylos 1.0.11__py3-none-any.whl → 1.1.11__py3-none-any.whl

test/test_cli.py

@@ -0,0 +1,353 @@
+#!/usr/bin/env python3
+import pytest
+import json
+import sys
+import logging
+from unittest.mock import Mock, patch, mock_open
+
+from skylos.cli import Colors, CleanFormatter, setup_logger, remove_unused_import, remove_unused_function, interactive_selection, print_badge, main
+
+class TestColors:
+    def test_colors_defined(self):
+        """Test that all color constants are defined."""
+        assert hasattr(Colors, 'RED')
+        assert hasattr(Colors, 'GREEN')
+        assert hasattr(Colors, 'RESET')
+        assert hasattr(Colors, 'BOLD')
+        
+        assert Colors.RED.startswith('\033[')
+        assert Colors.RESET == '\033[0m'
+
+class TestCleanFormatter:
+    def test_clean_formatter_removes_metadata(self):
+        """Test that CleanFormatter only returns the message."""
+        formatter = CleanFormatter()
+        
+        record = Mock()
+        record.getMessage.return_value = "Test message"
+        
+        result = formatter.format(record)
+        assert result == "Test message"
+        
+        record.getMessage.assert_called_once()
+
+
+class TestSetupLogger:
+    
+    @patch('skylos.cli.logging.FileHandler')
+    @patch('skylos.cli.logging.StreamHandler')
+    def test_setup_logger_console_only(self, mock_stream_handler, mock_file_handler):
+        """Test logger setup without output file."""
+        mock_handler = Mock()
+        mock_stream_handler.return_value = mock_handler
+        
+        logger = setup_logger()
+        
+        assert logger.name == 'skylos'
+        assert logger.level == logging.INFO
+        assert not logger.propagate
+        
+        mock_stream_handler.assert_called_once_with(sys.stdout)
+        mock_file_handler.assert_not_called()
+    
+    @patch('skylos.cli.logging.FileHandler')
+    @patch('skylos.cli.logging.StreamHandler')
+    def test_setup_logger_with_output_file(self, mock_stream_handler, mock_file_handler):
+        """Test logger setup with output file."""
+        mock_stream_handler.return_value = Mock()
+        mock_file_handler.return_value = Mock()
+        
+        logger = setup_logger("output.log")
+        
+        mock_stream_handler.assert_called_once_with(sys.stdout)
+        mock_file_handler.assert_called_once_with("output.log")
+
+
+class TestRemoveUnusedImport:
+    """Test unused import removal functionality."""
+    
+    def test_remove_simple_import(self):
+        """Test removing a simple import statement."""
+        content = """import os
+import sys
+import json
+
+def main():
+    print(sys.version)
+"""
+        
+        with patch('builtins.open', mock_open(read_data=content)) as mock_file:
+            result = remove_unused_import("test.py", "os", 1)
+            
+            assert result is True
+            handle = mock_file()
+            written_content = ''.join(call.args[0] for call in handle.write.call_args_list)
+            assert "import os" not in written_content
+    
+    def test_remove_from_multi_import(self):
+        content = "import os, sys, json\n"
+        
+        with patch('builtins.open', mock_open(read_data=content)) as mock_file:
+            result = remove_unused_import("test.py", "os", 1)
+            
+            assert result is True
+    
+    def test_remove_from_import_statement(self):
+        content = "from collections import defaultdict, Counter\n"
+        
+        with patch('builtins.open', mock_open(read_data=content)) as mock_file:
+            result = remove_unused_import("test.py", "Counter", 1)
+            
+            assert result is True
+            handle = mock_file()
+            written_lines = handle.writelines.call_args[0][0]
+            written_content = ''.join(written_lines)
+            assert "defaultdict" in written_content
+            assert "Counter" not in written_content
+
+    def test_remove_entire_from_import(self):
+        content = "from collections import defaultdict\n"
+        
+        with patch('builtins.open', mock_open(read_data=content)) as mock_file:
+            result = remove_unused_import("test.py", "defaultdict", 1)
+            
+            assert result is True
+            handle = mock_file()
+            written_content = ''.join(call.args[0] for call in handle.write.call_args_list)
+            # line should be empty
+            assert written_content.strip() == ""
+    
+    def test_remove_import_file_error(self):
+        """handling file errors when removing imports."""
+        with patch('builtins.open', side_effect=FileNotFoundError("File not found")):
+            result = remove_unused_import("nonexistent.py", "os", 1)
+            assert result is False
+
+class TestRemoveUnusedFunction:
+    def test_remove_simple_function(self):
+        """test remove a simple function."""
+        content = """def used_function():
+    return "used"
+
+def unused_function():
+    return "unused"
+
+def another_function():
+    return "another"
+"""
+        
+        with patch('skylos.cli.ast.parse') as mock_parse, \
+             patch('builtins.open', mock_open(read_data=content)) as mock_file:
+            
+            mock_func_node = Mock()
+            mock_func_node.name = "unused_function"
+            mock_func_node.lineno = 4
+            mock_func_node.end_lineno = 5
+            mock_func_node.decorator_list = []
+            
+            with patch('skylos.cli.ast.walk', return_value=[mock_func_node]):
+                with patch('skylos.cli.ast.FunctionDef', mock_func_node.__class__):
+                    result = remove_unused_function("test.py", "unused_function", 4)
+            
+            assert result is True
+    
+    def test_remove_function_with_decorators(self):
+        """removing function with decorators."""
+        content = """@property
+@decorator
+def unused_function():
+    return "unused"
+"""
+        
+        with patch('skylos.cli.ast.parse') as mock_parse, \
+             patch('builtins.open', mock_open(read_data=content)) as mock_file:
+            
+            mock_decorator = Mock()
+            mock_decorator.lineno = 1
+            
+            mock_func_node = Mock()
+            mock_func_node.name = "unused_function"
+            mock_func_node.lineno = 3
+            mock_func_node.end_lineno = 4
+            mock_func_node.decorator_list = [mock_decorator]
+            
+            with patch('skylos.cli.ast.walk', return_value=[mock_func_node]):
+                with patch('skylos.cli.ast.FunctionDef', mock_func_node.__class__):
+                    result = remove_unused_function("test.py", "unused_function", 3)
+            
+            assert result is True
+    
+    def test_remove_function_file_error(self):
+        with patch('builtins.open', side_effect=FileNotFoundError("File not found")):
+            result = remove_unused_function("nonexistent.py", "func", 1)
+            assert result is False
+    
+    def test_remove_function_parse_error(self):
+        with patch('builtins.open', mock_open(read_data="invalid python code")), \
+             patch('skylos.cli.ast.parse', side_effect=SyntaxError("Invalid syntax")):
+            result = remove_unused_function("test.py", "func", 1)
+            assert result is False
+
+class TestInteractiveSelection:
+    @pytest.fixture
+    def mock_logger(self):
+        return Mock()
+    
+    @pytest.fixture
+    def sample_unused_items(self):
+        """create fake sample unused items for testing"""
+        functions = [
+            {"name": "unused_func1", "file": "test1.py", "line": 10},
+            {"name": "unused_func2", "file": "test2.py", "line": 20}
+        ]
+        imports = [
+            {"name": "unused_import1", "file": "test1.py", "line": 1},
+            {"name": "unused_import2", "file": "test2.py", "line": 2}
+        ]
+        return functions, imports
+    
+    def test_interactive_selection_unavailable(self, mock_logger, sample_unused_items):
+        """interactive selection when inquirer is not available."""
+        functions, imports = sample_unused_items
+        
+        with patch('skylos.cli.INTERACTIVE_AVAILABLE', False):
+            selected_functions, selected_imports = interactive_selection(
+                mock_logger, functions, imports
+            )
+        
+        assert selected_functions == []
+        assert selected_imports == []
+        mock_logger.error.assert_called_once()
+    
+    @patch('skylos.cli.inquirer')
+    def test_interactive_selection_with_selections(self, mock_inquirer, mock_logger, sample_unused_items):
+        functions, imports = sample_unused_items
+        
+        mock_inquirer.prompt.side_effect = [
+            {'functions': [functions[0]]},
+            {'imports': [imports[1]]}
+        ]
+        
+        with patch('skylos.cli.INTERACTIVE_AVAILABLE', True):
+            selected_functions, selected_imports = interactive_selection(
+                mock_logger, functions, imports
+            )
+        
+        assert selected_functions == [functions[0]]
+        assert selected_imports == [imports[1]]
+        assert mock_inquirer.prompt.call_count == 2
+    
+    @patch('skylos.cli.inquirer')
+    def test_interactive_selection_no_selections(self, mock_inquirer, mock_logger, sample_unused_items):
+        functions, imports = sample_unused_items
+        
+        mock_inquirer.prompt.return_value = None
+        
+        with patch('skylos.cli.INTERACTIVE_AVAILABLE', True):
+            selected_functions, selected_imports = interactive_selection(
+                mock_logger, functions, imports
+            )
+        
+        assert selected_functions == []
+        assert selected_imports == []
+    
+    def test_interactive_selection_empty_lists(self, mock_logger):
+        selected_functions, selected_imports = interactive_selection(
+            mock_logger, [], []
+        )
+        
+        assert selected_functions == []
+        assert selected_imports == []
+
+
+class TestPrintBadge:    
+    @pytest.fixture
+    def mock_logger(self):
+        return Mock()
+    
+    def test_print_badge_zero_dead_code(self, mock_logger):
+        """Test badge printing with zero dead code."""
+        print_badge(0, mock_logger)
+        
+        calls = [call.args[0] for call in mock_logger.info.call_args_list]
+        badge_call = next((call for call in calls if "Dead_Code-Free" in call), None)
+        assert badge_call is not None
+        assert "brightgreen" in badge_call
+    
+    def test_print_badge_with_dead_code(self, mock_logger):
+        print_badge(5, mock_logger)
+        
+        calls = [call.args[0] for call in mock_logger.info.call_args_list]
+        badge_call = next((call for call in calls if "Dead_Code-5" in call), None)
+        assert badge_call is not None
+        assert "orange" in badge_call
+
+class TestMainFunction:
+    @pytest.fixture
+    def mock_skylos_result(self):
+        return {
+            "unused_functions": [
+                {"name": "unused_func", "file": "test.py", "line": 10}
+            ],
+            "unused_imports": [
+                {"name": "unused_import", "file": "test.py", "line": 1}
+            ],
+            "unused_parameters": [],
+            "unused_variables": [],
+            "analysis_summary": {
+                "total_files": 2,
+                "excluded_folders": []
+            }
+        }
+    
+    def test_main_json_output(self, mock_skylos_result):
+        """testing main function with JSON output"""
+        test_args = ["cli.py", "test_path", "--json"]
+        
+        with patch('sys.argv', test_args), \
+             patch('skylos.cli.skylos.analyze') as mock_analyze, \
+             patch('skylos.cli.setup_logger') as mock_setup_logger:
+            
+            mock_logger = Mock()
+            mock_setup_logger.return_value = mock_logger
+            mock_analyze.return_value = json.dumps(mock_skylos_result)
+            
+            main()
+            
+            mock_analyze.assert_called_once()
+            mock_logger.info.assert_called_with(json.dumps(mock_skylos_result))
+    
+    def test_main_verbose_output(self, mock_skylos_result):
+        """ with verbose"""
+        test_args = ["cli.py", "test_path", "--verbose"]
+        
+        with patch('sys.argv', test_args), \
+             patch('skylos.cli.skylos.analyze') as mock_analyze, \
+             patch('skylos.cli.setup_logger') as mock_setup_logger:
+            
+            mock_logger = Mock()
+            mock_setup_logger.return_value = mock_logger
+            mock_analyze.return_value = json.dumps(mock_skylos_result)
+            
+            main()
+            
+            mock_logger.setLevel.assert_called_with(logging.DEBUG)
+    
+    def test_main_analysis_error(self):
+        test_args = ["cli.py", "test_path"]
+        
+        with patch('sys.argv', test_args), \
+            patch('skylos.cli.skylos.analyze', side_effect=Exception("Analysis failed")), \
+            patch('skylos.cli.setup_logger') as mock_setup_logger, \
+            patch('skylos.cli.parse_exclude_folders', return_value=set()):
+            
+            mock_logger = Mock()
+            mock_setup_logger.return_value = mock_logger
+            
+            with pytest.raises(SystemExit):
+                main()
+            
+            mock_logger.error.assert_called_with("Error during analysis: Analysis failed")
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

test/test_integration.py

@@ -0,0 +1,320 @@
+import pytest
+import json
+import tempfile
+import os
+from pathlib import Path
+from textwrap import dedent
+
+import skylos
+from skylos.analyzer import Skylos
+from skylos.analyzer import DEFAULT_EXCLUDE_FOLDERS
+
+class TestSkylosIntegration:
+
+    @pytest.fixture
+    def temp_project(self):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            project_path = Path(temp_dir)
+            
+            main_py = project_path / "main.py"
+            main_py.write_text(dedent("""
+                import os  # unused import
+                import sys
+                from typing import List  # unused import
+                from collections import defaultdict
+                from utils import UsedClass, exported_function
+                
+                def used_function(x):
+                    '''This function is called and should not be flagged'''
+                    return x * 2
+                
+                def unused_function(a, b):
+                    '''This function is never called'''
+                    unused_var = a + b  # unused variable
+                    return unused_var
+                
+                def main():
+                    result = used_function(5)
+                    print(result, file=sys.stderr)
+                    data = defaultdict(list)
+                    
+                    obj = UsedClass()
+                    obj.get_value()
+                    exported_function()
+                    
+                    return data
+                
+                if __name__ == "__main__":
+                    main()
+            """))
+            
+            utils_py = project_path / "utils.py"
+            utils_py.write_text(dedent("""
+                import json  # unused import
+                
+                class UsedClass:
+                    '''This class is imported and used'''
+                    def __init__(self):
+                        self.value = 42
+                    
+                    def get_value(self):
+                        return self.value
+                
+                class UnusedClass:
+                    '''This class is never used'''
+                    def __init__(self):
+                        self.data = {}
+                    
+                    def unused_method(self, param):  # unused parameter
+                        return "never called"
+                
+                def exported_function():
+                    '''This function is used by main.py'''
+                    return "exported"
+            """))
+            
+            package_dir = project_path / "mypackage"
+            package_dir.mkdir()
+            
+            init_py = package_dir / "__init__.py"
+            init_py.write_text(dedent("""
+                from .submodule import PublicClass
+                
+                __all__ = ['PublicClass', 'public_function']
+                
+                def public_function():
+                    return "public"
+                
+                def _private_function():
+                    return "private"
+            """))
+            
+            sub_py = package_dir / "submodule.py"
+            sub_py.write_text(dedent("""
+                class PublicClass:
+                    '''Exported via __init__.py'''
+                    def method(self):
+                        return "method"
+                
+                class InternalClass:
+                    '''Not exported, should be flagged'''
+                    pass
+            """))
+            
+            test_py = project_path / "test_example.py"
+            test_py.write_text(dedent("""
+                import unittest
+                from main import used_function
+                
+                class TestExample(unittest.TestCase):
+                    def test_used_function(self):
+                        result = used_function(3)
+                        self.assertEqual(result, 6)
+                    
+                    def test_unused_method(self):
+                        pass
+            """))
+            
+            yield project_path
+
+    def test_basic_analysis(self, temp_project):
+        """Test basic unused code detection"""
+        result_json = skylos.analyze(str(temp_project), exclude_folders=list(DEFAULT_EXCLUDE_FOLDERS))
+        result = json.loads(result_json)
+        
+        assert "unused_functions" in result
+        assert "unused_imports" in result
+        assert "unused_variables" in result
+        assert "unused_parameters" in result
+        assert "unused_classes" in result
+        
+        assert len(result["unused_functions"]) > 0
+        assert len(result["unused_imports"]) > 0
+        
+        unused_function_names = [f["name"] for f in result["unused_functions"]]
+        assert "unused_function" in unused_function_names
+        
+        assert "used_function" not in unused_function_names
+        assert "main" not in unused_function_names
+
+    def test_unused_imports_detection(self, temp_project):
+        """Test detection of unused imports"""
+        result_json = skylos.analyze(str(temp_project))
+        result = json.loads(result_json)
+        
+        unused_imports = result["unused_imports"]
+        import_names = [imp["name"] for imp in unused_imports]
+        
+        assert any("os" in name for name in import_names)
+        assert any("typing.List" in name or "List" in name for name in import_names)
+        
+        used_imports = ["sys", "defaultdict"]
+        for used_import in used_imports:
+            assert not any(used_import in name for name in import_names)
+
+    def test_class_detection(self, temp_project):
+        """test detection of unused classes"""
+        result_json = skylos.analyze(str(temp_project))
+        result = json.loads(result_json)
+        
+        unused_classes = result["unused_classes"]
+        class_names = [cls["name"] for cls in unused_classes]
+        
+        
+        assert any("UnusedClass" in name for name in class_names), f"UnusedClass not found in {class_names}"
+        
+        used_classes_flagged = [name for name in class_names if "UsedClass" in name]
+        assert len(used_classes_flagged) == 0, f"UsedClass was incorrectly flagged as unused: {used_classes_flagged}"
+        
+        # publicclass should not be flagged because it's exported via __init__.py
+        public_classes_flagged = [name for name in class_names if "PublicClass" in name]
+        assert len(public_classes_flagged) == 0, f"PublicClass was incorrectly flagged as unused: {public_classes_flagged}"
+
+    def test_exclude_folders(self, temp_project):
+        result1 = skylos.analyze(str(temp_project))
+        
+        # exclude the mypackage folder
+        result2 = skylos.analyze(str(temp_project), exclude_folders=["mypackage"])
+        
+        # it'll find fewer items when excluding a folder
+        data1 = json.loads(result1)
+        data2 = json.loads(result2)
+        
+        total1 = sum(len(items) for items in data1.values() if isinstance(items, list))
+        total2 = sum(len(items) for items in data2.values() if isinstance(items, list))
+        
+        assert total2 <= total1
+
+    def test_custom_exclude_folders(self, temp_project):
+        custom_dir = temp_project / "custom_exclude"
+        custom_dir.mkdir()
+        
+        custom_file = custom_dir / "custom.py"
+        custom_file.write_text(dedent("""
+            def custom_function():
+                return "should be excluded"
+        """))
+        
+        result_json = skylos.analyze(str(temp_project), exclude_folders=["custom_exclude"])
+        result = json.loads(result_json)
+        
+        all_files = []
+        for category in ["unused_functions", "unused_imports", "unused_classes", "unused_variables"]:
+            for item in result[category]:
+                all_files.append(item["file"])
+        
+        excluded_files = [f for f in all_files if "custom_exclude" in f]
+        assert len(excluded_files) == 0, f"Found excluded files: {excluded_files}"
+
+    def test_magic_methods_excluded(self, temp_project):
+        magic_py = temp_project / "magic.py"
+        magic_py.write_text(dedent("""
+            class MagicClass:
+                def __init__(self):
+                    self.value = 0
+                
+                def __str__(self):
+                    return str(self.value)
+                
+                def __len__(self):
+                    return self.value
+                
+                def regular_method(self):
+                    return "regular"
+        """))
+        
+        result_json = skylos.analyze(str(temp_project))
+        result = json.loads(result_json)
+        
+        unused_functions = result["unused_functions"]
+        function_names = [f["name"] for f in unused_functions]
+        
+        magic_methods = ["__init__", "__str__", "__len__"]
+        for magic_method in magic_methods:
+            assert not any(magic_method in name for name in function_names)
+
+    def test_test_methods_excluded(self, temp_project):
+        """Test that test methods are not flagged as unused"""
+        result_json = skylos.analyze(str(temp_project))
+        result = json.loads(result_json)
+        
+        unused_functions = result["unused_functions"]
+        function_names = [f["name"] for f in unused_functions]
+        
+        test_methods = ["test_used_function", "test_unused_method"]
+        for test_method in test_methods:
+            assert not any(test_method in name for name in function_names)
+
+    def test_exported_functions_excluded(self, temp_project):
+        result_json = skylos.analyze(str(temp_project))
+        result = json.loads(result_json)
+        
+        unused_functions = result["unused_functions"]
+        function_names = [f["name"] for f in unused_functions]
+        
+        assert not any("public_function" in name for name in function_names)
+
+    def test_single_file_analysis(self, temp_project):
+        main_file = temp_project / "main.py"
+        
+        result_json = skylos.analyze(str(main_file))
+        result = json.loads(result_json)
+        
+        # should still detect unused items in the single file
+        assert len(result["unused_functions"]) > 0
+        assert len(result["unused_imports"]) > 0
+        
+        all_files = set()
+        for category in ["unused_functions", "unused_imports", "unused_variables"]:
+            for item in result[category]:
+                all_files.add(Path(item["file"]).name)
+        
+        assert "main.py" in all_files
+        assert "utils.py" not in all_files
+
+    def test_confidence_levels(self, temp_project):
+        result_json = skylos.analyze(str(temp_project))
+        result = json.loads(result_json)
+        
+        for category in ["unused_functions", "unused_imports", "unused_variables"]:
+            for item in result[category]:
+                assert "confidence" in item
+                assert isinstance(item["confidence"], (int, float))
+                assert 0 <= item["confidence"] <= 100
+
+    def test_analyzer_class_direct(self, temp_project):
+        analyzer = Skylos()
+        result_json = analyzer.analyze(str(temp_project), thr=50)
+        result = json.loads(result_json)
+        
+        expected_keys = [
+            "unused_functions", "unused_imports", "unused_classes",
+            "unused_variables", "unused_parameters", "analysis_summary"
+        ]
+        
+        for key in expected_keys:
+            assert key in result
+
+    def test_empty_project(self):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            result_json = skylos.analyze(temp_dir)
+            result = json.loads(result_json)
+            
+            assert result["unused_functions"] == []
+            assert result["unused_imports"] == []
+            assert result["analysis_summary"]["total_files"] == 0
+
+    def test_threshold_filtering(self, temp_project):
+        """Test that confidence threshold filtering works"""
+        # high threshold = find fewer items
+        result_high = json.loads(skylos.analyze(str(temp_project), conf=95))
+        
+        # low threshold = should find more items
+        result_low = json.loads(skylos.analyze(str(temp_project), conf=10))
+        
+        assert len(result_high["unused_functions"]) <= len(result_low["unused_functions"])
+        assert len(result_high["unused_imports"]) <= len(result_low["unused_imports"])
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])