Coverage for tests / unit / config / test_lintro_config.py: 100%

1"""Tests for lintro.config.lintro_config module.""" 

2 

3from __future__ import annotations 

4 

5from assertpy import assert_that 

6 

7from lintro.config.enforce_config import EnforceConfig 

8from lintro.config.execution_config import ExecutionConfig 

9from lintro.config.lintro_config import LintroConfig 

10from lintro.config.tool_config import LintroToolConfig 

11 

12 

13def test_lintro_config_default_execution() -> None: 

14 """LintroConfig has default ExecutionConfig.""" 

15 config = LintroConfig() 

16 assert_that(config.execution).is_instance_of(ExecutionConfig) 

17 

18 

19def test_lintro_config_default_enforce() -> None: 

20 """LintroConfig has default EnforceConfig.""" 

21 config = LintroConfig() 

22 assert_that(config.enforce).is_instance_of(EnforceConfig) 

23 

24 

25def test_lintro_config_default_defaults() -> None: 

26 """LintroConfig has empty defaults dict.""" 

27 config = LintroConfig() 

28 assert_that(config.defaults).is_empty() 

29 

30 

31def test_lintro_config_default_tools() -> None: 

32 """LintroConfig has empty tools dict.""" 

33 config = LintroConfig() 

34 assert_that(config.tools).is_empty() 

35 

36 

37def test_lintro_config_default_config_path() -> None: 

38 """LintroConfig has None config_path by default.""" 

39 config = LintroConfig() 

40 assert_that(config.config_path).is_none() 

41 

42 

43def test_lintro_config_set_config_path() -> None: 

44 """LintroConfig accepts config_path.""" 

45 config = LintroConfig(config_path="/path/to/.lintro-config.yaml") 

46 assert_that(config.config_path).is_equal_to("/path/to/.lintro-config.yaml") 

47 

48 

49def test_get_tool_config_returns_configured_tool() -> None: 

50 """get_tool_config returns configured tool config.""" 

51 tool_config = LintroToolConfig(enabled=False) 

52 config = LintroConfig(tools={"ruff": tool_config}) 

53 result = config.get_tool_config("ruff") 

54 assert_that(result.enabled).is_false() 

55 

56 

57def test_get_tool_config_returns_default_for_missing() -> None: 

58 """get_tool_config returns default config for unconfigured tool.""" 

59 config = LintroConfig() 

60 result = config.get_tool_config("ruff") 

61 assert_that(result).is_instance_of(LintroToolConfig) 

62 assert_that(result.enabled).is_true() 

63 

64 

65def test_get_tool_config_case_insensitive() -> None: 

66 """get_tool_config is case-insensitive.""" 

67 tool_config = LintroToolConfig(enabled=False) 

68 config = LintroConfig(tools={"ruff": tool_config}) 

69 result = config.get_tool_config("RUFF") 

70 assert_that(result.enabled).is_false() 

71 

72 

73def test_is_tool_enabled_default_true() -> None: 

74 """is_tool_enabled returns True for unconfigured tool.""" 

75 config = LintroConfig() 

76 assert_that(config.is_tool_enabled("ruff")).is_true() 

77 

78 

79def test_is_tool_enabled_respects_tool_config() -> None: 

80 """is_tool_enabled respects tool enabled flag.""" 

81 tool_config = LintroToolConfig(enabled=False) 

82 config = LintroConfig(tools={"ruff": tool_config}) 

83 assert_that(config.is_tool_enabled("ruff")).is_false() 

84 

85 

86def test_is_tool_enabled_respects_enabled_tools_filter() -> None: 

87 """is_tool_enabled respects execution.enabled_tools filter.""" 

88 execution = ExecutionConfig(enabled_tools=["black", "mypy"]) 

89 config = LintroConfig(execution=execution) 

90 assert_that(config.is_tool_enabled("ruff")).is_false() 

91 assert_that(config.is_tool_enabled("black")).is_true() 

92 

93 

94def test_is_tool_enabled_empty_enabled_tools_allows_all() -> None: 

95 """is_tool_enabled allows all tools when enabled_tools is empty.""" 

96 config = LintroConfig() 

97 assert_that(config.is_tool_enabled("ruff")).is_true() 

98 assert_that(config.is_tool_enabled("black")).is_true() 

99 assert_that(config.is_tool_enabled("mypy")).is_true() 

100 

101 

102def test_is_tool_enabled_case_insensitive() -> None: 

103 """is_tool_enabled is case-insensitive.""" 

104 execution = ExecutionConfig(enabled_tools=["RUFF"]) 

105 config = LintroConfig(execution=execution) 

106 assert_that(config.is_tool_enabled("ruff")).is_true() 

107 assert_that(config.is_tool_enabled("Ruff")).is_true() 

108 

109 

110def test_get_tool_defaults_returns_configured_defaults() -> None: 

111 """get_tool_defaults returns configured defaults.""" 

112 config = LintroConfig(defaults={"ruff": {"line-length": 120}}) 

113 result = config.get_tool_defaults("ruff") 

114 assert_that(result).is_equal_to({"line-length": 120}) 

115 

116 

117def test_get_tool_defaults_returns_empty_for_missing() -> None: 

118 """get_tool_defaults returns empty dict for unconfigured tool.""" 

119 config = LintroConfig() 

120 result = config.get_tool_defaults("ruff") 

121 assert_that(result).is_empty() 

122 

123 

124def test_get_tool_defaults_case_insensitive() -> None: 

125 """get_tool_defaults is case-insensitive.""" 

126 config = LintroConfig(defaults={"ruff": {"line-length": 88}}) 

127 result = config.get_tool_defaults("RUFF") 

128 assert_that(result).is_equal_to({"line-length": 88}) 

129 

130 

131def test_get_effective_line_length_returns_enforced() -> None: 

132 """get_effective_line_length returns enforce.line_length.""" 

133 enforce = EnforceConfig(line_length=120) 

134 config = LintroConfig(enforce=enforce) 

135 result = config.get_effective_line_length("ruff") 

136 assert_that(result).is_equal_to(120) 

137 

138 

139def test_get_effective_line_length_returns_none_when_not_set() -> None: 

140 """get_effective_line_length returns None when not configured.""" 

141 config = LintroConfig() 

142 result = config.get_effective_line_length("ruff") 

143 assert_that(result).is_none() 

144 

145 

146def test_get_effective_target_python_returns_enforced() -> None: 

147 """get_effective_target_python returns enforce.target_python.""" 

148 enforce = EnforceConfig(target_python="py311") 

149 config = LintroConfig(enforce=enforce) 

150 result = config.get_effective_target_python("ruff") 

151 assert_that(result).is_equal_to("py311") 

152 

153 

154def test_get_effective_target_python_returns_none_when_not_set() -> None: 

155 """get_effective_target_python returns None when not configured.""" 

156 config = LintroConfig() 

157 result = config.get_effective_target_python("ruff") 

158 assert_that(result).is_none()