refactor(test): Update test parameterization

ref: #733 #730 #729

app/conftest.py

@@ -41,11 +41,48 @@ def enable_db_access_for_all_tests(db):    # pylint: disable=W0613:unused-argume
 
 def pytest_generate_tests(metafunc):
 
-    # test_no_value = {"test_name", "test_value", "expected"} <= set(metafunc.fixturenames)
+    arg_values:list = None
 
-    # test_value = {"test_name", "test_value", "return_value", "expected"} <= set(metafunc.fixturenames)
+    fixture_parameters: list = []
+
+    parameterized_test = False
+
+    parameterized_key: str = None
+
+    if {'parameterized'} <= set(metafunc.fixturenames):
+
+        all_fixture_parameters = metafunc.fixturenames
+
+        fixture_parameters += ['parameterized']
+
+        for i in range(0, len(metafunc.fixturenames)):
+
+            if (
+                str(all_fixture_parameters[i]).startswith('param_')
+                and not str(all_fixture_parameters[i]).startswith('param_key_')
+            ):
+
+                fixture_parameters += [ all_fixture_parameters[i] ]
+
+
+            elif str(all_fixture_parameters[i]).startswith('param_key_'):
+
+                parameterized_key = str( all_fixture_parameters[i] ).replace('param_key_', '')
+
+                if len(fixture_parameters) == 1:
+
+                    fixture_parameters += [ all_fixture_parameters[i] ]
+
+                else:
+
+                    fixture_parameters[1] = all_fixture_parameters[i]
+
+
+        parameterized_test = len(fixture_parameters) > 0
+
+
+    if parameterized_test:
 
-    if {"test_name", "test_value", "expected"} <= set(metafunc.fixturenames):
         values = {}
 
 
@@ -55,26 +92,129 @@ def pytest_generate_tests(metafunc):
 
             for base in reversed(cls.__mro__):
 
-                base_values = getattr(base, "parametrized_test_data", [])
+                base_values = getattr(base, 'parametrized_' + parameterized_key, None)
 
-                if isinstance(base_values, dict):
+                if not isinstance(base_values, dict):
+
+                    continue
+
+                if len(values) == 0 and len(base_values) > 0:
 
                     values.update(base_values)
 
+                    continue
+
+                for key, value in values.items():
+
+                    if(
+                        type(value) is not dict
+                        or key not in base_values
+                    ):
+
+                        continue
+
+                    if key not in values:
+
+                        values.update({
+                            key: base_values[key]
+                        })
+
+                    else:
+
+                        values[key].update( base_values[key] )
+
+
+                for key, value in base_values.items():
+
+                    if key not in values:
+
+                        values.update({
+                            key: base_values[key]
+                        })
+
 
         if values:
 
-            metafunc.parametrize(
-                argnames = (
-                    "test_name", "test_value", "expected"
-                ),
-                argvalues = [
-                    (field, field, expected) for field, expected in values.items()
-                ],
-                ids = [
-                    str( field.replace('.', '_') + '_' + getattr(expected, '__name__', 'None').lower() ) for field, expected in values.items()
-                ],
-            )
+            ids = []
+
+            arg_values:list = []
+
+            for item in values.items():
+
+                ids_name = item[0]
+
+                item_values:tuple = ()
+
+                length = len(item)
+
+                is_key_value: bool = True
+
+                if type(item[1]) is not dict:
+
+                    continue
+
+
+                item_values += ( None, None, item[0])
+
+                for key in fixture_parameters:
+
+                    if key in [ fixture_parameters[0], fixture_parameters[1], fixture_parameters[2], ]:
+                        # these values are already defined in `item_values`
+                        # fixture_parameters[0] = parameterized.
+                        # fixture_parameters[1] = param_key
+                        # fixture_parameters[2] = the dict name
+
+                        continue
+
+                    if(
+                        str(key).startswith('param_')
+                        and not str(key).startswith('param_key_')
+                    ):
+
+                        key = str(key).replace('param_', '')
+
+                        if (
+                            type(item[1]) is not dict
+                            or item[1].get(key, 'key-does_not-exist') == 'key-does_not-exist'
+                        ):
+
+                            item_values = ()
+
+                            continue
+
+
+                        if key in item[1]:
+
+                            item_values += ( item[1][key], )
+
+                            if type(item[1][key]) is type:
+
+                                ids_name += '_' + getattr(item[1][key], '__name__', 'None').lower()
+
+                            else:
+
+                                ids_name += '_' + str(item[1][key]).lower()
+
+
+                if(
+                    len(item_values) > 0
+                    and len(fixture_parameters) == len(item_values)
+                ):
+
+                    arg_values += [ item_values ]
+
+                    ids += [ ids_name, ]
+
+
+            if len(arg_values) > 0:
+
+                metafunc.parametrize(
+                    argnames = [
+                        *fixture_parameters
+                    ],
+                    argvalues = arg_values,
+                    ids = ids,
+                )