Merge pull request #932 from nofusscomputing/refactor-itim-tests

app/api/tests/functional/test_functional_api_fields.py

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

app/itim/tests/functional/cluster/conftest.py

@@ -0,0 +1,25 @@
+import pytest
+
+
+
+@pytest.fixture( scope = 'class')
+def model(model_cluster):
+
+    yield model_cluster
+
+
+@pytest.fixture( scope = 'class', autouse = True)
+def model_kwargs(request, kwargs_cluster):
+
+    request.cls.kwargs_create_item = kwargs_cluster.copy()
+
+    yield kwargs_cluster.copy()
+
+    if hasattr(request.cls, 'kwargs_create_item'):
+        del request.cls.kwargs_create_item
+
+
+@pytest.fixture( scope = 'class')
+def model_serializer(serializer_cluster):
+
+    yield serializer_cluster

app/itim/tests/functional/cluster/test_cluster_serializer.py

@@ -1,89 +0,0 @@
-import pytest
-
-from django.test import TestCase
-
-from rest_framework.exceptions import ValidationError
-
-from access.models.tenant import Tenant as Organization
-
-from centurion.tests.abstract.mock_view import MockView, User
-
-from itim.serializers.cluster import Cluster, ClusterModelSerializer
-
-
-
-class ClusterValidationAPI(
-    TestCase,
-):
-
-    model = Cluster
-
-    @classmethod
-    def setUpTestData(self):
-        """Setup Test
-
-        1. Create an org
-        2. Create an item
-        """
-
-        organization = Organization.objects.create(name='test_org')
-
-        self.user = User.objects.create_user(username="test_user_view", password="password")
-
-        self.organization = organization
-
-        self.item = self.model.objects.create(
-            organization=organization,
-            name = 'os name',
-        )
-
-        self.mock_view = MockView( user = self.user )
-
-
-
-    def test_serializer_validation_no_name(self):
-        """Serializer Validation Check
-
-        Ensure that if creating and no name is provided a validation error occurs
-        """
-
-        with pytest.raises(ValidationError) as err:
-
-            serializer = ClusterModelSerializer(
-                context = {
-                    'request': self.mock_view.request,
-                    'view': self.mock_view,
-                },
-                data={
-                "organization": self.organization.id,
-            })
-
-            serializer.is_valid(raise_exception = True)
-
-        assert err.value.get_codes()['name'][0] == 'required'
-
-
-
-    def test_serializer_validation_self_not_parent(self):
-        """Serializer Validation Check
-
-        Ensure that if assiging itself as parent a validation error occurs
-        """
-
-        with pytest.raises(ValidationError) as err:
-
-            serializer = ClusterModelSerializer(
-                self.item,
-                context = {
-                    'request': self.mock_view.request,
-                    'view': self.mock_view,
-                },
-                data={
-                    "parent_cluster": self.item.id,
-                },
-                partial = True
-            )
-
-            serializer.is_valid(raise_exception = True)
-
-        assert err.value.get_codes()['parent_cluster'] == 'parent_not_self'

app/itim/tests/functional/cluster/test_functional_cluster_api_fields.py

@@ -0,0 +1,170 @@
+import pytest
+
+from django.db import models
+
+from rest_framework.relations import Hyperlink
+
+from api.tests.functional.test_functional_api_fields import (
+    APIFieldsInheritedCases,
+)
+
+
+
+@pytest.mark.model_cluster
+class ClusterAPITestCases(
+    APIFieldsInheritedCases,
+):
+
+    @pytest.fixture( scope = 'class')
+    def second_model(self, request, django_db_blocker,
+        model, model_kwargs
+    ):
+
+        item = None
+
+        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
+                    })
+
+
+            # Switch model fields so all fields can be checked
+            kwargs_many_to_many.update({ 'devices': kwargs_many_to_many['nodes']})
+            del kwargs_many_to_many['nodes']
+            # del kwargs_many_to_many['target_team']
+
+            kwargs.update({ 'parent_cluster': self.item})
+
+
+            item_two = model.objects.create(
+                **kwargs
+            )
+
+
+            for key, value in kwargs_many_to_many.items():
+
+                field = getattr(item_two, key)
+
+                for entry in value:
+
+                    field.add(entry)
+
+
+            request.cls.item_two = item_two
+
+        yield item_two
+
+        with django_db_blocker.unblock():
+
+            item_two.delete()
+
+            del request.cls.item_two
+
+
+    @pytest.fixture( scope = 'class', autouse = True)
+    def class_setup(self,
+        create_model,
+        second_model,
+        make_request,
+    ):
+
+        pass
+
+    @property
+    def parameterized_api_fields(self):
+
+        return {
+            'parent_cluster': {
+                'expected': dict
+            },
+            'parent_cluster.id': {
+                'expected': int
+            },
+            'parent_cluster.display_name': {
+                'expected': str
+            },
+            'parent_cluster.url': {
+                'expected': Hyperlink
+            },
+            'cluster_type': {
+                'expected': dict
+            },
+            'cluster_type.id': {
+                'expected': int
+            },
+            'cluster_type.display_name': {
+                'expected': str
+            },
+            'cluster_type.url': {
+                'expected': Hyperlink
+            },
+            'name': {
+                'expected': str
+            },
+            'config': {
+                'expected': dict
+            },
+            'config.config_key_1': {
+                'expected': str
+            },
+            'nodes': {
+                'expected': list
+            },
+            'nodes.0.id': {
+                'expected': int
+            },
+            'nodes.0.display_name': {
+                'expected': str
+            },
+            'nodes.0.url': {
+                'expected': Hyperlink
+            },
+            'devices': {
+                'expected': list
+            },
+            'devices.0.id': {
+                'expected': int
+            },
+            'devices.0.display_name': {
+                'expected': str
+            },
+            'devices.0.url': {
+                'expected': Hyperlink
+            },
+            'modified': {
+                'expected': str
+            }
+        }
+
+
+
+class ClusterAPIInheritedCases(
+    ClusterAPITestCases,
+):
+    pass
+
+
+
+@pytest.mark.module_itim
+class ClusterAPIPyTest(
+    ClusterAPITestCases,
+):
+
+    pass

app/itim/tests/functional/cluster/test_functional_cluster_metadata.py

@@ -8,9 +8,10 @@ from access.models.tenant import Tenant as Organization
 from access.models.team import Team
 from access.models.team_user import TeamUsers
 
-from api.tests.abstract.api_permissions_viewset import APIPermissions
+from api.tests.abstract.test_metadata_functional import (
-from api.tests.abstract.api_serializer_viewset import SerializersTestCases
+    MetadataAttributesFunctional,
-from api.tests.abstract.test_metadata_functional import MetadataAttributesFunctional, MetaDataNavigationEntriesFunctional
+    MetaDataNavigationEntriesFunctional
+)
 
 from itim.models.clusters import Cluster
 
@@ -18,6 +19,7 @@ from settings.models.app_settings import AppSettings
 
 
 
+@pytest.mark.model_cluster
 class ViewSetBase:
 
     model = Cluster
@@ -214,18 +216,7 @@ class ViewSetBase:
 
 
 
