nofusscomputing/centurion_erp
1
0
Fork 0
Code Issues Wiki Activity

Merge pull request #925 from nofusscomputing/refactor-itam-tests

Browse Source
This commit is contained in:
Jon
2025-08-02 12:44:27 +09:30
committed by GitHub
parent 3fa8bdf468 6578d67250
commit 4c49bb0bd2
53 changed files with 1543 additions and 1656 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
app/itam/tests/functional/operating_system/conftest.py Normal file
View File

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

57
app/itam/tests/functional/operating_system/test_functional_operating_system_api_fields.py Normal file
View File

@ -0,0 +1,57 @@
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_operatingsystem
class OperatingSystemAPITestCases(
APIFieldsInheritedCases,
):
@property
def parameterized_api_fields(self):
return {
'publisher': {
'expected': dict
},
'publisher.id': {
'expected': int
},
'publisher.display_name': {
'expected': str
},
'publisher.url': {
'expected': Hyperlink
},
'name': {
'expected': str
},
'modified': {
'expected': str
}
}
class OperatingSystemAPIInheritedCases(
OperatingSystemAPITestCases,
):
pass
@pytest.mark.module_itam
class OperatingSystemAPIPyTest(
OperatingSystemAPITestCases,
):
pass

24
app/itam/tests/functional/operating_system/test_operating_system_viewset.py → app/itam/tests/functional/operating_system/test_functional_operating_system_metadata.py
View File

