`b8f423f`

test files

Authored by

espadonne 8 months ago

SHA: b8f423f96eb4a678dac88189a6a19c7e6cef6a51
Parents: 5423f57
Tree: 525dfcb

5 changed files

Status	File	+	-
A	`tests/__init__.py`	1	0
A	`tests/__pycache__/test_args.cpython-39.pyc`	bin
A	`tests/__pycache__/test_selinux.cpython-39.pyc`	bin
A	`tests/test_args.py`	212	0
A	`tests/test_selinux.py`	177	0

tests/__init__.pyadded

`@@ -0,0 +1,1 @@`
	1	+"""Test suite for sultree."""

tests/__pycache__/test_args.cpython-39.pycadded

Binary file changed.

tests/__pycache__/test_selinux.cpython-39.pycadded

Binary file changed.

tests/test_args.pyadded

 +"""
 +Tests for command-line argument parsing.
 +"""
++
 +import unittest
 +from unittest.mock import patch
 +from pathlib import Path
 +import sys
 +import io
++
 +from sultree.args import (
 +    create_argument_parser,
 +    parse_arguments,
 +    validate_depth,
 +    validate_pattern,
 +    validate_selinux_pattern,
 +    validate_path
 +)
++
++
 +class TestArgumentValidation(unittest.TestCase):
 +    """Test argument validation functions."""
++
 +    def test_validate_depth(self):
 +        """Test depth validation."""
 +        self.assertEqual(validate_depth("5"), 5)
 +        self.assertEqual(validate_depth("0"), 0)
++
 +        with self.assertRaises(Exception):
 +            validate_depth("-1")  # Negative depth
++
 +        with self.assertRaises(Exception):
 +            validate_depth("not_a_number")
++
 +        with self.assertRaises(Exception):
 +            validate_depth("1001")  # Too large
++
 +    def test_validate_pattern(self):
 +        """Test pattern validation."""
 +        # Valid patterns
 +        self.assertEqual(validate_pattern("*.txt"), "*.txt")
 +        self.assertEqual(validate_pattern("test_*"), "test_*")
++
 +        # Invalid patterns
 +        with self.assertRaises(Exception):
 +            validate_pattern("")  # Empty pattern
++
 +        with self.assertRaises(Exception):
 +            validate_pattern("x" * 1001)  # Too long
++
 +    def test_validate_selinux_pattern(self):
 +        """Test SELinux pattern validation."""
 +        # Valid patterns
 +        self.assertEqual(validate_selinux_pattern("passwd_file_t"), "passwd_file_t")
 +        self.assertEqual(validate_selinux_pattern("system_u:object_r:*:s0"), "system_u:object_r:*:s0")
++
 +        # Invalid patterns with dangerous characters
 +        with self.assertRaises(Exception):
 +            validate_selinux_pattern("test; rm -rf /")
++
 +        with self.assertRaises(Exception):
 +            validate_selinux_pattern("test|malicious")
++
 +        with self.assertRaises(Exception):
 +            validate_selinux_pattern("test`command`")
++
 +    def test_validate_path(self):
 +        """Test path validation."""
 +        # Valid paths
 +        path = validate_path("/etc/passwd")
 +        self.assertEqual(str(path), "/etc/passwd")
++
 +        # Invalid paths
 +        with self.assertRaises(Exception):
 +            validate_path("")  # Empty path
++
 +        with self.assertRaises(Exception):
 +            validate_path("x" * 5000)  # Too long
++
 +        with self.assertRaises(Exception):
 +            validate_path("/path/with/\x00/null")  # Null bytes
++
++
 +class TestArgumentParser(unittest.TestCase):
 +    """Test argument parser functionality."""
++
 +    def setUp(self):
 +        """Set up test fixtures."""
 +        self.parser = create_argument_parser()
++
 +    def test_basic_parsing(self):
 +        """Test basic argument parsing."""
 +        args = self.parser.parse_args(['/etc'])
