IT-Naturschutz
/
konova
7
1
Fork 0
Code Issues 3 Pull Requests Actions Projects Releases 21 Wiki Activity

Unit test intervention/konova

Browse Source 
* adds unit test for intervention app
* adds unit test for konova app
pull/347/head
mpeltriaux 1 year ago
parent e22c9132e1
commit b09ad302b5
3 changed files with 353 additions and 1 deletions
Show Stats Download Patch File Download Diff File

50
intervention/tests/unit/test_models.py
Unescape Escape View File

@ -0,0 +1,50 @@
"""
Author: Michel Peltriaux
Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
Contact: ksp-servicestelle@sgdnord.rlp.de
Created on: 07.09.23
"""
from django.core.exceptions import ObjectDoesNotExist
from django.utils.timezone import now
from intervention.models import RevocationDocument, Revocation
from konova.tests.test_views import BaseTestCase
class RevocationDocumentTestCase(BaseTestCase):
def setUp(self) -> None:
super().setUp()
self.revocation = Revocation.objects.get_or_create(
date=now().date(),
comment="Test",
legal=self.intervention.legal
)[0]
self.doc = self.create_dummy_document(
RevocationDocument,
instance=self.revocation
)
def test_intervention_property(self):
self.assertEqual(
self.doc.intervention,
self.doc.instance.legal.intervention
)
self.assertEqual(
self.doc.intervention,
self.intervention
)
def test_delete(self):
revoc_docs, other_intervention_docs = self.intervention.get_documents()
self.assertIn(self.doc, revoc_docs)
try:
self.doc.delete()
self.doc.refresh_from_db()
self.fail("Should not be fetchable anymore!")
except ObjectDoesNotExist:
pass
revoc_docs, other_intervention_docs = self.intervention.get_documents()
self.assertEqual(revoc_docs.count(), 0)

15
konova/tests/test_views.py
Unescape Escape View File

