Merge branch 'main' into fix_yamlutils_as_json_object_inject_type

Author: puja-trivedi

tests/test_issues/test_include_schema.py

@@ -1,19 +1,19 @@
-import unittest
-
 from linkml_runtime.linkml_model.meta import SchemaDefinition
 from linkml_runtime.loaders import yaml_loader
 from tests.test_issues.environment import env
 
 # https://github.com/linkml/linkml/issues/3
 
 
-class IncludeSchemaTestCase(unittest.TestCase):
-    """include_schema.yaml produces a Python exception on an uncaught error"""
-
-    # "Awaiting fix for issue #3"
-    def test_include_schema(self):
-        inp = yaml_loader.load(env.input_path("include_schema.yaml"), SchemaDefinition)
+def test_include_schema():
+    """
+    Test for GitHub issue #3: include_schema.yaml produces a Python exception on an uncaught error
 
+    This is a regression test to ensure schema inclusion works without throwing exceptions.
+    """
+    # Load schema file - this should not raise an exception
+    inp = yaml_loader.load(env.input_path("include_schema.yaml"), SchemaDefinition)
 
-if __name__ == "__main__":
-    unittest.main()
+    # Verify the schema was loaded successfully
+    assert inp is not None
+    assert isinstance(inp, SchemaDefinition)

tests/test_loaders_dumpers/test_enum.py

@@ -1,5 +1,4 @@
 import json
-import unittest
 
 import yaml
 
@@ -8,31 +7,34 @@
 from tests.test_loaders_dumpers.models.enum_model import Organism, StateEnum
 
 
-class EnumTestCase(unittest.TestCase):
-    def test_enum(self):
-        """
-        Tests that enums are encoded as json correctly
-
-        * https://github.com/linkml/linkml/issues/337
-        * https://github.com/linkml/linkml/issues/119
-        """
-        i = Organism(state="LIVING")
-        print(i)
-        print(i.state)
-        print(i.state.code)
-        print(i.state.code.text)
-        print(type(i.state))
-        print(StateEnum.LIVING)
-        assert str(i.state) == "LIVING"
-        assert i.state.code == StateEnum.LIVING
-        obj = json.loads(json_dumper.dumps(i))
-        assert obj["state"] == "LIVING"
-        obj = yaml.safe_load(yaml_dumper.dumps(i))
-        assert obj["state"] == "LIVING"
-        reconstituted = json_loader.loads(json_dumper.dumps(i), target_class=Organism)
-        print(f"RECONSTITUTED = {reconstituted}")
-        assert reconstituted.state.code == StateEnum.LIVING
-
-
-if __name__ == "__main__":
-    unittest.main()
+def test_enum():
+    """
+    Tests that enums are encoded as json correctly
+
+    * https://github.com/linkml/linkml/issues/337
+    * https://github.com/linkml/linkml/issues/119
+    """
+    i = Organism(state="LIVING")
+    print(i)
+    print(i.state)
+    print(i.state.code)
+    print(i.state.code.text)
+    print(type(i.state))
+    print(StateEnum.LIVING)
+
+    # Test string representation and enum code
+    assert str(i.state) == "LIVING"
+    assert i.state.code == StateEnum.LIVING
+
+    # Test JSON dumping/loading
+    obj = json.loads(json_dumper.dumps(i))
+    assert obj["state"] == "LIVING"
+
+    # Test YAML dumping
+    obj = yaml.safe_load(yaml_dumper.dumps(i))
+    assert obj["state"] == "LIVING"
+
+    # Test round-trip JSON serialization
+    reconstituted = json_loader.loads(json_dumper.dumps(i), target_class=Organism)
+    print(f"RECONSTITUTED = {reconstituted}")
+    assert reconstituted.state.code == StateEnum.LIVING

tests/test_utils/test_curienamespace.py

@@ -1,24 +1,19 @@
-import unittest
-
+import pytest
 from rdflib import URIRef
 
 from linkml_runtime.utils.curienamespace import CurieNamespace
 
 
-class CurieNamespaceTestCase(unittest.TestCase):
-    def test_basics(self):
-        BFO = CurieNamespace("bfo", "http://purl.obolibrary.org/obo/BFO_")
-        self.assertEqual(URIRef("http://purl.obolibrary.org/obo/BFO_test"), BFO.test)
-        self.assertEqual("http://purl.obolibrary.org/obo/BFO_", BFO)
-        self.assertEqual("bfo:test", BFO.curie("test"))
-        self.assertEqual("bfo:", BFO.curie())
-
-    @unittest.expectedFailure
-    def test_curie_as_curie(self):
-        """ "curie can't be a local name at the moment" """
-        BFO = CurieNamespace("bfo", "http://purl.obolibrary.org/obo/BFO_")
-        self.assertEqual("bfo:curie", BFO.curie)
+def test_basics():
+    BFO = CurieNamespace("bfo", "http://purl.obolibrary.org/obo/BFO_")
+    assert URIRef("http://purl.obolibrary.org/obo/BFO_test") == BFO.test
+    assert "http://purl.obolibrary.org/obo/BFO_" == BFO
+    assert "bfo:test" == BFO.curie("test")
+    assert "bfo:" == BFO.curie()
 
 
-if __name__ == "__main__":
-    unittest.main()
+@pytest.mark.xfail(reason="curie can't be a local name at the moment")
+def test_curie_as_curie():
+    """curie can't be a local name at the moment"""
+    BFO = CurieNamespace("bfo", "http://purl.obolibrary.org/obo/BFO_")
+    assert "bfo:curie" == BFO.curie

