Merge pull request #402 from ialarmedalien/unittest_to_pytest

Converting the "issue" tests to pytest

Author: sierra-moxon

linkml_runtime/loaders/loader_root.py

@@ -75,7 +75,7 @@ def load(self, *args, **kwargs) -> Union[BaseModel, YAMLRoot]:
         :return: instance of target_class
         """
         results = self.load_any(*args, **kwargs)
-        if isinstance(results, BaseModel) or isinstance(results, YAMLRoot):
+        if isinstance(results, (BaseModel, YAMLRoot)):
             return results
         else:
             raise ValueError(f"Result is not an instance of BaseModel or YAMLRoot: {type(results)}")
@@ -145,9 +145,9 @@ def _construct_target_class(
             elif isinstance(data_as_dict, dict):
                 if issubclass(target_class, BaseModel):
                     return target_class.model_validate(data_as_dict)
-                else:
-                    return target_class(**data_as_dict)
-            elif isinstance(data_as_dict, JsonObj):
+                return target_class(**data_as_dict)
+
+            if isinstance(data_as_dict, JsonObj):
                 return [target_class(**as_dict(x)) for x in data_as_dict]
             else:
                 raise ValueError(f"Unexpected type {data_as_dict}")
@@ -170,7 +170,7 @@ def _read_source(
         if not isinstance(source, dict):
             # Try to get local version of schema, if one is known to exist
             try:
-                if str(source) in URI_TO_LOCAL.keys():
+                if str(source) in URI_TO_LOCAL:
                     source = str(URI_TO_LOCAL[str(source)])
             except (TypeError, KeyError) as e:
                 # Fine, use original `source` value

tests/test_issues/input/linkml_issue_478.yaml

@@ -9,7 +9,7 @@ classes:
       - id
       - preferred label
       - SOURCE
-  biosample processing:
+  biosample_processing:
     is_a: named thing
     attributes:
       processingMethod:
@@ -23,4 +23,4 @@ classes:
 slots:
   id:
   preferred label:
-  SOURCE:
+  SOURCE:

tests/test_issues/test_dataclass_extensions_376.py

@@ -1,19 +1,19 @@
-import sys
-import pytest
-import importlib.util
 import dataclasses
+import importlib.util
+
+import pytest
 
 
 def import_patch_module():
-    """Fresh import to ensure warning is triggered"""
+    """Fresh import to ensure warning is triggered."""
     spec = importlib.util.find_spec("linkml_runtime.utils.dataclass_extensions_376")
     mod = importlib.util.module_from_spec(spec)
     spec.loader.exec_module(mod)
     return mod
 
 
-def test_patch_module_emits_deprecation_warning():
-    """All Python versions: emits DeprecationWarning and defines compatibility symbols"""
+def test_patch_module_emits_deprecation_warning() -> None:
+    """All Python versions: emits DeprecationWarning and defines compatibility symbols."""
     with pytest.warns(DeprecationWarning):
         mod = import_patch_module()
 

tests/test_issues/test_issue_1040.py

@@ -1,22 +1,13 @@
-from unittest import TestCase
-
+import pytest
 import yaml.constructor
 
 from linkml_runtime.linkml_model import SchemaDefinition
 from linkml_runtime.loaders import yaml_loader
 from tests.test_issues.environment import env
 
 
-class Issue1040TestCase(TestCase):
-    """
-    https://github.com/linkml/linkml/issues/1040
-    """
-
-    env = env
-
-    def test_issue_1040_file_name(self):
-        """issue_1040.yaml has a parsing error is confusing as all getout when accompanied by a stack
-        trace.  We use this to make sure that the file name gets in correctly."""
-        with self.assertRaises(yaml.constructor.ConstructorError) as e:
-            yaml_loader.load(env.input_path("issue_1040.yaml"), SchemaDefinition)
-        self.assertIn('"issue_1040.yaml"', str(e.exception))
+def test_issue_1040_file_name() -> None:
+    """issue_1040.yaml has a parsing error is confusing as all getout when accompanied by a stack
+    trace.  We use this to make sure that the file name gets in correctly."""
+    with pytest.raises(yaml.constructor.ConstructorError, match='"issue_1040.yaml"'):
+        yaml_loader.load(env.input_path("issue_1040.yaml"), SchemaDefinition)

tests/test_issues/test_issue_1355.py

@@ -1,29 +1,14 @@
-"""
-Created on 2023-03-24
+import pytest
 
-@author: wf
-"""
-
-from unittest import TestCase
 from linkml_runtime.utils.metamodelcore import URI
 
 
-class Issue1355TestCase(TestCase):
-    """
-    https://github.com/linkml/linkml/issues/1355
-    improve invalid URL message
-    """
+def test_issue_1355_invalid_url_message() -> None:
+    """Check that quotes are used when referencing invalid urls to improve troubleshooting UX.
 
