OM-352: When deleting a worker, all group relations associated with t…

…hem must be removed

worker_voucher/gql_mutations.py

@@ -15,7 +15,7 @@
 from policyholder.models import PolicyHolder, PolicyHolderInsuree
 from policyholder.services import PolicyHolderInsuree as PolicyHolderInsureeService
 from worker_voucher.apps import WorkerVoucherConfig
-from worker_voucher.models import WorkerVoucher
+from worker_voucher.models import WorkerVoucher, WorkerGroup
 from worker_voucher.services import WorkerVoucherService, GroupOfWorkerService, validate_acquire_unassigned_vouchers, \
     validate_acquire_assigned_vouchers, validate_assign_vouchers, create_assigned_voucher, create_voucher_bill, \
     create_unassigned_voucher, assign_voucher, economic_unit_user_filter, check_existing_active_vouchers
@@ -144,10 +144,21 @@ def _delete_worker_for_eu(cls, user, worker_uuid, eu_uuid):
 
         today = datetime.datetime.now()
         check_existing_active_vouchers(eu_uuid, [phi.insuree.id], today)
+        cls._delete_worker_from_group(worker_uuid, eu_uuid)
 
         phi.delete(user=user)
         return []
 
+    @classmethod
+    def _delete_worker_from_group(cls, worker_uuid, eu_uuid):
+        workers_in_group = WorkerGroup.objects.filter(
+            group__policyholder__id=eu_uuid,
+            insuree__uuid=worker_uuid,
+            insuree__validity_to__isnull=True,
+            is_deleted=False
+        )
+        workers_in_group.delete()
+
 
 class CreateWorkerVoucherInput(OpenIMISMutation.Input):
     code = graphene.String(max_length=255, required=True)

worker_voucher/tests/data/gql_payloads.py