@ -8,7 +8,7 @@ Created on: 26.10.21
import datetime
import json
from codelist.settings import CODELIST_CONSERVATION_OFFICE_ID
from codelist.settings import CODELIST_CONSERVATION_OFFICE_ID, CODELIST_REGISTRATION_OFFICE_ID
from ema.models import Ema
from konova.sub_settings.lanis_settings import DEFAULT_SRID_RLP
from user.models import User, Team
@ -420,6 +420,19 @@ class BaseTestCase(TestCase):
codelist.codes.add(code)
return code
def get_registration_office_code(self):
""" Returns a dummy KonovaCode as conservation office code
Returns:
"""
codelist = KonovaCodeList.objects.get_or_create(
id=CODELIST_REGISTRATION_OFFICE_ID
)[0]
code = KonovaCode.objects.get(id=3)
codelist.codes.add(code)
return code
def fill_out_ema(self, ema):
""" Adds all required (dummy) data to an Ema

289
konova/tests/unit/test_forms.py
Unescape Escape View File

@ -0,0 +1,289 @@
"""
Author: Michel Peltriaux
Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
Contact: ksp-servicestelle@sgdnord.rlp.de
Created on: 07.09.23
"""
import mimetypes
from django.core.exceptions import ObjectDoesNotExist
from django.test import RequestFactory
from django.utils.translation import gettext_lazy as _
from django.core.files.uploadedfile import SimpleUploadedFile
from django.utils.timezone import now
from compensation.forms.modals.document import NewEcoAccountDocumentModalForm, NewCompensationDocumentModalForm
from compensation.models import Payment
from ema.forms import NewEmaDocumentModalForm
from intervention.forms.modals.document import NewInterventionDocumentModalForm
from intervention.models import InterventionDocument
from konova.forms.modals import EditDocumentModalForm, NewDocumentModalForm, RecordModalForm, RemoveModalForm, \
RemoveDeadlineModalForm
from konova.models import DeadlineType
from konova.tests.test_views import BaseTestCase
from konova.utils.generators import generate_random_string
from konova.utils.message_templates import DOCUMENT_EDITED, DEADLINE_REMOVED
from user.models import UserAction
class NewDocumentModalFormTestCase(BaseTestCase):
def setUp(self) -> None:
super().setUp()
self.request = RequestFactory().request()
self.request.user = self.superuser
self.dummy_file = SimpleUploadedFile(
"some_file.pdf",
b"Some conent in this file",
mimetypes.types_map[".pdf"]
)
dummy_file_dict = {
"file": self.dummy_file
}
self.data = {
"title": generate_random_string(length=5, use_letters_lc=True),
"creation_date": now().date(),
"comment": generate_random_string(length=50, use_letters_uc=True),
}
self.forms = [
NewInterventionDocumentModalForm(self.data, dummy_file_dict, request=self.request, instance=self.intervention),
NewCompensationDocumentModalForm(self.data, dummy_file_dict, request=self.request, instance=self.compensation),
NewEmaDocumentModalForm(self.data, dummy_file_dict, request=self.request, instance=self.ema),
NewEcoAccountDocumentModalForm(self.data, dummy_file_dict, request=self.request, instance=self.eco_account),
]
def test_init(self):
for form in self.forms:
self.assertEqual(form.form_title, str(_("Add new document")))
self.assertEqual(form.form_caption, str(_("")))
self.assertEqual(
form.form_attrs,
{
"enctype": "multipart/form-data"
}
)
self.assertEqual(form.request, self.request)
self.assertEqual(form.user, self.superuser)
try:
NewDocumentModalForm(request=self.request, instance=self.intervention)
self.fail("Base form NewDocumentModalForm should not be creatable")
except NotImplementedError:
pass
def test_is_valid(self):
for form in self.forms:
self.assertTrue(
form.is_valid(), msg=form.errors
)
def test_save(self):
for form in self.forms:
form.is_valid()
obj = form.save()
self.assertEqual(obj.created.action, UserAction.CREATED)
self.assertEqual(obj.created.user, self.superuser)
self.assertEqual(obj.title, self.data["title"])
self.assertEqual(obj.date_of_creation, self.data["creation_date"])
self.assertEqual(obj.comment, self.data["comment"])
self.assertIsNotNone(obj.file)
last_log = obj.instance.log.first()
self.assertEqual(last_log.action, UserAction.EDITED)
self.assertEqual(last_log.user, self.request.user)
self.assertEqual(last_log.comment, str(_("Added document")))
self.assertEqual(obj.instance.modified, last_log)
class EditDocumentModalFormTestCase(NewDocumentModalFormTestCase):
def setUp(self) -> None:
super().setUp()
dummy_file_dict = {
"file": self.dummy_file
}
self.doc = self.create_dummy_document(
InterventionDocument,
instance=self.intervention
)
self.form = EditDocumentModalForm(
self.data,
dummy_file_dict,
request=self.request,
instance=self.intervention,
document=self.doc
)
def test_init(self):
self.assertEqual(self.form.form_title, str(_("Edit document")))
self.assertEqual(self.form.document, self.doc)
self.assertEqual(self.form.request, self.request)
self.assertEqual(self.form.user, self.request.user)
self.assertEqual(self.form.fields["title"].initial, self.doc.title)
self.assertEqual(self.form.fields["comment"].initial, self.doc.comment)
self.assertEqual(self.form.fields["creation_date"].initial, self.doc.date_of_creation)
self.assertEqual(self.form.fields["file"].initial, self.doc.file)
def test_save(self):
self.assertTrue(self.form.is_valid(), msg=self.form.errors)
obj = self.form.save()
self.assertEqual(obj.title, self.data["title"])
self.assertEqual(obj.comment, self.data["comment"])
self.assertEqual(obj.date_of_creation, self.data["creation_date"])
last_log = obj.instance.log.first()
self.assertEqual(last_log.action, UserAction.EDITED)
self.assertEqual(last_log.user, self.request.user)
self.assertEqual(last_log.comment, DOCUMENT_EDITED)
class RecordModalFormTestCase(BaseTestCase):
def setUp(self) -> None:
super().setUp()
self.request = RequestFactory().request()
self.request.user = self.user
self.fill_out_compensation(self.compensation)
def test_init(self):
form = RecordModalForm(
request=self.request,
instance=self.intervention
)
self.assertEqual(form.form_title, str(_("Record data")))
self.assertEqual(form.form_caption, str(
_("I, {} {}, confirm that all necessary control steps have been performed by myself.").format(
self.user.first_name,
self.user.last_name
)
))
self.intervention.set_recorded(self.user)
self.intervention.refresh_from_db()
form = RecordModalForm(
request=self.request,
instance=self.intervention
)
self.assertEqual(form.form_title, str(_("Unrecord data")))
self.assertEqual(form.fields["confirm"].label, str(_("Confirm unrecord")))
self.assertEqual(form.form_caption, str(
_("I, {} {}, confirm that this data must be unrecorded.").format(
self.user.first_name,
self.user.last_name
)))
def test_is_valid(self):
data = {
"confirm": True
}
form = RecordModalForm(data, request=self.request, instance=self.intervention)
self.assertFalse(self.intervention.is_recorded)
self.assertFalse(form.is_valid(), msg=form.errors) # intervention not complete
self.intervention = self.fill_out_intervention(self.intervention)
form = RecordModalForm(data, request=self.request, instance=self.intervention)
self.assertTrue(form.is_valid(), msg=form.errors)
def test_save(self):
data = {
"confirm": True
}
self.intervention = self.fill_out_intervention(self.intervention)
form = RecordModalForm(data, request=self.request, instance=self.intervention)
self.assertTrue(form.is_valid(), msg=form.errors)
form.save()
self.assertEqual(self.intervention.recorded.action, UserAction.RECORDED)
self.assertEqual(self.intervention.recorded.user, self.request.user)
self.assertEqual(self.intervention.recorded, self.intervention.log.first())
class RemoveModalFormTestCase(BaseTestCase):
def setUp(self) -> None:
super().setUp()
self.request = RequestFactory().request()
self.request.user = self.user
def test_init(self):
form = RemoveModalForm(request=self.request, instance=self.intervention)
self.assertEqual(form.form_title, str(_("Remove")))
self.assertEqual(form.form_caption, str(_("Are you sure?")))
self.assertEqual(form.template, "modal/modal_form.html")
self.assertEqual(form.request, self.request)
self.assertEqual(form.user, self.request.user)
def test_save(self):
data = {
"confirm": True,
}
form = RemoveModalForm(
data,
request=self.request,
instance=self.intervention
)
self.assertTrue(form.is_valid(), msg=form.errors)
form.save()
self.assertEqual(self.intervention.deleted.action, UserAction.DELETED)
self.assertEqual(self.intervention.deleted.user, self.request.user)
payment = Payment.objects.create(
amount=1.0,
intervention=self.intervention
)
form = RemoveModalForm(
data,
request=self.request,
instance=payment
)
self.assertTrue(form.is_valid(), msg=form.errors)
form.save()
try:
payment.refresh_from_db()
self.fail("Payment still exists")
except ObjectDoesNotExist:
pass
class RemoveDeadlineTestCase(BaseTestCase):
def setUp(self) -> None:
super().setUp()
request = RequestFactory().request()
request.user = self.user
self.request = request
def test_init(self):
form = RemoveDeadlineModalForm(
request=self.request,
instance=self.compensation,
deadline=self.finished_deadline
)
self.assertEqual(form.form_title, str(_("Remove")))
self.assertEqual(form.form_caption, str(_("Are you sure?")))
self.assertEqual(form.template, "modal/modal_form.html")
self.assertEqual(form.request, self.request)
self.assertEqual(form.user, self.request.user)
def test_save(self):
self.compensation.deadlines.add(self.finished_deadline)
data = {
"confirm": True
}
form = RemoveDeadlineModalForm(
data,
request=self.request,
instance=self.compensation,
deadline=self.finished_deadline
)
self.assertTrue(form.is_valid(), msg=form.errors)
form.save()
try:
self.finished_deadline.refresh_from_db()
self.fail("Deadline still exists")
except ObjectDoesNotExist:
pass
last_log = self.compensation.log.first()
self.assertEqual(last_log.action, UserAction.EDITED)
self.assertEqual(last_log.user, self.request.user)
self.assertEqual(last_log.comment, DEADLINE_REMOVED)
Write Preview
Loading…
Cancel
Save