Debian Codegraph @

src/tests/test_parse_config_iplist.py

raw
1 """Basic unit tests of parse_config_iplist()."""
2 # pylint: disable=invalid-name,import-error
3 # ruff: noqa: N803
4
5 import contextlib
6 import copy
7 import unittest
8 import unittest.mock
9
10 from foomuuri import CONFIG as BASE_CONFIG
11 from foomuuri import INTERNAL as BASE_INTERNAL
12 from foomuuri import (
13 IPListOptions,
14 minimal_config,
15 parse_config_iplist,
16 parse_duration,
17 )
18
19
20 @unittest.mock.patch(
21 'foomuuri.INTERNAL', new_callable=lambda: copy.deepcopy(BASE_INTERNAL)
22 )
23 @unittest.mock.patch(
24 'foomuuri.CONFIG', new_callable=lambda: copy.deepcopy(BASE_CONFIG)
25 )
26 class TestIplistParseConfig(unittest.TestCase):
27 """Test parse_config_iplist()."""
28
29 @staticmethod
30 @contextlib.contextmanager
31 def mock_config_foomuuri(section: str = 'iplist', content: str = ''):
32 """Return context manager of foomuuri.find_config_files() patch.
33
34 foomuuri.find_config_files() is patched to return generated
35 foomuuri configuration file, containing arbitrary section {}
36 with specified content.
37 """
38 # consult tests/test_parse_config_foomuuri.py for mock explanation
39 config_file = unittest.mock.MagicMock()
40 config_file.read_text.return_value = f"""
41 {section} {{
42 {content}
43 }}
44 """
45 with unittest.mock.patch(
46 'foomuuri.find_config_files', side_effect=[[], [config_file]]
47 ):
48 yield config_file
49
50 @unittest.mock.patch('foomuuri.warning')
51 def test_obsolete_syntax(self, warning, *_):
52 """Test obsolete resolve{} section and timeout/refresh options."""
53 with self.mock_config_foomuuri(
54 section='resolve',
55 content="""
56 timeout 1d 5m
57 refresh 0d 30m
58 @foo https://foob.ar/
59 """,
60 ) as config_file:
61 iplists = parse_config_iplist(minimal_config())
62 options = iplists['@foo'].options
63 self.assertEqual(options.dns_timeout, parse_duration('1d 5m', 0))
64 self.assertEqual(options.url_timeout, parse_duration('1d 5m', 0))
65 self.assertEqual(options.dns_refresh, parse_duration('0d 30m', 0))
66 self.assertEqual(options.url_refresh, parse_duration('0d 30m', 0))
67 self.assertEqual(iplists['@foo'].sources, ['https://foob.ar/'])
68 warning.assert_has_calls(
69 [
70 unittest.mock.call(
71 'Section "resolve" is obsolete, use "iplist" instead',
72 ),
73 unittest.mock.call(
74 f'File {config_file} line 4: Iplist "timeout" is '
75 'obsolete, use "dns_timeout" or "url_timeout" instead',
76 ),
77 unittest.mock.call(
78 f'File {config_file} line 5: Iplist "refresh" is '
79 'obsolete, use "dns_refresh" or "url_refresh" instead',
80 ),
81 ]
82 )
83
84 @unittest.mock.patch('foomuuri.warning')
85 @unittest.mock.patch('foomuuri.fail', side_effect=SystemExit)
86 def test_obsolete_syntax_fail(self, fail, warning, *_):
87 """Test iplist{} section with invalid obsolete timeout option."""
88 with self.mock_config_foomuuri(
89 section='iplist',
90 content="""
91 timeout # value is missing
92 """,
93 ) as config_file:
94 with self.assertRaises(SystemExit):
95 _ = parse_config_iplist(minimal_config())
96 warning.assert_called_once_with(
97 f'File {config_file} line 4: Iplist "timeout" is obsolete, '
98 'use "dns_timeout" or "url_timeout" instead',
99 )
100 fail.assert_called_once_with(
101 f'File {config_file} line 4: Invalid iplist{{}} option '
102 'value: dns_timeout='
103 )
104
105 def test_empty_iplist_definition(self, *_):
106 """Test empty iplist definition."""
107 with self.mock_config_foomuuri(
108 section='iplist',
109 content="""
110 @foo
111 @foo -
112 """,
113 ):
114 iplists = parse_config_iplist(minimal_config())
115 self.assertEqual(iplists['@foo'].sources, [])
116
117 def test_valid_default_options(self, *_):
118 """Test valid default options, space and equal-sign styles."""
119 with self.mock_config_foomuuri(
120 section='iplist',
121 content="""
122 url_max_size 1024
123 url_timeout=69d
124 url_refresh=42d
125 dns_timeout 1d 2h # space-separated option value is
126 # supported by parse_duration()
127 @foo https://foob.ar/
128 """,
129 ):
130 iplists = parse_config_iplist(minimal_config())
131 options = iplists['@foo'].options
132 self.assertEqual(options.url_timeout, parse_duration('69d', 0))
133 self.assertEqual(options.url_refresh, parse_duration('42d', 0))
134 self.assertEqual(options.dns_timeout, parse_duration('1d 2h', 0))
135 self.assertEqual(options.url_max_size, 1024)
136
137 def test_single_line_multiple_valid_default_options(self, *_):
138 """Test mulitple valid default options on single line."""
139 with self.mock_config_foomuuri(
140 section='iplist',
141 content="""
142 url_timeout=69d url_refresh=42d
143 @foo https://foob.ar/
144 """,
145 ):
146 iplists = parse_config_iplist(minimal_config())
147 options = iplists['@foo'].options
148 self.assertEqual(options.url_timeout, parse_duration('69d', 0))
149 self.assertEqual(options.url_refresh, parse_duration('42d', 0))
150
151 @unittest.mock.patch('foomuuri.fail', side_effect=SystemExit)
152 def test_first_invalid_default_option(self, fail, *_):
153 """Test first invalid default option on single line."""
154 with self.mock_config_foomuuri(
155 section='iplist',
156 content="""
157 invalid url_timeout=2d url_refresh=1d
158 @foo https://foob.ar/
159 """,
160 ) as config_file:
161 with self.assertRaises(SystemExit):
162 _ = parse_config_iplist(minimal_config())
163
164 fail.assert_called_once_with(
165 f'File {config_file} line 4: Invalid iplist{{}} option name: '
166 'invalid=url_timeout=2d url_refresh=1d'
167 )
168
169 @unittest.mock.patch('foomuuri.fail', side_effect=SystemExit)
170 def test_second_invalid_default_option(self, fail, *_):
171 """Test second invalid default option on single line."""
172 with self.mock_config_foomuuri(
173 section='iplist',
174 content="""
175 url_timeout=2d invalid url_refresh=1d
176 @foo https://foob.ar/
177 """,
178 ) as config_file:
179 with self.assertRaises(SystemExit):
180 _ = parse_config_iplist(minimal_config())
181
182 fail.assert_called_once_with(
183 f'File {config_file} line 4: Unsupported syntax: '
184 'url_timeout=2d invalid url_refresh=1d'
185 )
186
187 @unittest.mock.patch('foomuuri.fail', side_effect=SystemExit)
188 def test_invalid_space_style_default_option_name(self, fail, *_):
189 """Test invalid space-style default option name."""
190 with self.mock_config_foomuuri(
191 section='iplist',
192 content="""
193 url_min_size 1024
194 """,
195 ) as config_file:
196 with self.assertRaises(SystemExit):
197 _ = parse_config_iplist(minimal_config())
198
199 fail.assert_called_once_with(
200 f'File {config_file} line 4: Invalid iplist{{}} option name: '
201 'url_min_size=1024'
202 )
203
204 @unittest.mock.patch('foomuuri.fail', side_effect=SystemExit)
205 def test_invalid_space_style_default_option_value(self, fail, *_):
206 """Test invalid space-style default option value."""
207 with self.mock_config_foomuuri(
208 section='iplist',
209 content="""
210 url_max_size abcd
211 """,
212 ) as config_file:
213 with self.assertRaises(SystemExit):
214 _ = parse_config_iplist(minimal_config())
215
216 fail.assert_called_once_with(
217 f'File {config_file} line 4: Invalid iplist{{}} option value: '
218 'url_max_size=abcd'
219 )
220
221 @unittest.mock.patch('foomuuri.fail', side_effect=SystemExit)
222 def test_invalid_default_option_name(self, fail, *_):
223 """Test invalid default option name."""
224 with self.mock_config_foomuuri(
225 section='iplist',
226 content="""
227 invalid_option=whatever_value
228 """,
229 ) as config_file:
230 with self.assertRaises(SystemExit):
231 _ = parse_config_iplist(minimal_config())
232
233 fail.assert_called_once_with(
234 f'File {config_file} line 4: Invalid iplist{{}} option name: '
235 'invalid_option=whatever_value'
236 )
237
238 @unittest.mock.patch('foomuuri.fail', side_effect=SystemExit)
239 def test_invalid_default_option_value(self, fail, *_):
240 """Test invalid default option value."""
241 with self.mock_config_foomuuri(
242 section='iplist',
243 content="""
244 url_max_size=abcd
245 """,
246 ) as config_file:
247 with self.assertRaises(SystemExit):
248 _ = parse_config_iplist(minimal_config())
249
250 fail.assert_called_once_with(
251 f'File {config_file} line 4: Invalid iplist{{}} option value: '
252 'url_max_size=abcd'
253 )
254
255 def test_start_merge_url_size_options(self, *_):
256 """Test start, merge, url_size options."""
257 with self.mock_config_foomuuri(
258 section='iplist',
259 content="""
260 -start -merge url_max_size=1024
261 @foo https://foob.ar/
262 @bar https://b.ar/ start=no merge=no
263 @baz https://b.az/ start=yes merge=yes url_max_size=2048
264 """,
265 ):
266 iplists = parse_config_iplist(minimal_config())
267 default_options = IPListOptions()
268 # Testing applcation as default options
269 # Asserting applied options differ from default values
270 self.assertNotEqual(
271 iplists['@foo'].options.start, default_options.start
272 )
273 self.assertNotEqual(
274 iplists['@foo'].options.merge, default_options.merge
275 )
276 self.assertNotEqual(
277 iplists['@foo'].options.url_max_size,
278 default_options.url_max_size,
279 )
280 # Asserting applied option values are exactly as set
281 self.assertFalse(iplists['@foo'].options.start)
282 self.assertFalse(iplists['@foo'].options.merge)
283 self.assertFalse(iplists['@foo'].options.dynamic)
284 self.assertEqual(iplists['@foo'].options.url_max_size, 1024)
285 # Alternative start/merge syntax (false)
286 self.assertFalse(iplists['@bar'].options.start)
287 self.assertFalse(iplists['@bar'].options.merge)
288 # Alternative start/merge syntax (true)
289 self.assertTrue(iplists['@baz'].options.start)
290 self.assertTrue(iplists['@baz'].options.merge)
291 # Iplist url_max_size overrides default option
292 self.assertTrue(iplists['@baz'].options.url_max_size, 2048)
293
294 @unittest.mock.patch('foomuuri.warning')
295 def test_iplist_sources_overwrite(self, warning, *_):
296 """Test overwriting of iplist sources."""
297 with self.mock_config_foomuuri(
298 section='iplist',
299 content="""
300 @foo https://foob.ar/
301 @foo https://rabo.of/
302 """,
303 ) as config_file:
304 iplists = parse_config_iplist(minimal_config())
305 self.assertEqual(
306 iplists['@foo'].sources,
307 ['https://rabo.of/'],
308 )
309 warning.assert_called_with(
310 f'File {config_file} line 5: Overwriting iplist "@foo" '
311 'with value "https://rabo.of/"'
312 )
313
314 def test_iplist_sources_append(self, *_):
315 """Test appending of iplist sources."""
316 with self.mock_config_foomuuri(
317 section='iplist',
318 content="""
319 @foo https://foob.ar/
320 @foo + https://rabo.of/
321
322 @bar + https://foo.bar/
323
324 @baz +
325 """,
326 ):
327 iplists = parse_config_iplist(minimal_config())
328 self.assertEqual(
329 iplists['@foo'].sources,
330 ['https://foob.ar/', 'https://rabo.of/'],
331 )
332 self.assertEqual(iplists['@bar'].sources, ['https://foo.bar/'])
333 self.assertEqual(iplists['@baz'].sources, [])
334
335 def test_intermixing_iplist_sources_options(self, *_):
336 """Test itermixing of iplist sources and options."""
337 with self.mock_config_foomuuri(
338 section='iplist',
339 content="""
340 @foo start=no https://foob.ar/ merge=no https://rabo.of/
341 """,
342 ):
343 iplists = parse_config_iplist(minimal_config())
344 default_options = IPListOptions()
345 # Asserting applied options differ from default values
346 self.assertNotEqual(
347 iplists['@foo'].options.start, default_options.start
348 )
349 self.assertNotEqual(
350 iplists['@foo'].options.merge, default_options.merge
351 )
352 # Asserting appled options values are exactly as set
353 self.assertFalse(iplists['@foo'].options.start)
354 self.assertFalse(iplists['@foo'].options.merge)
355 self.assertEqual(
356 iplists['@foo'].sources,
357 ['https://foob.ar/', 'https://rabo.of/'],
358 )
359
360 def test_last_option_priority_wins(self, *_):
361 """Test last option defined for same ipset definition wins."""
362 with self.mock_config_foomuuri(
363 section='iplist',
364 content="""
365 @foo url_timeout=42d
366 @foo url_timeout=69d
367 """,
368 ):
369 iplists = parse_config_iplist(minimal_config())
370 self.assertEqual(
371 iplists['@foo'].options.url_timeout, parse_duration('69d', 0)
372 )
373
374 @unittest.mock.patch('foomuuri.verbose')
375 def test_iplist_name_and_sources_vebose_output(self, verbose, CONFIG, *_):
376 """Test output of iplists name and sources when verbose >= 2."""
377 with self.mock_config_foomuuri(
378 section='iplist',
379 content="""
380 @foo https://foob.ar/
381 @bar https://foo.bar/
382 """,
383 ):
384 CONFIG.verbose = 2
385 _ = parse_config_iplist(minimal_config())
386 verbose.assert_has_calls(
387 [
388 unittest.mock.call('@foo https://foob.ar/'),
389 unittest.mock.call('@bar https://foo.bar/'),
390 ]
391 )
392
393 def test_iplist_dynamic(self, *_):
394 """Test dynamic flag in iplist."""
395 with self.mock_config_foomuuri(
396 section='iplist',
397 content="""
398 @foo dynamic=yes
399 @bar dynamic=yes element_timeout=1m30s
400 """,
401 ):
402 iplists = parse_config_iplist(minimal_config())
403 self.assertTrue(iplists['@foo'].options.dynamic)
404 self.assertTrue(iplists['@bar'].options.dynamic)
405 self.assertEqual(
406 iplists['@foo'].options.element_timeout,
407 parse_duration('0s', -1),
408 )
409 self.assertEqual(
410 iplists['@bar'].options.element_timeout,
411 parse_duration('1m30s', -1),
412 )
413
414 def test_internal_iplist_missing_ok_init(self, _, INTERNAL, *__):
415 """Test INTERNAL.iplist_missing_ok is initialized."""
416 with self.mock_config_foomuuri():
417 self.assertRaises(
418 AttributeError, lambda: INTERNAL.iplist_missing_ok
419 )
420 _ = parse_config_iplist(minimal_config())
421 self.assertEqual(INTERNAL.iplist_missing_ok, set())