Merge branch 'fix-recommend-removed' of 'https://github.com/jjmerchante/grimoirelab-sortinghat'

Merges #1006
Closes #1006

Author: sduenas

releases/unreleased/unavailable-individuals-in-recommendations.yml

@@ -0,0 +1,9 @@
+---
+title: Unavailable Individuals in Recommendations
+category: fixed
+author: Jose Javier Merchante <[email protected]>
+issue: null
+notes: >
+  Recommendations now handle cases where an individual has been
+  removed or merged, preventing errors when creating new
+  recommendations.

sortinghat/core/jobs.py

@@ -28,6 +28,8 @@
 import django_rq.utils
 import rq
 import redis.exceptions
+
+from django.core.exceptions import ObjectDoesNotExist
 from django.db import IntegrityError, transaction, connection
 from rq.job import Job
 
@@ -219,7 +221,7 @@ def recommend_affiliations(ctx, uuids=None, last_modified=MIN_PERIOD_DATE):
                 with transaction.atomic():
                     AffiliationRecommendation.objects.create(individual_id=rec.mk,
                                                              organization=org)
-            except IntegrityError:
+            except (IntegrityError, ObjectDoesNotExist):
                 logger.debug(
                     f"Job {job.id} 'Unable to create affiliation recommendation for"
                     f"Individual {rec.key} and Organization {org_name}"
@@ -317,16 +319,10 @@ def recommend_matches(ctx, source_uuids,
 
             indiv_1, indiv_2 = rec.mk, match
 
-            # Generate the recommendations sorting uuids alphabetical
-            if indiv_1 == indiv_2:
-                continue
-            elif indiv_1 > indiv_2:
-                indiv_1, indiv_2 = indiv_2, indiv_1
-
             try:
                 with transaction.atomic():
                     MergeRecommendation.objects.create(individual1_id=indiv_1, individual2_id=indiv_2)
-            except IntegrityError:
+            except (IntegrityError, ObjectDoesNotExist):
                 pass
 
     trxl.close()

tests/test_jobs.py

@@ -52,6 +52,7 @@
                                     AffiliationRecommendation,
                                     MergeRecommendation,
                                     GenderRecommendation)
+from sortinghat.core.recommendations import RecommendationEngine
 
 JOB_NOT_FOUND_ERROR = "DEF not found in the registry"
 
@@ -1243,6 +1244,60 @@ def test_not_found_uuid_error(self, mock_find_indv):
 
         self.assertDictEqual(result, expected)
 
+    @unittest.mock.patch('sortinghat.core.jobs.RecommendationEngine')
+    def test_recommend_matches_with_concurrent_removal(self, mock_recommendation_engine):
+        """Check if recommendations are obtained when an identity is removed while the job is running"""
+
+        ctx = SortingHatContext(self.user)
+
+        # Mock RecommendationEngine class to return a non-existing key and an existing one
+        def mock_recommend_matches(*args, **kwargs):
+            yield (self.john_smith.individual.mk,
+                   self.john_smith.individual.mk,
+                   ['non_existing_mk', self.jsmith.individual.mk])
+
+        class MockRecommendationEngine(RecommendationEngine):
+            RECOMMENDATION_TYPES = {
+                'matches': mock_recommend_matches,
+            }
+
+        mock_recommendation_engine.return_value = MockRecommendationEngine()
+
+        # Test
+        expected = {
+            'results': {
+                self.john_smith.uuid: sorted(['non_existing_mk', self.jsm3.individual.mk])
+            }
+        }
+        recommendations_expected = [
+            sorted([self.jsmith.individual.mk, self.john_smith.individual.mk])
+        ]
+
+        source_uuids = [self.john_smith.uuid]
+        target_uuids = [self.john_smith.uuid,
+                        self.jsmith.uuid]
+
+        criteria = ['email', 'name', 'username']
+
+        job = recommend_matches.delay(ctx,
+                                      source_uuids,
+                                      target_uuids,
+                                      criteria)
+        result = job.result
+
+        # Preserve job results order for the comparison against the expected results
+        for key in result['results']:
+            result['results'][key] = sorted(result['results'][key])
+
+        self.assertDictEqual(result, expected)
+
+        self.assertEqual(MergeRecommendation.objects.count(), 1)
+
+        for rec in recommendations_expected:
+            self.assertTrue(
+                MergeRecommendation.objects.filter(individual1=rec[0],
+                                                   individual2=rec[1]).exists())
+
     def test_transactions(self):
         """Check if the right transactions were created"""