@@ -74,6 +74,18 @@
 }
 """
 
+gql_mutation_worker_delete_multiple = """
+mutation deleteWorker {
+  deleteWorker(input: {
+    uuids: ["%s", "%s", "%s"]
+    economicUnitCode: "%s"
+    clientMutationId: "%s"
+  }) {
+    clientMutationId
+  }
+}
+"""
+
 gql_mutation_create_group_of_worker = """
 mutation addGroupOfWorker {
   createOrUpdateGroupOfWorkers(input: {

worker_voucher/tests/test_gql_worker_delete.py

@@ -6,10 +6,21 @@
 from graphene.test import Client
 from core.test_helpers import create_test_interactive_user
 from insuree.models import Insuree
+from insuree.test_helpers import generate_random_insuree_number
+from insuree.apps import InsureeConfig
+from worker_voucher.models import WorkerGroup
 from worker_voucher.schema import Query, Mutation
 from worker_voucher.services import worker_user_filter
-from worker_voucher.tests.data.gql_payloads import gql_mutation_worker_delete
-from worker_voucher.tests.util import create_test_eu_for_user, create_test_worker_for_eu
+from worker_voucher.tests.data.gql_payloads import (
+    gql_mutation_worker_delete,
+    gql_mutation_worker_delete_multiple
+)
+from worker_voucher.tests.util import (
+    create_test_eu_for_user,
+    create_test_worker_for_eu,
+    create_test_group_of_worker,
+    create_test_worker_group
+)
 
 
 class GQLWorkerDeleteTestCase(TestCase):
@@ -21,6 +32,9 @@ def __init__(self, user):
     user2 = None
     eu = None
     worker = None
+    worker2 = None
+    worker3 = None
+    group = None
 
     @classmethod
     def setUpClass(cls):
@@ -30,6 +44,8 @@ def setUpClass(cls):
         cls.user2 = create_test_interactive_user(username='VoucherTestUser2', roles=[role_employer.id])
         cls.eu = create_test_eu_for_user(cls.user)
         cls.worker = create_test_worker_for_eu(cls.user, cls.eu)
+        cls.worker2 = create_test_worker_for_eu(cls.user, cls.eu, chf_id=F"{generate_random_insuree_number()}")
+        cls.worker3 = create_test_worker_for_eu(cls.user, cls.eu, chf_id=F"{generate_random_insuree_number()}")
 
         gql_schema = Schema(
             query=Query,
@@ -39,10 +55,11 @@ def setUpClass(cls):
         cls.gql_client = Client(gql_schema)
         cls.gql_context = cls.GQLContext(cls.user)
         cls.gql_context2 = cls.GQLContext(cls.user2)
+        cls.group = create_test_group_of_worker(cls.user, cls.eu, "GroupForTest")
 
     def test_delete_worker_success(self):
         workers_before = Insuree.objects.filter(worker_user_filter(self.user, economic_unit_code=self.eu.code)).count()
-        self.assertEquals(workers_before, 1)
+        self.assertEquals(workers_before, 3)
 
         mutation_id = uuid4()
         mutation = gql_mutation_worker_delete % (
@@ -56,11 +73,11 @@ def test_delete_worker_success(self):
         self._assert_mutation_success(mutation_id)
 
         workers_after = Insuree.objects.filter(worker_user_filter(self.user, economic_unit_code=self.eu.code)).count()
-        self.assertEquals(workers_after, 0)
+        self.assertEquals(workers_after, 2)
 
     def test_delete_worker_failed_no_worker(self):
         workers_before = Insuree.objects.filter(worker_user_filter(self.user, economic_unit_code=self.eu.code)).count()
-        self.assertEquals(workers_before, 1)
+        self.assertEquals(workers_before, 3)
 
         mutation_id = uuid4()
         mutation = gql_mutation_worker_delete % (
@@ -74,7 +91,58 @@ def test_delete_worker_failed_no_worker(self):
         self._assert_mutation_failed(mutation_id)
 
         workers_after = Insuree.objects.filter(worker_user_filter(self.user, economic_unit_code=self.eu.code)).count()
-        self.assertEquals(workers_after, 1)
+        self.assertEquals(workers_after, 3)
+
+    def test_delete_worker_with_group_success(self):
+        InsureeConfig.reset_validation_settings()
+        create_test_worker_group(self.user, self.worker, self.group)
+        workers_before = Insuree.objects.filter(worker_user_filter(self.user, economic_unit_code=self.eu.code)).count()
+        self.assertEquals(workers_before, 3)
+        workers_group_before = WorkerGroup.objects.filter(group__id=self.group.id)
+        self.assertEquals(workers_group_before.count(), 1)
+
+        mutation_id = uuid4()
+        mutation = gql_mutation_worker_delete % (
+            self.worker.uuid,
+            self.eu.code,
+            mutation_id
+        )
+
+        res = self.gql_client.execute(mutation, context=self.gql_context)
+        self.assertFalse(res.get("errors", None))
+        self._assert_mutation_success(mutation_id)
+
+        workers_after = Insuree.objects.filter(worker_user_filter(self.user, economic_unit_code=self.eu.code)).count()
+        self.assertEquals(workers_after, 2)
+        workers_group_after = WorkerGroup.objects.filter(group__id=self.group.id)
+        self.assertEquals(workers_group_after.count(), 0)
+
+    def test_delete_worker_multiple_with_group_success(self):
+        InsureeConfig.reset_validation_settings()
+        create_test_worker_group(self.user, self.worker, self.group)
+        create_test_worker_group(self.user, self.worker2, self.group)
+        workers_before = Insuree.objects.filter(worker_user_filter(self.user, economic_unit_code=self.eu.code)).count()
+        self.assertEquals(workers_before, 3)
+        workers_group = WorkerGroup.objects.filter(group__id=self.group.id)
+        self.assertEquals(workers_group.count(), 2)
+
+        mutation_id = uuid4()
+        mutation = gql_mutation_worker_delete_multiple % (
+            self.worker.uuid,
+            self.worker2.uuid,
+            self.worker3.uuid,
+            self.eu.code,
+            mutation_id
+        )
+
+        res = self.gql_client.execute(mutation, context=self.gql_context)
+        self.assertFalse(res.get("errors", None))
+        self._assert_mutation_success(mutation_id)
+
+        workers_after = Insuree.objects.filter(worker_user_filter(self.user, economic_unit_code=self.eu.code)).count()
+        self.assertEquals(workers_after, 0)
+        workers_group_after = WorkerGroup.objects.filter(group__id=self.group.id)
+        self.assertEquals(workers_group_after.count(), 0)
 
     def _assert_mutation_success(self, mutation_id):
         mutation_log = MutationLog.objects.get(client_mutation_id=mutation_id)