nofusscomputing/centurion_erp
1
0
Fork 0
Code Issues Wiki Activity

test(core): Refactor TicketCommentBase model API Fields render test Suite to PyTest

Browse Source 
ref: #883 #884 #726
This commit is contained in:
Jon Lockwood
2025-07-24 18:19:56 +09:30
parent 25b8993462
commit 8159799afc
4 changed files with 278 additions and 388 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
app/core/tests/functional/ticket_comment_base/conftest.py
View File

@ -12,3 +12,11 @@ def model(request):
yield request.cls.model
del request.cls.model
@pytest.fixture( scope = 'class', autouse = True)
def model_kwargs(request, kwargs_ticketcommentbase):
request.cls.kwargs_create_item = kwargs_ticketcommentbase.copy()
yield kwargs_ticketcommentbase.copy()

240
app/core/tests/functional/ticket_comment_base/test_functional_ticket_comment_base_api_fields.py Normal file
View File

@ -0,0 +1,240 @@
import pytest
import random
from django.db import models
from rest_framework.relations import Hyperlink
from api.tests.functional.test_functional_api_fields import (
APIFieldsInheritedCases,
)
from core.models.ticket_comment_base import (
TicketBase,
TicketCommentBase,
)
@pytest.mark.model_ticketcommentbase
class TicketCommentBaseAPIFieldsTestCases(
APIFieldsInheritedCases,
):
base_model = TicketCommentBase
@pytest.fixture( scope = 'class')
def create_model(self, request, django_db_blocker,
model, model_kwargs
):
with django_db_blocker.unblock():
kwargs = model_kwargs.copy()
kwargs['body'] = 'the template comment'
del kwargs['external_ref']
del kwargs['external_system']
del kwargs['category']
kwargs['comment_type'] = model._meta.sub_model_type
kwargs['is_template'] = True
template_comment = model.objects.create(
**kwargs
)
kwargs = model_kwargs.copy()
kwargs['template'] = template_comment
kwargs['ticket'].is_closed = False
kwargs['ticket'].date_closed = None
kwargs['ticket'].is_solved = False
kwargs['ticket'].date_solved = None
kwargs['ticket'].status = TicketBase.TicketStatus.NEW
kwargs['ticket'].save()
kwargs['external_ref'] = random.randint(333, 33333)
item = model.objects.create(
**kwargs
)
request.cls.item = item
kwargs = model_kwargs.copy()
kwargs['body'] = 'the child comment'
kwargs['comment_type'] = model._meta.sub_model_type
kwargs['parent'] = request.cls.item
# kwargs['ticket'] = request.cls.item.ticket
del kwargs['external_ref']
del kwargs['external_system']
del kwargs['category']
kwargs['ticket'].is_closed = False
kwargs['ticket'].date_closed = None
kwargs['ticket'].is_solved = False
kwargs['ticket'].date_solved = None
kwargs['ticket'].status = TicketBase.TicketStatus.NEW
kwargs['ticket'].save()
item_two = model.objects.create(
**kwargs
)
request.cls.item_two = item_two
yield item
item_two.delete()
item.delete()
template_comment.delete()
@property
def parameterized_api_fields(self):
return {
'parent': {
'expected': dict
},
'parent.id': {
'expected': int
},
'parent.display_name': {
'expected': str
},
'parent.url': {
'expected': str
},
'ticket': {
'expected': dict
},
'ticket.id': {
'expected': int
},
'ticket.display_name': {
'expected': str
},
'ticket.url': {
'expected': str
},
'external_ref': {
'expected': int
},
'external_system': {
'expected': int
},
'comment_type': {
'expected': str
},
'category': {
'expected': dict
},
'category.id': {
'expected': int
},
'category.display_name': {
'expected': str
},
'category.url': {
'expected': Hyperlink
},
'body': {
'expected': str
},
'private': {
'expected': bool
},
'duration': {
'expected': int
},
'estimation': {
'expected': int
},
'template': {
'expected': dict
},
'template.id': {
'expected': int
},
'template.display_name': {
'expected': str
},
'template.url': {
'expected': str
},
'is_template': {
'expected': bool
},
'source': {
'expected': int
},
'user': {
'expected': dict
},
'user.id': {
'expected': int
},
'user.display_name': {
'expected': str
},
'user.url': {
'expected': str
},
'is_closed': {
'expected': bool
},
'date_closed': {
'expected': str
},
'_urls.threads': {
'expected': str
},
# Below fields dont exist.
'display_name': {
'expected': models.NOT_PROVIDED
},
'model_notes': {
'expected': models.NOT_PROVIDED
},
'_urls.notes': {
'expected': models.NOT_PROVIDED
},
}
class TicketCommentBaseAPIFieldsInheritedCases(
TicketCommentBaseAPIFieldsTestCases,
):
pass
@pytest.mark.module_core
class TicketCommentBaseAPIFieldsPyTest(
TicketCommentBaseAPIFieldsTestCases,
):
pass

