Coverage for tests / unit / enums / test_enum_normalizers.py: 100%
34 statements
« prev ^ index » next coverage.py v7.13.0, created at 2026-04-03 18:53 +0000
1"""Unit tests for enum normalizer functions."""
3from __future__ import annotations
5from typing import Any
7import pytest
8from assertpy import assert_that
10from lintro.enums.bandit_levels import (
11 BanditConfidenceLevel,
12 BanditSeverityLevel,
13 normalize_bandit_confidence_level,
14 normalize_bandit_severity_level,
15)
16from lintro.enums.config_format import ConfigFormat, normalize_config_format
17from lintro.enums.pytest_enums import (
18 PytestOutputFormat,
19 PytestSpecialMode,
20 TestStatus,
21 normalize_pytest_output_format,
22 normalize_pytest_special_mode,
23 normalize_test_status,
24)
25from lintro.enums.semgrep_enums import (
26 SemgrepSeverity,
27 normalize_semgrep_severity,
28)
29from lintro.enums.tool_type import ToolType, normalize_tool_type
30from lintro.enums.tools_value import ToolsValue, normalize_tools_value
32# Test cases for all normalizer functions
33# Format: (normalize_func, enum_class, enum_member, lowercase_str, uppercase_str, error_pattern)
34NORMALIZER_TEST_CASES = [
35 pytest.param(
36 normalize_bandit_severity_level,
37 BanditSeverityLevel,
38 BanditSeverityLevel.HIGH,
39 "low",
40 "MEDIUM",
41 "Unknown bandit severity level",
42 id="bandit_severity",
43 ),
44 pytest.param(
45 normalize_bandit_confidence_level,
46 BanditConfidenceLevel,
47 BanditConfidenceLevel.LOW,
48 "high",
49 "MEDIUM",
50 "Unknown bandit confidence level",
51 id="bandit_confidence",
52 ),
53 pytest.param(
54 normalize_config_format,
55 ConfigFormat,
56 ConfigFormat.YAML,
57 "yaml",
58 "JSON",
59 "Unknown config format",
60 id="config_format",
61 ),
62 pytest.param(
63 normalize_pytest_special_mode,
64 PytestSpecialMode,
65 PytestSpecialMode.LIST_MARKERS,
66 "collect_only",
67 "LIST_PLUGINS",
68 "Unknown pytest special mode",
69 id="pytest_special_mode",
70 ),
71 pytest.param(
72 normalize_pytest_output_format,
73 PytestOutputFormat,
74 PytestOutputFormat.JSON,
75 "text",
76 "JUNIT",
77 "Unknown pytest output format",
78 id="pytest_output_format",
79 ),
80 pytest.param(
81 normalize_test_status,
82 TestStatus,
83 TestStatus.PASSED,
84 "failed",
85 "SKIPPED",
86 "Unknown test status",
87 id="test_status",
88 ),
89 pytest.param(
90 normalize_tools_value,
91 ToolsValue,
92 ToolsValue.ALL,
93 "all",
94 "ALL",
95 "Unknown tools value",
96 id="tools_value",
97 ),
98 pytest.param(
99 normalize_semgrep_severity,
100 SemgrepSeverity,
101 SemgrepSeverity.WARNING,
102 "info",
103 "ERROR",
104 "Invalid Semgrep severity",
105 id="semgrep_severity",
106 ),
107]
110@pytest.mark.parametrize(
111 "normalize_func,enum_class,enum_member,lowercase_str,uppercase_str,error_pattern",
112 NORMALIZER_TEST_CASES,
113)
114def test_normalizer_with_enum_instance(
115 normalize_func: Any,
116 enum_class: Any,
117 enum_member: Any,
118 lowercase_str: str,
119 uppercase_str: str,
120 error_pattern: str,
121) -> None:
122 """Return enum instance unchanged.
124 Args:
125 normalize_func: The normalizer function to test.
126 enum_class: The enum class being tested.
127 enum_member: An instance of the enum class.
128 lowercase_str: A lowercase string representation.
129 uppercase_str: An uppercase string representation.
130 error_pattern: The error pattern for invalid inputs.
131 """
132 result = normalize_func(enum_member)
133 assert_that(result).is_equal_to(enum_member)
136@pytest.mark.parametrize(
137 "normalize_func,enum_class,enum_member,lowercase_str,uppercase_str,error_pattern",
138 NORMALIZER_TEST_CASES,
139)
140def test_normalizer_with_lowercase_string(
141 normalize_func: Any,
142 enum_class: Any,
143 enum_member: Any,
144 lowercase_str: str,
145 uppercase_str: str,
146 error_pattern: str,
147) -> None:
148 """Normalize lowercase string to enum.
150 Args:
151 normalize_func: The normalizer function to test.
152 enum_class: The enum class being tested.
153 enum_member: An instance of the enum class.
154 lowercase_str: A lowercase string representation.
155 uppercase_str: An uppercase string representation.
156 error_pattern: The error pattern for invalid inputs.
157 """
158 result = normalize_func(lowercase_str)
159 assert_that(result).is_instance_of(enum_class)
162@pytest.mark.parametrize(
163 "normalize_func,enum_class,enum_member,lowercase_str,uppercase_str,error_pattern",
164 NORMALIZER_TEST_CASES,
165)
166def test_normalizer_with_uppercase_string(
167 normalize_func: Any,
168 enum_class: Any,
169 enum_member: Any,
170 lowercase_str: str,
171 uppercase_str: str,
172 error_pattern: str,
173) -> None:
174 """Normalize uppercase string to enum.
176 Args:
177 normalize_func: The normalizer function to test.
178 enum_class: The enum class being tested.
179 enum_member: An instance of the enum class.
180 lowercase_str: A lowercase string representation.
181 uppercase_str: An uppercase string representation.
182 error_pattern: The error pattern for invalid inputs.
183 """
184 result = normalize_func(uppercase_str)
185 assert_that(result).is_instance_of(enum_class)
188@pytest.mark.parametrize(
189 "normalize_func,enum_class,enum_member,lowercase_str,uppercase_str,error_pattern",
190 NORMALIZER_TEST_CASES,
191)
192def test_normalizer_with_invalid_string(
193 normalize_func: Any,
194 enum_class: Any,
195 enum_member: Any,
196 lowercase_str: str,
197 uppercase_str: str,
198 error_pattern: str,
199) -> None:
200 """Raise ValueError for invalid string.
202 Args:
203 normalize_func: The normalizer function to test.
204 enum_class: The enum class being tested.
205 enum_member: An instance of the enum class.
206 lowercase_str: A lowercase string representation.
207 uppercase_str: An uppercase string representation.
208 error_pattern: The error pattern for invalid inputs.
209 """
210 with pytest.raises(ValueError, match=error_pattern):
211 normalize_func("definitely_invalid_xyz_12345")
214# --- ToolType-specific tests (has additional behavior) ---
217def test_normalize_tool_type_with_combined_enum() -> None:
218 """Preserve combined Flag values for ToolType."""
219 combined = ToolType.LINTER | ToolType.FORMATTER
220 result = normalize_tool_type(combined)
221 assert_that(result).is_equal_to(combined)
224def test_normalize_tool_type_with_invalid_type() -> None:
225 """Raise ValueError for invalid type."""
226 with pytest.raises(ValueError, match="Invalid tool type"):
227 normalize_tool_type(123) # type: ignore