Merge branch 'main' into convert-test-rdflib-dumper-to-pytest

Author: vladistan

tests/test_index/test_object_index.py

@@ -1,5 +1,6 @@
 import os
-import unittest
+
+import pytest
 
 import tests.test_index.model.container_test as src_dm
 from linkml_runtime.index.object_index import ObjectIndex, ProxyObject
@@ -12,92 +13,112 @@
 DATA = os.path.join(INPUT_DIR, "object-indexer-data.yaml")
 
 
-class ObjectIndexerTestCase(unittest.TestCase):
-    """
-    tests the data model
-    """
-
-    def setUp(self) -> None:
-        self.schemaview = SchemaView(SCHEMA)
-        obj: src_dm.Container
-        self.container = yaml_loader.load(DATA, target_class=src_dm.Container)
-
-    def test_object_index(self):
-        """checks indexing objects"""
-        # domain object
-        container = self.container
-        frt = container.persons[0].has_familial_relationships[0].type
-        self.assertIsInstance(frt, src_dm.FamilialRelationshipType)
-        # create an index
-        oix = ObjectIndex(container, schemaview=self.schemaview)
-        self.assertEqual(0, oix.proxy_object_cache_size)
-        self.assertGreater(oix.source_object_cache_size, 4)
-        # test basic lookups
-        proxy_obj = oix.bless(container)
-        # proxy objects mock the domain object class, plus
-        # they also instantiate ProxyObject
-        self.assertIsInstance(proxy_obj, ProxyObject)
-        self.assertIsInstance(proxy_obj, src_dm.Container)
-        proxy_obj = oix.bless(container.persons[0])
-        self.assertIsInstance(proxy_obj, ProxyObject)
-        self.assertIsInstance(proxy_obj, src_dm.Person)
-        v = proxy_obj.name
-        self.assertEqual("fred bloggs", v)
-        self.assertEqual(33, proxy_obj.age_in_years)
-        self.assertCountEqual(["a", "b"], proxy_obj.aliases)
-        addr = proxy_obj.current_address
-        self.assertIsInstance(addr, ProxyObject)
-        self.assertIsInstance(addr, src_dm.Address)
-        self.assertEqual("1 oak street", addr.street)
-        self.assertIsInstance(proxy_obj.has_familial_relationships, list)
-        fr = proxy_obj.has_familial_relationships[0]
-        self.assertIsInstance(fr, ProxyObject)
-        # test automatic dereferencing;
-        # related_to is *not* inlined in the schema
-        self.assertEqual("Alison Wu", fr.related_to.name)
-        self.assertIsInstance(fr.type, src_dm.FamilialRelationshipType)
-        self.assertIsNone(fr.related_to.age_in_years)
-        self.assertIsInstance(fr.related_to, ProxyObject)
-        self.assertEqual(2, len(proxy_obj.has_medical_history))
-        fr2 = fr.related_to.has_familial_relationships[0]
-        self.assertEqual("fred bloggs", fr2.related_to.name)
-        self.assertEqual(33, fr2.related_to.age_in_years)
-        self.assertIsInstance(fr2.related_to, ProxyObject)
-        fr3 = fr2.related_to.has_familial_relationships[0]
-        self.assertIsInstance(fr3.related_to, ProxyObject)
-        self.assertEqual("Alison Wu", fr3.related_to.name)
-        self.assertGreater(oix.proxy_object_cache_size, 1)
-        self.assertLess(oix.proxy_object_cache_size, 9)
-        oix.clear_proxy_object_cache()
-        self.assertEqual(0, oix.proxy_object_cache_size)
-        fr = proxy_obj.has_familial_relationships[0].related_to
-        # test that attributes are closed
-        with self.assertRaises(ValueError):
-            v = proxy_obj.fake_attribute
-        # test setting attributes, and that this affects shadowed object
-        proxy_obj.age_in_years = 44
-        self.assertEqual(44, proxy_obj.age_in_years)
-        self.assertEqual(44, self.container.persons[0].age_in_years)
-        # test evaluation of expressions
-        self.assertEqual(5, oix.eval_expr("5"))
-        self.assertEqual(5, oix.eval_expr("2*2+1"))
-        self.assertEqual("P:001", oix.eval_expr("persons", container)[0].id)
-        self.assertEqual("P:001", oix.eval_expr("persons[0].id", container))
-        self.assertEqual(oix.eval_expr("persons", container), oix.eval_expr("persons"))
-        person = oix.eval_expr("persons")[0]
-        self.assertIsInstance(oix.bless(container).persons[0], ProxyObject)
-        self.assertIsInstance(person, ProxyObject)
-        self.assertEqual("1 oak street", oix.eval_expr("current_address.street", person))
-        self.assertEqual("Alison Wu", oix.eval_expr("has_familial_relationships[0].related_to.name", person))
-        # experimental: reverse direction
-        self.assertEqual("P:001", oix.eval_expr("persons[0]._parents[0][1].persons[0].id"))
-        self.assertEqual("P:001", oix.eval_expr("persons[0].persons__inverse[0].persons[0].id"))
-        # test inference
-        # infer_all_slot_values(person, self.schemaview, class_name="Person")
-        config = Config(use_expressions=True)
-        infer_slot_value(person, "description", schemaview=self.schemaview, class_name="Person", config=config)
-        self.assertEqual("name: fred bloggs address: 1 oak street", person.description)
-
-
-if __name__ == "__main__":
-    unittest.main()
+@pytest.fixture
+def schema_view():
+    """SchemaView instance for container test schema."""
+    return SchemaView(SCHEMA)
+
+
+@pytest.fixture
+def container():
+    """Load container test data."""
+    return yaml_loader.load(DATA, target_class=src_dm.Container)
+
+
+@pytest.fixture
+def object_index(container, schema_view):
+    """ObjectIndex instance for testing."""
+    return ObjectIndex(container, schemaview=schema_view)
+
+
+def test_object_index(schema_view, container, object_index):
+    """Test object indexing functionality."""
+    # Test domain object
+    frt = container.persons[0].has_familial_relationships[0].type
+    assert isinstance(frt, src_dm.FamilialRelationshipType)
+
+    # Test index initialization
+    oix = object_index
+    assert oix.proxy_object_cache_size == 0
+    assert oix.source_object_cache_size > 4
+
+    # Test basic lookups
+    proxy_obj = oix.bless(container)
+    # Proxy objects mock the domain object class, plus they also instantiate ProxyObject
+    assert isinstance(proxy_obj, ProxyObject)
+    assert isinstance(proxy_obj, src_dm.Container)
+
+    proxy_obj = oix.bless(container.persons[0])
+    assert isinstance(proxy_obj, ProxyObject)
+    assert isinstance(proxy_obj, src_dm.Person)
+
+    # Test basic attributes
+    v = proxy_obj.name
+    assert v == "fred bloggs"
+    assert proxy_obj.age_in_years == 33
+    assert sorted(proxy_obj.aliases) == sorted(["a", "b"])
+
+    # Test address proxy
+    addr = proxy_obj.current_address
+    assert isinstance(addr, ProxyObject)
+    assert isinstance(addr, src_dm.Address)
+    assert addr.street == "1 oak street"
+
+    # Test familial relationships
+    assert isinstance(proxy_obj.has_familial_relationships, list)
+    fr = proxy_obj.has_familial_relationships[0]
+    assert isinstance(fr, ProxyObject)
+
+    # Test automatic dereferencing - related_to is *not* inlined in the schema
+    assert fr.related_to.name == "Alison Wu"
+    assert isinstance(fr.type, src_dm.FamilialRelationshipType)
+    assert fr.related_to.age_in_years is None
+    assert isinstance(fr.related_to, ProxyObject)
+    assert len(proxy_obj.has_medical_history) == 2
+
+    # Test recursive relationships
+    fr2 = fr.related_to.has_familial_relationships[0]
+    assert fr2.related_to.name == "fred bloggs"
+    assert fr2.related_to.age_in_years == 33
+    assert isinstance(fr2.related_to, ProxyObject)
+
+    fr3 = fr2.related_to.has_familial_relationships[0]
+    assert isinstance(fr3.related_to, ProxyObject)
+    assert fr3.related_to.name == "Alison Wu"
+
+    # Test cache behavior
+    assert oix.proxy_object_cache_size > 1
+    assert oix.proxy_object_cache_size < 9
+    oix.clear_proxy_object_cache()
+    assert oix.proxy_object_cache_size == 0
+
+    # Test that attributes are closed
+    with pytest.raises(ValueError):
+        v = proxy_obj.fake_attribute
+
+    # Test setting attributes affects shadowed object
+    proxy_obj.age_in_years = 44
+    assert proxy_obj.age_in_years == 44
+    assert container.persons[0].age_in_years == 44
+
+    # Test evaluation of expressions
+    assert oix.eval_expr("5") == 5
+    assert oix.eval_expr("2*2+1") == 5
+    assert oix.eval_expr("persons", container)[0].id == "P:001"
+    assert oix.eval_expr("persons[0].id", container) == "P:001"
+    assert oix.eval_expr("persons", container) == oix.eval_expr("persons")
+
+    person = oix.eval_expr("persons")[0]
+    assert isinstance(oix.bless(container).persons[0], ProxyObject)
+    assert isinstance(person, ProxyObject)
+    assert oix.eval_expr("current_address.street", person) == "1 oak street"
+    assert oix.eval_expr("has_familial_relationships[0].related_to.name", person) == "Alison Wu"
+
+    # Test experimental reverse direction
+    assert oix.eval_expr("persons[0]._parents[0][1].persons[0].id") == "P:001"
+    assert oix.eval_expr("persons[0].persons__inverse[0].persons[0].id") == "P:001"
+
+    # Test inference
+    config = Config(use_expressions=True)
+    infer_slot_value(person, "description", schemaview=schema_view, class_name="Person", config=config)
+    assert person.description == "name: fred bloggs address: 1 oak street"

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)