-class ClusterPermissionsAPI(ViewSetBase, APIPermissions, TestCase):
+@pytest.mark.module_itim
-
-    pass
-
-
-
-class ClusterViewSet(ViewSetBase, SerializersTestCases, TestCase):
-
-    pass
-
-
-
 class ClusterMetadata(
     ViewSetBase,
     MetadataAttributesFunctional,

app/itim/tests/functional/cluster/test_functional_cluster_model.py

@@ -0,0 +1,28 @@
+import pytest
+
+from core.tests.functional.centurion_abstract.test_functional_centurion_abstract_model import (
+    CenturionAbstractModelInheritedCases
+)
+
+
+
+@pytest.mark.model_cluster
+class ClusterModelTestCases(
+    CenturionAbstractModelInheritedCases
+):
+    pass
+
+
+
+class ClusterModelInheritedCases(
+    ClusterModelTestCases,
+):
+    pass
+
+
+
+@pytest.mark.module_itim
+class ClusterModelPyTest(
+    ClusterModelTestCases,
+):
+    pass

app/itim/tests/functional/cluster_types/conftest.py

@@ -0,0 +1,25 @@
+import pytest
+
+
+
+@pytest.fixture( scope = 'class')
+def model(model_clustertype):
+
+    yield model_clustertype
+
+
+@pytest.fixture( scope = 'class', autouse = True)
+def model_kwargs(request, kwargs_clustertype):
+
+    request.cls.kwargs_create_item = kwargs_clustertype.copy()
+
+    yield kwargs_clustertype.copy()
+
+    if hasattr(request.cls, 'kwargs_create_item'):
+        del request.cls.kwargs_create_item
+
+
+@pytest.fixture( scope = 'class')
+def model_serializer(serializer_clustertype):
+
+    yield serializer_clustertype

app/itim/tests/functional/cluster_types/test_cluster_type_serializer.py

@@ -1,53 +0,0 @@
-import pytest
-
-from django.test import TestCase
-
-from rest_framework.exceptions import ValidationError
-
-from access.models.tenant import Tenant as Organization
-
-from itim.serializers.cluster_type import ClusterType, ClusterTypeModelSerializer
-
-
-
-class ClusterTypeValidationAPI(
-    TestCase,
-):
-
-    model = ClusterType
-
-    @classmethod
-    def setUpTestData(self):
-        """Setup Test
-
-        1. Create an org
-        2. Create an item
-        """
-
-        organization = Organization.objects.create(name='test_org')
-
-        self.organization = organization
-
-        self.item = self.model.objects.create(
-            organization=organization,
-            name = 'os name',
-        )
-
-
-
-    def test_serializer_validation_no_name(self):
-        """Serializer Validation Check
-
-        Ensure that if creating and no name is provided a validation error occurs
-        """
-
-        with pytest.raises(ValidationError) as err:
-
-            serializer = ClusterTypeModelSerializer(data={
-                "organization": self.organization.id,
-            })
-
-            serializer.is_valid(raise_exception = True)
-
-        assert err.value.get_codes()['name'][0] == 'required'
-

app/itim/tests/functional/cluster_types/test_functional_cluster_type_api_fields.py

@@ -0,0 +1,46 @@
+import pytest
+
+from api.tests.functional.test_functional_api_fields import (
+    APIFieldsInheritedCases,
+)
+
+
+
+@pytest.mark.model_clustertype
+class ClusterTypeAPITestCases(
+    APIFieldsInheritedCases,
+):
+
+    @property
+    def parameterized_api_fields(self):
+
+        return {
+            'name': {
+                'expected': str
+            },
+            'config': {
+                'expected': dict
+            },
+            'config.config_key_1': {
+                'expected': str
+            },
+            'modified': {
+                'expected': str
+            }
+        }
+
+
+
+class ClusterTypeAPIInheritedCases(
+    ClusterTypeAPITestCases,
+):
+    pass
+
+
+
+@pytest.mark.module_itim
+class ClusterTypeAPIPyTest(
+    ClusterTypeAPITestCases,
+):
+
+    pass

app/itim/tests/functional/cluster_types/test_functional_cluster_type_metadata.py

@@ -8,8 +8,6 @@ from access.models.tenant import Tenant as Organization
 from access.models.team import Team
 from access.models.team_user import TeamUsers
 
-from api.tests.abstract.api_permissions_viewset import APIPermissions
-from api.tests.abstract.api_serializer_viewset import SerializersTestCases
 from api.tests.abstract.test_metadata_functional import MetadataAttributesFunctional
 
 from itim.models.clusters import ClusterType
@@ -18,6 +16,7 @@ from settings.models.app_settings import AppSettings
 
 
 
+@pytest.mark.model_clustertype
 class ViewSetBase:
 
     model = ClusterType
@@ -213,18 +212,7 @@ class ViewSetBase:
 
 
 
-class ClusterTypePermissionsAPI(ViewSetBase, APIPermissions, TestCase):
+@pytest.mark.module_itim
-
-    pass
-
-
-
-class ClusterTypeViewSet(ViewSetBase, SerializersTestCases, TestCase):
-
-    pass
-
-
-
 class ClusterTypeMetadata(
     ViewSetBase,
     MetadataAttributesFunctional,

app/itim/tests/functional/cluster_types/test_functional_cluster_type_model.py

@@ -0,0 +1,28 @@
+import pytest
+
+from core.tests.functional.centurion_abstract.test_functional_centurion_abstract_model import (
+    CenturionAbstractModelInheritedCases
+)
+
+
+
+@pytest.mark.model_clustertype
+class ClusterTypeModelTestCases(
+    CenturionAbstractModelInheritedCases
+):
+    pass
+
+
+
+class ClusterTypeModelInheritedCases(
+    ClusterTypeModelTestCases,
+):
+    pass
+
+
+
+@pytest.mark.module_itim
+class ClusterTypeModelPyTest(
+    ClusterTypeModelTestCases,
+):
+    pass

app/itim/tests/functional/port/conftest.py

@@ -0,0 +1,19 @@
+import pytest
+
+
+
+@pytest.fixture( scope = 'class')
+def model(model_port):
+
+    yield model_port
+
+
+@pytest.fixture( scope = 'class', autouse = True)
+def model_kwargs(request, kwargs_port):
+
+    request.cls.kwargs_create_item = kwargs_port.copy()
+
+    yield kwargs_port.copy()
+
+    if hasattr(request.cls, 'kwargs_create_item'):
+        del request.cls.kwargs_create_item

app/itim/tests/functional/port/test_functional_port_api_fields.py

@@ -0,0 +1,46 @@
+import pytest
+
+from api.tests.functional.test_functional_api_fields import (
+    APIFieldsInheritedCases,
+)
+
+
+
+@pytest.mark.model_port
+class ClusterTypeAPITestCases(
+    APIFieldsInheritedCases,
+):
+
+    @property
+    def parameterized_api_fields(self):
+
+        return {
+            'number': {
+                'expected': int
+            },
+            'description': {
+                'expected': str
+            },
+            'protocol': {
+                'expected': str
+            },
+            'modified': {
+                'expected': str
+            }
+        }
+
+
+
+class ClusterTypeAPIInheritedCases(
+    ClusterTypeAPITestCases,
+):
+    pass
+
+
+
+@pytest.mark.module_itim
+class ClusterTypeAPIPyTest(
+    ClusterTypeAPITestCases,
+):
+
+    pass

app/itim/tests/functional/port/test_functional_port_metadata.py

@@ -8,8 +8,6 @@ from access.models.tenant import Tenant as Organization
 from access.models.team import Team
 from access.models.team_user import TeamUsers
 
-from api.tests.abstract.api_permissions_viewset import APIPermissions
-from api.tests.abstract.api_serializer_viewset import SerializersTestCases
 from api.tests.abstract.test_metadata_functional import MetadataAttributesFunctional
 
 from itim.models.services import Port
@@ -18,6 +16,7 @@ from settings.models.app_settings import AppSettings
 
 
 
+@pytest.mark.model_port
 class ViewSetBase:
 
     model = Port
@@ -218,18 +217,7 @@ class ViewSetBase:
 
 
 
-class PortPermissionsAPI(ViewSetBase, APIPermissions, TestCase):
+@pytest.mark.module_itim
-
-    pass
-
-
-
-class PortViewSet(ViewSetBase, SerializersTestCases, TestCase):
-
-    pass
-
-
-
 class PortMetadata(
     ViewSetBase,
     MetadataAttributesFunctional,

app/itim/tests/functional/port/test_functional_port_model.py

@@ -0,0 +1,28 @@
+import pytest
+
+from core.tests.functional.centurion_abstract.test_functional_centurion_abstract_model import (
+    CenturionAbstractModelInheritedCases
+)
+
+
+
+@pytest.mark.model_port
+class ClusterTypeModelTestCases(
+    CenturionAbstractModelInheritedCases
+):
+    pass
+
+
+
+class ClusterTypeModelInheritedCases(
+    ClusterTypeModelTestCases,
+):
+    pass
+
+
+
+@pytest.mark.module_itim
+class ClusterTypeModelPyTest(
+    ClusterTypeModelTestCases,
+):
+    pass

app/itim/tests/functional/port/test_port_serializer.py

@@ -1,111 +0,0 @@
-import pytest
-
-from django.test import TestCase
-
-from rest_framework.exceptions import ValidationError
-
-from access.models.tenant import Tenant as Organization
-
-from centurion.tests.abstract.mock_view import MockView, User
-
-from itim.serializers.port import Port, PortModelSerializer
-
-
-
-class PortValidationAPI(
-    TestCase,
-):
-
-    model = Port
-
-    @classmethod
-    def setUpTestData(self):
-        """Setup Test
-
-        1. Create an org
-        # 2. Create an item
-        """
-
-        organization = Organization.objects.create(name='test_org')
-
-        self.user = User.objects.create_user(username="test_user_view", password="password")
-
-        self.organization = organization
-
-        # self.item = self.model.objects.create(
-        #     organization=organization,
-        #     number = 'os name',
-        # )
-
-        self.mock_view = MockView( user = self.user )
-
-
-
-    def test_serializer_validation_can_create(self):
-        """Serializer Validation Check
-
-        Ensure that a valid item has no validation errors
-        """
-
-        serializer = PortModelSerializer(
-            context = {
-                'request': self.mock_view.request,
-                'view': self.mock_view,
-            },
-            data={
-            "organization": self.organization.id,
-            "number": 80,
-            "protocol": Port.Protocol.TCP
-        })
-
-        assert serializer.is_valid(raise_exception = True)
-
-
-
-    def test_serializer_validation_no_number(self):
-        """Serializer Validation Check
-
-        Ensure that if creating and no number is provided a validation error occurs
-        """
-
-        with pytest.raises(ValidationError) as err:
-
-            serializer = PortModelSerializer(
-                context = {
-                'request': self.mock_view.request,
-                'view': self.mock_view,
-            },
-            data={
-                "organization": self.organization.id,
-                # "number": 80,
-                "protocol": Port.Protocol.TCP
-            })
-
-            serializer.is_valid(raise_exception = True)
-
-        assert err.value.get_codes()['number'][0] == 'required'
-
-
-
-    def test_serializer_validation_no_protocol(self):
-        """Serializer Validation Check
-
-        Ensure that if creating and no protocol is provided a validation error occurs
-        """
-
-        with pytest.raises(ValidationError) as err:
-
-            serializer = PortModelSerializer(
-                context = {
-                    'request': self.mock_view.request,
-                    'view': self.mock_view,
-                },
-                data={
-                "organization": self.organization.id,
-                "number": 80,
-                # "protocol": Port.Protocol.TCP
-            })
-
-            serializer.is_valid(raise_exception = True)
-
-        assert err.value.get_codes()['protocol'][0] == 'required'

app/itim/tests/functional/service/conftest.py

@@ -0,0 +1,25 @@
+import pytest
+
+
+
+@pytest.fixture( scope = 'class')
+def model(model_service):
+
+    yield model_service
+
+
+@pytest.fixture( scope = 'class', autouse = True)
+def model_kwargs(request, kwargs_service):
+
+    request.cls.kwargs_create_item = kwargs_service.copy()
+
+    yield kwargs_service.copy()
+
+    if hasattr(request.cls, 'kwargs_create_item'):
+        del request.cls.kwargs_create_item
+
+
+@pytest.fixture( scope = 'class')
+def model_serializer(serializer_service):
+
+    yield serializer_service

app/itim/tests/functional/service/test_functional_service_api_fields.py

@@ -0,0 +1,214 @@
+import pytest
+
+from django.db import models
+
+from rest_framework.relations import Hyperlink
+
+from api.tests.functional.test_functional_api_fields import (
+    APIFieldsInheritedCases,
+)
+
+
+
+@pytest.mark.model_service
+class ServiceAPITestCases(
+    APIFieldsInheritedCases,
+):
+
+
+    @pytest.fixture( scope = 'class')
+    def second_model(self, request, django_db_blocker,
+        model, model_kwargs, model_cluster, kwargs_cluster
+    ):
+
+        item = None
+
+        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
+                    })
+
+            dep_kwargs = model_kwargs.copy()
+            dep_kwargs['name'] = 'dep service'
+            ports = dep_kwargs['port']
+            del dep_kwargs['port']
+            dependent_service = model.objects.create( **dep_kwargs )
+
+            for port in ports:
+                dependent_service.port.add( port )
+
+            template_kwargs = model_kwargs.copy()
+            template_kwargs['name'] = 'a template'
+            del template_kwargs['port']
+            template = model.objects.create( **template_kwargs )
+
+            kwargs_many_to_many.update({ 'dependent_service': [ dependent_service ]})
+
+            clu_kwargs = kwargs_cluster.copy()
+            nodes = clu_kwargs['nodes']
+            del clu_kwargs['nodes']
+            cluster = model_cluster.objects.create( **clu_kwargs )
+
+            for node in nodes:
+                cluster.nodes.add( node )
+
+            kwargs.update({
+                'cluster': cluster,
+                'template': template,
+            })
+            del kwargs['device']
+
+
+            item_two = model.objects.create(
+                **kwargs
+            )
+
+
+            for key, value in kwargs_many_to_many.items():
+
+                field = getattr(item_two, key)
+
+                for entry in value:
+
+                    field.add(entry)
+
+
+            request.cls.item_two = item_two
+
+        yield item_two
+
+        with django_db_blocker.unblock():
+
+            item_two.delete()
+            cluster.delete()
+            template.delete()
+
+            del request.cls.item_two
+
+
+    @pytest.fixture( scope = 'class', autouse = True)
+    def class_setup(self,
+        create_model,
+        second_model,
+        make_request,
+    ):
+
+        pass
+
+
+    @property
+    def parameterized_api_fields(self):
+
+        return {
+            'is_template': {
+                'expected': bool
+            },
+            'template': {
+                'expected': dict
+            },
+            'template.id': {
+                'expected': int
+            },
+            'template.display_name': {
+                'expected': str
+            },
+            'template.url': {
+                'expected': Hyperlink
+            },
+            'name': {
+                'expected': str
+            },
+            'device': {
+                'expected': dict
+            },
+            'device.id': {
+                'expected': int
+            },
+            'device.display_name': {
+                'expected': str
+            },
+            'device.url': {
+                'expected': Hyperlink
+            },
+            'cluster': {
+                'expected': dict
+            },
+            'cluster.id': {
+                'expected': int
+            },
+            'cluster.display_name': {
+                'expected': str
+            },
+            'cluster.url': {
+                'expected': Hyperlink
+            },
+            'config': {
+                'expected': dict
+            },
+            'config.config_key_1': {
+                'expected': str
+            },
+            'config_key_variable': {
+                'expected': str
+            },
+            'port': {
+                'expected': list
+            },
+            'port.0.id': {
+                'expected': int
+            },
+            'port.0.display_name': {
+                'expected': str
+            },
+            'port.0.url': {
+                'expected': Hyperlink
+            },
+            'dependent_service': {
+                'expected': list
+            },
+            'dependent_service.0.id': {
+                'expected': int
+            },
+            'dependent_service.0.display_name': {
+                'expected': str
+            },
+            'dependent_service.0.url': {
+                'expected': Hyperlink
+            },
+            'modified': {
+                'expected': str
+            }
+        }
+
+
+
+class ServiceAPIInheritedCases(
+    ServiceAPITestCases,
+):
+    pass
+
+
+
+@pytest.mark.module_itim
+class ServiceAPIPyTest(
+    ServiceAPITestCases,
+):
+
+    pass

app/itim/tests/functional/service/test_functional_service_metadata.py

@@ -8,8 +8,6 @@ from access.models.tenant import Tenant as Organization
 from access.models.team import Team
 from access.models.team_user import TeamUsers
 
-from api.tests.abstract.api_permissions_viewset import APIPermissions
-from api.tests.abstract.api_serializer_viewset import SerializersTestCases
 from api.tests.abstract.test_metadata_functional import MetadataAttributesFunctional, MetaDataNavigationEntriesFunctional
 
 from itam.models.device import Device
@@ -20,6 +18,7 @@ from settings.models.app_settings import AppSettings
 
 
 
+@pytest.mark.model_service
 class ViewSetBase:
 
     model = Service
@@ -238,18 +237,7 @@ class ViewSetBase:
 
 
 
-class ServicePermissionsAPI(ViewSetBase, APIPermissions, TestCase):
+@pytest.mark.module_itim
-
-    pass
-
-
-
-class ServiceViewSet(ViewSetBase, SerializersTestCases, TestCase):
-
-    pass
-
-
-
 class ServiceMetadata(
     ViewSetBase,
     MetadataAttributesFunctional,

app/itim/tests/functional/service/test_functional_service_model.py

@@ -0,0 +1,28 @@
+import pytest
+
+from core.tests.functional.centurion_abstract.test_functional_centurion_abstract_model import (
+    CenturionAbstractModelInheritedCases
+)
+
+
+
+@pytest.mark.model_service
+class ServiceModelTestCases(
+    CenturionAbstractModelInheritedCases
+):
+    pass
+
+
+
+class ServiceModelInheritedCases(
+    ServiceModelTestCases,
+):
+    pass
+
+
+
+@pytest.mark.module_itim
+class ServiceModelPyTest(
+    ServiceModelTestCases,
+):
+    pass

app/itim/tests/functional/service/test_service_serializer.py

@@ -1,363 +0,0 @@
-import pytest
-
-from django.test import TestCase
-
-from rest_framework.exceptions import ValidationError
-
-from access.models.tenant import Tenant as Organization
-
-from centurion.tests.abstract.mock_view import MockView, User
-
-from itam.models.device import Device
-
-from itim.models.services import Port
-
-from itim.models.clusters import Cluster
-from itim.serializers.service import Service, ServiceModelSerializer
-
-
-
-class ServiceValidationAPI(
-    TestCase,
-):
-
-    model = Service
-
-    @classmethod
-    def setUpTestData(self):
-        """Setup Test
-
-        1. Create an org
-        2. Create an item
-        """
-
-        organization = Organization.objects.create(name='test_org')
-
-        self.user = User.objects.create_user(username="test_user_view", password="password")
-
-        self.organization = organization
-
-        self.mock_view = MockView( user = self.user )
-
-
-        self.port = Port.objects.create(
-            organization = self.organization,
-            number = 80,
-            protocol = Port.Protocol.TCP
-        )
-
-        self.device = Device.objects.create(
-            organization = self.organization,
-            name = 'a-device'
-        )
-
-        self.cluster = Cluster.objects.create(
-            organization = self.organization,
-            name = 'a cluster'
-        )
-
-
-        self.item = self.model.objects.create(
-            organization=organization,
-            name = 'os name',
-            cluster = self.cluster,
-            config_key_variable = 'value'
-        )
-
-        self.item_two = self.model.objects.create(
-            organization=organization,
-            name = 'os name',
-            cluster = self.cluster,
-        )
-
-        self.item_two.dependent_service.set([ self.item ])
-
-
-        self.item_is_template = self.model.objects.create(
-            organization=organization,
-            name = 'os name',
-            is_template = True,
-        )
-
-        self.item_is_template.port.set([ self.port ])
-
-
-        self.item_is_template_no_port = self.model.objects.create(
-            organization=organization,
-            name = 'os name',
-            is_template = True,
-        )
-
-
-
-
-    def test_serializer_validation_can_create_device(self):
-        """Serializer Validation Check
-
-        Ensure that a valid item is serialized
-        """
-
-        serializer = ServiceModelSerializer(
-            context = {
-                'request': self.mock_view.request,
-                'view': self.mock_view,
-            },
-            data={
-                'organization': self.organization.id,
-                'name': 'service',
-                'port': [
-                    self.port.id
-                ],
-                'config_key_variable': 'a_key',
-                'device': self.device.id
-            },
-        )
-
-        assert serializer.is_valid(raise_exception = True)
-
-
-
-    def test_serializer_validation_can_create_cluster(self):
-        """Serializer Validation Check
-
-        Ensure that a valid item is serialized
-        """
-
-        serializer = ServiceModelSerializer(
-            context = {
-                'request': self.mock_view.request,
-                'view': self.mock_view,
-            },
-            data={
-                'organization': self.organization.id,
-                'name': 'service',
-                'port': [
-                    self.port.id
-                ],
-                'config_key_variable': 'a_key',
-                'cluster': self.cluster.id
-            },
-        )
-
-        assert serializer.is_valid(raise_exception = True)
-
-
-
-    def test_serializer_validation_no_name(self):
-        """Serializer Validation Check
-
-        Ensure that if creating and no name is provided a validation error occurs
-        """
-
-        with pytest.raises(ValidationError) as err:
-
-            serializer = ServiceModelSerializer(
-                context = {
-                    'request': self.mock_view.request,
-                    'view': self.mock_view,
-                },
-                data={
-                    'organization': self.organization.id,
-                    'port': [
-                        self.port.id
-                    ],
-                    'config_key_variable': 'a_key',
-                    'device': self.device.id
-            })
-
-            serializer.is_valid(raise_exception = True)
-
-        assert err.value.get_codes()['name'][0] == 'required'
-
-
-
-    def test_serializer_validation_no_port(self):
-        """Serializer Validation Check
-
-        Ensure that if creating and no port is provided a validation error occurs
-        """
-
-        with pytest.raises(ValidationError) as err:
-
-            serializer = ServiceModelSerializer(
-                context = {
-                    'request': self.mock_view.request,
-                    'view': self.mock_view,
-                },
-                data={
-                'organization': self.organization.id,
-                'name': 'service',
-                'config_key_variable': 'a_key',
-                'device': self.device.id
-            })
-
-            serializer.is_valid(raise_exception = True)
-
-        assert err.value.get_codes()['port'][0] == 'required'
-
-
-
-    def test_serializer_validation_no_port_required_if_template_with_port(self):
-        """Serializer Validation Check
-
-        Ensure that if creating and no port is provided and the template has a port
-        no validation error occurs
-        """
-
-        serializer = ServiceModelSerializer(
-            context = {
-                'request': self.mock_view.request,
-                'view': self.mock_view,
-            },
-            data={
-            'organization': self.organization.id,
-            'name': 'service',
-            'config_key_variable': 'a_key',
-            'device': self.device.id,
-            'template': self.item_is_template.id
-        })
-
-        assert serializer.is_valid(raise_exception = True)
-
-
-
-    def test_serializer_validation_template_without_port(self):
-        """Serializer Validation Check
-
-        Ensure that if creating a port is provided and the template has no port
-        no validation error occurs
-        """
-
-        serializer = ServiceModelSerializer(
-                context = {
-                    'request': self.mock_view.request,
-                    'view': self.mock_view,
-                },
-            data={
-            'organization': self.organization.id,
-            'name': 'service',
-            'port': [
-                self.port.id
-            ],
-            'config_key_variable': 'a_key',
-            'device': self.device.id,
-            'template': self.item_is_template_no_port.id
-        })
-
-        assert serializer.is_valid(raise_exception = True)
-
-
-
-    def test_serializer_validation_no_port_or_template_port(self):
-        """Serializer Validation Check
-
-        Ensure that if creating and no port is provided and the template
-        has no port a validation error occurs
-        """
-
-        with pytest.raises(ValidationError) as err:
-
-            serializer = ServiceModelSerializer(
-                context = {
-                    'request': self.mock_view.request,
-                    'view': self.mock_view,
-                },
-                data={
-                'organization': self.organization.id,
-                'name': 'service',
-                'config_key_variable': 'a_key',
-                'device': self.device.id,
-                'template': self.item_is_template_no_port.id
-            })
-
-            serializer.is_valid(raise_exception = True)
-
-        assert err.value.get_codes()['port'][0] == 'required'
-
-
-
-    def test_serializer_validation_no_device(self):
-        """Serializer Validation Check
-
-        Ensure that if creating and no device is provided a validation error occurs
-        """
-
-        with pytest.raises(ValidationError) as err:
-
-            serializer = ServiceModelSerializer(
-                context = {
-                    'request': self.mock_view.request,
-                    'view': self.mock_view,
-                },
-                data={
-                'organization': self.organization.id,
-                'name': 'service',
-                'port': [
-                    self.port.id
-                ],
-                'config_key_variable': 'a_key',
-            })
-
-            serializer.is_valid(raise_exception = True)
-
-        assert err.value.get_codes()['non_field_errors'][0] == 'one_of_cluster_or_device'
-
-
-
-    def test_serializer_validation_device_and_cluster(self):
-        """Serializer Validation Check
-
-        Ensure that if creating and a cluster and device is provided
-        a validation error occurs
-        """
-
-        with pytest.raises(ValidationError) as err:
-
-            serializer = ServiceModelSerializer(
-                context = {
-                    'request': self.mock_view.request,
-                    'view': self.mock_view,
-                },
-                data={
-                'organization': self.organization.id,
-                'name': 'service',
-                'port': [
-                    self.port.id
-                ],
-                'config_key_variable': 'a_key',
-                'device': self.device.id,
-                'cluster': self.cluster.id
-            })
-
-            serializer.is_valid(raise_exception = True)
-
-        assert err.value.get_codes()['non_field_errors'][0] == 'either_cluster_or_device'
-
-
-
-    def test_serializer_validation_no_circular_dependency(self):
-        """Serializer Validation Check
-
-        Ensure that if creating and a dependent service loop
-        a validation error occurs
-        """
-
-        with pytest.raises(ValidationError) as err:
-
-            serializer = ServiceModelSerializer(
-                self.item,
-                context = {
-                    'request': self.mock_view.request,
-                    'view': self.mock_view,
-                },
-                data={
-                    'dependent_service': [
-                        self.item_two.id
-                    ],
-                },
-                partial = True
-            )
-
-            serializer.is_valid(raise_exception = True)
-
-        assert err.value.get_codes()['dependent_service'][0] == 'no_circular_dependencies'

app/itim/tests/unit/cluster/conftest.py

@@ -17,3 +17,9 @@ def model_kwargs(request, kwargs_cluster):
 
     if hasattr(request.cls, 'kwargs_create_item'):
         del request.cls.kwargs_create_item
+
+
+@pytest.fixture( scope = 'class')
+def model_serializer(serializer_cluster):
+
+    yield serializer_cluster

app/itim/tests/unit/cluster/test_cluster_api_v2.py

@@ -1,491 +0,0 @@
-import pytest
-
-from django.contrib.auth.models import Permission, User
-from django.contrib.contenttypes.models import ContentType
-from django.shortcuts import reverse
-from django.test import Client, TestCase
-
-from rest_framework.relations import Hyperlink
-
-from access.models.tenant import Tenant as Organization
-from access.models.team import Team
-from access.models.team_user import TeamUsers
-
-from api.tests.abstract.api_fields import APITenancyObject
-
-from itam.models.device import Device
-
-from itim.models.clusters import Cluster, ClusterType
-
-
-
-@pytest.mark.model_cluster
-@pytest.mark.module_itim
-class ClusterAPI(
-    TestCase,
-    APITenancyObject
-):
-
-    model = Cluster
-
-    @classmethod
-    def setUpTestData(self):
-        """Setup Test
-
-        1. Create an organization for user and item
-        2. Create an item
-
-        """
-
-        self.organization = Organization.objects.create(name='test_org')
-
-        node = Device.objects.create(
-            organization = self.organization,
-            name = 'node',
-        )
-
-        device = Device.objects.create(
-            organization = self.organization,
-            name = 'device',
-            is_virtual = True,
-        )
-
-        cluster_type = ClusterType.objects.create(
-            organization = self.organization,
-            name = 'cluster_type'
-        )
-
-        parent_cluster = Cluster.objects.create(
-            organization = self.organization,
-            name = 'two'
-        )
-
-        self.item = self.model.objects.create(
-            organization = self.organization,
-            name = 'one',
-            cluster_type = cluster_type,
-            config = dict({"one": "two"}),
-            parent_cluster = parent_cluster,
-            model_notes = 'a note'
-        )
-
-        self.item.devices.set([ device ])
-
-        self.item.nodes.set([ node ])
-
-
-        self.url_view_kwargs = {'pk': self.item.id}
-
-        view_permissions = Permission.objects.get(
-                codename = 'view_' + self.model._meta.model_name,
-                content_type = ContentType.objects.get(
-                    app_label = self.model._meta.app_label,
-                    model = self.model._meta.model_name,
-                )
-            )
-
-        view_team = Team.objects.create(
-            team_name = 'view_team',
-            organization = self.organization,
-        )
-
-        view_team.permissions.set([view_permissions])
-
-        self.view_user = User.objects.create_user(username="test_user_view", password="password")
-        teamuser = TeamUsers.objects.create(
-            team = view_team,
-            user = self.view_user
-        )
-
-        client = Client()
-        url = reverse('v2:_api_cluster-detail', kwargs=self.url_view_kwargs)
-
-
-        client.force_login(self.view_user)
-        response = client.get(url)
-
-        self.api_data = response.data
-
-
-    def test_api_field_exists_config(self):
-        """ Test for existance of API Field
-
-        config field must exist
-        """
-
-        assert 'config' in self.api_data
-
-
-    def test_api_field_type_config(self):
-        """ Test for type for API Field
-
-        config field must be dict
-        """
-
-        assert type(self.api_data['config']) is dict
-
-
-    def test_api_field_exists_rendered_config(self):
-        """ Test for existance of API Field
-
-        rendered_config field must exist
-        """
-
-        assert 'rendered_config' in self.api_data
-
-
-    def test_api_field_type_rendered_config(self):
-        """ Test for type for API Field
-
-        rendered_config field must be dict
-        """
-
-        assert type(self.api_data['rendered_config']) is dict
-
-
-    def test_api_field_exists_resources(self):
-        """ Test for existance of API Field
-
-        resources field must exist
-        """
-
-        assert 'resources' in self.api_data
-
-
-    def test_api_field_type_resources(self):
-        """ Test for type for API Field
-
-        resources field must be dict
-        """
-
-        assert type(self.api_data['resources']) is str
-
-
-
-    def test_api_field_exists_nodes(self):
-        """ Test for existance of API Field
-
-        nodes field must exist
-        """
-
-        assert 'nodes' in self.api_data
-
-
-    def test_api_field_type_nodes(self):
-        """ Test for type for API Field
-
-        nodes field must be dict
-        """
-
-        assert type(self.api_data['nodes'][0]) is dict
-
-
-    def test_api_field_exists_nodes_id(self):
-        """ Test for existance of API Field
-
-        nodes.id field must exist
-        """
-
-        assert 'id' in self.api_data['nodes'][0]
-
-
-    def test_api_field_type_nodes_id(self):
-        """ Test for type for API Field
-
-        nodes.id field must be int
-        """
-
-        assert type(self.api_data['nodes'][0]['id']) is int
-
-
-    def test_api_field_exists_nodes_display_name(self):
-        """ Test for existance of API Field
-
-        nodes.display_name field must exist
-        """
-
-        assert 'display_name' in self.api_data['nodes'][0]
-
-
-    def test_api_field_type_nodes_display_name(self):
-        """ Test for type for API Field
-
-        nodes.display_name field must be str
-        """
-
-        assert type(self.api_data['nodes'][0]['display_name']) is str
-
-
-    def test_api_field_exists_nodes_url(self):
-        """ Test for existance of API Field
-
-        nodes.url field must exist
-        """
-
-        assert 'url' in self.api_data['nodes'][0]
-
-
-    def test_api_field_type_nodes_url(self):
-        """ Test for type for API Field
-
-        nodes.url field must be Hyperlink
-        """
-
-        assert type(self.api_data['nodes'][0]['url']) is Hyperlink
-
-
-
-    def test_api_field_exists_devices(self):
-        """ Test for existance of API Field
-
-        devices field must exist
-        """
-
-        assert 'devices' in self.api_data
-
-
-    def test_api_field_type_devices(self):
-        """ Test for type for API Field
-
-        devices field must be list
-        """
-
-        assert type(self.api_data['devices']) is list
-
-
-    def test_api_field_exists_devices_id(self):
-        """ Test for existance of API Field
-
-        devices.id field must exist
-        """
-
-        assert 'id' in self.api_data['devices'][0]
-
-
-    def test_api_field_type_devices_id(self):
-        """ Test for type for API Field
-
-        devices.id field must be int
-        """
-
-        assert type(self.api_data['devices'][0]['id']) is int
-
-
-    def test_api_field_exists_devices_display_name(self):
-        """ Test for existance of API Field
-
-        devices.display_name field must exist
-        """
-
-        assert 'display_name' in self.api_data['devices'][0]
-
-
-    def test_api_field_type_devices_display_name(self):
-        """ Test for type for API Field
-
-        devices.display_name field must be str
-        """
-
-        assert type(self.api_data['devices'][0]['display_name']) is str
-
-
-    def test_api_field_exists_devices_url(self):
-        """ Test for existance of API Field
-
-        devices.url field must exist
-        """
-
-        assert 'url' in self.api_data['devices'][0]
-
-
-    def test_api_field_type_devices_url(self):
-        """ Test for type for API Field
-
-        devices.url field must be Hyperlink
-        """
-
-        assert type(self.api_data['devices'][0]['url']) is Hyperlink
-
-
-
-    def test_api_field_exists_cluster_type(self):
-        """ Test for existance of API Field
-
-        cluster_type field must exist
-        """
-
-        assert 'cluster_type' in self.api_data
-
-
-    def test_api_field_type_cluster_type(self):
-        """ Test for type for API Field
-
-        cluster_type field must be dict
-        """
-
-        assert type(self.api_data['cluster_type']) is dict
-
-
-    def test_api_field_exists_cluster_type_id(self):
-        """ Test for existance of API Field
-
-        cluster_type.id field must exist
-        """
-
-        assert 'id' in self.api_data['cluster_type']
-
-
-    def test_api_field_type_cluster_type_id(self):
-        """ Test for type for API Field
-
-        cluster_type.id field must be int
-        """
-
-        assert type(self.api_data['cluster_type']['id']) is int
-
-
-    def test_api_field_exists_cluster_type_display_name(self):
-        """ Test for existance of API Field
-
-        cluster_type.display_name field must exist
-        """
-
-        assert 'display_name' in self.api_data['cluster_type']
-
-
-    def test_api_field_type_cluster_type_display_name(self):
-        """ Test for type for API Field
-
-        cluster_type.display_name field must be str
-        """
-
-        assert type(self.api_data['cluster_type']['display_name']) is str
-
-
-    def test_api_field_exists_cluster_type_url(self):
-        """ Test for existance of API Field
-
-        cluster_type.url field must exist
-        """
-
-        assert 'url' in self.api_data['cluster_type']
-
-
-    def test_api_field_type_cluster_type_url(self):
-        """ Test for type for API Field
-
-        cluster_type.url field must be Hyperlink
-        """
-
-        assert type(self.api_data['cluster_type']['url']) is Hyperlink
-
-
-
-    def test_api_field_exists_parent_cluster(self):
-        """ Test for existance of API Field
-
-        parent_cluster field must exist
-        """
-
-        assert 'parent_cluster' in self.api_data
-
-
-    def test_api_field_type_parent_cluster(self):
-        """ Test for type for API Field
-
-        parent_cluster field must be dict
-        """
-
-        assert type(self.api_data['parent_cluster']) is dict
-
-
-    def test_api_field_exists_parent_cluster_id(self):
-        """ Test for existance of API Field
-
-        parent_cluster.id field must exist
-        """
-
-        assert 'id' in self.api_data['parent_cluster']
-
-
-    def test_api_field_type_parent_cluster_id(self):
-        """ Test for type for API Field
-
-        parent_cluster.id field must be int
-        """
-
-        assert type(self.api_data['parent_cluster']['id']) is int
-
-
-    def test_api_field_exists_parent_cluster_display_name(self):
-        """ Test for existance of API Field
-
-        parent_cluster.display_name field must exist
-        """
-
-        assert 'display_name' in self.api_data['parent_cluster']
-
-
-    def test_api_field_type_parent_cluster_display_name(self):
-        """ Test for type for API Field
-
-        parent_cluster.display_name field must be str
-        """
-
-        assert type(self.api_data['parent_cluster']['display_name']) is str
-
-
-    def test_api_field_exists_parent_cluster_url(self):
-        """ Test for existance of API Field
-
-        parent_cluster.url field must exist
-        """
-
-        assert 'url' in self.api_data['parent_cluster']
-
-
-    def test_api_field_type_parent_cluster_url(self):
-        """ Test for type for API Field
-
-        parent_cluster.url field must be Hyperlink
-        """
-
-        assert type(self.api_data['parent_cluster']['url']) is Hyperlink
-
-
-
-    def test_api_field_exists_urls_tickets(self):
-        """ Test for existance of API Field
-
-        _urls.tickets field must exist
-        """
-
-        assert 'tickets' in self.api_data['_urls']
-
-
-    def test_api_field_type_urls_tickets(self):
-        """ Test for type for API Field
-
-        _urls.tickets field must be str
-        """
-
-        assert type(self.api_data['_urls']['tickets']) is str
-
-
-
-    def test_api_field_exists_urls_external_links(self):
-        """ Test for existance of API Field
-
-        _urls.external_links field must exist
-        """
-
-        assert 'external_links' in self.api_data['_urls']
-
-
-    def test_api_field_type_urls_external_links(self):
-        """ Test for type for API Field
-
-        _urls.external_links field must be str
-        """
-
-        assert type(self.api_data['_urls']['external_links']) is str

app/itim/tests/unit/cluster/test_cluster_item_ticket_api_v2.py

@@ -1,99 +0,0 @@
-import pytest
-
-from django.shortcuts import reverse
-from django.test import Client, TestCase
-
-from core.tests.abstract.test_item_ticket_api_v2 import ItemTicketAPI
-
-from core.models.ticket.ticket_linked_items import TicketLinkedItem
-
-from itim.models.clusters import Cluster
-
-
-
-@pytest.mark.skip( reason = 'this ticket model is depreciated' )
-@pytest.mark.model_cluster
-@pytest.mark.module_itim
-class ClusterItemTicketAPI(
-    ItemTicketAPI,
-    TestCase,
-):
-    """Test Cases for Item Tickets
-
-    Args:
-        APITenancyObject (class): Base class for ALL field checks
-    """
-
-    item_type = TicketLinkedItem.Modules.CLUSTER
-
-    item_class = 'cluster'
-
-    item_model = Cluster
-
-
-    @classmethod
-    def setUpTestData(self):
-        """Setup Test
-
-        1. Create an organization for user and item
-        2. Create an item
-
-        """
-
-        super().setUpTestData()
-
-
-        self.linked_item = self.item_model.objects.create(
-            organization = self.organization,
-            name = 'dev'
-        )
-
-
-
-        self.item = self.model.objects.create(
-            organization = self.organization,
-            ticket = self.ticket,
-
-            # Item attributes
-
-            item = self.linked_item.id,
-            item_type = self.item_type,
-        )
-
-
-
-        self.url_view_kwargs = {
-            'item_class': self.item_class,
-            'item_id': self.item.id,
-            'pk': self.item.id,
-        }
-
-
-        client = Client()
-        url = reverse('v2:_api_v2_item_tickets-detail', kwargs=self.url_view_kwargs)
-
-
-        client.force_login(self.view_user)
-        response = client.get(url)
-
-        self.api_data = response.data
-
-
-
-    def test_api_field_value_item_id(self):
-        """ Test for existance of API Field
-
-        item.id field must exist
-        """
-
-        assert  self.api_data['item']['id'] == self.linked_item.id
-
-
-
-    def test_api_field_value_item_type(self):
-        """ Test for type for API Field
-
-        item_type field must be int
-        """
-
-        assert self.api_data['item_type'] == self.item_type

app/itim/tests/unit/cluster/test_unit_cluster_serializer.py

@@ -0,0 +1,142 @@
+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_cluster
+class ClusterSerializerTestCases(
+    SerializerTestCases
+):
+
+
+    @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_name(self,
+        kwargs_api_create, model, model_serializer, request_user
+    ):
+        """Serializer Validation Check
+
+        Ensure that if creating and no name is provided a validation error occurs
+        """
+
+        mock_view = MockView(
+            user = request_user,
+            model = model,
+            action = 'create',
+        )
+
+        kwargs = kwargs_api_create.copy()
+        del kwargs['name']
+
+        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()['name'][0] == 'required'
+
+
+
+    def test_serializer_validation_self_not_parent(self,
+        created_model,
+        kwargs_api_create, model, model_serializer, request_user
+    ):
+        """Serializer Validation Check
+
+        Ensure that if assiging itself as parent a validation error occurs
+        """
+
+        mock_view = MockView(
+            user = request_user,
+            model = model,
+            action = 'create',
+        )
+
+        with pytest.raises(ValidationError) as err:
+
+            serializer = model_serializer['model'](
+                created_model,
+                context = {
+                    'request': mock_view.request,
+                    'view': mock_view,
+                },
+                data={
+                    "parent_cluster":created_model.id,
+                },
+                partial = True
+            )
+
+            serializer.is_valid(raise_exception = True)
+
+        assert err.value.get_codes()['parent_cluster'] == 'parent_not_self'
+
+
+
+class ClusterSerializerInheritedCases(
+    ClusterSerializerTestCases
+):
+    pass
+
+
+
+@pytest.mark.module_itim
+class ClusterSerializerPyTest(
+    ClusterSerializerTestCases
+):
+    pass

app/itim/tests/unit/cluster/test_unit_cluster_viewset.py

@@ -1,45 +1,86 @@
 import pytest
 
-from django.test import Client, TestCase
-
-from rest_framework.reverse import reverse
-
 from api.tests.unit.test_unit_common_viewset import ModelViewSetInheritedCases
 
-from itim.viewsets.cluster import ViewSet
+from itim.viewsets.cluster import (
+    Cluster,
+    ViewSet,
+)
 
 
 
-@pytest.mark.skip(reason = 'see #895, tests being refactored')
 @pytest.mark.model_cluster
-@pytest.mark.module_itim
+class ViewsetTestCases(
-class ClusterViewsetList(
     ModelViewSetInheritedCases,
-    TestCase,
 ):
 
-    viewset = ViewSet
 
-    route_name = 'v2:_api_cluster'
+    @pytest.fixture( scope = 'function' )
+    def viewset(self):
+        return ViewSet
 
 
-    @classmethod
+    @property
-    def setUpTestData(self):
+    def parameterized_class_attributes(self):
-        """Setup Test
+        return {
-
+            '_model_documentation': {
-        1. make list request
+                'type': type(None),
-        """
+            },
-
+            'back_url': {
-        super().setUpTestData()
+                'type': type(None),
+            },
+            'documentation': {
+                'type': type(None),
+                'value': None
+            },
+            'filterset_fields': {
+                'value': [
+                    'parent_cluster',
+                    'cluster_type',
+                    'nodes',
+                    'devices'
+                ]
+            },
+            'model': {
+                'value': Cluster
+            },
+            'model_documentation': {
+                'type': type(None),
+            },
+            'queryset': {
+                'type': type(None),
+            },
+            'serializer_class': {
+                'type': type(None),
+            },
+            'search_fields': {
+                'value': [
+                    'name',
+                ]
+            },
+            'view_description': {
+                'value': 'Physical Devices'
+            },
+            'view_name': {
+                'type': type(None),
+            },
+            'view_serializer_name': {
+                'type': type(None),
+            }
+        }
 
 
-        client = Client()
 
-        url = reverse(
+class ClusterViewsetInheritedCases(
-            self.route_name + '-list',
+    ViewsetTestCases,
-            kwargs = self.kwargs
+):
-        )
+    pass
 
-        client.force_login(self.view_user)
 
-        self.http_options_response_list = client.options(url)
+
+@pytest.mark.module_itim
+class ClusterViewsetPyTest(
+    ViewsetTestCases,
+):
+
+    pass

app/itim/tests/unit/cluster_types/conftest.py

@@ -17,3 +17,9 @@ def model_kwargs(request, kwargs_clustertype):
 
     if hasattr(request.cls, 'kwargs_create_item'):
         del request.cls.kwargs_create_item
+
+
+@pytest.fixture( scope = 'class')
+def model_serializer(serializer_clustertype):
+
+    yield serializer_clustertype

app/itim/tests/unit/cluster_types/test_cluster_type_api_v2.py

@@ -1,96 +0,0 @@
-import pytest
-
-from django.contrib.auth.models import Permission, User
-from django.contrib.contenttypes.models import ContentType
-from django.shortcuts import reverse
-from django.test import Client, TestCase
-
-from rest_framework.relations import Hyperlink
-
-from access.models.tenant import Tenant as Organization
-from access.models.team import Team
-from access.models.team_user import TeamUsers
-
-from api.tests.abstract.api_fields import APITenancyObject
-
-from itim.models.clusters import ClusterType
-
-
-
-@pytest.mark.model_clustertype
-@pytest.mark.module_itim
-class ClusterTypeAPI(
-    TestCase,
-    APITenancyObject
-):
-
-    model = ClusterType
-
-    @classmethod
-    def setUpTestData(self):
-        """Setup Test
-
-        1. Create an organization for user and item
-        2. Create an item
-
-        """
-
-        self.organization = Organization.objects.create(name='test_org')
-
-        self.item = self.model.objects.create(
-            organization = self.organization,
-            name = 'one',
-            config = dict({"one": "two"}),
-            model_notes = 'a note'
-        )
-
-        self.url_view_kwargs = {'pk': self.item.id}
-
-        view_permissions = Permission.objects.get(
-                codename = 'view_' + self.model._meta.model_name,
-                content_type = ContentType.objects.get(
-                    app_label = self.model._meta.app_label,
-                    model = self.model._meta.model_name,
-                )
-            )
-
-        view_team = Team.objects.create(
-            team_name = 'view_team',
-            organization = self.organization,
-        )
-
-        view_team.permissions.set([view_permissions])
-
-        self.view_user = User.objects.create_user(username="test_user_view", password="password")
-        teamuser = TeamUsers.objects.create(
-            team = view_team,
-            user = self.view_user
-        )
-
-        client = Client()
-        url = reverse('v2:_api_clustertype-detail', kwargs=self.url_view_kwargs)
-
-
-        client.force_login(self.view_user)
-        response = client.get(url)
-
-        self.api_data = response.data
-
-
-    def test_api_field_exists_config(self):
-        """ Test for existance of API Field
-
-        config field must exist
-        """
-
-        assert 'config' in self.api_data
-
-
-    def test_api_field_type_config(self):
-        """ Test for type for API Field
-
-        config field must be dict
-        """
-
-        assert type(self.api_data['config']) is dict
-

app/itim/tests/unit/cluster_types/test_unit_cluster_type_model.py

@@ -21,7 +21,7 @@ class ClusterModelTestCases(
         return {
             'model_tag': {
                 'type': str,
-                'value': 'cluster'
+                'value': 'cluster_type'
             },
         }
 

app/itim/tests/unit/cluster_types/test_unit_cluster_type_serializer.py

@@ -0,0 +1,107 @@
+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_clustertype
+class ClusterTypeSerializerTestCases(
+    SerializerTestCases
+):
+
+
+    @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_name(self,
+        kwargs_api_create, model, model_serializer, request_user
+    ):
+        """Serializer Validation Check
+
+        Ensure that if creating and no name is provided a validation error occurs
+        """
+
+        mock_view = MockView(
+            user = request_user,
+            model = model,
+            action = 'create',
+        )
+
+        kwargs = kwargs_api_create.copy()
+        del kwargs['name']
+
+        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()['name'][0] == 'required'
+
+
+
+class ClusterTypeSerializerInheritedCases(
+    ClusterTypeSerializerTestCases
+):
+    pass
+
+
+
+@pytest.mark.module_itim
+class ClusterTypeSerializerPyTest(
+    ClusterTypeSerializerTestCases
+):
+    pass

app/itim/tests/unit/cluster_types/test_unit_cluster_types_viewset.py

@@ -1,46 +1,83 @@
 import pytest
 
-from django.test import Client, TestCase
-
-from rest_framework.reverse import reverse
-
 from api.tests.unit.test_unit_common_viewset import ModelViewSetInheritedCases
 
-from itim.viewsets.cluster_type import ViewSet
+from itim.viewsets.cluster_type import (
+    ClusterType,
+    ViewSet,
+)
 
 
 
-@pytest.mark.skip(reason = 'see #895, tests being refactored')
 @pytest.mark.model_clustertype
-@pytest.mark.module_itim
+class ViewsetTestCases(
-class ClusterTypesViewsetList(
     ModelViewSetInheritedCases,
-    TestCase,
 ):
 
-    viewset = ViewSet
 
-    route_name = 'v2:_api_clustertype'
+    @pytest.fixture( scope = 'function' )
+    def viewset(self):
+        return ViewSet
 
 
-    @classmethod
+    @property
-    def setUpTestData(self):
+    def parameterized_class_attributes(self):
-        """Setup Test
+        return {
-
+            '_model_documentation': {
-        1. make list request
+                'type': type(None),
-        """
+            },
+            'back_url': {
+                'type': type(None),
+            },
+            'documentation': {
+                'type': type(None),
+                'value': None
+            },
+            'filterset_fields': {
+                'value': [
+                    'organization'
+                ]
+            },
+            'model': {
+                'value': ClusterType
+            },
+            'model_documentation': {
+                'type': type(None),
+            },
+            'queryset': {
+                'type': type(None),
+            },
+            'serializer_class': {
+                'type': type(None),
+            },
+            'search_fields': {
+                'value': [
+                    'name',
+                ]
+            },
+            'view_description': {
+                'value': 'Physical Devices'
+            },
+            'view_name': {
+                'type': type(None),
+            },
+            'view_serializer_name': {
+                'type': type(None),
+            }
+        }
 
 
-        super().setUpTestData()
+
+class ClusterTypeViewsetInheritedCases(
+    ViewsetTestCases,
+):
+    pass
 
 
-        client = Client()
-        
-        url = reverse(
-            self.route_name + '-list',
-            kwargs = self.kwargs
-        )
 
-        client.force_login(self.view_user)
+@pytest.mark.module_itim
+class ClusterTypeViewsetPyTest(
+    ViewsetTestCases,
+):
 
-        self.http_options_response_list = client.options(url)
+    pass

app/itim/tests/unit/port/conftest.py

@@ -17,3 +17,9 @@ def model_kwargs(request, kwargs_port):
 
     if hasattr(request.cls, 'kwargs_create_item'):
         del request.cls.kwargs_create_item
+
+
+@pytest.fixture( scope = 'class')
+def model_serializer(serializer_port):
+
+    yield serializer_port

app/itim/tests/unit/port/test_port_api_v2.py

@@ -1,135 +0,0 @@
-import pytest
-
-from django.contrib.auth.models import Permission, User
-from django.contrib.contenttypes.models import ContentType
-from django.shortcuts import reverse
-from django.test import Client, TestCase
-
-from rest_framework.relations import Hyperlink
-
-from access.models.tenant import Tenant as Organization
-from access.models.team import Team
-from access.models.team_user import TeamUsers
-
-from api.tests.abstract.api_fields import APITenancyObject
-
-from itim.models.services import Port
-
-
-
-@pytest.mark.model_port
-@pytest.mark.module_itim
-class PortAPI(
-    TestCase,
-    APITenancyObject
-):
-
-    model = Port
-
-    @classmethod
-    def setUpTestData(self):
-        """Setup Test
-
-        1. Create an organization for user and item
-        2. Create an item
-
-        """
-
-        self.organization = Organization.objects.create(name='test_org')
-
-        self.item = self.model.objects.create(
-            organization = self.organization,
-            number = 80,
-            protocol = Port.Protocol.TCP,
-            description = 'one',
-            model_notes = 'a note'
-        )
-
-        self.url_view_kwargs = {'pk': self.item.id}
-
-        view_permissions = Permission.objects.get(
-                codename = 'view_' + self.model._meta.model_name,
-                content_type = ContentType.objects.get(
-                    app_label = self.model._meta.app_label,
-                    model = self.model._meta.model_name,
-                )
-            )
-
-        view_team = Team.objects.create(
-            team_name = 'view_team',
-            organization = self.organization,
-        )
-
-        view_team.permissions.set([view_permissions])
-
-        self.view_user = User.objects.create_user(username="test_user_view", password="password")
-        teamuser = TeamUsers.objects.create(
-            team = view_team,
-            user = self.view_user
-        )
-
-        client = Client()
-        url = reverse('v2:_api_port-detail', kwargs=self.url_view_kwargs)
-
-
-        client.force_login(self.view_user)
-        response = client.get(url)
-
-        self.api_data = response.data
-
-
-
-    def test_api_field_exists_number(self):
-        """ Test for existance of API Field
-
-        number field must exist
-        """
-
-        assert 'number' in self.api_data
-
-
-    def test_api_field_type_number(self):
-        """ Test for type for API Field
-
-        number field must be int
-        """
-
-        assert type(self.api_data['number']) is int
-
-
-
-    def test_api_field_exists_description(self):
-        """ Test for existance of API Field
-
-        description field must exist
-        """
-
-        assert 'description' in self.api_data
-
-
-    def test_api_field_type_description(self):
-        """ Test for type for API Field
-
-        description field must be str
-        """
-
-        assert type(self.api_data['description']) is str
-
-
-
-    def test_api_field_exists_protocol(self):
-        """ Test for existance of API Field
-
-        protocol field must exist
-        """
-
-        assert 'protocol' in self.api_data
-
-
-    def test_api_field_type_protocol(self):
-        """ Test for type for API Field
-
-        protocol field must be str
-        """
-
-        assert type(self.api_data['protocol']) is str

app/itim/tests/unit/port/test_unit_port_serializer.py

@@ -0,0 +1,98 @@
+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_port
+class PortSerializerTestCases(
+    SerializerTestCases
+):
+
+
+    def test_serializer_validation_no_number(self,
+        kwargs_api_create, model, model_serializer, request_user
+    ):
+        """Serializer Validation Check
+
+        Ensure that if creating and no number is provided a validation error occurs
+        """
+
+        mock_view = MockView(
+            user = request_user,
+            model = model,
+            action = 'create',
+        )
+
+        kwargs = kwargs_api_create.copy()
+        del kwargs['number']
+
+        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()['number'][0] == 'required'
+
+
+
+    def test_serializer_validation_no_protocol(self,
+        kwargs_api_create, model, model_serializer, request_user
+    ):
+        """Serializer Validation Check
+
+        Ensure that if creating and no protocol is provided a validation error occurs
+        """
+
+        mock_view = MockView(
+            user = request_user,
+            model = model,
+            action = 'create',
+        )
+
+        kwargs = kwargs_api_create.copy()
+        del kwargs['protocol']
+
+        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()['protocol'][0] == 'required'
+
+
+
+class PortSerializerInheritedCases(
+    PortSerializerTestCases
+):
+    pass
+
+
+
+@pytest.mark.module_itim
+class PortSerializerPyTest(
+    PortSerializerTestCases
+):
+    pass

app/itim/tests/unit/port/test_unit_port_viewset.py

@@ -1,46 +1,84 @@
 import pytest
 
-from django.test import Client, TestCase
-
-from rest_framework.reverse import reverse
-
 from api.tests.unit.test_unit_common_viewset import ModelViewSetInheritedCases
 
-from itim.viewsets.port import ViewSet
+from itim.viewsets.port import (
+    Port,
+    ViewSet,
+)
 
 
 
-@pytest.mark.skip(reason = 'see #895, tests being refactored')
 @pytest.mark.model_port
-@pytest.mark.module_itim
+class ViewsetTestCases(
-class PortViewsetList(
     ModelViewSetInheritedCases,
-    TestCase,
 ):
 
-    viewset = ViewSet
 
-    route_name = 'v2:_api_port'
+    @pytest.fixture( scope = 'function' )
+    def viewset(self):
+        return ViewSet
 
 
-    @classmethod
+    @property
-    def setUpTestData(self):
+    def parameterized_class_attributes(self):
-        """Setup Test
+        return {
-
+            '_model_documentation': {
-        1. make list request
+                'type': type(None),
-        """
+            },
+            'back_url': {
+                'type': type(None),
+            },
+            'documentation': {
+                'type': type(None),
+                'value': None
+            },
+            'filterset_fields': {
+                'value': [
+                    'number',
+                    'protocol'
+                ]
+            },
+            'model': {
+                'value': Port
+            },
+            'model_documentation': {
+                'type': type(None),
+            },
+            'queryset': {
+                'type': type(None),
+            },
+            'serializer_class': {
+                'type': type(None),
+            },
+            'search_fields': {
+                'value': [
+                    'description'
+                ]
+            },
+            'view_description': {
+                'value': 'Physical Devices'
+            },
+            'view_name': {
+                'type': type(None),
+            },
+            'view_serializer_name': {
+                'type': type(None),
+            }
+        }
 
 
-        super().setUpTestData()
+
+class PortViewsetInheritedCases(
+    ViewsetTestCases,
+):
+    pass
 
 
-        client = Client()
-        
-        url = reverse(
-            self.route_name + '-list',
-            kwargs = self.kwargs
-        )
 
