Add test for --relative-paths

Author: AA-Turner

Lib/test/test_build_details.py

@@ -1,12 +1,34 @@
+import importlib
 import json
 import os
+import os.path
 import sys
 import sysconfig
 import string
 import unittest
+from pathlib import Path
 
 from test.support import is_android, is_apple_mobile, is_wasm32
 
+BASE_PATH = Path(
+    __file__,  # Lib/test/test_build_details.py
+    '..',  # Lib/test
+    '..',  # Lib
+    '..',  # <src/install dir>
+).resolve()
+MODULE_PATH = BASE_PATH / 'Tools' / 'build' / 'generate-build-details.py'
+
+try:
+    # Import "generate-build-details.py" as "generate_build_details"
+    spec = importlib.util.spec_from_file_location(
+        "generate_build_details", MODULE_PATH
+    )
+    generate_build_details = importlib.util.module_from_spec(spec)
+    sys.modules["generate_build_details"] = generate_build_details
+    spec.loader.exec_module(generate_build_details)
+except ImportError:
+    generate_build_details = None
+
 
 class FormatTestsBase:
     @property
@@ -31,16 +53,15 @@ def key(self, name):
             value = value[part]
         return value
 
-    def test_parse(self):
-        self.data
-
     def test_top_level_container(self):
         self.assertIsInstance(self.data, dict)
         for key, value in self.data.items():
             with self.subTest(key=key):
-                if key in ('schema_version', 'base_prefix', 'base_interpreter', 'platform'):
+                if key in ('schema_version', 'base_prefix', 'base_interpreter',
+                           'platform'):
                     self.assertIsInstance(value, str)
-                elif key in ('language', 'implementation', 'abi', 'suffixes', 'libpython', 'c_api', 'arbitrary_data'):
+                elif key in ('language', 'implementation', 'abi', 'suffixes',
+                             'libpython', 'c_api', 'arbitrary_data'):
                     self.assertIsInstance(value, dict)
 
     def test_base_prefix(self):
@@ -71,15 +92,20 @@ def test_language_version_info(self):
         self.assertEqual(len(value), sys.version_info.n_fields)
         for part_name, part_value in value.items():
             with self.subTest(part=part_name):
-                self.assertEqual(part_value, getattr(sys.version_info, part_name))
+                sys_version_value = getattr(sys.version_info, part_name)
+                self.assertEqual(part_value, sys_version_value)
 
     def test_implementation(self):
+        impl_ver = sys.implementation.version
         for key, value in self.key('implementation').items():
             with self.subTest(part=key):
                 if key == 'version':
-                    self.assertEqual(len(value), len(sys.implementation.version))
+                    self.assertEqual(len(value), len(impl_ver))
                     for part_name, part_value in value.items():
-                        self.assertEqual(getattr(sys.implementation.version, part_name), part_value)
+                        assert not isinstance(sys.implementation.version, dict)
+                        getattr(sys.implementation.version, part_name)
+                        sys_implementation_value = getattr(impl_ver, part_name)
+                        self.assertEqual(sys_implementation_value, part_value)
                 else:
                     self.assertEqual(getattr(sys.implementation, key), value)
 
@@ -101,15 +127,16 @@ def location(self):
                 dirname = sysconfig.get_config_var('BINDIR')
             else:
                 projectdir = sysconfig.get_config_var('projectbase')
-                with open(os.path.join(projectdir, 'pybuilddir.txt')) as f:
+                pybuilddir = os.path.join(projectdir, 'pybuilddir.txt')
+                with open(pybuilddir, encoding='utf-8') as f:
                     dirname = os.path.join(projectdir, f.read())
         else:
             dirname = sysconfig.get_path('stdlib')
         return os.path.join(dirname, 'build-details.json')
 
     @property
     def contents(self):
-        with open(self.location, 'r') as f:
+        with open(self.location, 'r', encoding='utf-8') as f:
             return f.read()
 
     @needs_installed_python
@@ -149,5 +176,62 @@ def test_c_api(self):
         self.assertTrue(os.path.exists(os.path.join(value['pkgconfig_path'], f'python-{version}.pc')))
 
 
+@unittest.skipIf(
+    generate_build_details is None,
+    "Failed to import generate-build-details"
+)
+class BuildDetailsRelativePathsTests(unittest.TestCase):
+    @property
+    def build_details_absolute_paths(self):
+        data = generate_build_details.generate_data(schema_version='1.0')
+        return json.loads(json.dumps(data))
+
+    @property
+    def build_details_relative_paths(self):
+        data = self.build_details_absolute_paths
+        generate_build_details.make_paths_relative(data, config_path=None)
+        return data
+
+    def test_round_trip(self):
+        data_abs_path = self.build_details_absolute_paths
+        data_rel_path = self.build_details_relative_paths
+
+        self.assertEqual(data_abs_path['base_prefix'],
+                         data_rel_path['base_prefix'])
+
+        base_prefix = data_abs_path['base_prefix']
+
+        top_level_keys = ('base_interpreter',)
+        for key in top_level_keys:
+            self.assertEqual(key in data_abs_path, key in data_rel_path)
+            if key not in data_abs_path:
+                continue
+
+            abs_rel_path = os.path.join(base_prefix, data_rel_path[key])
+            abs_rel_path = os.path.normpath(abs_rel_path)
+            self.assertEqual(data_abs_path[key], abs_rel_path)
+
+        second_level_keys = (
+            ('libpython', 'dynamic'),
+            ('libpython', 'dynamic_stableabi'),
+            ('libpython', 'static'),
+            ('c_api', 'headers'),
+            ('c_api', 'pkgconfig_path'),
+
+        )
+        for part, key in second_level_keys:
+            self.assertEqual(part in data_abs_path, part in data_rel_path)
+            if part not in data_abs_path:
+                continue
+            self.assertEqual(key in data_abs_path[part],
+                             key in data_rel_path[part])
+            if key not in data_abs_path[part]:
+                continue
+
+            abs_rel_path = os.path.join(base_prefix, data_rel_path[part][key])
+            abs_rel_path = os.path.normpath(abs_rel_path)
+            self.assertEqual(data_abs_path[part][key], abs_rel_path)
+
+
 if __name__ == '__main__':
     unittest.main()

Tools/build/generate-build-details.py

@@ -55,7 +55,7 @@ def generate_data(schema_version: str) -> collections.defaultdict[str, Any]:
     data['language']['version'] = sysconfig.get_python_version()
     data['language']['version_info'] = version_info_to_dict(sys.version_info)
 
-    data['implementation'] = vars(sys.implementation)
+    data['implementation'] = vars(sys.implementation).copy()
     data['implementation']['version'] = version_info_to_dict(sys.implementation.version)
     # Fix cross-compilation
     if '_multiarch' in data['implementation']: