pyfunceble_config_loader.custom_config = Merge(
pyfunceble_defaults.PERSISTENT_CONFIG).into(
pyfunceble_config_loader.custom_config)
pyfunceble_config_loader.start()
app = FastAPI(
title=assets_defaults.PROJECT_NAME,
description=assets_defaults.PROJECT_DESCRIPTION,
version=__version__,
docs_url=None,
redoc_url=None,
)
with importlib.resources.path("pyfunceble_webworker.data",
"logger.yaml") as logger_config_path:
logger_data = DictHelper.from_yaml_file(str(logger_config_path))
logger_data["handlers"]["file"]["filename"] = os.path.join(
pyfunceble_webworker.storage.CONFIG_DIRECTORY,
logger_data["handlers"]["file"]["filename"],
)
logging.config.dictConfig(logger_data)
if core_settings.BACKEND_CORS_ORIGINS:
app.add_middleware(
CORSMiddleware,
allow_origins=[str(x) for x in core_settings.BACKEND_CORS_ORIGINS],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
class TestDictHelper(unittest.TestCase):
"""
Provides the test of our dictionnary helper.
"""
def setUp(self) -> None:
"""
Setups everything needed for the tests.
"""
self.test_subject = {
"Hello": "world",
"World": {
"world": "hello"
},
"funilrys": ["Fun", "Ilrys"],
"Py": "Funceble",
"pyfunceble": ["funilrys"],
}
self.helper = DictHelper()
def tearDown(self) -> None:
"""
Destroy everything needed by the tests.
"""
del self.test_subject
del self.helper
def test_set_subject_return(self) -> None:
"""
Tests the response from the method which let us set the subject to work
with.
"""
actual = self.helper.set_subject(self.test_subject)
self.assertIsInstance(actual, DictHelper)
def test_set_subject_method(self) -> None:
"""
Tests the method which let us set the subject to work with.
"""
given = self.test_subject
expected = dict(self.test_subject)
self.helper.set_subject(given)
actual = self.helper.subject
self.assertEqual(expected, actual)
def test_set_subject_attribute(self) -> None:
"""
Tests overwritting of the :code:`subject` attribute.
"""
given = self.test_subject
expected = dict(self.test_subject)
self.helper.subject = given
actual = self.helper.subject
self.assertEqual(expected, actual)
def test_set_subject_through_init(self) -> None:
"""
Tests the overwritting of the subject to work through the class
constructor.
"""
given = self.test_subject
expected = dict(self.test_subject)
helper = DictHelper(given)
actual = helper.subject
self.assertEqual(expected, actual)
def test_has_same_key_as(self) -> None:
"""
Tests the method which let us know if the keys of 2 dicts are the same.
"""
origin = {"a": 1, "b": 1}
target = {"a": 1, "b": 2, "c": {"a": 1, "b": 3, "c": {"x": "x"}}}
expected = True
actual = self.helper.set_subject(target).has_same_keys_as(origin)
self.assertEqual(expected, actual)
expected = False
actual = self.helper.set_subject(origin).has_same_keys_as(target)
self.assertEqual(expected, actual)
origin["c"] = {"a": 1, "b": 3, "c": {"x": "x"}}
expected = True
actual = self.helper.set_subject(target).has_same_keys_as(origin)
self.assertEqual(expected, actual)
actual = self.helper.set_subject(origin).has_same_keys_as(target)
self.assertEqual(expected, actual)
del origin["c"]["c"]
expected = False
actual = self.helper.set_subject(origin).has_same_keys_as(target)
self.assertEqual(expected, actual)
def test_remove_key_not_dict(self) -> None:
"""
Tests the method which let us remove a key from a given dict for the
case that the given subject is not a dict.
"""
given = "Hello"
expected = "Hello"
actual = self.helper.set_subject(given).remove_key("Py")
self.assertEqual(expected, actual)
def test_remove_key(self) -> None:
"""
Test the method which let us remove a key from a given dict.
"""
given = copy.deepcopy(self.test_subject)
expected = {
"Hello": "world",
"World": {
"world": "hello"
},
"funilrys": ["Fun", "Ilrys"],
"pyfunceble": ["funilrys"],
}
actual = self.helper.set_subject(given).remove_key("Py")
self.assertEqual(expected, actual)
actual = self.helper.set_subject(given).remove_key(["Py", "test"])
self.assertEqual(expected, actual)
def test_remove_multiple_key(self) -> None:
"""
Tests the method which let us remove a key with multiple key to
remove.
"""
given = copy.deepcopy(self.test_subject)
expected = {
"Hello": "world",
"World": {
"world": "hello"
},
"pyfunceble": ["funilrys"],
}
actual = self.helper.set_subject(given).remove_key(["funilrys", "Py"])
self.assertEqual(expected, actual)
def test_remove_key_not_exists(self) -> None:
"""
Tests the method which let us remove a key for the cas that the key to
remove does not exists.
"""
given = copy.deepcopy(self.test_subject)
expected = copy.deepcopy(self.test_subject)
actual = self.helper.set_subject(given).remove_key("xxx.")
self.assertEqual(expected, actual)
def test_rename_key_not_dict(self) -> None:
"""
Tests the method which let us rename a key of a dict for the case that
the given subject is not a dict.
"""
given = "Hello, World!"
expected = "Hello, World!"
actual = self.helper.set_subject(given).rename_key(
{"Py": "PyFunceble"})
self.assertEqual(expected, actual)
def test_rename_key_strict_single(self) -> None:
"""
Tests the method which let us rename a key for the case that we only
want to strictly rename one key.
"""
given = copy.deepcopy(self.test_subject)
expected = {
"Hello": "world",
"World": {
"world": "hello"
},
"funilrys": ["Fun", "Ilrys"],
"PyFunceble": "Funceble",
"pyfunceble": ["funilrys"],
}
actual = self.helper.set_subject(given).rename_key(
{"Py": "PyFunceble"}, strict=True)
self.assertEqual(expected, actual)
def test_rename_key_not_strict_single(self) -> None:
"""
Tests the method which let us rename a key for the case that we only
want to rename all occurrences of the given key.
"""
given = copy.deepcopy(self.test_subject)
expected = {
"Hello": "world",
"World": {
"world": "hello"
},
"nuilrys": ["Fun", "Ilrys"],
"Py": "Funceble",
"nuceble": ["funilrys"],
}
actual = self.helper.set_subject(given).rename_key({"fun": "nuf"},
strict=False)
self.assertEqual(expected, actual)
def test_to_and_from_json_file(self) -> None:
"""
Tests the method which let us save and load a dict into/from a JSON
file.
"""
output_file = tempfile.NamedTemporaryFile("w", delete=False)
given = copy.deepcopy(self.test_subject)
expected = copy.deepcopy(self.test_subject)
self.helper.set_subject(given).to_json_file(output_file.name)
output_file.seek(0)
actual = self.helper.from_json_file(output_file.name)
self.assertEqual(expected, actual)
output_file.close()
os.remove(output_file.name)
def test_from_json_file_not_json(self) -> None:
"""
Tests the method which let us load a JSON file for the case that no
JSON file is given.
"""
output_file = tempfile.NamedTemporaryFile("wb", delete=False)
output_file.write(b"Hello, World!")
output_file.seek(0)
expected = dict() # pylint: disable=use-dict-literal
actual = self.helper.from_json_file(output_file.name)
self.assertEqual(expected, actual)
output_file.close()
os.remove(output_file.name)
def test_to_json(self) -> None:
"""
Tests the method which let us convert a dict to a JSON and vice-versa.
"""
given = copy.deepcopy(self.test_subject)
expected = """{
"Hello": "world",
"Py": "Funceble",
"World": {
"world": "hello"
},
"funilrys": [
"Fun",
"Ilrys"
],
"pyfunceble": [
"funilrys"
]
}"""
actual = self.helper.set_subject(given).to_json()
self.assertIsInstance(actual, str)
self.assertEqual(expected, actual)
actual = self.helper.from_json(expected)
expected = copy.deepcopy(self.test_subject)
self.assertEqual(expected, actual)
def test_from_json_not_json(self) -> None:
"""
Tests the method which let us convert a JSON to a JSON for the case
that no JSON is given.
"""
given = "Hello, World!"
expected = dict() # pylint: disable=use-dict-literal
actual = self.helper.from_json(given)
self.assertEqual(expected, actual)
def test_from_yaml_file(self) -> None:
"""
Tests the method which let us save and load a dict into/from a YAML file.
"""
output_file = tempfile.NamedTemporaryFile("w", delete=False)
given = copy.deepcopy(self.test_subject)
expected = copy.deepcopy(self.test_subject)
self.helper.set_subject(given).to_yaml_file(output_file.name)
output_file.seek(0)
actual = self.helper.from_yaml_file(output_file.name)
self.assertEqual(expected, actual)
output_file.close()
os.remove(output_file.name)
def test_to_yaml(self) -> None:
"""
Tests the method which let us convert a dict into a YAML and vice-versa.
"""
expected = """Hello: world
Py: Funceble
World:
world: hello
funilrys:
- Fun
- Ilrys
pyfunceble:
- funilrys
"""
given = copy.deepcopy(self.test_subject)
actual = self.helper.set_subject(given).to_yaml()
self.assertEqual(expected, actual)
actual = self.helper.from_yaml(expected)
expected = copy.deepcopy(self.test_subject)
self.assertEqual(expected, actual)
def test_flatten(self) -> None:
"""
Tests the method which let us flatten a dict.
"""
expected = {
"Hello": "world",
"World.world": "hello",
"funilrys": ["Fun", "Ilrys"],
"Py": "Funceble",
"pyfunceble": ["funilrys"],
}
actual = self.helper.set_subject(self.test_subject).flatten()
self.assertEqual(expected, actual)
def test_deeper_flatten(self) -> None:
"""
Tests the method which let us flatten a dict with more level.
"""
given = {
"Hello": "world",
"World": {
"world": "hello"
},
"funilrys": ["Fun", "Ilrys"],
"Py": "Funceble",
"pyfunceble": ["funilrys"],
"this": {
"is": {
"a": {
"test": {
"id": 1,
"deep": {
"hello": {
"world": ["Hello!"]
}
},
"response": "World",
}
},
"b": 1,
"c": [{
"hello": {
"this": {
"is": "a test"
}
}
}],
}
},
"": {
"hello-fun": "world",
"": "hehe"
},
}
expected = {
"Hello": "world",
"World.world": "hello",
"funilrys": ["Fun", "Ilrys"],
"Py": "Funceble",
"pyfunceble": ["funilrys"],
"this.is.a.test.deep.hello.world": ["Hello!"],
"this.is.a.test.id": 1,
"this.is.a.test.response": "World",
"this.is.b": 1,
"this.is.c": [{
"hello": {
"this": {
"is": "a test"
}
}
}],
"..": "hehe",
".hello-fun": "world",
}
actual = self.helper.set_subject(given).flatten()
self.assertEqual(expected, actual)
def test_unflatten(self) -> None:
"""
Tests the method which let us unflatten a dict.
"""
given = {
"Hello": "world",
"World.world": "hello",
"funilrys": ["Fun", "Ilrys"],
"Py": "Funceble",
"pyfunceble": ["funilrys"],
}
expected = dict(self.test_subject)
actual = self.helper.set_subject(given).unflatten()
self.assertEqual(expected, actual)
def test_deeper_unflatten(self) -> None:
"""
Tests the method which let us unflatten a dict with more level.
"""
given = {
"Hello": "world",
"World.world": "hello",
"funilrys": ["Fun", "Ilrys"],
"Py": "Funceble",
"pyfunceble": ["funilrys"],
"this.is.a.test.deep.hello.world": ["Hello!"],
"this.is.a.test.id": 1,
"this.is.a.test.response": "World",
"this.is.b": 1,
"this.is.c": [{
"hello": {
"this": {
"is": "a test"
}
}
}],
"..": "hehe",
".hello-fun": "world",
}
expected = {
"Hello": "world",
"World": {
"world": "hello"
},
"funilrys": ["Fun", "Ilrys"],
"Py": "Funceble",
"pyfunceble": ["funilrys"],
"this": {
"is": {
"a": {
"test": {
"id": 1,
"deep": {
"hello": {
"world": ["Hello!"]
}
},
"response": "World",
}
},
"b": 1,
"c": [{
"hello": {
"this": {
"is": "a test"
}
}
}],
}
},
"": {
"hello-fun": "world",
"": "hehe"
},
}
actual = self.helper.set_subject(given).unflatten()
self.assertEqual(expected, actual)