-        client.force_login(self.view_user)
+@pytest.mark.module_itim
+class PortViewsetPyTest(
+    ViewsetTestCases,
+):
 
-        self.http_options_response_list = client.options(url)
+    pass

app/itim/tests/unit/service/conftest.py

@@ -17,3 +17,9 @@ def model_kwargs(request, kwargs_service):
 
     if hasattr(request.cls, 'kwargs_create_item'):
         del request.cls.kwargs_create_item
+
+
+@pytest.fixture( scope = 'class')
+def model_serializer(serializer_service):
+
+    yield serializer_service

app/itim/tests/unit/service/test_service_api_v2.py

@@ -1,593 +0,0 @@
-import pytest
-
-from django.contrib.auth.models import Permission, User
-from django.contrib.contenttypes.models import ContentType
-from django.shortcuts import reverse
-from django.test import Client, TestCase
-
-from rest_framework.relations import Hyperlink
-
-from access.models.tenant import Tenant as Organization
-from access.models.team import Team
-from access.models.team_user import TeamUsers
-
-from api.tests.abstract.api_fields import APITenancyObject
-
-from itam.models.device import Device
-
-from itim.models.clusters import Cluster
-from itim.models.services import Service, Port
-
-
-
-@pytest.mark.model_service
-@pytest.mark.module_itim
-class ServiceAPI(
-    TestCase,
-    APITenancyObject
-):
-
-    model = Service
-
-    @classmethod
-    def setUpTestData(self):
-        """Setup Test
-
-        1. Create an organization for user and item
-        2. Create an item
-
-        """
-
-        self.organization = Organization.objects.create(name='test_org')
-
-        port = Port.objects.create(
-            organization = self.organization,
-            number = 80,
-            protocol = Port.Protocol.TCP
-        )
-
-        device = Device.objects.create(
-            organization = self.organization,
-            name = 'device-one'
-        )
-
-
-        cluster = Cluster.objects.create(
-            organization = self.organization,
-            name = 'cluster one'
-        )
-
-
-        dependent_service = self.model.objects.create(
-            organization = self.organization,
-            name = 'one',
-        )
-
-        self.item = self.model.objects.create(
-            organization = self.organization,
-            name = 'one',
-            model_notes = 'a note',
-            device = device,
-            config = dict({ "one": "two"}),
-            is_template = True,
-            config_key_variable = 'boo'
-        )
-
-        self.item_two = self.model.objects.create(
-            organization = self.organization,
-            name = 'one',
-            model_notes = 'a note',
-            cluster = cluster,
-            template = self.item
-        )
-
-
-        self.item.port.set([ port ])
-
-        self.item.dependent_service.set([ dependent_service ])
-
-
-        self.url_view_kwargs = {'pk': self.item.id}
-
-        view_permissions = Permission.objects.get(
-                codename = 'view_' + self.model._meta.model_name,
-                content_type = ContentType.objects.get(
-                    app_label = self.model._meta.app_label,
-                    model = self.model._meta.model_name,
-                )
-            )
-
-        view_team = Team.objects.create(
-            team_name = 'view_team',
-            organization = self.organization,
-        )
-
-        view_team.permissions.set([view_permissions])
-
-        self.view_user = User.objects.create_user(username="test_user_view", password="password")
-        teamuser = TeamUsers.objects.create(
-            team = view_team,
-            user = self.view_user
-        )
-
-        client = Client()
-        url = reverse('v2:_api_service-detail', kwargs=self.url_view_kwargs)
-
-
-        client.force_login(self.view_user)
-        response = client.get(url)
-
-        self.api_data = response.data
-
-
-        url = reverse('v2:_api_service-detail', kwargs={'pk': self.item_two.id})
-
-        client.force_login(self.view_user)
-        response = client.get(url)
-
-        self.api_data_two = response.data
-
-
-
-    def test_api_field_exists_config(self):
-        """ Test for existance of API Field
-
-        config field must exist
-        """
-
-        assert 'config' in self.api_data
-
-
-    def test_api_field_type_config(self):
-        """ Test for type for API Field
-
-        config field must be dict
-        """
-
-        assert type(self.api_data['config']) is dict
-
-
-
-    def test_api_field_exists_rendered_config(self):
-        """ Test for existance of API Field
-
-        rendered_config field must exist
-        """
-
-        assert 'rendered_config' in self.api_data
-
-
-    def test_api_field_type_rendered_config(self):
-        """ Test for type for API Field
-
-        rendered_config field must be dict
-        """
-
-        assert type(self.api_data['rendered_config']) is dict
-
-
-
-    def test_api_field_exists_is_template(self):
-        """ Test for existance of API Field
-
-        is_template field must exist
-        """
-
-        assert 'is_template' in self.api_data
-
-
-    def test_api_field_type_is_template(self):
-        """ Test for type for API Field
-
-        is_template field must be bool
-        """
-
-        assert type(self.api_data['is_template']) is bool
-
-
-
-    def test_api_field_exists_template(self):
-        """ Test for existance of API Field
-
-        template field must exist
-        """
-
-        assert 'template' in self.api_data_two
-
-
-    def test_api_field_type_template(self):
-        """ Test for type for API Field
-
-        template field must be dict
-        """
-
-        assert type(self.api_data_two['template']) is dict
-
-
-
-    def test_api_field_exists_template_id(self):
-        """ Test for existance of API Field
-
-        template.id field must exist
-        """
-
-        assert 'id' in self.api_data_two['template']
-
-
-    def test_api_field_type_template_id(self):
-        """ Test for type for API Field
-
-        template.id field must be int
-        """
-
-        assert type(self.api_data_two['template']['id']) is int
-
-
-    def test_api_field_exists_template_display_name(self):
-        """ Test for existance of API Field
-
-        template.display_name field must exist
-        """
-
-        assert 'display_name' in self.api_data_two['template']
-
-
-    def test_api_field_type_template_display_name(self):
-        """ Test for type for API Field
-
-        template.display_name field must be str
-        """
-
-        assert type(self.api_data_two['template']['display_name']) is str
-
-
-    def test_api_field_exists_template_url(self):
-        """ Test for existance of API Field
-
-        template.url field must exist
-        """
-
-        assert 'url' in self.api_data_two['template']
-
-
-    def test_api_field_type_template_url(self):
-        """ Test for type for API Field
-
-        template.url field must be Hyperlink
-        """
-
-        assert type(self.api_data_two['template']['url']) is Hyperlink
-
-
-
-    def test_api_field_exists_config_key_variable(self):
-        """ Test for existance of API Field
-
-        config_key_variable field must exist
-        """
-
-        assert 'config_key_variable' in self.api_data
-
-
-    def test_api_field_type_config_key_variable(self):
-        """ Test for type for API Field
-
-        config_key_variable field must be str
-        """
-
-        assert type(self.api_data['config_key_variable']) is str
-
-
-
-    def test_api_field_exists_dependent_service(self):
-        """ Test for existance of API Field
-
-        dependent_service field must exist
-        """
-
-        assert 'dependent_service' in self.api_data
-
-
-    def test_api_field_type_dependent_service(self):
-        """ Test for type for API Field
-
-        dependent_service field must be list
-        """
-
-        assert type(self.api_data['dependent_service']) is list
-
-
-
-    def test_api_field_exists_dependent_service_id(self):
-        """ Test for existance of API Field
-
-        dependent_service.id field must exist
-        """
-
-        assert 'id' in self.api_data['dependent_service'][0]
-
-
-    def test_api_field_type_dependent_service_id(self):
-        """ Test for type for API Field
-
-        dependent_service.id field must be int
-        """
-
-        assert type(self.api_data['dependent_service'][0]['id']) is int
-
-
-    def test_api_field_exists_dependent_service_display_name(self):
-        """ Test for existance of API Field
-
-        dependent_service.display_name field must exist
-        """
-
-        assert 'display_name' in self.api_data['dependent_service'][0]
-
-
-    def test_api_field_type_dependent_service_display_name(self):
-        """ Test for type for API Field
-
-        dependent_service.display_name field must be str
-        """
-
-        assert type(self.api_data['dependent_service'][0]['display_name']) is str
-
-
-    def test_api_field_exists_dependent_service_url(self):
-        """ Test for existance of API Field
-
-        dependent_service.url field must exist
-        """
-
-        assert 'url' in self.api_data['dependent_service'][0]
-
-
-    def test_api_field_type_dependent_service_url(self):
-        """ Test for type for API Field
-
-        dependent_service.url field must be Hyperlink
-        """
-
-        assert type(self.api_data['dependent_service'][0]['url']) is Hyperlink
-
-
-
-    def test_api_field_exists_port(self):
-        """ Test for existance of API Field
-
-        port field must exist
-        """
-
-        assert 'port' in self.api_data
-
-
-    def test_api_field_type_port(self):
-        """ Test for type for API Field
-
-        port field must be list
-        """
-
-        assert type(self.api_data['port']) is list
-
-
-
-    def test_api_field_exists_port_id(self):
-        """ Test for existance of API Field
-
-        port.id field must exist
-        """
-
-        assert 'id' in self.api_data['port'][0]
-
-
-    def test_api_field_type_port_id(self):
-        """ Test for type for API Field
-
-        port.id field must be int
-        """
-
-        assert type(self.api_data['port'][0]['id']) is int
-
-
-    def test_api_field_exists_port_display_name(self):
-        """ Test for existance of API Field
-
-        port.display_name field must exist
-        """
-
-        assert 'display_name' in self.api_data['port'][0]
-
-
-    def test_api_field_type_port_display_name(self):
-        """ Test for type for API Field
-
-        port.display_name field must be str
-        """
-
-        assert type(self.api_data['port'][0]['display_name']) is str
-
-
-    def test_api_field_exists_port_url(self):
-        """ Test for existance of API Field
-
-        port.url field must exist
-        """
-
-        assert 'url' in self.api_data['port'][0]
-
-
-    def test_api_field_type_port_url(self):
-        """ Test for type for API Field
-
-        port.url field must be Hyperlink
-        """
-
-        assert type(self.api_data['port'][0]['url']) is Hyperlink
-
-
-
-    def test_api_field_exists_device(self):
-        """ Test for existance of API Field
-
-        device field must exist
-        """
-
-        assert 'device' in self.api_data
-
-
-    def test_api_field_type_device(self):
-        """ Test for type for API Field
-
-        device field must be dict
-        """
-
-        assert type(self.api_data['device']) is dict
-
-
-
-    def test_api_field_exists_device_id(self):
-        """ Test for existance of API Field
-
-        device.id field must exist
-        """
-
-        assert 'id' in self.api_data['device']
-
-
-    def test_api_field_type_device_id(self):
-        """ Test for type for API Field
-
-        device.id field must be int
-        """
-
-        assert type(self.api_data['device']['id']) is int
-
-
-    def test_api_field_exists_device_display_name(self):
-        """ Test for existance of API Field
-
-        device.display_name field must exist
-        """
-
-        assert 'display_name' in self.api_data['device']
-
-
-    def test_api_field_type_device_display_name(self):
-        """ Test for type for API Field
-
-        device.display_name field must be str
-        """
-
-        assert type(self.api_data['device']['display_name']) is str
-
-
-    def test_api_field_exists_device_url(self):
-        """ Test for existance of API Field
-
-        device.url field must exist
-        """
-
-        assert 'url' in self.api_data['device']
-
-
-    def test_api_field_type_device_url(self):
-        """ Test for type for API Field
-
-        device.url field must be Hyperlink
-        """
-
-        assert type(self.api_data['device']['url']) is Hyperlink
-
-
-
-    def test_api_field_exists_cluster(self):
-        """ Test for existance of API Field
-
-        cluster field must exist
-        """
-
-        assert 'cluster' in self.api_data_two
-
-
-    def test_api_field_type_cluster(self):
-        """ Test for type for API Field
-
-        cluster field must be list
-        """
-
-        assert type(self.api_data_two['cluster']) is dict
-
-
-
-    def test_api_field_exists_cluster_id(self):
-        """ Test for existance of API Field
-
-        cluster.id field must exist
-        """
-
-        assert 'id' in self.api_data_two['cluster']
-
-
-    def test_api_field_type_cluster_id(self):
-        """ Test for type for API Field
-
-        cluster.id field must be int
-        """
-
-        assert type(self.api_data_two['cluster']['id']) is int
-
-
-    def test_api_field_exists_cluster_display_name(self):
-        """ Test for existance of API Field
-
-        cluster.display_name field must exist
-        """
-
-        assert 'display_name' in self.api_data_two['cluster']
-
-
-    def test_api_field_type_cluster_display_name(self):
-        """ Test for type for API Field
-
-        cluster.display_name field must be str
-        """
-
-        assert type(self.api_data_two['cluster']['display_name']) is str
-
-
-    def test_api_field_exists_cluster_url(self):
-        """ Test for existance of API Field
-
-        cluster.url field must exist
-        """
-
-        assert 'url' in self.api_data_two['cluster']
-
-
-    def test_api_field_type_cluster_url(self):
-        """ Test for type for API Field
-
-        cluster.url field must be Hyperlink
-        """
-
-        assert type(self.api_data_two['cluster']['url']) is Hyperlink
-
-
-
-    def test_api_field_exists_urls_tickets(self):
-        """ Test for existance of API Field
-
-        _urls.tickets field must exist
-        """
-
-        assert 'tickets' in self.api_data['_urls']
-
-
-    def test_api_field_type_urls_tickets(self):
-        """ Test for type for API Field
-
-        _urls.tickets field must be str
-        """
-
-        assert type(self.api_data['_urls']['tickets']) is str