@ -9,8 +9,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.operating_system import OperatingSystem
@ -21,6 +19,7 @@ User = django.contrib.auth.get_user_model()
@pytest.mark.module_itam
class ViewSetBase:
model = OperatingSystem
@ -218,26 +217,7 @@ class ViewSetBase:
class OperatingSystemPermissionsAPI(
ViewSetBase,
APIPermissions,
TestCase,
):
pass
class OperatingSystemViewSet(
ViewSetBase,
SerializersTestCases,
TestCase,
):
pass
@pytest.mark.module_itam
class OperatingSystemMetadata(
ViewSetBase,
MetadataAttributesFunctional,

28
app/itam/tests/functional/operating_system/test_functional_operating_system_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_operatingsystem
class OperatingSystemModelTestCases(
CenturionAbstractModelInheritedCases
):
pass
class OperatingSystemModelInheritedCases(
OperatingSystemModelTestCases,
):
pass
@pytest.mark.module_itam
class OperatingSystemModelPyTest(
OperatingSystemModelTestCases,
):
pass

63
app/itam/tests/functional/operating_system/test_operating_system_serializer.py
View File

@ -1,63 +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.serializers.operating_system import OperatingSystem, OperatingSystemModelSerializer
class OperatingSystemValidationAPI(
TestCase,
):
model = OperatingSystem
@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.mock_view = MockView( user = self.user )
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 = OperatingSystemModelSerializer(
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'

25
app/itam/tests/functional/operating_system_version/conftest.py Normal file
View File

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

55
app/itam/tests/functional/operating_system_version/test_functional_operating_system_version_api_fields.py Normal file
View File

@ -0,0 +1,55 @@
import pytest
from rest_framework.relations import Hyperlink
from api.tests.functional.test_functional_api_fields import (
APIFieldsInheritedCases,
)
@pytest.mark.model_operatingsystem
class OperatingSystemVersionAPITestCases(
APIFieldsInheritedCases,
):
@property
def parameterized_api_fields(self):
return {
'operating_system': {
'expected': dict
},
'operating_system.id': {
'expected': int
},
'operating_system.display_name': {
'expected': str
},
'operating_system.url': {
'expected': Hyperlink
},
'name': {
'expected': str
},
'modified': {
'expected': str
}
}
class OperatingSystemVersionAPIInheritedCases(
OperatingSystemVersionAPITestCases,
):
pass
@pytest.mark.module_itam
class OperatingSystemVersionAPIPyTest(
OperatingSystemVersionAPITestCases,
):
pass

28
app/itam/tests/functional/operating_system_version/test_functional_operating_system_version_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_operatingsystem
class OperatingSystemVersionModelTestCases(
CenturionAbstractModelInheritedCases
):
pass
class OperatingSystemVersionModelInheritedCases(
OperatingSystemVersionModelTestCases,
):
pass
@pytest.mark.module_itam
class OperatingSystemVersionModelPyTest(
OperatingSystemVersionModelTestCases,
):
pass

16
app/itam/tests/functional/operating_system_version/test_operating_system_version_viewset.py → app/itam/tests/functional/operating_system_version/test_operating_system_version_metadata.py
View File

@ -9,8 +9,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 itam.models.operating_system import OperatingSystem, OperatingSystemVersion
@ -21,6 +19,7 @@ User = django.contrib.auth.get_user_model()
@pytest.mark.model_operatingsystemversion
class ViewSetBase:
model = OperatingSystemVersion
@ -232,18 +231,7 @@ class ViewSetBase:
class OperatingSystemVersionPermissionsAPI(ViewSetBase, APIPermissions, TestCase):
pass
class OperatingSystemVersionViewSetBase(ViewSetBase, SerializersTestCases, TestCase):
pass
@pytest.mark.module_itam
class OperatingSystemVersionMetadata(
ViewSetBase,
MetadataAttributesFunctional,

69
app/itam/tests/functional/operating_system_version/test_operating_system_version_serializer.py
View File

@ -1,69 +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.serializers.operating_system_version import OperatingSystem, OperatingSystemVersion, OperatingSystemVersionModelSerializer
class OperatingSystemVersionValidationAPI(
TestCase,
):
model = OperatingSystemVersion
@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.mock_view = MockView( user = self.user )
self.organization = organization
os = OperatingSystem.objects.create(
organization=organization,
name = 'os name'
)
self.item = self.model.objects.create(
organization=organization,
name = 'os name',
operating_system = os
)
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 = OperatingSystemVersionModelSerializer(
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'

25
app/itam/tests/functional/software/conftest.py Normal file
View File

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

69
app/itam/tests/functional/software/test_functional_software_api_fields.py Normal file
View File

@ -0,0 +1,69 @@
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_software
class SoftwareAPITestCases(
APIFieldsInheritedCases,
):
@property
def parameterized_api_fields(self):
return {
'publisher': {
'expected': dict
},
'publisher.id': {
'expected': int
},
'publisher.display_name': {
'expected': str
},
'publisher.url': {
'expected': Hyperlink
},
'name': {
'expected': str
},
'category': {
'expected': dict
},
'category.id': {
'expected': int
},
'category.display_name': {
'expected': str
},
'category.url': {
'expected': Hyperlink
},
'modified': {
'expected': str
}
}
class SoftwareAPIInheritedCases(
SoftwareAPITestCases,
):
pass
@pytest.mark.module_itam
class SoftwareAPIPyTest(
SoftwareAPITestCases,
):
pass

16
app/itam/tests/functional/software/test_software_viewset.py → app/itam/tests/functional/software/test_functional_software_metadata.py
View File

@ -9,8 +9,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.software import Software
@ -21,6 +19,7 @@ User = django.contrib.auth.get_user_model()
@pytest.mark.model_software
class ViewSetBase:
model = Software
@ -219,18 +218,7 @@ class ViewSetBase:
class SoftwarePermissionsAPI(ViewSetBase, APIPermissions, TestCase):
pass
class SoftwareViewSet(ViewSetBase, SerializersTestCases, TestCase):
pass
@pytest.mark.module_itam
class SoftwareMetadata(
ViewSetBase,
MetadataAttributesFunctional,

28
app/itam/tests/functional/software/test_functional_software_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_software
class SoftwareModelTestCases(
CenturionAbstractModelInheritedCases
):
pass
class SoftwareModelInheritedCases(
SoftwareModelTestCases,
):
pass
@pytest.mark.module_itam
class SoftwareModelPyTest(
SoftwareModelTestCases,
):
pass

63
app/itam/tests/functional/software/test_software_serializer.py
View File

@ -1,63 +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.serializers.software import Software, SoftwareModelSerializer
class SoftwareValidationAPI(
TestCase,
):
model = Software
@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 = SoftwareModelSerializer(
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'

25
app/itam/tests/functional/software_category/conftest.py Normal file
View File

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

45
app/itam/tests/functional/software_category/test_functional_software_category_api_fields.py Normal file
View File

@ -0,0 +1,45 @@
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_softwarecategory
class SoftwareCategoryAPITestCases(
APIFieldsInheritedCases,
):
@property
def parameterized_api_fields(self):
return {
'name': {
'expected': str
},
'modified': {
'expected': str
}
}
class SoftwareCategoryAPIInheritedCases(
SoftwareCategoryAPITestCases,
):
pass
@pytest.mark.module_itam
class SoftwareCategoryAPIPyTest(
SoftwareCategoryAPITestCases,
):
pass

16
app/itam/tests/functional/software_category/test_software_category_viewset.py → app/itam/tests/functional/software_category/test_functional_software_category_metadata.py
View File

@ -9,8 +9,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 itam.models.software import SoftwareCategory
@ -21,6 +19,7 @@ User = django.contrib.auth.get_user_model()
@pytest.mark.model_softwarecategory
class ViewSetBase:
model = SoftwareCategory
@ -218,18 +217,7 @@ class ViewSetBase:
class SoftwareCategoryPermissionsAPI(ViewSetBase, APIPermissions, TestCase):
pass
class SoftwareCategoryViewSet(ViewSetBase, SerializersTestCases, TestCase):
pass
@pytest.mark.module_itam
class SoftwareCategoryMetadata(
ViewSetBase,
MetadataAttributesFunctional,

28
app/itam/tests/functional/software_category/test_functional_software_category_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_softwarecategory
class SoftwareCategoryModelTestCases(
CenturionAbstractModelInheritedCases
):
pass
class SoftwareCategoryModelInheritedCases(
SoftwareCategoryModelTestCases,
):
pass
@pytest.mark.module_itam
class SoftwareCategoryModelPyTest(
SoftwareCategoryModelTestCases,
):
pass

63
app/itam/tests/functional/software_category/test_software_category_serializer.py
View File

@ -1,63 +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.serializers.software_category import SoftwareCategory, SoftwareCategoryModelSerializer
class SoftwareCategoryValidationAPI(
TestCase,
):
model = SoftwareCategory
@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 = SoftwareCategoryModelSerializer(
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'

25
app/itam/tests/functional/software_version/conftest.py Normal file
View File

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

57
app/itam/tests/functional/software_version/test_functional_software_version_api_fields.py Normal file
View File

@ -0,0 +1,57 @@
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_softwareversion
class SoftwareVersionAPITestCases(
APIFieldsInheritedCases,
):
@property
def parameterized_api_fields(self):
return {
'software': {
'expected': dict
},
'software.id': {
'expected': int
},
'software.display_name': {
'expected': str
},
'software.url': {
'expected': Hyperlink
},
'name': {
'expected': str
},
'modified': {
'expected': str
}
}
class SoftwareVersionAPIInheritedCases(
SoftwareVersionAPITestCases,
):
pass
@pytest.mark.module_itam
class SoftwareVersionAPIPyTest(
SoftwareVersionAPITestCases,
):
pass

16
app/itam/tests/functional/software_version/test_software_version_viewset.py → app/itam/tests/functional/software_version/test_functional_software_version_metadata.py
View File

@ -9,8 +9,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 itam.models.software import Software, SoftwareVersion
@ -21,6 +19,7 @@ User = django.contrib.auth.get_user_model()
@pytest.mark.model_softwareversion
class ViewSetBase:
model = SoftwareVersion
@ -231,18 +230,7 @@ class ViewSetBase:
class SoftwareVersionPermissionsAPI(ViewSetBase, APIPermissions, TestCase):
pass
class SoftwareVersionViewSet(ViewSetBase, SerializersTestCases, TestCase):
pass
@pytest.mark.module_itam
class SoftwareVersionMetadata(
ViewSetBase,
MetadataAttributesFunctional,

28
app/itam/tests/functional/software_version/test_functional_software_version_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_softwareversion
class SoftwareVersionModelTestCases(
CenturionAbstractModelInheritedCases
):
pass
class SoftwareVersionModelInheritedCases(
SoftwareVersionModelTestCases,
):
pass
@pytest.mark.module_itam
class SoftwareVersionModelPyTest(
SoftwareVersionModelTestCases,
):
pass

6
app/itam/tests/unit/operating_system/conftest.py
View File

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

182
app/itam/tests/unit/operating_system/test_operating_system_api_v2.py
View File

@ -1,182 +0,0 @@
import django
import pytest
import unittest
from django.contrib.auth.models import Permission
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 core.models.manufacturer import Manufacturer
from itam.models.operating_system import OperatingSystem
User = django.contrib.auth.get_user_model()
@pytest.mark.model_operatingsystem
@pytest.mark.module_itam
class OperatingSystemAPI(
TestCase,
APITenancyObject
):
model = OperatingSystem
@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')
manufacturer = Manufacturer.objects.create(
organization = self.organization,
name = 'a manufacturer'
)
self.item = self.model.objects.create(
organization = self.organization,
name = 'one',
publisher = manufacturer,
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_operatingsystem-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_publisher(self):
""" Test for existance of API Field
publisher field must exist
"""
assert 'publisher' in self.api_data
def test_api_field_type_publisher(self):
""" Test for type for API Field
publisher field must be dict
"""
assert type(self.api_data['publisher']) is dict
def test_api_field_exists_publisher_id(self):
""" Test for existance of API Field
publisher.id field must exist
"""
assert 'id' in self.api_data['publisher']
def test_api_field_type_publisher_id(self):
""" Test for type for API Field
publisher.id field must be int
"""
assert type(self.api_data['publisher']['id']) is int
def test_api_field_exists_publisher_display_name(self):
""" Test for existance of API Field
publisher.display_name field must exist
"""
assert 'display_name' in self.api_data['publisher']
def test_api_field_type_publisher_display_name(self):
""" Test for type for API Field
publisher.display_name field must be str
"""
assert type(self.api_data['publisher']['display_name']) is str
def test_api_field_exists_publisher_url(self):
""" Test for existance of API Field
publisher.url field must exist
"""
assert 'url' in self.api_data['publisher']
def test_api_field_type_publisher_url(self):
""" Test for type for API Field
publisher.url field must be Hyperlink
"""
assert type(self.api_data['publisher']['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

99
app/itam/tests/unit/operating_system/test_operating_system_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 itam.models.operating_system import OperatingSystem
@pytest.mark.skip( reason = 'this ticket model is depreciated' )
@pytest.mark.model_operatingsystem
@pytest.mark.module_itam
class OperatingSystemItemTicketAPI(
ItemTicketAPI,
TestCase,
):
"""Test Cases for Item Tickets
Args:
APITenancyObject (class): Base class for ALL field checks
"""
item_type = TicketLinkedItem.Modules.OPERATING_SYSTEM
item_class = 'operating_system'
item_model = OperatingSystem
@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

32
app/itam/tests/unit/operating_system/test_unit_operating_system_model.py
View File

@ -67,35 +67,3 @@ class OperatingSystemModelPyTest(
OperatingSystemModelTestCases,
):
pass
# def test_method_get_url_kwargs(self, mocker, model_instance, model_kwargs):
# """Test Class Method
# Ensure method `get_url_kwargs` returns the correct value.
# """
# url = model_instance.get_url_kwargs()
# assert model_instance.get_url_kwargs() == {
# 'device_id': model_kwargs['device'].id,
# 'pk': model_instance.id
# }
# def test_model_tag_defined(self, model):
# """ Model Tag
# Ensure that the model has a tag defined.
# """
# pytest.xfail( reason = 'model does not require' )
# def test_method_value_not_default___str__(self, model, model_instance ):
# """Test Method
# Ensure method `__str__` does not return the default value.
# """
# pytest.xfail( reason = 'model does not require' )

108
app/itam/tests/unit/operating_system/test_unit_operating_system_serializer.py Normal file
View File

@ -0,0 +1,108 @@
import pytest
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_operatingsystem
class OperatingSystemSerializerTestCases(
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 OperatingSystemSerializerInheritedCases(
OperatingSystemSerializerTestCases
):
pass
@pytest.mark.module_itam
class OperatingSystemSerializerPyTest(
OperatingSystemSerializerTestCases
):
pass

92
app/itam/tests/unit/operating_system/test_unit_operating_system_viewset.py
View File

@ -1,44 +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 itam.viewsets.operating_system import ViewSet
from itam.viewsets.operating_system import (
OperatingSystem,
ViewSet,
)
@pytest.mark.skip(reason = 'see #895, tests being refactored')
@pytest.mark.model_operatingsystem
@pytest.mark.module_itam
class OperatingSystemViewsetList(
class ViewsetTestCases(
ModelViewSetInheritedCases,
TestCase,
):
viewset = ViewSet
route_name = 'v2:_api_operatingsystem'
@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': str,
'value': 'itam/operating_system'
},
'filterset_fields': {
'value': [
'organization',
'publisher'
]
},
'model': {
'value': OperatingSystem
},
'model_documentation': {
'type': type(None),
},
'queryset': {
'type': type(None),
},
'serializer_class': {
'type': type(None),
},
'search_fields': {
'value': [
'name'
]
},
'view_description': {
'value': 'Operating Systems'
},
'view_name': {
'type': type(None),
},
'view_serializer_name': {
'type': type(None),
}
}
client = Client()
url = reverse(
self.route_name + '-list',
kwargs = self.kwargs
)
client.force_login(self.view_user)
class OperatingSystemViewsetInheritedCases(
ViewsetTestCases,
):
pass
self.http_options_response_list = client.options(url)
@pytest.mark.module_itam
class OperatingSystemViewsetPyTest(
ViewsetTestCases,
):
pass

6
app/itam/tests/unit/operating_system_version/conftest.py
View File

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

160
app/itam/tests/unit/operating_system_version/test_test_operating_system_version_api_v2.py
View File

@ -1,160 +0,0 @@
import django
import pytest
from django.contrib.auth.models import Permission
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.operating_system import OperatingSystem, OperatingSystemVersion
User = django.contrib.auth.get_user_model()
@pytest.mark.model_operatingsystemversion
@pytest.mark.module_itam
class OperatingSystemVersionAPI(
TestCase,
APITenancyObject
):
model = OperatingSystemVersion
@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')
operating_system = OperatingSystem.objects.create(
organization = self.organization,
name = 'one',
model_notes = 'a note'
)
self.item = self.model.objects.create(
organization = self.organization,
name = '10',
model_notes = 'a note',
operating_system = operating_system
)
self.url_view_kwargs = {'operating_system_id': operating_system.id, '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_operatingsystemversion-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_operating_system(self):
""" Test for existance of API Field
operating_system field must exist
"""
assert 'operating_system' in self.api_data
def test_api_field_type_operating_system(self):
""" Test for type for API Field
operating_system field must be dict
"""
assert type(self.api_data['operating_system']) is dict
def test_api_field_exists_operating_system_id(self):
""" Test for existance of API Field
operating_system.id field must exist
"""
assert 'id' in self.api_data['operating_system']
def test_api_field_type_operating_system_id(self):
""" Test for type for API Field
operating_system.id field must be int
"""
assert type(self.api_data['operating_system']['id']) is int
def test_api_field_exists_operating_system_display_name(self):
""" Test for existance of API Field
operating_system.display_name field must exist
"""
assert 'display_name' in self.api_data['operating_system']
def test_api_field_type_operating_system_display_name(self):
""" Test for type for API Field
operating_system.display_name field must be str
"""
assert type(self.api_data['operating_system']['display_name']) is str
def test_api_field_exists_operating_system_url(self):
""" Test for existance of API Field
operating_system.url field must exist
"""
assert 'url' in self.api_data['operating_system']
def test_api_field_type_operating_system_url(self):
""" Test for type for API Field
operating_system.url field must be Hyperlink
"""
assert type(self.api_data['operating_system']['url']) is Hyperlink

98
app/itam/tests/unit/operating_system_version/test_unit_operating_system_version_serializer.py Normal file
View File

@ -0,0 +1,98 @@
import pytest
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_operatingsystemversion
class OperatingSystemVersionSerializerTestCases(
SerializerTestCases
):
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'
@pytest.mark.regression
def test_serializer_create_calls_model_full_clean(self,
kwargs_api_create, mocker, model, model_serializer, request_user
):
mock_view = MockView(
user = request_user,
model = model,
action = 'create',
)
mock_view.kwargs = {
'operating_system_id': kwargs_api_create['operating_system']
}
serializer = model_serializer['model'](
context = {
'request': mock_view.request,
'view': mock_view,
},
data = kwargs_api_create
)
serializer.is_valid(raise_exception = True)
full_clean = mocker.spy(model, 'full_clean')
serializer.save()
full_clean.assert_called_once()
class OperatingSystemVersionSerializerInheritedCases(
OperatingSystemVersionSerializerTestCases
):
pass
@pytest.mark.module_itam
class OperatingSystemVersionSerializerPyTest(
OperatingSystemVersionSerializerTestCases
):
pass

150
app/itam/tests/unit/operating_system_version/test_unit_operating_system_version_viewset.py
View File

@ -1,53 +1,135 @@
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 itam.models.operating_system import OperatingSystem
from itam.viewsets.operating_system_version import ViewSet
from itam.viewsets.operating_system_version import (
OperatingSystemVersion,
ViewSet,
)
@pytest.mark.skip(reason = 'see #895, tests being refactored')
@pytest.mark.model_operatingsystemversion
@pytest.mark.module_itam
class DeviceSoftwareViewsetList(
class ViewsetTestCases(
ModelViewSetInheritedCases,
TestCase,
):
viewset = ViewSet
route_name = 'v2:_api_operatingsystemversion'
@pytest.fixture( scope = 'function' )
def viewset(self):
return ViewSet
@classmethod
def setUpTestData(self):
"""Setup Test
1. make list request
"""
super().setUpTestData()
self.kwargs = {
'operating_system_id': OperatingSystem.objects.create(
organization = self.organization,
name = 'os'
).id
@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': OperatingSystemVersion
},
'model_documentation': {
'type': type(None),
},
'queryset': {
'type': type(None),
},
'serializer_class': {
'type': type(None),
},
'search_fields': {
'value': [
'name'
]
},
'view_description': {
'value': 'Operating Systems'
},
'view_name': {
'type': type(None),
},
'view_serializer_name': {
'type': type(None),
}
}
client = Client()
url = reverse(
self.route_name + '-list',
kwargs = self.kwargs
)
def test_view_func_get_queryset_cache_result(self, viewset_mock_request,
# kwargs_create_item
):
"""Viewset Test
client.force_login(self.view_user)
Ensure that the `get_queryset` function caches the result under
attribute `<viewset>.queryset`
"""
self.http_options_response_list = client.options(url)
view_set = viewset_mock_request
view_set.kwargs = {
'operating_system_id': self.kwargs_create_item['operating_system'].id
}
assert view_set.queryset is None # Must be empty before init
q = view_set.get_queryset()
assert view_set.queryset is not None # Must not be empty after init
assert q == view_set.queryset
def test_view_func_get_queryset_cache_result_used(self, mocker, viewset, viewset_mock_request,
# kwargs_create_item
):
"""Viewset Test
Ensure that the `get_queryset` function caches the result under
attribute `<viewset>.queryset`
"""
qs = mocker.spy(viewset_mock_request.model, 'objects')
view_set = viewset_mock_request
view_set.kwargs = {
'operating_system_id': self.kwargs_create_item['operating_system'].id
}
view_set.get_queryset() # Initial QuerySet fetch/filter and cache
assert len(qs.method_calls) == 1 # one call to .all()
assert len(qs.mock_calls) == 3 # calls = .all(), all().filter()
view_set.get_queryset() # Use Cached results, dont re-fetch QuerySet
assert len(qs.method_calls) == 1
assert len(qs.mock_calls) == 3
class OperatingSystemVersionViewsetInheritedCases(
ViewsetTestCases,
):
pass
@pytest.mark.module_itam
class OperatingSystemVersionViewsetPyTest(
ViewsetTestCases,
):
pass

6
app/itam/tests/unit/software/conftest.py
View File

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

354
app/itam/tests/unit/software/test_software_api_v2.py
View File

@ -1,354 +0,0 @@
import django
import pytest
from django.contrib.auth.models import Permission
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 core.models.manufacturer import Manufacturer
from itam.models.software import Software, SoftwareCategory
User = django.contrib.auth.get_user_model()
@pytest.mark.model_software
@pytest.mark.module_itam
class SoftwareAPI(
TestCase,
APITenancyObject
):
model = Software
@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')
manufacturer = Manufacturer.objects.create(
organization = self.organization,
name = 'a manufacturer'
)
category = SoftwareCategory.objects.create(
organization = self.organization,
name = 'category'
)
self.item = self.model.objects.create(
organization = self.organization,
name = 'one',
publisher = manufacturer,
category = category,
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_software-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_category(self):
""" Test for existance of API Field
category field must exist
"""
assert 'category' in self.api_data
def test_api_field_type_category(self):
""" Test for type for API Field
category field must be dict
"""
assert type(self.api_data['category']) is dict
def test_api_field_exists_category_id(self):
""" Test for existance of API Field
category.id field must exist
"""
assert 'id' in self.api_data['category']
def test_api_field_type_category_id(self):
""" Test for type for API Field
category.id field must be int
"""
assert type(self.api_data['category']['id']) is int
def test_api_field_exists_category_display_name(self):
""" Test for existance of API Field
category.display_name field must exist
"""
assert 'display_name' in self.api_data['category']
def test_api_field_type_category_display_name(self):
""" Test for type for API Field
category.display_name field must be str
"""
assert type(self.api_data['category']['display_name']) is str
def test_api_field_exists_category_url(self):
""" Test for existance of API Field
category.url field must exist
"""
assert 'url' in self.api_data['category']
def test_api_field_type_category_url(self):
""" Test for type for API Field
category.url field must be Hyperlink
"""
assert type(self.api_data['category']['url']) is Hyperlink
def test_api_field_exists_publisher(self):
""" Test for existance of API Field
publisher field must exist
"""
assert 'publisher' in self.api_data
def test_api_field_type_publisher(self):
""" Test for type for API Field
publisher field must be dict
"""
assert type(self.api_data['publisher']) is dict
def test_api_field_exists_publisher_id(self):
""" Test for existance of API Field
publisher.id field must exist
"""
assert 'id' in self.api_data['publisher']
def test_api_field_type_publisher_id(self):
""" Test for type for API Field
publisher.id field must be int
"""
assert type(self.api_data['publisher']['id']) is int
def test_api_field_exists_publisher_display_name(self):
""" Test for existance of API Field
publisher.display_name field must exist
"""
assert 'display_name' in self.api_data['publisher']
def test_api_field_type_publisher_display_name(self):
""" Test for type for API Field
publisher.display_name field must be str
"""
assert type(self.api_data['publisher']['display_name']) is str
def test_api_field_exists_publisher_url(self):
""" Test for existance of API Field
publisher.url field must exist
"""
assert 'url' in self.api_data['publisher']
def test_api_field_type_publisher_url(self):
""" Test for type for API Field
publisher.url field must be Hyperlink
"""
assert type(self.api_data['publisher']['url']) is Hyperlink
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
# def test_api_field_exists_urls_history(self):
# """ Test for existance of API Field
# _urls.history field must exist
# """
# assert 'history' in self.api_data['_urls']
# def test_api_field_type_urls_history(self):
# """ Test for type for API Field
# _urls.history field must be str
# """
# assert type(self.api_data['_urls']['history']) is str
# def test_api_field_exists_urls_notes(self):
# """ Test for existance of API Field
# _urls.notes field must exist
# """
# assert 'notes' in self.api_data['_urls']
# def test_api_field_type_urls_notes(self):
# """ Test for type for API Field
# _urls.notes field must be str
# """
# assert type(self.api_data['_urls']['notes']) is str
def test_api_field_exists_urls_version(self):
""" Test for existance of API Field
_urls.version field must exist
"""
assert 'version' in self.api_data['_urls']
# def test_api_field_type_urls_notes(self):
# """ Test for type for API Field
# _urls.version field must be str
# """
# assert type(self.api_data['_urls']['version']) is str
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_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

97
app/itam/tests/unit/software/test_software_item_ticket_api_v2.py
View File

@ -1,97 +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 itam.models.software import Software
@pytest.mark.model_software
@pytest.mark.module_itam
class SoftwareItemTicketAPI(
ItemTicketAPI,
TestCase,
):
"""Test Cases for Item Tickets
Args:
APITenancyObject (class): Base class for ALL field checks
"""
item_type = TicketLinkedItem.Modules.SOFTWARE
item_class = 'software'
item_model = Software
@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.linked_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

66
app/itam/tests/unit/software/test_unit_software_serializer.py Normal file
View File

@ -0,0 +1,66 @@
import pytest
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_software
class SoftwareSerializerTestCases(
SerializerTestCases
):
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 SoftwareSerializerInheritedCases(
SoftwareSerializerTestCases
):
pass
@pytest.mark.module_itam
class SoftwareSerializerPyTest(
SoftwareSerializerTestCases
):
pass

91
app/itam/tests/unit/software/test_unit_software_viewset.py
View File

@ -1,46 +1,85 @@
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 itam.viewsets.software import ViewSet
from itam.viewsets.software import (
Software,
ViewSet,
)
@pytest.mark.skip(reason = 'see #895, tests being refactored')
@pytest.mark.model_software
@pytest.mark.module_itam
class SoftwareViewsetList(
class ViewsetTestCases(
ModelViewSetInheritedCases,
TestCase,
):
viewset = ViewSet
route_name = 'v2:_api_software'
@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': [
'category',
'organization',
'publisher'
]
},
'model': {
'value': Software
},
'model_documentation': {
'type': type(None),
},
'queryset': {
'type': type(None),
},
'serializer_class': {
'type': type(None),
},
'search_fields': {
'value': [
'name'
]
},
'view_description': {
'value': 'Physical Softwares'
},
'view_name': {
'type': type(None),
},
'view_serializer_name': {
'type': type(None),
}
}
super().setUpTestData()
class SoftwareViewsetInheritedCases(
ViewsetTestCases,
):
pass
client = Client()
url = reverse(
self.route_name + '-list',
kwargs = self.kwargs
)
client.force_login(self.view_user)
@pytest.mark.module_itam
class SoftwareViewsetPyTest(
ViewsetTestCases,
):
self.http_options_response_list = client.options(url)
pass

6
app/itam/tests/unit/software_category/conftest.py
View File

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

87
app/itam/tests/unit/software_category/test_software_category_api_v2.py
View File

@ -1,87 +0,0 @@
import django
import pytest
from django.contrib.auth.models import Permission
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 core.models.manufacturer import Manufacturer
from itam.models.software import Software, SoftwareCategory
User = django.contrib.auth.get_user_model()
@pytest.mark.model_softwarecategory
@pytest.mark.module_itam
class SoftwareCategoryAPI(
TestCase,
APITenancyObject
):
model = SoftwareCategory
@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')
manufacturer = Manufacturer.objects.create(
organization = self.organization,
name = 'a manufacturer'
)
self.item = SoftwareCategory.objects.create(
organization = self.organization,
name = 'category',
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_softwarecategory-detail', kwargs=self.url_view_kwargs)
client.force_login(self.view_user)
response = client.get(url)
self.api_data = response.data

65
app/itam/tests/unit/software_category/test_unit_software_category_serializer.py Normal file
View File

@ -0,0 +1,65 @@
import pytest
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_softwarecategory
class SoftwareCategorySerializerTestCases(
SerializerTestCases
):
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 SoftwareCategorySerializerInheritedCases(
SoftwareCategorySerializerTestCases
):
pass
@pytest.mark.module_itam
class SoftwareCategorySerializerPyTest(
SoftwareCategorySerializerTestCases
):
pass

88
app/itam/tests/unit/software_category/test_unit_software_category_viewset.py
View File

@ -1,45 +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 itam.viewsets.software_category import ViewSet
from itam.viewsets.software_category import (
SoftwareCategory,
ViewSet,
)
@pytest.mark.skip(reason = 'see #895, tests being refactored')
@pytest.mark.model_softwarecategory
@pytest.mark.module_itam
class SoftwareCategoryViewsetList(
class ViewsetTestCases(
ModelViewSetInheritedCases,
TestCase,
):
viewset = ViewSet
route_name = 'v2:_api_softwarecategory'
@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': SoftwareCategory
},
'model_documentation': {
'type': type(None),
},
'queryset': {
'type': type(None),
},
'serializer_class': {
'type': type(None),
},
'search_fields': {
'value': [
'name'
]
},
'view_description': {
'value': 'Physical Softwares'
},
'view_name': {
'type': type(None),
},
'view_serializer_name': {
'type': type(None),
}
}
super().setUpTestData()
class SoftwareCategoryViewsetInheritedCases(
ViewsetTestCases,
):
pass
client = Client()
url = reverse(
self.route_name + '-list',
kwargs = self.kwargs
)
client.force_login(self.view_user)
@pytest.mark.module_itam
class SoftwareCategoryViewsetPyTest(
ViewsetTestCases,
):
self.http_options_response_list = client.options(url)
pass

6
app/itam/tests/unit/software_version/conftest.py
View File

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

163
app/itam/tests/unit/software_version/test_software_version_api_v2.py
View File

@ -1,163 +0,0 @@
import django
import pytest
from django.contrib.auth.models import Permission
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.software import Software, SoftwareVersion
User = django.contrib.auth.get_user_model()
@pytest.mark.model_softwareversion
@pytest.mark.module_itam
class SoftwareVersionCategoryAPI(
TestCase,
APITenancyObject
):
model = SoftwareVersion
@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')
software = Software.objects.create(
organization = self.organization,
name = 'software'
)
self.item = self.model.objects.create(
organization = self.organization,
name = '10',
model_notes = 'a note',
software = software
)
self.url_view_kwargs = {'software_id': software.id, '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_softwareversion-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_software(self):
""" Test for existance of API Field
software field must exist
"""
assert 'software' in self.api_data
def test_api_field_type_software(self):
""" Test for type for API Field
software field must be dict
"""
assert type(self.api_data['software']) is dict
def test_api_field_exists_software_id(self):
""" Test for existance of API Field
software.id field must exist
"""
assert 'id' in self.api_data['software']
def test_api_field_type_software_id(self):
""" Test for type for API Field
software.id field must be int
"""
assert type(self.api_data['software']['id']) is int
def test_api_field_exists_software_display_name(self):
""" Test for existance of API Field
software.display_name field must exist
"""
assert 'display_name' in self.api_data['software']
def test_api_field_type_software_display_name(self):
""" Test for type for API Field
software.display_name field must be str
"""
assert type(self.api_data['software']['display_name']) is str
def test_api_field_exists_software_url(self):
""" Test for existance of API Field
software.url field must exist
"""
assert 'url' in self.api_data['software']
def test_api_field_type_software_url(self):
""" Test for type for API Field
software.url field must be Hyperlink
"""
assert type(self.api_data['software']['url']) is Hyperlink

95
app/itam/tests/unit/software_version/test_unit_software_version_serializer.py Normal file
View File

@ -0,0 +1,95 @@
import pytest
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_softwareversion
class SoftwareVersionSerializerTestCases(
SerializerTestCases
):
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'
@pytest.mark.regression
def test_serializer_create_calls_model_full_clean(self,
kwargs_api_create, mocker, model, model_serializer, request_user
):
mock_view = MockView(
user = request_user,
model = model,
action = 'create',
)
mock_view.kwargs = {
'software_id': kwargs_api_create['software']
}
serializer = model_serializer['model'](
context = {
'request': mock_view.request,
'view': mock_view,
},
data = kwargs_api_create
)
serializer.is_valid(raise_exception = True)
full_clean = mocker.spy(model, 'full_clean')
serializer.save()
full_clean.assert_called_once()
class SoftwareVersionSerializerInheritedCases(
SoftwareVersionSerializerTestCases
):
pass
@pytest.mark.module_itam
class SoftwareVersionSerializerPyTest(
SoftwareVersionSerializerTestCases
):
pass

149
app/itam/tests/unit/software_version/test_unit_software_version_viewset.py
View File

@ -1,53 +1,134 @@
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 itam.models.software import Software
from itam.viewsets.software_version import ViewSet
from itam.viewsets.software_version import (
SoftwareVersion,
ViewSet,
)
@pytest.mark.skip(reason = 'see #895, tests being refactored')
@pytest.mark.model_softwareversion
@pytest.mark.module_itam
class SoftwareVersionViewsetList(
class ViewsetTestCases(
ModelViewSetInheritedCases,
TestCase,
):
viewset = ViewSet
route_name = 'v2:_api_softwareversion'
@pytest.fixture( scope = 'function' )
def viewset(self):
return ViewSet
@classmethod
def setUpTestData(self):
"""Setup Test
1. make list request
"""
super().setUpTestData()
self.kwargs = {
'software_id': Software.objects.create(
organization = self.organization,
name = 'soft'
).id
@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',
'software'
]
},
'model': {
'value': SoftwareVersion
},
'model_documentation': {
'type': type(None),
},
'queryset': {
'type': type(None),
},
'serializer_class': {
'type': type(None),
},
'search_fields': {
'value': [
'name'
]
},
'view_description': {
'value': 'Physical Softwares'
},
'view_name': {
'type': type(None),
},
'view_serializer_name': {
'type': type(None),
}
}
client = Client()
url = reverse(
self.route_name + '-list',
kwargs = self.kwargs
)
client.force_login(self.view_user)
def test_view_func_get_queryset_cache_result(self, viewset_mock_request):
"""Viewset Test
self.http_options_response_list = client.options(url)
Ensure that the `get_queryset` function caches the result under
attribute `<viewset>.queryset`
"""
view_set = viewset_mock_request
view_set.kwargs = {
'software_id': self.kwargs_create_item['software'].id
}
assert view_set.queryset is None # Must be empty before init
q = view_set.get_queryset()
assert view_set.queryset is not None # Must not be empty after init
assert q == view_set.queryset
def test_view_func_get_queryset_cache_result_used(self, mocker, viewset, viewset_mock_request):
"""Viewset Test
Ensure that the `get_queryset` function caches the result under
attribute `<viewset>.queryset`
"""
qs = mocker.spy(viewset_mock_request.model, 'objects')
view_set = viewset_mock_request
view_set.kwargs = {
'software_id': self.kwargs_create_item['software'].id
}
view_set.get_queryset() # Initial QuerySet fetch/filter and cache
assert len(qs.method_calls) == 1 # one call to .all()
assert len(qs.mock_calls) == 3 # calls = .all(), all().filter()
view_set.get_queryset() # Use Cached results, dont re-fetch QuerySet
assert len(qs.method_calls) == 1
assert len(qs.mock_calls) == 3
class SoftwareVersionViewsetInheritedCases(
ViewsetTestCases,
):
pass
@pytest.mark.module_itam
class SoftwareVersionViewsetPyTest(
ViewsetTestCases,
):
pass

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

@ -206,11 +206,13 @@ from .model_manufacturer import (
from .model_operatingsystem import (
kwargs_operatingsystem,
model_operatingsystem,
serializer_operatingsystem,
)
from .model_operatingsystemversion import (
kwargs_operatingsystemversion,
model_operatingsystemversion,
serializer_operatingsystemversion
)
from .model_permission import (
@ -272,11 +274,13 @@ from .model_slmticket import (
from .model_software import (
kwargs_software,
model_software,
serializer_software
)
from .model_softwarecategory import (
kwargs_softwarecategory,
model_softwarecategory,
serializer_softwarecategory,
)
from .model_softwareenablefeatureflag import (
@ -287,6 +291,7 @@ from .model_softwareenablefeatureflag import (
from .model_softwareversion import (
kwargs_softwareversion,
model_softwareversion,
serializer_softwareversion,
)
from .model_ticketbase import (

15
app/tests/fixtures/model_operatingsystem.py vendored
View File

@ -2,6 +2,11 @@ import datetime
import pytest
from itam.models.operating_system import OperatingSystem
from itam.serializers.operating_system import (
OperatingSystemBaseSerializer,
OperatingSystemModelSerializer,
OperatingSystemViewSerializer,
)
@ -36,3 +41,13 @@ def kwargs_operatingsystem(django_db_blocker,
with django_db_blocker.unblock():
publisher.delete()
@pytest.fixture( scope = 'class')
def serializer_operatingsystem():
yield {
'base': OperatingSystemBaseSerializer,
'model': OperatingSystemModelSerializer,
'view': OperatingSystemViewSerializer
}

15
app/tests/fixtures/model_operatingsystemversion.py vendored
View File

@ -2,6 +2,11 @@ import datetime
import pytest
from itam.models.operating_system import OperatingSystemVersion
from itam.serializers.operating_system_version import (
OperatingSystemVersionBaseSerializer,
OperatingSystemVersionModelSerializer,
OperatingSystemVersionViewSerializer,
)
@ -39,3 +44,13 @@ def kwargs_operatingsystemversion(django_db_blocker,
with django_db_blocker.unblock():
os.delete()
@pytest.fixture( scope = 'class')
def serializer_operatingsystemversion():
yield {
'base': OperatingSystemVersionBaseSerializer,
'model': OperatingSystemVersionModelSerializer,
'view': OperatingSystemVersionViewSerializer
}

34
app/tests/fixtures/model_software.py vendored
View File

@ -2,6 +2,11 @@ import datetime
import pytest
from itam.models.software import Software
from itam.serializers.software import (
SoftwareBaseSerializer,
SoftwareModelSerializer,
SoftwareViewSerializer,
)
@ -12,13 +17,40 @@ def model_software(request):
@pytest.fixture( scope = 'class')
def kwargs_software(kwargs_centurionmodel):
def kwargs_software(kwargs_centurionmodel, django_db_blocker,
model_manufacturer, kwargs_manufacturer,
model_softwarecategory, kwargs_softwarecategory
):
random_str = str(datetime.datetime.now(tz=datetime.timezone.utc))
with django_db_blocker.unblock():
publisher = model_manufacturer.objects.create( **kwargs_manufacturer )
category = model_softwarecategory.objects.create( **kwargs_softwarecategory )
kwargs = {
**kwargs_centurionmodel.copy(),
'publisher': publisher,
'name': 'software_' + random_str,
'category': category,
}
yield kwargs.copy()
with django_db_blocker.unblock():
publisher.delete()
category.delete()
@pytest.fixture( scope = 'class')
def serializer_software():
yield {
'base': SoftwareBaseSerializer,
'model': SoftwareModelSerializer,
'view': SoftwareViewSerializer
}

15
app/tests/fixtures/model_softwarecategory.py vendored
View File

@ -2,6 +2,11 @@ import datetime
import pytest
from itam.models.software import SoftwareCategory
from itam.serializers.software_category import (
SoftwareCategoryBaseSerializer,
SoftwareCategoryModelSerializer,
SoftwareCategoryViewSerializer
)
@ -24,3 +29,13 @@ def kwargs_softwarecategory(kwargs_centurionmodel):
}
yield kwargs.copy()
@pytest.fixture( scope = 'class')
def serializer_softwarecategory():
yield {
'base': SoftwareCategoryBaseSerializer,
'model': SoftwareCategoryModelSerializer,
'view': SoftwareCategoryViewSerializer
}

15
app/tests/fixtures/model_softwareversion.py vendored
View File

@ -2,6 +2,11 @@ import datetime
import pytest
from itam.models.software import SoftwareVersion
from itam.serializers.software_version import (
SoftwareVersionBaseSerializer,
SoftwareVersionModelSerializer,
SoftwareVersionViewSerializer
)
@ -41,3 +46,13 @@ def kwargs_softwareversion(django_db_blocker,
with django_db_blocker.unblock():
software.delete()
@pytest.fixture( scope = 'class')
def serializer_softwareversion():
yield {
'base': SoftwareVersionBaseSerializer,
'model': SoftwareVersionModelSerializer,
'view': SoftwareVersionViewSerializer
}