refactor(assistance): Serializer Unit Test Suite re-written to pytest for model KnowledgeBase

ref: #904 closes #900

app/assistance/tests/functional/knowledge_base/knowledge_base_serializer.py

@@ -75,142 +75,3 @@ class KnowledgeBaseValidationAPI(
         )
 
         self.item_has_target_team.target_team.set([ self.add_team ])
-
-
-
-    def test_serializer_validation_no_title(self):
-        """Serializer Validation Check
-
-        Ensure that if creating and no title is provided a validation error occurs
-        """
-
-        with pytest.raises(ValidationError) as err:
-
-            serializer = KnowledgeBaseModelSerializer(
-                context = {
-                    'request': self.mock_view.request,
-                    'view': self.mock_view,
-                },
-                data={
-                "organization": self.organization.id,
-                "content": "random note",
-                "target_user": self.add_user.id,
-                "target_team": [
-                    self.add_team.id
-                ],
-                "responsible_user": self.add_user.id,
-            })
-
-            serializer.is_valid(raise_exception = True)
-
-        assert err.value.get_codes()['title'][0] == 'required'
-
-
-
-    def test_serializer_validation_both_target_team_target_user(self):
-        """Serializer Validation Check
-
-        Ensure that both target user and target team raises a validation error
-        """
-
-        with pytest.raises(ValidationError) as err:
-
-            serializer = KnowledgeBaseModelSerializer(
-                context = {
-                    'request': self.mock_view.request,
-                    'view': self.mock_view,
-                },
-                data={
-                "organization": self.organization.id,
-                "title": "teamone",
-                "content": "random note",
-                "target_user": self.add_user.id,
-                "target_team": [
-                    self.add_team.id
-                ],
-                "responsible_user": self.add_user.id,
-            })
-
-            serializer.is_valid(raise_exception = True)
-
-        assert err.value.get_codes()['non_field_errors'][0] == 'invalid_not_both_target_team_user'
-
-
-
-    def test_serializer_validation_no_target_team_target_user(self):
-        """Serializer Validation Check
-
-        Ensure that if either target user and target team is missing it raises validation error
-        """
-
-
-        with pytest.raises(ValidationError) as err:
-
-            serializer = KnowledgeBaseModelSerializer(
-                context = {
-                    'request': self.mock_view.request,
-                    'view': self.mock_view,
-                },
-                data={
-                "organization": self.organization.id,
-                "title": 'teamone',
-                "content": 'random note',
-                "responsible_user": self.add_user.id,
-            })
-
-            serializer.is_valid(raise_exception = True)
-
-        assert err.value.get_codes()['non_field_errors'][0] == 'invalid_need_target_team_or_user'
-
-
-
-    def test_serializer_validation_update_existing_target_user(self):
-        """Serializer Validation Check
-
-        Ensure that if an existing item with target user is updated to include a target_team
-        it raises a validation error
-        """
-
-        with pytest.raises(ValidationError) as err:
-
-            serializer = KnowledgeBaseModelSerializer(
-                self.item_has_target_user,
-                context = {
-                    'request': self.mock_view.request,
-                    'view': self.mock_view,
-                },
-                data={
-                    "target_team": [ self.add_team.id ]
-                },
-                partial=True,
-            )
-
-            serializer.is_valid(raise_exception = True)
-
-        assert err.value.get_codes()['non_field_errors'][0] == 'invalid_not_both_target_team_user'
-
-
-    def test_serializer_validation_update_existing_target_team(self):
-        """Serializer Validation Check
-
-        Ensure that if an existing item with target team is updated to include a target_user
-        it raises a validation error
-        """
-
-        with pytest.raises(ValidationError) as err:
-
-            serializer = KnowledgeBaseModelSerializer(
-                self.item_has_target_team,
-                context = {
-                    'request': self.mock_view.request,
-                    'view': self.mock_view,
-                },
-                data={
-                    "target_user": self.add_user.id
-                },
-                partial=True,
-            )
-
-            serializer.is_valid(raise_exception = True)
-
-        assert err.value.get_codes()['non_field_errors'][0] == 'invalid_not_both_target_team_user'

app/assistance/tests/unit/knowledge_base/test_unit_knowledge_base_serializer.py

@@ -1,15 +1,249 @@
 import pytest
 
+from django.db import models
+
+from rest_framework.exceptions import ValidationError
+
 from api.tests.unit.test_unit_serializer import (
     SerializerTestCases
 )
 
+from centurion.tests.abstract.mock_view import MockView
+
+
 
 @pytest.mark.model_knowledgebase
 class KnowledgeBaseSerializerTestCases(
     SerializerTestCases
 ):