app/itim/tests/unit/service/test_service_item_ticket_api_v2.py

@@ -1,98 +0,0 @@
-import pytest
-
-from django.shortcuts import reverse
-from django.test import Client, TestCase
-
-from core.tests.abstract.test_item_ticket_api_v2 import ItemTicketAPI
-
-from core.models.ticket.ticket_linked_items import TicketLinkedItem
-
-from itim.models.services import Service
-
-
-@pytest.mark.skip( reason = 'this ticket model is depreciated' )
-@pytest.mark.model_service
-@pytest.mark.module_itim
-class ServiceItemTicketAPI(
-    ItemTicketAPI,
-    TestCase,
-):
-    """Test Cases for Item Tickets
-
-    Args:
-        APITenancyObject (class): Base class for ALL field checks
-    """
-
-    item_type = TicketLinkedItem.Modules.SERVICE
-
-    item_class = 'service'
-
-    item_model = Service
-
-
-    @classmethod
-    def setUpTestData(self):
-        """Setup Test
-
-        1. Create an organization for user and item
-        2. Create an item
-
-        """
-
-        super().setUpTestData()
-
-
-        self.linked_item = self.item_model.objects.create(
-            organization = self.organization,
-            name = 'dev'
-        )
-
-
-
-        self.item = self.model.objects.create(
-            organization = self.organization,
-            ticket = self.ticket,
-
-            # Item attributes
-
-            item = self.linked_item.id,
-            item_type = self.item_type,
-        )
-
-
-
-        self.url_view_kwargs = {
-            'item_class': self.item_class,
-            'item_id': self.item.id,
-            'pk': self.item.id,
-        }
-
-
-        client = Client()
-        url = reverse('v2:_api_v2_item_tickets-detail', kwargs=self.url_view_kwargs)
-
-
-        client.force_login(self.view_user)
-        response = client.get(url)
-
-        self.api_data = response.data
-
-
-
-    def test_api_field_value_item_id(self):
-        """ Test for existance of API Field
-
-        item.id field must exist
-        """
-
-        assert  self.api_data['item']['id'] == self.linked_item.id
-
-
-
-    def test_api_field_value_item_type(self):
-        """ Test for type for API Field
-
-        item_type field must be int
-        """
-
-        assert self.api_data['item_type'] == self.item_type