++
 +        self.assertEqual(len(args.directories), 1)
 +        self.assertEqual(str(args.directories[0]), '/etc')
 +        self.assertFalse(args.all)
 +        self.assertFalse(args.dirs_only)
++
 +    def test_flag_parsing(self):
 +        """Test various flags."""
 +        args = self.parser.parse_args(['-a', '-d', '-l', '/tmp'])
++
 +        self.assertTrue(args.all)
 +        self.assertTrue(args.dirs_only)
 +        self.assertTrue(args.follow_links)
++
 +    def test_pattern_parsing(self):
 +        """Test pattern argument parsing."""
 +        args = self.parser.parse_args(['-P', '*.txt', '-I', '*.bak', '/tmp'])
++
 +        self.assertIn('*.txt', args.include_patterns)
 +        self.assertIn('*.bak', args.exclude_patterns)
++
 +    def test_selinux_pattern_parsing(self):
 +        """Test SELinux pattern parsing."""
 +        args = self.parser.parse_args(['-S', 'passwd_file_t', '-S', '*_exec_t', '/etc'])
++
 +        self.assertEqual(len(args.selinux_patterns), 2)
 +        self.assertIn('passwd_file_t', args.selinux_patterns)
 +        self.assertIn('*_exec_t', args.selinux_patterns)
++
 +    def test_depth_parsing(self):
 +        """Test depth limit parsing."""
 +        args = self.parser.parse_args(['-L', '3', '/tmp'])
++
 +        self.assertEqual(args.level, 3)
++
 +    def test_multiple_directories(self):
 +        """Test multiple directory arguments."""
 +        args = self.parser.parse_args(['/etc', '/tmp', '/var'])
++
 +        self.assertEqual(len(args.directories), 3)
 +        self.assertIn(Path('/etc'), args.directories)
 +        self.assertIn(Path('/tmp'), args.directories)
 +        self.assertIn(Path('/var'), args.directories)
++
++
 +class TestParseArguments(unittest.TestCase):
 +    """Test the main parse_arguments function."""
++
 +    @patch('sultree.selinux.is_selinux_enabled')
 +    @patch('pathlib.Path.exists')
 +    @patch('pathlib.Path.is_dir')
 +    def test_successful_parsing(self, mock_is_dir, mock_exists, mock_selinux_enabled):
 +        """Test successful argument parsing."""
 +        # Mock path validation
 +        mock_exists.return_value = True
 +        mock_is_dir.return_value = True
 +        mock_selinux_enabled.return_value = True
++
 +        args, options = parse_arguments(['-a', '-L', '2', '/etc'])
++
 +        self.assertTrue(options.show_all)
 +        self.assertEqual(options.max_depth, 2)
 +        self.assertEqual(len(args.directories), 1)
++
 +    @patch('sultree.selinux.is_selinux_enabled')
 +    @patch('pathlib.Path.exists')
 +    @patch('pathlib.Path.is_dir')
 +    def test_selinux_filter_creation(self, mock_is_dir, mock_exists, mock_selinux_enabled):
 +        """Test SELinux filter creation."""
 +        mock_exists.return_value = True
 +        mock_is_dir.return_value = True
 +        mock_selinux_enabled.return_value = True
++
 +        args, options = parse_arguments(['-S', 'passwd_file_t', '/etc'])
++
 +        self.assertIsNotNone(options.selinux_filter)
++
 +    @patch('sultree.selinux.is_selinux_enabled')
 +    @patch('pathlib.Path.exists')
 +    def test_nonexistent_directory(self, mock_exists, mock_selinux_enabled):
 +        """Test handling of non-existent directories."""
 +        mock_exists.return_value = False
 +        mock_selinux_enabled.return_value = True
++
 +        # Capture stderr to check error message
 +        old_stderr = sys.stderr
 +        sys.stderr = captured_output = io.StringIO()
++
 +        try:
 +            with self.assertRaises(SystemExit):
 +                parse_arguments(['/non/existent/path'])
 +        finally:
 +            sys.stderr = old_stderr
