Coverage for tests / unit / utils / test_ascii_normalize_cli.py: 100%

1"""Unit tests for ascii_normalize_cli module.""" 

2 

3from __future__ import annotations 

4 

5from pathlib import Path 

6from unittest.mock import patch 

7 

8from assertpy import assert_that 

9 

10from lintro.utils.ascii_normalize_cli import _ascii_art_dir, _write_sections, main 

11 

12# --- _ascii_art_dir tests --- 

13 

14 

15def test_ascii_art_dir_returns_path() -> None: 

16 """Test that function returns a Path object.""" 

17 result = _ascii_art_dir() 

18 assert_that(result).is_instance_of(Path) 

19 

20 

21def test_ascii_art_dir_points_to_ascii_art() -> None: 

22 """Test that path ends with ascii-art.""" 

23 result = _ascii_art_dir() 

24 assert_that(str(result)).ends_with("ascii-art") 

25 

26 

27# --- _write_sections tests --- 

28 

29 

30def test_write_sections_single(tmp_path: Path) -> None: 

31 """Test writing a single section to file. 

32 

33 Args: 

34 tmp_path: Temporary directory path for testing. 

35 """ 

36 file_path = tmp_path / "test.txt" 

37 sections = [["line1", "line2", "line3"]] 

38 

39 _write_sections(file_path, sections) 

40 

41 content = file_path.read_text() 

42 assert_that(content).is_equal_to("line1\nline2\nline3\n") 

43 

44 

45def test_write_sections_multiple_with_blank_separator(tmp_path: Path) -> None: 

46 """Test that multiple sections are separated by blank line. 

47 

48 Args: 

49 tmp_path: Temporary directory path for testing. 

50 """ 

51 file_path = tmp_path / "test.txt" 

52 sections = [["sec1_line1", "sec1_line2"], ["sec2_line1", "sec2_line2"]] 

53 

54 _write_sections(file_path, sections) 

55 

56 content = file_path.read_text() 

57 assert_that(content).is_equal_to( 

58 "sec1_line1\nsec1_line2\n\nsec2_line1\nsec2_line2\n", 

59 ) 

60 

61 

62def test_write_sections_empty(tmp_path: Path) -> None: 

63 """Test handling of empty sections list. 

64 

65 Args: 

66 tmp_path: Temporary directory path for testing. 

67 """ 

68 file_path = tmp_path / "test.txt" 

69 sections: list[list[str]] = [] 

70 

71 _write_sections(file_path, sections) 

72 

73 content = file_path.read_text() 

74 assert_that(content).is_equal_to("\n") 

75 

76 

77# --- main tests --- 

78 

79 

80def test_main_returns_error_when_dir_not_found() -> None: 

81 """Test returns 1 when ascii-art directory not found.""" 

82 with ( 

83 patch( 

84 "lintro.utils.ascii_normalize_cli._ascii_art_dir", 

85 return_value=Path("/nonexistent/path"), 

86 ), 

87 patch( 

88 "lintro.utils.ascii_normalize_cli.argparse.ArgumentParser.parse_args", 

89 ) as mock_args, 

90 ): 

91 mock_args.return_value.files = [] 

92 mock_args.return_value.width = 80 

93 mock_args.return_value.height = 20 

94 mock_args.return_value.align = "center" 

95 mock_args.return_value.valign = "middle" 

96 

97 result = main() 

98 

99 assert_that(result).is_equal_to(1) 

100 

101 

102def test_main_processes_specific_files(tmp_path: Path) -> None: 

103 """Test processing specific files. 

104 

105 Args: 

106 tmp_path: Temporary directory path for testing. 

107 """ 

108 test_file = tmp_path / "test.txt" 

109 test_file.write_text("test\n") 

110 

111 with ( 

112 patch( 

113 "lintro.utils.ascii_normalize_cli._ascii_art_dir", 

114 return_value=tmp_path, 

115 ), 

116 patch( 

117 "lintro.utils.ascii_normalize_cli.argparse.ArgumentParser.parse_args", 

118 ) as mock_args, 

119 patch( 

120 "lintro.utils.ascii_normalize_cli.normalize_ascii_file_sections", 

121 return_value=[["normalized"]], 

122 ), 

123 patch("lintro.utils.ascii_normalize_cli._write_sections") as mock_write, 

124 ): 

125 mock_args.return_value.files = ["test.txt"] 

126 mock_args.return_value.width = 80 

127 mock_args.return_value.height = 20 

128 mock_args.return_value.align = "center" 

129 mock_args.return_value.valign = "middle" 

130 

131 result = main() 

132 

133 assert_that(result).is_equal_to(0) 

134 mock_write.assert_called_once() 

135 

136 

137def test_main_processes_all_txt_files(tmp_path: Path) -> None: 

138 """Test processing all .txt files when no specific files given. 

139 

140 Args: 

141 tmp_path: Temporary directory path for testing. 

142 """ 

143 (tmp_path / "file1.txt").write_text("test1\n") 

144 (tmp_path / "file2.txt").write_text("test2\n") 

145 

146 with ( 

147 patch( 

148 "lintro.utils.ascii_normalize_cli._ascii_art_dir", 

149 return_value=tmp_path, 

150 ), 

151 patch( 

152 "lintro.utils.ascii_normalize_cli.argparse.ArgumentParser.parse_args", 

153 ) as mock_args, 

154 patch( 

155 "lintro.utils.ascii_normalize_cli.normalize_ascii_file_sections", 

156 return_value=[["normalized"]], 

157 ), 

158 patch("lintro.utils.ascii_normalize_cli._write_sections"), 

159 ): 

160 mock_args.return_value.files = [] 

161 mock_args.return_value.width = 80 

162 mock_args.return_value.height = 20 

163 mock_args.return_value.align = "center" 

164 mock_args.return_value.valign = "middle" 

165 

166 result = main() 

167 

168 assert_that(result).is_equal_to(0) 

169 

170 

171def test_main_skips_files_with_no_sections(tmp_path: Path) -> None: 

172 """Test that files returning no sections are skipped. 

173 

174 Args: 

175 tmp_path: Temporary directory path for testing. 

176 """ 

177 (tmp_path / "empty.txt").write_text("") 

178 

179 with ( 

180 patch( 

181 "lintro.utils.ascii_normalize_cli._ascii_art_dir", 

182 return_value=tmp_path, 

183 ), 

184 patch( 

185 "lintro.utils.ascii_normalize_cli.argparse.ArgumentParser.parse_args", 

186 ) as mock_args, 

187 patch( 

188 "lintro.utils.ascii_normalize_cli.normalize_ascii_file_sections", 

189 return_value=[], 

190 ), 

191 patch("lintro.utils.ascii_normalize_cli._write_sections") as mock_write, 

192 ): 

193 mock_args.return_value.files = ["empty.txt"] 

194 mock_args.return_value.width = 80 

195 mock_args.return_value.height = 20 

196 mock_args.return_value.align = "center" 

197 mock_args.return_value.valign = "middle" 

198 

199 result = main() 

200 

201 assert_that(result).is_equal_to(0) 

202 mock_write.assert_not_called()