384
app/core/tests/unit/ticket_comment_base/test_unit_ticket_comment_base_api_fields.py
View File

@ -1,384 +0,0 @@
import django
import pytest
from django.contrib.auth.models import ContentType, Permission
from django.db import models
from django.shortcuts import reverse
from rest_framework.relations import Hyperlink
from api.tests.functional.test_functional_api_fields import (
APIFieldsInheritedCases,
)
from core.models.ticket_comment_base import (
Entity,
TicketBase,
TicketCommentBase,
TicketCommentCategory
)
User = django.contrib.auth.get_user_model()
@pytest.mark.model_ticketcommentbase
class TicketCommentBaseAPITestCases(
APIFieldsInheritedCases,
):
base_model = TicketCommentBase
@pytest.fixture( scope = 'class')
def setup_model(self, request, django_db_blocker,
model,
):
with django_db_blocker.unblock():
ticket_view_permission = Permission.objects.get(
codename = 'view_' + TicketBase._meta.model_name,
content_type = ContentType.objects.get(
app_label = TicketBase._meta.app_label,
model = TicketBase._meta.model_name,
)
)
request.cls.view_team.permissions.add( ticket_view_permission )
category = TicketCommentCategory.objects.create(
organization = request.cls.organization,
name = 'comment category'
)
ticket_user = User.objects.create_user(username="ticket_user", password="password")
ticket = TicketBase.objects.create(
organization = request.cls.organization,
title = 'ticket comment title',
opened_by = ticket_user,
)
comment_user = Entity.objects.create(
organization = request.cls.organization,
)
request.cls.comment_user = comment_user
valid_data = request.cls.kwargs_create_item.copy()
valid_data['body'] = 'the template comment'
del valid_data['external_ref']
del valid_data['external_system']
del valid_data['category']
del valid_data['template']
del valid_data['parent']
valid_data['comment_type'] = TicketCommentBase._meta.sub_model_type
valid_data['ticket'] = ticket
valid_data['user'] = request.cls.comment_user
template_comment = TicketCommentBase.objects.create(
**valid_data
)
request.cls.kwargs_create_item.update({
'category': category,
'ticket': ticket,
'user': comment_user,
'parent': None,
'template': template_comment,
'comment_type': model._meta.sub_model_type
})
yield
with django_db_blocker.unblock():
try:
template_comment.delete()
except:
pass
try:
category.delete()
except:
pass
del request.cls.comment_user
for comment in ticket.ticketcommentbase_set.all():
comment.delete()
ticket.delete()
ticket_user.delete()
@pytest.fixture( scope = 'class')
def post_model(self, request, model, django_db_blocker ):
request.cls.url_view_kwargs.update({
'ticket_id': request.cls.item.ticket.id
})
if (
model != self.base_model
or self.item.parent
):
request.cls.url_view_kwargs.update({
'ticket_comment_model': model._meta.sub_model_type
})
valid_data = request.cls.kwargs_create_item.copy()
valid_data['body'] = 'the child comment'
valid_data['comment_type'] = TicketCommentBase._meta.sub_model_type
valid_data['parent'] = request.cls.item
valid_data['ticket'] = request.cls.item.ticket
valid_data['user'] = request.cls.comment_user
del valid_data['external_ref']
del valid_data['external_system']
del valid_data['category']
del valid_data['template']
with django_db_blocker.unblock():
request.cls.item.ticket.is_closed = False
request.cls.item.ticket.date_closed = None
request.cls.item.ticket.is_solved = False
request.cls.item.ticket.date_solved = None
request.cls.item.ticket.status = TicketBase.TicketStatus.NEW
request.cls.item.ticket.save()
request.cls.item_two = model.objects.create(
**valid_data
)
url_ns_name = '_api_ticket_comment_base_sub_thread'
request.cls.url_two = reverse(
'v2:' + url_ns_name + '-detail',
kwargs = {
**request.cls.url_view_kwargs,
'pk': request.cls.item_two.id,
'parent_id': request.cls.item.id,
'ticket_comment_model': model._meta.sub_model_type
}
)
yield
with django_db_blocker.unblock():
request.cls.item_two.delete(keep_parents = False)
del request.cls.item_two
del request.cls.url_two
@pytest.fixture( scope = 'class', autouse = True)
def class_setup(self, request, django_db_blocker,
setup_pre,
setup_model,
create_model,
post_model,
setup_post,
):
pass
@property
def parameterized_test_data(self):
return {
'parent': {
'expected': dict
},
'parent.id': {
'expected': int
},
'parent.display_name': {
'expected': str
},
'parent.url': {
'expected': str
},
'ticket': {
'expected': dict
},
'ticket.id': {
'expected': int
},
'ticket.display_name': {
'expected': str
},
'ticket.url': {
'expected': str
},
'external_ref': {
'expected': int
},
'external_system': {
'expected': int
},
'comment_type': {
'expected': str
},
'category': {
'expected': dict
},
'category.id': {
'expected': int
},
'category.display_name': {
'expected': str
},
'category.url': {
'expected': Hyperlink
},
'body': {
'expected': str
},
'private': {
'expected': bool
},
'duration': {
'expected': int
},
'estimation': {
'expected': int
},
'template': {
'expected': dict
},
'template.id': {
'expected': int
},
'template.display_name': {
'expected': str
},
'template.url': {
'expected': str
},
'is_template': {
'expected': bool
},
'source': {
'expected': int
},
'user': {
'expected': dict
},
'user.id': {
'expected': int
},
'user.display_name': {
'expected': str
},
'user.url': {
'expected': str
},
'is_closed': {
'expected': bool
},
'date_closed': {
'expected': str
},
'_urls.threads': {
'expected': str
},
# Below fields dont exist.
'display_name': {
'expected': models.NOT_PROVIDED
},
'model_notes': {
'expected': models.NOT_PROVIDED
},
'_urls.notes': {
'expected': models.NOT_PROVIDED
},
}
kwargs_create_item: dict = {
'parent': '',
'ticket': '',
'external_ref': 123,
'external_system': TicketBase.Ticket_ExternalSystem.CUSTOM_1,
'comment_type': '',
'category': '',
'body': 'the ticket comment',
'private': False,
'duration': 1,
'estimation': 2,
'template': '',
'is_template': True,
'source': TicketBase.TicketSource.HELPDESK,
'user': '',
'is_closed': True,
'date_closed': '2025-05-09T19:32Z',
}
url_ns_name = '_api_ticket_comment_base'
"""Url namespace (optional, if not required) and url name"""
class TicketCommentBaseAPIInheritedCases(
TicketCommentBaseAPITestCases,
):
kwargs_create_item: dict = None
model = None
url_ns_name = '_api_ticket_comment_base_sub'
@pytest.mark.module_core
class TicketCommentBaseAPIPyTest(
TicketCommentBaseAPITestCases,
):
pass

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

