Coverage for tests / unit / utils / result_formatters / test_pytest_output.py: 100%

1"""Tests for pytest output handling in print_tool_result.""" 

2 

3from __future__ import annotations 

4 

5from typing import TYPE_CHECKING, Any 

6 

7import pytest 

8from assertpy import assert_that 

9 

10from lintro.utils.result_formatters import print_tool_result 

11 

12if TYPE_CHECKING: 

13 from collections.abc import Callable 

14 

15 

16def test_pytest_with_output_displays_header( 

17 console_capture_with_kwargs: tuple[ 

18 Callable[..., None], 

19 list[tuple[str, dict[str, Any]]], 

20 ], 

21 success_capture: tuple[Callable[[str], None], list[str]], 

22) -> None: 

23 """Verify pytest output includes test results header and separator. 

24 

25 Args: 

26 console_capture_with_kwargs: Mock console output capture with kwargs. 

27 success_capture: Mock success message capture. 

28 """ 

29 mock_console, console_output = console_capture_with_kwargs 

30 mock_success, _ = success_capture 

31 

32 print_tool_result( 

33 console_output_func=mock_console, 

34 success_func=mock_success, 

35 tool_name="pytest", 

36 output="test_example.py::test_one PASSED", 

37 issues_count=0, 

38 ) 

39 

40 texts = [t for t, _ in console_output] 

41 assert_that(texts).contains("🧪 Test Results") 

42 assert_that(texts).contains("-" * 20) 

43 

44 

45def test_pytest_no_issues_no_output_shows_success( 

46 console_capture_with_kwargs: tuple[ 

47 Callable[..., None], 

48 list[tuple[str, dict[str, Any]]], 

49 ], 

50 success_capture: tuple[Callable[[str], None], list[str]], 

51) -> None: 

52 """Verify success message displayed for pytest with no issues and empty output. 

53 

54 Args: 

55 console_capture_with_kwargs: Mock console output capture with kwargs. 

56 success_capture: Mock success message capture. 

57 """ 

58 mock_console, _ = console_capture_with_kwargs 

59 mock_success, success_calls = success_capture 

60 

61 print_tool_result( 

62 console_output_func=mock_console, 

63 success_func=mock_success, 

64 tool_name="pytest", 

65 output="", 

66 issues_count=0, 

67 ) 

68 

69 assert_that(success_calls).contains("✓ No issues found.") 

70 

71 

72def test_pytest_filters_json_output_at_line_start( 

73 console_capture_with_kwargs: tuple[ 

74 Callable[..., None], 

75 list[tuple[str, dict[str, Any]]], 

76 ], 

77 success_capture: tuple[Callable[[str], None], list[str]], 

78) -> None: 

79 """Verify standalone JSON lines at start are filtered from pytest output. 

80 

81 Args: 

82 console_capture_with_kwargs: Mock console output capture with kwargs. 

83 success_capture: Mock success message capture. 

84 """ 

85 mock_console, console_output = console_capture_with_kwargs 

86 mock_success, _ = success_capture 

87 

88 output = '{"key": "value"}\nMore text' 

89 

90 print_tool_result( 

91 console_output_func=mock_console, 

92 success_func=mock_success, 

93 tool_name="pytest", 

94 output=output, 

95 issues_count=0, 

96 ) 

97 

98 texts = [ 

99 t for t, _ in console_output if t and t not in ("🧪 Test Results", "-" * 20, "") 

100 ] 

101 combined = "\n".join(texts) 

102 assert_that(combined).contains("More text") 

103 

104 

105def test_pytest_preserves_progress_markers( 

106 console_capture_with_kwargs: tuple[ 

107 Callable[..., None], 

108 list[tuple[str, dict[str, Any]]], 

109 ], 

110 success_capture: tuple[Callable[[str], None], list[str]], 

111) -> None: 

112 """Verify progress indicators are preserved in pytest output. 

113 

114 Args: 

115 console_capture_with_kwargs: Mock console output capture with kwargs. 

116 success_capture: Mock success message capture. 

117 """ 

118 mock_console, console_output = console_capture_with_kwargs 

119 mock_success, _ = success_capture 

120 

121 output = "test_file.py [100%]\nAll tests passed" 

122 

123 print_tool_result( 

124 console_output_func=mock_console, 

125 success_func=mock_success, 

126 tool_name="pytest", 

127 output=output, 

128 issues_count=0, 

129 ) 

130 

131 texts = [ 

132 t for t, _ in console_output if t and t not in ("🧪 Test Results", "-" * 20, "") 

133 ] 

134 combined = "\n".join(texts) 

135 assert_that(combined).contains("[100%]") 

136 

137 

138@pytest.mark.parametrize( 

139 ("tool_name", "expected_header"), 

140 [ 

141 ("pytest", "🧪 Test Results"), 

142 ("PYTEST", "🧪 Test Results"), 

143 ("PyTest", "🧪 Test Results"), 

144 ], 

145 ids=["lowercase_pytest", "uppercase_pytest", "mixed_case_pytest"], 

146) 

147def test_pytest_tool_name_case_insensitive( 

148 console_capture_with_kwargs: tuple[ 

149 Callable[..., None], 

150 list[tuple[str, dict[str, Any]]], 

151 ], 

152 success_capture: tuple[Callable[[str], None], list[str]], 

153 tool_name: str, 

154 expected_header: str, 

155) -> None: 

156 """Verify pytest tool name handling is case-insensitive. 

157 

158 Args: 

159 console_capture_with_kwargs: Mock console output capture with kwargs. 

160 success_capture: Mock success message capture. 

161 tool_name: Name of the tool. 

162 expected_header: Expected header text. 

163 """ 

164 mock_console, console_output = console_capture_with_kwargs 

165 mock_success, _ = success_capture 

166 

167 print_tool_result( 

168 console_output_func=mock_console, 

169 success_func=mock_success, 

170 tool_name=tool_name, 

171 output="test output", 

172 issues_count=0, 

173 ) 

174 

175 texts = [t for t, _ in console_output] 

176 assert_that(texts).contains(expected_header)