app/itim/tests/unit/service/test_unit_service_serializer.py

@@ -0,0 +1,421 @@
+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_service
+class ServiceSerializerTestCases(
+    SerializerTestCases
+):
+
+
+    @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_name(self,
+        kwargs_api_create, model, model_serializer, request_user
+    ):
+        """Serializer Validation Check
+
+        Ensure that if creating and no name is provided a validation error occurs
+        """
+
+        mock_view = MockView(
+            user = request_user,
+            model = model,
+            action = 'create',
+        )
+
+        kwargs = kwargs_api_create.copy()
+        del kwargs['name']
+
+        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()['name'][0] == 'required'
+
+
+
+    def test_serializer_validation_can_create_device(self,
+        kwargs_api_create, model, model_serializer, request_user
+    ):
+        """Serializer Validation Check
+
+        Ensure that a valid item is serialized
+        """
+
+        mock_view = MockView(
+            user = request_user,
+            model = model,
+            action = 'create',
+        )
+
+        kwargs = kwargs_api_create.copy()
+
+        serializer = model_serializer['model'](
+            context = {
+                'request': mock_view.request,
+                'view': mock_view,
+            },
+            data = kwargs,
+        )
+
+        assert serializer.is_valid(raise_exception = True)
+
+
+
+    def test_serializer_validation_no_port(self,
+        kwargs_api_create, model, model_serializer, request_user
+    ):
+        """Serializer Validation Check
+
+        Ensure that if creating and no port is provided a validation error occurs
+        """
+
+        mock_view = MockView(
+            user = request_user,
+            model = model,
+            action = 'create',
+        )
+
+        kwargs = kwargs_api_create.copy()
+        del kwargs['port']
+
+        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()['port'][0] == 'required'
+
+
+
+    def test_serializer_validation_no_port_required_if_template_with_port(self,
+        kwargs_api_create, model, model_serializer, request_user,
+        model_kwargs,
+    ):
+        """Serializer Validation Check
+
+        Ensure that if creating and no port is provided and the template has a port
+        no validation error occurs
+        """
+
+        mock_view = MockView(
+            user = request_user,
+            model = model,
+            action = 'create',
+        )
+
+        kwargs = model_kwargs.copy()
+        kwargs['is_template'] = True
+        ports = kwargs['port']
+        del kwargs['port']
+
+        template = model.objects.create( **kwargs )
+
+        for port in ports:
+            template.port.add( port )
+
+
+        kwargs = kwargs_api_create.copy()
+        kwargs['is_template'] = False
+        kwargs['template'] = template.id
+        del kwargs['port']
+
+        serializer = model_serializer['model'](
+            context = {
+                'request': mock_view.request,
+                'view': mock_view,
+            },
+            data = kwargs
+        )
+
+        assert serializer.is_valid(raise_exception = True)
+        template.delete()
+
+
+
+    def test_serializer_validation_template_without_port(self,
+        kwargs_api_create, model, model_serializer, request_user,
+        model_kwargs
+    ):
+        """Serializer Validation Check
+
+        Ensure that if creating a port is provided and the template has no port
+        no validation error occurs
+        """
+
+        mock_view = MockView(
+            user = request_user,
+            model = model,
+            action = 'create',
+        )
+
+        kwargs = model_kwargs.copy()
+        kwargs['is_template'] = True
+        del kwargs['port']
+
+        template = model.objects.create( **kwargs )
+
+        kwargs = kwargs_api_create.copy()
+        kwargs['is_template'] = False
+        kwargs['template'] = template.id
+
+
+        serializer = model_serializer['model'](
+            context = {
+                'request': mock_view.request,
+                'view': mock_view,
+            },
+            data = kwargs
+        )
+
+        assert serializer.is_valid(raise_exception = True)
+        template.delete()
+
+
+
+    def test_serializer_validation_no_port_or_template_port(self,
+        kwargs_api_create, model, model_serializer, request_user,
+        model_kwargs,
+    ):
+        """Serializer Validation Check
+
+        Ensure that if creating and no port is provided and the template
+        has no port a validation error occurs
+        """
+
+        mock_view = MockView(
+            user = request_user,
+            model = model,
+            action = 'create',
+        )
+
+        kwargs = model_kwargs.copy()
+        kwargs['is_template'] = True
+        del kwargs['port']
+        del kwargs['device']
+
+        template = model.objects.create( **kwargs )
+
+        kwargs = kwargs_api_create.copy()
+        kwargs['is_template'] = False
+        kwargs['template'] = template.id
+        del kwargs['port']
+
+        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()['port'][0] == 'required'
+        template.delete()
+
+
+
+    def test_serializer_validation_no_device(self,
+        kwargs_api_create, model, model_serializer, request_user
+    ):
+        """Serializer Validation Check
+
+        Ensure that if creating and no device is provided a validation error occurs
+        """
+
+        mock_view = MockView(
+            user = request_user,
+            model = model,
+            action = 'create',
+        )
+
+        kwargs = kwargs_api_create.copy()
+        del kwargs['device']
+
+        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] == 'one_of_cluster_or_device'
+
+
+
+    def test_serializer_validation_device_and_cluster(self,
+        kwargs_api_create, model, model_serializer, request_user,
+        model_cluster, kwargs_cluster
+    ):
+        """Serializer Validation Check
+
+        Ensure that if creating and a cluster and device is provided
+        a validation error occurs
+        """
+
+        mock_view = MockView(
+            user = request_user,
+            model = model,
+            action = 'create',
+        )
+
+        kwargs = kwargs_cluster.copy()
+        nodes = kwargs['nodes']
+        del kwargs['nodes']
+        cluster = model_cluster.objects.create( **kwargs )
+
+        for node in nodes:
+            cluster.nodes.add( node )
+
+        kwargs = kwargs_api_create.copy()
+        kwargs['cluster'] = cluster.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)
+
+        assert err.value.get_codes()['non_field_errors'][0] == 'either_cluster_or_device'
+        cluster.delete()
+
+
+
+    def test_serializer_validation_no_circular_dependency(self,
+        created_model,
+        kwargs_api_create, model, model_serializer, request_user,
+        model_kwargs
+    ):
+        """Serializer Validation Check
+
+        Ensure that if creating and a dependent service loop
+        a validation error occurs
+        """
+
+        mock_view = MockView(
+            user = request_user,
+            model = model,
+            action = 'create',
+        )
+
+        kwargs = model_kwargs.copy()
+        del kwargs['port']
+        root_service = model.objects.create ( **kwargs )
+        root_service.dependent_service.add( created_model )
+
+
+        kwargs = kwargs_api_create.copy()
+        kwargs['dependent_service'] = [ root_service.id ]
+
+        with pytest.raises(ValidationError) as err:
+
+            serializer = model_serializer['model'](
+                created_model,
+                context = {
+                    'request': mock_view.request,
+                    'view': mock_view,
+                },
+                data = kwargs,
+                partial = True
+            )
+
+            serializer.is_valid(raise_exception = True)
+
+        assert err.value.get_codes()['dependent_service'][0] == 'no_circular_dependencies'
+        root_service.delete()
+
+
+
+class ServiceSerializerInheritedCases(
+    ServiceSerializerTestCases
+):
+    pass
+
+
+
+@pytest.mark.module_itim
+class ServiceSerializerPyTest(
+    ServiceSerializerTestCases
+):
+    pass

