"""Test the config system."""
from __future__ import annotations
import contextlib
import itertools
import pathlib
import random
import string
import sys
from typing import Any, Iterable, List, cast
import pytest
from pytest import mark
# isort: split
sys.path += [str(pathlib.Path(__file__).parent.parent.resolve()), "."]
print(sys.path)
from _old_config import old_config # noqa: E402
from config import LinuxConfig, config # noqa: E402
def _fuzz_list(length: int) -> List[str]:
out = []
for _ in range(length):
out.append(_fuzz_generators[str](random.randint(0, 1337)))
return cast(List[str], out)
_fuzz_generators = { # Type annotating this would be a nightmare.
int: lambda i: random.randint(min(0, i), max(0, i)),
# This doesn't cover unicode, or random bytes. Use them at your own peril
str: lambda l: "".join(random.choice(string.ascii_letters + string.digits + '\r\n') for _ in range(l)),
bool: lambda _: bool(random.choice((True, False))),
list: _fuzz_list,
}
def _get_fuzz(_type: Any, num_values=50, value_length=(0, 10)) -> list:
return [_fuzz_generators[_type](random.randint(*value_length)) for _ in range(num_values)]
int_tests = [0, 1, 2, 3, (1 << 32)-1, -1337]
string_tests = [
"test", "", "this\nis\na\ntest", "orange sidewinder", "needs \\ more backslashes\\", "\\; \\n", r"\\\\ \\\\; \\\\n",
r"entry with escapes \\ \\; \\n"
]
list_tests = [
["test"],
["multiple", "entries"],
["multiple", "entries", "with", "", "blanks"],
["entry", "that ends", "in a", ""],
["entry with \n", "newlines\nin", "weird\nplaces"],
[r"entry with escapes \\ \\; \\n"],
[r"\\\\ \\\\; \\\\n"]
]
bool_tests = [True, False]
big_int = int(0xFFFFFFFF) # 32 bit int
def _make_params(args: List[Any], id_name: str = 'random_test_{i}') -> list:
return [pytest.param(x, id=id_name.format(i=i)) for i, x in enumerate(args)]
def _build_test_list(static_data, random_data, random_id_name='random_test_{i}') -> Iterable:
return itertools.chain(static_data, _make_params(random_data, id_name=random_id_name))
class TestNewConfig:
"""Test the new config with an array of hand picked and random data."""
def __update_linuxconfig(self) -> None:
"""On linux config uses ConfigParser, which doesn't update from disk changes. Force the update here."""
if isinstance(config, LinuxConfig) and config.config is not None:
config.config.read(config.filename)
@mark.parametrize("i", _build_test_list(int_tests, _get_fuzz(int, value_length=(-big_int, big_int))))
def test_ints(self, i: int) -> None:
"""Save int and then unpack it again."""
if sys.platform == 'win32':
i = abs(i)
name = f"int_test_{i}"
config.set(name, i)
config.save()
self.__update_linuxconfig()
assert i == config.get_int(name)
config.delete(name)
@mark.parametrize("string", _build_test_list(string_tests, _get_fuzz(str, value_length=(0, 512))))
def test_string(self, string: str) -> None:
"""Save a string and then ask for it back."""
name = f'str_test_{hash(string)}'
config.set(name, string)
config.save()
self.__update_linuxconfig()
assert string == config.get_str(name)
config.delete(name)
@mark.parametrize("lst", _build_test_list(list_tests, _get_fuzz(list)))
def test_list(self, lst: List[str]) -> None:
"""Save a list and then ask for it back."""
name = f'list_test_{ hash("".join(lst)) }'
config.set(name, lst)
config.save()
self.__update_linuxconfig()
assert lst == config.get_list(name)
config.delete(name)
@mark.parametrize('b', bool_tests)
def test_bool(self, b: bool) -> None:
"""Save a bool and ask for it back."""
name = str(b)
config.set(name, b)
config.save()
self.__update_linuxconfig()
assert b == config.get_bool(name)
config.delete(name)
def test_get_no_error(self) -> None:
"""Regression test to ensure that get() doesn't throw a TypeError."""
name = 'test-get'
config.set(name, '1337')
config.save()
self.__update_linuxconfig()
with pytest.deprecated_call():
res = config.get(name)
assert res == '1337'
config.delete(name)
class TestOldNewConfig:
"""Tests going through the old config and out the new config."""
KEY_PREFIX = 'oldnew_'
def teardown_method(self) -> None:
"""
Teardown for all config tests to save out configs.
It is expected that tests have cleaned up whatever keys they have aded.
This is here to ensure that a save out happens for configs that need it.
"""
old_config.save()
config.save()
def cleanup_entry(self, entry: str) -> None:
"""Remove the given key, on both sides if on linux."""
config.delete(entry)
if sys.platform == 'linux':
old_config.delete(entry)
def __update_linuxconfig(self) -> None:
"""On linux config uses ConfigParser, which doesn't update from disk changes. Force the update here."""
if isinstance(config, LinuxConfig) and config.config is not None:
config.config.read(config.filename)
@mark.parametrize("i", _build_test_list(int_tests, _get_fuzz(int, 50, (-big_int, big_int))))
def test_int(self, i: int) -> None:
"""Save an int though the old config, recall it using the new config."""
if sys.platform == 'win32':
i = abs(i)
name = self.KEY_PREFIX + f'int_{i}'
old_config.set(name, i)
old_config.save()
self.__update_linuxconfig()
res = config.get_int(name)
with contextlib.ExitStack() as stack:
stack.callback(self.cleanup_entry, name)
assert res == i
@mark.parametrize("string", _build_test_list(string_tests, _get_fuzz(str, value_length=(0, 512))))
def test_string(self, string: str) -> None:
"""Save a string though the old config, recall it using the new config."""
string = string.replace("\r", "") # The old config does _not_ support \r in its entries. We do.
name = self.KEY_PREFIX + f'string_{hash(string)}'
old_config.set(name, string)
old_config.save()
self.__update_linuxconfig()
res = config.get_str(name)
with contextlib.ExitStack() as stack:
stack.callback(self.cleanup_entry, name)
assert res == string
@mark.parametrize("lst", _build_test_list(list_tests, _get_fuzz(list)))
def test_list(self, lst: List[str]) -> None:
"""Save a list though the old config, recall it using the new config."""
lst = [x.replace("\r", "") for x in lst] # OldConfig on linux fails to store these correctly
if sys.platform == 'win32':
# old conf on windows replaces empty entries with spaces as a workaround for a bug. New conf does not
# So insert those spaces here, to ensure that it works otherwise.
lst = [e if len(e) > 0 else ' ' for e in lst]
name = self.KEY_PREFIX + f'list_test_{ hash("".join(lst)) }'
old_config.set(name, lst)
old_config.save()
self.__update_linuxconfig()
res = config.get_list(name)
with contextlib.ExitStack() as stack:
stack.callback(self.cleanup_entry, name)
assert res == lst
@mark.skipif(sys.platform == 'win32', reason="Old Windows config does not support bool types")
@mark.parametrize("b", bool_tests)
def test_bool(self, b: bool) -> None:
"""Save a bool though the old config, recall it using the new config."""
name = str(b)
old_config.set(name, b)
old_config.save()
self.__update_linuxconfig()
with contextlib.ExitStack() as stack:
stack.callback(self.cleanup_entry, name)
assert config.get_bool(name) == b