diff options
Diffstat (limited to 'archaeological_operations/tests.py')
| -rw-r--r-- | archaeological_operations/tests.py | 3004 |
1 files changed, 1743 insertions, 1261 deletions
diff --git a/archaeological_operations/tests.py b/archaeological_operations/tests.py index 1e85b4f5a..3f4e73639 100644 --- a/archaeological_operations/tests.py +++ b/archaeological_operations/tests.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python +#!/usr/bin/env python3 # -*- coding: utf-8 -*- # Copyright (C) 2012-2017 Étienne Loks <etienne.loks_AT_peacefrogsDOTnet> @@ -42,55 +42,102 @@ from ishtar_common.views import document_deletion_steps from ishtar_common.serializers import document_serialization from archaeological_operations import views, serializers -from ishtar_common.models import OrganizationType, Organization, ItemKey, \ - ImporterType, IshtarUser, TargetKey, ImporterModel, IshtarSiteProfile, \ - Town, ImporterColumn, Person, Author, SourceType, AuthorType, \ - DocumentTemplate, PersonType, TargetKeyGroup, JsonDataField, \ - JsonDataSection, ImportTarget, FormaterType, CustomForm, ExcludedField, \ - UserProfile, ProfileType, Area, CustomFormJsonField, get_current_profile, \ - Document, ValueFormater, Regexp +from ishtar_common.models import ( + OrganizationType, + Organization, + ItemKey, + ImporterType, + IshtarUser, + TargetKey, + ImporterModel, + IshtarSiteProfile, + Town, + ImporterColumn, + Person, + Author, + SourceType, + AuthorType, + DocumentTemplate, + PersonType, + TargetKeyGroup, + JsonDataField, + JsonDataSection, + ImportTarget, + FormaterType, + CustomForm, + ExcludedField, + UserProfile, + ProfileType, + Area, + CustomFormJsonField, + get_current_profile, + Document, + ValueFormater, + Regexp, +) from archaeological_files.models import File, FileType from archaeological_context_records.models import Unit, ContextRecord from ishtar_common import forms_common -from ishtar_common.tests import WizardTest, WizardTestFormData as FormData, \ - create_superuser, create_user, TestCase, OPERATION_FIXTURES, \ - AutocompleteTestBase, AcItem, OPERATION_TOWNS_FIXTURES, FILE_FIXTURES, \ - COMMON_FIXTURES, GenericSerializationTest, WAREHOUSE_FIXTURES, SearchText +from ishtar_common.tests import ( + WizardTest, + WizardTestFormData as FormData, + create_superuser, + create_user, + TestCase, + OPERATION_FIXTURES, + AutocompleteTestBase, + AcItem, + OPERATION_TOWNS_FIXTURES, + FILE_FIXTURES, + COMMON_FIXTURES, + GenericSerializationTest, + WAREHOUSE_FIXTURES, + SearchText, +) from ishtar_common.serializers import restore_serialized class FileInit(object): def login_as_superuser(self): - self.client.login(username='username', password='tralala') + self.client.login(username="username", password="tralala") def create_file(self): self.extra_models, self.model_list = {}, [] - self.user, created = User.objects.get_or_create(username='username', - is_superuser=True) - self.user.set_password('tralala') + self.user, created = User.objects.get_or_create( + username="username", is_superuser=True + ) + self.user.set_password("tralala") self.user.save() - self.o_user, created = User.objects.get_or_create(username='ousername') + self.o_user, created = User.objects.get_or_create(username="ousername") person_type, created = PersonType.objects.get_or_create( - label='Test person type', txt_idx='test_person', - available=True) - self.extra_models['person_type'] = person_type + label="Test person type", txt_idx="test_person", available=True + ) + self.extra_models["person_type"] = person_type self.model_list.append(person_type) - person = models.Person(surname='Surname', name='Name', - history_modifier=self.o_user) + person = models.Person( + surname="Surname", name="Name", history_modifier=self.o_user + ) person.save() - self.extra_models['person'] = person + self.extra_models["person"] = person self.model_list.append(person) file_type, created = FileType.objects.get_or_create( - label='Test file type', txt_idx='test_file', available=True) - self.extra_models['file_type'] = file_type + label="Test file type", txt_idx="test_file", available=True + ) + self.extra_models["file_type"] = file_type self.model_list.append(file_type) - dct = {'year': 2010, 'numeric_reference': 1000, 'file_type': file_type, - 'internal_reference': 'UNIT_testÉ ?', 'in_charge': person, - 'history_modifier': self.o_user, 'total_surface': 10000} + dct = { + "year": 2010, + "numeric_reference": 1000, + "file_type": file_type, + "internal_reference": "UNIT_testÉ ?", + "in_charge": person, + "history_modifier": self.o_user, + "total_surface": 10000, + } self.item = File(**dct) self.item.save() @@ -101,29 +148,36 @@ class ImportTest(object): self.ishtar_user = IshtarUser.objects.get(pk=self.user.pk) def set_target_key(self, target, key, value, imp=None): - keys = {'target__target': target, 'key': key} + keys = {"target__target": target, "key": key} if imp: - keys['associated_import'] = imp + keys["associated_import"] = imp tg = TargetKey.objects.get(**keys) tg.value = value tg.is_set = True tg.save() - def init_ope_import(self, filename='MCC-operations-example.csv', - sep=","): + def init_ope_import(self, filename="MCC-operations-example.csv", sep=","): mcc_operation = ImporterType.objects.get(name="MCC - Opérations") mcc_operation_file = open( - settings.ROOT_PATH + - '../archaeological_operations/tests/' + filename, - 'rb') - file_dict = {'imported_file': SimpleUploadedFile( - mcc_operation_file.name, mcc_operation_file.read())} + settings.ROOT_PATH + "../archaeological_operations/tests/" + filename, "rb" + ) + file_dict = { + "imported_file": SimpleUploadedFile( + mcc_operation_file.name, mcc_operation_file.read() + ) + } group, c = TargetKeyGroup.objects.get_or_create(name="My group") - post_dict = {'importer_type': mcc_operation.pk, 'skip_lines': 1, - "encoding": 'utf-8', "name": 'init_ope_import', - "associated_group": group.pk, "csv_sep": sep} - form = forms_common.NewImportForm(data=post_dict, files=file_dict, - user=self.user) + post_dict = { + "importer_type": mcc_operation.pk, + "skip_lines": 1, + "encoding": "utf-8", + "name": "init_ope_import", + "associated_group": group.pk, + "csv_sep": sep, + } + form = forms_common.NewImportForm( + data=post_dict, files=file_dict, user=self.user + ) form.is_valid() return mcc_operation, form @@ -136,20 +190,22 @@ class ImportTest(object): ik.delete() # target for this import - target = TargetKey.objects.filter( - target__target='operation_type').order_by('-pk').all()[0] - target.value = models.OperationType.objects.get( - txt_idx='prog_excavation').pk + target = ( + TargetKey.objects.filter(target__target="operation_type") + .order_by("-pk") + .all()[0] + ) + target.value = models.OperationType.objects.get(txt_idx="prog_excavation").pk target.is_set = True target.associated_import = imp target.save() # target for all users - tgs = list(TargetKey.objects.filter(key='gallo-romain').all()) + tgs = list(TargetKey.objects.filter(key="gallo-romain").all()) for tg in tgs[1:]: tg.delete() target2 = tgs[0] - gallo = models.Period.objects.get(txt_idx='gallo-roman') + gallo = models.Period.objects.get(txt_idx="gallo-roman") target2.value = gallo.pk target2.is_set = True target2.associated_import = None @@ -158,11 +214,11 @@ class ImportTest(object): target2.save() # target for this user - tgs = list(TargetKey.objects.filter(key='age-du-fer').all()) + tgs = list(TargetKey.objects.filter(key="age-du-fer").all()) for tg in tgs[1:]: tg.delete() target3 = tgs[0] - iron = models.Period.objects.get(txt_idx='iron-age') + iron = models.Period.objects.get(txt_idx="iron-age") target3.value = iron.pk target3.is_set = True target3.associated_import = None @@ -173,11 +229,11 @@ class ImportTest(object): # target for another user username, password, user = create_user() another_user = IshtarUser.objects.get(pk=user.pk) - tgs = list(TargetKey.objects.filter(key='neolithik').all()) + tgs = list(TargetKey.objects.filter(key="neolithik").all()) for tg in tgs[1:]: tg.delete() target4 = tgs[0] - neo = models.Period.objects.get(txt_idx='neolithic') + neo = models.Period.objects.get(txt_idx="neolithic") target4.value = neo.pk target4.is_set = True target4.associated_import = None @@ -186,11 +242,11 @@ class ImportTest(object): target4.save() # target for the current group - tgs = list(TargetKey.objects.filter(key='moderne').all()) + tgs = list(TargetKey.objects.filter(key="moderne").all()) for tg in tgs[1:]: tg.delete() target5 = tgs[0] - modern = models.Period.objects.get(txt_idx='modern') + modern = models.Period.objects.get(txt_idx="modern") target5.value = modern.pk target5.is_set = True target5.associated_import = None @@ -211,16 +267,23 @@ class ImportTest(object): self.init_ope() mcc_parcel = ImporterType.objects.get(name="MCC - Parcelles") mcc_file = open( - settings.ROOT_PATH + - '../archaeological_operations/tests/MCC-parcelles-example.csv', - 'rb') - file_dict = {'imported_file': SimpleUploadedFile(mcc_file.name, - mcc_file.read())} - post_dict = {'importer_type': mcc_parcel.pk, 'skip_lines': 1, - "encoding": 'utf-8', "name": 'init_parcel_import', - "csv_sep": ","} - form = forms_common.NewImportForm(data=post_dict, files=file_dict, - user=self.user) + settings.ROOT_PATH + + "../archaeological_operations/tests/MCC-parcelles-example.csv", + "rb", + ) + file_dict = { + "imported_file": SimpleUploadedFile(mcc_file.name, mcc_file.read()) + } + post_dict = { + "importer_type": mcc_parcel.pk, + "skip_lines": 1, + "encoding": "utf-8", + "name": "init_parcel_import", + "csv_sep": ",", + } + form = forms_common.NewImportForm( + data=post_dict, files=file_dict, user=self.user + ) form.is_valid() return mcc_parcel, form @@ -234,25 +297,32 @@ class ImportTest(object): self.init_parcel() mcc = ImporterType.objects.get(name="MCC - UE") mcc_file = open( - settings.ROOT_PATH + - '../archaeological_context_records/tests/' - 'MCC-context-records-example.csv', 'rb') - file_dict = {'imported_file': SimpleUploadedFile(mcc_file.name, - mcc_file.read())} - post_dict = {'importer_type': mcc.pk, 'skip_lines': 1, - "encoding": 'utf-8', "name": 'init_context_record_import', - 'csv_sep': ","} - form = forms_common.NewImportForm(data=post_dict, files=file_dict, - user=self.user) + settings.ROOT_PATH + "../archaeological_context_records/tests/" + "MCC-context-records-example.csv", + "rb", + ) + file_dict = { + "imported_file": SimpleUploadedFile(mcc_file.name, mcc_file.read()) + } + post_dict = { + "importer_type": mcc.pk, + "skip_lines": 1, + "encoding": "utf-8", + "name": "init_context_record_import", + "csv_sep": ",", + } + form = forms_common.NewImportForm( + data=post_dict, files=file_dict, user=self.user + ) form.is_valid() return mcc, form def init_cr_targetkey(self, imp): - hc = Unit.objects.get(txt_idx='not_in_context').pk - self.set_target_key('unit', 'hc', hc, imp=imp) - self.set_target_key('unit', 'hors-contexte', hc, imp=imp) - layer = Unit.objects.get(txt_idx='negative').pk - self.set_target_key('unit', 'couche', layer, imp=imp) + hc = Unit.objects.get(txt_idx="not_in_context").pk + self.set_target_key("unit", "hc", hc, imp=imp) + self.set_target_key("unit", "hors-contexte", hc, imp=imp) + layer = Unit.objects.get(txt_idx="negative").pk + self.set_target_key("unit", "couche", layer, imp=imp) def init_context_record(self): mcc, form = self.init_context_record_import() @@ -294,31 +364,31 @@ class ImportOperationTest(ImportTest, TestCase): current_person_nb = Person.objects.count() self.assertEqual(current_person_nb, first_person_nb + 1) # and well imported - last_ope = models.Operation.objects.order_by('-pk').all()[0] + last_ope = models.Operation.objects.order_by("-pk").all()[0] self.assertEqual(last_ope.name, "Oppìdum de Paris") - self.assertEqual(last_ope.code_patriarche, '4200') - self.assertEqual(last_ope.operation_type.txt_idx, 'prog_excavation') + self.assertEqual(last_ope.code_patriarche, "4200") + self.assertEqual(last_ope.operation_type.txt_idx, "prog_excavation") self.assertEqual(last_ope.periods.count(), 3) periods = [period.txt_idx for period in last_ope.periods.all()] - self.assertIn('iron-age', periods) - self.assertIn('gallo-roman', periods) + self.assertIn("iron-age", periods) + self.assertIn("gallo-roman", periods) # target key set for another user - self.assertNotIn('neolithic', periods) + self.assertNotIn("neolithic", periods) # a second importation will be not possible: no two same patriarche # code impt.importation() - self.assertEqual(last_ope, - models.Operation.objects.order_by('-pk').all()[0]) + self.assertEqual(last_ope, models.Operation.objects.order_by("-pk").all()[0]) def test_import_bad_encoding(self): - self.init_ope_import('MCC-operations-example-bad-encoding.csv') + self.init_ope_import("MCC-operations-example-bad-encoding.csv") def test_import_semi_colon_sep(self): first_ope_nb = models.Operation.objects.count() importer, form = self.init_ope_import( - 'MCC-operations-example-semi-colon.csv', sep=";") + "MCC-operations-example-semi-colon.csv", sep=";" + ) self.assertTrue(form.is_valid()) impt = form.save(self.ishtar_user) impt.initialize() @@ -331,18 +401,22 @@ class ImportOperationTest(ImportTest, TestCase): def test_import_multi_column_concat(self): first_ope_nb = models.Operation.objects.count() importer, form = self.init_ope_import( - 'MCC-operations-example-multi-col-periods.csv') - col = ImporterColumn.objects.create(col_number=12, - importer_type_id=importer.pk) + "MCC-operations-example-multi-col-periods.csv" + ) + col = ImporterColumn.objects.create(col_number=12, importer_type_id=importer.pk) period_imp = ImporterColumn.objects.get( - col_number=9, - importer_type_id=importer.pk) + col_number=9, importer_type_id=importer.pk + ) period_target = period_imp.targets.all()[0] target = ImportTarget.objects.create( - column=col, target=period_target.target, - formater_type=period_target.formater_type, concat=True) + column=col, + target=period_target.target, + formater_type=period_target.formater_type, + concat=True, + ) importer, form = self.init_ope_import( - 'MCC-operations-example-multi-col-periods.csv') + "MCC-operations-example-multi-col-periods.csv" + ) self.assertTrue(form.is_valid()) impt = form.save(self.ishtar_user) @@ -352,7 +426,7 @@ class ImportOperationTest(ImportTest, TestCase): current_ope_nb = models.Operation.objects.count() self.assertEqual(current_ope_nb, first_ope_nb + 2) - modern = models.Period.objects.get(txt_idx='modern') + modern = models.Period.objects.get(txt_idx="modern") for ope in models.Operation.objects.order_by("-pk")[0:2]: self.assertIn(modern, list(ope.periods.all())) target.delete() @@ -361,8 +435,7 @@ class ImportOperationTest(ImportTest, TestCase): def test_import_value_format(self): importer, form = self.init_ope_import() column = importer.columns.get(col_number=1) - f = ValueFormater.objects.create(name="-", slug="-", - format_string="oa-{}") + f = ValueFormater.objects.create(name="-", slug="-", format_string="oa-{}") column.value_format = f column.save() @@ -372,11 +445,11 @@ class ImportOperationTest(ImportTest, TestCase): self.init_ope_targetkey(imp=impt) impt.importation() self.assertEqual( - models.Operation.objects.filter(code_patriarche='oa-4201').count(), - 1) + models.Operation.objects.filter(code_patriarche="oa-4201").count(), 1 + ) self.assertEqual( - models.Operation.objects.filter(code_patriarche='oa-4200').count(), - 1) + models.Operation.objects.filter(code_patriarche="oa-4200").count(), 1 + ) f.delete() def test_keys_limitation(self): @@ -428,13 +501,10 @@ class ImportOperationTest(ImportTest, TestCase): self.init_ope_targetkey(imp=impt) impt.importation() self.assertEqual(len(impt.errors), 2) + self.assertTrue("cody" in impt.errors[0]["error"]) self.assertTrue( - "cody" in impt.errors[0]['error'] - ) - self.assertTrue( - "Importer configuration error" in impt.errors[0]['error'] or - "Erreur de configuration de l\'importeur" in - impt.errors[0]['error'] + "Importer configuration error" in impt.errors[0]["error"] + or "Erreur de configuration de l'importeur" in impt.errors[0]["error"] ) def test_model_limitation(self): @@ -450,15 +520,15 @@ class ImportOperationTest(ImportTest, TestCase): current_ope_nb = models.Operation.objects.count() self.assertEqual(current_ope_nb, init_ope_number + 2) - for ope in models.Operation.objects.order_by('-pk').all()[:2]: + for ope in models.Operation.objects.order_by("-pk").all()[:2]: ope.delete() importer, form = self.init_ope_import() # add an inadequate model to make created_models non empty importer.created_models.clear() - importer.created_models.add(ImporterModel.objects.get( - klass='ishtar_common.models.Organization' - )) + importer.created_models.add( + ImporterModel.objects.get(klass="ishtar_common.models.Organization") + ) impt = form.save(self.ishtar_user) impt.initialize() self.init_ope_targetkey(imp=impt) @@ -471,9 +541,11 @@ class ImportOperationTest(ImportTest, TestCase): importer, form = self.init_ope_import() # add operation model to allow creation importer.created_models.clear() - importer.created_models.add(ImporterModel.objects.get( - klass='archaeological_operations.models.Operation' - )) + importer.created_models.add( + ImporterModel.objects.get( + klass="archaeological_operations.models.Operation" + ) + ) impt = form.save(self.ishtar_user) impt.initialize() self.init_ope_targetkey(imp=impt) @@ -489,23 +561,25 @@ class ImportOperationTest(ImportTest, TestCase): mcc_operation = ImporterType.objects.get(name="MCC - Opérations") generated_file = mcc_operation.get_libreoffice_template() zip_file = zipfile.ZipFile(generated_file) - self.assertIsNone(zip_file.testzip(), "Libreoffice template generated " - "is not a correct zip file.") + self.assertIsNone( + zip_file.testzip(), + "Libreoffice template generated " "is not a correct zip file.", + ) filename = None for name in zip_file.namelist(): - if name == 'content.xml': + if name == "content.xml": filename = name break self.assertIsNotNone(filename) # only check that all operation types are listed in the source file - with tempfile.TemporaryDirectory(prefix='tmp-ishtar-') as tmpdir: + with tempfile.TemporaryDirectory(prefix="tmp-ishtar-") as tmpdir: imported_file = zip_file.extract(filename, tmpdir) with open(imported_file) as content_file: content = content_file.read() for ope_type in models.OperationType.objects.all(): - ope_type = str(ope_type).replace("'", ''') + ope_type = str(ope_type).replace("'", "'") self.assertIn(ope_type, content) def test_mcc_import_parcels(self): @@ -519,18 +593,16 @@ class ImportOperationTest(ImportTest, TestCase): self.assertEqual(current_nb, old_nb + 3) # and well imported - last_parcels = models.Parcel.objects.order_by('-pk').all()[0:3] - external_ids = sorted(['4200-59350-YY55', '4200-75101-XXXX', - '4201-59350-YY55']) - parcel_numbers = sorted(['42', '55', '55']) - sections = sorted(['ZX', 'YY', 'YY']) - self.assertEqual(external_ids, - sorted([p.external_id for p in last_parcels])) - self.assertEqual(parcel_numbers, - sorted([p.parcel_number for p in last_parcels])) - self.assertEqual(sections, - sorted([p.section for p in last_parcels])) - ope1 = models.Operation.objects.get(code_patriarche='4200') + last_parcels = models.Parcel.objects.order_by("-pk").all()[0:3] + external_ids = sorted(["4200-59350-YY55", "4200-75101-XXXX", "4201-59350-YY55"]) + parcel_numbers = sorted(["42", "55", "55"]) + sections = sorted(["ZX", "YY", "YY"]) + self.assertEqual(external_ids, sorted([p.external_id for p in last_parcels])) + self.assertEqual( + parcel_numbers, sorted([p.parcel_number for p in last_parcels]) + ) + self.assertEqual(sections, sorted([p.section for p in last_parcels])) + ope1 = models.Operation.objects.get(code_patriarche="4200") towns_ope = ope1.towns.all() imported = [imp for acc, imp in impt.get_all_imported()] for p in last_parcels: @@ -539,13 +611,14 @@ class ImportOperationTest(ImportTest, TestCase): self.assertEqual(len(imported), len(last_parcels)) self.assertEqual( models.Parcel.objects.get( - parcel_number='55', section='YY', - operation_id=ope1.pk).external_id, - '4200-59350-YY55') + parcel_number="55", section="YY", operation_id=ope1.pk + ).external_id, + "4200-59350-YY55", + ) # cached_label update - ope2 = models.Operation.objects.get(code_patriarche='4201') + ope2 = models.Operation.objects.get(code_patriarche="4201") self.assertIsNotNone(ope2.cached_label) - self.assertIn('LILLE', ope2.cached_label.upper()) + self.assertIn("LILLE", ope2.cached_label.upper()) # delete associated parcel with the import deletion parcel_count = models.Parcel.objects.count() impt.delete() @@ -553,105 +626,113 @@ class ImportOperationTest(ImportTest, TestCase): def test_json_fields(self): importer, form = self.init_ope_import("operations-with-json-fields.csv") - col = ImporterColumn.objects.create(importer_type=importer, - col_number=11) - formater_type = FormaterType.objects.get( - formater_type='IntegerFormater') + col = ImporterColumn.objects.create(importer_type=importer, col_number=11) + formater_type = FormaterType.objects.get(formater_type="IntegerFormater") it = ImportTarget.objects.create( - column=col, target='data__autre_refs__arbitraire', - formater_type=formater_type) + column=col, + target="data__autre_refs__arbitraire", + formater_type=formater_type, + ) impt = form.save(self.ishtar_user) impt.initialize() self.init_ope_targetkey(imp=impt) impt.importation() - ope1 = models.Operation.objects.get(code_patriarche='4200') - self.assertEqual(ope1.data, {'autre_refs': {'arbitraire': 789}}) - ope2 = models.Operation.objects.get(code_patriarche='4201') - self.assertEqual(ope2.data, {'autre_refs': {'arbitraire': 456}}) + ope1 = models.Operation.objects.get(code_patriarche="4200") + self.assertEqual(ope1.data, {"autre_refs": {"arbitraire": 789}}) + ope2 = models.Operation.objects.get(code_patriarche="4201") + self.assertEqual(ope2.data, {"autre_refs": {"arbitraire": 456}}) # #4292: Import of new JSON fields erase all precedent JSON fields it.delete() - col2 = ImporterColumn.objects.create(importer_type=importer, - col_number=12) + col2 = ImporterColumn.objects.create(importer_type=importer, col_number=12) ImportTarget.objects.create( - column=col2, target='data__autre', - formater_type=formater_type) + column=col2, target="data__autre", formater_type=formater_type + ) impt = form.save(self.ishtar_user) impt.initialize() self.init_ope_targetkey(imp=impt) impt.importation() - ope1 = models.Operation.objects.get(code_patriarche='4200') - self.assertEqual(ope1.data, {'autre_refs': {'arbitraire': 789}, - "autre": 666}) - ope2 = models.Operation.objects.get(code_patriarche='4201') - self.assertEqual(ope2.data, {'autre_refs': {'arbitraire': 456}, - "autre": 333}) + ope1 = models.Operation.objects.get(code_patriarche="4200") + self.assertEqual(ope1.data, {"autre_refs": {"arbitraire": 789}, "autre": 666}) + ope2 = models.Operation.objects.get(code_patriarche="4201") + self.assertEqual(ope2.data, {"autre_refs": {"arbitraire": 456}, "autre": 333}) def test_regexp(self): importer, form = self.init_ope_import("operations-with-json-fields.csv") r, __ = Regexp.objects.get_or_create( - name="Code INSEE", - regexp='([0-9]{0,1}[0-9A-B]) *([0-9]{3})' + name="Code INSEE", regexp="([0-9]{0,1}[0-9A-B]) *([0-9]{3})" ) col = ImporterColumn.objects.create( - importer_type=importer, col_number=13, regexp_pre_filter=r) + importer_type=importer, col_number=13, regexp_pre_filter=r + ) formater_type = FormaterType.objects.get( - formater_type='UnicodeFormater', options="") + formater_type="UnicodeFormater", options="" + ) ImportTarget.objects.create( - column=col, target='data__code_insee', - formater_type=formater_type) + column=col, target="data__code_insee", formater_type=formater_type + ) impt = form.save(self.ishtar_user) impt.initialize() self.init_ope_targetkey(imp=impt) impt.importation() - ope1 = models.Operation.objects.get(code_patriarche='4200') + ope1 = models.Operation.objects.get(code_patriarche="4200") self.assertEqual(ope1.data, {"code_insee": "45123"}) - ope2 = models.Operation.objects.get(code_patriarche='4201') + ope2 = models.Operation.objects.get(code_patriarche="4201") self.assertEqual(ope2.data, {"code_insee": "6456"}) class ImportDocumentTest(ImportTest, TestCase): fixtures = OPERATION_TOWNS_FIXTURES - def init_doc_import(self, filename='document-example.csv'): + def init_doc_import(self, filename="document-example.csv"): model, __ = ImporterModel.objects.get_or_create( - klass="ishtar_common.models.Document", - defaults={ - "name": "Documentation" - } + klass="ishtar_common.models.Document", defaults={"name": "Documentation"} ) doc_import, __ = ImporterType.objects.get_or_create( - name="Doc import", slug="doc-import", associated_models=model) - - col = ImporterColumn.objects.create(col_number=1, - importer_type_id=doc_import.pk) - formater = FormaterType.objects.filter( - formater_type='IntegerFormater').all()[0] - ImportTarget.objects.create(target='import_get_next_index', - formater_type_id=formater.pk, - column_id=col.pk) - col = ImporterColumn.objects.create(col_number=2, - importer_type_id=doc_import.pk) + name="Doc import", slug="doc-import", associated_models=model + ) + + col = ImporterColumn.objects.create( + col_number=1, importer_type_id=doc_import.pk + ) + formater = FormaterType.objects.filter(formater_type="IntegerFormater").all()[0] + ImportTarget.objects.create( + target="import_get_next_index", + formater_type_id=formater.pk, + column_id=col.pk, + ) + col = ImporterColumn.objects.create( + col_number=2, importer_type_id=doc_import.pk + ) formater, __ = FormaterType.objects.get_or_create( - formater_type='UnicodeFormater', options=None) - ImportTarget.objects.create(target='title', - formater_type_id=formater.pk, - column_id=col.pk) + formater_type="UnicodeFormater", options=None + ) + ImportTarget.objects.create( + target="title", formater_type_id=formater.pk, column_id=col.pk + ) doc_import_file = open( - settings.ROOT_PATH + - '../archaeological_operations/tests/' + filename, - 'rb') + settings.ROOT_PATH + "../archaeological_operations/tests/" + filename, "rb" + ) - file_dict = {'imported_file': SimpleUploadedFile( - doc_import_file.name, doc_import_file.read())} + file_dict = { + "imported_file": SimpleUploadedFile( + doc_import_file.name, doc_import_file.read() + ) + } group, c = TargetKeyGroup.objects.get_or_create(name="My group") - post_dict = {'importer_type': doc_import.pk, 'skip_lines': 1, - "encoding": 'utf-8', "name": 'init_ope_import', - "associated_group": group.pk, "csv_sep": ","} - form = forms_common.NewImportForm(data=post_dict, files=file_dict, - user=self.user) + post_dict = { + "importer_type": doc_import.pk, + "skip_lines": 1, + "encoding": "utf-8", + "name": "init_ope_import", + "associated_group": group.pk, + "csv_sep": ",", + } + form = forms_common.NewImportForm( + data=post_dict, files=file_dict, user=self.user + ) form.is_valid() return doc_import, form @@ -681,8 +762,9 @@ class ImportStepByStepTest(ImportTest, TestCase): first_person_nb = Person.objects.count() first_ope_nb = models.Operation.objects.count() - import_url = reverse('import_step_by_step', - kwargs={'pk': impt.pk, 'line_number': 2}) + import_url = reverse( + "import_step_by_step", kwargs={"pk": impt.pk, "line_number": 2} + ) response = c.get(import_url) # no login redirect self.assertEqual(response.status_code, 302) @@ -692,12 +774,13 @@ class ImportStepByStepTest(ImportTest, TestCase): response = c.get(import_url) self.assertEqual(response.status_code, 200) # verify pagination for next link is OK - self.assertIn('href="/import-step-by-step/{}/3/"'.format(impt.pk), - response.content.decode()) + self.assertIn( + 'href="/import-step-by-step/{}/3/"'.format(impt.pk), + response.content.decode(), + ) # creation have been evaluated self.assertIn( - str(_("New objects will be created.")), - response.content.decode('utf-8') + str(_("New objects will be created.")), response.content.decode("utf-8") ) # import this line @@ -705,8 +788,9 @@ class ImportStepByStepTest(ImportTest, TestCase): response = c.post(import_url, posted) self.assertEqual(response.status_code, 302) # successful import - go to the next line - new_import_url = reverse('import_step_by_step', - kwargs={'pk': impt.pk, 'line_number': 3}) + new_import_url = reverse( + "import_step_by_step", kwargs={"pk": impt.pk, "line_number": 3} + ) self.assertRedirects(response, new_import_url) current_ope_nb = models.Operation.objects.count() self.assertEqual(current_ope_nb, first_ope_nb + 1) @@ -727,12 +811,13 @@ class ImportStepByStepTest(ImportTest, TestCase): self.assertEqual(response.status_code, 200) self.assertIn( str(_("This line have been already imported.")), - response.content.decode('utf-8') + response.content.decode("utf-8"), ) # import next page next_import_url = reverse( - 'import_step_by_step', kwargs={'pk': impt.pk, 'line_number': 3}) + "import_step_by_step", kwargs={"pk": impt.pk, "line_number": 3} + ) posted = {"valid": "import"} c.post(next_import_url, posted) current_ope_nb = models.Operation.objects.count() @@ -761,11 +846,13 @@ class ImportStepByStepTest(ImportTest, TestCase): imported_line = fle.readline() self.assertIn("2000/01/32", imported_line) # error detected on the source file - error = str(_( - "The following error(s) has been encountered while parsing " - "the source file:") + error = str( + _( + "The following error(s) has been encountered while parsing " + "the source file:" + ) ) - self.assertIn(error, response.content.decode('utf-8')) + self.assertIn(error, response.content.decode("utf-8")) class SerializationTest(GenericSerializationTest, TestCase): @@ -773,69 +860,73 @@ class SerializationTest(GenericSerializationTest, TestCase): def setUp(self): self.username, self.password, self.user = create_superuser() - operation = create_operation(self.user, - values={"code_patriarche": "66666"}) + operation = create_operation(self.user, values={"code_patriarche": "66666"}) ope2 = create_operation(self.user, values={"code_patriarche": "66667"}) self.operations = [operation, ope2] models.RecordRelations.objects.create( - left_record=operation, right_record=ope2, - relation_type=models.RelationType.objects.all()[0] - ) - site = models.ArchaeologicalSite.objects.create( - reference="ref-site" + left_record=operation, + right_record=ope2, + relation_type=models.RelationType.objects.all()[0], ) + site = models.ArchaeologicalSite.objects.create(reference="ref-site") operation.archaeological_sites.add(site) operation.top_sites.add(site) - default = {"town": Town.objects.create(numero_insee="66666"), - "section": 'A', 'parcel_number': '1', "operation": operation} + default = { + "town": Town.objects.create(numero_insee="66666"), + "section": "A", + "parcel_number": "1", + "operation": operation, + } parcel = models.Parcel.objects.create(**default) models.ParcelOwner.objects.create( - parcel=parcel, owner=Person.objects.create(), - start_date=datetime.date.today(), end_date=datetime.date.today()) + parcel=parcel, + owner=Person.objects.create(), + start_date=datetime.date.today(), + end_date=datetime.date.today(), + ) def test_serialization(self): - res = self.generic_serialization_test( - serializers.operation_serialization) + res = self.generic_serialization_test(serializers.operation_serialization) ope_json = json.loads( - res[('operations', 'archaeological_operations__Operation')] + res[("operations", "archaeological_operations__Operation")] ) self.assertEqual(len(ope_json), 2) - result_queryset = models.Operation.objects.filter( - code_patriarche="66666") + result_queryset = models.Operation.objects.filter(code_patriarche="66666") res = self.generic_serialization_test( - serializers.operation_serialization, no_test=True, - kwargs={"operation_queryset": result_queryset} + serializers.operation_serialization, + no_test=True, + kwargs={"operation_queryset": result_queryset}, ) ope_json = json.loads( - res[('operations', 'archaeological_operations__Operation')] + res[("operations", "archaeological_operations__Operation")] ) self.assertEqual(len(ope_json), 1) site_json = json.loads( - res[('operations', 'archaeological_operations__ArchaeologicalSite')] + res[("operations", "archaeological_operations__ArchaeologicalSite")] ) self.assertEqual(len(site_json), 1) rel_json = json.loads( - res[('operations', 'archaeological_operations__RecordRelations')] + res[("operations", "archaeological_operations__RecordRelations")] ) self.assertEqual(len(rel_json), 0) - result_queryset = models.Operation.objects.filter( - code_patriarche="66667") + result_queryset = models.Operation.objects.filter(code_patriarche="66667") res = self.generic_serialization_test( - serializers.operation_serialization, no_test=True, - kwargs={"operation_queryset": result_queryset} + serializers.operation_serialization, + no_test=True, + kwargs={"operation_queryset": result_queryset}, ) ope_json = json.loads( - res[('operations', 'archaeological_operations__Operation')] + res[("operations", "archaeological_operations__Operation")] ) self.assertEqual(len(ope_json), 1) site_json = json.loads( - res[('operations', 'archaeological_operations__ArchaeologicalSite')] + res[("operations", "archaeological_operations__ArchaeologicalSite")] ) self.assertEqual(len(site_json), 0) rel_json = json.loads( - res[('operations', 'archaeological_operations__RecordRelations')] + res[("operations", "archaeological_operations__RecordRelations")] ) self.assertEqual(len(rel_json), 0) @@ -849,8 +940,10 @@ class SerializationTest(GenericSerializationTest, TestCase): def test_lock(self): self.reinit_lock() self.generic_serialization_test( - serializers.operation_serialization, no_test=True, - kwargs={"put_locks": False}) + serializers.operation_serialization, + no_test=True, + kwargs={"put_locks": False}, + ) for operation in self.operations: operation = models.Operation.objects.get(pk=operation.pk) self.assertFalse(operation.locked) @@ -858,8 +951,10 @@ class SerializationTest(GenericSerializationTest, TestCase): self.reinit_lock() self.generic_serialization_test( - serializers.operation_serialization, no_test=True, - kwargs={"put_locks": True}) + serializers.operation_serialization, + no_test=True, + kwargs={"put_locks": True}, + ) for operation in self.operations: operation = models.Operation.objects.get(pk=operation.pk) self.assertTrue(operation.locked) @@ -867,8 +962,10 @@ class SerializationTest(GenericSerializationTest, TestCase): self.reinit_lock() self.generic_serialization_test( - serializers.operation_serialization, no_test=True, - kwargs={"put_locks": True, "lock_user": self.user}) + serializers.operation_serialization, + no_test=True, + kwargs={"put_locks": True, "lock_user": self.user}, + ) for operation in self.operations: operation = models.Operation.objects.get(pk=operation.pk) self.assertTrue(operation.locked) @@ -876,40 +973,50 @@ class SerializationTest(GenericSerializationTest, TestCase): def test_restore(self): current_number, zip_filename = self.generic_restore_test_genzip( - serializers.OPERATION_MODEL_LIST, - serializers.operation_serialization) - self.generic_restore_test(zip_filename, current_number, - serializers.OPERATION_MODEL_LIST) + serializers.OPERATION_MODEL_LIST, serializers.operation_serialization + ) + self.generic_restore_test( + zip_filename, current_number, serializers.OPERATION_MODEL_LIST + ) def test_unlock_on_restore(self): current_number, zip_filename = self.generic_restore_test_genzip( serializers.OPERATION_MODEL_LIST, serializers.operation_serialization, - kwargs={"put_locks": True, "lock_user": self.user}) + kwargs={"put_locks": True, "lock_user": self.user}, + ) - self.generic_restore_test(zip_filename, current_number, - serializers.OPERATION_MODEL_LIST, - delete_existing=False) + self.generic_restore_test( + zip_filename, + current_number, + serializers.OPERATION_MODEL_LIST, + delete_existing=False, + ) for operation in self.operations: operation = models.Operation.objects.get( - code_patriarche=operation.code_patriarche) + code_patriarche=operation.code_patriarche + ) self.assertTrue(operation.locked) self.assertEqual(operation.lock_user, self.user) - self.generic_restore_test(zip_filename, current_number, - serializers.OPERATION_MODEL_LIST, - delete_existing=False, - release_locks=True) + self.generic_restore_test( + zip_filename, + current_number, + serializers.OPERATION_MODEL_LIST, + delete_existing=False, + release_locks=True, + ) for operation in self.operations: operation = models.Operation.objects.get( - code_patriarche=operation.code_patriarche) + code_patriarche=operation.code_patriarche + ) self.assertFalse(operation.locked) self.assertIsNone(operation.lock_user) def test_historization_on_restore(self): current_number, zip_filename = self.generic_restore_test_genzip( - serializers.OPERATION_MODEL_LIST, - serializers.operation_serialization) + serializers.OPERATION_MODEL_LIST, serializers.operation_serialization + ) operation = models.Operation.objects.get(code_patriarche="66666") version_nb = operation.history.count() @@ -941,191 +1048,516 @@ class ParcelTest(ImportTest, TestCase): def test_parse_parcels(self): # the database needs to be initialised before importing from archaeological_operations.utils import parse_parcels + # default_town = Town.objects.create(numero_insee="12345", # name="default_town") test_values = ( - ("1996 : XT:53,54,56,57,59,60,61,62", - {1996: [ - ("XT", "53"), ("XT", "54"), ("XT", "56"), ("XT", "57"), - ("XT", "59"), ("XT", "60"), ("XT", "61"), ("XT", "62"), - ]} - ), - ("AD:23", - {None: [ - ("AD", "23") - ]}), - ("1961 :B1:227;", - {1961: [ - ("B1", '227') - ]}), - ("1982 CV:35;CV:36", - {1982: [ - ("CV", "35"), ("CV", "36"), - ]}), - ("E:24;E:25", - {None: [ - ("E", "24"), ("E", "25"), - ]}), - ("B : 375, 376, 386, 387, 645, 646 / C : 412 à 415, 432 à 435, " - "622 / F : 120, 149, 150, 284, 287, 321 à 323", - {None: [ - ("B", "375"), ("B", "376"), ("B", "386"), ("B", "387"), - ("B", "645"), ("B", "646"), - ("C", "412"), ("C", "413"), ("C", "414"), ("C", "415"), - ("C", "432"), ("C", "433"), ("C", "434"), ("C", "435"), - ("C", "622"), - ("F", "120"), ("F", "149"), ("F", "150"), ("F", "284"), - ("F", "287"), ("F", "321"), ("F", "322"), ("F", "323"), - ]}), - ("AD : 95, 96, 86, 87, 81, 252, AE : 58, AD : 115 à 132", - {None: [ - ("AD", "95"), ("AD", "96"), ("AD", "86"), ("AD", "87"), - ("AD", "81"), ("AD", "252"), ("AD", "115"), ("AD", "116"), - ("AD", "117"), ("AD", "118"), ("AD", "119"), ("AD", "120"), - ("AD", "121"), ("AD", "122"), ("AD", "123"), ("AD", "124"), - ("AD", "125"), ("AD", "126"), ("AD", "127"), ("AD", "128"), - ("AD", "129"), ("AD", "130"), ("AD", "131"), ("AD", "132"), - ("AE", "58"), - ]}), - ("XD:1 à 13, 24 à 28, 33 à 39, 50 à 52, 80, 83, 84 à 86, 259 à " - "261, 182, 225 ; XH:5 ; P:1640, 1888, 1889, 1890 ; R:1311, " - "1312, 1314,1342, 1343, 1559 à 1569", - {None: [ - ('XD', "1"), ('XD', "2"), ('XD', "3"), ('XD', "4"), - ('XD', "5"), ('XD', "6"), ('XD', "7"), ('XD', "8"), - ('XD', "9"), ('XD', "10"), ('XD', "11"), ('XD', "12"), - ('XD', "13"), ("XD", "24"), ("XD", "25"), ("XD", "26"), - ("XD", "27"), ("XD", "28"), ("XD", "33"), ("XD", "34"), - ("XD", "35"), ("XD", "36"), ("XD", "37"), ("XD", "38"), - ("XD", "39"), ("XD", "50"), ("XD", "51"), ("XD", "52"), - ("XD", "80"), ("XD", "83"), ("XD", "84"), ("XD", "85"), - ("XD", "86"), ("XD", "259"), ("XD", "260"), ("XD", "261"), - ("XD", "182"), ("XD", "225"), ("XH", "5"), - ("P", "1640"), ("P", "1888"), ("P", "1889"), ("P", "1890"), - ("R", "1311"), ("R", "1312"), ("R", "1314"), ("R", "1342"), - ("R", "1343"), ("R", "1559"), ("R", "1560"), ("R", "1561"), - ("R", "1562"), ("R", "1563"), ("R", "1564"), ("R", "1565"), - ("R", "1566"), ("R", "1567"), ("R", "1568"), ("R", "1569"), - ]}), - ("BZ:2 à 5, 365 ; CD:88 à 104, 106, 108, 326", - {None: [ - ('BZ', '2'), ('BZ', '3'), ('BZ', '4'), ('BZ', '5'), - ('BZ', '365'), ('CD', '88'), ('CD', '89'), ('CD', '90'), - ('CD', '91'), ('CD', '92'), ('CD', '93'), ('CD', '94'), - ('CD', '95'), ('CD', '96'), ('CD', '97'), ('CD', '98'), - ('CD', '99'), ('CD', '100'), ('CD', '101'), ('CD', '102'), - ('CD', '103'), ('CD', '104'), ('CD', '106'), ('CD', '326'), - ('CD', '108') - ]}), - ("AV 118 à 125, 127, 132 à 137, 153, 398p, 399, 402; BI 27, 30, " - "32, 33, 188, 255, 256 à 258, 260, 284p, 294; BL 297", - {None: [ - ('AV', '118'), ('AV', '119'), ('AV', '120'), ('AV', '121'), - ('AV', '122'), ('AV', '123'), ('AV', '124'), ('AV', '125'), - ('AV', '127'), ('AV', '132'), ('AV', '133'), ('AV', '134'), - ('AV', '135'), ('AV', '136'), ('AV', '137'), ('AV', '153'), - ('AV', '398p'), ('AV', '399'), ('AV', '402'), - ('BI', '27'), ('BI', '30'), ('BI', '32'), ('BI', '33'), - ('BI', '188'), ('BI', '255'), ('BI', '256'), ('BI', '257'), - ('BI', '258'), ('BI', '260'), ('BI', '284p'), ('BI', '294'), - ('BL', '297'), - ]}), - ("A : 904 à 906, 911 ; E:40, 41", - {None: [ - ("A", '904'), ("A", '905'), ("A", '906'), ("A", '911'), - ("E", '40'), ("E", "41") - ]}), - ("1991 : BE:8, 12", - {"1991": [ - ('BE', '8'), ('BE', '12'), - ]}), - ("1979 : EM:1", - {"1979": [ - ('EM', '1') - ]},), - ("B:448;B:449;B:450;B:451;B:452;B:455;B:456;B:457;B:458;B:459;" - "B:1486;", - {None: [ - ("B", "448"), ("B", "449"), ("B", "450"), ("B", "451"), - ("B", "452"), ("B", "455"), ("B", "456"), ("B", "457"), - ("B", "458"), ("B", "459"), ("B", "1486"), - ]}), - ("AC : 72 à 81, 91 à 100, 197 / ZC:180 à 189", - {None: [ - ('AC', '72'), ('AC', '73'), ('AC', '74'), ('AC', '75'), - ('AC', '76'), ('AC', '77'), ('AC', '78'), ('AC', '79'), - ('AC', '80'), ('AC', '81'), ('AC', '91'), ('AC', '92'), - ('AC', '93'), ('AC', '94'), ('AC', '95'), ('AC', '96'), - ('AC', '97'), ('AC', '98'), ('AC', '99'), ('AC', '100'), - ('AC', '197'), ('ZC', '180'), ('ZC', '181'), ('ZC', '182'), - ('ZC', '183'), ('ZC', '184'), ('ZC', '185'), ('ZC', '186'), - ('ZC', '187'), ('ZC', '188'), ('ZC', '189'), - ]}), - ("AB 37 et 308", - {None: [ - ('AB', '37'), ('AB', '308'), - ]}), - ("1983 D2 n° 458 et 459", - {"1983": [ - ('D2', '458'), ('D2', '459'), - ]}), - ("ZS : 21p, 66", - {None: [ - ('ZS', '21p'), ('ZS', '66'), - ]}), - ("VV:166, 167, domaine public", - {None: [ - ('VV', '166'), ('VV', '167'), - ]}), - (" AS:13 à 15, 17 à 19, 21 à 32, 34 à 45, 47 à 53, 69, 70, 82, " - "84 / CK:1, 24, 25, 29, 30, 37 à 43", - {None: [ - ("AS", "13"), ("AS", "14"), ("AS", "15"), ("AS", "17"), - ("AS", "18"), ("AS", "19"), ("AS", "21"), ("AS", "22"), - ("AS", "23"), ("AS", "24"), ("AS", "25"), ("AS", "26"), - ("AS", "27"), ("AS", "28"), ("AS", "29"), ("AS", "30"), - ("AS", "31"), ("AS", "32"), ("AS", "34"), ("AS", "35"), - ("AS", "36"), ("AS", "37"), ("AS", "38"), ("AS", "39"), - ("AS", "40"), ("AS", "41"), ("AS", "42"), ("AS", "43"), - ("AS", "44"), ("AS", "45"), ("AS", "47"), ("AS", "48"), - ("AS", "49"), ("AS", "50"), ("AS", "51"), ("AS", "52"), - ("AS", "53"), ('AS', "69"), ('AS', "70"), ('AS', "82"), - ('AS', "84"), ('CK', "1"), ('CK', "24"), ('CK', "25"), - ('CK', "29"), ('CK', "30"), ('CK', "37"), ('CK', "38"), - ('CK', "39"), ('CK', "40"), ('CK', "41"), ('CK', "42"), - ('CK', "43"), ]}), - (" ZN:37, 15, 35, 28, 29 / ZM:9, 73", - {None: [ - ("ZN", "37"), ("ZN", "15"), ("ZN", "35"), ("ZN", "28"), - ("ZN", "29"), ("ZM", "9"), ("ZM", "73"), - ]}), - (" Tranche n°1 : YP:243, 12, 14 à 16, 18 à 26, DP / Tranche n°2 :" - "YP:17, 307, 27, 308, 44 à 46, 683, BM:1, 250, 488 à 492", - {None: [ - ('YP', '243'), ('YP', '12'), ('YP', '14'), ('YP', '15'), - ('YP', '16'), ('YP', '18'), ('YP', '19'), ('YP', '20'), - ('YP', '21'), ('YP', '22'), ('YP', '23'), ('YP', '24'), - ('YP', '25'), ('YP', '26'), ('YP', '17'), ('YP', '27'), - ('YP', '308'), ('YP', '44'), ('YP', '45'), ('YP', '46'), - ('YP', '683'), ('YP', '307'), ('BM', '1'), ('BM', '250'), - ('BM', '488'), ('BM', '489'), ('BM', '490'), ('BM', '491'), - ('BM', '492'), - ]}), - (" H : 106, 156, 158", - {None: [ - ('H', '106'), ('H', '156'), ('H', '158'), - ]}), - ("Section YO : parcelles n° 19; 20", - {None: [ - ('YO', '19'), ('YO', '20'), - ]}), - ("1991 :AI:23;19;20;21;22;181;AM:116;214;215;233;235", - {"1991": [ - ("AI", "19"), ("AI", "20"), ("AI", "21"), ("AI", "22"), - ("AI", "23"), ("AI", "181"), - ("AM", "116"), ("AM", "214"), ("AM", "215"), - ("AM", "233"), ("AM", "235"), - ]}) + ( + "1996 : XT:53,54,56,57,59,60,61,62", + { + 1996: [ + ("XT", "53"), + ("XT", "54"), + ("XT", "56"), + ("XT", "57"), + ("XT", "59"), + ("XT", "60"), + ("XT", "61"), + ("XT", "62"), + ] + }, + ), + ("AD:23", {None: [("AD", "23")]}), + ("1961 :B1:227;", {1961: [("B1", "227")]}), + ( + "1982 CV:35;CV:36", + { + 1982: [ + ("CV", "35"), + ("CV", "36"), + ] + }, + ), + ( + "E:24;E:25", + { + None: [ + ("E", "24"), + ("E", "25"), + ] + }, + ), + ( + "B : 375, 376, 386, 387, 645, 646 / C : 412 à 415, 432 à 435, " + "622 / F : 120, 149, 150, 284, 287, 321 à 323", + { + None: [ + ("B", "375"), + ("B", "376"), + ("B", "386"), + ("B", "387"), + ("B", "645"), + ("B", "646"), + ("C", "412"), + ("C", "413"), + ("C", "414"), + ("C", "415"), + ("C", "432"), + ("C", "433"), + ("C", "434"), + ("C", "435"), + ("C", "622"), + ("F", "120"), + ("F", "149"), + ("F", "150"), + ("F", "284"), + ("F", "287"), + ("F", "321"), + ("F", "322"), + ("F", "323"), + ] + }, + ), + ( + "AD : 95, 96, 86, 87, 81, 252, AE : 58, AD : 115 à 132", + { + None: [ + ("AD", "95"), + ("AD", "96"), + ("AD", "86"), + ("AD", "87"), + ("AD", "81"), + ("AD", "252"), + ("AD", "115"), + ("AD", "116"), + ("AD", "117"), + ("AD", "118"), + ("AD", "119"), + ("AD", "120"), + ("AD", "121"), + ("AD", "122"), + ("AD", "123"), + ("AD", "124"), + ("AD", "125"), + ("AD", "126"), + ("AD", "127"), + ("AD", "128"), + ("AD", "129"), + ("AD", "130"), + ("AD", "131"), + ("AD", "132"), + ("AE", "58"), + ] + }, + ), + ( + "XD:1 à 13, 24 à 28, 33 à 39, 50 à 52, 80, 83, 84 à 86, 259 à " + "261, 182, 225 ; XH:5 ; P:1640, 1888, 1889, 1890 ; R:1311, " + "1312, 1314,1342, 1343, 1559 à 1569", + { + None: [ + ("XD", "1"), + ("XD", "2"), + ("XD", "3"), + ("XD", "4"), + ("XD", "5"), + ("XD", "6"), + ("XD", "7"), + ("XD", "8"), + ("XD", "9"), + ("XD", "10"), + ("XD", "11"), + ("XD", "12"), + ("XD", "13"), + ("XD", "24"), + ("XD", "25"), + ("XD", "26"), + ("XD", "27"), + ("XD", "28"), + ("XD", "33"), + ("XD", "34"), + ("XD", "35"), + ("XD", "36"), + ("XD", "37"), + ("XD", "38"), + ("XD", "39"), + ("XD", "50"), + ("XD", "51"), + ("XD", "52"), + ("XD", "80"), + ("XD", "83"), + ("XD", "84"), + ("XD", "85"), + ("XD", "86"), + ("XD", "259"), + ("XD", "260"), + ("XD", "261"), + ("XD", "182"), + ("XD", "225"), + ("XH", "5"), + ("P", "1640"), + ("P", "1888"), + ("P", "1889"), + ("P", "1890"), + ("R", "1311"), + ("R", "1312"), + ("R", "1314"), + ("R", "1342"), + ("R", "1343"), + ("R", "1559"), + ("R", "1560"), + ("R", "1561"), + ("R", "1562"), + ("R", "1563"), + ("R", "1564"), + ("R", "1565"), + ("R", "1566"), + ("R", "1567"), + ("R", "1568"), + ("R", "1569"), + ] + }, + ), + ( + "BZ:2 à 5, 365 ; CD:88 à 104, 106, 108, 326", + { + None: [ + ("BZ", "2"), + ("BZ", "3"), + ("BZ", "4"), + ("BZ", "5"), + ("BZ", "365"), + ("CD", "88"), + ("CD", "89"), + ("CD", "90"), + ("CD", "91"), + ("CD", "92"), + ("CD", "93"), + ("CD", "94"), + ("CD", "95"), + ("CD", "96"), + ("CD", "97"), + ("CD", "98"), + ("CD", "99"), + ("CD", "100"), + ("CD", "101"), + ("CD", "102"), + ("CD", "103"), + ("CD", "104"), + ("CD", "106"), + ("CD", "326"), + ("CD", "108"), + ] + }, + ), + ( + "AV 118 à 125, 127, 132 à 137, 153, 398p, 399, 402; BI 27, 30, " + "32, 33, 188, 255, 256 à 258, 260, 284p, 294; BL 297", + { + None: [ + ("AV", "118"), + ("AV", "119"), + ("AV", "120"), + ("AV", "121"), + ("AV", "122"), + ("AV", "123"), + ("AV", "124"), + ("AV", "125"), + ("AV", "127"), + ("AV", "132"), + ("AV", "133"), + ("AV", "134"), + ("AV", "135"), + ("AV", "136"), + ("AV", "137"), + ("AV", "153"), + ("AV", "398p"), + ("AV", "399"), + ("AV", "402"), + ("BI", "27"), + ("BI", "30"), + ("BI", "32"), + ("BI", "33"), + ("BI", "188"), + ("BI", "255"), + ("BI", "256"), + ("BI", "257"), + ("BI", "258"), + ("BI", "260"), + ("BI", "284p"), + ("BI", "294"), + ("BL", "297"), + ] + }, + ), + ( + "A : 904 à 906, 911 ; E:40, 41", + { + None: [ + ("A", "904"), + ("A", "905"), + ("A", "906"), + ("A", "911"), + ("E", "40"), + ("E", "41"), + ] + }, + ), + ( + "1991 : BE:8, 12", + { + "1991": [ + ("BE", "8"), + ("BE", "12"), + ] + }, + ), + ( + "1979 : EM:1", + {"1979": [("EM", "1")]}, + ), + ( + "B:448;B:449;B:450;B:451;B:452;B:455;B:456;B:457;B:458;B:459;" + "B:1486;", + { + None: [ + ("B", "448"), + ("B", "449"), + ("B", "450"), + ("B", "451"), + ("B", "452"), + ("B", "455"), + ("B", "456"), + ("B", "457"), + ("B", "458"), + ("B", "459"), + ("B", "1486"), + ] + }, + ), + ( + "AC : 72 à 81, 91 à 100, 197 / ZC:180 à 189", + { + None: [ + ("AC", "72"), + ("AC", "73"), + ("AC", "74"), + ("AC", "75"), + ("AC", "76"), + ("AC", "77"), + ("AC", "78"), + ("AC", "79"), + ("AC", "80"), + ("AC", "81"), + ("AC", "91"), + ("AC", "92"), + ("AC", "93"), + ("AC", "94"), + ("AC", "95"), + ("AC", "96"), + ("AC", "97"), + ("AC", "98"), + ("AC", "99"), + ("AC", "100"), + ("AC", "197"), + ("ZC", "180"), + ("ZC", "181"), + ("ZC", "182"), + ("ZC", "183"), + ("ZC", "184"), + ("ZC", "185"), + ("ZC", "186"), + ("ZC", "187"), + ("ZC", "188"), + ("ZC", "189"), + ] + }, + ), + ( + "AB 37 et 308", + { + None: [ + ("AB", "37"), + ("AB", "308"), + ] + }, + ), + ( + "1983 D2 n° 458 et 459", + { + "1983": [ + ("D2", "458"), + ("D2", "459"), + ] + }, + ), + ( + "ZS : 21p, 66", + { + None: [ + ("ZS", "21p"), + ("ZS", "66"), + ] + }, + ), + ( + "VV:166, 167, domaine public", + { + None: [ + ("VV", "166"), + ("VV", "167"), + ] + }, + ), + ( + " AS:13 à 15, 17 à 19, 21 à 32, 34 à 45, 47 à 53, 69, 70, 82, " + "84 / CK:1, 24, 25, 29, 30, 37 à 43", + { + None: [ + ("AS", "13"), + ("AS", "14"), + ("AS", "15"), + ("AS", "17"), + ("AS", "18"), + ("AS", "19"), + ("AS", "21"), + ("AS", "22"), + ("AS", "23"), + ("AS", "24"), + ("AS", "25"), + ("AS", "26"), + ("AS", "27"), + ("AS", "28"), + ("AS", "29"), + ("AS", "30"), + ("AS", "31"), + ("AS", "32"), + ("AS", "34"), + ("AS", "35"), + ("AS", "36"), + ("AS", "37"), + ("AS", "38"), + ("AS", "39"), + ("AS", "40"), + ("AS", "41"), + ("AS", "42"), + ("AS", "43"), + ("AS", "44"), + ("AS", "45"), + ("AS", "47"), + ("AS", "48"), + ("AS", "49"), + ("AS", "50"), + ("AS", "51"), + ("AS", "52"), + ("AS", "53"), + ("AS", "69"), + ("AS", "70"), + ("AS", "82"), + ("AS", "84"), + ("CK", "1"), + ("CK", "24"), + ("CK", "25"), + ("CK", "29"), + ("CK", "30"), + ("CK", "37"), + ("CK", "38"), + ("CK", "39"), + ("CK", "40"), + ("CK", "41"), + ("CK", "42"), + ("CK", "43"), + ] + }, + ), + ( + " ZN:37, 15, 35, 28, 29 / ZM:9, 73", + { + None: [ + ("ZN", "37"), + ("ZN", "15"), + ("ZN", "35"), + ("ZN", "28"), + ("ZN", "29"), + ("ZM", "9"), + ("ZM", "73"), + ] + }, + ), + ( + " Tranche n°1 : YP:243, 12, 14 à 16, 18 à 26, DP / Tranche n°2 :" + "YP:17, 307, 27, 308, 44 à 46, 683, BM:1, 250, 488 à 492", + { + None: [ + ("YP", "243"), + ("YP", "12"), + ("YP", "14"), + ("YP", "15"), + ("YP", "16"), + ("YP", "18"), + ("YP", "19"), + ("YP", "20"), + ("YP", "21"), + ("YP", "22"), + ("YP", "23"), + ("YP", "24"), + ("YP", "25"), + ("YP", "26"), + ("YP", "17"), + ("YP", "27"), + ("YP", "308"), + ("YP", "44"), + ("YP", "45"), + ("YP", "46"), + ("YP", "683"), + ("YP", "307"), + ("BM", "1"), + ("BM", "250"), + ("BM", "488"), + ("BM", "489"), + ("BM", "490"), + ("BM", "491"), + ("BM", "492"), + ] + }, + ), + ( + " H : 106, 156, 158", + { + None: [ + ("H", "106"), + ("H", "156"), + ("H", "158"), + ] + }, + ), + ( + "Section YO : parcelles n° 19; 20", + { + None: [ + ("YO", "19"), + ("YO", "20"), + ] + }, + ), + ( + "1991 :AI:23;19;20;21;22;181;AM:116;214;215;233;235", + { + "1991": [ + ("AI", "19"), + ("AI", "20"), + ("AI", "21"), + ("AI", "22"), + ("AI", "23"), + ("AI", "181"), + ("AM", "116"), + ("AM", "214"), + ("AM", "215"), + ("AM", "233"), + ("AM", "235"), + ] + }, + ), ) # ),("Domaine public", {} # ),("Tranche 1 : AV:4 à 6, 18, 80, 104 / partiellement : 5 et 18", {} @@ -1135,52 +1567,63 @@ class ParcelTest(ImportTest, TestCase): parcels = parse_parcels(value) if not parcels and not result: continue - self.assertTrue(parcels != [], - msg="No parcel parsed for \"%s\"" % value) + self.assertTrue(parcels != [], msg='No parcel parsed for "%s"' % value) parcels_copy = parcels[:] for year in result.keys(): for values in parcels_copy: - if values['year'] != year and \ - values['year'] != str(year): + if values["year"] != year and values["year"] != str(year): continue self.assertTrue( - (values['section'], values['parcel_number']) - in result[year], - msg="Section - Parcel number: \"%s - %s\" is not " - "in \"%s\"" % ( - values['section'], values['parcel_number'], - str(result[year]))) + (values["section"], values["parcel_number"]) in result[year], + msg='Section - Parcel number: "%s - %s" is not ' + 'in "%s"' + % ( + values["section"], + values["parcel_number"], + str(result[year]), + ), + ) parcels.pop(parcels.index(values)) - result[year].pop(result[year].index( - (values['section'], values['parcel_number']))) + result[year].pop( + result[year].index((values["section"], values["parcel_number"])) + ) # all parcels have been imported - self.assertEqual(parcels, [], msg="Parcel(s): \"%s\" haven't be " - "recognized in \"%s\"" % (str(parcels), value)) + self.assertEqual( + parcels, + [], + msg='Parcel(s): "%s" haven\'t be ' + 'recognized in "%s"' % (str(parcels), value), + ) not_imported = [data for data in result.values() if data] self.assertEqual( - not_imported, [], msg="Parcel(s): \"%s\" haven't be " - "recognized in \"%s\"" % (str(not_imported), value)) + not_imported, + [], + msg='Parcel(s): "%s" haven\'t be ' + 'recognized in "%s"' % (str(not_imported), value), + ) def create_orga(user): - orga_type, created = OrganizationType.objects.get_or_create( - txt_idx='operator') + orga_type, created = OrganizationType.objects.get_or_create(txt_idx="operator") orga, created = Organization.objects.get_or_create( - name='Operator', organization_type=orga_type, history_modifier=user) + name="Operator", organization_type=orga_type, history_modifier=user + ) return orga def create_operation(user, orga=None, values=None): - operation_type = models.OperationType.objects.get( - txt_idx="arch_diagnostic") + operation_type = models.OperationType.objects.get(txt_idx="arch_diagnostic") if not values: values = {} - dct = {'year': 2010, 'operation_type_id': operation_type.pk, - 'history_modifier': user} + dct = { + "year": 2010, + "operation_type_id": operation_type.pk, + "history_modifier": user, + } dct.update(values) if orga: - dct['operator'] = orga - if 'code_patriarche' not in dct: + dct["operator"] = orga + if "code_patriarche" not in dct: idx = 1 while models.Operation.objects.filter(code_patriarche=str(idx)).count(): idx += 1 @@ -1206,36 +1649,39 @@ class OperationInitTest(object): return self.orgas def get_default_orga(self, user=None): - if not hasattr(self, 'orgas') or not self.orgas: + if not hasattr(self, "orgas") or not self.orgas: self.create_orgas(user) return self.orgas[0] def create_towns(self, datas=None): if not datas: datas = {} - default = {'numero_insee': '12345', 'name': 'default_town'} + default = {"numero_insee": "12345", "name": "default_town"} default.update(datas) town = models.Town.objects.create(**default) - if not hasattr(self, 'towns') or not self.towns: + if not hasattr(self, "towns") or not self.towns: self.towns = [] self.towns.append(town) return self.towns def get_default_town(self): - towns = getattr(self, 'towns', None) + towns = getattr(self, "towns", None) if not towns: self.create_towns() return self.towns[0] def create_parcel(self, data=None): - default = {'town': self.get_default_town(), - 'section': 'A', 'parcel_number': '1'} - if not hasattr(self, 'operations'): + default = { + "town": self.get_default_town(), + "section": "A", + "parcel_number": "1", + } + if not hasattr(self, "operations"): self.create_operation() - default['operation'] = self.operations[0] + default["operation"] = self.operations[0] if data: default.update(data) - if not getattr(self, 'parcels', None): + if not getattr(self, "parcels", None): self.parcels = [] self.parcels.append(models.Parcel.objects.create(**default)) return self.parcels @@ -1254,7 +1700,7 @@ class OperationInitTest(object): self.get_default_orga(user) if not user: self.get_default_user() - if not getattr(self, 'operations', None): + if not getattr(self, "operations", None): self.operations = [] self.operations.append(create_operation(user, orga)) return self.operations @@ -1270,19 +1716,19 @@ class OperationInitTest(object): def tearDown(self): # cleanup for further test - if hasattr(self, 'user'): + if hasattr(self, "user"): self.user.delete() self.user = None # all try/except is necessary for bad migrations on main... # should be removed at the next big version - if hasattr(self, 'operations'): + if hasattr(self, "operations"): for ope in self.operations: try: ope.delete() except: pass self.operations = [] - if hasattr(self, 'parcels'): + if hasattr(self, "parcels"): for p in self.parcels: try: p.delete() @@ -1295,93 +1741,105 @@ class OperationTest(TestCase, OperationInitTest): fixtures = FILE_FIXTURES def setUp(self): - IshtarSiteProfile.objects.get_or_create( - slug='default', active=True) + IshtarSiteProfile.objects.get_or_create(slug="default", active=True) self.username, self.password, self.user = create_superuser() self.alt_username, self.alt_password, self.alt_user = create_user() - self.alt_user.user_permissions.add(Permission.objects.get( - codename='view_own_operation')) + self.alt_user.user_permissions.add( + Permission.objects.get(codename="view_own_operation") + ) self.orgas = self.create_orgas(self.user) self.operations = self.create_operation(self.user, self.orgas[0]) self.operations += self.create_operation(self.alt_user, self.orgas[0]) self.item = self.operations[0] for idx in range(15): - ContextRecord.objects.create(label='CR-{}'.format(idx), - operation=self.item) + ContextRecord.objects.create(label="CR-{}".format(idx), operation=self.item) def test_external_id(self): - self.item.code_patriarche = '123456789' + self.item.code_patriarche = "123456789" self.item.save() parcel = self.get_default_parcel() parcel.operation = self.item parcel.save() correct_ext_id = "{}-{}-{}{}".format( - self.item.code_patriarche, parcel.town.numero_insee, - parcel.section, parcel.parcel_number) + self.item.code_patriarche, + parcel.town.numero_insee, + parcel.section, + parcel.parcel_number, + ) self.assertEqual(parcel.external_id, correct_ext_id) # auto has been previously set - parcel.external_id = 'blabla' + parcel.external_id = "blabla" parcel.save() self.assertEqual(parcel.external_id, correct_ext_id) # deactivate auto parcel.auto_external_id = False - parcel.external_id = 'blabla' + parcel.external_id = "blabla" parcel.save() - self.assertEqual(parcel.external_id, 'blabla') + self.assertEqual(parcel.external_id, "blabla") def test_complete_identifier(self): profile = get_current_profile() - profile.operation_complete_identifier = \ + profile.operation_complete_identifier = ( "{code_patriarche}-{towns__numero_insee}" + ) profile.save() self.item = models.Operation.objects.get(pk=self.item.pk) t = Town.objects.create(numero_insee="12345", name="OK town") self.item.towns.add(t) self.item = models.Operation.objects.get(pk=self.item.pk) - self.item.code_patriarche = '123456789' + self.item.code_patriarche = "123456789" self.item.year = 2020 self.item.save() self.item = models.Operation.objects.get(pk=self.item.pk) - self.assertEqual(self.item.complete_identifier, - '{}-{}'.format(self.item.code_patriarche, - t.numero_insee)) + self.assertEqual( + self.item.complete_identifier, + "{}-{}".format(self.item.code_patriarche, t.numero_insee), + ) - profile.operation_complete_identifier = \ - "{year}-{towns__numero_insee}" + profile.operation_complete_identifier = "{year}-{towns__numero_insee}" profile.save() self.item.save() self.item = models.Operation.objects.get(pk=self.item.pk) - self.assertEqual(self.item.complete_identifier, - '{}-{}'.format(self.item.year, - t.numero_insee)) + self.assertEqual( + self.item.complete_identifier, + "{}-{}".format(self.item.year, t.numero_insee), + ) def test_associated(self): scientist = Person.objects.create(name="C-3PO") self.item.scientist = scientist self.item.save() scientist = Person.objects.get(pk=scientist.pk) - self.assertIn(PersonType.objects.get(txt_idx='head_scientist'), - scientist.person_types.all()) + self.assertIn( + PersonType.objects.get(txt_idx="head_scientist"), + scientist.person_types.all(), + ) # do not change if in the list sra = Person.objects.create(name="R2D2") - sra.person_types.add(PersonType.objects.get(txt_idx='sra_agent')) + sra.person_types.add(PersonType.objects.get(txt_idx="sra_agent")) self.item.scientist = sra self.item.save() - self.assertNotIn(PersonType.objects.get(txt_idx='head_scientist'), - sra.person_types.all()) + self.assertNotIn( + PersonType.objects.get(txt_idx="head_scientist"), sra.person_types.all() + ) def create_relations(self): rel1 = models.RelationType.objects.create( - symmetrical=True, label='Include', txt_idx='include') + symmetrical=True, label="Include", txt_idx="include" + ) rel2 = models.RelationType.objects.create( - symmetrical=False, label='Included', txt_idx='included', - inverse_relation=rel1) + symmetrical=False, + label="Included", + txt_idx="included", + inverse_relation=rel1, + ) models.RecordRelations.objects.create( left_record=self.operations[0], right_record=self.operations[1], - relation_type=rel1) + relation_type=rel1, + ) return rel1, rel2 def testPostDeleteRelations(self): @@ -1390,7 +1848,7 @@ class OperationTest(TestCase, OperationInitTest): def testPostDeleteParcels(self): ope = self.operations[0] - town = Town.objects.create(name='plouf', numero_insee='20000') + town = Town.objects.create(name="plouf", numero_insee="20000") parcel = models.Parcel.objects.create(town=town) parcel_nb = models.Parcel.objects.count() ope.parcels.add(parcel) @@ -1407,38 +1865,37 @@ class OperationTest(TestCase, OperationInitTest): self.assertEqual(parcel_nb, models.Parcel.objects.count()) def testIndex(self): - ope = create_operation(self.user, values={'year': 2042}) + ope = create_operation(self.user, values={"year": 2042}) self.assertEqual(ope.operation_code, 1) - ope2 = create_operation(self.user, values={'year': 2042}) + ope2 = create_operation(self.user, values={"year": 2042}) self.assertEqual(ope2.operation_code, 2) - ope = create_operation(self.user, values={'year': 0}) + ope = create_operation(self.user, values={"year": 0}) self.assertEqual(ope.operation_code, 1) - ope2 = create_operation(self.user, values={'year': 0}) + ope2 = create_operation(self.user, values={"year": 0}) self.assertEqual(ope2.operation_code, 2) def test_cache_update(self): self.create_towns() operation = self.operations[0] self.assertIsNotNone(operation.cached_label) - town, ope_id = operation.cached_label.split(' | ') - self.assertIn(town, ('Intercommunal', "Multi-town")) - self.assertEqual(ope_id, 'OA1 - OP2010-1') + town, ope_id = operation.cached_label.split(" | ") + self.assertIn(town, ("Intercommunal", "Multi-town")) + self.assertEqual(ope_id, "OA1 - OP2010-1") operation = models.Operation.objects.get(pk=operation.pk) operation.year = 2011 operation.save() operation.towns.add(self.towns[0]) operation = models.Operation.objects.get(pk=operation.pk) self.assertIsNotNone(operation.cached_label) - town, ope_id = operation.cached_label.split(' | ') - self.assertEqual(ope_id, 'OA1 - OP2011-1') + town, ope_id = operation.cached_label.split(" | ") + self.assertEqual(ope_id, "OA1 - OP2011-1") self.assertEqual(town, self.towns[0].name) def test_search_vector_update(self): operation = self.operations[0] - town = self.create_towns({'numero_insee': '12346', 'name': 'Daisy'})[-1] + town = self.create_towns({"numero_insee": "12346", "name": "Daisy"})[-1] operation.towns.add(town) - town = self.create_towns( - {'numero_insee': '12347', 'name': 'Dirty old'})[-1] + town = self.create_towns({"numero_insee": "12347", "name": "Dirty old"})[-1] operation.towns.add(town) operation = models.Operation.objects.get(pk=operation.pk) operation.comment = "Zardoz" @@ -1449,9 +1906,15 @@ class OperationTest(TestCase, OperationInitTest): operation.save() self.assertIsNotNone(operation.search_vector) for key in ( - 'old', 'dirty', 'daisy', "'2010'", "zardoz", "huiaaa5", - "{}42huiaaa5".format(profile.operation_prefix.lower()), - "42huiaaa5"): + "old", + "dirty", + "daisy", + "'2010'", + "zardoz", + "huiaaa5", + "{}42huiaaa5".format(profile.operation_prefix.lower()), + "42huiaaa5", + ): self.assertIn(key, operation.search_vector) def test_cache_bulk_update(self): @@ -1460,24 +1923,30 @@ class OperationTest(TestCase, OperationInitTest): operation.parcels.add(init_parcel) from archaeological_context_records.models import ContextRecord - cr_data = {'label': "Context record", "operation": operation, - 'parcel': init_parcel, - 'history_modifier': self.get_default_user()} + + cr_data = { + "label": "Context record", + "operation": operation, + "parcel": init_parcel, + "history_modifier": self.get_default_user(), + } cr = ContextRecord.objects.create(**cr_data) from archaeological_finds.models import BaseFind, Find, MaterialType + bf_data = { - 'label': "Base find", 'history_modifier': self.get_default_user(), - 'context_record': cr + "label": "Base find", + "history_modifier": self.get_default_user(), + "context_record": cr, } base_find = BaseFind.objects.create(**bf_data) find = Find.objects.create( - history_modifier=self.get_default_user(), - label='Find me' + history_modifier=self.get_default_user(), label="Find me" ) find.base_finds.add(base_find) mat = MaterialType.objects.create( - label='Adamentium', txt_idx='admentium', code='ADA') + label="Adamentium", txt_idx="admentium", code="ADA" + ) find.material_types.add(mat) class TestObj(object): @@ -1485,7 +1954,7 @@ class OperationTest(TestCase, OperationInitTest): self.context_record_reached = [] def reached(self, sender, **kwargs): - instance = kwargs.get('instance') + instance = kwargs.get("instance") if sender == ContextRecord: self.context_record_reached.append(instance) @@ -1501,73 +1970,70 @@ class OperationTest(TestCase, OperationInitTest): # verify the relevance of the update cr = ContextRecord.objects.get(pk=cr.pk) self.assertIsNotNone(cr.cached_label) - ope_id, parcel_sec, parcel_nb, cr_label = cr.cached_label.split(' | ') + ope_id, parcel_sec, parcel_nb, cr_label = cr.cached_label.split(" | ") profile = get_current_profile() - self.assertEqual(ope_id, 'OA1') + self.assertEqual(ope_id, "OA1") base_find = BaseFind.objects.get(pk=base_find.pk) - op_code, idx = base_find.cache_short_id.split(' | ') - self.assertEqual(op_code, 'OA1') - self.assertEqual(idx, '00001') + op_code, idx = base_find.cache_short_id.split(" | ") + self.assertEqual(op_code, "OA1") + self.assertEqual(idx, "00001") self.assertIsNotNone(base_find.cache_complete_id) - op_code, mat_code, lbl, idx = base_find.cache_complete_id.split(' | ') - self.assertEqual(op_code, 'OA1') - self.assertEqual(mat_code, 'ADA') - self.assertEqual(lbl, 'Context record') - self.assertEqual(idx, '00001') + op_code, mat_code, lbl, idx = base_find.cache_complete_id.split(" | ") + self.assertEqual(op_code, "OA1") + self.assertEqual(mat_code, "ADA") + self.assertEqual(lbl, "Context record") + self.assertEqual(idx, "00001") find = Find.objects.get(pk=find.pk) self.assertIsNotNone(find.cached_label) - op_code_idx, lbl = find.cached_label.split(' | ') - self.assertEqual(op_code_idx, 'OA1-00001') - self.assertEqual(lbl, 'Find me') + op_code_idx, lbl = find.cached_label.split(" | ") + self.assertEqual(op_code_idx, "OA1-00001") + self.assertEqual(lbl, "Find me") operation = models.Operation.objects.get(pk=operation.pk) - operation.code_patriarche = '666' + operation.code_patriarche = "666" operation.save() cr = ContextRecord.objects.get(pk=cr.pk) self.assertIsNotNone(cr.cached_label) - ope_id, parcel_sec, parcel_nb, cr_label = cr.cached_label.split(' | ') + ope_id, parcel_sec, parcel_nb, cr_label = cr.cached_label.split(" | ") - self.assertEqual(ope_id, '{}666'.format(profile.operation_prefix)) + self.assertEqual(ope_id, "{}666".format(profile.operation_prefix)) base_find = BaseFind.objects.get(pk=base_find.pk) self.assertIsNotNone(base_find.cache_short_id) - op_code, idx = base_find.cache_short_id.split(' | ') - self.assertEqual(op_code, 'OA666') + op_code, idx = base_find.cache_short_id.split(" | ") + self.assertEqual(op_code, "OA666") self.assertIsNotNone(base_find.cache_complete_id) - op_code, mat_code, lbl, idx = base_find.cache_complete_id.split(' | ') - self.assertEqual(op_code, 'OA666') + op_code, mat_code, lbl, idx = base_find.cache_complete_id.split(" | ") + self.assertEqual(op_code, "OA666") find = Find.objects.get(pk=find.pk) self.assertIsNotNone(find.cached_label) - op_code_idx, lbl = find.cached_label.split(' | ') - self.assertEqual(op_code_idx, 'OA666-00001') + op_code_idx, lbl = find.cached_label.split(" | ") + self.assertEqual(op_code_idx, "OA666-00001") def test_show(self): operation = self.operations[0] source = models.Document.objects.create( - title="Source title", - source_type=models.SourceType.objects.all()[0] + title="Source title", source_type=models.SourceType.objects.all()[0] ) operation.documents.add(source) c = Client() - response = c.get(reverse('show-operation', kwargs={'pk': operation.pk})) + response = c.get(reverse("show-operation", kwargs={"pk": operation.pk})) self.assertEqual(response.status_code, 200) # empty content when not allowed self.assertEqual(response.content, b"") - response = c.get(reverse('show-document', - kwargs={'pk': source.pk})) + response = c.get(reverse("show-document", kwargs={"pk": source.pk})) self.assertRedirects(response, "/") c.login(username=self.username, password=self.password) - response = c.get(reverse('show-operation', kwargs={'pk': operation.pk})) + response = c.get(reverse("show-operation", kwargs={"pk": operation.pk})) self.assertEqual(response.status_code, 200) self.assertIn(b'class="card sheet"', response.content) - response = c.get(reverse('show-document', - kwargs={'pk': source.pk})) + response = c.get(reverse("show-document", kwargs={"pk": source.pk})) self.assertEqual(response.status_code, 200) self.assertIn(b'class="card sheet"', response.content) @@ -1582,46 +2048,53 @@ class OperationTest(TestCase, OperationInitTest): operation.save() c.login(username=self.username, password=self.password) - response = c.get(reverse('show-operation', kwargs={'pk': operation.pk})) + response = c.get(reverse("show-operation", kwargs={"pk": operation.pk})) self.assertEqual(response.status_code, 200) self.assertIn(b'class="card sheet"', response.content) - self.assertIn(b'/show-historized-operation/', response.content) + self.assertIn(b"/show-historized-operation/", response.content) c.login(username=self.alt_username, password=self.alt_password) - response = c.get(reverse('show-operation', kwargs={'pk': operation.pk})) + response = c.get(reverse("show-operation", kwargs={"pk": operation.pk})) self.assertEqual(response.status_code, 200) self.assertIn(b'class="card sheet"', response.content) - self.assertNotIn(b'/show-historized-operation/', response.content) + self.assertNotIn(b"/show-historized-operation/", response.content) def test_show_pdf(self): operation = self.operations[0] c = Client() - response = c.get(reverse('show-operation', - kwargs={'pk': operation.pk, 'type': 'pdf'})) + response = c.get( + reverse("show-operation", kwargs={"pk": operation.pk, "type": "pdf"}) + ) self.assertEqual(response.status_code, 200) # empty content when not allowed self.assertEqual(response.content, b"") c.login(username=self.username, password=self.password) - response = c.get(reverse('show-operation', - kwargs={'pk': operation.pk, 'type': 'pdf'})) + response = c.get( + reverse("show-operation", kwargs={"pk": operation.pk, "type": "pdf"}) + ) self.assertEqual(response.status_code, 200) f = BytesIO(response.content) - filetype = Popen("/usr/bin/file -b --mime -", shell=True, stdout=PIPE, - stdin=PIPE).communicate(f.read(1024))[0].strip() - self.assertTrue(filetype.startswith(b'application/pdf')) + filetype = ( + Popen("/usr/bin/file -b --mime -", shell=True, stdout=PIPE, stdin=PIPE) + .communicate(f.read(1024))[0] + .strip() + ) + self.assertTrue(filetype.startswith(b"application/pdf")) def test_show_odt(self): - locale.setlocale(locale.LC_ALL, 'fr_FR.UTF-8') + locale.setlocale(locale.LC_ALL, "fr_FR.UTF-8") operation = self.operations[0] c = Client() - response = c.get(reverse('show-operation', - kwargs={'pk': operation.pk, 'type': 'odt'})) + response = c.get( + reverse("show-operation", kwargs={"pk": operation.pk, "type": "odt"}) + ) self.assertEqual(response.status_code, 200) # empty content when not allowed self.assertEqual(response.content, b"") c.login(username=self.username, password=self.password) - response = c.get(reverse('show-operation', kwargs={'pk': operation.pk, - 'type': 'odt'})) + response = c.get( + reverse("show-operation", kwargs={"pk": operation.pk, "type": "odt"}) + ) self.assertEqual(response.status_code, 200) f = BytesIO(response.content) z = zipfile.ZipFile(f) @@ -1629,12 +2102,12 @@ class OperationTest(TestCase, OperationInitTest): filename = None for name in z.namelist(): - if name == 'content.xml': + if name == "content.xml": filename = name break self.assertIsNotNone(filename) - tmpdir = tempfile.mkdtemp(prefix='tmp-ishtar-') + tmpdir = tempfile.mkdtemp(prefix="tmp-ishtar-") imported_file = z.extract(filename, tmpdir) with open(imported_file) as content_file: content = content_file.read() @@ -1645,34 +2118,45 @@ class OperationTest(TestCase, OperationInitTest): def test_json(self): operation = self.operations[0] - operation.data = {"groundhog": {"number": 53444, - "awake_state": "réveillée", - "with_feather": "Oui"}, - "frog_number": 32303} + operation.data = { + "groundhog": { + "number": 53444, + "awake_state": "réveillée", + "with_feather": "Oui", + }, + "frog_number": 32303, + } operation.save() content_type = ContentType.objects.get_for_model(operation) groundhog_section = JsonDataSection.objects.create( - name="Marmotte", content_type=content_type) - JsonDataField.objects.create(name="État d'éveil", - key='groundhog__awake_state', - content_type=content_type, - section=groundhog_section) - JsonDataField.objects.create(name="Avec plume", - key='groundhog__with_feather', - content_type=content_type, - section=groundhog_section) - JsonDataField.objects.create(name="Zzzzzzzz", - key='groundhog__zzz', - content_type=content_type, - section=groundhog_section) - JsonDataField.objects.create(name="Grenouille", - key='frog_number', - content_type=content_type) + name="Marmotte", content_type=content_type + ) + JsonDataField.objects.create( + name="État d'éveil", + key="groundhog__awake_state", + content_type=content_type, + section=groundhog_section, + ) + JsonDataField.objects.create( + name="Avec plume", + key="groundhog__with_feather", + content_type=content_type, + section=groundhog_section, + ) + JsonDataField.objects.create( + name="Zzzzzzzz", + key="groundhog__zzz", + content_type=content_type, + section=groundhog_section, + ) + JsonDataField.objects.create( + name="Grenouille", key="frog_number", content_type=content_type + ) c = Client() c.login(username=self.username, password=self.password) - response = c.get(reverse('show-operation', kwargs={'pk': operation.pk})) + response = c.get(reverse("show-operation", kwargs={"pk": operation.pk})) self.assertEqual(response.status_code, 200) content = response.content.decode() self.assertIn('class="card sheet"', content) @@ -1686,7 +2170,7 @@ class OperationTest(TestCase, OperationInitTest): operation.data = {} operation.save() - response = c.get(reverse('show-operation', kwargs={'pk': operation.pk})) + response = c.get(reverse("show-operation", kwargs={"pk": operation.pk})) self.assertEqual(response.status_code, 200) self.assertIn(b'class="card sheet"', response.content) self.assertNotIn(b"Marmotte", response.content) @@ -1694,30 +2178,33 @@ class OperationTest(TestCase, OperationInitTest): def test_json_search_vector_update(self): operation = self.operations[0] content_type = ContentType.objects.get_for_model(operation) - JsonDataField.objects.create(name="Nom de marmotte", - key='groundhog__name', - content_type=content_type, - search_index=True) - JsonDataField.objects.create(name="Numéro grenouille", - key='frog_number', - content_type=content_type) + JsonDataField.objects.create( + name="Nom de marmotte", + key="groundhog__name", + content_type=content_type, + search_index=True, + ) + JsonDataField.objects.create( + name="Numéro grenouille", key="frog_number", content_type=content_type + ) operation = models.Operation.objects.get(pk=operation.pk) - operation.data = {"groundhog": {"name": "La Marmotte héhé", - "color": "Red"}, - "frog_number": 32303} + operation.data = { + "groundhog": {"name": "La Marmotte héhé", "color": "Red"}, + "frog_number": 32303, + } operation.save() operation = models.Operation.objects.get(pk=operation.pk) self.assertIsNotNone(operation.search_vector) - for key in ('marmott',): + for key in ("marmott",): self.assertIn(key, operation.search_vector) - for key in ('32303', 'red', 'Red'): + for key in ("32303", "red", "Red"): self.assertNotIn(key, operation.search_vector) def test_document(self): operation = self.operations[0] - q = Document.objects.values('index').order_by('-index') + q = Document.objects.values("index").order_by("-index") if q.count(): - c_index = q.all()[0]['index'] + c_index = q.all()[0]["index"] else: c_index = 0 doc = Document.objects.create(title="Image!") @@ -1737,23 +2224,19 @@ class OperationTest(TestCase, OperationInitTest): Find = apps.get_model("archaeological_finds", "Find") BaseFind = apps.get_model("archaeological_finds", "BaseFind") Warehouse = apps.get_model("archaeological_warehouse", "Warehouse") - WarehouseType = apps.get_model("archaeological_warehouse", - "WarehouseType") + WarehouseType = apps.get_model("archaeological_warehouse", "WarehouseType") Container = apps.get_model("archaeological_warehouse", "Container") - ContainerType = apps.get_model("archaeological_warehouse", - "ContainerType") + ContainerType = apps.get_model("archaeological_warehouse", "ContainerType") operation = self.operations[0] - hc, __ = Unit.objects.get_or_create(txt_idx='not-in-context', order=10) - cr = ContextRecord.objects.create( - operation=operation, unit=hc) + hc, __ = Unit.objects.get_or_create(txt_idx="not-in-context", order=10) + cr = ContextRecord.objects.create(operation=operation, unit=hc) bf = BaseFind.objects.create(context_record=cr) f = Find.objects.create() f.base_finds.add(bf) - wt = WarehouseType.objects.create(label='WT') + wt = WarehouseType.objects.create(label="WT") w = Warehouse.objects.create(name="Warehouse", warehouse_type=wt) - ct = ContainerType.objects.create(label='CT') - c = Container.objects.create(reference="Test", location=w, - container_type=ct) + ct = ContainerType.objects.create(label="CT") + c = Container.objects.create(reference="Test", location=w, container_type=ct) f.container = c f.save() @@ -1765,8 +2248,7 @@ class LockTest(TestCase, OperationInitTest): fixtures = FILE_FIXTURES def setUp(self): - IshtarSiteProfile.objects.get_or_create( - slug='default', active=True) + IshtarSiteProfile.objects.get_or_create(slug="default", active=True) self.username, self.password, self.user = create_superuser() self.orgas = self.create_orgas(self.user) self.operations = self.create_operation(self.user, self.orgas[0]) @@ -1781,39 +2263,39 @@ class LockTest(TestCase, OperationInitTest): cls_wiz = OperationWizardModifTest() url = reverse(cls_wiz.url_name) # first wizard step - step = 'selec-operation_modification' + step = "selec-operation_modification" response = cls_wiz.wizard_post( - self.client, url, step, {'pk': self.operation.pk}) - msg = str(_("This item is locked for edition.") - ).replace("'", "'") - self.assertIn(msg, response.content.decode(), - msg="wizard lock for edition not effective") + self.client, url, step, {"pk": self.operation.pk} + ) + msg = str(_("This item is locked for edition.")).replace("'", "'") + self.assertIn( + msg, response.content.decode(), msg="wizard lock for edition not effective" + ) def test_qa_lock(self): - url = reverse('operation-qa-bulk-update', args=[self.operation.pk]) + url = reverse("operation-qa-bulk-update", args=[self.operation.pk]) response = self.client.get(url) - self.assertRedirects(response, reverse('qa-not-available', - args=["locked"])) + self.assertRedirects(response, reverse("qa-not-available", args=["locked"])) def test_sheet_lock(self): - url = reverse('show-operation', kwargs={'pk': self.operation.pk}) + url = reverse("show-operation", kwargs={"pk": self.operation.pk}) response = self.client.get(url) - msg = str(_("This item has been locked. Edition is disabled.") - ).replace("'", "\'") - self.assertIn(msg, response.content.decode(), - msg="lock not displayed on sheet") + msg = str(_("This item has been locked. Edition is disabled.")).replace( + "'", "'" + ) + self.assertIn(msg, response.content.decode(), msg="lock not displayed on sheet") class CustomFormTest(TestCase, OperationInitTest): fixtures = FILE_FIXTURES def setUp(self): - IshtarSiteProfile.objects.get_or_create( - slug='default', active=True) + IshtarSiteProfile.objects.get_or_create(slug="default", active=True) self.username, self.password, self.user = create_superuser() self.alt_username, self.alt_password, self.alt_user = create_user() - self.alt_user.user_permissions.add(Permission.objects.get( - codename='view_own_operation')) + self.alt_user.user_permissions.add( + Permission.objects.get(codename="view_own_operation") + ) self.orgas = self.create_orgas(self.user) self.operations = self.create_operation(self.user, self.orgas[0]) self.operations += self.create_operation(self.alt_user, self.orgas[0]) @@ -1826,42 +2308,46 @@ class CustomFormTest(TestCase, OperationInitTest): cls_wiz = OperationWizardModifTest() url = reverse(cls_wiz.url_name) # first wizard step - step = 'selec-operation_modification' - cls_wiz.wizard_post(c, url, step, {'pk': self.operations[0].pk}) + step = "selec-operation_modification" + cls_wiz.wizard_post(c, url, step, {"pk": self.operations[0].pk}) - step = 'general-operation_modification' + step = "general-operation_modification" data = { - '{}{}-current_step'.format(cls_wiz.url_name, - cls_wiz.wizard_name): [step], + "{}{}-current_step".format(cls_wiz.url_name, cls_wiz.wizard_name): [step], } - MSG_FOUND = " - '{}' field found on the modification "\ - "wizard. It should have been filtered." - MSG_NOT_FOUND = " - '{}' field not found on the modification "\ - "wizard. It shouldn't have been filtered." + MSG_FOUND = ( + " - '{}' field found on the modification " + "wizard. It should have been filtered." + ) + MSG_NOT_FOUND = ( + " - '{}' field not found on the modification " + "wizard. It shouldn't have been filtered." + ) key_in_charge = "in_charge" response = c.post(url, data) content = response.content.decode() res = key_in_charge in content - self.assertTrue(res, - msg="filter all" + MSG_NOT_FOUND.format(key_in_charge)) + self.assertTrue(res, msg="filter all" + MSG_NOT_FOUND.format(key_in_charge)) f = CustomForm.objects.create( - name="Test - all", form="operation-010-general", - available=True, apply_to_all=True) + name="Test - all", + form="operation-010-general", + available=True, + apply_to_all=True, + ) ExcludedField.objects.create(custom_form=f, field="in_charge") response = c.post(url, data) content = response.content.decode() res = key_in_charge not in content - self.assertTrue(res, - msg="filter all" + MSG_FOUND.format(key_in_charge)) + self.assertTrue(res, msg="filter all" + MSG_FOUND.format(key_in_charge)) # user type form prevail on "all" f_scientist = CustomForm.objects.create( - name="Test - user type", form="operation-010-general", - available=True) - tpe = PersonType.objects.get(txt_idx='head_scientist') + name="Test - user type", form="operation-010-general", available=True + ) + tpe = PersonType.objects.get(txt_idx="head_scientist") key_address = "address" f_scientist.user_types.add(tpe) self.user.ishtaruser.person.person_types.add(tpe) @@ -1871,60 +2357,53 @@ class CustomFormTest(TestCase, OperationInitTest): content = response.content.decode() res = key_in_charge in content self.assertTrue( - res, - msg="filter profile type" + MSG_NOT_FOUND.format(key_in_charge) + res, msg="filter profile type" + MSG_NOT_FOUND.format(key_in_charge) ) res = key_address not in content - self.assertTrue( - res, - msg="filter profile type" + MSG_FOUND.format(key_address)) + self.assertTrue(res, msg="filter profile type" + MSG_FOUND.format(key_address)) # profile type form prevail on "all" and "user types" f_scientist2 = CustomForm.objects.create( - name="Test - profile type", form="operation-010-general", - available=True) + name="Test - profile type", form="operation-010-general", available=True + ) key_scientific = "scientific_documentation_comment" - ExcludedField.objects.create(custom_form=f_scientist2, - field=key_scientific) + ExcludedField.objects.create(custom_form=f_scientist2, field=key_scientific) - collaborator = ProfileType.objects.get(txt_idx='collaborator') + collaborator = ProfileType.objects.get(txt_idx="collaborator") UserProfile.objects.create( - profile_type=collaborator, - person=self.user.ishtaruser.person, - current=True) + profile_type=collaborator, person=self.user.ishtaruser.person, current=True + ) f_scientist2.profile_types.add(collaborator) response = c.post(url, data) content = response.content.decode() res = key_in_charge in content self.assertTrue( - res, - msg="filter profile type" + MSG_NOT_FOUND.format(key_in_charge)) + res, msg="filter profile type" + MSG_NOT_FOUND.format(key_in_charge) + ) res = key_address in content self.assertTrue( - res, - msg="filter profile type" + MSG_NOT_FOUND.format(key_address)) + res, msg="filter profile type" + MSG_NOT_FOUND.format(key_address) + ) res = key_scientific not in content self.assertTrue( - res, - msg="filter profile type" + MSG_FOUND.format(key_scientific)) + res, msg="filter profile type" + MSG_FOUND.format(key_scientific) + ) # user prevail on "all", "profile_type" and "user_types" f_user = CustomForm.objects.create( - name="Test - user", form="operation-010-general", available=True) + name="Test - user", form="operation-010-general", available=True + ) f_user.users.add(self.user.ishtaruser) response = c.post(url, data) content = response.content.decode() res = key_in_charge in content - self.assertTrue(res, - msg="filter user" + MSG_NOT_FOUND.format(key_in_charge)) + self.assertTrue(res, msg="filter user" + MSG_NOT_FOUND.format(key_in_charge)) res = key_scientific in content - self.assertTrue(res, - msg="filter user" + MSG_NOT_FOUND.format(key_scientific)) + self.assertTrue(res, msg="filter user" + MSG_NOT_FOUND.format(key_scientific)) res = key_address in content - self.assertTrue(res, - msg="filter user" + MSG_FOUND.format(key_address)) + self.assertTrue(res, msg="filter user" + MSG_FOUND.format(key_address)) def test_enabled(self): c = Client() @@ -1933,37 +2412,47 @@ class CustomFormTest(TestCase, OperationInitTest): cls_wiz = OperationWizardModifTest() url = reverse(cls_wiz.url_name) # first wizard step - step = 'selec-operation_modification' - cls_wiz.wizard_post(c, url, step, {'pk': self.operations[0].pk}) + step = "selec-operation_modification" + cls_wiz.wizard_post(c, url, step, {"pk": self.operations[0].pk}) - step = 'collaborators-operation_modification' + step = "collaborators-operation_modification" data = { - '{}{}-current_step'.format(cls_wiz.url_name, - cls_wiz.wizard_name): [step], + "{}{}-current_step".format(cls_wiz.url_name, cls_wiz.wizard_name): [step], } response = c.post(url, data) self.assertNotEqual(response.status_code, 404) CustomForm.objects.create( - name="Test2", form="operation-020-collaborators", available=True, - apply_to_all=True, enabled=False) + name="Test2", + form="operation-020-collaborators", + available=True, + apply_to_all=True, + enabled=False, + ) response = c.post(url, data) self.assertEqual(response.status_code, 404) def test_json(self): operation = self.operations[0] - operation.data = {"groundhog": {"number": 53444, - "awake_state": "réveillée", - "with_feather": "Oui"}, - "frog_number": 32303} + operation.data = { + "groundhog": { + "number": 53444, + "awake_state": "réveillée", + "with_feather": "Oui", + }, + "frog_number": 32303, + } operation.save() content_type = ContentType.objects.get_for_model(operation) field = JsonDataField.objects.create( - name="État d'éveil", key='groundhog__awake_state', - content_type=content_type, value_type='C') + name="État d'éveil", + key="groundhog__awake_state", + content_type=content_type, + value_type="C", + ) form = CustomForm.objects.create( - name="Test", form="operation-010-general", available=True, - apply_to_all=True) + name="Test", form="operation-010-general", available=True, apply_to_all=True + ) CustomFormJsonField.objects.create( custom_form=form, json_field=field, @@ -1976,50 +2465,52 @@ class CustomFormTest(TestCase, OperationInitTest): cls_wiz = OperationWizardModifTest() url = reverse(cls_wiz.url_name) # first wizard step - step = 'selec-operation_modification' - cls_wiz.wizard_post(c, url, step, {'pk': self.operations[0].pk}) + step = "selec-operation_modification" + cls_wiz.wizard_post(c, url, step, {"pk": self.operations[0].pk}) - step = 'general-operation_modification' + step = "general-operation_modification" data = { - '{}{}-current_step'.format(cls_wiz.url_name, - cls_wiz.wizard_name): [step], + "{}{}-current_step".format(cls_wiz.url_name, cls_wiz.wizard_name): [step], } response = c.post(url, data) self.assertIn( - b"Le beau", response.content, - msg="json field not displayed on modification wizard" + b"Le beau", + response.content, + msg="json field not displayed on modification wizard", ) - cls_wiz.wizard_post(c, url, step, {'pk': self.operations[1].pk}) + cls_wiz.wizard_post(c, url, step, {"pk": self.operations[1].pk}) response = c.post(url, data) self.assertIn( - b"Le beau", response.content, - msg="json field form: existing value should be presented in select" + b"Le beau", + response.content, + msg="json field form: existing value should be presented in select", ) class OperationSearchTest(TestCase, OperationInitTest, SearchText): fixtures = FILE_FIXTURES - SEARCH_URL = 'get-operation' + SEARCH_URL = "get-operation" def setUp(self): - IshtarSiteProfile.objects.get_or_create( - slug='default', active=True) + IshtarSiteProfile.objects.get_or_create(slug="default", active=True) self.username, self.password, self.user = create_superuser() self.alt_username, self.alt_password, self.alt_user = create_user() - self.alt_user.user_permissions.add(Permission.objects.get( - codename='view_own_operation')) - self.alt_user.user_permissions.add(Permission.objects.get( - codename='change_own_operation')) + self.alt_user.user_permissions.add( + Permission.objects.get(codename="view_own_operation") + ) + self.alt_user.user_permissions.add( + Permission.objects.get(codename="change_own_operation") + ) self.alt_username2, self.alt_password2, self.alt_user2 = create_user( - username='luke', password='iamyourfather' + username="luke", password="iamyourfather" ) profile = UserProfile.objects.create( - profile_type=ProfileType.objects.get(txt_idx='collaborator'), - person=self.alt_user2.ishtaruser.person + profile_type=ProfileType.objects.get(txt_idx="collaborator"), + person=self.alt_user2.ishtaruser.person, ) - town = Town.objects.create(name='Tatouine', numero_insee='66000') - area = Area.objects.create(label='Galaxie', txt_idx='galaxie') + town = Town.objects.create(name="Tatouine", numero_insee="66000") + area = Area.objects.create(label="Galaxie", txt_idx="galaxie") area.towns.add(town) profile.areas.add(area) @@ -2033,23 +2524,22 @@ class OperationSearchTest(TestCase, OperationInitTest, SearchText): def test_base_search(self): c = Client() - response = c.get(reverse('get-operation'), {'year': '2010'}) + response = c.get(reverse("get-operation"), {"year": "2010"}) # no result when no authentication self.assertTrue(not json.loads(response.content.decode())) c.login(username=self.username, password=self.password) - response = c.get(reverse('get-operation'), {'year': '2010'}) - self.assertEqual(json.loads(response.content.decode())['recordsTotal'], - 2) + response = c.get(reverse("get-operation"), {"year": "2010"}) + self.assertEqual(json.loads(response.content.decode())["recordsTotal"], 2) response = c.get( - reverse('get-operation'), - {pgettext_lazy("key for text search", "operator"): - self.orgas[0].name}) + reverse("get-operation"), + {pgettext_lazy("key for text search", "operator"): self.orgas[0].name}, + ) result = json.loads(response.content.decode()) - self.assertEqual(result['recordsTotal'], 3) + self.assertEqual(result["recordsTotal"], 3) def test_base_search_vector(self): c = Client() - response = c.get(reverse('get-operation'), {'search_vector': 'chaTEAU'}) + response = c.get(reverse("get-operation"), {"search_vector": "chaTEAU"}) # no result when no authentication self.assertTrue(not json.loads(response.content.decode())) c.login(username=self.username, password=self.password) @@ -2057,17 +2547,16 @@ class OperationSearchTest(TestCase, OperationInitTest, SearchText): operation = models.Operation.objects.get(pk=self.operations[0].pk) operation.common_name = "Opération : Château de Fougères" operation.save() - response = c.get(reverse('get-operation'), {'search_vector': 'chaTEAU'}) + response = c.get(reverse("get-operation"), {"search_vector": "chaTEAU"}) result = json.loads(response.content.decode()) - self.assertEqual(result['recordsTotal'], 1) - response = c.get(reverse('get-operation'), {'search_vector': 'château'}) + self.assertEqual(result["recordsTotal"], 1) + response = c.get(reverse("get-operation"), {"search_vector": "château"}) result = json.loads(response.content.decode()) - self.assertEqual(result['recordsTotal'], 1) + self.assertEqual(result["recordsTotal"], 1) # test search with inappropriate minus sign - response = c.get(reverse('get-operation'), - {'search_vector': 'chaTEAU - '}) + response = c.get(reverse("get-operation"), {"search_vector": "chaTEAU - "}) result = json.loads(response.content.decode()) - self.assertEqual(result['recordsTotal'], 1) + self.assertEqual(result["recordsTotal"], 1) def test_complex_search_vector(self): c = Client() @@ -2077,33 +2566,34 @@ class OperationSearchTest(TestCase, OperationInitTest, SearchText): operation_3 = models.Operation.objects.get(pk=self.operations[2].pk) operation_1.common_name = "Opération : Château de Fougères" operation_1.save() - operation_2.common_name = "Opération : Fougère filicophyta et " \ - "herbe à chat" + operation_2.common_name = "Opération : Fougère filicophyta et " "herbe à chat" operation_2.save() operation_3.common_name = "Opération : Château Filicophyta" operation_3.save() # simple separation - response = c.get(reverse('get-operation'), - {'search_vector': 'chaTEAU fougeres'}) + response = c.get( + reverse("get-operation"), {"search_vector": "chaTEAU fougeres"} + ) result = json.loads(response.content.decode()) - self.assertEqual(result['recordsTotal'], 1) - response = c.get(reverse('get-operation'), - {'search_vector': 'chaTEAU fougere'}) + self.assertEqual(result["recordsTotal"], 1) + response = c.get(reverse("get-operation"), {"search_vector": "chaTEAU fougere"}) result = json.loads(response.content.decode()) - self.assertEqual(result['recordsTotal'], 1) + self.assertEqual(result["recordsTotal"], 1) # explicit AND - response = c.get(reverse('get-operation'), - {'search_vector': 'chaTEAU & fougere'}) + response = c.get( + reverse("get-operation"), {"search_vector": "chaTEAU & fougere"} + ) result = json.loads(response.content.decode()) - self.assertEqual(result['recordsTotal'], 1) + self.assertEqual(result["recordsTotal"], 1) # explicit OR - response = c.get(reverse('get-operation'), - {'search_vector': 'chaTEAU | fougere'}) + response = c.get( + reverse("get-operation"), {"search_vector": "chaTEAU | fougere"} + ) result = json.loads(response.content.decode()) - self.assertEqual(result['recordsTotal'], 3) + self.assertEqual(result["recordsTotal"], 3) # query with parenthesis # response = c.get(reverse('get-operation'), @@ -2112,21 +2602,22 @@ class OperationSearchTest(TestCase, OperationInitTest, SearchText): # self.assertEqual(result['recordsTotal'], 2) # query with mistmatch parenthesis - response = c.get(reverse('get-operation'), - {'search_vector': ')) 2010 &) ((chaTEAU | fougere)'}) + response = c.get( + reverse("get-operation"), + {"search_vector": ")) 2010 &) ((chaTEAU | fougere)"}, + ) result = json.loads(response.content.decode()) - self.assertEqual(result['recordsTotal'], 2) + self.assertEqual(result["recordsTotal"], 2) # open search - response = c.get(reverse('get-operation'), {'search_vector': 'cha*'}) + response = c.get(reverse("get-operation"), {"search_vector": "cha*"}) result = json.loads(response.content.decode()) - self.assertEqual(result['recordsTotal'], 3) + self.assertEqual(result["recordsTotal"], 3) # exclude - response = c.get(reverse('get-operation'), - {'search_vector': '-fougere'}) + response = c.get(reverse("get-operation"), {"search_vector": "-fougere"}) result = json.loads(response.content.decode()) - self.assertEqual(result['recordsTotal'], 1) + self.assertEqual(result["recordsTotal"], 1) def test_facet_search_vector(self): ope1 = self.operations[0] @@ -2141,13 +2632,13 @@ class OperationSearchTest(TestCase, OperationInitTest, SearchText): ope2.year = 2020 ope2.save() - data = {'numero_insee': '05000', 'name': 'Champoleon (test)'} + data = {"numero_insee": "05000", "name": "Champoleon (test)"} town = self.create_towns(datas=data)[-1] ope1.towns.add(town) - neo = models.Period.objects.get(txt_idx='neolithic') - final_neo = models.Period.objects.get(txt_idx='final-neolithic') + neo = models.Period.objects.get(txt_idx="neolithic") + final_neo = models.Period.objects.get(txt_idx="final-neolithic") gallo = models.Period.objects.get(txt_idx="gallo-roman") ope1.periods.add(final_neo) @@ -2155,7 +2646,7 @@ class OperationSearchTest(TestCase, OperationInitTest, SearchText): ope2.periods.add(neo) ope3.periods.add(gallo) - villa = models.RemainType.objects.get(txt_idx='villa') + villa = models.RemainType.objects.get(txt_idx="villa") ope1.remains.add(villa) search_period_q = str(pgettext("key for text search", "period")) @@ -2180,8 +2671,7 @@ class OperationSearchTest(TestCase, OperationInitTest, SearchText): result = [ ('{}="{}"'.format(search_town_q, town.cached_label), 1), ] - self._test_search(c, result, - context="String search with parenthesis and minus") + self._test_search(c, result, context="String search with parenthesis and minus") result = [ ('{}="{}"'.format(search_period_q, str(neo)), 2), ] @@ -2193,10 +2683,18 @@ class OperationSearchTest(TestCase, OperationInitTest, SearchText): self._test_search(c, result, context="Period exclude") result = [ - ('{}="{}"'.format(search_period_q, - '{}";"{}'.format(neo.label, gallo.label)), 3), - ('{}="{}" {}="{}"'.format(search_period_q, neo.label, - search_period_q, gallo.label), 3), + ( + '{}="{}"'.format( + search_period_q, '{}";"{}'.format(neo.label, gallo.label) + ), + 3, + ), + ( + '{}="{}" {}="{}"'.format( + search_period_q, neo.label, search_period_q, gallo.label + ), + 3, + ), ] self._test_search(c, result, context="Period OR") @@ -2215,8 +2713,7 @@ class OperationSearchTest(TestCase, OperationInitTest, SearchText): result = [ ('{}="{}"'.format(search_remain_q, str(villa)), 1), ] - self._test_search(c, result, - context="Non hierarchic remain search") + self._test_search(c, result, context="Non hierarchic remain search") # boolean search search_open_q = str(pgettext("key for text search", "is-open")) @@ -2236,20 +2733,25 @@ class OperationSearchTest(TestCase, OperationInitTest, SearchText): search_year_q = str(pgettext("key for text search", "year")) q = '"chateau fougere" {}="2042"'.format(search_year_q) - response = c.get(reverse('get-operation'), {'search_vector': q}) + response = c.get(reverse("get-operation"), {"search_vector": q}) result = json.loads(response.content.decode()) - self.assertEqual(result['recordsTotal'], 1) + self.assertEqual(result["recordsTotal"], 1) def create_relations(self): rel1 = models.RelationType.objects.create( - symmetrical=True, label='Include', txt_idx='include') + symmetrical=True, label="Include", txt_idx="include" + ) rel2 = models.RelationType.objects.create( - symmetrical=False, label='Included', txt_idx='included', - inverse_relation=rel1) + symmetrical=False, + label="Included", + txt_idx="included", + inverse_relation=rel1, + ) models.RecordRelations.objects.create( left_record=self.operations[0], right_record=self.operations[1], - relation_type=rel1) + relation_type=rel1, + ) return rel1, rel2 def test_related_search(self): @@ -2258,17 +2760,13 @@ class OperationSearchTest(TestCase, OperationInitTest, SearchText): self.operations[1].year = 2011 self.operations[1].save() reltype_key = pgettext_lazy("key for text search", "relation-types") - search = { - 'search_vector': 'year=2010 {}="{}"'.format( - reltype_key, rel2.name) - } - response = c.get(reverse('get-operation'), search) + search = {"search_vector": 'year=2010 {}="{}"'.format(reltype_key, rel2.name)} + response = c.get(reverse("get-operation"), search) # no result when no authentication self.assertTrue(not json.loads(response.content.decode())) c.login(username=self.username, password=self.password) - response = c.get(reverse('get-operation'), search) - self.assertEqual(json.loads(response.content.decode())['recordsTotal'], - 2) + response = c.get(reverse("get-operation"), search) + self.assertEqual(json.loads(response.content.decode())["recordsTotal"], 2) def test_search_with_problematic_characters(self): c = Client() @@ -2281,63 +2779,59 @@ class OperationSearchTest(TestCase, OperationInitTest, SearchText): result = [ ('{}="{}"'.format(search_name_q, lbl), 1), ] - self._test_search(c, result, - context="Facet search with = and | characters") + self._test_search(c, result, context="Facet search with = and | characters") def test_search_with_asterisk_inside_names(self): c = Client() c.login(username=self.username, password=self.password) ope = self.operations[0] ope_type = ope.operation_type - ope_type.label = 'label*with*asterisk' + ope_type.label = "label*with*asterisk" ope_type.save() search_name_q = str(pgettext("key for text search", "type")) nb = models.Operation.objects.filter(operation_type=ope_type).count() result = [ ('{}="{}"'.format(search_name_q, ope_type.label), nb), ] - self._test_search(c, result, - context="Facet search with * characters") + self._test_search(c, result, context="Facet search with * characters") def test_hierarchic_search(self): ope = self.operations[1] c = Client() - neo = models.Period.objects.get(txt_idx='neolithic') - final_neo = models.Period.objects.get(txt_idx='final-neolithic') - recent_neo = models.Period.objects.get(txt_idx='recent-neolithic') + neo = models.Period.objects.get(txt_idx="neolithic") + final_neo = models.Period.objects.get(txt_idx="final-neolithic") + recent_neo = models.Period.objects.get(txt_idx="recent-neolithic") ope.periods.add(final_neo) - search = {'periods': final_neo.pk} + search = {"periods": final_neo.pk} # no result when no authentication - response = c.get(reverse('get-operation'), search) + response = c.get(reverse("get-operation"), search) self.assertEqual(response.status_code, 200) self.assertTrue(not json.loads(response.content.decode())) c.login(username=self.username, password=self.password) # one result for exact search - response = c.get(reverse('get-operation'), search) + response = c.get(reverse("get-operation"), search) self.assertEqual(response.status_code, 200) res = json.loads(response.content.decode()) - self.assertTrue(res['recordsTotal'] == 1) + self.assertTrue(res["recordsTotal"] == 1) # no result for the brother - search = {'periods': recent_neo.pk} - response = c.get(reverse('get-operation'), search) + search = {"periods": recent_neo.pk} + response = c.get(reverse("get-operation"), search) self.assertEqual(response.status_code, 200) - self.assertEqual(json.loads(response.content.decode())['recordsTotal'], - 0) + self.assertEqual(json.loads(response.content.decode())["recordsTotal"], 0) # one result for the father - search = {'periods': neo.pk} - response = c.get(reverse('get-operation'), search) + search = {"periods": neo.pk} + response = c.get(reverse("get-operation"), search) self.assertEqual(response.status_code, 200) - self.assertEqual(json.loads(response.content.decode())['recordsTotal'], - 1) + self.assertEqual(json.loads(response.content.decode())["recordsTotal"], 1) # test on text search - period_key = str(pgettext_lazy("key for text search", 'period')) + period_key = str(pgettext_lazy("key for text search", "period")) result = [ ('{}="{}"'.format(period_key, str(final_neo)), 1), ('{}="{}"'.format(period_key, str(recent_neo)), 0), @@ -2349,14 +2843,14 @@ class OperationSearchTest(TestCase, OperationInitTest, SearchText): c = Client() c.login(username=self.username, password=self.password) - data = {'numero_insee': '98989', 'name': 'base_town'} + data = {"numero_insee": "98989", "name": "base_town"} base_town = self.create_towns(datas=data)[-1] - data = {'numero_insee': '56789', 'name': 'parent_town'} + data = {"numero_insee": "56789", "name": "parent_town"} parent_town = self.create_towns(datas=data)[-1] parent_town.children.add(base_town) - data = {'numero_insee': '01234', 'name': 'child_town'} + data = {"numero_insee": "01234", "name": "child_town"} child_town = self.create_towns(datas=data)[-1] base_town.children.add(child_town) @@ -2364,32 +2858,28 @@ class OperationSearchTest(TestCase, OperationInitTest, SearchText): ope.towns.add(base_town) # simple search - search = {'towns': base_town.pk} - response = c.get(reverse('get-operation'), search) + search = {"towns": base_town.pk} + response = c.get(reverse("get-operation"), search) self.assertEqual(response.status_code, 200) - self.assertEqual(json.loads(response.content.decode())['recordsTotal'], - 1) + self.assertEqual(json.loads(response.content.decode())["recordsTotal"], 1) # parent search - search = {'towns': parent_town.pk} - response = c.get(reverse('get-operation'), search) + search = {"towns": parent_town.pk} + response = c.get(reverse("get-operation"), search) self.assertEqual(response.status_code, 200) - self.assertEqual(json.loads(response.content.decode())['recordsTotal'], - 1) + self.assertEqual(json.loads(response.content.decode())["recordsTotal"], 1) # child search - search = {'towns': child_town.pk} - response = c.get(reverse('get-operation'), search) + search = {"towns": child_town.pk} + response = c.get(reverse("get-operation"), search) self.assertEqual(response.status_code, 200) - self.assertEqual(json.loads(response.content.decode())['recordsTotal'], - 1) + self.assertEqual(json.loads(response.content.decode())["recordsTotal"], 1) def test_statistics(self): c = Client() c.login(username=self.username, password=self.password) - q = {"stats_modality_1": "year", - "stats_modality_2": "operation_type__label"} - response = c.get(reverse('get-operation', args=['json-stats']), q) + q = {"stats_modality_1": "year", "stats_modality_2": "operation_type__label"} + response = c.get(reverse("get-operation", args=["json-stats"]), q) self.assertEqual(response.status_code, 200) expected_result = [] @@ -2411,32 +2901,33 @@ class OperationSearchTest(TestCase, OperationInitTest, SearchText): current_values[val_idx][1] += 1 values = json.loads(response.content.decode()) - self.assertEqual(values['data'], expected_result) + self.assertEqual(values["data"], expected_result) class OperationPermissionTest(TestCase, OperationInitTest): fixtures = FILE_FIXTURES def setUp(self): - IshtarSiteProfile.objects.get_or_create( - slug='default', active=True) + IshtarSiteProfile.objects.get_or_create(slug="default", active=True) self.username, self.password, self.user = create_superuser() self.alt_username, self.alt_password, self.alt_user = create_user() - self.alt_user.user_permissions.add(Permission.objects.get( - codename='view_own_operation')) - self.alt_user.user_permissions.add(Permission.objects.get( - codename='change_own_operation')) + self.alt_user.user_permissions.add( + Permission.objects.get(codename="view_own_operation") + ) + self.alt_user.user_permissions.add( + Permission.objects.get(codename="change_own_operation") + ) self.alt_username2, self.alt_password2, self.alt_user2 = create_user( - username='luke', password='iamyourfather' + username="luke", password="iamyourfather" ) - profile_type = ProfileType.objects.get(txt_idx='collaborator') + profile_type = ProfileType.objects.get(txt_idx="collaborator") profile = UserProfile.objects.create( profile_type=profile_type, person=self.alt_user2.ishtaruser.person, - current=True + current=True, ) - town = Town.objects.create(name='Tatouine', numero_insee='66000') - area = Area.objects.create(label='Galaxie', txt_idx='galaxie') + town = Town.objects.create(name="Tatouine", numero_insee="66000") + area = Area.objects.create(label="Galaxie", txt_idx="galaxie") area.towns.add(town) profile.areas.add(area) @@ -2449,86 +2940,76 @@ class OperationPermissionTest(TestCase, OperationInitTest): def test_own_search(self): # no result when no authentification c = Client() - response = c.get(reverse('get-operation'), {'year': '2010'}) + response = c.get(reverse("get-operation"), {"year": "2010"}) self.assertTrue(not json.loads(response.content.decode())) # possession c = Client() c.login(username=self.alt_username, password=self.alt_password) - response = c.get(reverse('get-operation'), {'year': '2010'}) + response = c.get(reverse("get-operation"), {"year": "2010"}) # only one "own" operation available self.assertTrue(json.loads(response.content.decode())) - self.assertEqual(json.loads(response.content.decode())['recordsTotal'], - 1) + self.assertEqual(json.loads(response.content.decode())["recordsTotal"], 1) operator_key = pgettext_lazy("key for text search", "operator") - response = c.get(reverse('get-operation'), - {operator_key: self.orgas[0].name}) - self.assertEqual(json.loads(response.content.decode())['recordsTotal'], - 1) - response = c.get(reverse('get-operation'), - {'search_vector': '{}="{}"'.format( - operator_key, self.orgas[0].name)}) - self.assertEqual(json.loads(response.content.decode())['recordsTotal'], - 1) + response = c.get(reverse("get-operation"), {operator_key: self.orgas[0].name}) + self.assertEqual(json.loads(response.content.decode())["recordsTotal"], 1) + response = c.get( + reverse("get-operation"), + {"search_vector": '{}="{}"'.format(operator_key, self.orgas[0].name)}, + ) + self.assertEqual(json.loads(response.content.decode())["recordsTotal"], 1) # area filter c = Client() c.login(username=self.alt_username2, password=self.alt_password2) - response = c.get(reverse('get-operation'), - {'year': '2010'}) + response = c.get(reverse("get-operation"), {"year": "2010"}) # only one "own" operation available self.assertTrue(json.loads(response.content.decode())) - self.assertEqual(json.loads(response.content.decode())['recordsTotal'], - 1) - response = c.get(reverse('get-operation'), - {operator_key: self.orgas[0].name}) - self.assertEqual(json.loads(response.content.decode())['recordsTotal'], - 1) - response = c.get(reverse('get-operation'), - {'search_vector': '{}="{}"'.format( - operator_key, self.orgas[0].name)}) - self.assertEqual(json.loads(response.content.decode())['recordsTotal'], - 1) + self.assertEqual(json.loads(response.content.decode())["recordsTotal"], 1) + response = c.get(reverse("get-operation"), {operator_key: self.orgas[0].name}) + self.assertEqual(json.loads(response.content.decode())["recordsTotal"], 1) + response = c.get( + reverse("get-operation"), + {"search_vector": '{}="{}"'.format(operator_key, self.orgas[0].name)}, + ) + self.assertEqual(json.loads(response.content.decode())["recordsTotal"], 1) def test_own_modify(self): operation_pk1 = self.operations[0].pk operation_pk2 = self.operations[1].pk - modif_url = '/operation_modification/general-operation_modification' + modif_url = "/operation_modification/general-operation_modification" # no result when no authentification c = Client() - response = c.get(reverse('operation_modify', args=[operation_pk2])) + response = c.get(reverse("operation_modify", args=[operation_pk2])) self.assertRedirects(response, "/") # possession c = Client() c.login(username=self.alt_username, password=self.alt_password) - response = c.get(reverse('operation_modify', args=[operation_pk2]), - follow=True) + response = c.get(reverse("operation_modify", args=[operation_pk2]), follow=True) self.assertRedirects(response, modif_url) response = c.get(modif_url) self.assertEqual(response.status_code, 200) - response = c.get(reverse('operation_modify', args=[operation_pk1]), - follow=True) + response = c.get(reverse("operation_modify", args=[operation_pk1]), follow=True) self.assertRedirects(response, "/") - profile_type = ProfileType.objects.get(txt_idx='collaborator') + profile_type = ProfileType.objects.get(txt_idx="collaborator") profile_type.groups.add( - Group.objects.get(name="Opérations rattachées : " - "modification/suppression") + Group.objects.get( + name="Opérations rattachées : " "modification/suppression" + ) ) # area filter c = Client() c.login(username=self.alt_username2, password=self.alt_password2) - response = c.get(reverse('operation_modify', args=[operation_pk2]), - follow=True) + response = c.get(reverse("operation_modify", args=[operation_pk2]), follow=True) self.assertRedirects(response, modif_url) response = c.get(modif_url) self.assertEqual(response.status_code, 200) - response = c.get(reverse('operation_modify', args=[operation_pk1]), - follow=True) + response = c.get(reverse("operation_modify", args=[operation_pk1]), follow=True) self.assertRedirects(response, "/") @@ -2536,8 +3017,7 @@ class LabelTest(TestCase, OperationInitTest): fixtures = FILE_FIXTURES def setUp(self): - IshtarSiteProfile.objects.get_or_create( - slug='default', active=True) + IshtarSiteProfile.objects.get_or_create(slug="default", active=True) self.username, self.password, self.user = create_superuser() self.orgas = self.create_orgas(self.user) self.operations = self.create_operation(self.user, self.orgas[0]) @@ -2548,12 +3028,11 @@ class LabelTest(TestCase, OperationInitTest): ope.save() tpl = open( - settings.ROOT_PATH + - '../archaeological_operations/tests/labels-8.odt', - 'rb') + settings.ROOT_PATH + "../archaeological_operations/tests/labels-8.odt", "rb" + ) template = SimpleUploadedFile(tpl.name, tpl.read()) model, __ = ImporterModel.objects.get_or_create( - klass='archaeological_operations.models.Operation' + klass="archaeological_operations.models.Operation" ) doc = DocumentTemplate.objects.create( name="Labels", @@ -2562,7 +3041,7 @@ class LabelTest(TestCase, OperationInitTest): available=True, for_labels=True, label_per_page=8, - template=template + template=template, ) c = Client() url = reverse("generate-labels", args=[doc.slug]) @@ -2577,9 +3056,9 @@ class LabelTest(TestCase, OperationInitTest): f = BytesIO(response.content) z = zipfile.ZipFile(f) self.assertIsNone(z.testzip()) - content = z.open('content.xml') + content = z.open("content.xml") full_content = content.read() - self.assertIn(b'1789', full_content) + self.assertIn(b"1789", full_content) # jpe file are added for missing pictures / must be filtered self.assertNotIn(b'.jpe"', full_content) finally: @@ -2595,14 +3074,13 @@ class DashboardTest(TestCase, OperationInitTest): fixtures = FILE_FIXTURES def setUp(self): - IshtarSiteProfile.objects.get_or_create( - slug='default', active=True) + IshtarSiteProfile.objects.get_or_create(slug="default", active=True) self.username, self.password, self.user = create_superuser() self.orgas = self.create_orgas(self.user) self.operations = self.create_operation(self.user, self.orgas[0]) def test_dashboard(self): - url = 'dashboard-operation' + url = "dashboard-operation" c = Client() c.login(username=self.username, password=self.password) @@ -2612,12 +3090,15 @@ class DashboardTest(TestCase, OperationInitTest): def create_administrativact(user, operation): act_type, created = models.ActType.objects.get_or_create( - txt_idx='act_type_O', intented_to='O') - dct = {'history_modifier': user, - 'act_type': act_type, - 'operation': operation, - 'signature_date': datetime.date(2014, 5, 12), - 'index': 322} + txt_idx="act_type_O", intented_to="O" + ) + dct = { + "history_modifier": user, + "act_type": act_type, + "operation": operation, + "signature_date": datetime.date(2014, 5, 12), + "index": 322, + } adminact, created = models.AdministrativeAct.objects.get_or_create(**dct) return [act_type], [adminact] @@ -2629,53 +3110,53 @@ class RegisterTest(TestCase, OperationInitTest): self.username, self.password, self.user = create_superuser() self.operations = self.create_operation(self.user) self.act_types, self.admin_acts = create_administrativact( - self.user, self.operations[0]) + self.user, self.operations[0] + ) def test_search(self): c = Client() - response = c.get(reverse('get-administrativeact'), {'year': '2014'}) + response = c.get(reverse("get-administrativeact"), {"year": "2014"}) # no result when no authentication self.assertTrue(not json.loads(response.content.decode())) c.login(username=self.username, password=self.password) - response = c.get(reverse('get-administrativeact'), {'year': '2014'}) - self.assertEqual( - json.loads(response.content.decode())['recordsTotal'], 1) - response = c.get(reverse('get-administrativeact'), {'indexed': '2'}) - self.assertEqual( - json.loads(response.content.decode())['recordsTotal'], 1) + response = c.get(reverse("get-administrativeact"), {"year": "2014"}) + self.assertEqual(json.loads(response.content.decode())["recordsTotal"], 1) + response = c.get(reverse("get-administrativeact"), {"indexed": "2"}) + self.assertEqual(json.loads(response.content.decode())["recordsTotal"], 1) def test_document_generation(self): tpl = open( - settings.ROOT_PATH + - '../archaeological_operations/tests/document_reference.odt', - 'rb') + settings.ROOT_PATH + + "../archaeological_operations/tests/document_reference.odt", + "rb", + ) template = SimpleUploadedFile(tpl.name, tpl.read()) model, __ = ImporterModel.objects.get_or_create( - klass='archaeological_operations.models.AdministrativeAct' + klass="archaeological_operations.models.AdministrativeAct" ) doc = DocumentTemplate.objects.create( name="Test", slug=True, associated_model=model, available=True, - template=template + template=template, ) self.act_types[0].associated_template.add(doc) c = Client() - data = {'pk': self.admin_acts[0].pk, 'document_template': doc.pk} - response = c.post(reverse('operation-administrativeact-document'), data) + data = {"pk": self.admin_acts[0].pk, "document_template": doc.pk} + response = c.post(reverse("operation-administrativeact-document"), data) # no result when no authentication self.assertEqual(response.content, b"") c.login(username=self.username, password=self.password) - response = c.post(reverse('operation-administrativeact-document'), data) + response = c.post(reverse("operation-administrativeact-document"), data) content, z, f = None, None, None try: f = BytesIO(response.content) z = zipfile.ZipFile(f) self.assertIsNone(z.testzip()) - content = z.open('content.xml') - self.assertIn(b'2014-05-12', content.read()) + content = z.open("content.xml") + self.assertIn(b"2014-05-12", content.read()) finally: if content: content.close() @@ -2687,204 +3168,209 @@ class RegisterTest(TestCase, OperationInitTest): class OperationWizardCreationTest(WizardTest, OperationInitTest, TestCase): fixtures = FILE_FIXTURES - url_name = 'operation_creation' - wizard_name = 'operation_wizard' + url_name = "operation_creation" + wizard_name = "operation_wizard" steps = views.wizard_steps - redirect_url = "/operation_modification/selec-operation_modification"\ - "?open_item={last_id}" + redirect_url = ( + "/operation_modification/selec-operation_modification" "?open_item={last_id}" + ) model = models.Operation form_datas = [ FormData( "Create a preventive diag", form_datas={ - 'filechoice': {}, - 'general': { - 'code_patriarche': 'codeope1', - 'operation_type': None, - 'year': 2016}, - 'townsgeneral': [], - 'parcelsgeneral': [], + "filechoice": {}, + "general": { + "code_patriarche": "codeope1", + "operation_type": None, + "year": 2016, + }, + "townsgeneral": [], + "parcelsgeneral": [], }, - ignored=('towns-operation_creation', - 'parcels-operation_creation', - 'judiciary-operation_creation', - 'preventive-operation_creation') + ignored=( + "towns-operation_creation", + "parcels-operation_creation", + "judiciary-operation_creation", + "preventive-operation_creation", + ), ), FormData( "Create another preventive diag with same parcel name", form_datas={ - 'filechoice': {}, - 'general': { - 'code_patriarche': 'codeope2', - 'operation_type': None, - 'year': 2016}, - 'townsgeneral': [], - 'parcelsgeneral': [], + "filechoice": {}, + "general": { + "code_patriarche": "codeope2", + "operation_type": None, + "year": 2016, + }, + "townsgeneral": [], + "parcelsgeneral": [], }, - ignored=('towns-operation_creation', - 'parcels-operation_creation', - 'judiciary-operation_creation', - 'preventive-operation_creation') + ignored=( + "towns-operation_creation", + "parcels-operation_creation", + "judiciary-operation_creation", + "preventive-operation_creation", + ), ), FormData( "Create an operation related to a file", form_datas={ - 'filechoice': {}, - 'general': { - 'code_patriarche': 'codeope3', - 'operation_type': None, - 'year': 2016}, - 'towns': [], - 'parcels': [], + "filechoice": {}, + "general": { + "code_patriarche": "codeope3", + "operation_type": None, + "year": 2016, + }, + "towns": [], + "parcels": [], }, - ignored=('townsgeneral-operation_creation', - 'parcelsgeneral-operation_creation', - 'judiciary-operation_creation', - 'preventive-operation_creation') + ignored=( + "townsgeneral-operation_creation", + "parcelsgeneral-operation_creation", + "judiciary-operation_creation", + "preventive-operation_creation", + ), ), ] def pre_wizard(self): profile, created = IshtarSiteProfile.objects.get_or_create( - slug='default', active=True) + slug="default", active=True + ) profile.files = True profile.save() - if 'townsgeneral' not in \ - self.form_datas[0].form_datas: + if "townsgeneral" not in self.form_datas[0].form_datas: return super(OperationWizardCreationTest, self).pre_wizard() town = self.create_towns()[0] - town_data = {'town': town.pk} + town_data = {"town": town.pk} parcel_data = { - 'town': town.pk, 'year': 2017, 'section': 'S', - 'parcel_number': '42'} + "town": town.pk, + "year": 2017, + "section": "S", + "parcel_number": "42", + } for idx in range(2): - self.form_datas[idx].append('townsgeneral', town_data) - self.form_datas[idx].append('parcelsgeneral', parcel_data) + self.form_datas[idx].append("townsgeneral", town_data) + self.form_datas[idx].append("parcelsgeneral", parcel_data) FI = FileInit() FI.create_file() file = FI.item file.towns.add(town) parcel = models.Parcel.objects.create( - town=town, year=2017, section='G', parcel_number='43' + town=town, year=2017, section="G", parcel_number="43" ) file.parcels.add(parcel) - self.form_datas[2].set('filechoice', 'associated_file', file.pk) - self.form_datas[2].append('parcelsgeneral', {'parcel': parcel.pk}) - self.form_datas[2].append('towns', town_data) - self.form_datas[2].append('parcels', {'parcel': parcel.pk}) + self.form_datas[2].set("filechoice", "associated_file", file.pk) + self.form_datas[2].append("parcelsgeneral", {"parcel": parcel.pk}) + self.form_datas[2].append("towns", town_data) + self.form_datas[2].append("parcels", {"parcel": parcel.pk}) # diagnostic - ope_type = models.OperationType.objects.get(txt_idx='arch_diagnostic') - self.form_datas[0].set('general', 'operation_type', ope_type.pk) - self.form_datas[1].set('general', 'operation_type', ope_type.pk) - self.form_datas[2].set('general', 'operation_type', ope_type.pk) + ope_type = models.OperationType.objects.get(txt_idx="arch_diagnostic") + self.form_datas[0].set("general", "operation_type", ope_type.pk) + self.form_datas[1].set("general", "operation_type", ope_type.pk) + self.form_datas[2].set("general", "operation_type", ope_type.pk) self.operation_number = models.Operation.objects.count() self.parcel_number = models.Parcel.objects.count() super(OperationWizardCreationTest, self).pre_wizard() def post_wizard(self): - self.assertEqual(models.Operation.objects.count(), - self.operation_number + 3) + self.assertEqual(models.Operation.objects.count(), self.operation_number + 3) operations = models.Operation.objects.order_by("-pk").all()[:3] parcel_ids = [] for operation in operations: for parcel in operation.parcels.all(): parcel_ids.append(parcel.external_id) - self.assertEqual(list(sorted(parcel_ids)), - ['codeope1-12345-S42', 'codeope2-12345-S42', - 'codeope3-12345-G43']) - self.assertEqual(models.Parcel.objects.count(), - self.parcel_number + 3) + self.assertEqual( + list(sorted(parcel_ids)), + ["codeope1-12345-S42", "codeope2-12345-S42", "codeope3-12345-G43"], + ) + self.assertEqual(models.Parcel.objects.count(), self.parcel_number + 3) class OperationWizardModifTest(WizardTest, OperationInitTest, TestCase): fixtures = FILE_FIXTURES - url_name = 'operation_modification' - wizard_name = url_name + '_wizard' + url_name = "operation_modification" + wizard_name = url_name + "_wizard" steps = views.operation_modif_wizard_steps redirect_url = "/{url_name}/selec-{url_name}?open_item={current_id}" model = models.Operation base_ignored_steps = ( - 'archaeologicalsite-operation_modification', - 'preventive-operation_modification', - 'preventivediag-operation_modification', - 'judiciary-operation_modification', - 'towns-operation_modification', - 'parcels-operation_modification', - 'remains-operation_modification', - 'periods-operation_modification', - 'relations-operation_modification', - 'abstract-operation_modification',) + "archaeologicalsite-operation_modification", + "preventive-operation_modification", + "preventivediag-operation_modification", + "judiciary-operation_modification", + "towns-operation_modification", + "parcels-operation_modification", + "remains-operation_modification", + "periods-operation_modification", + "relations-operation_modification", + "abstract-operation_modification", + ) form_datas = [ FormData( "Update an operation", form_datas={ - 'selec': {}, - 'general': { - 'operation_type': 2, - 'year': 2017}, - 'townsgeneral': [], - 'parcelsgeneral': [], + "selec": {}, + "general": {"operation_type": 2, "year": 2017}, + "townsgeneral": [], + "parcelsgeneral": [], }, - ignored=base_ignored_steps + ignored=base_ignored_steps, ), FormData( "Operation: try to remove a parcel with attached context record", form_datas={ - 'selec': {}, - 'general': { - 'code_patriarche': "codeope42", - 'operation_type': 2, - 'year': 2017}, - 'townsgeneral': [], - 'parcelsgeneral': [], + "selec": {}, + "general": { + "code_patriarche": "codeope42", + "operation_type": 2, + "year": 2017, + }, + "townsgeneral": [], + "parcelsgeneral": [], }, - ignored=base_ignored_steps + ignored=base_ignored_steps, ), FormData( "Operation: remove a parcel with no attached context record", form_datas={ - 'selec': {}, - 'general': { - 'operation_type': 2, - 'year': 2017}, - 'townsgeneral': [], - 'parcelsgeneral': [], + "selec": {}, + "general": {"operation_type": 2, "year": 2017}, + "townsgeneral": [], + "parcelsgeneral": [], }, - ignored=base_ignored_steps + ignored=base_ignored_steps, ), FormData( "Set an operation to an exiting operation code for this year", form_datas={ - 'selec': {}, - 'general': { - 'operation_type': 2, - 'operation_code': 42, - 'year': 2017}, - 'townsgeneral': [], - 'parcelsgeneral': [], + "selec": {}, + "general": {"operation_type": 2, "operation_code": 42, "year": 2017}, + "townsgeneral": [], + "parcelsgeneral": [], }, ignored=base_ignored_steps, - error_expected='general' + error_expected="general", ), FormData( "Operation: change a parcel", form_datas={ - 'selec': {}, - 'general': { - 'operation_type': 2, - 'year': 2017}, - 'townsgeneral': [], - 'parcelsgeneral': [], + "selec": {}, + "general": {"operation_type": 2, "year": 2017}, + "townsgeneral": [], + "parcelsgeneral": [], }, - ignored=base_ignored_steps + ignored=base_ignored_steps, ), ] @@ -2903,19 +3389,22 @@ class OperationWizardModifTest(WizardTest, OperationInitTest, TestCase): operation2.save() from archaeological_context_records.models import ContextRecord - cr_data = {'label': "Context record", "operation": operation, - 'parcel': init_parcel, - 'history_modifier': self.get_default_user()} + + cr_data = { + "label": "Context record", + "operation": operation, + "parcel": init_parcel, + "history_modifier": self.get_default_user(), + } self.cr = ContextRecord.objects.create(**cr_data) # diagnostic - self.ope_type = models.OperationType.objects.get( - txt_idx='prev_excavation') - self.form_datas[0].set('general', 'operation_type', self.ope_type.pk) - self.form_datas[1].set('general', 'operation_type', self.ope_type.pk) - self.form_datas[2].set('general', 'operation_type', self.ope_type.pk) - self.form_datas[3].set('general', 'operation_type', self.ope_type.pk) - self.form_datas[4].set('general', 'operation_type', self.ope_type.pk) + self.ope_type = models.OperationType.objects.get(txt_idx="prev_excavation") + self.form_datas[0].set("general", "operation_type", self.ope_type.pk) + self.form_datas[1].set("general", "operation_type", self.ope_type.pk) + self.form_datas[2].set("general", "operation_type", self.ope_type.pk) + self.form_datas[3].set("general", "operation_type", self.ope_type.pk) + self.form_datas[4].set("general", "operation_type", self.ope_type.pk) data = self.form_datas[0].form_datas data2 = self.form_datas[1].form_datas @@ -2923,116 +3412,124 @@ class OperationWizardModifTest(WizardTest, OperationInitTest, TestCase): data4 = self.form_datas[3].form_datas data5 = self.form_datas[4].form_datas - data['selec']['pk'] = operation.pk - data2['selec']['pk'] = operation.pk - data3['selec']['pk'] = operation.pk - data4['selec']['pk'] = operation.pk - data5['selec']['pk'] = operation.pk + data["selec"]["pk"] = operation.pk + data2["selec"]["pk"] = operation.pk + data3["selec"]["pk"] = operation.pk + data4["selec"]["pk"] = operation.pk + data5["selec"]["pk"] = operation.pk - town = self.create_towns( - datas={'numero_insee': '67890', 'name': 'Twin Peaks'})[-1] - towns = [{'town': town.pk}, {'town': init_town.pk}] + town = self.create_towns(datas={"numero_insee": "67890", "name": "Twin Peaks"})[ + -1 + ] + towns = [{"town": town.pk}, {"town": init_town.pk}] parcel_data = { - 'town': town.pk, 'year': 2017, 'section': 'S', - 'parcel_number': '42'} + "town": town.pk, + "year": 2017, + "section": "S", + "parcel_number": "42", + } for idx in range(0, 5): for t in towns: - self.form_datas[idx].append('townsgeneral', t) + self.form_datas[idx].append("townsgeneral", t) if idx != 4: - self.form_datas[idx].append('parcelsgeneral', parcel_data) + self.form_datas[idx].append("parcelsgeneral", parcel_data) parcel_data_2 = { - 'town': init_parcel.town.pk, 'year': init_parcel.year or '', - 'section': init_parcel.section, - 'pk': init_parcel.pk, - 'parcel_number': init_parcel.parcel_number} - data['parcelsgeneral'].append(parcel_data_2) + "town": init_parcel.town.pk, + "year": init_parcel.year or "", + "section": init_parcel.section, + "pk": init_parcel.pk, + "parcel_number": init_parcel.parcel_number, + } + data["parcelsgeneral"].append(parcel_data_2) p = parcel_data.copy() - p['parcel_number'] = '43' - self.form_datas[4].form_datas['parcelsgeneral'] = [p] + p["parcel_number"] = "43" + self.form_datas[4].form_datas["parcelsgeneral"] = [p] self.operation_number = models.Operation.objects.count() self.parcel_number = models.Parcel.objects.count() def post_first_wizard(test_object, final_step_response): - test_object.assertEqual(models.Operation.objects.count(), - test_object.operation_number) - operation = models.Operation.objects.get( - pk=test_object.operations[0].pk) - test_object.assertEqual(operation.operation_type.pk, - self.ope_type.pk) + test_object.assertEqual( + models.Operation.objects.count(), test_object.operation_number + ) + operation = models.Operation.objects.get(pk=test_object.operations[0].pk) + test_object.assertEqual(operation.operation_type.pk, self.ope_type.pk) test_object.assertEqual(operation.year, 2017) - test_object.assertEqual(models.Parcel.objects.count(), - test_object.parcel_number + 1) - test_object.assertEqual(operation.parcels.count(), - test_object.parcel_number + 1) + test_object.assertEqual( + models.Parcel.objects.count(), test_object.parcel_number + 1 + ) + test_object.assertEqual( + operation.parcels.count(), test_object.parcel_number + 1 + ) def pre_second_wizard(test_object): test_object.form_datas[1].form_datas[ - 'parcelsgeneral-operation_modification'][0]["pk"] = \ - models.Parcel.objects.get(parcel_number="42").pk + "parcelsgeneral-operation_modification" + ][0]["pk"] = models.Parcel.objects.get(parcel_number="42").pk def post_second_wizard(test_object, final_step_response): - test_object.assertEqual(models.Operation.objects.count(), - test_object.operation_number) - operation = models.Operation.objects.get( - pk=test_object.operations[0].pk) - test_object.assertEqual(operation.operation_type.pk, - self.ope_type.pk) + test_object.assertEqual( + models.Operation.objects.count(), test_object.operation_number + ) + operation = models.Operation.objects.get(pk=test_object.operations[0].pk) + test_object.assertEqual(operation.operation_type.pk, self.ope_type.pk) test_object.assertEqual(operation.year, 2017) - test_object.assertEqual(models.Parcel.objects.count(), - test_object.parcel_number + 1) + test_object.assertEqual( + models.Parcel.objects.count(), test_object.parcel_number + 1 + ) # the init parcel is not submited but have a context record # the init parcel is not detached from the operation - test_object.assertEqual(operation.parcels.count(), - test_object.parcel_number + 1) + test_object.assertEqual( + operation.parcels.count(), test_object.parcel_number + 1 + ) # update the external id on update cr = ContextRecord.objects.get(pk=self.cr.pk) - test_object.assertEqual(cr.external_id, - "codeope42-12345-A1-Context record") + test_object.assertEqual(cr.external_id, "codeope42-12345-A1-Context record") def pre_third_wizard(test_object): parcel_nb = models.Parcel.objects.count() test_object.cr.delete() - test_object.assertEqual( - parcel_nb, models.Parcel.objects.count()) + test_object.assertEqual(parcel_nb, models.Parcel.objects.count()) def post_third_wizard(test_object, final_step_response): - test_object.assertEqual(models.Operation.objects.count(), - test_object.operation_number) - operation = models.Operation.objects.get( - pk=test_object.operations[0].pk) - test_object.assertEqual(operation.operation_type.pk, - self.ope_type.pk) + test_object.assertEqual( + models.Operation.objects.count(), test_object.operation_number + ) + operation = models.Operation.objects.get(pk=test_object.operations[0].pk) + test_object.assertEqual(operation.operation_type.pk, self.ope_type.pk) test_object.assertEqual(operation.year, 2017) # with no attach the parcel is deleted - test_object.assertEqual(operation.parcels.count(), - test_object.parcel_number) + test_object.assertEqual( + operation.parcels.count(), test_object.parcel_number + ) # the parcel object is no more automatically deleted - test_object.assertEqual(models.Parcel.objects.count(), - test_object.parcel_number + 1) + test_object.assertEqual( + models.Parcel.objects.count(), test_object.parcel_number + 1 + ) def pre_fifth_wizard(test_object): test_object.parcel_number = models.Parcel.objects.count() - operation = models.Operation.objects.get( - pk=test_object.operations[0].pk) + operation = models.Operation.objects.get(pk=test_object.operations[0].pk) test_object.operation_parcel_number = operation.parcels.count() test_object.form_datas[4].form_datas[ - 'parcelsgeneral-operation_modification'][0]["pk"] = \ - models.Parcel.objects.get(parcel_number="42").pk + "parcelsgeneral-operation_modification" + ][0]["pk"] = models.Parcel.objects.get(parcel_number="42").pk def post_fifth_wizard(test_object, final_step_response): - test_object.assertEqual(models.Operation.objects.count(), - test_object.operation_number) - operation = models.Operation.objects.get( - pk=test_object.operations[0].pk) - test_object.assertEqual(models.Parcel.objects.count(), - test_object.parcel_number) - test_object.assertEqual(operation.parcels.count(), - test_object.operation_parcel_number) + test_object.assertEqual( + models.Operation.objects.count(), test_object.operation_number + ) + operation = models.Operation.objects.get(pk=test_object.operations[0].pk) + test_object.assertEqual( + models.Parcel.objects.count(), test_object.parcel_number + ) + test_object.assertEqual( + operation.parcels.count(), test_object.operation_parcel_number + ) self.form_datas[0].extra_tests = [post_first_wizard] self.form_datas[1].pre_tests = [pre_second_wizard] @@ -3046,16 +3543,16 @@ class OperationWizardModifTest(WizardTest, OperationInitTest, TestCase): class OperationWizardDeleteTest(OperationWizardCreationTest): fixtures = FILE_FIXTURES - url_name = 'operation_deletion' - wizard_name = 'operation_deletion_wizard' + url_name = "operation_deletion" + wizard_name = "operation_deletion_wizard" steps = views.operation_deletion_steps redirect_url = "/{}/selec-{}".format(url_name, url_name) form_datas = [ FormData( "Wizard deletion test", form_datas={ - 'selec-operation_deletion': {'pks': None}, - } + "selec-operation_deletion": {"pks": None}, + }, ) ] @@ -3068,38 +3565,35 @@ class OperationWizardDeleteTest(OperationWizardCreationTest): self.ope = self.get_default_operation(force=True) self.ope.parcels.add(self.create_parcel()[0]) self.parcel_nb = models.Parcel.objects.count() - self.form_datas[0].form_datas['selec-operation_deletion']['pks'] = \ - self.ope.pk + self.form_datas[0].form_datas["selec-operation_deletion"]["pks"] = self.ope.pk self.operation_number = models.Operation.objects.count() super(OperationWizardDeleteTest, self).pre_wizard() def post_wizard(self): - self.assertEqual(self.operation_number - 1, - models.Operation.objects.count()) + self.assertEqual(self.operation_number - 1, models.Operation.objects.count()) # associated parcel is... no more removed self.assertEqual(self.parcel_nb, models.Parcel.objects.count()) class OperationWizardClosingTest(OperationWizardCreationTest): fixtures = FILE_FIXTURES - url_name = 'operation_closing' - wizard_name = 'operation_closing_wizard' + url_name = "operation_closing" + wizard_name = "operation_closing_wizard" steps = views.operation_closing_steps redirect_url = "/operation_closing/done" form_datas = [ FormData( "Wizard closing test", form_datas={ - 'selec-operation_closing': {'pk': None}, - 'date-operation_closing': {'end_date': '2016-01-01'}, - } + "selec-operation_closing": {"pk": None}, + "date-operation_closing": {"end_date": "2016-01-01"}, + }, ) ] def pre_wizard(self): self.ope = self.get_default_operation() - self.form_datas[0].form_datas['selec-operation_closing']['pk'] = \ - self.ope.pk + self.form_datas[0].form_datas["selec-operation_closing"]["pk"] = self.ope.pk self.assertTrue(self.ope.is_active()) super(OperationWizardClosingTest, self).pre_wizard() @@ -3107,25 +3601,24 @@ class OperationWizardClosingTest(OperationWizardCreationTest): ope = models.Operation.objects.get(pk=self.ope.pk) self.assertFalse(ope.is_active()) self.assertEqual( - ope.closing()['date'].strftime('%Y-%d-%m'), - self.form_datas[0].form_datas['date-operation_closing']['end_date'] + ope.closing()["date"].strftime("%Y-%d-%m"), + self.form_datas[0].form_datas["date-operation_closing"]["end_date"], ) -class OperationAdminActWizardCreationTest(WizardTest, OperationInitTest, - TestCase): +class OperationAdminActWizardCreationTest(WizardTest, OperationInitTest, TestCase): fixtures = FILE_FIXTURES - url_name = 'operation_administrativeactop' - wizard_name = 'operation_administrative_act_wizard' + url_name = "operation_administrativeactop" + wizard_name = "operation_administrative_act_wizard" steps = views.administrativeactop_steps form_datas = [ FormData( "Admin act creation", form_datas={ - 'selec-operation_administrativeactop': {}, - 'administrativeact-operation_administrativeactop': { - 'signature_date': str(datetime.date.today()) - } + "selec-operation_administrativeactop": {}, + "administrativeact-operation_administrativeactop": { + "signature_date": str(datetime.date.today()) + }, }, ) ] @@ -3135,38 +3628,34 @@ class OperationAdminActWizardCreationTest(WizardTest, OperationInitTest, self.number = models.AdministrativeAct.objects.count() data = self.form_datas[0].form_datas - data['selec-operation_administrativeactop']['pk'] = ope.pk - act = models.ActType.objects.filter(intented_to='O').all()[0].pk + data["selec-operation_administrativeactop"]["pk"] = ope.pk + act = models.ActType.objects.filter(intented_to="O").all()[0].pk - data['administrativeact-operation_administrativeactop'][ - 'act_type'] = act + data["administrativeact-operation_administrativeactop"]["act_type"] = act super(OperationAdminActWizardCreationTest, self).pre_wizard() def post_wizard(self): - self.assertEqual(models.AdministrativeAct.objects.count(), - self.number + 1) + self.assertEqual(models.AdministrativeAct.objects.count(), self.number + 1) class SiteTest(TestCase, OperationInitTest): fixtures = FILE_FIXTURES def setUp(self): - IshtarSiteProfile.objects.get_or_create( - slug='default', active=True) + IshtarSiteProfile.objects.get_or_create(slug="default", active=True) self.username, self.password, self.user = create_superuser() self.alt_username, self.alt_password, self.alt_user = create_user() - self.alt_user.user_permissions.add(Permission.objects.get( - codename='view_own_operation')) + self.alt_user.user_permissions.add( + Permission.objects.get(codename="view_own_operation") + ) self.orgas = self.create_orgas(self.user) def test_create_or_update_top_operations(self): operation_0 = self.create_operation(self.user, self.orgas[0])[0] operation_1 = self.create_operation(self.alt_user, self.orgas[0])[1] - site = models.ArchaeologicalSite.objects.create( - reference="ref-site" - ) + site = models.ArchaeologicalSite.objects.create(reference="ref-site") site.create_or_update_top_operation() - q = models.ArchaeologicalSite.objects.filter(reference='ref-site') + q = models.ArchaeologicalSite.objects.filter(reference="ref-site") site = q.all()[0] # creation not forced - no creation self.assertEqual(site.top_operations.count(), 0) @@ -3188,8 +3677,7 @@ class SiteTest(TestCase, OperationInitTest): self.assertTrue(site.top_operation.virtual_operation) self.assertEqual(site.top_operation.right_relations.count(), 1) self.assertEqual( - site.top_operation.right_relations.all()[0].right_record, - operation_0 + site.top_operation.right_relations.all()[0].right_record, operation_0 ) # create with two operations attached @@ -3203,8 +3691,7 @@ class SiteTest(TestCase, OperationInitTest): self.assertTrue(site.top_operation.virtual_operation) self.assertEqual(site.top_operation.right_relations.count(), 2) attached = [ - rel.right_record - for rel in site.top_operation.right_relations.all() + rel.right_record for rel in site.top_operation.right_relations.all() ] self.assertIn(operation_0, attached) self.assertIn(operation_1, attached) @@ -3217,8 +3704,7 @@ class SiteTest(TestCase, OperationInitTest): self.assertTrue(site.top_operation.virtual_operation) self.assertEqual(site.top_operation.right_relations.count(), 1) self.assertEqual( - site.top_operation.right_relations.all()[0].right_record, - operation_0 + site.top_operation.right_relations.all()[0].right_record, operation_0 ) # reattach it @@ -3229,35 +3715,29 @@ class SiteTest(TestCase, OperationInitTest): self.assertTrue(site.top_operation.virtual_operation) self.assertEqual(site.top_operation.right_relations.count(), 2) attached = [ - rel.right_record - for rel in site.top_operation.right_relations.all() + rel.right_record for rel in site.top_operation.right_relations.all() ] self.assertIn(operation_0, attached) self.assertIn(operation_1, attached) def test_search(self): - site = models.ArchaeologicalSite.objects.create( - reference="reference-site" - ) + site = models.ArchaeologicalSite.objects.create(reference="reference-site") c = Client() - search = {'search_vector': 'reference="reference-site"'} - response = c.get(reverse('get-site'), search) + search = {"search_vector": 'reference="reference-site"'} + response = c.get(reverse("get-site"), search) # no result when no authentication self.assertTrue(not json.loads(response.content.decode())) c.login(username=self.username, password=self.password) - response = c.get(reverse('get-site'), search) - self.assertEqual(json.loads(response.content.decode())['recordsTotal'], - 1) + response = c.get(reverse("get-site"), search) + self.assertEqual(json.loads(response.content.decode())["recordsTotal"], 1) - search = {'search_vector': 'reference="reference"'} - response = c.get(reverse('get-site'), search) - self.assertEqual(json.loads(response.content.decode())['recordsTotal'], - 0) + search = {"search_vector": 'reference="reference"'} + response = c.get(reverse("get-site"), search) + self.assertEqual(json.loads(response.content.decode())["recordsTotal"], 0) - search = {'search_vector': 'reference="reference*"'} - response = c.get(reverse('get-site'), search) - self.assertEqual(json.loads(response.content.decode())['recordsTotal'], - 1) + search = {"search_vector": 'reference="reference*"'} + response = c.get(reverse("get-site"), search) + self.assertEqual(json.loads(response.content.decode())["recordsTotal"], 1) class GenerateQRCode(OperationInitTest, TestCase): @@ -3274,14 +3754,15 @@ class GenerateQRCode(OperationInitTest, TestCase): operation = models.Operation.objects.get(pk=self.operation.pk) self.assertIn(operation.qrcode.name, ["", None]) c = Client() - url = reverse('qrcode-item', args=[ - 'archaeological-operations', 'operation', operation.pk]) + url = reverse( + "qrcode-item", args=["archaeological-operations", "operation", operation.pk] + ) response = c.get(url) self.assertEqual(response.status_code, 302) c.login(username=self.username, password=self.password) response = c.get(url) self.assertEqual(response.status_code, 200) - self.assertEqual(response['Content-Type'], "image/png") + self.assertEqual(response["Content-Type"], "image/png") operation = models.Operation.objects.get(pk=self.operation.pk) self.assertIsNotNone(operation.qrcode.name) @@ -3290,9 +3771,7 @@ class GenerateQRCode(OperationInitTest, TestCase): self.operation.generate_qrcode() self.assertIsNotNone(self.operation.qrcode.name) self.assertTrue( - self.operation.qrcode.name.startswith( - "operation/2010/OA1/qrcode" - ) + self.operation.qrcode.name.startswith("operation/2010/OA1/qrcode") ) @@ -3305,7 +3784,7 @@ class DocumentTest(OperationInitTest, TestCase): def test_create(self): c = Client() - url = reverse('create-document') + url = reverse("create-document") nb_doc = models.Document.objects.count() nb_doc_ope = self.operation.documents.count() @@ -3315,10 +3794,12 @@ class DocumentTest(OperationInitTest, TestCase): c.login(username=self.username, password=self.password) response = c.get(url, {"operation": self.operation.pk}) self.assertEqual(response.status_code, 200) - self.assertIn('option value="{}" selected'.format(self.operation.pk), - response.content.decode()) + self.assertIn( + 'option value="{}" selected'.format(self.operation.pk), + response.content.decode(), + ) - posted = {'authors': []} + posted = {"authors": []} for related_key in models.Document.RELATED_MODELS: posted[related_key] = [] posted["operations"] = [str(self.operation.pk)] @@ -3333,15 +3814,17 @@ class DocumentTest(OperationInitTest, TestCase): self.assertEqual(nb_doc + 1, models.Document.objects.count()) self.assertEqual(nb_doc_ope + 1, self.operation.documents.count()) self.assertRedirects( - response, '/document/edit/?open_item={}'.format( - self.operation.documents.order_by('-pk').all()[0].pk - )) + response, + "/document/edit/?open_item={}".format( + self.operation.documents.order_by("-pk").all()[0].pk + ), + ) def test_edit(self): doc = models.Document.objects.create(title="hop2") doc.operations.add(self.operation) c = Client() - url = reverse('edit-document', args=[doc.pk]) + url = reverse("edit-document", args=[doc.pk]) response = c.get(url) self.assertEqual(response.status_code, 302) @@ -3349,35 +3832,33 @@ class DocumentTest(OperationInitTest, TestCase): c.login(username=self.username, password=self.password) response = c.get(url) self.assertEqual(response.status_code, 200) - self.assertIn('option value="{}" selected'.format(self.operation.pk), - response.content.decode()) + self.assertIn( + 'option value="{}" selected'.format(self.operation.pk), + response.content.decode(), + ) - posted = { - 'authors': [], - 'title': "hop2-is-back" - } + posted = {"authors": [], "title": "hop2-is-back"} for related_key in models.Document.RELATED_MODELS: posted[related_key] = [] posted["operations"] = [str(self.operation.pk)] response = c.post(url, posted) - self.assertRedirects( - response, '/document/edit/?open_item={}'.format(doc.pk)) - response = c.get('/show-document/{}/'.format(doc.pk)) + self.assertRedirects(response, "/document/edit/?open_item={}".format(doc.pk)) + response = c.get("/show-document/{}/".format(doc.pk)) self.assertIn(posted["title"], response.content.decode()) class DocumentWizardDeleteTest(WizardTest, OperationInitTest, TestCase): fixtures = FILE_FIXTURES - url_name = 'document_deletion' + url_name = "document_deletion" url_uri = "document/delete" - wizard_name = 'document_deletion_wizard' + wizard_name = "document_deletion_wizard" redirect_url = "/{}/selec-{}".format(url_uri, url_name) steps = document_deletion_steps form_datas = [ FormData( "Delete document", form_datas={ - 'selec': {'pks': None}, + "selec": {"pks": None}, }, ), ] @@ -3387,41 +3868,44 @@ class DocumentWizardDeleteTest(WizardTest, OperationInitTest, TestCase): document = Document.objects.create(title="testy") document.operations.add(ope) self.ope_id = ope.pk - self.form_datas[0].set('selec', 'pks', document.pk) + self.form_datas[0].set("selec", "pks", document.pk) self.doc_nb = Document.objects.count() super(DocumentWizardDeleteTest, self).pre_wizard() def post_wizard(self): - self.assertEqual(Document.objects.count(), - self.doc_nb - 1) + self.assertEqual(Document.objects.count(), self.doc_nb - 1) # operation not deleted with the document - self.assertEqual(models.Operation.objects.filter( - pk=self.ope_id).count(), 1) + self.assertEqual(models.Operation.objects.filter(pk=self.ope_id).count(), 1) class AutocompleteTest(AutocompleteTestBase, TestCase): fixtures = OPERATION_FIXTURES models = [ - AcItem(models.Operation, 'autocomplete-operation', - prepare_func="create_operation"), - AcItem(models.ArchaeologicalSite, 'autocomplete-archaeologicalsite', - "reference"), - AcItem(models.Operation, 'autocomplete-patriarche', - prepare_func="create_operation_patriarche", - id_key="code_patriarche", one_word_search=True), + AcItem( + models.Operation, "autocomplete-operation", prepare_func="create_operation" + ), + AcItem( + models.ArchaeologicalSite, "autocomplete-archaeologicalsite", "reference" + ), + AcItem( + models.Operation, + "autocomplete-patriarche", + prepare_func="create_operation_patriarche", + id_key="code_patriarche", + one_word_search=True, + ), ] def create_operation(self, base_name): item, __ = models.Operation.objects.get_or_create( - common_name=base_name, - operation_type=models.OperationType.objects.all()[0] + common_name=base_name, operation_type=models.OperationType.objects.all()[0] ) return item, None def create_operation_patriarche(self, base_name): item, __ = models.Operation.objects.get_or_create( code_patriarche=base_name, - operation_type=models.OperationType.objects.all()[0] + operation_type=models.OperationType.objects.all()[0], ) return item, None @@ -3436,25 +3920,26 @@ class OperationQATest(OperationInitTest, TestCase): self.create_operation(self.user, self.orgas[0]) self.create_operation(self.user, self.orgas[0]) self.alt_username, self.alt_password, self.alt_user = create_user() - self.alt_user.user_permissions.add(Permission.objects.get( - codename='change_operation')) + self.alt_user.user_permissions.add( + Permission.objects.get(codename="change_operation") + ) def test_lock(self): c = Client() op0, op1 = self.operations[0], self.operations[1] pks = "{}-{}".format(op0.pk, op1.pk) - url = reverse('operation-qa-lock', args=[pks]) + url = reverse("operation-qa-lock", args=[pks]) response = c.get(url) self.assertEqual(response.status_code, 404) c.login(username=self.username, password=self.password) - response = c.get(reverse('operation-qa-lock', args=[pks])) + response = c.get(reverse("operation-qa-lock", args=[pks])) self.assertEqual(response.status_code, 200) response = c.post(url, {"action": "lock"}) if response.status_code != 200: - self.assertRedirects(response, '/success/') + self.assertRedirects(response, "/success/") for ope in (op0, op1): ope = models.Operation.objects.get(pk=ope.pk) self.assertEqual(ope.locked, True) @@ -3462,7 +3947,7 @@ class OperationQATest(OperationInitTest, TestCase): response = c.post(url, {"action": "unlock"}) if response.status_code != 200: - self.assertRedirects(response, '/success/') + self.assertRedirects(response, "/success/") for ope in (op0, op1): ope = models.Operation.objects.get(pk=ope.pk) self.assertEqual(ope.locked, False) @@ -3470,12 +3955,12 @@ class OperationQATest(OperationInitTest, TestCase): c = Client() c.login(username=self.alt_username, password=self.alt_password) - response = c.get(reverse('operation-qa-lock', args=[pks])) + response = c.get(reverse("operation-qa-lock", args=[pks])) self.assertEqual(response.status_code, 200) response = c.post(url, {"action": "lock"}) if response.status_code != 200: - self.assertRedirects(response, '/success/') + self.assertRedirects(response, "/success/") for ope in (op0, op1): ope = models.Operation.objects.get(pk=ope.pk) self.assertEqual(ope.locked, True) @@ -3483,7 +3968,7 @@ class OperationQATest(OperationInitTest, TestCase): response = c.post(url, {"action": "unlock"}) if response.status_code != 200: - self.assertRedirects(response, '/success/') + self.assertRedirects(response, "/success/") for ope in (op0, op1): ope = models.Operation.objects.get(pk=ope.pk) self.assertEqual(ope.locked, False) @@ -3500,7 +3985,7 @@ class OperationQATest(OperationInitTest, TestCase): op1.save() response = c.post(url, {"action": "unlock"}) - self.assertRedirects(response, '/qa-not-available/locked-by-others/') + self.assertRedirects(response, "/qa-not-available/locked-by-others/") op0 = models.Operation.objects.get(pk=op0.pk) self.assertEqual(op0.locked, True) @@ -3513,17 +3998,17 @@ class OperationQATest(OperationInitTest, TestCase): def test_bulk_update(self): c = Client() pks = "{}-{}".format(self.operations[0].pk, self.operations[1].pk) - response = c.get(reverse('operation-qa-bulk-update', args=[pks])) - self.assertRedirects(response, '/') + response = c.get(reverse("operation-qa-bulk-update", args=[pks])) + self.assertRedirects(response, "/") c = Client() c.login(username=self.username, password=self.password) - response = c.get(reverse('operation-qa-bulk-update', args=[pks])) + response = c.get(reverse("operation-qa-bulk-update", args=[pks])) self.assertEqual(response.status_code, 200) c = Client() c.login(username=self.alt_username, password=self.alt_password) - response = c.get(reverse('operation-qa-bulk-update', args=[pks])) + response = c.get(reverse("operation-qa-bulk-update", args=[pks])) self.assertEqual(response.status_code, 200) operation_0 = self.operations[0] @@ -3536,30 +4021,31 @@ class OperationQATest(OperationInitTest, TestCase): operation_1.save() operation_type = models.OperationType.objects.exclude( - txt_idx="arch_diagnostic").all()[0] + txt_idx="arch_diagnostic" + ).all()[0] self.assertNotEqual( models.Operation.objects.get(pk=operation_0.pk).operation_type, - operation_type + operation_type, ) self.assertNotEqual( models.Operation.objects.get(pk=operation_1.pk).operation_type, - operation_type + operation_type, ) response = c.post( - reverse('operation-qa-bulk-update-confirm', args=[pks]), - {'qa_operation_type': operation_type.pk} + reverse("operation-qa-bulk-update-confirm", args=[pks]), + {"qa_operation_type": operation_type.pk}, ) if response.status_code != 200: - self.assertRedirects(response, '/success/') + self.assertRedirects(response, "/success/") self.assertEqual( models.Operation.objects.get(pk=operation_0.pk).operation_type, - operation_type + operation_type, ) self.assertEqual( models.Operation.objects.get(pk=operation_1.pk).operation_type, - operation_type + operation_type, ) # one item lock by another user @@ -3569,10 +4055,10 @@ class OperationQATest(OperationInitTest, TestCase): op0.save() response = c.post( - reverse('operation-qa-bulk-update-confirm', args=[pks]), - {'qa_operation_type': operation_type.pk} + reverse("operation-qa-bulk-update-confirm", args=[pks]), + {"qa_operation_type": operation_type.pk}, ) - self.assertRedirects(response, '/qa-not-available/locked/') + self.assertRedirects(response, "/qa-not-available/locked/") class DocumentQATest(OperationInitTest, TestCase): @@ -3582,58 +4068,54 @@ class DocumentQATest(OperationInitTest, TestCase): def setUp(self): self.username, self.password, self.user = create_superuser() self.alt_username, self.alt_password, self.alt_user = create_user() - self.alt_user.user_permissions.add(Permission.objects.get( - codename='change_document')) + self.alt_user.user_permissions.add( + Permission.objects.get(codename="change_document") + ) self.source_1 = models.Document.objects.create( - title="Source title", - source_type=models.SourceType.objects.all()[0] + title="Source title", source_type=models.SourceType.objects.all()[0] ) self.source_2 = models.Document.objects.create( - title="Source title2", - source_type=models.SourceType.objects.all()[0] + title="Source title2", source_type=models.SourceType.objects.all()[0] ) def test_bulk_update(self): c = Client() pks = "{}-{}".format(self.source_1.pk, self.source_2.pk) - response = c.get(reverse('document-qa-bulk-update', args=[pks])) - self.assertRedirects(response, '/') + response = c.get(reverse("document-qa-bulk-update", args=[pks])) + self.assertRedirects(response, "/") c = Client() c.login(username=self.username, password=self.password) - response = c.get(reverse('document-qa-bulk-update', args=[pks])) + response = c.get(reverse("document-qa-bulk-update", args=[pks])) self.assertEqual(response.status_code, 200) c = Client() c.login(username=self.alt_username, password=self.alt_password) - response = c.get(reverse('document-qa-bulk-update', args=[pks])) + response = c.get(reverse("document-qa-bulk-update", args=[pks])) self.assertEqual(response.status_code, 200) document_0 = self.source_1 document_1 = self.source_2 source_type = models.SourceType.objects.exclude( - txt_idx=self.source_1.source_type.txt_idx).all()[0] + txt_idx=self.source_1.source_type.txt_idx + ).all()[0] self.assertNotEqual( - models.Document.objects.get(pk=document_0.pk).source_type, - source_type + models.Document.objects.get(pk=document_0.pk).source_type, source_type ) self.assertNotEqual( - models.Document.objects.get(pk=document_1.pk).source_type, - source_type + models.Document.objects.get(pk=document_1.pk).source_type, source_type ) response = c.post( - reverse('document-qa-bulk-update-confirm', args=[pks]), - {'qa_source_type': source_type.pk} + reverse("document-qa-bulk-update-confirm", args=[pks]), + {"qa_source_type": source_type.pk}, ) if response.status_code != 200: - self.assertRedirects(response, '/success/') + self.assertRedirects(response, "/success/") self.assertEqual( - models.Document.objects.get(pk=document_0.pk).source_type, - source_type + models.Document.objects.get(pk=document_0.pk).source_type, source_type ) self.assertEqual( - models.Document.objects.get(pk=document_1.pk).source_type, - source_type + models.Document.objects.get(pk=document_1.pk).source_type, source_type ) |