++
 +        self.assertIn("does not exist", captured_output.getvalue())
++
 +    @patch('sultree.selinux.is_selinux_enabled')
 +    @patch('pathlib.Path.exists')
 +    @patch('pathlib.Path.is_dir')
 +    def test_selinux_unavailable(self, mock_is_dir, mock_exists, mock_selinux_enabled):
 +        """Test handling when SELinux is unavailable."""
 +        mock_exists.return_value = True
 +        mock_is_dir.return_value = True
 +        mock_selinux_enabled.return_value = False
++
 +        old_stderr = sys.stderr
 +        sys.stderr = captured_output = io.StringIO()
++
 +        try:
 +            with self.assertRaises(SystemExit):
 +                parse_arguments(['-S', 'passwd_file_t', '/etc'])
 +        finally:
 +            sys.stderr = old_stderr
++
 +        self.assertIn("SELinux", captured_output.getvalue())
++
++
 +if __name__ == '__main__':
 +    unittest.main()

tests/test_selinux.pyadded

 +"""
 +Tests for SELinux functionality.
 +"""
++
 +import unittest
 +from pathlib import Path
 +from unittest.mock import patch, MagicMock
 +import subprocess
++
 +from sultree.selinux import (
 +    SELinuxContext,
 +    SELinuxFilter,
 +    get_selinux_context,
 +    is_selinux_enabled,
 +    SELinuxQueryError
 +)
++
++
 +class TestSELinuxContext(unittest.TestCase):
 +    """Test SELinux context parsing."""
++
 +    def test_valid_context_parsing(self):
 +        """Test parsing valid SELinux contexts."""
 +        context = SELinuxContext("system_u:object_r:passwd_file_t:s0")
++
 +        self.assertEqual(context.user, "system_u")
 +        self.assertEqual(context.role, "object_r")
 +        self.assertEqual(context.type, "passwd_file_t")
 +        self.assertEqual(context.level, "s0")
 +        self.assertEqual(context.raw, "system_u:object_r:passwd_file_t:s0")
++
 +    def test_context_with_complex_level(self):
 +        """Test context with complex MLS level."""
 +        context = SELinuxContext("user_u:user_r:user_t:s0:c0.c1023")
++
 +        self.assertEqual(context.user, "user_u")
 +        self.assertEqual(context.role, "user_r")
 +        self.assertEqual(context.type, "user_t")
 +        self.assertEqual(context.level, "s0:c0.c1023")
++
 +    def test_invalid_context_format(self):
 +        """Test handling of invalid context formats."""
 +        with self.assertRaises(ValueError):
 +            SELinuxContext("invalid")
++
 +        with self.assertRaises(ValueError):
 +            SELinuxContext("user:role")  # Too few fields
++
 +    def test_pattern_matching_exact(self):
 +        """Test exact pattern matching."""
 +        context = SELinuxContext("system_u:object_r:passwd_file_t:s0")
++
 +        self.assertTrue(context.matches_pattern("passwd_file_t"))
 +        self.assertTrue(context.matches_pattern("system_u"))
 +        self.assertFalse(context.matches_pattern("shadow_t"))
++
 +    def test_pattern_matching_wildcard(self):
 +        """Test wildcard pattern matching."""
 +        context = SELinuxContext("system_u:object_r:httpd_exec_t:s0")
++
 +        self.assertTrue(context.matches_pattern("httpd_*"))
 +        self.assertTrue(context.matches_pattern("*_exec_t"))
 +        self.assertTrue(context.matches_pattern("*_u:*:*_t:*"))
 +        self.assertFalse(context.matches_pattern("ssh_*"))
++
++
 +class TestSELinuxFilter(unittest.TestCase):
 +    """Test SELinux filtering functionality."""
++
 +    def test_filter_initialization(self):
 +        """Test filter initialization with patterns."""
 +        patterns = ["passwd_file_t", "*_exec_t", "httpd_*"]
 +        selinux_filter = SELinuxFilter(patterns)
