Update tests to use CodeBase

Since a lot of the functionality driven by the tests has not yet been updated
to use Path, a lot of casts between Path and string are introduced here. These
casts will eventually be removed, but require changes to other functionality.

Signed-off-by: John Pennycook <john.pennycook@intel.com>

Author: Pennycook

tests/basic_asm/test_basic_asm.py

@@ -2,10 +2,10 @@
 # SPDX-License-Identifier: BSD-3-Clause
 
 import logging
-import os
 import unittest
+from pathlib import Path
 
-from codebasin import finder
+from codebasin import CodeBase, finder
 from codebasin.walkers.platform_mapper import PlatformMapper
 
 
@@ -15,25 +15,16 @@ class TestBasicAsm(unittest.TestCase):
     """
 
     def setUp(self):
-        self.rootdir = "./tests/basic_asm/"
+        self.rootdir = Path(__file__).parent.resolve()
         logging.getLogger("codebasin").disabled = True
 
         self.expected_setmap = {frozenset(["CPU"]): 24}
 
     def test_yaml(self):
         """basic_asm/basic_asm.yaml"""
-        files = ["test.s", "test.S", "test.asm"]
-        codebase = {
-            "files": [
-                os.path.realpath(os.path.join(self.rootdir, f)) for f in files
-            ],
-            "platforms": ["CPU"],
-            "exclude_files": set(),
-            "exclude_patterns": [],
-            "rootdir": self.rootdir,
-        }
+        codebase = CodeBase(self.rootdir)
         entries = []
-        for f in codebase["files"]:
+        for f in codebase:
             entries.append(
                 {
                     "file": f,
@@ -43,7 +34,7 @@ def test_yaml(self):
                 },
             )
         configuration = {"CPU": entries}
-        state = finder.find(self.rootdir, codebase, configuration)
+        state = finder.find(str(self.rootdir), codebase, configuration)
         mapper = PlatformMapper(codebase)
         setmap = mapper.walk(state)
         self.assertDictEqual(
@@ -54,17 +45,9 @@ def test_yaml(self):
 
     def test_ptx(self):
         """basic_asm/basic_asm_ptx.yaml"""
-        codebase = {
-            "files": [
-                os.path.realpath(os.path.join(self.rootdir, "test.ptx")),
-            ],
-            "platforms": ["GPU"],
-            "exclude_files": set(),
-            "exclude_patterns": [],
-            "rootdir": self.rootdir,
-        }
+        codebase = CodeBase(self.rootdir)
         entry = {
-            "file": codebase["files"][0],
+            "file": str(self.rootdir / "test.ptx"),
             "defines": [],
             "include_paths": [],
             "include_files": [],
@@ -73,7 +56,7 @@ def test_ptx(self):
         self.assertRaises(
             RuntimeError,
             finder.find,
-            self.rootdir,
+            str(self.rootdir),
             codebase,
             configuration,
         )

tests/basic_fortran/test_basic_fortran.py

@@ -2,10 +2,10 @@
 # SPDX-License-Identifier: BSD-3-Clause
 
 import logging
-import os
 import unittest
+from pathlib import Path
 
-from codebasin import finder
+from codebasin import CodeBase, finder
 from codebasin.walkers.platform_mapper import PlatformMapper
 
 
@@ -15,7 +15,7 @@ class TestBasicFortran(unittest.TestCase):
     """
 
     def setUp(self):