-    def test_issue_1355_invalid_url_message(self):
-        """
-        check that quotes are used when referencing invalid urls so that
-        the visiblity of the problem gets better
-        """
-        #  note the trailing blank
-        url = "https://ceur-ws.org/Vol-2931/ICBO_2019_paper_20.pdf "
-        try:
-            _uri = URI(url)
-        except ValueError as vex:
-            msg = str(vex)
-            # 'https://ceur-ws.org/Vol-2931/ICBO_2019_paper_20.pdf ': is not a valid URI
-            self.assertTrue(".pdf '" in msg)
+    See https://github.com/linkml/linkml/issues/1355, improve invalid URL message
+    """
+    #  note the trailing blank
+    url = "https://ceur-ws.org/Vol-2931/ICBO_2019_paper_20.pdf "
+    with pytest.raises(ValueError, match="'https://ceur-ws.org/Vol-2931/ICBO_2019_paper_20.pdf ': is not a valid URI"):
+        URI(url)

tests/test_issues/test_issue_163.py

@@ -1,40 +1,31 @@
-import unittest
-from typing import Callable
+from collections.abc import Callable
 
-from linkml_runtime.dumpers import json_dumper, yaml_dumper, rdf_dumper
-from tests.test_issues.environment import env
-from tests.test_loaders_dumpers.loaderdumpertestcase import LoaderDumperTestCase
+from linkml_runtime.dumpers import json_dumper, rdf_dumper, yaml_dumper
 from linkml_runtime.utils.compile_python import compile_python
+from tests.test_issues.environment import env
 
 
-class Issue368TestCase(LoaderDumperTestCase):
-    env = env
-
-    def header(self, txt: str) -> str:
-        return "\n" + ("=" * 20) + f" {txt} " + ("=" * 20)
-
-    def test_issue_368_enums(self):
-        """Test Enum generation"""
-
-        module = compile_python(env.input_path("issue_368.py"))
+def header(txt: str) -> str:
+    return "\n" + ("=" * 20) + f" {txt} " + ("=" * 20)
 
-        enum_inst = module.SampleEnum("pva")  # EnumInstanceImpl
-        example = module.SampleClass(slot_1="pva")
-        assert hasattr(example, "slot_1")
-        assert example.slot_1.code.text == enum_inst.code.text
-        assert str(example.slot_1) == "pva"
 
-        def dump_and_load(dumper: Callable, sfx: str) -> None:
-            fname = env.actual_path(f"issue_368_1.{sfx}")
-            dumper(example, fname)
-            with open(fname) as f:
-                print(f"\n----- {sfx} -----")
-                print(f.read())
+def test_issue_368_enums() -> None:
+    """Test Enum generation."""
+    module = compile_python(env.input_path("issue_368.py"))
 
-        dump_and_load(json_dumper.dump, "json")
-        dump_and_load(yaml_dumper.dump, "yaml")
-        dump_and_load(lambda obj, fname: rdf_dumper.dump(obj, fname, env.input_path("issue_368.context.jsonld")), "ttl")
+    enum_inst = module.SampleEnum("pva")  # EnumInstanceImpl
+    example = module.SampleClass(slot_1="pva")
+    assert hasattr(example, "slot_1")
+    assert example.slot_1.code.text == enum_inst.code.text
+    assert str(example.slot_1) == "pva"
 
+    def dump_and_load(dumper: Callable, sfx: str) -> None:
+        fname = env.actual_path(f"issue_368_1.{sfx}")
+        dumper(example, fname)
+        with open(fname) as f:
+            print(f"\n----- {sfx} -----")
+            print(f.read())
 
-if __name__ == "__main__":
-    unittest.main()
+    dump_and_load(json_dumper.dump, "json")
+    dump_and_load(yaml_dumper.dump, "yaml")
+    dump_and_load(lambda obj, fname: rdf_dumper.dump(obj, fname, env.input_path("issue_368.context.jsonld")), "ttl")

tests/test_issues/test_issue_368_enums.py

@@ -1,6 +1,5 @@
-import unittest
-
 import hbreader
+import pytest
 import yaml
 
 from linkml_runtime.utils.yamlutils import DupCheckYamlLoader, TypedNode
@@ -13,26 +12,29 @@
 """
 
 
