Some improvements/fixes related to previous metadata commits

Author: etj

geonode/metadata/api/views.py

@@ -117,6 +117,7 @@ def schema_instance(self, request, pk=None):
                         if request.method == "PUT"
                         else metadata_manager.update_schema_instance_partial(resource, request.data, request.user, lang)
                     )
+                    resource.refresh_from_db()
                     resource.save()  # we want to trigger all the post_save signals
                 except Exception as e:
                     logger.warning(f"Error while updating schema instance: {e}")

geonode/metadata/handlers/doi.py

@@ -46,5 +46,6 @@ def get_jsonschema_instance(self, resource, field_name, context, errors, lang=No
         return resource.doi
 
     def update_resource(self, resource, field_name, json_instance, context, errors, **kwargs):
-        resource.doi = json_instance.get(field_name, None)
-        context.setdefault("base", {})[field_name] = json_instance.get(field_name, None)
+        doi_value = json_instance.get(field_name, None)
+        resource.doi = doi_value
+        context.setdefault("base", {})[field_name] = doi_value

geonode/metadata/manager.py

@@ -19,9 +19,11 @@
 
 import logging
 import copy
+from types import SimpleNamespace
 
 from django.utils.translation import gettext as _
 
+from geonode.base.models import ResourceBase
 from geonode.metadata.handlers.abstract import MetadataHandler
 from geonode.metadata.exceptions import UnsetFieldException
 from geonode.metadata.i18n import I18nCache
@@ -136,8 +138,7 @@ def update_schema_instance(self, resource, request_obj, lang=None, partial=None)
             if partial:
                 if fieldname not in partial:
                     continue
-                else:
-                    logger.debug(f"Storing partial field {fieldname}")
+                logger.debug(f"Storing partial field {fieldname}")
             handler = self.handlers[subschema["geonode:handler"]]
             try:
                 handler.update_resource(resource, fieldname, json_instance, context, errors)
@@ -164,12 +165,12 @@ def update_schema_instance(self, resource, request_obj, lang=None, partial=None)
                     ),
                 )
         try:
-            resource.get_real_concrete_instance_class().objects.filter(id=resource.id).update(
-                **context.setdefault("base")
-            )
-            resource.refresh_from_db()
+            if basefields := context.get("base", None):
+                ResourceBase.objects.filter(id=resource.id).update(**basefields)
+                resource.get_real_concrete_instance_class().objects.filter(id=resource.id).update(**basefields)
+                resource.refresh_from_db()
         except Exception as e:
-            logger.warning(f"Error while updating schema instance: {e}")
+            logger.warning(f"Error while updating schema instance: {e}", exc_info=e)
             MetadataHandler._set_error(
                 errors, [], MetadataHandler.localize_message(context, "metadata_error_save", {"exc": e})
             )
@@ -193,13 +194,13 @@ def update_schema_instance(self, resource, request_obj, lang=None, partial=None)
         return errors
 
     def update_schema_instance_partial(self, resource, json_instance, user, lang=None) -> dict:
+        if not json_instance:
+            return {}
         # We can't loop on the payload's field, since post_ or pre_ methods may rely on the whole instance
         # Let's create a full instance by using the old one, merged with the payload
         old_instance = self.build_schema_instance(resource, lang)
         old_instance.update(json_instance)
-        fake_req = lambda: None
-        fake_req.data = old_instance
-        fake_req.user = user
+        fake_req = SimpleNamespace(data=old_instance, user=user)
         return self.update_schema_instance(resource, fake_req, lang, partial=json_instance.keys())
 
 

geonode/metadata/tests/tests.py

@@ -918,8 +918,6 @@ def test_update_schema_instance_no_errors(self, mock_get_schema):
         expected_context = {"labels": {}, "user": self.test_user_1}
 
         mock_get_schema.return_value = self.fake_schema
-        # Mock the save method
-        self.resource.save = MagicMock()
 
         with patch.dict(metadata_manager.handlers, self.fake_handlers, clear=True):
 
@@ -945,9 +943,6 @@ def test_update_schema_instance_no_errors(self, mock_get_schema):
             # Assert no errors were raised
             self.assertEqual(errors, {})
 
-            # Check that resource.save() is called
-            self.resource.save.assert_called_once()
-
     @patch("geonode.metadata.manager.metadata_manager.get_schema")
     @patch("geonode.metadata.manager.MetadataHandler.localize_message")
     def test_update_schema_instance_with_handler_error(self, mock_localize_message, mock_get_schema):
@@ -959,9 +954,6 @@ def test_update_schema_instance_with_handler_error(self, mock_localize_message,
 
         mock_get_schema.return_value = self.fake_schema
 
-        # Mock the save method
-        self.resource.save = MagicMock()
-
         # Mock localize_message to return a custom error message
         mock_localize_message.side_effect = lambda context, msg_id, data: f"Error in handler: {data['exc']}"
 
@@ -984,46 +976,3 @@ def test_update_schema_instance_with_handler_error(self, mock_localize_message,
             self.handler1.update_resource.assert_called()
             self.handler2.update_resource.assert_called()
             self.handler3.update_resource.assert_called()
-
-            # Assert that resource.save() was called
-            self.resource.save.assert_called_once()
-
-            # Assert resource.save was called
-            self.resource.save.assert_called_once()
-
-    @patch("geonode.metadata.manager.metadata_manager.get_schema")
-    @patch("geonode.metadata.manager.MetadataHandler.localize_message")
-    def test_update_schema_instance_with_db_error(self, mock_localize_message, mock_get_schema):
-
-        # Fake request with data and user
-        mock_request = MagicMock()
-        mock_request.data = {"field1": "new_value1", "new_field2": "new_value2"}
-        mock_request.user = self.test_user_1
-
-        mock_get_schema.return_value = self.fake_schema
-
-        mock_localize_message.side_effect = (
-            lambda context, msg_id, data: f"Error while saving the resource: {data['exc']}"
-        )
-
-        # Mock save method with an exception
-        self.resource.save = MagicMock(side_effect=Exception("Error during the resource save"))
-
-        with patch.dict(metadata_manager.handlers, self.fake_handlers, clear=True):
-
-            self.handler1.update_resource.side_effect = None
-            self.handler2.update_resource.side_effect = None
-            self.handler3.update_resource.side_effect = None
-
-            # Call the method under test
-            errors = metadata_manager.update_schema_instance(self.resource, mock_request)
-
-            # Assert that update_resource was called for each handler
-            self.handler1.update_resource.assert_called()
-            self.handler2.update_resource.assert_called()
-            self.handler3.update_resource.assert_called()
-
-            # Assert that save raised an error and was recorded
-            self.resource.save.assert_called_once()
-            self.assertIn("__errors", errors)
-            self.assertEqual(errors["__errors"], ["Error while saving the resource: Error during the resource save"])