Coverage for tests / unit / ai / test_enums.py: 100%

1"""Tests for AI-specific enumerations.""" 

2 

3from __future__ import annotations 

4 

5import pytest 

6from assertpy import assert_that 

7 

8from lintro.ai.enums import ConfidenceLevel, RiskLevel 

9 

10# -- TestConfidenceLevel: Tests for ConfidenceLevel enum. -------------------- 

11 

12 

13@pytest.mark.parametrize( 

14 ("member", "expected_value"), 

15 [ 

16 (ConfidenceLevel.HIGH, "high"), 

17 (ConfidenceLevel.MEDIUM, "medium"), 

18 (ConfidenceLevel.LOW, "low"), 

19 ], 

20 ids=["high", "medium", "low"], 

21) 

22def test_confidence_string_value( 

23 member: ConfidenceLevel, 

24 expected_value: str, 

25) -> None: 

26 """ConfidenceLevel members have the expected string values.""" 

27 assert_that(str(member)).is_equal_to(expected_value) 

28 

29 

30@pytest.mark.parametrize( 

31 ("member", "expected_value"), 

32 [ 

33 (ConfidenceLevel.HIGH, "high"), 

34 (ConfidenceLevel.MEDIUM, "medium"), 

35 (ConfidenceLevel.LOW, "low"), 

36 ], 

37 ids=["high", "medium", "low"], 

38) 

39def test_confidence_string_equality( 

40 member: ConfidenceLevel, 

41 expected_value: str, 

42) -> None: 

43 """ConfidenceLevel members compare equal to their string values.""" 

44 assert_that(member).is_equal_to(expected_value) 

45 assert_that(member == expected_value).is_true() 

46 

47 

48@pytest.mark.parametrize( 

49 ("member", "expected_order"), 

50 [ 

51 (ConfidenceLevel.HIGH, 3), 

52 (ConfidenceLevel.MEDIUM, 2), 

53 (ConfidenceLevel.LOW, 1), 

54 ], 

55 ids=["high=3", "medium=2", "low=1"], 

56) 

57def test_confidence_numeric_order( 

58 member: ConfidenceLevel, 

59 expected_order: int, 

60) -> None: 

61 """numeric_order returns correct ordering values.""" 

62 assert_that(member.numeric_order).is_equal_to(expected_order) 

63 

64 

65def test_ordering_high_gt_medium_gt_low() -> None: 

66 """HIGH > MEDIUM > LOW by numeric_order.""" 

67 assert_that(ConfidenceLevel.HIGH.numeric_order).is_greater_than( 

68 ConfidenceLevel.MEDIUM.numeric_order, 

69 ) 

70 assert_that(ConfidenceLevel.MEDIUM.numeric_order).is_greater_than( 

71 ConfidenceLevel.LOW.numeric_order, 

72 ) 

73 

74 

75def test_confidence_is_str_subclass() -> None: 

76 """ConfidenceLevel members are str instances.""" 

77 assert_that(ConfidenceLevel.HIGH).is_instance_of(str) 

78 

79 

80def test_confidence_construction_from_string() -> None: 

81 """ConfidenceLevel can be constructed from a string value.""" 

82 assert_that(ConfidenceLevel("high")).is_equal_to(ConfidenceLevel.HIGH) 

83 assert_that(ConfidenceLevel("medium")).is_equal_to(ConfidenceLevel.MEDIUM) 

84 assert_that(ConfidenceLevel("low")).is_equal_to(ConfidenceLevel.LOW) 

85 

86 

87def test_confidence_invalid_value_raises() -> None: 

88 """Invalid string raises ValueError.""" 

89 with pytest.raises(ValueError, match="invalid"): 

90 ConfidenceLevel("invalid") 

91 

92 

93# -- TestRiskLevel: Tests for RiskLevel enum. -------------------------------- 

94 

95 

96@pytest.mark.parametrize( 

97 ("member", "expected_value"), 

98 [ 

99 (RiskLevel.SAFE_STYLE, "safe-style"), 

100 (RiskLevel.BEHAVIORAL_RISK, "behavioral-risk"), 

101 ], 

102 ids=["safe-style", "behavioral-risk"], 

103) 

104def test_risk_hyphenated_string_value( 

105 member: RiskLevel, 

106 expected_value: str, 

107) -> None: 

108 """RiskLevel members produce hyphenated string values.""" 

109 assert_that(str(member)).is_equal_to(expected_value) 

110 

111 

112@pytest.mark.parametrize( 

113 ("member", "expected_value"), 

114 [ 

115 (RiskLevel.SAFE_STYLE, "safe-style"), 

116 (RiskLevel.BEHAVIORAL_RISK, "behavioral-risk"), 

117 ], 

118 ids=["safe-style", "behavioral-risk"], 

119) 

120def test_risk_string_equality( 

121 member: RiskLevel, 

122 expected_value: str, 

123) -> None: 

124 """RiskLevel members compare equal to their hyphenated string values.""" 

125 assert_that(member).is_equal_to(expected_value) 

126 assert_that(member == expected_value).is_true() 

127 

128 

129@pytest.mark.parametrize( 

130 ("member", "sarif", "expected_label"), 

131 [ 

132 (RiskLevel.SAFE_STYLE, False, "notice"), 

133 (RiskLevel.SAFE_STYLE, True, "note"), 

134 (RiskLevel.BEHAVIORAL_RISK, False, "warning"), 

135 (RiskLevel.BEHAVIORAL_RISK, True, "warning"), 

136 ], 

137 ids=[ 

138 "safe-style-annotation", 

139 "safe-style-sarif", 

140 "behavioral-risk-annotation", 

141 "behavioral-risk-sarif", 

142 ], 

143) 

144def test_risk_to_severity_label( 

145 member: RiskLevel, 

146 sarif: bool, 

147 expected_label: str, 

148) -> None: 

149 """to_severity_label returns correct labels for each format.""" 

150 assert_that(member.to_severity_label(sarif=sarif)).is_equal_to(expected_label) 

151 

152 

153def test_risk_is_str_subclass() -> None: 

154 """RiskLevel members are str instances.""" 

155 assert_that(RiskLevel.SAFE_STYLE).is_instance_of(str) 

156 

157 

158def test_risk_construction_from_string() -> None: 

159 """RiskLevel can be constructed from a hyphenated string value.""" 

160 assert_that(RiskLevel("safe-style")).is_equal_to(RiskLevel.SAFE_STYLE) 

161 assert_that(RiskLevel("behavioral-risk")).is_equal_to( 

162 RiskLevel.BEHAVIORAL_RISK, 

163 ) 

164 

165 

166def test_risk_invalid_value_raises() -> None: 

167 """Invalid string raises ValueError.""" 

168 with pytest.raises(ValueError, match="invalid"): 

169 RiskLevel("invalid")