WIP - adding tests

Crivella · Crivella · commit 1a5ea6434841 · 2025-06-18T12:44:53.000+02:00
diff --git a/easybuild/tools/docs.py b/easybuild/tools/docs.py
@@ -66,6 +66,7 @@
 from easybuild.tools.toolchain.utilities import search_toolchain
 from easybuild.tools.utilities import INDENT_2SPACES, INDENT_4SPACES
 from easybuild.tools.utilities import import_available_modules, mk_md_table, mk_rst_table, nub, quote_str
+from easybuild.tools.entrypoints import EASYBLOCK_ENTRYPOINT_MARK
 
 
 _log = fancylogger.getLogger('tools.docs')
@@ -724,6 +725,9 @@ def gen_list_easyblocks(list_easyblocks, format_strings):
     def add_class(classes, cls):
         """Add a new class, and all of its subclasses."""
         children = cls.__subclasses__()
+        # Filter out possible sublcasses coming from entrypoints as they will be readded letter
+        if not build_option('use_entrypoints', default=False):
+            children = [c for c in children if not hasattr(c, EASYBLOCK_ENTRYPOINT_MARK)]
         classes.update({cls.__name__: {
             'module': cls.__module__,
             'children': sorted([c.__name__ for c in children], key=lambda x: x.lower())
diff --git a/easybuild/tools/entrypoints.py b/easybuild/tools/entrypoints.py
@@ -47,11 +47,9 @@ def get_group_entrypoints(group: str):
                 _log.debug("`get_group_entrypoints` called before BuildOptions initialized, with python < 3.8")
         else:
             if HAVE_ENTRY_POINTS_CLS:
-                eps = entry_points(group=group)
-                res = set(eps)
+                res = set(entry_points(group=group))
             else:
-                eps = entry_points()
-                res = set(eps.get(group, []))
+                res = set(entry_points().get(group, []))
 
     return res
 
diff --git a/easybuild/tools/toolchain/toolchain.py b/easybuild/tools/toolchain/toolchain.py
@@ -168,7 +168,7 @@ class Toolchain:
     CLASS_CONSTANTS_TO_RESTORE = None
     CLASS_CONSTANT_COPIES = {}
 
-    # class method
+    @classmethod
     def _is_toolchain_for(cls, name):
         """see if this class can provide support for toolchain named name"""
         # TODO report later in the initialization the found version
@@ -181,8 +181,6 @@ def _is_toolchain_for(cls, name):
             # is no name is supplied, check whether class can be used as a toolchain
             return bool(getattr(cls, 'NAME', None))
 
-    _is_toolchain_for = classmethod(_is_toolchain_for)
-
     def __init__(self, name=None, version=None, mns=None, class_constants=None, tcdeps=None, modtool=None,
                  hidden=False):
         """
diff --git a/easybuild/tools/toolchain/utilities.py b/easybuild/tools/toolchain/utilities.py
@@ -42,7 +42,7 @@
 import easybuild.tools.toolchain
 from easybuild.tools.entrypoints import (
     get_toolchain_entrypoints, validate_toolchain_entrypoints,
-    TOOLCHAIN_ENTRYPOINT_PREPEND
+    TOOLCHAIN_ENTRYPOINT_PREPEND, TOOLCHAIN_ENTRYPOINT_MARK
 )
 from easybuild.base import fancylogger
 from easybuild.tools.build_log import EasyBuildError
@@ -113,6 +113,10 @@ def search_toolchain(name):
     # obtain all subclasses of toolchain
     found_tcs = nub(get_subclasses(Toolchain))
 
+    # Getting all subclasses will also include toolchains that are registered as entrypoints even if we are not
+    # using the `--use-entrypoints` option, so we filter them out here and re-add them later if needed.
+    found_tcs = [x for x in found_tcs if not hasattr(x, TOOLCHAIN_ENTRYPOINT_MARK)]
+
     invalid_eps = validate_toolchain_entrypoints()
     if invalid_eps:
         _log.warning("Invalid toolchain entrypoints found: %s", ', '.join(invalid_eps))
diff --git a/test/framework/entrypoints.py b/test/framework/entrypoints.py
@@ -0,0 +1,275 @@
+# #
+# Copyright 2013-2025 Ghent University
+#
+# This file is part of EasyBuild,
+# originally created by the HPC team of Ghent University (http://ugent.be/hpc/en),
+# with support of Ghent University (http://ugent.be/hpc),
+# the Flemish Supercomputer Centre (VSC) (https://www.vscentrum.be),
+# Flemish Research Foundation (FWO) (http://www.fwo.be/en)
+# and the Department of Economy, Science and Innovation (EWI) (http://www.ewi-vlaanderen.be/en).
+#
+# https://github.com/easybuilders/easybuild
+#
+# EasyBuild is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation v2.
+#
+# EasyBuild is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with EasyBuild.  If not, see <http://www.gnu.org/licenses/>.
+# #
+"""
+Unit tests for EasyBuild configuration.
+
+@author: Davide Grassano (CECAM - EPFL)
+"""
+
+import os
+import re
+import shutil
+import sys
+import tempfile
+from importlib import reload
+from test.framework.utilities import EnhancedTestCase, TestLoaderFiltered, init_config
+from unittest import TextTestRunner
+
+import easybuild.tools.options as eboptions
+from easybuild.tools.build_log import EasyBuildError
+from easybuild.tools.config import ERROR, IGNORE, WARN, BuildOptions, ConfigurationVariables
+from easybuild.tools.config import build_option, build_path, get_build_log_path, get_log_filename, get_repositorypath
+from easybuild.tools.config import install_path, log_file_format, log_path, source_paths
+from easybuild.tools.config import update_build_option, update_build_options
+from easybuild.tools.config import DEFAULT_PATH_SUBDIRS, init_build_options
+from easybuild.tools.filetools import copy_dir, mkdir, write_file
+from easybuild.tools.options import CONFIG_ENV_VAR_PREFIX
+from easybuild.tools.docs import list_easyblocks, list_software, list_toolchains
+from easybuild.tools.entrypoints import (
+    get_group_entrypoints, HOOKS_ENTRYPOINT, EASYBLOCK_ENTRYPOINT, TOOLCHAIN_ENTRYPOINT,
+    HAVE_ENTRY_POINTS
+)
+from easybuild.framework.easyconfig.easyconfig import get_module_path
+from easybuild.framework.easyblock import EasyBlock
+
+
+if HAVE_ENTRY_POINTS:
+    from importlib.metadata import DistributionFinder, Distribution
+
+
+MOCK_HOOK_EP_NAME = "mock_hook"
+MOCK_EASYBLOCK_EP_NAME = "mock_easyblock"
+MOCK_TOOLCHAIN_EP_NAME = "mock_toolchain"
+
+MOCK_HOOK = "hello_world"
+MOCK_EASYBLOCK = "TestEasyBlock"
+MOCK_TOOLCHAIN = "MockTc"
+
+
+MOCK_EP_FILE=f"""
+from easybuild.tools.entrypoints import register_entrypoint_hooks
+from easybuild.tools.hooks import CONFIGURE_STEP, START
+
+
+@register_entrypoint_hooks(START)
+def {MOCK_HOOK}():
+    print("Hello, World! ----------------------------------------")
+
+##########################################################################
+from easybuild.framework.easyblock import EasyBlock
+from easybuild.tools.entrypoints import register_easyblock_entrypoint
+
+@register_easyblock_entrypoint()
+class {MOCK_EASYBLOCK}(EasyBlock):
+    def configure_step(self):
+        print("{MOCK_EASYBLOCK}: configure_step called.")
+
+    def build_step(self):
+        print("{MOCK_EASYBLOCK}: build_step called.")
+
+    def install_step(self):
+        print("{MOCK_EASYBLOCK}: install_step called.")
+
+    def sanity_check_step(self):
+        print("{MOCK_EASYBLOCK}: sanity_check_step called.")
+
+##########################################################################
+from easybuild.tools.entrypoints import register_toolchain_entrypoint
+from easybuild.tools.toolchain.compiler import DEFAULT_OPT_LEVEL, Compiler
+from easybuild.tools.toolchain.toolchain import SYSTEM_TOOLCHAIN_NAME
+
+TC_CONSTANT_MOCK = "Mock"
+
+class MockCompiler(Compiler):
+    COMPILER_FAMILY = TC_CONSTANT_MOCK
+    SUBTOOLCHAIN = SYSTEM_TOOLCHAIN_NAME
+
+@register_toolchain_entrypoint()
+class {MOCK_TOOLCHAIN}(MockCompiler):
+    NAME = '{MOCK_TOOLCHAIN}'  # Using `...tc` to distinguish toolchain from package
+    COMPILER_MODULE_NAME = [NAME]
+    SUBTOOLCHAIN = [SYSTEM_TOOLCHAIN_NAME]
+"""
+
+
+
+MOCK_EP_META_FILE = f"""
+[{HOOKS_ENTRYPOINT}]
+{MOCK_HOOK_EP_NAME} = {{module}}:hello_world
+
+[{EASYBLOCK_ENTRYPOINT}]
+{MOCK_EASYBLOCK_EP_NAME} = {{module}}:TestEasyBlock
+
+[{TOOLCHAIN_ENTRYPOINT}]
+{MOCK_TOOLCHAIN_EP_NAME} = {{module}}:MockTc
+"""
+
+
+class MockDistribution(Distribution):
+    """Mock distribution for testing entry points."""
+    def __init__(self, module):
+        self.module = module
+
+    def read_text(self, filename):
+        if filename == "entry_points.txt":
+            return MOCK_EP_META_FILE.format(module=self.module)
+
+        if filename == "METADATA":
+            return "Name: mock_hook\nVersion: 0.1.0\n"
+
+class MockDistributionFinder(DistributionFinder):
+    """Mock distribution finder for testing entry points."""
+    def __init__(self, *args, module, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.module = module
+
+    def find_distributions(self, context=None):
+        yield MockDistribution(self.module)
+
+
+class EasyBuildEntrypointsTest(EnhancedTestCase):
+    """Test cases for EasyBuild configuration."""
+
+    tmpdir = None
+
+    def setUp(self):
+        """Set up the test environment."""
+        reload(eboptions)
+        super().setUp()
+        self.tmpdir = tempfile.mkdtemp(prefix='easybuild_test_')
+
+        if HAVE_ENTRY_POINTS:
+            filename_root = "mock"
+            dirname, dirpath = os.path.split(self.tmpdir)
+
+            self.module = '.'.join([dirpath, filename_root])
+            sys.path.insert(0, dirname)
+            sys.meta_path.insert(0, MockDistributionFinder(module=self.module))
+
+            # Create a mock entry point for testing
+            mock_hook_file = os.path.join(self.tmpdir, f'{filename_root}.py')
+            write_file(mock_hook_file, MOCK_EP_FILE)
+
+    def tearDown(self):
+        """Clean up the test environment."""
+        if self.tmpdir and os.path.isdir(self.tmpdir):
+            shutil.rmtree(self.tmpdir)
+
+        if HAVE_ENTRY_POINTS:
+            # Remove the entry point from the working set
+            torm = []
+            for idx,cls in enumerate(sys.meta_path):
+                if isinstance(cls, MockDistributionFinder):
+                    torm.append(idx)
+            for idx in reversed(torm):
+                del sys.meta_path[idx]
+
+    def test_entrypoints_get_group_too_old_python(self):
+        """Test retrieving entrypoints for a specific group with too old Python version."""
+        if HAVE_ENTRY_POINTS:
+            self.skipTest("Entry points available in this Python version")
+        self.assertRaises(EasyBuildError, get_group_entrypoints, HOOKS_ENTRYPOINT)
+
+    def test_entrypoints_get_group(self):
+        """Test retrieving entrypoints for a specific group."""
+        if not HAVE_ENTRY_POINTS:
+            self.skipTest("Entry points not available in this Python version")
+
+        expected = {
+            HOOKS_ENTRYPOINT: MOCK_HOOK_EP_NAME,
+            EASYBLOCK_ENTRYPOINT: MOCK_EASYBLOCK_EP_NAME,
+            TOOLCHAIN_ENTRYPOINT: MOCK_TOOLCHAIN_EP_NAME,
+        }
+
+        # init_config()
+        for group in [HOOKS_ENTRYPOINT, EASYBLOCK_ENTRYPOINT, TOOLCHAIN_ENTRYPOINT]:
+            epts = get_group_entrypoints(group)
+            self.assertIsInstance(epts, set, f"Expected set for group {group}")
+            self.assertEqual(len(epts), 0, f"Expected non-empty set for group {group}")
+
+        init_config(build_options={'use_entrypoints': True})
+        for group in [HOOKS_ENTRYPOINT, EASYBLOCK_ENTRYPOINT, TOOLCHAIN_ENTRYPOINT]:
+            epts = get_group_entrypoints(group)
+            self.assertIsInstance(epts, set, f"Expected set for group {group}")
+            self.assertGreater(len(epts), 0, f"Expected non-empty set for group {group}")
+
+            loaded_names = [ep.name for ep in epts]
+            self.assertIn(expected[group], loaded_names, f"Expected entry point {expected[group]} in group {group}")
+
+    def test_entrypoints_list_easyblocks(self):
+        """
+        Tests for list_easyblocks function with entry points enabled.
+        """
+        if not HAVE_ENTRY_POINTS:
+            self.skipTest("Entry points not available in this Python version")
+
+        # init_config()
+        # print('-------', build_option('use_entrypoints', default='1234'))
+        txt = list_easyblocks()
+        self.assertNotIn("TestEasyBlock", txt, "TestEasyBlock should not be listed without entry points enabled")
+
+        init_config(build_options={'use_entrypoints': True})
+        txt = list_easyblocks()
+        self.assertIn("TestEasyBlock", txt, "TestEasyBlock should be listed with entry points enabled")
+
+    def test_entrypoints_list_toolchains(self):
+        """
+        Tests for list_toolchains function with entry points enabled.
+        """
+        if not HAVE_ENTRY_POINTS:
+            self.skipTest("Entry points not available in this Python version")
+
+        # init_config()
+        txt = list_toolchains()
+        self.assertNotIn(MOCK_TOOLCHAIN, txt, f"{MOCK_TOOLCHAIN} should not be listed without entry points enabled")
+
+        init_config(build_options={'use_entrypoints': True})
+
+        txt = list_toolchains()
+        self.assertIn(MOCK_TOOLCHAIN, txt, f"{MOCK_TOOLCHAIN} should be listed with entry points enabled")
+
+    def test_entrypoints_get_module_path(self):
+        """
+        Tests for get_module_path function with entry points enabled.
+        """
+        if not HAVE_ENTRY_POINTS:
+            self.skipTest("Entry points not available in this Python version")
+
+        module_path = get_module_path(MOCK_EASYBLOCK)
+        self.assertIn('.generic.', module_path, "Module path should contain '.generic.'")
+
+        init_config(build_options={'use_entrypoints': True})
+        # Reload the EasyBlock module to ensure it is recognized
+        module_path = get_module_path(MOCK_EASYBLOCK)
+        self.assertEqual(module_path, self.module, "Module path should match the mock module path")
+
+
+def suite():
+    return TestLoaderFiltered().loadTestsFromTestCase(EasyBuildEntrypointsTest, sys.argv[1:])
+
+
+if __name__ == '__main__':
+    res = TextTestRunner(verbosity=1).run(suite())
+    sys.exit(len(res.failures))
diff --git a/test/framework/suite.py b/test/framework/suite.py
@@ -52,6 +52,7 @@
 import test.framework.easyconfigversion as ev
 import test.framework.easystack as es
 import test.framework.ebconfigobj as ebco
+import test.framework.entrypoints as epts
 import test.framework.environment as env
 import test.framework.docs as d
 import test.framework.filetools as f
@@ -119,7 +120,7 @@
 
 # call suite() for each module and then run them all
 # note: make sure the options unit tests run first, to avoid running some of them with a readily initialized config
-tests = [gen, d, bl, o, r, ef, ev, ebco, ep, e, mg, m, mt, f, run, a, robot, b, v, g, tcv, tc, t, c, s, lic, f_c,
+tests = [gen, d, bl, o, r, ef, ev, ebco, ep, epts, e, mg, m, mt, f, run, a, robot, b, v, g, tcv, tc, t, c, s, lic, f_c,
          tw, p, i, pkg, env, et, st, h, ct, lib, u, es, ou]
 
 SUITE = unittest.TestSuite([x.suite() for x in tests])
