83 lines
3.6 KiB
Python
83 lines
3.6 KiB
Python
import os
|
|
import unittest
|
|
from io import StringIO
|
|
from tempfile import TemporaryFile
|
|
from typing import Any, Dict, List, cast
|
|
|
|
import Utils
|
|
from settings import Settings, Group
|
|
|
|
|
|
class TestIDs(unittest.TestCase):
|
|
yaml_options: Dict[Any, Any]
|
|
|
|
@classmethod
|
|
def setUpClass(cls) -> None:
|
|
with TemporaryFile("w+", encoding="utf-8") as f:
|
|
Settings(None).dump(f)
|
|
f.seek(0, os.SEEK_SET)
|
|
yaml_options = Utils.parse_yaml(f.read())
|
|
assert isinstance(yaml_options, dict)
|
|
cls.yaml_options = yaml_options
|
|
|
|
def test_utils_in_yaml(self) -> None:
|
|
"""Tests that the auto generated host.yaml has default settings in it"""
|
|
for option_key, option_set in Settings(None).items():
|
|
with self.subTest(option_key):
|
|
self.assertIn(option_key, self.yaml_options)
|
|
for sub_option_key in option_set:
|
|
self.assertIn(sub_option_key, self.yaml_options[option_key])
|
|
|
|
def test_yaml_in_utils(self) -> None:
|
|
"""Tests that the auto generated host.yaml shows up in reference calls"""
|
|
utils_options = Settings(None)
|
|
for option_key, option_set in self.yaml_options.items():
|
|
with self.subTest(option_key):
|
|
self.assertIn(option_key, utils_options)
|
|
for sub_option_key in option_set:
|
|
self.assertIn(sub_option_key, utils_options[option_key])
|
|
|
|
|
|
class TestSettingsDumper(unittest.TestCase):
|
|
def test_string_format(self) -> None:
|
|
"""Test that dumping a string will yield the expected output"""
|
|
# By default, pyyaml has automatic line breaks in strings and quoting is optional.
|
|
# What we want for consistency instead is single-line strings and always quote them.
|
|
# Line breaks have to become \n in that quoting style.
|
|
class AGroup(Group):
|
|
key: str = " ".join(["x"] * 60) + "\n" # more than 120 chars, contains spaces and a line break
|
|
|
|
with StringIO() as writer:
|
|
AGroup().dump(writer, 0)
|
|
expected_value = AGroup.key.replace("\n", "\\n")
|
|
self.assertEqual(writer.getvalue(), f"key: \"{expected_value}\"\n",
|
|
"dumped string has unexpected formatting")
|
|
|
|
def test_indentation(self) -> None:
|
|
"""Test that dumping items will add indentation"""
|
|
# NOTE: we don't care how many spaces there are, but it has to be a multiple of level
|
|
class AList(List[Any]):
|
|
__doc__ = None # make sure we get no doc string
|
|
|
|
class AGroup(Group):
|
|
key: AList = cast(AList, ["a", "b", [1]])
|
|
|
|
for level in range(3):
|
|
with StringIO() as writer:
|
|
AGroup().dump(writer, level)
|
|
lines = writer.getvalue().split("\n", 5)
|
|
key_line = lines[0]
|
|
key_spaces = len(key_line) - len(key_line.lstrip(" "))
|
|
value_lines = lines[1:-1]
|
|
value_spaces = [len(value_line) - len(value_line.lstrip(" ")) for value_line in value_lines]
|
|
if level == 0:
|
|
self.assertEqual(key_spaces, 0)
|
|
else:
|
|
self.assertGreaterEqual(key_spaces, level)
|
|
self.assertEqual(key_spaces % level, 0)
|
|
self.assertGreaterEqual(value_spaces[0], key_spaces) # a
|
|
self.assertEqual(value_spaces[1], value_spaces[0]) # b
|
|
self.assertEqual(value_spaces[2], value_spaces[0]) # start of sub-list
|
|
self.assertGreater(value_spaces[3], value_spaces[0],
|
|
f"{value_lines[3]} should have more indentation than {value_lines[0]} in {lines}")
|