Coverage for tests / unit / tools / taplo / test_error_handling.py: 100%

1"""Tests for TaploPlugin error handling, timeouts, and edge cases.""" 

2 

3from __future__ import annotations 

4 

5import subprocess 

6from pathlib import Path 

7from unittest.mock import patch 

8 

9from assertpy import assert_that 

10 

11from lintro.tools.definitions.taplo import TaploPlugin 

12 

13# Tests for timeout handling in check method 

14 

15 

16def test_check_with_timeout( 

17 taplo_plugin: TaploPlugin, 

18 tmp_path: Path, 

19) -> None: 

20 """Check handles timeout correctly. 

21 

22 Args: 

23 taplo_plugin: The TaploPlugin instance to test. 

24 tmp_path: Temporary directory path for test files. 

25 """ 

26 test_file = tmp_path / "test.toml" 

27 test_file.write_text('[project]\nname = "test"\n') 

28 

29 with patch.object( 

30 taplo_plugin, 

31 "_run_subprocess", 

32 side_effect=subprocess.TimeoutExpired(cmd=["taplo"], timeout=30), 

33 ): 

34 result = taplo_plugin.check([str(test_file)], {}) 

35 

36 assert_that(result.success).is_false() 

37 assert_that(result.issues_count).is_greater_than(0) 

38 assert_that(result.output).contains("timed out") 

39 

40 

41def test_check_with_timeout_on_format_check( 

42 taplo_plugin: TaploPlugin, 

43 tmp_path: Path, 

44) -> None: 

45 """Check handles timeout during format check correctly. 

46 

47 Args: 

48 taplo_plugin: The TaploPlugin instance to test. 

49 tmp_path: Temporary directory path for test files. 

50 """ 

51 test_file = tmp_path / "test.toml" 

52 test_file.write_text('[project]\nname = "test"\n') 

53 

54 with patch.object( 

55 taplo_plugin, 

56 "_run_subprocess", 

57 side_effect=[ 

58 (True, ""), # lint succeeds 

59 subprocess.TimeoutExpired(cmd=["taplo"], timeout=30), # fmt times out 

60 ], 

61 ): 

62 result = taplo_plugin.check([str(test_file)], {}) 

63 

64 assert_that(result.success).is_false() 

65 assert_that(result.output).contains("timed out") 

66 

67 

68# Tests for timeout handling in fix method 

69 

70 

71def test_fix_with_timeout( 

72 taplo_plugin: TaploPlugin, 

73 tmp_path: Path, 

74) -> None: 

75 """Fix handles timeout correctly. 

76 

77 Args: 

78 taplo_plugin: The TaploPlugin instance to test. 

79 tmp_path: Temporary directory path for test files. 

80 """ 

81 test_file = tmp_path / "test.toml" 

82 test_file.write_text('[project]\nname = "test"\n') 

83 

84 with patch.object( 

85 taplo_plugin, 

86 "_run_subprocess", 

87 side_effect=subprocess.TimeoutExpired(cmd=["taplo"], timeout=30), 

88 ): 

89 result = taplo_plugin.fix([str(test_file)], {}) 

90 

91 assert_that(result.success).is_false() 

92 assert_that(result.output).contains("timed out") 

93 

94 

95def test_fix_with_timeout_during_fix_command( 

96 taplo_plugin: TaploPlugin, 

97 tmp_path: Path, 

98) -> None: 

99 """Fix handles timeout during fix command correctly. 

100 

101 Args: 

102 taplo_plugin: The TaploPlugin instance to test. 

103 tmp_path: Temporary directory path for test files. 

104 """ 

105 test_file = tmp_path / "test.toml" 

106 test_file.write_text('[project]\nname="test"\n') 

107 

108 format_issue = """error[formatting]: the file is not properly formatted 

109 --> test.toml:2:1 

110 | 

111 2 | name="test" 

112 | ^ formatting issue 

113""" 

114 

115 with patch.object( 

116 taplo_plugin, 

117 "_run_subprocess", 

118 side_effect=[ 

119 (False, format_issue), # initial format check 

120 (True, ""), # initial lint check 

121 subprocess.TimeoutExpired(cmd=["taplo"], timeout=30), # fix times out 

122 ], 

123 ): 

124 result = taplo_plugin.fix([str(test_file)], {}) 

125 

126 assert_that(result.success).is_false() 

127 assert_that(result.output).contains("timed out") 

128 assert_that(result.initial_issues_count).is_equal_to(1)