-class Issue6TestCase(unittest.TestCase):
-    def test_loc_function(self):
-        inp = yaml.load(hbreader.hbread(inp_yaml), DupCheckYamlLoader)
-        self.assertEqual('File "<unicode string>", line 3, col 8: ', TypedNode.yaml_loc(inp["foo"]["x"]))
-        self.assertEqual('File "<unicode string>", line 3, col 8', TypedNode.yaml_loc(inp["foo"]["x"], suffix=""))
-        self.assertEqual('File "<unicode string>", line 4, col 8: ', TypedNode.yaml_loc(inp["foo"]["y"]))
-        self.assertEqual(
-            'File "<unicode string>", line 4, col 8I yam that I yam',
-            TypedNode.yaml_loc(inp["foo"]["y"], suffix=inp["foo"]["y"]),
-        )
-        self.assertEqual('File "<unicode string>", line 5, col 8: ', TypedNode.yaml_loc(inp["foo"]["z"]))
-
-        with self.assertWarns(DeprecationWarning) as cm:
-            self.assertEqual('File "<unicode string>", line 3, col 8', TypedNode.loc(inp["foo"]["x"]))
-        self.assertEqual("Call to deprecated method loc. (Use yaml_loc instead)", cm.warning.args[0])
-
-        self.assertEqual("", TypedNode.yaml_loc(None))
-        self.assertEqual("", TypedNode.yaml_loc("abc"))
-        self.assertEqual("", TypedNode.yaml_loc(["a", "b"]))
-
-
-if __name__ == "__main__":
-    unittest.main()
+def test_loc_function() -> None:
+    """Test the TypedNode.yaml_loc function."""
+    inp = yaml.load(hbreader.hbread(inp_yaml), DupCheckYamlLoader)
+    assert TypedNode.yaml_loc(inp["foo"]["x"]) == 'File "<unicode string>", line 3, col 8: '
+    assert TypedNode.yaml_loc(inp["foo"]["x"], suffix="") == 'File "<unicode string>", line 3, col 8'
+    assert TypedNode.yaml_loc(inp["foo"]["y"]) == 'File "<unicode string>", line 4, col 8: '
+    assert (
+        TypedNode.yaml_loc(inp["foo"]["y"], suffix=inp["foo"]["y"])
+        == 'File "<unicode string>", line 4, col 8I yam that I yam'
+    )
+    assert TypedNode.yaml_loc(inp["foo"]["z"]) == 'File "<unicode string>", line 5, col 8: '
+
+
+def test_yaml_loc_warning() -> None:
+    """Test that a warning is emitted when using the `loc` method."""
+    inp = yaml.load(hbreader.hbread(inp_yaml), DupCheckYamlLoader)
+    with pytest.warns(DeprecationWarning) as warning_list:
+        assert TypedNode.loc(inp["foo"]["x"]) == 'File "<unicode string>", line 3, col 8'
+    assert len(warning_list) == 1
+    assert str(warning_list[0].message) == "Call to deprecated method loc. (Use yaml_loc instead)"
+
+
+@pytest.mark.parametrize("loc", [None, "abc", ["a", "b"]])
+def test_yaml_loc_empty_str(loc) -> None:
+    """Test yaml_loc values that translate to an empty string."""
+    assert TypedNode.yaml_loc(loc) == ""

tests/test_issues/test_issue_6.py

@@ -1,5 +1,3 @@
-import unittest
-
 from linkml_runtime.linkml_model import SchemaDefinition
 from linkml_runtime.utils.yamlutils import from_yaml
 
@@ -12,22 +10,17 @@
   string:
     base: str
     uri: xsd:string
-    
+
 slots:
   name:
 """
 
 
-class IsolatedNameTestCase(unittest.TestCase):
-    def test_it(self):
-        """Dangling name should not throw a type error"""
-        error_thrown = False
-        try:
-            from_yaml(model_txt, SchemaDefinition)
-        except TypeError as e:
-            error_thrown = True
-        self.assertFalse(error_thrown, msg="Type error should not be thrown")
-
-
-if __name__ == "__main__":
-    unittest.main()
+def test_read_dangling_name() -> None:
+    """Dangling name should not throw a type error."""
+    error_thrown = False
+    try:
+        from_yaml(model_txt, SchemaDefinition)
+    except TypeError:
+        error_thrown = True
+    assert error_thrown is False

tests/test_issues/test_issue_626.py

@@ -1,14 +1,16 @@
-import pytest
+from __future__ import annotations
+
 from dataclasses import dataclass
-from typing import Optional, ClassVar
+from typing import ClassVar
 
+import pytest
 import yaml
 
-from linkml_runtime.utils.yamlutils import YAMLRoot, DupCheckYamlLoader
+from linkml_runtime.utils.yamlutils import DupCheckYamlLoader, YAMLRoot
 
 
 @pytest.mark.xfail(reason="Reporting line numbers should happen at load time not when instantiating dataclasses")
-def test_issue_38():
+def test_issue_38() -> None:
     # The goal is to provide line numbers on error messages.   We've tweaked the parser so that it returns augmented
     # str's and int's with the line numbers on them.  The problem we are trying to address now is that the dataclass
     # constructor doesn't support **argv out of the box.  We can certainly tweak the generator to emit the __init__
@@ -18,8 +20,8 @@ def test_issue_38():
     class FesterBesterTester(YAMLRoot):
         cv: ClassVar[int] = 42
 
-        a: Optional[int] = 0
-        b: Optional[str] = None
+        a: int | None = 0
+        b: str | None = None
 
     with pytest.raises(TypeError, match="unexpected keyword argument 'c'"):
         FesterBesterTester(a=12, b="Sell", c="buy")