tests/test_utils/test_distroutils.py

@@ -1,16 +1,9 @@
-import unittest
-
 from linkml_runtime.utils.distroutils import get_jsonschema_string, get_schema_string
 
 
-class DistroUtilsTestCase(unittest.TestCase):
-    def test_distroutils(self):
-        p = "linkml_runtime.linkml_model.meta"
-        js = get_jsonschema_string(p)
-        assert "ClassDefinition" in js
-        ys = get_schema_string(p)
-        assert "class_definition" in ys
-
-
-if __name__ == "__main__":
-    unittest.main()
+def test_distroutils():
+    p = "linkml_runtime.linkml_model.meta"
+    js = get_jsonschema_string(p)
+    assert "ClassDefinition" in js
+    ys = get_schema_string(p)
+    assert "class_definition" in ys

tests/test_utils/test_formatutils.py

@@ -1,5 +1,4 @@
 import json
-import unittest
 from typing import Any
 
 from jsonasobj2 import JsonObj, as_json
@@ -99,105 +98,89 @@
 """
 
 
-class FormatUtilsTestCase(unittest.TestCase):
-    def test_formats(self):
-        self.assertEqual("ThisIsIt", camelcase("this is it"))
-        self.assertEqual("ThisIsIT", camelcase("  this   is iT   "))
-        self.assertEqual("un camelcased", uncamelcase("UnCamelcased"))
-        self.assertEqual("oneword", uncamelcase("Oneword"))
-        self.assertEqual("one_word", uncamelcase("one_word"))
-        self.assertEqual("another word", uncamelcase("anotherWord"))
-        self.assertEqual("IBeY", camelcase("i be y "))
-        self.assertEqual("ThisIsIt", camelcase("This__is_it"))
-
-        self.assertEqual("this_is_it", underscore(" this is it "))
-        self.assertEqual("this_is_it", underscore("this   is   it"))
-
-        self.assertEqual("thisIsIt", lcamelcase("   this   is\t  it\n"))
-
-        self.assertEqual("abc", be("  abc\n"))
-        self.assertEqual("", be(None))
-        self.assertEqual("", be("   "))
-
-    def test_linestuff(self):
-        text = (
-            "This is a mess'o test that goes on for a long way.  It has some carriage\n returns embedded in it "
-            "but otherwise it drags on and on and on until the cows come home.  Splitline covers this we hope."
-        )
-        self.assertEqual(
-            [
-                "This is a mess'o test that goes on for a long way. It has some carriage returns embedded"
-                " in it but otherwise it ",
-                "drags on and on and on until the cows come home. Splitline covers this we hope. ",
-            ],
-            split_line(text),
-        )
-        self.assertEqual(
-            [
-                "This is a mess'o ",
-                "test that goes on ",
-                "for a long way. It ",
-                "has some carriage ",
-                "returns embedded in ",
-                "it but otherwise it ",
-                "drags on and on and ",
-                "on until the cows ",
-                "come home. ",
-                "Splitline covers ",
-                "this we hope. ",
-            ],
-            split_line(text, 20),
-        )
-        self.assertEqual(["X" * 100 + " "], split_line("X" * 100, 20))
-        self.assertEqual(
-            (
-                "This is a mess'o test that goes on for a long way.  It has some carriage\n"
-                "\treturns embedded in it but otherwise it drags on and on and on until the "
-                "cows come home. Splitline covers this we \n"
-                "\thope. "
-            ),
-            wrapped_annotation(text),
-        )
-
-    def test_empty_functions(self):
-        """Test the various forms of is_empty"""
-        for thing in empty_things:
-            self.assertTrue(is_empty(thing), msg=f"{thing} should clock in as empty")
-        for thing in non_empty_things:
-            self.assertFalse(is_empty(thing))
-        obj = JsonObj([])
-        assert is_empty(obj)
-
-    def test_remove_empty_items(self):
-        """Test the various remove empty items paths"""
-        seen = set()
-        save = list()  # Keep garbage collection from reusing ids
-        for thing, expected in things_removed:
-            actual = remove_empty_items(thing)
-            self.assertEqual(expected, actual, msg=f"Input = {thing}")
-            self.assertFalse(isinstance(actual, JsonObj), msg="JSON objects are never returned")
-            if isinstance(expected, (dict, list)):
-                self.assertNotEqual(id(expected), id(actual), msg=f"Copy of {thing} was not returned")
-                self.assertNotIn(id(actual), seen, msg="remove_empty_items should always return a new thing")
-                save.append(actual)
-                seen.add(id(actual))
-
-    def test_enumerations_case(self):
-        self.assertEqual(
-            """[
+def test_formats():
+    assert "ThisIsIt" == camelcase("this is it")
+    assert "ThisIsIT" == camelcase("  this   is iT   ")
+    assert "un camelcased" == uncamelcase("UnCamelcased")
+    assert "oneword" == uncamelcase("Oneword")
+    assert "one_word" == uncamelcase("one_word")
+    assert "another word" == uncamelcase("anotherWord")
+    assert "IBeY" == camelcase("i be y ")
+    assert "ThisIsIt" == camelcase("This__is_it")
+
+    assert "this_is_it" == underscore(" this is it ")
+    assert "this_is_it" == underscore("this   is   it")
+
+    assert "thisIsIt" == lcamelcase("   this   is\t  it\n")
+
+    assert "abc" == be("  abc\n")
+    assert "" == be(None)
+    assert "" == be("   ")
+
+
+def test_linestuff():
+    text = (
+        "This is a mess'o test that goes on for a long way.  It has some carriage\n returns embedded in it "
+        "but otherwise it drags on and on and on until the cows come home.  Splitline covers this we hope."
+    )
+    assert [
+        "This is a mess'o test that goes on for a long way. It has some carriage returns embedded"
+        " in it but otherwise it ",
+        "drags on and on and on until the cows come home. Splitline covers this we hope. ",
+    ] == split_line(text)
+    assert [
+        "This is a mess'o ",
+        "test that goes on ",
+        "for a long way. It ",
+        "has some carriage ",
+        "returns embedded in ",
+        "it but otherwise it ",
+        "drags on and on and ",
+        "on until the cows ",
+        "come home. ",
+        "Splitline covers ",
+        "this we hope. ",
+    ] == split_line(text, 20)
+    assert ["X" * 100 + " "] == split_line("X" * 100, 20)
+    assert (
+        "This is a mess'o test that goes on for a long way.  It has some carriage\n"
+        "\treturns embedded in it but otherwise it drags on and on and on until the "
+        "cows come home. Splitline covers this we \n"
+        "\thope. "
+    ) == wrapped_annotation(text)
+
+
+def test_empty_functions():
+    """Test the various forms of is_empty"""
+    for thing in empty_things:
+        assert is_empty(thing), f"{thing} should clock in as empty"
+    for thing in non_empty_things:
+        assert not is_empty(thing)
+    obj = JsonObj([])
+    assert is_empty(obj)
+
+
+def test_remove_empty_items():
+    """Test the various remove empty items paths"""
+    seen = set()
+    save = list()  # Keep garbage collection from reusing ids
+    for thing, expected in things_removed:
+        actual = remove_empty_items(thing)
+        assert expected == actual, f"Input = {thing}"
+        assert not isinstance(actual, JsonObj), "JSON objects are never returned"
+        if isinstance(expected, (dict, list)):
+            assert id(expected) != id(actual), f"Copy of {thing} was not returned"
+            assert id(actual) not in seen, "remove_empty_items should always return a new thing"
+            save.append(actual)
+            seen.add(id(actual))
+
+
+def test_enumerations_case():
+    assert """[
    "state",
    "1"
-]""",
-            as_json(remove_empty_items(json.loads(issue_157_1), hide_protected_keys=True)),
-        )
-        self.assertEqual(
-            """[
+]""" == as_json(remove_empty_items(json.loads(issue_157_1), hide_protected_keys=True))
+    assert """[
    "namedstate",
    "production"
-]""",
-            as_json(remove_empty_items(json.loads(issue_157_2), hide_protected_keys=True)),
-        )
-
-
-if __name__ == "__main__":
-    unittest.main()
+]""" == as_json(remove_empty_items(json.loads(issue_157_2), hide_protected_keys=True))

tests/test_utils/test_list_strings.py

@@ -1,5 +1,3 @@
-import unittest
-
 from linkml_runtime.linkml_model.meta import SchemaDefinition
 from linkml_runtime.loaders import yaml_loader
 
@@ -36,14 +34,9 @@
 """
 
 
-class ListStringsTestCase(unittest.TestCase):
-    def test_strings_in_list_slot(self):
-        rslt = yaml_loader.loads(sample, SchemaDefinition)
-        self.assertEqual(1, len(rslt.classes["AClass"].slots))
-        self.assertEqual("a_slot", rslt.classes["AClass"].slots[0])
-        self.assertEqual(1, len(rslt.classes["BClass"].mixins))
-        self.assertEqual("AClass", rslt.classes["BClass"].mixins[0])
-
-
-if __name__ == "__main__":
-    unittest.main()
+def test_strings_in_list_slot():
+    rslt = yaml_loader.loads(sample, SchemaDefinition)
+    assert len(rslt.classes["AClass"].slots) == 1
+    assert rslt.classes["AClass"].slots[0] == "a_slot"
+    assert len(rslt.classes["BClass"].mixins) == 1
+    assert rslt.classes["BClass"].mixins[0] == "AClass"