-        self.rootdir = "./tests/basic_fortran/"
+        self.rootdir = Path(__file__).parent.resolve()
         logging.getLogger("codebasin").disabled = True
 
         self.expected_setmap = {
@@ -26,34 +26,26 @@ def setUp(self):
 
     def test_yaml(self):
         """basic_fortran/basic_fortran.yaml"""
-        codebase = {
-            "files": [
-                os.path.realpath(os.path.join(self.rootdir, "test.f90")),
-            ],
-            "platforms": ["CPU", "GPU"],
-            "exclude_files": set(),
-            "exclude_patterns": [],
-            "rootdir": self.rootdir,
-        }
+        codebase = CodeBase(self.rootdir)
         configuration = {
             "CPU": [
                 {
-                    "file": codebase["files"][0],
+                    "file": str(self.rootdir / "test.f90"),
                     "defines": ["CPU"],
                     "include_paths": [],
                     "include_files": [],
                 },
             ],
             "GPU": [
                 {
-                    "file": codebase["files"][0],
+                    "file": str(self.rootdir / "test.f90"),
                     "defines": ["GPU"],
                     "include_paths": [],
                     "include_files": [],
                 },
             ],
         }
-        state = finder.find(self.rootdir, codebase, configuration)
+        state = finder.find(str(self.rootdir), codebase, configuration)
         mapper = PlatformMapper(codebase)
         setmap = mapper.walk(state)
         self.assertDictEqual(

tests/build-dir/test_build_dir.py

@@ -7,7 +7,7 @@
 import unittest
 from pathlib import Path
 
-from codebasin import config, finder
+from codebasin import CodeBase, config, finder
 from codebasin.walkers.platform_mapper import PlatformMapper
 
 
@@ -17,7 +17,7 @@ class TestBuildDirectories(unittest.TestCase):
     """
 
     def setUp(self):
-        self.rootdir = str(Path(__file__).parent)
+        self.rootdir = Path(__file__).parent.resolve()
         logging.getLogger("codebasin").disabled = False
 
     def test_absolute_paths(self):
@@ -26,11 +26,11 @@ def test_absolute_paths(self):
         All "file" fields are absolute paths.
         """
 
-        source = str(Path(__file__).parent.joinpath("foo.cpp"))
+        source = self.rootdir / "foo.cpp"
 
         # CBI only understands how to load compilation databases from file.
         # For now, create temporary files every time we test.
-        dir1 = str(Path(__file__).parent.joinpath("build1/"))
+        dir1 = self.rootdir / "build1/"
         build1 = tempfile.NamedTemporaryFile()
         json1 = [
             {
@@ -42,7 +42,7 @@ def test_absolute_paths(self):
         with open(build1.name, "w") as f:
             json.dump(json1, f)
 
-        dir2 = str(Path(__file__).parent.joinpath("build2/"))
+        dir2 = self.rootdir / "build2/"
         build2 = tempfile.NamedTemporaryFile()
         json2 = [
             {
@@ -54,13 +54,7 @@ def test_absolute_paths(self):
         with open(build2.name, "w") as f:
             json.dump(json2, f)
 
-        codebase = {
-            "files": [source],
-            "platforms": ["one", "two"],
-            "exclude_files": set(),
-            "exclude_patterns": [],
-            "rootdir": self.rootdir,
-        }
+        codebase = CodeBase(self.rootdir)
 
         configuration = {}
         for name, path in [("one", build1.name), ("two", build2.name)]:
@@ -69,7 +63,7 @@ def test_absolute_paths(self):
 
         expected_setmap = {frozenset(["one", "two"]): 1}
 
-        state = finder.find(self.rootdir, codebase, configuration)
+        state = finder.find(str(self.rootdir), codebase, configuration)
         mapper = PlatformMapper(codebase)
         setmap = mapper.walk(state)
         self.assertDictEqual(setmap, expected_setmap, "Mismatch in setmap")
@@ -80,11 +74,11 @@ def test_empty_platform(self):
         This may be a sign that the compilation database has incorrect paths.
         """
 
-        source = str(Path(__file__).parent.joinpath("foo.cpp"))
+        source = self.rootdir / "foo.cpp"
 
         # CBI only understands how to load compilation databases from file.
         # For now, create temporary files every time we test.
-        build = str(Path(__file__).parent.joinpath("build/"))
+        build = self.rootdir / "build/"
         tmp = tempfile.NamedTemporaryFile()
         obj = [
             {

tests/code-base/__init__.py

@@ -0,0 +1,2 @@
+# Copyright (C) 2019-2024 Intel Corporation
+# SPDX-License-Identifier: BSD-3-Clause

tests/code-base/test_code_base.py

@@ -0,0 +1,106 @@
+# Copyright (C) 2019-2024 Intel Corporation
+# SPDX-License-Identifier: BSD-3-Clause
+
+import logging
+import tempfile
+import unittest
+import warnings
+from pathlib import Path
+
+from codebasin import CodeBase
+
+
+class TestCodeBase(unittest.TestCase):
+    """
+    Test CodeBase class.
+    """
+
+    def setUp(self):
+        logging.getLogger("codebasin").disabled = False
+        warnings.simplefilter("ignore", ResourceWarning)
+
+        # Create a temporary codebase spread across two directories
+        self.tmp1 = tempfile.TemporaryDirectory()
+        self.tmp2 = tempfile.TemporaryDirectory()
+        p1 = Path(self.tmp1.name)
+        p2 = Path(self.tmp2.name)
+        open(p1 / "foo.cpp", mode="w").close()
+        open(p1 / "bar.cpp", mode="w").close()
+        open(p1 / "baz.h", mode="w").close()
+        open(p1 / "README.md", mode="w").close()
+        open(p2 / "qux.cpp", mode="w").close()
+        open(p2 / "quux.h", mode="w").close()
+        open(p2 / "README.md", mode="w").close()
+
+    def test_constructor(self):
+        """Check directories and exclude_patterns are handled correctly"""
+        path = Path(self.tmp1.name)
+        codebase = CodeBase(path, exclude_patterns=["*.h"])
+        self.assertTrue(codebase.directories == [str(path)])
+        self.assertTrue(codebase.exclude_patterns == ["*.h"])
+
+    def test_constructor_validation(self):
+        """Check directories and exclude_patterns are valid"""
+
+        with self.assertRaises(TypeError):
+            CodeBase(exclude_patterns="*")
+
+        with self.assertRaises(TypeError):
+            CodeBase(1, "2", 3)
+
+        with self.assertRaises(TypeError):
+            CodeBase(exclude_patterns=[1, "2", 3])
+
+    def test_repr(self):
+        """Check implementation of __repr__"""
+        path = Path(self.tmp1.name)
+        codebase = CodeBase(path, exclude_patterns=["*.h"])
+        self.assertTrue(
+            codebase.__repr__(),
+            f'CodeBase(directories=[{path}], exclude_patterns=[".h"])',
+        )
+
+    def test_contains(self):
+        """Check implementation of __contains__"""
+        p1 = Path(self.tmp1.name)
+        p2 = Path(self.tmp2.name)
+        codebase = CodeBase(p1, p2, exclude_patterns=["*.h"])
+
+        # Files in the temporary directories should be in the code base.
+        self.assertTrue(p1 / "foo.cpp" in codebase)
+        self.assertTrue(p1 / "bar.cpp" in codebase)
+        self.assertTrue(p2 / "qux.cpp" in codebase)
+
+        # Files that match exclude pattern(s) should not be in the code base.
+        self.assertFalse(p1 / "baz.h" in codebase)
+        self.assertFalse(p2 / "quux.h" in codebase)
+
+        # Files that don't exist should not be in the code base.
+        self.assertFalse(p1 / "asdf.cpp" in codebase)
+        self.assertFalse(p2 / "asdf.cpp" in codebase)
+
+        # The temporary directories themselves should not be in the code base.
+        self.assertFalse(p1 in codebase)
+        self.assertFalse(p2 in codebase)
+
+        # Non-source files should not be in the code base.
+        self.assertFalse(p1 / "README.md" in codebase)
+        self.assertFalse(p2 / "README.md" in codebase)
+
+    def test_iterator(self):
+        """Check implementation of __iter__"""
+        p1 = Path(self.tmp1.name)
+        p2 = Path(self.tmp2.name)
+        codebase = CodeBase(p1, p2, exclude_patterns=["*.h"])
+
+        files = [f for f in codebase]
+        expected = [
+            str(p1 / "bar.cpp"),
+            str(p1 / "foo.cpp"),
+            str(p2 / "qux.cpp"),
+        ]
+        self.assertEqual(files, expected)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/commented_directive/test_commented_directive.py

@@ -2,10 +2,10 @@
 # SPDX-License-Identifier: BSD-3-Clause
 
 import logging
-import os
 import unittest
+from pathlib import Path
 
-from codebasin import finder
+from codebasin import CodeBase, finder
 from codebasin.walkers.platform_mapper import PlatformMapper
 
 
@@ -16,7 +16,7 @@ class TestCommentedDirective(unittest.TestCase):
     """
 
     def setUp(self):
-        self.rootdir = "./tests/commented_directive/"
+        self.rootdir = Path(__file__).parent.resolve()
         logging.getLogger("codebasin").disabled = True
 
         self.expected_setmap = {frozenset(["CPU", "GPU"]): 5}
@@ -30,34 +30,26 @@ def count_children_nodes(self, node):
 
     def test_yaml(self):
         """commented_directive/commented_directive.yaml"""
-        codebase = {
-            "files": [
-                os.path.realpath(os.path.join(self.rootdir, "main.cpp")),
-            ],
-            "platforms": ["CPU", "GPU"],
-            "exclude_files": set(),
-            "exclude_patterns": [],
-            "rootdir": self.rootdir,
-        }
+        codebase = CodeBase(self.rootdir)
         configuration = {
             "CPU": [
                 {
-                    "file": codebase["files"][0],
+                    "file": str(self.rootdir / "main.cpp"),
                     "defines": ["CPU"],
                     "include_paths": [],
                     "include_files": [],
                 },
             ],
             "GPU": [
                 {
-                    "file": codebase["files"][0],
+                    "file": str(self.rootdir / "main.cpp"),
                     "defines": ["GPU"],
                     "include_paths": [],
                     "include_files": [],
                 },
             ],
         }
-        state = finder.find(self.rootdir, codebase, configuration)
+        state = finder.find(str(self.rootdir), codebase, configuration)
         mapper = PlatformMapper(codebase)
         setmap = mapper.walk(state)