def main():
print("--- start test -------------------------")
loader = ModuleLoader()
print(f'Base path is {loader.base_path}')
print(loader.load_class(".tests.clazz.base.module_1"))
print(loader.load_classes("tests.clazz.packageA"))
print(loader.load_classes("tests.clazz.packageA", recursive=True))
print(loader.load_classes("tests.clazz.base.packageD"))
print(loader.load_function("./tests/func/base/func1.py"))
print(loader.load_functions("tests/func/packageA"))
print(loader.load_functions("tests/func/packageA", recursive=True))
print(loader.load_functions("tests/func/base/packageD"))
print("--- end test -------------------------")
class TestAutoLoadModule(unittest.TestCase):
def setUp(self):
print('setup')
self.loader = ModuleLoader()
def test_load_function(self):
result_1 = func1()
result_A_1 = package_a_func1()
result_B_1 = package_b_func1()
result_C_1 = package_c_func1()
# Importing path test runs on class base test.
test_cases = (
("func1", result_1),
("..packageA.package_a_func1", result_A_1),
("../packageA/packageB/package_b_func1", result_B_1),
("/packageC/package_c_func1", result_C_1),
)
for file_name, expected in test_cases:
with self.subTest(file_name=file_name):
self.assertEqual(
self.loader.load_function(file_name)(), expected)
def test_load_functions_by_module(self):
test_cases = (
("func1", {func1()}),
(".packageD.not_load", set()),
(".packageD.package_d_func1",
{package_d_func1(), multiple2(),
multiple3()}),
(".packageD.package_d_func2", {multiple4(),
multiple5()}),
)
for src, expected in test_cases:
with self.subTest(src=src):
classes = self.loader.load_functions(src)
instances = set([clazz() for clazz in classes])
self.assertSetEqual(instances, expected)
def test_load_functions_exclude(self):
basepkg_result = {func3(), func2(), func1()}
test_cases = (
(".", None, basepkg_result),
(".", [], basepkg_result),
(".", ["func3"], {func2(), func1()}),
(".", ["func3", "func2"], {func1()}),
(".", ("func3", "func2"), {func1()}),
)
for src, excludes, expected in test_cases:
with self.subTest(src=src, excludes=excludes):
functions = self.loader.load_functions(src=src,
excludes=excludes)
results = set([function() for function in functions])
self.assertSetEqual(results, expected)
def test_load_functions_complex_path_load(self):
pkgB_result = {package_b_func3(), package_b_func2(), package_b_func1()}
test_cases = (("../packageA/packageB", None, pkgB_result), )
for src, exclude, expected in test_cases:
with self.subTest(src=src, exclude=exclude):
functions = self.loader.load_functions(src, exclude)
results = set([function() for function in functions])
self.assertSetEqual(results, expected)
def test_load_functions_partial_order(self):
# Only ModuleA1 has order.
pkgA_result = (package_a_func2(), package_a_func3(), package_a_func1())
test_cases = (("../packageA/", None, pkgA_result), )
for src, exclude, expected in test_cases:
with self.subTest(src=src, exclude=exclude):
functions = self.loader.load_functions(src, exclude)
results = [function() for function in functions]
if not results[0] == expected[0]:
self.fail()
self.assertSetEqual(set(results[1:]), set(expected[1:]))
def test_load_functions_no_order(self):
# Module1 has other python package.
basepkg_result = {func3(), func2(), func1()}
test_cases = (
("", None, basepkg_result),
("./", ("func3", "func2"), {func1()}),
)
for src, exclude, expected in test_cases:
with self.subTest(src=src, exclude=exclude):
functions = self.loader.load_functions(src, exclude)
results = set([function() for function in functions])
self.assertSetEqual(results, expected)
def test_load_functions_order(self):
pkgC_result = (package_c_func3(), package_c_func2(), package_c_func1())
test_cases = (
("packageC", [], pkgC_result),
("packageC", ["package_c_func2"], (package_c_func3(),
package_c_func1())),
)
for src, exclude, expected in test_cases:
with self.subTest(src=src, exclude=exclude):
functions = self.loader.load_functions(src, exclude)
results = tuple([function() for function in functions])
self.assertTupleEqual(results, expected)
def test_load_functions_raise_error(self):
test_cases = (
("./nonepackage", None),
(".", 123),
(".", [1, 2, 3]),
)
for src, exclude in test_cases:
with self.assertRaises(Exception):
self.loader.load_functions(src, exclude)
def test_load_functions_recursive(self):
pkgA_result = {package_a_func2(), package_a_func3(), package_a_func1()}
pkgB_result = {package_b_func3(), package_b_func2(), package_b_func1()}
test_cases = (
("../packageA", False, pkgA_result),
# expected packageA is ordered, B is random.
("../packageA", True, pkgA_result | pkgB_result),
)
for src, recursive, expected in test_cases:
with self.subTest(src=src, recursive=recursive):
functions = self.loader.load_functions(src,
recursive=recursive)
instances = set([function() for function in functions])
self.assertSetEqual(instances, expected)
def test_load_multiple_functions(self):
basepkg_result = {
package_d_func1(),
multiple2(),
multiple3(),
multiple4(),
multiple5(),
package_d_func3()
}
test_cases = (("packageD", None, basepkg_result), )
for src, exclude, expected in test_cases:
with self.subTest(src=src, exclude=exclude):
functions = self.loader.load_functions(src, exclude)
results = set([function() for function in functions])
self.assertSetEqual(results, expected)
def test_strict_mode(self):
self.loader = ModuleLoader(strict=True)
self.test_load_functions_exclude()
self.test_load_functions_partial_order()
self.test_load_functions_no_order()
self.test_load_functions_order()
def test_strict_mode_raise_error(self):
self.loader = ModuleLoader(strict=True)
test_cases = ("packageD", "packageD.package_d_func1")
for src in test_cases:
with self.assertRaises(LoaderStrictModeError):
try:
self.loader.load_functions(src)
except LoaderStrictModeError as e:
# check message
print(e)
raise e