app/itim/tests/unit/service/test_unit_service_viewset.py

@@ -1,46 +1,87 @@
+
 import pytest
 
-from django.test import Client, TestCase
-
-from rest_framework.reverse import reverse
-
 from api.tests.unit.test_unit_common_viewset import ModelViewSetInheritedCases
 
-from itim.viewsets.service import ViewSet
+from itim.viewsets.service import (
+    Service,
+    ViewSet,
+)
 
 
 
-@pytest.mark.skip(reason = 'see #895, tests being refactored')
 @pytest.mark.model_service
-@pytest.mark.module_itim
+class ViewsetTestCases(
-class ServiceViewsetList(
     ModelViewSetInheritedCases,
-    TestCase,
 ):
 
-    viewset = ViewSet
 
-    route_name = 'v2:_api_service'
+    @pytest.fixture( scope = 'function' )
+    def viewset(self):
+        return ViewSet
 
 
-    @classmethod
+    @property
-    def setUpTestData(self):
+    def parameterized_class_attributes(self):
-        """Setup Test
+        return {
-
+            '_model_documentation': {
-        1. make list request
+                'type': type(None),
-        """
+            },
+            'back_url': {
+                'type': type(None),
+            },
+            'documentation': {
+                'type': type(None),
+                'value': None
+            },
+            'filterset_fields': {
+                'value': [
+                    'name',
+                    'cluster',
+                    'device',
+                    'port'
+                ]
+            },
+            'model': {
+                'value': Service
+            },
+            'model_documentation': {
+                'type': type(None),
+            },
+            'queryset': {
+                'type': type(None),
+            },
+            'serializer_class': {
+                'type': type(None),
+            },
+            'search_fields': {
+                'value': [
+                    'name'
+                ]
+            },
+            'view_description': {
+                'value': 'Physical Devices'
+            },
+            'view_name': {
+                'type': type(None),
+            },
+            'view_serializer_name': {
+                'type': type(None),
+            }
+        }
 
 
-        super().setUpTestData()
+
+class ServiceViewsetInheritedCases(
+    ViewsetTestCases,
+):
+    pass
 
 
-        client = Client()
-        
-        url = reverse(
-            self.route_name + '-list',
-            kwargs = self.kwargs
-        )
 