++
 +        self.assertEqual(len(selinux_filter.patterns), 3)
 +        self.assertIn("passwd_file_t", selinux_filter.patterns)
++
 +    def test_filter_sanitization(self):
 +        """Test pattern sanitization."""
 +        dangerous_patterns = [
 +            "passwd_file_t; rm -rf /",  # Command injection attempt
 +            "test_t|malicious",         # Pipe attempt
 +            "normal_pattern_t"          # Normal pattern
 +        ]
++
 +        selinux_filter = SELinuxFilter(dangerous_patterns)
++
 +        # Should have sanitized dangerous patterns
 +        for pattern in selinux_filter.patterns:
 +            self.assertNotIn(';', pattern)
 +            self.assertNotIn('|', pattern)
 +            self.assertNotIn('`', pattern)
++
 +    @patch('sultree.selinux.get_selinux_context')
 +    def test_filter_matching(self, mock_get_context):
 +        """Test file matching against patterns."""
 +        # Mock SELinux context
 +        mock_context = MagicMock()
 +        mock_context.matches_pattern.return_value = True
 +        mock_get_context.return_value = mock_context
++
 +        selinux_filter = SELinuxFilter(["passwd_file_t"])
 +        test_path = Path("/etc/passwd")
++
 +        result = selinux_filter.matches(test_path)
++
 +        self.assertTrue(result)
 +        mock_get_context.assert_called_once_with(test_path)
++
++
 +class TestSELinuxUtilities(unittest.TestCase):
 +    """Test SELinux utility functions."""
++
 +    @patch('subprocess.run')
 +    def test_get_selinux_context_success(self, mock_run):
 +        """Test successful SELinux context retrieval."""
 +        # Mock successful getfattr output
 +        mock_result = MagicMock()
 +        mock_result.returncode = 0
 +        mock_result.stdout = "system_u:object_r:passwd_file_t:s0"
 +        mock_run.return_value = mock_result
++
 +        context = get_selinux_context(Path("/etc/passwd"))
++
 +        self.assertIsNotNone(context)
 +        self.assertEqual(context.type, "passwd_file_t")
++
 +        # Verify secure command construction
 +        args, kwargs = mock_run.call_args
 +        command = args[0]
 +        self.assertEqual(command[0], 'getfattr')
 +        self.assertIn('--only-values', command)
 +        self.assertIn('-n', command)
 +        self.assertIn('security.selinux', command)
++
 +    @patch('subprocess.run')
 +    def test_get_selinux_context_timeout(self, mock_run):
 +        """Test timeout handling in context retrieval."""
 +        mock_run.side_effect = subprocess.TimeoutExpired('getfattr', 5)
++
 +        with self.assertRaises(SELinuxQueryError):
 +            get_selinux_context(Path("/etc/passwd"))
++
 +    @patch('subprocess.run')
 +    def test_get_selinux_context_no_context(self, mock_run):
 +        """Test handling when no SELinux context exists."""
 +        mock_result = MagicMock()
 +        mock_result.returncode = 1  # getfattr returns 1 for no attribute
 +        mock_result.stdout = ""
 +        mock_run.return_value = mock_result
++
 +        context = get_selinux_context(Path("/etc/passwd"))
++
 +        self.assertIsNone(context)
++
 +    def test_path_validation(self):
 +        """Test path validation in get_selinux_context."""
 +        # Test with non-existent path
 +        non_existent = Path("/non/existent/path")
 +        context = get_selinux_context(non_existent)
++
 +        self.assertIsNone(context)
++
 +    @patch('sultree.selinux.get_selinux_context')
 +    def test_is_selinux_enabled(self, mock_get_context):
 +        """Test SELinux availability detection."""
 +        # Test when SELinux is available
 +        mock_get_context.return_value = MagicMock()
 +        self.assertTrue(is_selinux_enabled())
++
 +        # Test when SELinux is not available
 +        mock_get_context.return_value = None
 +        self.assertFalse(is_selinux_enabled())
++
++
 +if __name__ == '__main__':
 +    unittest.main()