nofusscomputing/centurion_erp
1
0
Fork 0
Code Issues Wiki Activity

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

Browse Source
This commit is contained in:
Jon
2025-08-03 15:02:19 +09:30
committed by GitHub
parent 4c49bb0bd2 1b7d92e300
commit fa0b703877
47 changed files with 1858 additions and 2296 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
app/api/tests/functional/test_functional_api_fields.py
View File

@ -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:

25
app/itim/tests/functional/cluster/conftest.py Normal file
View File

@ -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

89
app/itim/tests/functional/cluster/test_cluster_serializer.py
View File

@ -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'

170
app/itim/tests/functional/cluster/test_functional_cluster_api_fields.py Normal file
View File

@ -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

21
app/itim/tests/functional/cluster/test_cluster_viewset.py → app/itim/tests/functional/cluster/test_functional_cluster_metadata.py
View File

@ -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.api_serializer_viewset import SerializersTestCases
from api.tests.abstract.test_metadata_functional import MetadataAttributesFunctional, MetaDataNavigationEntriesFunctional
from api.tests.abstract.test_metadata_functional import (
MetadataAttributesFunctional,
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):
pass
class ClusterViewSet(ViewSetBase, SerializersTestCases, TestCase):
pass
@pytest.mark.module_itim
class ClusterMetadata(
ViewSetBase,
MetadataAttributesFunctional,

28
app/itim/tests/functional/cluster/test_functional_cluster_model.py Normal file
View File

@ -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

25
app/itim/tests/functional/cluster_types/conftest.py Normal file
View File

@ -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

53
app/itim/tests/functional/cluster_types/test_cluster_type_serializer.py
View File

@ -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'

46
app/itim/tests/functional/cluster_types/test_functional_cluster_type_api_fields.py Normal file
View File

@ -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

16
app/itim/tests/functional/cluster_types/test_cluster_type_viewset.py → app/itim/tests/functional/cluster_types/test_functional_cluster_type_metadata.py
View File

@ -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):
pass
class ClusterTypeViewSet(ViewSetBase, SerializersTestCases, TestCase):
pass
@pytest.mark.module_itim
class ClusterTypeMetadata(
ViewSetBase,
MetadataAttributesFunctional,

28
app/itim/tests/functional/cluster_types/test_functional_cluster_type_model.py Normal file
View File

@ -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

19
app/itim/tests/functional/port/conftest.py Normal file
View File

@ -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

46
app/itim/tests/functional/port/test_functional_port_api_fields.py Normal file
View File

@ -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

16
app/itim/tests/functional/port/test_port_viewset.py → app/itim/tests/functional/port/test_functional_port_metadata.py
View File

@ -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):
pass
class PortViewSet(ViewSetBase, SerializersTestCases, TestCase):
pass
@pytest.mark.module_itim
class PortMetadata(
ViewSetBase,
MetadataAttributesFunctional,

28
app/itim/tests/functional/port/test_functional_port_model.py Normal file
View File

@ -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

111
app/itim/tests/functional/port/test_port_serializer.py
View File

@ -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'

25
app/itim/tests/functional/service/conftest.py Normal file
View File

@ -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

214
app/itim/tests/functional/service/test_functional_service_api_fields.py Normal file
View File

@ -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

16
app/itim/tests/functional/service/test_service_viewset.py → app/itim/tests/functional/service/test_functional_service_metadata.py
View File

@ -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):
pass
class ServiceViewSet(ViewSetBase, SerializersTestCases, TestCase):
pass
@pytest.mark.module_itim
class ServiceMetadata(
ViewSetBase,
MetadataAttributesFunctional,

28
app/itim/tests/functional/service/test_functional_service_model.py Normal file
View File

@ -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

363
app/itim/tests/functional/service/test_service_serializer.py
View File

@ -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'

6
app/itim/tests/unit/cluster/conftest.py
View File

@ -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

491
app/itim/tests/unit/cluster/test_cluster_api_v2.py
View File

@ -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

99
app/itim/tests/unit/cluster/test_cluster_item_ticket_api_v2.py
View File

@ -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

142
app/itim/tests/unit/cluster/test_unit_cluster_serializer.py Normal file
View File

@ -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

93
app/itim/tests/unit/cluster/test_unit_cluster_viewset.py
View File

@ -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 ClusterViewsetList(
class ViewsetTestCases(
ModelViewSetInheritedCases,
TestCase,
):
viewset = ViewSet
route_name = 'v2:_api_cluster'
@pytest.fixture( scope = 'function' )
def viewset(self):
return ViewSet
@classmethod
def setUpTestData(self):
"""Setup Test
1. make list request
"""
super().setUpTestData()
@property
def parameterized_class_attributes(self):
return {
'_model_documentation': {
'type': type(None),
},
'back_url': {
'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(
self.route_name + '-list',
kwargs = self.kwargs
)
class ClusterViewsetInheritedCases(
ViewsetTestCases,
):
pass
client.force_login(self.view_user)
self.http_options_response_list = client.options(url)
@pytest.mark.module_itim
class ClusterViewsetPyTest(
ViewsetTestCases,
):
pass

6
app/itim/tests/unit/cluster_types/conftest.py
View File

@ -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

96
app/itim/tests/unit/cluster_types/test_cluster_type_api_v2.py
View File

@ -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

2
app/itim/tests/unit/cluster_types/test_unit_cluster_type_model.py
View File

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

107
app/itim/tests/unit/cluster_types/test_unit_cluster_type_serializer.py Normal file
View File

@ -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

89
app/itim/tests/unit/cluster_types/test_unit_cluster_types_viewset.py
View File

@ -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 ClusterTypesViewsetList(
class ViewsetTestCases(
ModelViewSetInheritedCases,
TestCase,
):
viewset = ViewSet
route_name = 'v2:_api_clustertype'
@pytest.fixture( scope = 'function' )
def viewset(self):
return ViewSet
@classmethod
def setUpTestData(self):
"""Setup Test
1. make list request
"""
@property
def parameterized_class_attributes(self):
return {
'_model_documentation': {
'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

6
app/itim/tests/unit/port/conftest.py
View File

@ -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

135
app/itim/tests/unit/port/test_port_api_v2.py
View File

@ -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

98
app/itim/tests/unit/port/test_unit_port_serializer.py Normal file
View File

@ -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

90
app/itim/tests/unit/port/test_unit_port_viewset.py
View File

@ -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 PortViewsetList(
class ViewsetTestCases(
ModelViewSetInheritedCases,
TestCase,
):
viewset = ViewSet
route_name = 'v2:_api_port'
@pytest.fixture( scope = 'function' )
def viewset(self):
return ViewSet
@classmethod
def setUpTestData(self):
"""Setup Test
1. make list request
"""
@property
def parameterized_class_attributes(self):
return {
'_model_documentation': {
'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

6
app/itim/tests/unit/service/conftest.py
View File

@ -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

593
app/itim/tests/unit/service/test_service_api_v2.py
View File

@ -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

98
app/itim/tests/unit/service/test_service_item_ticket_api_v2.py
View File

@ -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

421
app/itim/tests/unit/service/test_unit_service_serializer.py Normal file
View File

@ -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

93
app/itim/tests/unit/service/test_unit_service_viewset.py
View File

@ -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 ServiceViewsetList(
class ViewsetTestCases(
ModelViewSetInheritedCases,
TestCase,
):
viewset = ViewSet
route_name = 'v2:_api_service'
@pytest.fixture( scope = 'function' )
def viewset(self):
return ViewSet
@classmethod
def setUpTestData(self):
"""Setup Test
1. make list request
"""
@property
def parameterized_class_attributes(self):
return {
'_model_documentation': {
'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

4
app/tests/fixtures/__init__.py vendored
View File

@ -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 (

39
app/tests/fixtures/model_cluster.py vendored
View File

@ -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
}

16
app/tests/fixtures/model_clustertype.py vendored
View File

@ -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
}

13
app/tests/fixtures/model_device.py vendored
View File

@ -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()
device_type.delete()
try:
device_model.delete()
except models.deletion.ProtectedError:
pass
try:
device_type.delete()
except models.deletion.ProtectedError:
pass
@pytest.fixture( scope = 'class')

7
app/tests/fixtures/model_devicemodel.py vendored
View File

@ -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')

18
app/tests/fixtures/model_port.py vendored
View File

@ -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
}

17
app/tests/fixtures/model_service.py vendored
View File

@ -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
}