-        client.force_login(self.view_user)
+@pytest.mark.module_itim
+class ServiceViewsetPyTest(
+    ViewsetTestCases,
+):
 
-        self.http_options_response_list = client.options(url)
+    pass

app/tests/fixtures/__init__.py

@@ -61,11 +61,13 @@ from .model_checkin import (
 from .model_cluster import (
     kwargs_cluster,
     model_cluster,
+    serializer_cluster,
 )
 
 from .model_clustertype import (
     kwargs_clustertype,
     model_clustertype,
+    serializer_clustertype,
 )
 
 from .model_company import (
@@ -228,6 +230,7 @@ from .model_person import (
 from .model_port import (
     kwargs_port,
     model_port,
+    serializer_port,
 )
 
 from .model_project import (
@@ -264,6 +267,7 @@ from .model_role import (
 from .model_service import (
     kwargs_service,
     model_service,
+    serializer_service,
 )
 
 from .model_slmticket import (

app/tests/fixtures/model_cluster.py

@@ -2,6 +2,11 @@ import datetime
 import pytest
 
 from itim.models.clusters import Cluster
+from itim.serializers.cluster import (
+    ClusterBaseSerializer,
+    ClusterModelSerializer,
+    ClusterViewSerializer
+)
 
 
 
@@ -12,15 +17,47 @@ def model_cluster():
 
 
 @pytest.fixture( scope = 'class')
-def kwargs_cluster(kwargs_centurionmodel):
+def kwargs_cluster(kwargs_centurionmodel, django_db_blocker,
+    model_device, kwargs_device,
+    model_clustertype, kwargs_clustertype
+):
 
     random_str = str(datetime.datetime.now(tz=datetime.timezone.utc))
     random_str = str(random_str).replace(
             ' ', '').replace(':', '').replace('+', '').replace('.', '')
 
+    with django_db_blocker.unblock():
+
+        kwargs = kwargs_device.copy()
+        kwargs['serial_number'] = 'clu-123-654'
+        kwargs['uuid'] = '1cf3a2d4-1776-418b-86eb-00404a43d60e'
+
+        node = model_device.objects.create( **kwargs )
+        cluster_type = model_clustertype.objects.create( **kwargs_clustertype )
+
     kwargs = {
         **kwargs_centurionmodel.copy(),
         'name': 'cluster_' + random_str,
+        'nodes': [ node ],
+        'cluster_type': cluster_type,
+        'config': { 'config_key_1': 'config_value_1' }
     }
 
     yield kwargs.copy()
+
+
+    with django_db_blocker.unblock():
+
+        node.delete()
+        cluster_type.delete()
+
+
+
+@pytest.fixture( scope = 'class')
+def serializer_cluster():
+
+    yield {
+        'base': ClusterBaseSerializer,
+        'model': ClusterModelSerializer,
+        'view': ClusterViewSerializer
+    }

app/tests/fixtures/model_clustertype.py

@@ -2,6 +2,11 @@ import datetime
 import pytest
 
 from itim.models.clusters import ClusterType
+from itim.serializers.cluster_type import (
+    ClusterTypeBaseSerializer,
+    ClusterTypeModelSerializer,
+    ClusterTypeViewSerializer
+)
 
 
 
@@ -21,6 +26,17 @@ def kwargs_clustertype(kwargs_centurionmodel):
     kwargs = {
         **kwargs_centurionmodel.copy(),
         'name': 'clustertype_' + random_str,
+        'config': { 'config_key_1': 'config_value_1' }
     }
 
     yield kwargs.copy()
+
+
+@pytest.fixture( scope = 'class')
+def serializer_clustertype():
+
+    yield {
+        'base': ClusterTypeBaseSerializer,
+        'model': ClusterTypeModelSerializer,
+        'view': ClusterTypeViewSerializer
+    }

app/tests/fixtures/model_device.py

@@ -1,6 +1,8 @@
 import pytest
 import random
 
+from django.db import models
+
 from itam.models.device import Device
 from itam.serializers.device import (
     DeviceBaseSerializer,
@@ -43,8 +45,15 @@ def kwargs_device(django_db_blocker, kwargs_centurionmodel,
 
     with django_db_blocker.unblock():
 
-        device_model.delete()
+        try:
-        device_type.delete()
+            device_model.delete()
+        except models.deletion.ProtectedError:
+            pass
+
+        try:
+            device_type.delete()
+        except models.deletion.ProtectedError:
+            pass
 
 
 @pytest.fixture( scope = 'class')

app/tests/fixtures/model_devicemodel.py

@@ -2,6 +2,8 @@ import datetime
 import pytest
 import random
 
+from django.db import models
+
 from itam.models.device import DeviceModel
 from itam.serializers.device_model import (
     DeviceModelBaseSerializer,
@@ -41,7 +43,10 @@ def kwargs_devicemodel(kwargs_centurionmodel, django_db_blocker,
 
     with django_db_blocker.unblock():
 
-        manufacturer.delete()
+        try:
+            manufacturer.delete()
+        except models.deletion.ProtectedError:
+            pass
 
 
 @pytest.fixture( scope = 'class')

app/tests/fixtures/model_port.py

@@ -1,8 +1,12 @@
-import datetime
 import pytest
 import random
 
 from itim.models.services import Port
+from itim.serializers.port import (
+    PortBaseSerializer,
+    PortModelSerializer,
+    PortViewSerializer
+)
 
 
 
@@ -19,8 +23,20 @@ def kwargs_port(kwargs_centurionmodel):
 
     kwargs = {
         **kwargs_centurionmodel.copy(),
+        'description': 'a descriptive str',
         'number': random_port,
         'protocol': Port.Protocol.TCP
     }
 
     yield kwargs.copy()
+
+
+
+@pytest.fixture( scope = 'class')
+def serializer_port():
+
+    yield {
+        'base': PortBaseSerializer,
+        'model': PortModelSerializer,
+        'view': PortViewSerializer
+    }

app/tests/fixtures/model_service.py

@@ -2,6 +2,11 @@ import datetime
 import pytest
 
 from itim.models.services import Service
+from itim.serializers.service import (
+    ServiceBaseSerializer,
+    ServiceModelSerializer,
+    ServiceViewSerializer,
+)
 
 
 
@@ -39,6 +44,7 @@ def kwargs_service(django_db_blocker,
         'device': device,
         'config_key_variable': 'svc',
         'port': [ port ],
+        'config': { 'config_key_1': 'config_value_1' }
     }
 
     yield kwargs.copy()
@@ -51,3 +57,14 @@ def kwargs_service(django_db_blocker,
             pass
 
         port.delete()
+
+
+
+@pytest.fixture( scope = 'class')
+def serializer_service():
+
+    yield {
+        'base': ServiceBaseSerializer,
+        'model': ServiceModelSerializer,
+        'view': ServiceViewSerializer
+    }