-    pass
+
+
+    @pytest.fixture( scope = 'function' )
+    def created_model(self, django_db_blocker, model, model_kwargs):
+
+        with django_db_blocker.unblock():
+
+            kwargs_many_to_many = {}
+
+            kwargs = {}
+
+            for key, value in model_kwargs.items():
+
+                field = model._meta.get_field(key)
+
+                if isinstance(field, models.ManyToManyField):
+
+                    kwargs_many_to_many.update({
+                        key: value
+                    })
+
+                else:
+
+                    kwargs.update({
+                        key: value
+                    })
+
+
+            item = model.objects.create( **kwargs )
+
+            for key, value in kwargs_many_to_many.items():
+
+                field = getattr(item, key)
+
+                for entry in value:
+
+                    field.add(entry)
+
+            yield item
+
+            item.delete()
+
+
+
+    def test_serializer_validation_no_title(self,
+        kwargs_api_create, model, model_serializer, request_user):
+        """Serializer Validation Check
+
+        Ensure that if creating and no title is provided a validation error occurs
+        """
+
+        mock_view = MockView(
+            user = request_user,
+            model = model,
+            action = 'create',
+        )
+
+        kwargs = kwargs_api_create.copy()
+        del kwargs['title']
+
+        with pytest.raises(ValidationError) as err:
+
+            serializer = model_serializer['model'](
+                context = {
+                    'request': mock_view.request,
+                    'view': mock_view,
+                },
+                data = kwargs
+            )
+
+            serializer.is_valid(raise_exception = True)
+
+        assert err.value.get_codes()['title'][0] == 'required'
+
+
+
+    def test_serializer_validation_both_target_team_target_user(self,
+        kwargs_api_create, model, model_serializer, request_user,
+        model_team, kwargs_team
+    ):
+        """Serializer Validation Check
+
+        Ensure that both target user and target team raises a validation error
+        """
+
+        mock_view = MockView(
+            user = request_user,
+            model = model,
+            action = 'create',
+        )
+
+        kwargs = kwargs_api_create.copy()
+        # team = model_team.objects.create( **kwargs_team )
+        kwargs.update({
+            'target_user': request_user.id
+        })
+
+        with pytest.raises(ValidationError) as err:
+
+            serializer = model_serializer['model'](
+                context = {
+                    'request': mock_view.request,
+                    'view': mock_view,
+                },
+                data = kwargs
+            )
+
+            serializer.is_valid(raise_exception = True)
+
+        # team.delete()
+
+        assert err.value.get_codes()['non_field_errors'][0] == 'invalid_not_both_target_team_user'
+
+
+
+    def test_serializer_validation_no_target_team_target_user(self,
+        kwargs_api_create, model, model_serializer, request_user,
+        model_team, kwargs_team
+    ):
+        """Serializer Validation Check
+
+        Ensure that if either target user and target team is missing it raises validation error
+        """
+
+        mock_view = MockView(
+            user = request_user,
+            model = model,
+            action = 'create',
+        )
+
+        kwargs = kwargs_api_create.copy()
+        del kwargs['target_team']
+
+        with pytest.raises(ValidationError) as err:
+
+            serializer = model_serializer['model'](
+                context = {
+                    'request': mock_view.request,
+                    'view': mock_view,
+                },
+                data = kwargs
+            )
+
+            serializer.is_valid(raise_exception = True)
+
+        assert err.value.get_codes()['non_field_errors'][0] == 'invalid_need_target_team_or_user'
+
+
+
+    def test_serializer_validation_update_existing_target_user(self,
+        kwargs_api_create, model, model_serializer, request_user,
+        model_team, kwargs_team
+    ):
+        """Serializer Validation Check
+
+        Ensure that if an existing item with target user is updated to include a target_team
+        it raises a validation error
+        """
+
+        mock_view = MockView(
+            user = request_user,
+            model = model,
+            action = 'create',
+        )
+
+        kwargs = kwargs_api_create.copy()
+        with pytest.raises(ValidationError) as err:
+
+            serializer = model_serializer['model'](
+                self.item_has_target_user,
+                context = {
+                    'request': mock_view.request,
+                    'view': mock_view,
+                },
+                data={
+                    "target_team": [ self.add_team.id ]
+                },
+                partial=True,
+            )
+
+            serializer.is_valid(raise_exception = True)
+
+        assert err.value.get_codes()['non_field_errors'][0] == 'invalid_not_both_target_team_user'
+
+
+    def test_serializer_validation_update_existing_target_user(self,
+        created_model,
+        kwargs_api_create, model, model_serializer, request_user,
+        model_team, kwargs_team
+    ):
+        """Serializer Validation Check
+
+        Ensure that if an existing item with target team is updated to include a target_user
+        it raises a validation error
+        """
+
+        mock_view = MockView(
+            user = request_user,
+            model = model,
+            action = 'create',
+        )
+
+        kwargs = kwargs_api_create.copy()
+        team = model_team.objects.create( **kwargs_team )
+        kwargs.update({
+            'target_team': [ team ]
+        })
+
+        with pytest.raises(ValidationError) as err:
+
+            serializer = model_serializer['model'](
+                created_model,
+                context = {
+                    'request': mock_view.request,
+                    'view': mock_view,
+                },
+                data={
+                    "target_user": request_user.id
+                },
+                partial=True,
+            )
+
+            serializer.is_valid(raise_exception = True)
+
+        team.delete()
+
+        assert err.value.get_codes()['non_field_errors'][0] == 'invalid_not_both_target_team_user'
+
 
 
 
@@ -20,7 +254,7 @@ class KnowledgeBaseSerializerInheritedCases(
 
 
 
-@pytest.mark.module_module_assistance
+@pytest.mark.module_assistance
 class KnowledgeBaseSerializerPyTest(
     KnowledgeBaseSerializerTestCases
 ):

app/centurion/tests/functional_models.py

@@ -72,7 +72,7 @@ class ModelTestCases:
 
                 for key, value in kwargs_many_to_many.items():
 
-                    field = getattr(item, 'target_team')
+                    field = getattr(item, key)
 
                     for entry in value: