Merge pull request 'master' (#348) from master into Docker
Reviewed-on: SGD-Nord/konova#348pull/380/head
commit
06197c3cfb
@ -1,3 +1,5 @@
|
||||
# Project exclude paths
|
||||
/venv/
|
||||
/.idea/
|
||||
/.coverage
|
||||
/htmlcov/
|
||||
|
@ -1,3 +0,0 @@
|
||||
from django.test import TestCase
|
||||
|
||||
# Create your tests here.
|
@ -0,0 +1,7 @@
|
||||
"""
|
||||
Author: Michel Peltriaux
|
||||
Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
|
||||
Contact: ksp-servicestelle@sgdnord.rlp.de
|
||||
Created on: 15.08.23
|
||||
|
||||
"""
|
@ -0,0 +1,7 @@
|
||||
"""
|
||||
Author: Michel Peltriaux
|
||||
Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
|
||||
Contact: ksp-servicestelle@sgdnord.rlp.de
|
||||
Created on: 15.08.23
|
||||
|
||||
"""
|
@ -0,0 +1,47 @@
|
||||
"""
|
||||
Author: Michel Peltriaux
|
||||
Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
|
||||
Contact: ksp-servicestelle@sgdnord.rlp.de
|
||||
Created on: 15.08.23
|
||||
|
||||
"""
|
||||
from datetime import timedelta
|
||||
|
||||
from django.urls import reverse
|
||||
from django.utils.timezone import now
|
||||
from django.utils.translation import gettext_lazy as _
|
||||
|
||||
from analysis.forms import TimespanReportForm
|
||||
from konova.tests.test_views import BaseTestCase
|
||||
|
||||
|
||||
class TimeSpanReportFormTestCase(BaseTestCase):
|
||||
def setUp(self) -> None:
|
||||
super().setUp()
|
||||
eiv = self.create_dummy_intervention()
|
||||
|
||||
def test_init(self):
|
||||
form = TimespanReportForm()
|
||||
self.assertEqual(form.form_title, str(_("Generate report")))
|
||||
self.assertEqual(form.form_caption, str(_("Select a timespan and the desired conservation office") ))
|
||||
self.assertEqual(form.action_url, reverse("analysis:reports"))
|
||||
self.assertFalse(form.show_cancel_btn)
|
||||
self.assertEqual(form.action_btn_label, str(_("Continue")))
|
||||
|
||||
def test_save(self):
|
||||
date_from = now().date() - timedelta(days=365)
|
||||
date_to = now().date()
|
||||
office = self.get_conservation_office_code()
|
||||
data = {
|
||||
"date_from": date_from,
|
||||
"date_to": date_to,
|
||||
"conservation_office": office,
|
||||
}
|
||||
form = TimespanReportForm(data)
|
||||
self.assertTrue(form.is_valid(), msg=f"{form.errors}")
|
||||
|
||||
detail_report_url = form.save()
|
||||
self.assertEqual(
|
||||
detail_report_url,
|
||||
reverse("analysis:report-detail", args=(office.id,)) + f"?df={date_from}&dt={date_to}"
|
||||
)
|
@ -0,0 +1,98 @@
|
||||
"""
|
||||
Author: Michel Peltriaux
|
||||
Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
|
||||
Contact: ksp-servicestelle@sgdnord.rlp.de
|
||||
Created on: 17.08.23
|
||||
|
||||
"""
|
||||
from datetime import timedelta
|
||||
|
||||
from django.utils.timezone import now
|
||||
|
||||
from analysis.settings import LKOMPVZVO_PUBLISH_DATE
|
||||
from analysis.utils.report import TimespanReport
|
||||
from konova.sub_settings.django_settings import DEFAULT_DATE_FORMAT
|
||||
from konova.tests.test_views import BaseTestCase
|
||||
|
||||
|
||||
class TimeSpanReportTestCase(BaseTestCase):
|
||||
def setUp(self) -> None:
|
||||
super().setUp()
|
||||
|
||||
today = now().date()
|
||||
old_date = LKOMPVZVO_PUBLISH_DATE - timedelta(days=1)
|
||||
|
||||
self.conservation_office = self.get_conservation_office_code()
|
||||
self.eiv_old = self.create_dummy_intervention()
|
||||
self.kom_old = self.create_dummy_compensation(interv=self.eiv_old)
|
||||
self.assertNotEqual(self.compensation.intervention, self.kom_old.intervention)
|
||||
self.eiv = self.compensation.intervention
|
||||
self.oek_old = self.create_dummy_eco_account()
|
||||
|
||||
self.eiv_old.responsible.conservation_office = self.conservation_office
|
||||
self.eiv_old.legal.binding_date = old_date
|
||||
self.eiv_old.legal.registration_date = old_date
|
||||
|
||||
self.eiv.responsible.conservation_office = self.conservation_office
|
||||
self.eiv.legal.binding_date = today
|
||||
self.eiv.legal.registration_date = today
|
||||
|
||||
self.eco_account.responsible.conservation_office = self.conservation_office
|
||||
self.eco_account.legal.registration_date = today
|
||||
self.eco_account.legal.binding_date = today
|
||||
|
||||
self.oek_old.responsible.conservation_office = self.conservation_office
|
||||
self.oek_old.legal.registration_date = old_date
|
||||
self.oek_old.legal.binding_date = old_date
|
||||
|
||||
self.eiv.legal.save()
|
||||
self.eiv.responsible.save()
|
||||
|
||||
self.eiv_old.legal.save()
|
||||
self.eiv_old.responsible.save()
|
||||
|
||||
self.eco_account.legal.save()
|
||||
self.eco_account.responsible.save()
|
||||
|
||||
self.oek_old.legal.save()
|
||||
self.oek_old.responsible.save()
|
||||
|
||||
self.deduction.account = self.eco_account
|
||||
self.deduction.intervention = self.eiv
|
||||
self.deduction.save()
|
||||
|
||||
def test_init(self):
|
||||
date_from = now().date() - timedelta(days=365)
|
||||
date_to = now().date()
|
||||
report = TimespanReport(self.conservation_office.id, date_from, date_to)
|
||||
|
||||
self.assertEqual(report.office_id, self.conservation_office.id)
|
||||
self.assertEqual(report.date_from, date_from)
|
||||
self.assertEqual(report.date_to, date_to)
|
||||
|
||||
self.assertIsNotNone(report.intervention_report)
|
||||
self.assertIsNotNone(report.compensation_report)
|
||||
self.assertIsNotNone(report.eco_account_report)
|
||||
self.assertIsNotNone(report.old_data_report)
|
||||
|
||||
self.assertEqual(report.excel_map["date_from"], date_from.strftime(DEFAULT_DATE_FORMAT))
|
||||
self.assertEqual(report.excel_map["date_to"], date_to.strftime(DEFAULT_DATE_FORMAT))
|
||||
|
||||
self.assertEqual(report.old_data_report.queryset_intervention_count, 1)
|
||||
self.assertEqual(report.old_data_report.queryset_intervention_recorded_count, 0)
|
||||
self.assertEqual(report.old_data_report.queryset_comps_count, 1)
|
||||
self.assertEqual(report.old_data_report.queryset_acc_count, 1)
|
||||
self.assertEqual(report.old_data_report.queryset_acc_recorded_count, 0)
|
||||
|
||||
self.assertEqual(report.intervention_report.queryset_count, 1)
|
||||
self.assertEqual(report.intervention_report.queryset_checked_count, 0)
|
||||
self.assertEqual(report.intervention_report.queryset_recorded_count, 0)
|
||||
|
||||
self.assertEqual(report.compensation_report.queryset_count, 1)
|
||||
self.assertEqual(report.compensation_report.queryset_checked_count, 0)
|
||||
self.assertEqual(report.compensation_report.queryset_recorded_count, 0)
|
||||
|
||||
self.assertEqual(report.eco_account_report.queryset_count, 1)
|
||||
self.assertEqual(report.eco_account_report.queryset_recorded_count, 0)
|
||||
self.assertEqual(report.eco_account_report.queryset_deductions_count, 1)
|
||||
self.assertEqual(report.eco_account_report.queryset_deductions_recorded_count, 0)
|
@ -0,0 +1,7 @@
|
||||
"""
|
||||
Author: Michel Peltriaux
|
||||
Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
|
||||
Contact: ksp-servicestelle@sgdnord.rlp.de
|
||||
Created on: 17.08.23
|
||||
|
||||
"""
|
@ -0,0 +1,71 @@
|
||||
"""
|
||||
Author: Michel Peltriaux
|
||||
Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
|
||||
Contact: ksp-servicestelle@sgdnord.rlp.de
|
||||
Created on: 17.08.23
|
||||
|
||||
"""
|
||||
from datetime import timedelta
|
||||
|
||||
from django.utils.timezone import now
|
||||
|
||||
from api.models import APIUserToken
|
||||
from konova.tests.test_views import BaseTestCase
|
||||
|
||||
|
||||
class APIUserTokenTestCase(BaseTestCase):
|
||||
def setUp(self) -> None:
|
||||
super().setUp()
|
||||
|
||||
self.token = APIUserToken.objects.create()
|
||||
self.superuser.api_token = self.token
|
||||
self.superuser.save()
|
||||
|
||||
def test_str(self):
|
||||
self.assertEqual(str(self.token), self.token.token)
|
||||
|
||||
def test_get_user_from_token(self):
|
||||
a_day = timedelta(days=1)
|
||||
today = now().date()
|
||||
|
||||
self.assertFalse(self.token.is_active)
|
||||
self.assertIsNone(self.token.valid_until)
|
||||
|
||||
try:
|
||||
#Token not existing --> fail
|
||||
token_user = APIUserToken.get_user_from_token(self.token.token[::-1])
|
||||
self.fail("There should not have been any token")
|
||||
except PermissionError:
|
||||
pass
|
||||
|
||||
try:
|
||||
# Token not active --> fail
|
||||
token_user = APIUserToken.get_user_from_token(self.token.token)
|
||||
self.fail("Token is unverified but token user has been fetchable.")
|
||||
except PermissionError:
|
||||
pass
|
||||
self.token.is_active = True
|
||||
self.token.valid_until = today - a_day
|
||||
self.token.save()
|
||||
|
||||
try:
|
||||
# Token valid until yesterday --> fail
|
||||
token_user = APIUserToken.get_user_from_token(self.token.token)
|
||||
self.fail("Token reached end of lifetime but token user has been fetchable.")
|
||||
except PermissionError:
|
||||
pass
|
||||
|
||||
# Token valid until tomorrow --> success
|
||||
self.token.valid_until = today + a_day
|
||||
self.token.save()
|
||||
|
||||
token_user = APIUserToken.get_user_from_token(self.token.token)
|
||||
self.assertEqual(token_user, self.superuser)
|
||||
del token_user
|
||||
|
||||
# Token valid forever --> success
|
||||
self.token.valid_until = None
|
||||
self.token.save()
|
||||
token_user = APIUserToken.get_user_from_token(self.token.token)
|
||||
self.assertEqual(token_user, self.superuser)
|
||||
|
@ -0,0 +1,7 @@
|
||||
"""
|
||||
Author: Michel Peltriaux
|
||||
Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
|
||||
Contact: ksp-servicestelle@sgdnord.rlp.de
|
||||
Created on: 21.08.23
|
||||
|
||||
"""
|
@ -0,0 +1,318 @@
|
||||
"""
|
||||
Author: Michel Peltriaux
|
||||
Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
|
||||
Contact: ksp-servicestelle@sgdnord.rlp.de
|
||||
Created on: 21.08.23
|
||||
|
||||
"""
|
||||
from django.core.exceptions import ObjectDoesNotExist
|
||||
from django.test import RequestFactory
|
||||
from django.utils.translation import gettext_lazy as _
|
||||
|
||||
from codelist.models import KonovaCodeList
|
||||
from codelist.settings import CODELIST_COMPENSATION_ACTION_ID, CODELIST_BIOTOPES_ID
|
||||
from compensation.forms.modals.compensation_action import NewCompensationActionModalForm, \
|
||||
EditCompensationActionModalForm, RemoveCompensationActionModalForm
|
||||
from compensation.forms.modals.state import NewCompensationStateModalForm, EditCompensationStateModalForm, \
|
||||
RemoveCompensationStateModalForm
|
||||
from compensation.models import UnitChoices
|
||||
from konova.tests.test_views import BaseTestCase
|
||||
from konova.utils.generators import generate_random_string
|
||||
from konova.utils.message_templates import COMPENSATION_ACTION_EDITED, ADDED_COMPENSATION_ACTION, \
|
||||
COMPENSATION_ACTION_REMOVED, ADDED_COMPENSATION_STATE, COMPENSATION_STATE_EDITED, \
|
||||
COMPENSATION_STATE_REMOVED
|
||||
from user.models import UserAction
|
||||
|
||||
|
||||
class NewCompensationActionModalFormTestCase(BaseTestCase):
|
||||
|
||||
def setUp(self) -> None:
|
||||
super().setUp()
|
||||
self.request = RequestFactory().request()
|
||||
self.request.user = self.superuser
|
||||
|
||||
self.action_dummy_code = self.create_dummy_codes().first()
|
||||
action_list = KonovaCodeList.objects.get_or_create(
|
||||
id=CODELIST_COMPENSATION_ACTION_ID,
|
||||
)[0]
|
||||
action_list.codes.add(self.action_dummy_code)
|
||||
|
||||
def test_init(self):
|
||||
form = NewCompensationActionModalForm()
|
||||
self.assertEqual(form.form_title, str(_("New action")))
|
||||
self.assertEqual(form.form_caption, str(_("Insert data for the new action")))
|
||||
self.assertTrue(len(form.fields["action_type"].choices) == 1)
|
||||
|
||||
def test_save(self):
|
||||
comment = "TEST_comment"
|
||||
unit = UnitChoices.km
|
||||
amount = 2.5
|
||||
|
||||
data = {
|
||||
"action_type": [self.action_dummy_code.id],
|
||||
"action_type_details": [],
|
||||
"unit": unit,
|
||||
"amount": amount,
|
||||
"comment": comment,
|
||||
}
|
||||
form = NewCompensationActionModalForm(data, request=self.request, instance=self.compensation)
|
||||
self.assertTrue(form.is_valid(), msg=form.errors)
|
||||
|
||||
comp_action = form.save()
|
||||
last_log = self.compensation.log.first()
|
||||
self.assertIn(comp_action, self.compensation.actions.all())
|
||||
self.assertEqual(last_log.action, UserAction.EDITED)
|
||||
self.assertEqual(last_log.user, self.superuser)
|
||||
self.assertEqual(last_log.comment, ADDED_COMPENSATION_ACTION)
|
||||
self.assertEqual(comp_action.amount, amount)
|
||||
self.assertEqual(comp_action.unit, unit)
|
||||
self.assertEqual(comp_action.comment, comment)
|
||||
comp_action_types = comp_action.action_type.all()
|
||||
self.assertEqual(comp_action_types.count(), 1)
|
||||
self.assertEqual(comp_action_types.first(), self.action_dummy_code)
|
||||
|
||||
|
||||
class EditCompensationActionModalFormTestCase(NewCompensationActionModalFormTestCase):
|
||||
|
||||
def setUp(self) -> None:
|
||||
super().setUp()
|
||||
self.comp_action = self.create_dummy_action()
|
||||
self.compensation.actions.add(self.comp_action)
|
||||
|
||||
def test_init(self):
|
||||
form = EditCompensationActionModalForm(request=self.request, instance=self.compensation, action=self.comp_action)
|
||||
self.assertEqual(form.form_title, str(_("Edit action")))
|
||||
self.assertEqual(len(form.fields["action_type"].initial), self.comp_action.action_type.count())
|
||||
self.assertEqual(len(form.fields["action_type_details"].initial), self.comp_action.action_type_details.count())
|
||||
self.assertEqual(form.fields["amount"].initial, self.comp_action.amount)
|
||||
self.assertEqual(form.fields["unit"].initial, self.comp_action.unit)
|
||||
self.assertEqual(form.fields["comment"].initial, self.comp_action.comment)
|
||||
|
||||
def test_save(self):
|
||||
amount = 25.4
|
||||
unit = UnitChoices.cm
|
||||
comment = generate_random_string(length=20, use_numbers=True, use_letters_lc=True, use_letters_uc=True)
|
||||
|
||||
data = {
|
||||
"action_type": [self.action_dummy_code.id],
|
||||
"action_type_details": [],
|
||||
"amount": amount,
|
||||
"unit": unit,
|
||||
"comment": comment,
|
||||
}
|
||||
|
||||
form = EditCompensationActionModalForm(data, request=self.request, instance=self.compensation, action=self.comp_action)
|
||||
|
||||
self.assertTrue(form.is_valid())
|
||||
action = form.save()
|
||||
|
||||
self.assertEqual(action.action_type.count(), len(data["action_type"]))
|
||||
self.assertEqual(action.action_type_details.count(), 0)
|
||||
self.assertEqual(float(action.amount), amount)
|
||||
self.assertEqual(action.unit, unit)
|
||||
self.assertEqual(action.comment, comment)
|
||||
|
||||
last_log = self.compensation.log.first()
|
||||
self.assertEqual(last_log.action, UserAction.EDITED)
|
||||
self.assertEqual(last_log.user, self.superuser)
|
||||
self.assertEqual(last_log.comment, COMPENSATION_ACTION_EDITED)
|
||||
self.assertIn(action, self.compensation.actions.all())
|
||||
self.assertEqual(self.compensation.actions.count(), 1)
|
||||
|
||||
|
||||
class RemoveCompensationActionModalFormTestCase(EditCompensationActionModalFormTestCase):
|
||||
def setUp(self) -> None:
|
||||
super().setUp()
|
||||
|
||||
def test_init(self):
|
||||
self.assertIn(self.comp_action, self.compensation.actions.all())
|
||||
form = RemoveCompensationActionModalForm(request=self.request, instance=self.compensation, action=self.comp_action)
|
||||
self.assertEqual(form.action, self.comp_action)
|
||||
|
||||
def test_save(self):
|
||||
data = {
|
||||
"confirm": True,
|
||||
}
|
||||
form = RemoveCompensationActionModalForm(
|
||||
data,
|
||||
request=self.request,
|
||||
instance=self.compensation,
|
||||
action=self.comp_action
|
||||
)
|
||||
self.assertTrue(form.is_valid())
|
||||
self.assertIn(self.comp_action, self.compensation.actions.all())
|
||||
|
||||
form.save()
|
||||
|
||||
last_log = self.compensation.log.first()
|
||||
self.assertEqual(last_log.action, UserAction.EDITED)
|
||||
self.assertEqual(last_log.user, self.superuser)
|
||||
self.assertEqual(last_log.comment, COMPENSATION_ACTION_REMOVED)
|
||||
|
||||
self.assertNotIn(self.comp_action, self.compensation.actions.all())
|
||||
try:
|
||||
self.comp_action.refresh_from_db()
|
||||
self.fail(msg="This action should not be fetchable anymore")
|
||||
except ObjectDoesNotExist:
|
||||
pass
|
||||
|
||||
|
||||
class NewCompensationStateModalFormTestCase(BaseTestCase):
|
||||
def setUp(self) -> None:
|
||||
super().setUp()
|
||||
self.request = RequestFactory().request()
|
||||
self.request.user = self.superuser
|
||||
|
||||
self.comp_biotope_code = self.create_dummy_codes().first()
|
||||
self.biotope_codelist = KonovaCodeList.objects.get_or_create(
|
||||
id=CODELIST_BIOTOPES_ID
|
||||
)[0]
|
||||
self.biotope_codelist.codes.add(self.comp_biotope_code)
|
||||
|
||||
def test_init(self):
|
||||
form = NewCompensationStateModalForm(request=self.request, instance=self.compensation)
|
||||
|
||||
self.assertEqual(form.form_title, str(_("New state")))
|
||||
self.assertEqual(form.form_caption, str(_("Insert data for the new state")))
|
||||
self.assertEqual(len(form.fields["biotope_type"].choices), 1)
|
||||
|
||||
def test_save(self):
|
||||
test_surface = 123.45
|
||||
data = {
|
||||
"biotope_type": self.comp_biotope_code.id,
|
||||
"biotope_extra": [],
|
||||
"surface": test_surface,
|
||||
}
|
||||
self.assertEqual(self.compensation.before_states.count(), 0)
|
||||
self.assertEqual(self.compensation.after_states.count(), 0)
|
||||
|
||||
form = NewCompensationStateModalForm(data, request=self.request, instance=self.compensation)
|
||||
|
||||
self.assertTrue(form.is_valid(), msg=form.errors)
|
||||
|
||||
is_before_state = True
|
||||
state = form.save(is_before_state)
|
||||
|
||||
self.assertEqual(self.compensation.before_states.count(), 1)
|
||||
self.assertEqual(self.compensation.after_states.count(), 0)
|
||||
self.assertIn(state, self.compensation.before_states.all())
|
||||
self.assertEqual(state.biotope_type, self.comp_biotope_code)
|
||||
self.assertEqual(state.biotope_type_details.count(), 0)
|
||||
self.assertEqual(float(state.surface), test_surface)
|
||||
|
||||
last_log = self.compensation.log.first()
|
||||
self.assertEqual(last_log.user, self.superuser)
|
||||
self.assertEqual(last_log.action, UserAction.EDITED)
|
||||
self.assertEqual(last_log.comment, ADDED_COMPENSATION_STATE)
|
||||
|
||||
is_before_state = False
|
||||
state = form.save(is_before_state)
|
||||
|
||||
self.assertEqual(self.compensation.before_states.count(), 1)
|
||||
self.assertEqual(self.compensation.after_states.count(), 1)
|
||||
self.assertIn(state, self.compensation.after_states.all())
|
||||
self.assertEqual(state.biotope_type, self.comp_biotope_code)
|
||||
self.assertEqual(state.biotope_type_details.count(), 0)
|
||||
self.assertEqual(float(state.surface), test_surface)
|
||||
|
||||
last_log = self.compensation.log.first()
|
||||
self.assertEqual(last_log.user, self.superuser)
|
||||
self.assertEqual(last_log.action, UserAction.EDITED)
|
||||
self.assertEqual(last_log.comment, ADDED_COMPENSATION_STATE)
|
||||
|
||||
|
||||
class EditCompensationStateModalFormTestCase(NewCompensationStateModalFormTestCase):
|
||||
def setUp(self) -> None:
|
||||
super().setUp()
|
||||
self.comp_state.biotope_type = self.comp_biotope_code
|
||||
self.comp_state.save()
|
||||
|
||||
self.compensation.after_states.add(self.comp_state)
|
||||
|
||||
def test_init(self):
|
||||
form = EditCompensationStateModalForm(request=self.request, instance=self.compensation, state=self.comp_state)
|
||||
|
||||
self.assertEqual(form.state, self.comp_state)
|
||||
self.assertEqual(form.form_title, str(_("Edit state")))
|
||||
self.assertEqual(form.fields["biotope_type"].initial, self.comp_state.biotope_type.id)
|
||||
self.assertTrue(
|
||||
form.fields["biotope_extra"].initial.difference(
|
||||
self.comp_state.biotope_type_details.all()
|
||||
).count() == 0
|
||||
)
|
||||
self.assertEqual(form.fields["surface"].initial, self.comp_state.surface)
|
||||
|
||||
def test_save(self):
|
||||
test_surface = 987.65
|
||||
test_code = self.create_dummy_codes().exclude(
|
||||
id=self.comp_biotope_code.id
|
||||
).first()
|
||||
self.biotope_codelist.codes.add(test_code)
|
||||
|
||||
self.assertEqual(self.compensation.after_states.count(), 1)
|
||||
self.assertEqual(self.compensation.before_states.count(), 0)
|
||||
|
||||
data = {
|
||||
"biotope_type": test_code.id,
|
||||
"biotope_extra": [],
|
||||
"surface": test_surface,
|
||||
}
|
||||
form = EditCompensationStateModalForm(
|
||||
data,
|
||||
request=self.request,
|
||||
instance=self.compensation,
|
||||
state=self.comp_state
|
||||
)
|
||||
self.assertTrue(form.is_valid(), msg=form.errors)
|
||||
|
||||
is_before_state = False
|
||||
state = form.save(is_before_state=is_before_state)
|
||||
self.assertEqual(state.biotope_type, test_code)
|
||||
self.assertEqual(state.biotope_type_details.count(), 0)
|
||||
self.assertEqual(float(state.surface), test_surface)
|
||||
|
||||
last_log = self.compensation.log.first()
|
||||
self.assertEqual(last_log.action, UserAction.EDITED)
|
||||
self.assertEqual(last_log.user, self.superuser)
|
||||
self.assertEqual(last_log.comment, COMPENSATION_STATE_EDITED)
|
||||
|
||||
|
||||
class RemoveCompensationStateModalFormTestCase(EditCompensationStateModalFormTestCase):
|
||||
def setUp(self) -> None:
|
||||
super().setUp()
|
||||
|
||||
def test_init(self):
|
||||
form = RemoveCompensationStateModalForm(request=self.request, instance=self.compensation, state=self.comp_state)
|
||||
|
||||
self.assertEqual(form.state, self.comp_state)
|
||||
|
||||
def test_save(self):
|
||||
data = {
|
||||
"confirm": True
|
||||
}
|
||||
form = RemoveCompensationStateModalForm(
|
||||
data,
|
||||
request=self.request,
|
||||
instance=self.compensation,
|
||||
state=self.comp_state
|
||||
)
|
||||
self.assertTrue(form.is_valid(), msg=form.errors)
|
||||
|
||||
self.assertIn(self.comp_state, self.compensation.after_states.all())
|
||||
self.assertNotIn(self.comp_state, self.compensation.before_states.all())
|
||||
|
||||
form.save()
|
||||
|
||||
self.assertEqual(self.compensation.after_states.count(), 0)
|
||||
self.assertEqual(self.compensation.before_states.count(), 0)
|
||||
try:
|
||||
self.comp_state.refresh_from_db()
|
||||
self.fail("Entry should not existing anymore")
|
||||
except ObjectDoesNotExist:
|
||||
pass
|
||||
|
||||
last_log = self.compensation.log.first()
|
||||
self.assertEqual(last_log.user, self.superuser)
|
||||
self.assertEqual(last_log.action, UserAction.EDITED)
|
||||
self.assertEqual(last_log.comment, COMPENSATION_STATE_REMOVED)
|
||||
|
@ -0,0 +1,201 @@
|
||||
"""
|
||||
Author: Michel Peltriaux
|
||||
Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
|
||||
Contact: ksp-servicestelle@sgdnord.rlp.de
|
||||
Created on: 30.08.23
|
||||
|
||||
"""
|
||||
from django.core.exceptions import ObjectDoesNotExist
|
||||
from django.test import RequestFactory
|
||||
from django.utils.timezone import now
|
||||
|
||||
from compensation.forms.modals.deadline import NewDeadlineModalForm
|
||||
from compensation.models import CompensationDocument
|
||||
from konova.forms.modals import RemoveDeadlineModalForm
|
||||
from konova.models import DeadlineType
|
||||
from konova.tests.test_views import BaseTestCase
|
||||
from konova.utils.message_templates import DEADLINE_REMOVED, DOCUMENT_REMOVED_TEMPLATE, COMPENSATION_REMOVED_TEMPLATE, \
|
||||
DEADLINE_ADDED
|
||||
from user.models import UserAction, Team
|
||||
|
||||
|
||||
class AbstractCompensationModelTestCase(BaseTestCase):
|
||||
def setUp(self) -> None:
|
||||
super().setUp()
|
||||
self.request = RequestFactory().request()
|
||||
self.request.user = self.superuser
|
||||
|
||||
def test_remove_deadline(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)
|
||||
self.assertIn(self.finished_deadline, self.compensation.deadlines.all())
|
||||
form.save()
|
||||
|
||||
last_log = self.compensation.log.first()
|
||||
self.assertEqual(last_log.user, self.request.user)
|
||||
self.assertEqual(last_log.action, UserAction.EDITED)
|
||||
self.assertEqual(last_log.comment, DEADLINE_REMOVED)
|
||||
|
||||
self.assertNotIn(self.finished_deadline, self.compensation.deadlines.all())
|
||||
try:
|
||||
self.finished_deadline.refresh_from_db()
|
||||
self.fail("Deadline should not exist anymore after removing from abstract compensation")
|
||||
except ObjectDoesNotExist:
|
||||
pass
|
||||
|
||||
def test_add_deadline(self):
|
||||
request = RequestFactory().request()
|
||||
request.user = self.superuser
|
||||
|
||||
data = {
|
||||
"type": DeadlineType.MAINTAIN,
|
||||
"date": now().date(),
|
||||
"comment": "TestDeadline"
|
||||
}
|
||||
form = NewDeadlineModalForm(
|
||||
data,
|
||||
request=self.request,
|
||||
instance=self.compensation,
|
||||
)
|
||||
self.assertTrue(form.is_valid(), msg=form.errors)
|
||||
deadline = self.compensation.add_deadline(form)
|
||||
self.assertEqual(deadline.date, data["date"])
|
||||
self.assertEqual(deadline.type, data["type"])
|
||||
self.assertEqual(deadline.comment, data["comment"])
|
||||
self.assertEqual(deadline.created.action, UserAction.CREATED)
|
||||
self.assertEqual(deadline.created.user, self.superuser)
|
||||
self.assertEqual(deadline.created.comment, None)
|
||||
self.assertIn(deadline, self.compensation.deadlines.all())
|
||||
|
||||
last_log = self.compensation.log.first()
|
||||
self.assertEqual(last_log.action, UserAction.EDITED)
|
||||
self.assertEqual(last_log.user, self.superuser)
|
||||
self.assertEqual(last_log.comment, DEADLINE_ADDED)
|
||||
|
||||
|
||||
class CompensationTestCase(BaseTestCase):
|
||||
def setUp(self) -> None:
|
||||
super().setUp()
|
||||
|
||||
def test_str(self):
|
||||
self.assertEqual(str(self.compensation), self.compensation.identifier)
|
||||
|
||||
def test_save(self):
|
||||
old_identifier = self.compensation.identifier
|
||||
self.compensation.identifier = None
|
||||
self.compensation.save()
|
||||
self.assertIsNotNone(self.compensation.identifier)
|
||||
self.assertNotEqual(old_identifier, self.compensation.identifier)
|
||||
|
||||
def test_share_with_user(self):
|
||||
self.assertNotIn(self.user, self.compensation.shared_users)
|
||||
self.compensation.share_with_user(self.user)
|
||||
self.assertIn(self.user, self.compensation.shared_users)
|
||||
|
||||
def test_share_with_user_list(self):
|
||||
user_list = [
|
||||
self.user
|
||||
]
|
||||
self.assertNotIn(self.user, self.compensation.shared_users)
|
||||
self.compensation.share_with_user_list(user_list)
|
||||
self.assertIn(self.user, self.compensation.shared_users)
|
||||
user_list = [
|
||||
self.superuser
|
||||
]
|
||||
self.assertNotIn(self.superuser, self.compensation.shared_users)
|
||||
self.compensation.share_with_user_list(user_list)
|
||||
self.assertIn(self.superuser, self.compensation.shared_users)
|
||||
self.assertNotIn(self.user, self.compensation.shared_users)
|
||||
|
||||
def test_share_with_team(self):
|
||||
self.assertNotIn(self.team, self.compensation.shared_teams)
|
||||
self.compensation.share_with_team(self.team)
|
||||
self.assertIn(self.team, self.compensation.shared_teams)
|
||||
|
||||
def test_share_with_team_list(self):
|
||||
self.compensation.share_with_team(self.team)
|
||||
self.assertIn(self.team, self.compensation.shared_teams)
|
||||
other_team = Team.objects.create(
|
||||
name="NewTeam"
|
||||
)
|
||||
team_list = [
|
||||
other_team
|
||||
]
|
||||
self.compensation.share_with_team_list(team_list)
|
||||
self.assertIn(other_team, self.compensation.shared_teams)
|
||||
self.assertNotIn(self.team, self.compensation.shared_teams)
|
||||
|
||||
def test_shared_users(self):
|
||||
intervention = self.compensation.intervention
|
||||
diff = self.compensation.shared_users.difference(intervention.shared_users)
|
||||
self.assertEqual(diff.count(), 0)
|
||||
|
||||
self.compensation.share_with_user(self.superuser)
|
||||
diff = self.compensation.shared_users.difference(intervention.shared_users)
|
||||
self.assertEqual(diff.count(), 0)
|
||||
|
||||
def test_shared_teams(self):
|
||||
intervention = self.compensation.intervention
|
||||
diff = self.compensation.shared_users.difference(intervention.shared_users)
|
||||
self.assertEqual(diff.count(), 0)
|
||||
|
||||
self.compensation.share_with_user(self.superuser)
|
||||
diff = self.compensation.shared_users.difference(intervention.shared_users)
|
||||
self.assertEqual(diff.count(), 0)
|
||||
|
||||
def test_get_documents(self):
|
||||
doc = self.create_dummy_document(CompensationDocument, self.compensation)
|
||||
docs = self.compensation.get_documents()
|
||||
self.assertIn(doc, docs)
|
||||
|
||||
def test_mark_as_deleted(self):
|
||||
self.assertIsNone(self.compensation.deleted)
|
||||
self.compensation.mark_as_deleted(self.superuser, send_mail=False)
|
||||
|
||||
comp_deleted = self.compensation.deleted
|
||||
self.assertIsNotNone(comp_deleted)
|
||||
self.assertEqual(comp_deleted.action, UserAction.DELETED)
|
||||
self.assertEqual(comp_deleted.user, self.superuser)
|
||||
self.assertEqual(comp_deleted.comment, None)
|
||||
|
||||
intervention_last_log = self.compensation.intervention.log.first()
|
||||
self.assertEqual(intervention_last_log.action, UserAction.EDITED)
|
||||
self.assertEqual(intervention_last_log.user, self.superuser)
|
||||
self.assertEqual(
|
||||
intervention_last_log.comment,
|
||||
COMPENSATION_REMOVED_TEMPLATE.format(
|
||||
self.compensation.identifier
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
class CompensationDocumentTestCase(BaseTestCase):
|
||||
def setUp(self) -> None:
|
||||
super().setUp()
|
||||
self.doc = self.create_dummy_document(CompensationDocument, self.compensation)
|
||||
|
||||
def test_delete(self):
|
||||
doc_title = self.doc.title
|
||||
self.assertIn(self.doc, self.compensation.get_documents())
|
||||
self.doc.delete(self.superuser)
|
||||
self.assertNotIn(self.doc, self.compensation.get_documents())
|
||||
try:
|
||||
self.doc.refresh_from_db()
|
||||
self.fail("Document should not be fetchable anymore")
|
||||
except ObjectDoesNotExist:
|
||||
pass
|
||||
last_log = self.compensation.log.first()
|
||||
self.assertEqual(last_log.user, self.superuser)
|
||||
self.assertEqual(last_log.action, UserAction.EDITED)
|
||||
self.assertEqual(last_log.comment, DOCUMENT_REMOVED_TEMPLATE.format(doc_title))
|
@ -0,0 +1,7 @@
|
||||
"""
|
||||
Author: Michel Peltriaux
|
||||
Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
|
||||
Contact: ksp-servicestelle@sgdnord.rlp.de
|
||||
Created on: 30.08.23
|
||||
|
||||
"""
|
@ -0,0 +1,128 @@
|
||||
"""
|
||||
Author: Michel Peltriaux
|
||||
Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
|
||||
Contact: ksp-servicestelle@sgdnord.rlp.de
|
||||
Created on: 30.08.23
|
||||
|
||||
"""
|
||||
from django.core.exceptions import ObjectDoesNotExist
|
||||
from django.urls import reverse
|
||||
|
||||
from compensation.models import EcoAccountDocument
|
||||
from konova.tests.test_views import BaseTestCase
|
||||
from konova.utils.message_templates import DOCUMENT_REMOVED_TEMPLATE, DEDUCTION_REMOVED
|
||||
from user.models import UserAction
|
||||
|
||||
|
||||
class EcoAccountTestCase(BaseTestCase):
|
||||
|
||||
def setUp(self) -> None:
|
||||
super().setUp()
|
||||
|
||||
def test_str(self):
|
||||
self.assertEqual(str(self.eco_account), f"{self.eco_account.identifier} ({self.eco_account.title})")
|
||||
|
||||
def test_save(self):
|
||||
old_id = self.eco_account.identifier
|
||||
self.assertIsNotNone(self.eco_account.identifier)
|
||||
self.eco_account.identifier = None
|
||||
self.eco_account.save()
|
||||
self.assertIsNotNone(self.eco_account.identifier)
|
||||
self.assertNotEqual(old_id, self.eco_account.identifier)
|
||||
|
||||
def test_property_deductions_surface_sum(self):
|
||||
self.assertEqual(
|
||||
self.eco_account.deductions_surface_sum,
|
||||
self.eco_account.get_deductions_surface()
|
||||
)
|
||||
|
||||
def test_get_documents(self):
|
||||
docs = self.eco_account.get_documents()
|
||||
self.assertEqual(docs.count(), 0)
|
||||
doc = self.create_dummy_document(EcoAccountDocument, self.eco_account)
|
||||
self.assertIn(doc, self.eco_account.get_documents())
|
||||
|
||||
def test_get_share_link(self):
|
||||
self.assertEqual(
|
||||
self.eco_account.get_share_link(),
|
||||
reverse(
|
||||
"compensation:acc:share-token",
|
||||
args=(self.eco_account.id, self.eco_account.access_token)
|
||||
)
|
||||
)
|
||||
|
||||
def test_get_deductable_rest_relative(self):
|
||||
self.assertEqual(self.eco_account.deductions.count(), 0)
|
||||
self.eco_account.deductable_surface = 5.0
|
||||
self.eco_account.save()
|
||||
self.eco_account.update_deductable_rest()
|
||||
|
||||
self.assertEqual(self.eco_account.get_deductable_rest_relative(), 100)
|
||||
self.eco_account.deductable_surface = None
|
||||
self.eco_account.save()
|
||||
self.assertEqual(self.eco_account.get_deductable_rest_relative(), 0)
|
||||
|
||||
|
||||
class EcoAccountDocumentTestCase(BaseTestCase):
|
||||
def setUp(self) -> None:
|
||||
super().setUp()
|
||||
|
||||
def test_delete(self):
|
||||
doc = self.create_dummy_document(
|
||||
EcoAccountDocument,
|
||||
self.eco_account
|
||||
)
|
||||
doc_title = doc.title
|
||||
docs = self.eco_account.get_documents()
|
||||
self.assertIn(doc, docs)
|
||||
|
||||
doc.delete(user=self.superuser)
|
||||
last_log = self.eco_account.log.first()
|
||||
self.assertEqual(last_log.user, self.superuser)
|
||||
self.assertEqual(last_log.action, UserAction.EDITED)
|
||||
self.assertEqual(last_log.comment, DOCUMENT_REMOVED_TEMPLATE.format(
|
||||
doc_title
|
||||
))
|
||||
try:
|
||||
doc.refresh_from_db()
|
||||
self.fail("Document should not have been fetchable")
|
||||
except ObjectDoesNotExist:
|
||||
pass
|
||||
|
||||
|
||||
class EcoAccountDeductionTestCase(BaseTestCase):
|
||||
def setUp(self) -> None:
|
||||
super().setUp()
|
||||
|
||||
def test_str(self):
|
||||
self.assertEqual(str(self.deduction), f"{self.deduction.surface} of {self.deduction.account}")
|
||||
|
||||
def test_delete(self):
|
||||
self.deduction.account = self.eco_account
|
||||
self.deduction.intervention = self.intervention
|
||||
self.deduction.save()
|
||||
|
||||
self.eco_account.update_deductable_rest()
|
||||
old_deductable_rest = self.eco_account.deductable_rest
|
||||
deduction_surface = self.deduction.surface
|
||||
|
||||
self.deduction.delete(self.superuser)
|
||||
|
||||
last_log_intervention = self.intervention.log.first()
|
||||
last_log_account = self.eco_account.log.first()
|
||||
logs = [
|
||||
last_log_intervention,
|
||||
last_log_account,
|
||||
]
|
||||
for log in logs:
|
||||
self.assertEqual(log.action, UserAction.EDITED)
|
||||
self.assertEqual(log.user, self.superuser)
|
||||
self.assertEqual(log.comment, DEDUCTION_REMOVED)
|
||||
|
||||
self.assertLess(old_deductable_rest, self.eco_account.deductable_rest)
|
||||
self.assertEqual(old_deductable_rest + deduction_surface, self.eco_account.deductable_rest)
|
||||
try:
|
||||
self.deduction.refresh_from_db()
|
||||
self.fail("Deduction still fetchable after deleting")
|
||||
except ObjectDoesNotExist:
|
||||
pass
|
@ -0,0 +1,7 @@
|
||||
"""
|
||||
Author: Michel Peltriaux
|
||||
Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
|
||||
Contact: ksp-servicestelle@sgdnord.rlp.de
|
||||
Created on: 24.08.23
|
||||
|
||||
"""
|
@ -0,0 +1,141 @@
|
||||
"""
|
||||
Author: Michel Peltriaux
|
||||
Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
|
||||
Contact: ksp-servicestelle@sgdnord.rlp.de
|
||||
Created on: 01.09.23
|
||||
|
||||
"""
|
||||
import json
|
||||
|
||||
from django.urls import reverse
|
||||
from django.utils.translation import gettext_lazy as _
|
||||
|
||||
from ema.forms import NewEmaForm, EditEmaForm
|
||||
from konova.forms import SimpleGeomForm
|
||||
from konova.tests.test_views import BaseTestCase
|
||||
from konova.utils.generators import generate_random_string
|
||||
from user.models import UserAction
|
||||
|
||||
|
||||
class NewEmaFormTestCase(BaseTestCase):
|
||||
|
||||
def setUp(self) -> None:
|
||||
super().setUp()
|
||||
|
||||
def test_init(self):
|
||||
form = NewEmaForm()
|
||||
self.assertEqual(form.form_title, str(_("New EMA")))
|
||||
self.assertEqual(form.action_url, reverse("ema:new"))
|
||||
self.assertEqual(form.cancel_redirect, reverse("ema:index"))
|
||||
self.assertIsNotNone(form.fields["identifier"].initial)
|
||||
self.assertEqual(form.fields["title"].widget.attrs["placeholder"], str(_("Compensation XY; Location ABC")))
|
||||
|
||||
def test_save(self):
|
||||
cons_office_code = self.get_conservation_office_code()
|
||||
data = {
|
||||
"identifier": generate_random_string(length=20, use_numbers=True),
|
||||
"title": generate_random_string(length=20, use_letters_lc=True),
|
||||
"conservation_office": cons_office_code,
|
||||
"conservation_file_number": generate_random_string(length=10, use_numbers=True),
|
||||
"is_pik": True,
|
||||
"comment": generate_random_string(length=20, use_numbers=True, use_letters_uc=True),
|
||||
}
|
||||
form = NewEmaForm(data)
|
||||
|
||||
test_geom = self.create_dummy_geometry()
|
||||
geom_form_data = self.create_geojson(
|
||||
test_geom
|
||||
)
|
||||
geom_form_data = json.loads(geom_form_data)
|
||||
geom_form_data = {
|
||||
"geom": json.dumps(geom_form_data)
|
||||
}
|
||||
|
||||
geom_form = SimpleGeomForm(geom_form_data)
|
||||
self.assertTrue(form.is_valid(), msg=form.errors)
|
||||
self.assertTrue(geom_form.is_valid(), msg=form.errors)
|
||||
|
||||
obj = form.save(user=self.superuser, geom_form=geom_form)
|
||||
self.assertEqual(obj.title, data["title"])
|
||||
self.assertEqual(obj.is_pik, data["is_pik"])
|
||||
self.assertIsNotNone(obj.responsible)
|
||||
self.assertIsNotNone(obj.responsible.handler)
|
||||
self.assertEqual(obj.responsible.conservation_office, data["conservation_office"])
|
||||
self.assertEqual(obj.responsible.conservation_file_number, data["conservation_file_number"])
|
||||
self.assertEqual(obj.identifier, data["identifier"])
|
||||
self.assertEqual(obj.comment, data["comment"])
|
||||
|
||||
self.assertIn(self.superuser, obj.shared_users)
|
||||
|
||||
last_log = obj.log.first()
|
||||
self.assertEqual(obj.created, obj.modified)
|
||||
self.assertEqual(obj.created, last_log)
|
||||
self.assertEqual(last_log.action, UserAction.CREATED)
|
||||
self.assertEqual(last_log.user, self.superuser)
|
||||
self.assertTrue(test_geom.equals_exact(obj.geometry.geom, 0.000001))
|
||||
|
||||
|
||||
class EditEmaFormTestCase(BaseTestCase):
|
||||
def test_init(self):
|
||||
form = EditEmaForm(instance=self.ema)
|
||||
self.assertEqual(form.form_title, str(_("Edit EMA")))
|
||||
self.assertEqual(form.action_url, reverse("ema:edit", args=(self.ema.id,)))
|
||||
self.assertEqual(form.cancel_redirect, reverse("ema:detail", args=(self.ema.id,)))
|
||||
self.assertEqual(form.fields["identifier"].widget.attrs["url"], reverse("ema:new-id"))
|
||||
self.assertEqual(form.fields["title"].widget.attrs["placeholder"], str(_("Compensation XY; Location ABC")))
|
||||
|
||||
values = {
|
||||
"identifier": self.ema.identifier,
|
||||
"title": self.ema.title,
|
||||
"comment": self.ema.comment,
|
||||
"conservation_office": self.ema.responsible.conservation_office,
|
||||
"conservation_file_number": self.ema.responsible.conservation_file_number,
|
||||
"is_pik": self.ema.is_pik,
|
||||
"handler_type": self.ema.responsible.handler.type,
|
||||
"handler_detail": self.ema.responsible.handler.detail,
|
||||
}
|
||||
for k, v in values.items():
|
||||
self.assertEqual(form.fields[k].initial, v)
|
||||
|
||||
def test_save(self):
|
||||
cons_office_code = self.get_conservation_office_code()
|
||||
data = {
|
||||
"identifier": generate_random_string(length=20, use_numbers=True),
|
||||
"title": generate_random_string(length=20, use_letters_lc=True),
|
||||
"conservation_office": cons_office_code,
|
||||
"conservation_file_number": generate_random_string(length=10, use_numbers=True),
|
||||
"is_pik": not self.ema.is_pik,
|
||||
"comment": generate_random_string(length=20, use_numbers=True, use_letters_uc=True),
|
||||
}
|
||||
form = EditEmaForm(data, instance=self.ema)
|
||||
self.assertTrue(form.is_valid(), msg=form.errors)
|
||||
|
||||
test_geom = self.create_dummy_geometry()
|
||||
geom_form_data = self.create_geojson(
|
||||
test_geom
|
||||
)
|
||||
geom_form_data = json.loads(geom_form_data)
|
||||
geom_form_data = {
|
||||
"geom": json.dumps(geom_form_data)
|
||||
}
|
||||
|
||||
geom_form = SimpleGeomForm(geom_form_data)
|
||||
self.assertTrue(geom_form.is_valid())
|
||||
|
||||
obj = form.save(self.superuser, geom_form)
|
||||
self.assertEqual(obj.id, self.ema.id)
|
||||
self.assertEqual(obj.title, data["title"])
|
||||
self.assertEqual(obj.is_pik, data["is_pik"])
|
||||
self.assertIsNotNone(obj.responsible)
|
||||
self.assertIsNotNone(obj.responsible.handler)
|
||||
self.assertEqual(obj.responsible.conservation_office, data["conservation_office"])
|
||||
self.assertEqual(obj.responsible.conservation_file_number, data["conservation_file_number"])
|
||||
self.assertEqual(obj.identifier, data["identifier"])
|
||||
self.assertEqual(obj.comment, data["comment"])
|
||||
|
||||
last_log = obj.log.first()
|
||||
self.assertEqual(obj.modified, last_log)
|
||||
self.assertEqual(last_log.action, UserAction.EDITED)
|
||||
self.assertEqual(last_log.user, self.superuser)
|
||||
self.assertTrue(test_geom.equals_exact(obj.geometry.geom, 0.000001))
|
||||
|
@ -0,0 +1,90 @@
|
||||
"""
|
||||
Author: Michel Peltriaux
|
||||
Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
|
||||
Contact: ksp-servicestelle@sgdnord.rlp.de
|
||||
Created on: 24.08.23
|
||||
|
||||
"""
|
||||
from django.urls import reverse
|
||||
from django.utils.timezone import now
|
||||
|
||||
from ema.models import Ema, EmaDocument
|
||||
from ema.settings import EMA_IDENTIFIER_TEMPLATE
|
||||
from konova.tests.test_views import BaseTestCase
|
||||
from konova.utils.message_templates import DOCUMENT_REMOVED_TEMPLATE
|
||||
from user.models import UserAction
|
||||
|
||||
|
||||
class EmaModelTestCase(BaseTestCase):
|
||||
def setUp(self) -> None:
|
||||
super().setUp()
|
||||
|
||||
def test_str(self):
|
||||
self.assertEqual(str(self.ema), f"{self.ema.identifier}")
|
||||
|
||||
def test_save(self):
|
||||
new_ema = Ema(
|
||||
title="Test"
|
||||
)
|
||||
self.assertIsNone(new_ema.identifier)
|
||||
|
||||
new_ema.save()
|
||||
new_ema.refresh_from_db()
|
||||
|
||||
self.assertIsNotNone(new_ema.identifier)
|
||||
self.assertIn("EMA-", new_ema.identifier)
|
||||
|
||||
def test_is_ready_for_publish(self):
|
||||
self.assertIsNone(self.ema.recorded)
|
||||
self.assertFalse(self.ema.is_ready_for_publish())
|
||||
|
||||
self.ema.set_recorded(self.superuser)
|
||||
self.ema.refresh_from_db()
|
||||
self.assertIsNotNone(self.ema.recorded)
|
||||
self.assertTrue(self.ema.is_ready_for_publish())
|
||||
|
||||
def test_get_share_link(self):
|
||||
self.assertEqual(
|
||||
self.ema.get_share_link(),
|
||||
reverse("ema:share-token", args=(self.ema.id, self.ema.access_token))
|
||||
)
|
||||
|
||||
def test_get_documents(self):
|
||||
self.assertEqual(self.ema.get_documents().count(), 0)
|
||||
|
||||
doc = EmaDocument(
|
||||
instance=self.ema,
|
||||
date_of_creation=now().date(),
|
||||
comment="Test",
|
||||
)
|
||||
doc.save()
|
||||
docs = self.ema.get_documents()
|
||||
self.assertEqual(docs.count(), 1)
|
||||
self.assertEqual(docs.first(), doc)
|
||||
|
||||
|
||||
class EmaDocumentModelTestCase(BaseTestCase):
|
||||
def setUp(self) -> None:
|
||||
super().setUp()
|
||||
|
||||
def test_delete(self):
|
||||
doc = EmaDocument.objects.create(
|
||||
date_of_creation=now().date(),
|
||||
instance=self.ema,
|
||||
comment="TEST"
|
||||
)
|
||||
self.ema.refresh_from_db()
|
||||
docs = self.ema.get_documents()
|
||||
self.assertEqual(docs.count(), 1)
|
||||
self.assertEqual(docs.first(), doc)
|
||||
|
||||
doc_title = doc.title
|
||||
doc.delete(user=self.superuser)
|
||||
last_log = self.ema.log.first()
|
||||
self.assertEqual(last_log.action, UserAction.EDITED)
|
||||
self.assertEqual(last_log.user, self.superuser)
|
||||
self.assertEqual(last_log.comment, DOCUMENT_REMOVED_TEMPLATE.format(doc_title))
|
||||
|
||||
docs = self.ema.get_documents()
|
||||
self.assertEqual(docs.count(), 0)
|
||||
|
@ -0,0 +1,7 @@
|
||||
"""
|
||||
Author: Michel Peltriaux
|
||||
Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
|
||||
Contact: ksp-servicestelle@sgdnord.rlp.de
|
||||
Created on: 24.08.23
|
||||
|
||||
"""
|
@ -0,0 +1,333 @@
|
||||
"""
|
||||
Author: Michel Peltriaux
|
||||
Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
|
||||
Contact: ksp-servicestelle@sgdnord.rlp.de
|
||||
Created on: 24.08.23
|
||||
|
||||
"""
|
||||
import json
|
||||
from datetime import timedelta
|
||||
|
||||
from django.core.exceptions import ObjectDoesNotExist
|
||||
from django.urls import reverse
|
||||
from django.utils.timezone import now
|
||||
from django.utils.translation import gettext_lazy as _
|
||||
from django.test import RequestFactory
|
||||
|
||||
from intervention.forms.intervention import NewInterventionForm, EditInterventionForm
|
||||
from intervention.forms.modals.revocation import NewRevocationModalForm, EditRevocationModalForm, \
|
||||
RemoveRevocationModalForm
|
||||
from intervention.forms.modals.share import ShareModalForm
|
||||
from intervention.models import Revocation
|
||||
from konova.forms import SimpleGeomForm
|
||||
from konova.settings import DEFAULT_GROUP, ZB_GROUP
|
||||
from konova.tests.test_views import BaseTestCase
|
||||
from konova.utils.generators import generate_random_string
|
||||
from konova.utils.message_templates import REVOCATION_ADDED, REVOCATION_EDITED, REVOCATION_REMOVED
|
||||
from user.models import UserAction
|
||||
|
||||
|
||||
class NewInterventionFormTestCase(BaseTestCase):
|
||||
def setUp(self) -> None:
|
||||
super().setUp()
|
||||
|
||||
def test_init(self):
|
||||
form = NewInterventionForm()
|
||||
self.assertEqual(form.form_title, str(_("New intervention")))
|
||||
self.assertEqual(form.action_url, reverse("intervention:new"))
|
||||
self.assertEqual(form.cancel_redirect, reverse("intervention:index"))
|
||||
|
||||
initial_identifier = form.fields["identifier"].initial
|
||||
self.assertIsNotNone(initial_identifier)
|
||||
self.assertIn("EIV-", initial_identifier)
|
||||
|
||||
def test_is_valid(self):
|
||||
data = {
|
||||
"identifier": generate_random_string(length=15, use_letters_uc=True),
|
||||
"title": generate_random_string(length=15, use_letters_uc=True),
|
||||
}
|
||||
form = NewInterventionForm({})
|
||||
self.assertFalse(form.is_valid())
|
||||
form = NewInterventionForm(data)
|
||||
self.assertTrue(form.is_valid(), msg=form.errors)
|
||||
|
||||
def test_save(self):
|
||||
data = {
|
||||
"identifier": generate_random_string(length=15, use_letters_uc=True),
|
||||
"title": generate_random_string(length=15, use_letters_uc=True),
|
||||
}
|
||||
test_geom = self.create_dummy_geometry()
|
||||
geom_form_data = self.create_geojson(
|
||||
test_geom
|
||||
)
|
||||
geom_form_data = json.loads(geom_form_data)
|
||||
geom_form_data = {
|
||||
"geom": json.dumps(geom_form_data)
|
||||
}
|
||||
geom_form = SimpleGeomForm(geom_form_data)
|
||||
|
||||
form = NewInterventionForm(data)
|
||||
self.assertTrue(form.is_valid())
|
||||
self.assertTrue(geom_form.is_valid())
|
||||
obj = form.save(self.superuser, geom_form)
|
||||
|
||||
self.assertEqual(obj.identifier, data["identifier"])
|
||||
self.assertEqual(obj.title, data["title"])
|
||||
self.assertIsNotNone(obj.legal)
|
||||
self.assertIsNotNone(obj.responsible)
|
||||
self.assertIsNotNone(obj.responsible.handler)
|
||||
self.assertEqual(obj.created.action, UserAction.CREATED)
|
||||
self.assertEqual(obj.created.user, self.superuser)
|
||||
self.assertEqual(obj.created, obj.log.first())
|
||||
self.assertEqual(obj.created, obj.modified)
|
||||
|
||||
self.assertIn(self.superuser, obj.shared_users)
|
||||
self.assertTrue(test_geom.equals_exact(obj.geometry.geom, 0.000001))
|
||||
|
||||
|
||||
class EditInterventionFormTestCase(NewInterventionFormTestCase):
|
||||
|
||||
def test_init(self):
|
||||
today = now().date()
|
||||
data = {
|
||||
"identifier": self.intervention.identifier,
|
||||
"title": generate_random_string(length=5, use_letters_lc=True),
|
||||
"comment": generate_random_string(length=5, use_letters_lc=True),
|
||||
"registration_date": today,
|
||||
"binding_date": today,
|
||||
"registration_file_number": generate_random_string(length=5, use_numbers=True),
|
||||
"conservation_file_number": generate_random_string(length=5, use_numbers=True),
|
||||
}
|
||||
test_geom = self.create_dummy_geometry()
|
||||
geom_form_data = self.create_geojson(
|
||||
test_geom
|
||||
)
|
||||
geom_form_data = json.loads(geom_form_data)
|
||||
geom_form_data = {
|
||||
"geom": json.dumps(geom_form_data)
|
||||
}
|
||||
|
||||
geom_form = SimpleGeomForm(geom_form_data)
|
||||
form = EditInterventionForm(data, instance=self.intervention)
|
||||
self.assertTrue(geom_form.is_valid())
|
||||
self.assertTrue(form.is_valid())
|
||||
|
||||
obj = form.save(self.superuser, geom_form)
|
||||
|
||||
last_log = obj.log.first()
|
||||
self.assertEqual(last_log.user, self.superuser)
|
||||
self.assertEqual(last_log.action, UserAction.EDITED)
|
||||
self.assertEqual(last_log, obj.modified)
|
||||
self.assertEqual(obj.identifier, self.intervention.identifier)
|
||||
self.assertIsNotNone(obj.legal)
|
||||
self.assertIsNotNone(obj.responsible)
|
||||
self.assertIsNotNone(obj.responsible.handler)
|
||||
self.assertEqual(obj.title, data["title"])
|
||||
self.assertEqual(obj.comment, data["comment"])
|
||||
self.assertTrue(test_geom.equals_exact(obj.geometry.geom, 0.000001))
|
||||
|
||||
self.assertEqual(obj.legal.binding_date, today)
|
||||
self.assertEqual(obj.legal.registration_date, today)
|
||||
self.assertEqual(obj.responsible.registration_file_number, data["registration_file_number"])
|
||||
self.assertEqual(obj.responsible.conservation_file_number, data["conservation_file_number"])
|
||||
|
||||
|
||||
class ShareModalFormTestCase(BaseTestCase):
|
||||
def setUp(self) -> None:
|
||||
super().setUp()
|
||||
self.request = RequestFactory().request()
|
||||
self.request.user = self.superuser
|
||||
|
||||
def test_init(self):
|
||||
self.intervention.access_token = None
|
||||
self.intervention.save()
|
||||
|
||||
form = ShareModalForm(
|
||||
request=self.request,
|
||||
instance=self.intervention
|
||||
)
|
||||
self.assertIsNotNone(self.intervention.access_token)
|
||||
self.assertEqual(form.form_title, str(_("Share")))
|
||||
self.assertEqual(form.form_caption, str(_("Share settings for {}").format(
|
||||
self.intervention.identifier
|
||||
)))
|
||||
self.assertEqual(form.template, "modal/modal_form.html")
|
||||
self.assertEqual(form.instance, self.intervention)
|
||||
self.assertEqual(form.user, self.superuser)
|
||||
|
||||
def test_is_valid_and_save(self):
|
||||
# make user default-group-only (special treatment)
|
||||
self.superuser.groups.set(
|
||||
self.groups.filter(
|
||||
name=DEFAULT_GROUP
|
||||
)
|
||||
)
|
||||
|
||||
self.assertNotIn(self.superuser, self.intervention.shared_users)
|
||||
self.assertNotIn(self.team, self.intervention.shared_teams)
|
||||
|
||||
# Add new sharing data
|
||||
## Default-only is able to add new sharing but can not remove existing ones
|
||||
data = {
|
||||
"users": [self.superuser.id,],
|
||||
"teams": [self.team.id,],
|
||||
}
|
||||
form = ShareModalForm(
|
||||
data,
|
||||
request=self.request,
|
||||
instance=self.intervention,
|
||||
)
|
||||
self.assertTrue(form.is_valid(), msg=form.errors)
|
||||
form.save()
|
||||
self.assertIn(self.superuser, self.intervention.shared_users)
|
||||
self.assertIn(self.team, self.intervention.shared_teams)
|
||||
|
||||
# Try to remove sharing data das default-only user
|
||||
data = {
|
||||
"users": [],
|
||||
"teams": [],
|
||||
}
|
||||
form = ShareModalForm(
|
||||
data,
|
||||
request=self.request,
|
||||
instance=self.intervention,
|
||||
)
|
||||
self.assertFalse(form.is_valid(), msg=form.errors)
|
||||
self.assertTrue(form.has_error("teams"))
|
||||
self.assertTrue(form.has_error("users"))
|
||||
|
||||
# Add another permission group for user
|
||||
self.superuser.groups.add(
|
||||
self.groups.get(
|
||||
name=ZB_GROUP
|
||||
)
|
||||
)
|
||||
form = ShareModalForm(
|
||||
data,
|
||||
request=self.request,
|
||||
instance=self.intervention,
|
||||
)
|
||||
self.assertTrue(form.is_valid(), msg=form.errors)
|
||||
self.assertIn(self.superuser, self.intervention.shared_users)
|
||||
self.assertIn(self.team, self.intervention.shared_teams)
|
||||
|
||||
form.save()
|
||||
|
||||
self.assertNotIn(self.superuser, self.intervention.shared_users)
|
||||
self.assertNotIn(self.team, self.intervention.shared_teams)
|
||||
|
||||
|
||||
class NewRevocationModalFormTestCase(BaseTestCase):
|
||||
def setUp(self) -> None:
|
||||
super().setUp()
|
||||
self.request = RequestFactory().request()
|
||||
self.request.user = self.superuser
|
||||
|
||||
def test_init(self):
|
||||
form = NewRevocationModalForm(
|
||||
request=self.request,
|
||||
instance=self.intervention
|
||||
)
|
||||
self.assertEqual(form.instance, self.intervention)
|
||||
self.assertEqual(form.user, self.request.user)
|
||||
self.assertEqual(form.request, self.request)
|
||||
self.assertEqual(form.form_title, str(_("Add revocation")))
|
||||
self.assertEqual(form.form_caption, "")
|
||||
self.assertEqual(form.form_attrs, {
|
||||
"enctype": "multipart/form-data"
|
||||
})
|
||||
|
||||
def test_save(self):
|
||||
data = {
|
||||
"date": now().date(),
|
||||
"file": None,
|
||||
"comment": generate_random_string(20, use_letters_uc=True)
|
||||
}
|
||||
form = NewRevocationModalForm(
|
||||
data,
|
||||
request=self.request,
|
||||
instance=self.intervention
|
||||
)
|
||||
self.assertTrue(form.is_valid(), msg=form.errors)
|
||||
obj = form.save()
|
||||
self.assertEqual(obj.intervention, self.intervention)
|
||||
self.assertEqual(obj.date, data["date"])
|
||||
self.assertEqual(obj.legal, self.intervention.legal)
|
||||
self.assertEqual(obj.comment, data["comment"])
|
||||
|
||||
last_log = self.intervention.log.first()
|
||||
self.assertEqual(last_log.user, self.superuser)
|
||||
self.assertEqual(last_log.action, UserAction.EDITED)
|
||||
self.assertEqual(last_log.comment, REVOCATION_ADDED)
|
||||
|
||||
|
||||
class EditRevocationModalFormTestCase(NewRevocationModalFormTestCase):
|
||||
def setUp(self) -> None:
|
||||
super().setUp()
|
||||
self.revoc = Revocation.objects.get_or_create(
|
||||
date=now().date(),
|
||||
comment="TEST",
|
||||
legal=self.intervention.legal,
|
||||
)[0]
|
||||
|
||||
def test_init(self):
|
||||
new_date = now().date() - timedelta(days=10)
|
||||
data = {
|
||||
"date": new_date,
|
||||
"comment": generate_random_string(20, use_letters_lc=True)
|
||||
}
|
||||
form = EditRevocationModalForm(
|
||||
data,
|
||||
request=self.request,
|
||||
instance=self.intervention,
|
||||
revocation=self.revoc
|
||||
)
|
||||
self.assertTrue(form.is_valid(), msg=form.errors)
|
||||
obj = form.save()
|
||||
self.assertEqual(obj.date, new_date)
|
||||
self.assertEqual(obj.comment, data["comment"])
|
||||
self.assertEqual(obj.legal, self.intervention.legal)
|
||||
self.assertEqual(obj.intervention, self.intervention)
|
||||
|
||||
last_log = self.intervention.log.first()
|
||||
self.assertEqual(last_log.action, UserAction.EDITED)
|
||||
self.assertEqual(last_log.user, self.superuser)
|
||||
self.assertEqual(last_log.comment, REVOCATION_EDITED)
|
||||
|
||||
class RemoveRevocationModalFormTestCase(EditRevocationModalFormTestCase):
|
||||
def setUp(self) -> None:
|
||||
super().setUp()
|
||||
|
||||
def test_init(self):
|
||||
form = RemoveRevocationModalForm(
|
||||
request=self.request,
|
||||
instance=self.intervention,
|
||||
revocation=self.revoc,
|
||||
)
|
||||
self.assertEqual(form.instance, self.intervention)
|
||||
self.assertEqual(form.revocation, self.revoc)
|
||||
self.assertEqual(form.request, self.request)
|
||||
self.assertEqual(form.user, self.request.user)
|
||||
|
||||
def test_save(self):
|
||||
data = {
|
||||
"confirm": True,
|
||||
}
|
||||
form = RemoveRevocationModalForm(
|
||||
data,
|
||||
request=self.request,
|
||||
instance=self.intervention,
|
||||
revocation=self.revoc
|
||||
)
|
||||
self.assertTrue(form.is_valid(), msg=form.errors)
|
||||
form.save()
|
||||
|
||||
try:
|
||||
self.revoc.refresh_from_db()
|
||||
self.fail("Revocation should not exist anymore")
|
||||
except ObjectDoesNotExist:
|
||||
pass
|
||||
last_log = self.intervention.log.first()
|
||||
self.assertEqual(last_log.action, UserAction.EDITED)
|
||||
self.assertEqual(last_log.user, self.superuser)
|
||||
self.assertEqual(last_log.comment, REVOCATION_REMOVED)
|
@ -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)
|
@ -0,0 +1,7 @@
|
||||
"""
|
||||
Author: Michel Peltriaux
|
||||
Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
|
||||
Contact: ksp-servicestelle@sgdnord.rlp.de
|
||||
Created on: 29.08.23
|
||||
|
||||
"""
|
@ -0,0 +1,118 @@
|
||||
"""
|
||||
Author: Michel Peltriaux
|
||||
Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
|
||||
Contact: ksp-servicestelle@sgdnord.rlp.de
|
||||
Created on: 29.08.23
|
||||
|
||||
"""
|
||||
from django.test import RequestFactory
|
||||
from django.utils.timezone import now
|
||||
from django.utils.translation import gettext_lazy as _
|
||||
|
||||
from compensation.forms.modals.deadline import NewDeadlineModalForm, EditDeadlineModalForm
|
||||
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 DEADLINE_ADDED, DEADLINE_EDITED
|
||||
from user.models import UserAction
|
||||
|
||||
|
||||
class NewDeadlineModalFormTestCase(BaseTestCase):
|
||||
def setUp(self) -> None:
|
||||
super().setUp()
|
||||
self.request = RequestFactory().request()
|
||||
self.request.user = self.superuser
|
||||
self.today = now().date()
|
||||
|
||||
def test_init(self):
|
||||
form = NewDeadlineModalForm(request=self.request, instance=self.compensation)
|
||||
self.assertEqual(form.form_title, str(_("New deadline")))
|
||||
self.assertEqual(form.form_caption, str(_("Insert data for the new deadline")))
|
||||
self.assertEqual(form.user, self.superuser)
|
||||
self.assertEqual(form.request, self.request)
|
||||
|
||||
def test_is_valid(self):
|
||||
data = {
|
||||
"type": DeadlineType.MAINTAIN,
|
||||
"date": self.today,
|
||||
"comment": "",
|
||||
}
|
||||
form = NewDeadlineModalForm(
|
||||
data,
|
||||
request=self.request,
|
||||
instance=self.compensation
|
||||
)
|
||||
self.assertTrue(form.is_valid())
|
||||
|
||||
data["type"] = DeadlineType.OTHER
|
||||
form = NewDeadlineModalForm(
|
||||
data,
|
||||
request=self.request,
|
||||
instance=self.compensation
|
||||
)
|
||||
self.assertFalse(form.is_valid(), msg=form.errors)
|
||||
self.assertTrue(form.has_error("comment"))
|
||||
_error = form.errors["comment"]
|
||||
self.assertEqual(len(_error), 1)
|
||||
self.assertEqual(_error[0], str(_("Please explain this 'other' type of deadline.")))
|
||||
|
||||
data["comment"] = "Test"
|
||||
data["type"] = DeadlineType.OTHER
|
||||
form = NewDeadlineModalForm(
|
||||
data,
|
||||
request=self.request,
|
||||
instance=self.compensation
|
||||
)
|
||||
self.assertTrue(form.is_valid())
|
||||
|
||||
def test_save(self):
|
||||
data = {
|
||||
"type": DeadlineType.MAINTAIN,
|
||||
"date": self.today,
|
||||
"comment": generate_random_string(length=20, use_letters_lc=True),
|
||||
}
|
||||
form = NewDeadlineModalForm(
|
||||
data,
|
||||
request=self.request,
|
||||
instance=self.compensation
|
||||
)
|
||||
self.assertTrue(form.is_valid(), msg=form.errors)
|
||||
deadline = form.save()
|
||||
self.assertEqual(deadline.type, data["type"])
|
||||
self.assertEqual(deadline.date, data["date"])
|
||||
self.assertEqual(deadline.comment, data["comment"])
|
||||
self.assertIn(deadline, self.compensation.deadlines.all())
|
||||
|
||||
last_log = self.compensation.log.first()
|
||||
self.assertEqual(last_log.user, self.superuser)
|
||||
self.assertEqual(last_log.action, UserAction.EDITED)
|
||||
self.assertEqual(last_log.comment, DEADLINE_ADDED)
|
||||
|
||||
|
||||
class EditDeadlineModalFormTestCase(NewDeadlineModalFormTestCase):
|
||||
def setUp(self) -> None:
|
||||
super().setUp()
|
||||
|
||||
def test_save(self):
|
||||
data = {
|
||||
"type": DeadlineType.MAINTAIN,
|
||||
"date": self.today,
|
||||
"comment": generate_random_string(length=20, use_letters_lc=True),
|
||||
}
|
||||
form = EditDeadlineModalForm(
|
||||
data,
|
||||
request=self.request,
|
||||
instance=self.compensation,
|
||||
deadline=self.finished_deadline,
|
||||
)
|
||||
|
||||
self.assertTrue(form.is_valid(), msg=form.errors)
|
||||
deadline = form.save()
|
||||
self.assertEqual(deadline.type, data["type"])
|
||||
self.assertEqual(deadline.date, data["date"])
|
||||
self.assertEqual(deadline.comment, data["comment"])
|
||||
|
||||
last_log = self.compensation.log.first()
|
||||
self.assertEqual(last_log.action, UserAction.EDITED)
|
||||
self.assertEqual(last_log.user, self.superuser)
|
||||
self.assertEqual(last_log.comment, DEADLINE_EDITED)
|
@ -0,0 +1,365 @@
|
||||
"""
|
||||
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 datetime import timedelta
|
||||
|
||||
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, ResubmissionModalForm
|
||||
from konova.models import Resubmission
|
||||
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)
|
||||
|
||||
|
||||
class ResubmissionModalFormTestCase(BaseTestCase):
|
||||
def setUp(self) -> None:
|
||||
super().setUp()
|
||||
self.request = RequestFactory().request()
|
||||
self.request.user = self.user
|
||||
|
||||
def test_init(self):
|
||||
# Resubmission nonexistent
|
||||
form = ResubmissionModalForm(request=self.request, instance=self.intervention)
|
||||
self.assertEqual(form.form_title, str(_("Resubmission")))
|
||||
self.assertEqual(form.form_caption, str(_("Set your resubmission for this entry.")))
|
||||
self.assertEqual(form.action_url, None)
|
||||
self.assertIsNotNone(form.resubmission)
|
||||
|
||||
resubmission = Resubmission.objects.create(
|
||||
user=self.request.user,
|
||||
resubmit_on=now().date(),
|
||||
comment=generate_random_string(length=10, use_letters_lc=True)
|
||||
)
|
||||
self.intervention.resubmissions.add(resubmission)
|
||||
|
||||
# Resubmission exists
|
||||
form = ResubmissionModalForm(request=self.request, instance=self.intervention)
|
||||
self.assertEqual(form.form_title, str(_("Resubmission")))
|
||||
self.assertEqual(form.form_caption, str(_("Set your resubmission for this entry.")))
|
||||
self.assertEqual(form.action_url, None)
|
||||
self.assertEqual(form.fields["date"].initial, str(resubmission.resubmit_on))
|
||||
self.assertEqual(form.fields["comment"].initial, resubmission.comment)
|
||||
self.assertEqual(form.resubmission, resubmission)
|
||||
|
||||
def test_is_valid(self):
|
||||
yesterday = now().date() - timedelta(days=1)
|
||||
data = {
|
||||
"date": yesterday,
|
||||
"comment": "Edited comment"
|
||||
}
|
||||
form = ResubmissionModalForm(
|
||||
data,
|
||||
request=self.request,
|
||||
instance=self.intervention
|
||||
)
|
||||
self.assertFalse(form.is_valid(), msg=form.errors)
|
||||
self.assertTrue(form.has_error("date"))
|
||||
|
||||
tomorrow = yesterday + timedelta(days=2)
|
||||
data = {
|
||||
"date": tomorrow,
|
||||
"comment": "Edited comment"
|
||||
}
|
||||
form = ResubmissionModalForm(
|
||||
data,
|
||||
request=self.request,
|
||||
instance=self.intervention
|
||||
)
|
||||
self.assertTrue(form.is_valid(), msg=form.errors)
|
||||
|
||||
def test_save(self):
|
||||
data = {
|
||||
"date": now().date() + timedelta(days=1),
|
||||
"comment": "New comment for new resubmission"
|
||||
}
|
||||
form = ResubmissionModalForm(
|
||||
data,
|
||||
request=self.request,
|
||||
instance=self.intervention
|
||||
)
|
||||
self.assertTrue(form.is_valid(), msg=form.errors)
|
||||
obj = form.save()
|
||||
self.assertIn(obj, self.intervention.resubmissions.all())
|
||||
self.assertEqual(obj.resubmit_on, data["date"])
|
||||
self.assertEqual(obj.comment, data["comment"])
|
||||
self.assertEqual(obj.resubmission_sent, False)
|
||||
self.assertEqual(obj.user, self.request.user)
|
@ -0,0 +1,201 @@
|
||||
"""
|
||||
Author: Michel Peltriaux
|
||||
Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
|
||||
Contact: ksp-servicestelle@sgdnord.rlp.de
|
||||
Created on: 08.09.23
|
||||
|
||||
"""
|
||||
from django.test import RequestFactory
|
||||
from django.utils.timezone import now
|
||||
|
||||
from intervention.forms.modals.share import ShareModalForm
|
||||
from konova.models import DeadlineType, Resubmission
|
||||
from konova.settings import ZB_GROUP
|
||||
from konova.tests.test_views import BaseTestCase
|
||||
from user.models import UserAction
|
||||
|
||||
|
||||
|
||||
class DeadlineTestCase(BaseTestCase):
|
||||
def setUp(self) -> None:
|
||||
super().setUp()
|
||||
|
||||
def test_str(self):
|
||||
self.assertEqual(str(self.finished_deadline), self.finished_deadline.type)
|
||||
|
||||
def test_type_humanized_property(self):
|
||||
self.assertEqual(self.finished_deadline.type_humanized, DeadlineType.FINISHED.label)
|
||||
|
||||
|
||||
class BaseObjectTestCase(BaseTestCase):
|
||||
def test_add_log_entry(self):
|
||||
self.assertEqual(self.intervention.log.count(), 0)
|
||||
self.intervention.add_log_entry(UserAction.EDITED, self.user, "TEST")
|
||||
self.assertEqual(self.intervention.log.count(), 1)
|
||||
last_log = self.intervention.log.first()
|
||||
self.assertEqual(last_log.user, self.user)
|
||||
self.assertEqual(last_log.comment, "TEST")
|
||||
self.assertEqual(last_log.action, UserAction.EDITED)
|
||||
|
||||
def test_generate_new_identifier(self):
|
||||
old_identifier = self.intervention.identifier
|
||||
new_identifier = self.intervention.generate_new_identifier()
|
||||
self.assertNotEqual(old_identifier, new_identifier)
|
||||
|
||||
|
||||
class RecordableObjectMixinTestCase(BaseTestCase):
|
||||
def test_set_recorded_and_set_unrecorded(self):
|
||||
""" Tests set_unrecorded() as well
|
||||
|
||||
Returns:
|
||||
|
||||
"""
|
||||
self.intervention.set_recorded(self.user)
|
||||
self.assertIsNotNone(self.intervention.recorded)
|
||||
self.assertEqual(self.intervention.recorded.user, self.user)
|
||||
self.assertEqual(self.intervention.recorded.action, UserAction.RECORDED)
|
||||
|
||||
self.intervention.set_unrecorded(self.user)
|
||||
self.assertIsNone(self.intervention.recorded)
|
||||
last_log = self.intervention.log.first()
|
||||
self.assertEqual(last_log.action, UserAction.UNRECORDED)
|
||||
self.assertEqual(last_log.user, self.user)
|
||||
|
||||
|
||||
class CheckableObjectMixinTestCase(BaseTestCase):
|
||||
def test_set_unchecked_and_set_checked(self):
|
||||
self.intervention.set_checked(self.user)
|
||||
self.assertIsNotNone(self.intervention.checked)
|
||||
self.assertEqual(self.intervention.checked.action, UserAction.CHECKED)
|
||||
self.assertEqual(self.intervention.checked.user, self.user)
|
||||
checked_action = self.intervention.checked
|
||||
|
||||
self.intervention.set_unchecked()
|
||||
self.assertIsNone(self.intervention.checked)
|
||||
|
||||
# There is no explicit UNCHECKED UserAction since unchecking does never happen manually but only as an
|
||||
# automatic consequence of editing an already checked entry. Therefore the last log entry in this case would
|
||||
# be the checking of the entry
|
||||
last_log = self.intervention.log.first()
|
||||
self.assertEqual(last_log.action, UserAction.CHECKED)
|
||||
self.assertEqual(last_log.user, self.user)
|
||||
self.assertEqual(last_log, checked_action)
|
||||
|
||||
def test_get_last_checked_action(self):
|
||||
self.intervention.set_checked(self.user)
|
||||
action = self.intervention.checked
|
||||
|
||||
self.intervention.mark_as_edited(self.user)
|
||||
last_log = self.intervention.log.first()
|
||||
self.assertNotEqual(last_log, action)
|
||||
|
||||
last_check_action = self.intervention.get_last_checked_action()
|
||||
self.assertEqual(action, last_check_action)
|
||||
|
||||
|
||||
class ShareableObjectMixinTestCase(BaseTestCase):
|
||||
def test_share_with_and_is_shared_with(self):
|
||||
self.assertFalse(self.intervention.is_shared_with(self.user))
|
||||
self.assertNotIn(self.user, self.intervention.shared_users)
|
||||
|
||||
self.intervention.share_with_user(self.user)
|
||||
self.assertTrue(self.intervention.is_shared_with(self.user))
|
||||
self.assertIn(self.user, self.intervention.shared_users)
|
||||
|
||||
self.assertTrue(self.intervention.is_only_shared_with(self.user))
|
||||
self.assertFalse(self.intervention.is_only_shared_with(self.superuser))
|
||||
self.assertNotIn(self.superuser, self.intervention.shared_users)
|
||||
self.intervention.share_with_user(self.superuser)
|
||||
self.assertFalse(self.intervention.is_only_shared_with(self.user))
|
||||
self.assertIn(self.superuser, self.intervention.shared_users)
|
||||
|
||||
self.intervention.share_with_user_list([])
|
||||
self.assertNotIn(self.superuser, self.intervention.shared_users)
|
||||
self.assertNotIn(self.user, self.intervention.shared_users)
|
||||
self.intervention.share_with_user_list([
|
||||
self.superuser,
|
||||
self.user
|
||||
])
|
||||
self.assertIn(self.superuser, self.intervention.shared_users)
|
||||
self.assertIn(self.user, self.intervention.shared_users)
|
||||
|
||||
def test_share_with_team_and_team_list(self):
|
||||
self.assertNotIn(self.team, self.intervention.shared_teams)
|
||||
self.intervention.share_with_team(self.team)
|
||||
self.assertIn(self.team, self.intervention.shared_teams)
|
||||
|
||||
another_team = self.create_dummy_team(name="Another team")
|
||||
team_list = [
|
||||
self.team,
|
||||
another_team
|
||||
]
|
||||
self.assertNotIn(another_team, self.intervention.shared_teams)
|
||||
self.intervention.share_with_team_list(team_list)
|
||||
self.assertIn(another_team, self.intervention.shared_teams)
|
||||
|
||||
def test_update_shared_access(self):
|
||||
another_team = self.create_dummy_team(name="Another team")
|
||||
request = RequestFactory().request()
|
||||
request.user = self.superuser
|
||||
self.superuser.groups.add(
|
||||
self.groups.get(name=ZB_GROUP)
|
||||
)
|
||||
|
||||
self.intervention.share_with_team(another_team)
|
||||
self.intervention.share_with_user(self.user)
|
||||
self.assertTrue(self.intervention.is_shared_with(self.user))
|
||||
self.assertIn(another_team, self.intervention.shared_teams)
|
||||
|
||||
data = {
|
||||
"users": [
|
||||
self.superuser.id,
|
||||
],
|
||||
"teams": [
|
||||
self.team.id,
|
||||
]
|
||||
}
|
||||
form = ShareModalForm(data, request=request, instance=self.intervention)
|
||||
self.assertTrue(form.is_valid(), msg=form.errors)
|
||||
form.save()
|
||||
self.assertNotIn(self.user, self.intervention.shared_users)
|
||||
self.assertNotIn(another_team, self.intervention.shared_teams)
|
||||
self.assertIn(self.superuser, self.intervention.shared_users)
|
||||
self.assertIn(self.team, self.intervention.shared_teams)
|
||||
|
||||
def test_unshare_with_default_users(self):
|
||||
self.superuser.groups.add(
|
||||
self.groups.get(
|
||||
name=ZB_GROUP
|
||||
)
|
||||
)
|
||||
self.intervention.share_with_user(self.user)
|
||||
self.intervention.share_with_user(self.superuser)
|
||||
|
||||
self.assertTrue(self.user.is_default_group_only())
|
||||
self.assertFalse(self.superuser.is_default_group_only())
|
||||
|
||||
self.assertTrue(self.intervention.is_shared_with(self.user))
|
||||
self.assertTrue(self.intervention.is_shared_with(self.superuser))
|
||||
|
||||
self.intervention.unshare_with_default_users()
|
||||
self.assertFalse(self.intervention.is_shared_with(self.user))
|
||||
self.assertTrue(self.intervention.is_shared_with(self.superuser))
|
||||
|
||||
|
||||
class ResubmissionTestCase(BaseTestCase):
|
||||
def test_send_resubmission_mail(self):
|
||||
resubmission = Resubmission.objects.create(
|
||||
user=self.user,
|
||||
resubmit_on=now().date(),
|
||||
comment="Test",
|
||||
)
|
||||
self.intervention.resubmissions.add(resubmission)
|
||||
|
||||
self.assertFalse(resubmission.resubmission_sent)
|
||||
resubmission.send_resubmission_mail(
|
||||
self.intervention.identifier,
|
||||
[
|
||||
"Test_municipal_1"
|
||||
],
|
||||
)
|
||||
self.assertTrue(resubmission.resubmission_sent)
|
@ -1,37 +0,0 @@
|
||||
"""
|
||||
Author: Michel Peltriaux
|
||||
Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
|
||||
Contact: michel.peltriaux@sgdnord.rlp.de
|
||||
Created on: 02.07.21
|
||||
|
||||
"""
|
||||
from user.models import User
|
||||
|
||||
from konova.settings import ETS_GROUP, ZB_GROUP
|
||||
|
||||
|
||||
def in_group(user: User, group: str) -> bool:
|
||||
""" Checks if the user is part of a group
|
||||
|
||||
Args:
|
||||
user (User): The user object
|
||||
group (str): The group's name
|
||||
|
||||
Returns:
|
||||
bool
|
||||
"""
|
||||
return user.groups.filter(
|
||||
name=group
|
||||
)
|
||||
|
||||
|
||||
def is_default_group_only(user: User) -> bool:
|
||||
""" Checks if the user is only part of the default group
|
||||
|
||||
Args:
|
||||
user (User): The user object
|
||||
|
||||
Returns:
|
||||
bool
|
||||
"""
|
||||
return not in_group(user, ZB_GROUP) and not in_group(user, ETS_GROUP)
|
Binary file not shown.
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,7 @@
|
||||
"""
|
||||
Author: Michel Peltriaux
|
||||
Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
|
||||
Contact: ksp-servicestelle@sgdnord.rlp.de
|
||||
Created on: 12.09.23
|
||||
|
||||
"""
|
@ -0,0 +1,286 @@
|
||||
"""
|
||||
Author: Michel Peltriaux
|
||||
Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
|
||||
Contact: ksp-servicestelle@sgdnord.rlp.de
|
||||
Created on: 12.09.23
|
||||
|
||||
"""
|
||||
from django.core.exceptions import ObjectDoesNotExist
|
||||
from django.test import RequestFactory
|
||||
from django.urls import reverse
|
||||
from django.utils.translation import gettext_lazy as _
|
||||
|
||||
from api.models import APIUserToken
|
||||
from konova.tests.test_views import BaseTestCase
|
||||
from user.forms.modals.team import NewTeamModalForm, EditTeamModalForm, RemoveTeamModalForm, LeaveTeamModalForm
|
||||
from user.forms.user import UserNotificationForm, UserAPITokenForm
|
||||
from user.models import Team, UserAction, UserNotification
|
||||
|
||||
|
||||
class NewTeamModalFormTestCase(BaseTestCase):
|
||||
|
||||
def setUp(self) -> None:
|
||||
super().setUp()
|
||||
self.request = RequestFactory().request()
|
||||
self.request.user = self.user
|
||||
|
||||
def test_init(self):
|
||||
form = NewTeamModalForm(
|
||||
request=self.request
|
||||
)
|
||||
self.assertEqual(form.form_title, str(_("Create new team")))
|
||||
self.assertEqual(form.form_caption, str(_("You will become the administrator for this group by default. You do not need to add yourself to the list of members.")))
|
||||
self.assertEqual(form.action_url, reverse("user:team-new"))
|
||||
self.assertEqual(form.cancel_redirect, reverse("user:team-index"))
|
||||
self.assertEqual(form.request, self.request)
|
||||
self.assertEqual(form.user, self.request.user)
|
||||
|
||||
def test_is_valid(self):
|
||||
invalid_data = {
|
||||
"name": self.team.name,
|
||||
"description": "Test description",
|
||||
"members": [self.superuser.id,],
|
||||
}
|
||||
form = NewTeamModalForm(
|
||||
invalid_data,
|
||||
request=self.request
|
||||
)
|
||||
self.assertFalse(form.is_valid())
|
||||
self.assertTrue(form.has_error("name"))
|
||||
|
||||
valid_data = invalid_data
|
||||
valid_data["name"] = self.team.name + "_OTHER"
|
||||
|
||||
form = NewTeamModalForm(
|
||||
invalid_data,
|
||||
request=self.request
|
||||
)
|
||||
self.assertTrue(form.is_valid())
|
||||
|
||||
def test_save(self):
|
||||
valid_data = {
|
||||
"name": self.team.name + "_OTHER",
|
||||
"description": "Test description",
|
||||
"members": [self.superuser.id,],
|
||||
}
|
||||
form = NewTeamModalForm(
|
||||
valid_data,
|
||||
request=self.request
|
||||
)
|
||||
self.assertTrue(form.is_valid())
|
||||
obj = form.save()
|
||||
self.assertEqual(obj.name, valid_data["name"])
|
||||
self.assertEqual(obj.description, valid_data["description"])
|
||||
users = obj.users.all()
|
||||
admins = obj.admins.all()
|
||||
self.assertIn(self.request.user, users)
|
||||
self.assertIn(self.request.user, admins)
|
||||
self.assertIn(self.superuser, users)
|
||||
self.assertNotIn(self.superuser, admins)
|
||||
|
||||
|
||||
class EditTeamModalFormTestCase(NewTeamModalFormTestCase):
|
||||
|
||||
def test_init(self):
|
||||
self.team.admins.add(self.superuser)
|
||||
|
||||
form = EditTeamModalForm(request=self.request, instance=self.team)
|
||||
self.assertEqual(form.form_title, str(_("Edit team")))
|
||||
self.assertEqual(form.action_url, reverse("user:team-edit", args=(self.team.id,)))
|
||||
self.assertEqual(form.cancel_redirect, reverse("user:team-index"))
|
||||
|
||||
self.assertEqual(form.fields["name"].initial, self.team.name)
|
||||
self.assertEqual(form.fields["description"].initial, self.team.description)
|
||||
self.assertEqual(form.fields["members"].initial.count(), 1)
|
||||
self.assertIn(self.superuser, form.fields["members"].initial)
|
||||
self.assertEqual(form.fields["admins"].initial.count(), 1)
|
||||
self.assertIn(self.superuser, form.fields["admins"].initial)
|
||||
|
||||
def test_is_valid(self):
|
||||
data = {
|
||||
"name": self.team.name,
|
||||
"description": self.team.description,
|
||||
"members": self.team.users.values_list("id", flat=True),
|
||||
"admins": self.team.admins.values_list("id", flat=True),
|
||||
}
|
||||
form = EditTeamModalForm(
|
||||
data,
|
||||
request=self.request,
|
||||
instance=self.team
|
||||
)
|
||||
|
||||
# Error 1: Admin not in user list
|
||||
self.team.users.set([self.superuser])
|
||||
self.team.admins.set([self.user])
|
||||
self.assertFalse(form.is_valid())
|
||||
self.assertTrue(form.has_error("admins"))
|
||||
|
||||
# Error 2: Admin list empty
|
||||
self.team.admins.set([])
|
||||
self.assertFalse(form.is_valid())
|
||||
self.assertTrue(form.has_error("admins"))
|
||||
|
||||
# Error 3: Name taken
|
||||
other_team = Team.objects.create(
|
||||
name=self.team.name
|
||||
)
|
||||
self.team.admins.set([self.superuser])
|
||||
self.assertFalse(form.is_valid())
|
||||
self.assertTrue(form.has_error("name"))
|
||||
|
||||
def test_save(self):
|
||||
data = {
|
||||
"name": self.team.name + "_EDITED",
|
||||
"description": self.team.description + "_EDITED",
|
||||
"members": [self.user.id, self.superuser.id,],
|
||||
"admins": [self.user.id,],
|
||||
}
|
||||
form = EditTeamModalForm(
|
||||
data,
|
||||
request=self.request,
|
||||
instance=self.team
|
||||
)
|
||||
self.assertTrue(form.is_valid(), msg=form.errors)
|
||||
obj = form.save()
|
||||
self.assertEqual(obj.name, data["name"])
|
||||
self.assertEqual(obj.description, data["description"])
|
||||
self.assertIn(self.user, obj.users.all())
|
||||
self.assertIn(self.superuser, obj.users.all())
|
||||
self.assertIn(self.user, obj.admins.all())
|
||||
self.assertEqual(obj.admins.count(), 1)
|
||||
self.assertEqual(obj.users.count(), 2)
|
||||
|
||||
|
||||
class RemoveTeamModalFormTestCase(BaseTestCase):
|
||||
def setUp(self) -> None:
|
||||
super().setUp()
|
||||
self.request = RequestFactory().request()
|
||||
self.request.user = self.user
|
||||
|
||||
def test_init(self):
|
||||
form = RemoveTeamModalForm(
|
||||
request=self.request,
|
||||
instance=self.team
|
||||
)
|
||||
self.assertEqual(form.form_caption, str(_("ATTENTION!\n\nRemoving the team means all members will lose their access to data, based on this team! \n\nAre you sure to remove this team?")))
|
||||
self.assertEqual(form.user, self.request.user)
|
||||
self.assertEqual(form.request, self.request)
|
||||
|
||||
def test_save(self):
|
||||
data = {
|
||||
"confirm": True
|
||||
}
|
||||
form = RemoveTeamModalForm(
|
||||
data,
|
||||
request=self.request,
|
||||
instance=self.team
|
||||
)
|
||||
self.assertTrue(form.is_valid(), msg=form.errors)
|
||||
form.save()
|
||||
self.team.refresh_from_db()
|
||||
|
||||
self.assertIsNotNone(self.team.deleted)
|
||||
self.assertEqual(self.team.deleted.user, self.request.user)
|
||||
self.assertEqual(self.team.deleted.action, UserAction.DELETED)
|
||||
|
||||
|
||||
class LeaveTeamModalFormTestCase(BaseTestCase):
|
||||
def setUp(self) -> None:
|
||||
super().setUp()
|
||||
self.request = RequestFactory().request()
|
||||
self.request.user = self.user
|
||||
|
||||
def test_init(self):
|
||||
form = LeaveTeamModalForm(
|
||||
request=self.request,
|
||||
instance=self.team
|
||||
)
|
||||
self.assertEqual(form.form_title, str(_("Leave team")))
|
||||
|
||||
def test_save(self):
|
||||
self.team.users.add(self.user)
|
||||
data = {
|
||||
"confirm": True,
|
||||
}
|
||||
form = LeaveTeamModalForm(
|
||||
data,
|
||||
request=self.request,
|
||||
instance=self.team
|
||||
)
|
||||
self.assertTrue(form.is_valid(), msg=form.errors)
|
||||
self.assertIn(self.request.user, self.team.users.all())
|
||||
form.save()
|
||||
self.assertNotIn(self.request.user, self.team.users.all())
|
||||
|
||||
|
||||
class UserNotificationFormTestCase(BaseTestCase):
|
||||
def setUp(self) -> None:
|
||||
super().setUp()
|
||||
|
||||
if not UserNotification.objects.all().exists():
|
||||
self.notifications = UserNotification.objects.bulk_create(
|
||||
[
|
||||
UserNotification(id="notification_1", name="notification_1", is_active=True),
|
||||
UserNotification(id="notification_2", name="notification_2", is_active=True),
|
||||
UserNotification(id="notification_3", name="notification_3", is_active=True),
|
||||
UserNotification(id="notification_4", name="notification_4", is_active=True),
|
||||
]
|
||||
)
|
||||
|
||||
def test_init(self):
|
||||
form = UserNotificationForm(
|
||||
user=self.user
|
||||
)
|
||||
self.assertEqual(form.form_title, str(_("Edit notifications")))
|
||||
self.assertEqual(form.form_caption, "")
|
||||
self.assertEqual(form.action_url, reverse("user:notifications"))
|
||||
self.assertEqual(form.cancel_redirect, reverse("user:index"))
|
||||
|
||||
def test_save(self):
|
||||
selected_notification = UserNotification.objects.first()
|
||||
data = {
|
||||
"notifications": [selected_notification.id,]
|
||||
}
|
||||
form = UserNotificationForm(
|
||||
data=data,
|
||||
user=self.user
|
||||
)
|
||||
self.assertTrue(form.is_valid(), msg=form.errors)
|
||||
self.assertEqual(self.user.notifications.count(), 0)
|
||||
form.save()
|
||||
self.assertEqual(self.user.notifications.count(), 1)
|
||||
self.assertIn(selected_notification, self.user.notifications.all())
|
||||
|
||||
|
||||
class UserAPITokenFormTestCase(BaseTestCase):
|
||||
def test_init(self):
|
||||
form = UserAPITokenForm(
|
||||
instance=self.user
|
||||
)
|
||||
self.assertEqual(form.form_title, str(_("Create new token")))
|
||||
self.assertEqual(form.form_caption, str(_("A new token needs to be validated by an administrator!")))
|
||||
self.assertEqual(form.action_url, reverse("user:api-token"))
|
||||
self.assertEqual(form.cancel_redirect, reverse("user:index"))
|
||||
|
||||
self.assertIsNone(form.fields["token"].initial)
|
||||
self.assertTrue(form.fields["token"].widget.attrs["readonly"])
|
||||
|
||||
def test_save(self):
|
||||
data = {
|
||||
"token": APIUserToken().token
|
||||
}
|
||||
form = UserAPITokenForm(
|
||||
data,
|
||||
instance=self.user
|
||||
)
|
||||
self.assertTrue(form.is_valid(), msg=form.errors)
|
||||
self.assertIsNone(self.user.api_token)
|
||||
token = form.save()
|
||||
self.assertEqual(self.user.api_token, token)
|
||||
new_token = form.save()
|
||||
self.assertEqual(self.user.api_token, new_token)
|
||||
try:
|
||||
token.refresh_from_db()
|
||||
self.fail("Token should be deleted and not be fetchable anymore")
|
||||
except ObjectDoesNotExist:
|
||||
pass
|
@ -0,0 +1,61 @@
|
||||
"""
|
||||
Author: Michel Peltriaux
|
||||
Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
|
||||
Contact: ksp-servicestelle@sgdnord.rlp.de
|
||||
Created on: 13.09.23
|
||||
|
||||
"""
|
||||
from konova.settings import ZB_GROUP, DEFAULT_GROUP, ETS_GROUP
|
||||
from konova.tests.test_views import BaseTestCase
|
||||
from user.enums import UserNotificationEnum
|
||||
from user.models import UserNotification
|
||||
|
||||
|
||||
class UserTestCase(BaseTestCase):
|
||||
def test_is_notification_setting_set(self):
|
||||
notification = UserNotification.objects.create(
|
||||
id=UserNotificationEnum.NOTIFY_ON_DEDUCTION_CHANGES.name,
|
||||
name=UserNotificationEnum.NOTIFY_ON_DEDUCTION_CHANGES.value,
|
||||
)
|
||||
self.assertFalse(self.user.is_notification_setting_set(UserNotificationEnum.NOTIFY_ON_DEDUCTION_CHANGES))
|
||||
self.user.notifications.add(notification)
|
||||
self.assertTrue(self.user.is_notification_setting_set(UserNotificationEnum.NOTIFY_ON_DEDUCTION_CHANGES))
|
||||
|
||||
def test_is_group_member(self):
|
||||
zb_group = self.groups.get(name=ZB_GROUP)
|
||||
ets_group = self.groups.get(name=ETS_GROUP)
|
||||
default_group = self.groups.get(name=DEFAULT_GROUP)
|
||||
|
||||
self.user.groups.set([])
|
||||
self.assertFalse(self.user.is_zb_user())
|
||||
self.assertFalse(self.user.is_ets_user())
|
||||
self.assertFalse(self.user.is_default_user())
|
||||
|
||||
self.user.groups.add(zb_group)
|
||||
self.assertTrue(self.user.is_zb_user())
|
||||
|
||||
self.user.groups.add(ets_group)
|
||||
self.assertTrue(self.user.is_ets_user())
|
||||
|
||||
self.user.groups.add(default_group)
|
||||
self.assertTrue(self.user.is_default_user())
|
||||
|
||||
def test_get_API_token(self):
|
||||
self.assertIsNone(self.user.api_token)
|
||||
token = self.user.get_API_token()
|
||||
self.assertIsNotNone(self.user.api_token)
|
||||
self.assertEqual(self.user.api_token, token)
|
||||
|
||||
# Make sure the same token is returned if command is called twice
|
||||
token = self.user.get_API_token()
|
||||
self.assertEqual(self.user.api_token, token)
|
||||
|
||||
def test_shared_teams_property(self):
|
||||
shared_teams = self.user.shared_teams
|
||||
self.assertEqual(shared_teams.count(), 0)
|
||||
|
||||
self.team.users.add(self.user)
|
||||
shared_teams = self.user.shared_teams
|
||||
self.assertEqual(shared_teams.count(), 1)
|
||||
self.assertIn(self.team, shared_teams)
|
||||
|
Loading…
Reference in New Issue