@ -1,6 +1,8 @@
import datetime
import pytest
from django.db import models
from core.models.ticket_comment_base import TicketCommentBase
@ -14,7 +16,8 @@ def model_ticketcommentbase(request):
@pytest.fixture( scope = 'class')
def kwargs_ticketcommentbase(django_db_blocker, kwargs_centurionmodel,
model_person, kwargs_person, model_ticketcommentbase,
model_ticketbase, kwargs_ticketbase
model_ticketbase, kwargs_ticketbase,
model_ticketcommentcategory, kwargs_ticketcommentcategory
):
random_str = str(datetime.datetime.now(tz=datetime.timezone.utc))
@ -27,19 +30,42 @@ def kwargs_ticketcommentbase(django_db_blocker, kwargs_centurionmodel,
ticket = model_ticketbase.objects.create( **kwargs_ticketbase )
category = model_ticketcommentcategory.objects.create(
**kwargs_ticketcommentcategory
)
kwargs = kwargs_centurionmodel.copy()
del kwargs['model_notes']
kwargs = {
**kwargs,
'body': 'a comment body',
'comment_type': model_ticketcommentbase._meta.sub_model_type,
# 'parent': '',
'ticket': ticket,
'external_ref': 123,
'external_system': model_ticketbase.Ticket_ExternalSystem.CUSTOM_1,
'comment_type': model_ticketcommentbase._meta.sub_model_type,
'category': category,
'body': 'a comment body',
'private': False,
'duration': 1,
'estimation': 2,
# 'template': '',
'is_template': False,
'source': model_ticketbase.TicketSource.HELPDESK,
'user': person,
'is_closed': True,
'date_closed': '2025-05-09T19:32Z',
}
yield kwargs.copy()
with django_db_blocker.unblock():
person.delete()
person.delete()
try:
category.delete()
except models.deletion.ProtectedError:
pass