nofusscomputing/centurion_erp
1
0
Fork 0
Code Issues Wiki Activity

refactor(project_management): Serializer Unit Test Suite re-written to Pytest for model Project

Browse Source 
ref: #938 #934
This commit is contained in:
Jon Lockwood
2025-08-04 14:19:47 +09:30
parent b7d190218c
commit 91082b205d
5 changed files with 249 additions and 136 deletions
Download Patch File Download Diff File Expand all files Collapse all files

135
app/project_management/tests/functional/project/test_project_serializer.py
View File

@ -1,135 +0,0 @@
import pytest
from django.test import TestCase
from rest_framework.exceptions import ValidationError
from access.models.tenant import Tenant as Organization
from project_management.serializers.project import (
Project,
ProjectImportSerializer,
ProjectModelSerializer
)
class ProjectValidationAPI(
TestCase,
):
model = Project
@classmethod
def setUpTestData(self):
"""Setup Test
1. Create an org
2. Create an item
"""
organization = Organization.objects.create(name='test_org')
self.organization = organization
def test_serializer_validation_can_create(self):
"""Serializer Validation Check
Ensure that a valid item can be creates
"""
serializer = ProjectModelSerializer(data={
"organization": self.organization.id,
"name": 'a project'
})
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 = ProjectModelSerializer(
data={
"organization": self.organization.id,
},
)
serializer.is_valid(raise_exception = True)
assert err.value.get_codes()['name'][0] == 'required'
def test_serializer_validation_external_ref_not_import_user(self):
"""Serializer Validation Check
Ensure that if creating by user who is not import user, they can't edit
fields external_ref and external_system.
"""
class MockView:
is_import_user = False
serializer = ProjectModelSerializer(
context = {
'view': MockView
},
data={
"name": 'project name',
"organization": self.organization.id,
'external_ref': 1,
'external_system': int(Project.Ticket_ExternalSystem.CUSTOM_1)
},
)
serializer.is_valid(raise_exception = True)
serializer.save()
assert serializer.instance.external_ref is None and serializer.instance.external_system is None
def test_serializer_validation_external_ref_is_import_user(self):
"""Serializer Validation Check
Ensure that if creating by user who import user, they can edit
fields external_ref and external_system.
"""
class MockView:
is_import_user = True
serializer = ProjectImportSerializer(
context = {
'view': MockView
},
data={
"name": 'another project',
"organization": self.organization.id,
"external_ref": 1,
"external_system": int(Project.Ticket_ExternalSystem.CUSTOM_1)
},
)
serializer.is_valid(raise_exception = True)
serializer.save()
assert (
serializer.instance.external_ref == 1 and
serializer.instance.external_system == int(Project.Ticket_ExternalSystem.CUSTOM_1)
)

6
app/project_management/tests/unit/project/conftest.py
View File

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

188
app/project_management/tests/unit/project/test_unit_project_serializer.py Normal file
View File

@ -0,0 +1,188 @@
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
from project_management.serializers.project import (
Project,
)
@pytest.mark.model_project
class ProjectSerializerTestCases(
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_external_ref_not_import_user(self,
kwargs_api_create, model, model_serializer, request_user
):
"""Serializer Validation Check
Ensure that if creating by user who is not import user, they can't edit
fields external_ref and external_system.
"""
mock_view = MockView(
user = request_user,
model = model,
action = 'create',
)
kwargs = kwargs_api_create.copy()
kwargs['external_ref'] = 1,
kwargs['external_system'] = int(Project.Ticket_ExternalSystem.CUSTOM_1)
mock_view.is_import_user = False
serializer = model_serializer['model'](
context = {
'request': mock_view.request,
'view': mock_view,
},
data = kwargs,
)
serializer.is_valid(raise_exception = True)
serializer.save()
assert serializer.instance.external_ref is None and serializer.instance.external_system is None
def test_serializer_validation_external_ref_is_import_user(self,
kwargs_api_create, model, model_serializer, request_user
):
"""Serializer Validation Check
Ensure that if creating by user who import user, they can edit
fields external_ref and external_system.
"""
mock_view = MockView(
user = request_user,
model = model,
action = 'create',
)
kwargs = kwargs_api_create.copy()
kwargs['external_ref'] = 1
kwargs['external_system'] = int(Project.Ticket_ExternalSystem.CUSTOM_1)
mock_view.is_import_user = True
serializer = model_serializer['import'](
context = {
'request': mock_view.request,
'view': mock_view,
},
data = kwargs,
)
serializer.is_valid(raise_exception = True)
serializer.save()
assert (
serializer.instance.external_ref == 1 and
serializer.instance.external_system == int(Project.Ticket_ExternalSystem.CUSTOM_1)
)
class ProjectSerializerInheritedCases(
ProjectSerializerTestCases
):
pass
@pytest.mark.module_project_management
class ProjectSerializerPyTest(
ProjectSerializerTestCases
):
pass

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

@ -236,6 +236,7 @@ from .model_port import (
from .model_project import (
kwargs_project,
model_project,
serializer_project,
)
from .model_projectmilestone import (

55
app/tests/fixtures/model_project.py vendored
View File

@ -1,7 +1,14 @@
import datetime
import pytest
import random
from project_management.models.projects import Project
from project_management.serializers.project import (
ProjectBaseSerializer,
ProjectImportSerializer,
ProjectModelSerializer,
ProjectViewSerializer,
)
@ -12,19 +19,65 @@ def model_project():
@pytest.fixture( scope = 'class')
def kwargs_project(kwargs_centurionmodel):
def kwargs_project(kwargs_centurionmodel, django_db_blocker,
model_projectstate, kwargs_projectstate,
model_projecttype, kwargs_projecttype,
model_user, kwargs_user,
):
random_str = str(datetime.datetime.now(tz=datetime.timezone.utc))
random_str = str(random_str).replace(
' ', '').replace(':', '').replace('+', '').replace('.', '')
with django_db_blocker.unblock():
state = model_projectstate.objects.create( **kwargs_projectstate )
pr_type = model_projecttype.objects.create( **kwargs_projecttype )
kwargs = kwargs_user.copy()
kwargs['username'] = 'tm_proj' + str( random.randint(333, 666) )
manager = model_user.objects.create( **kwargs )
kwargs = kwargs_user.copy()
kwargs['username'] = 'tm_proj' + str( random.randint(777, 999) )
team_member = model_user.objects.create( **kwargs )
kwargs = kwargs_centurionmodel.copy()
del kwargs['model_notes']
kwargs = {
**kwargs,
'code': 'aCODE',
'name': 'project_' + random_str,
'description': 'a description',
'priority': Project.Priority.LOW,
'state': state,
'project_type': pr_type,
'planned_start_date': '2025-08-04T00:00:01Z',
'planned_finish_date': '2025-08-04T00:00:02Z',
'real_start_date': '2025-08-04T00:00:03Z',
'real_finish_date': '2025-08-04T00:00:04Z',
'manager_user': manager,
'team_members': [ team_member ],
}
yield kwargs.copy()
with django_db_blocker.unblock():
state.delete()
pr_type.delete()
manager.delete()
team_member.delete()
@pytest.fixture( scope = 'class')
def serializer_project():
yield {
'base': ProjectBaseSerializer,
'import': ProjectImportSerializer,
'model': ProjectModelSerializer,
'view': ProjectViewSerializer
}