1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
|
import json
from pathlib import Path
from typing import Callable, Tuple
import pytest
from config_file.config_file import ConfigFile
from config_file.config_file_path import ConfigFilePath
from config_file.exceptions import ParsingError
from config_file.parsers.abstract_parser import AbstractParser
from config_file.parsers.ini_parser import IniParser
SUPPORTED_FILE_TYPES = ["ini", "json", "yaml", "toml"]
@pytest.fixture(params=SUPPORTED_FILE_TYPES)
def template_and_config_file(
request, template_file
) -> Callable[[str], Tuple[Path, ConfigFile]]:
"""
Fixture that is a wrapper around the template_file
fixture. Using the function returned, we can retrieve
a temporary file that has the contents of the specified
template file as well as a ConfigFile with the template
already passed in.
This fixture will make the test function run once for every
supported file type, each with the corresponding template
in the different file type.
"""
def func(template_name: str = "default"):
template = template_file(request.param, template_name)
return template, ConfigFile(template)
return func
@pytest.fixture(params=SUPPORTED_FILE_TYPES)
def templated_config_file(template_and_config_file) -> Callable[[str], ConfigFile]:
"""
Wrapper around template_and_config_file for when we
only need the ConfigFile and not the template.
"""
def func(template_name: str = "default"):
return template_and_config_file(template_name)[1]
return func
def test_config_file_init_has_correct_path_and_parser(template_and_config_file):
"""
config_file.config_file.ConfigFile.__init__
Ensure that an initialized ConfigFile has the
correct file path and has a parser that is a AbstractParser.
"""
template_file, config = template_and_config_file()
assert config.path == template_file
assert isinstance(config._ConfigFile__parser, AbstractParser)
@pytest.mark.parametrize("file_type", SUPPORTED_FILE_TYPES)
def test_config_file_raises_error_on_malformed_file(template_file, file_type):
"""
config_file.config_file.ConfigFile.__init__
Ensure that a ParsingError is raised on a malformed file.
"""
with pytest.raises(ParsingError):
ConfigFile(template_file(file_type, template_name="invalid"))
def test_config_file_expands_home_tildes_in_path():
"""
config_file.config_file.ConfigFile.__init__
Ensure that a home tilde (~) in a file path passed
to ConfigFile is expanded to the full path.
"""
config_name = "temp.ini"
config_path = "~/" + config_name
try:
Path(config_path).expanduser().touch()
assert ConfigFile(config_path).path == Path.home() / config_name
finally:
Path(config_path).expanduser().unlink()
@pytest.mark.parametrize("path", ["invalid", "invalid.conf"])
def test_config_file_raises_error_on_non_existent_path(path):
"""
config_file.config_file.ConfigFile.__init__
Ensure that when a path to a file that does not exist
that is passed into the constructor, it raises a FileNotFoundError.
"""
with pytest.raises(FileNotFoundError):
ConfigFile(path)
def test_config_file_raises_error_if_path_is_directory():
"""
config_file.config_file.ConfigFile.__init__
Ensure when a path to a directory is passed into
the constructor, it raises a ValueError.
"""
with pytest.raises(ValueError):
ConfigFile(".")
@pytest.mark.parametrize(
"key, value",
[
("header_one.list_key", "different value"),
("header_one", {}),
("header_one.number_key", 1),
],
)
def test_set_can_add_to_or_alter_the_file(templated_config_file, key, value):
"""
config_file.config_file.ConfigFile.set
Ensure that for the keys we can, we retrieve that same value back
(with the exception of ini, which should always be a string).
"""
config = templated_config_file()
config.set(key, value)
# configparser treats everything as a string. Make
# sure we're entering in files in the dict as a str.
if ConfigFilePath(config.path).extension == "ini":
if isinstance(value, (int, float)):
value = str(value)
assert config.get(key) == value
else:
assert config.get(key) == value
def test_config_file_can_save(template_and_config_file):
"""
config_file.config_file.ConfigFile.save
Ensure that altering the configuration file and saving it
writes those changes out to the filesystem.
"""
template_file, config = template_and_config_file()
config.set("header_one.number_key", 25)
config.save()
assert str(config) == template_file.read_text()
def test_restore_original_can_restore_with_calculated_in_path(
templated_config_file, template_original_file
):
"""
config_file.config_file.ConfigFile.restore_original
Ensure that we can restore the "original" configuration
file, using the *calculated* path, after altering the
internal config contents.
Those internal contents and file should be reset to the
original file.
"""
config = templated_config_file()
original_file = template_original_file(config.path)
config.set("header_one.number_key", 5)
config.restore_original()
assert str(config) == original_file.read_text()
assert config.path.read_text() == original_file.read_text()
@pytest.mark.parametrize("file_type", SUPPORTED_FILE_TYPES)
def test_restore_original_can_restore_with_passed_in_path(
template_file, tmp_file, file_type
):
"""
config_file.config_file.ConfigFile.restore_original
Ensure that we can restore the "original" configuration
file, using the *passed* in path, after altering the
internal config contents.
"""
config_file = template_file(file_type)
config = ConfigFile(config_file)
original_file = tmp_file(f"file.{file_type}", config_file.read_text())
original_config = ConfigFile(original_file)
original_config.set("some_new_section.some_new_key", 5)
original_config.save()
config.restore_original(original_path=original_file)
assert str(config) == str(original_config)
assert config.path.read_text() == original_file.read_text()
def test_restore_original_raises_error_on_missing_file(templated_config_file):
"""
config_file.config_file.ConfigFile.restore_original
Ensure that if we try to restore_original without using
the optional original_path argument but we do not
have a file at the calculated default path, a FileNotFoundError
is raised.
"""
config = templated_config_file()
with pytest.raises(FileNotFoundError) as error:
config.restore_original()
assert "The specified config file" in str(error)
assert "does not exist" in str(error)
@pytest.mark.parametrize("key", ["header_one", "header_one.number_key"])
def test_has_can_find_sections_and_keys(templated_config_file, key):
"""
config_file.config_file.ConfigFile.has
Ensure that when a section or key that exists
is passed to has(), it can find it and returns True.
"""
config = templated_config_file()
assert config.has(key)
assert key in config
def test_has_returns_false_for_sections_and_keys_that_do_not_exist(
templated_config_file,
):
"""
config_file.config_file.ConfigFile.has
Ensure that when a section or key that does not exist
is passed to has(), it can't find it and returns False.
"""
config = templated_config_file()
assert not config.has("header_one.blah")
def test_has_can_search_for_a_key_anywhere(templated_config_file):
"""
config_file.config_file.ConfigFile.has
Ensure that the wild=True keyword argument to has()
retrieves if we have the key anywhere in the file.
"""
config = templated_config_file()
assert config.has("list_key", wild=True)
@pytest.mark.parametrize(
"key, value",
[
("header_one.number_key", 0),
("header_two.list_key", [1, 2, 3]),
("header_one", {"number_key": 0}),
],
)
def test_get_can_retrieve_existent_keys(templated_config_file, key, value):
"""
config_file.config_file.ConfigFile.get
Ensure that we can retrieve a section or key
and that it is in its native type (the type that
it was set to).
The one caveat here is the IniParser. The IniParser
uses configparser under the hood which simply always
returns back a string. However, that is not the case
for JsonParser, YamlParser, or TomlParser.
"""
config = templated_config_file()
if isinstance(config._ConfigFile__parser, IniParser):
if type(value) is not dict:
# not a section being retrieved
value = str(value)
else:
# section is being retrieved so it should be a dict
# but the values inside should be strings.
value = json.loads(json.dumps(value), parse_int=str)
assert config.get(key) == value
def test_get_can_parse_all_types(templated_config_file):
"""
config_file.config_file.ConfigFile.get
Ensure we're able to parse out all the different types that
may be used in a configuration file with the parse_types option.
"""
config = templated_config_file(template_name="all_strings")
output = {"list": [], "dict": {}, "num": 5, "bool": False, "float": 5.5}
assert config.get("header", parse_types=True) == output
def test_get_can_use_a_default(templated_config_file):
config = templated_config_file()
assert config.get("does_not_exist", default="default!") == "default!"
def test_get_raises_a_key_error_on_invalid_key(templated_config_file):
config = templated_config_file()
with pytest.raises(KeyError):
config.get("does_not_exist")
@pytest.mark.parametrize("key", ["header_one.number_key", "header_one"])
def test_delete_can_remove_sections_and_keys(templated_config_file, key):
"""
config_file.config_file.ConfigFile.delete
Ensure that we can delete keys and that they are removed
from the internal contents of the ConfigFile.
"""
config = templated_config_file()
config.delete(key)
assert config.has(key) is False
@pytest.mark.parametrize("key", ["", 0, False, {}, "header_one.does_not_exist"])
def test_delete_raises_key_error_on_invalid_input_or_missing_key(
templated_config_file, key
):
"""
config_file.config_file.ConfigFile.delete
Ensure that a KeyError is raised if we
tried to provide a value that is not valid
(like the wrong type so it is an invalid key)
or one that does not exist.
"""
config = templated_config_file()
with pytest.raises(KeyError):
config.delete(key)
def test_keys_can_be_set_with_array_notation(template_and_config_file):
"""
config_file.config_file.ConfigFile.__setitem__
Ensure that the ConfigFile exposes its parsed contents
using an array notation so we can set keys that way.
"""
template_file, config = template_and_config_file()
config["header_one"] = {}
config.save()
assert str(config) == template_file.read_text()
def test_keys_can_be_retrieved_with_array_notation(templated_config_file):
"""
config_file.config_file.ConfigFile.__getitem__
Ensure that the ConfigFile exposes its parsed contents
using an array notation so we can retrieve keys that way.
"""
config = templated_config_file()
assert int(config["header_one"]["number_key"]) == 0
def test_keys_can_be_deleted_with_array_notation(templated_config_file):
"""
config_file.config_file.ConfigFile.__delitem__
Ensure that the ConfigFile exposes its parsed contents
using an array notation so we can delete keys that way.
"""
config = templated_config_file()
del config["header_one"]
with pytest.raises(KeyError):
config["header_one"]
def test_the_config_file_can_be_stringified(template_and_config_file):
"""
config_file.config_file.ConfigFile.__str__
config_file.config_file.ConfigFile.__repr__
Ensure that the stringified version of the config file
is the string version of the file and that the repr also
includes the file path.
"""
template, config = template_and_config_file()
assert template.read_text() == str(config)
assert f"{str(template)}\n\n{str(config)}" == repr(config)
|