Updated tests per review

Author: VisLab

CHANGELOG.md

@@ -11,7 +11,7 @@ Previously, loading a schema whose version existed only in the prerelease cache
 - Removed the `check_prerelease` parameter from `load_schema_version()`, `load_schema()`, `from_string()`, and `from_dataframes()` in `hed_schema_io.py`.
 - Removed the parameter from `SchemaLoader` (base class) and all subclasses (`SchemaLoaderXML`, `SchemaLoaderWiki`, `SchemaLoaderJSON`, `SchemaLoaderDF`).
 - `get_hed_version_path()` in `hed_cache.py` now always searches both regular and prerelease directories (regular first).
-- `get_hed_versions()` in `hed_cache.py` now defaults to `check_prerelease=True`; the compliance checker explicitly passes `False` to compare against released versions only.
+- `get_hed_versions()` in `hed_cache.py` now defaults to `check_prerelease=True`. **This is a silent API change**: external callers that omitted `check_prerelease` will now receive prerelease versions. Internal callers that need released-only versions (compliance checker, `deprecatedFrom` validation, hedId comparison) explicitly pass `check_prerelease=False`.
 - Default schema version is now resolved dynamically from the cache (highest released version) instead of being hardcoded, so new schema releases no longer require a code change.
 - `check_schema_loading.py` simplified — removed `_is_prerelease_partner()` helper.
 - `run_loading_check()` now raises `ValueError` immediately for mutually exclusive flag combinations (`prerelease_only` + `exclude_prereleases`, or `library_filter` + `standard_only`), consistent with the existing CLI-level validation.

hed/schema/hed_schema_io.py

@@ -358,12 +358,12 @@ def _load_schema_version_sub(xml_version, schema_namespace="", xml_folder=None,
     """
     if not xml_version:
         versions = hed_cache.get_hed_versions(xml_folder, check_prerelease=False)
-        if versions:
+        if isinstance(versions, list) and versions:
             xml_version = versions[0]
         else:
             raise HedFileError(
                 HedExceptions.FILE_NOT_FOUND,
-                "No HED schema versions found in cache. Ensure schemas are installed or cached.",
+                "No HED standard schema versions found in cache. Ensure schemas are installed or cached.",
                 "",
             )
 

hed/schema/schema_validation/attribute_validators.py

@@ -194,7 +194,7 @@ def tag_is_deprecated_check(hed_schema, tag_entry, attribute_name) -> list:
     library_name = tag_entry.has_attribute(HedKey.InLibrary, return_value=True)
     if not library_name and not hed_schema.with_standard:
         library_name = hed_schema.library
-    all_versions = get_hed_versions(library_name=library_name)
+    all_versions = get_hed_versions(library_name=library_name, check_prerelease=False)
     if deprecated_version:
         library_version = schema_version_for_library(hed_schema, library_name)
         # Allow the current schema version even if it's prerelease (not yet in known versions)

hed/schema/schema_validation/hed_id_validator.py

@@ -50,7 +50,7 @@ def __init__(self, hed_schema):
     @staticmethod
     def _get_previous_version(version, library):
         current_version = Version(version)
-        all_schema_versions = get_hed_versions(library_name=library)
+        all_schema_versions = get_hed_versions(library_name=library, check_prerelease=False)
         for old_version in all_schema_versions:
             if Version(old_version) < current_version:
                 prev_version = old_version

spec_tests/test_hed_cache.py

@@ -79,15 +79,20 @@ def test_get_hed_versions_library(self):
         self.assertTrue(len(cached_versions) > 0)
 
     def test_get_hed_versions_library_prerelease(self):
-        all_versions = hed_cache.get_hed_versions(self.hed_cache_dir, library_name="score")
-        released_only = hed_cache.get_hed_versions(self.hed_cache_dir, library_name="score", check_prerelease=False)
-        self.assertIsInstance(all_versions, list)
-        self.assertTrue(len(all_versions) > 0)
-        self.assertGreater(
-            len(all_versions),
-            len(released_only),
-            "Default (prerelease included) should return more versions than released-only",
-        )
+        # Plant a known prerelease file so this test is deterministic
+        prerelease_dir = os.path.join(self.hed_cache_dir, "prerelease")
+        os.makedirs(prerelease_dir, exist_ok=True)
+        fake_prerelease = os.path.join(prerelease_dir, "HED_score_0.0.1-alpha.1.xml")
+        try:
+            with open(fake_prerelease, "w") as f:
+                f.write("")
+            all_versions = hed_cache.get_hed_versions(self.hed_cache_dir, library_name="score")
+            released_only = hed_cache.get_hed_versions(self.hed_cache_dir, library_name="score", check_prerelease=False)
+            self.assertIsInstance(all_versions, list)
+            self.assertIn("0.0.1-alpha.1", all_versions)
+            self.assertNotIn("0.0.1-alpha.1", released_only)
+        finally:
+            os.remove(fake_prerelease)
 
     def test_sort_version_list(self):
         valid_versions = ["8.1.0", "8.0.0", "8.0.0-alpha.1", "7.1.1", "1.0.0"]

tests/schema/test_hed_schema_io.py

@@ -88,6 +88,28 @@ def test_verify_utf8_dupe(self):
         self.assertTrue(schema.get_tag_entry("Wßord"))
         self.assertTrue(schema.get_tag_entry("Wssord"))
 
+    def test_load_schema_version_default_resolves_latest(self):
+        """Test that empty version resolves to the highest released standard schema."""
+        schema_default = load_schema_version("")
+        self.assertIsInstance(schema_default, HedSchema)
+        # Should be the highest standard version in the cache
+        versions = hed_cache.get_hed_versions(check_prerelease=False)
+        self.assertIsInstance(versions, list)
+        self.assertEqual(schema_default.version_number, versions[0])
+
+    def test_load_schema_version_default_no_standard_raises(self):
+        """Test that empty version with only library schemas raises HedFileError."""
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            # Copy only a library schema into the temp directory (no standard schemas)
+            src = os.path.join(
+                os.path.dirname(os.path.realpath(__file__)), "../../hed/schema/schema_data/HED_score_1.0.0.xml"
+            )
+            shutil.copy(src, tmp_dir)
+
+            with self.assertRaises(HedFileError) as context:
+                load_schema_version("", xml_folder=tmp_dir)
+            self.assertIn("No HED standard schema", str(context.exception))
+
     def test_load_and_verify_tags(self):
         # Load 'testlib' by itself
         testlib = load_schema_version("testlib_2.0.0")