Update test_mapper with improved reporting

* Exceptions in mapper init are now reported
* pytest failures due to exceptions include backtrace
* Fixes pytest short circuiting on mapper init

Author: timfrazee

docker-compose.yml

@@ -1,5 +1,6 @@
 services:
   python:
+    container_name: rikolti
     build:
       context: ./
       dockerfile: ./Dockerfile.dev

metadata_mapper/test/helpers/base_helper.py

@@ -32,7 +32,7 @@ class BaseTestHelper:
     # Values generated for any field name in STATIC_ATTRS is cached so that it
     # can be reused. This is especially useful for identifier fields that need
     # to be referenced multiple times throughout fixture generation.
-    STATIC_ATTRS = ["id" "identifier"]
+    STATIC_ATTRS = ["id", "identifier"]
 
     @classmethod
     def for_mapper(cls, module_parts: list[str]) -> type["BaseTestHelper"]:
@@ -65,7 +65,7 @@ def for_mapper(cls, module_parts: list[str]) -> type["BaseTestHelper"]:
 
     def __init__(self):
         self.faker = Faker()
-        self.static = []
+        self.static = {}
 
     def instantiate_record(self, record_class) -> type["Record"]:
         instance = record_class(self.faker.pyint, self.generate_fixture())
@@ -94,7 +94,7 @@ def generate_value_for(
         if isinstance(expected_type, str):
             return getattr(self, expected_type)()
         elif not skip_static and field_name in self.STATIC_ATTRS:
-            if not self.static[field_name]:
+            if not self.static.get(field_name):
                 self.static[field_name] = self.generate_value_for(
                     field_name, expected_type, skip_static=True
                 )

metadata_mapper/test/helpers/oai/content_dm/cca_vault_helper.py

@@ -0,0 +1,17 @@
+from datetime import datetime
+from random import randint
+from typing import Any
+
+from .contentdm_helper import ContentdmTestHelper
+
+class CcaVaultTestHelper(ContentdmTestHelper):
+  
+  SCHEMA = {
+    "contributor": "list_of_splittable_strings",
+    "coverage": "splittable_string",
+    "creator": "list_of_splittable_strings",
+    "spatial": "splittable_string",
+    "type": "list_of_splittable_strings",
+    "language": "list_of_splittable_strings",
+    "subject": "list_of_splittable_strings"
+  }

metadata_mapper/test/helpers/oai/content_dm/csudh_helper.py

@@ -0,0 +1,17 @@
+from datetime import datetime
+from random import randint
+from typing import Any
+
+from .contentdm_helper import ContentdmTestHelper
+
+class CsudhTestHelper(ContentdmTestHelper):
+  
+  SCHEMA = {
+    "contributor": "list_of_splittable_strings",
+    "coverage": "splittable_string",
+    "creator": "list_of_splittable_strings",
+    "spatial": "splittable_string",
+    "type": "list_of_splittable_strings",
+    "language": "list_of_splittable_strings",
+    "subject": "list_of_splittable_strings"
+  }

metadata_mapper/test/test_mapper.py

@@ -2,77 +2,85 @@
 import os
 import pytest
 import re
+import traceback
 
 from .helpers.base_helper import BaseTestHelper
 from ..mappers.mapper import Record
 
-class TestMapper:
-
-   DEFAULT_TEST_METHOD_NAME = "_test_generic_mapper"
 
-   def find_mappers_to_test(self, start_path = "metadata_mapper/mappers"):
-      ret = {}
+class TestMapper:
+    DEFAULT_TEST_METHOD_NAME = "_test_generic_mapper"
 
-      for dir in os.scandir(start_path):
-         if dir.is_dir():
-            ret = { **ret, **self.find_mappers_to_test(dir.path) }
-         elif dir.is_file() and dir.name.endswith("_mapper.py"):
-            path_regex_result = re.search("([\\w\\/]+?_mapper).py", dir.path)
-            if path_regex_result:
-               full_mapper_path = path_regex_result[1].replace("/", ".").lstrip(".")
-               module_parts = [p for p in full_mapper_path.split(".")
-                                       if p not in ["metadata_mapper", "mappers"]]
-               mapper_name = module_parts[-1]
-               mapper_path = ".".join(module_parts)
+    def find_mappers_to_test(self, start_path="metadata_mapper/mappers"):
+        ret = {}
 
-               if f"test_{mapper_name}" in locals().keys():
-                  ret[mapper_path] = getattr(self, f"test_{mapper_name}")
-               else:
-                  ret[mapper_path] = getattr(self, self.DEFAULT_TEST_METHOD_NAME)
+        for dir in os.scandir(start_path):
+            if dir.is_dir():
+                ret = {**ret, **self.find_mappers_to_test(dir.path)}
+            elif dir.is_file() and dir.name.endswith("_mapper.py"):
+                path_regex_result = re.search("([\\w\\/]+?_mapper).py", dir.path)
+                if path_regex_result:
+                    full_mapper_path = (
+                        path_regex_result[1].replace("/", ".").lstrip(".")
+                    )
+                    module_parts = [
+                        p
+                        for p in full_mapper_path.split(".")
+                        if p not in ["metadata_mapper", "mappers"]
+                    ]
+                    mapper_name = module_parts[-1]
+                    mapper_path = ".".join(module_parts)
 
-      return ret
+                    if f"test_{mapper_name}" in locals().keys():
+                        ret[mapper_path] = getattr(self, f"test_{mapper_name}")
+                    else:
+                        ret[mapper_path] = getattr(self, self.DEFAULT_TEST_METHOD_NAME)
 
-   def get_helper(self, module_parts) -> BaseTestHelper:
-      return BaseTestHelper.for_mapper(module_parts)
-   
-      helper_path = f"metadata_mapper/test/helpers/{'/'.join(module_parts).replace('_mapper', '')}_helper.py"
-      if os.path.exists(helper_path):
-         helper_module_parts = [p.replace('_mapper', '_helper') for p in module_parts]
-         helper_class_name = f"{self.camelize(module_parts[-1].replace('_mapper', ''))}TestHelper"
-         helper_module = importlib.import_module(f".helpers.{'.'.join(helper_module_parts)}", package="rikolti.metadata_mapper.test")
-         return getattr(helper_module, helper_class_name)
-      else:
-         return BaseTestHelper
+        return ret
 
-   def get_record(self, module_parts, module) -> Record:
-      mapper_name = module_parts[-1].replace("_mapper", "")
-      class_name = f"{self.camelize(mapper_name)}Record"
-      return getattr(module, class_name)
+    def get_record(self, module_parts, module) -> Record:
+        mapper_name = module_parts[-1].replace("_mapper", "")
+        class_name = f"{self.camelize(mapper_name)}Record"
+        return getattr(module, class_name)
 
-   def camelize(self, words: str) -> str:
-      return "".join([word.title() for word in words.split("_")])
+    def camelize(self, words: str) -> str:
+        return "".join([word.title() for word in words.split("_")])
 
-   def _test_generic_mapper(self, record_class, helper):
-      instance = helper.instantiate_record(record_class)
-      try:
-         instance.to_UCLDC()
-      except Exception as exc:
-         pytest.assume(False, f"{type(instance).__name__} raised {exc}")
+    def _test_generic_mapper(self, record_class, helper):
+        try:
+            instance = helper.instantiate_record(record_class)
+            try:
+                instance.to_UCLDC()
+            except Exception as exc:
+                pytest.assume(
+                    False,
+                    f"{type(instance).__name__} raised '{exc}' at mapping:\n{traceback.format_exc()}",
+                )
+        except Exception as exc:
+            pytest.assume(
+                False,
+                f"{record_class.__name__} raised '{exc}' at initialization:\n{traceback.format_exc()}",
+            )
 
-   # Test methods (invoked by pytest)
+    # Test methods (invoked by pytest)
 
-   # This will loop through all mappers that don't have explicit test methods and
-   # run them with default data
-   def test_mappers(self):
-      default_test_method = getattr(self, self.DEFAULT_TEST_METHOD_NAME)
-      
-      mappers = [mapper for mapper, method in self.find_mappers_to_test().items()
-                 if method == default_test_method]
+    # This will loop through all mappers that don't have explicit test methods and
+    # run them with default data
+    def test_mappers(self):
+        default_test_method = getattr(self, self.DEFAULT_TEST_METHOD_NAME)
 
-      for mapper in mappers:
-         module_parts = mapper.split(".")
-         module = importlib.import_module(f".mappers.{'.'.join(module_parts)}", package="rikolti.metadata_mapper")
-         helper = self.get_helper(module_parts)()
-         record_class = self.get_record(module_parts, module)
+        mappers = [
+            mapper
+            for mapper, method in self.find_mappers_to_test().items()
+            if method == default_test_method
+        ]
 
-         default_test_method(record_class, helper)
+        for mapper in mappers:
+            module_parts = mapper.split(".")
+            module = importlib.import_module(
+                f".mappers.{'.'.join(module_parts)}", package="rikolti.metadata_mapper"
+            )
+            helper = self.get_helper(module_parts)()
+            if type(helper) != BaseTestHelper:
+                record_class = self.get_record(module_parts, module)
+                default_test_method(record_class, helper)