diff options
Diffstat (limited to 'archaeological_finds/tests.py')
| -rw-r--r-- | archaeological_finds/tests.py | 1733 |
1 files changed, 911 insertions, 822 deletions
diff --git a/archaeological_finds/tests.py b/archaeological_finds/tests.py index 61caca858..bb249e2ea 100644 --- a/archaeological_finds/tests.py +++ b/archaeological_finds/tests.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python +#!/usr/bin/env python3 # -*- coding: utf-8 -*- # Copyright (C) 2015-2017 Étienne Loks <etienne.loks_AT_peacefrogsDOTnet> @@ -35,27 +35,63 @@ from django.core.files.uploadedfile import SimpleUploadedFile from django.core.urlresolvers import reverse from django.test import tag from django.test.client import Client -from ishtar_common.models import ImporterType, IshtarUser, ImporterColumn,\ - FormaterType, ImportTarget, IshtarSiteProfile, ProfileType, ImporterModel, \ - DocumentTemplate +from ishtar_common.models import ( + ImporterType, + IshtarUser, + ImporterColumn, + FormaterType, + ImportTarget, + IshtarSiteProfile, + ProfileType, + ImporterModel, + DocumentTemplate, +) from django.utils.text import slugify from django.utils.translation import pgettext_lazy, gettext_lazy as _ -from ishtar_common.models import Person, get_current_profile, UserProfile, \ - Town, Area, Document, SpatialReferenceSystem -from archaeological_context_records.models import Period, Dating, \ - ContextRecord, DatingType, DatingQuality +from ishtar_common.models import ( + Person, + get_current_profile, + UserProfile, + Town, + Area, + Document, + SpatialReferenceSystem, +) +from archaeological_context_records.models import ( + Period, + Dating, + ContextRecord, + DatingType, + DatingQuality, +) from archaeological_finds import models, views -from archaeological_warehouse.models import Warehouse, WarehouseType, \ - ContainerType, Container, WarehouseDivisionLink +from archaeological_warehouse.models import ( + Warehouse, + WarehouseType, + ContainerType, + Container, + WarehouseDivisionLink, +) from archaeological_operations.models import Operation, OperationType from ishtar_common import forms_common -from ishtar_common.tests import WizardTest, WizardTestFormData as FormData, \ - TestCase, create_user, create_superuser, AutocompleteTestBase, AcItem, \ - FIND_FIXTURES, FIND_TOWNS_FIXTURES, WAREHOUSE_FIXTURES, \ - COMMON_FIXTURES, GenericSerializationTest, SearchText +from ishtar_common.tests import ( + WizardTest, + WizardTestFormData as FormData, + TestCase, + create_user, + create_superuser, + AutocompleteTestBase, + AcItem, + FIND_FIXTURES, + FIND_TOWNS_FIXTURES, + WAREHOUSE_FIXTURES, + COMMON_FIXTURES, + GenericSerializationTest, + SearchText, +) from archaeological_operations.tests import ImportTest, create_operation from archaeological_context_records.tests import ContextRecordInit @@ -72,22 +108,25 @@ class FindInit(ContextRecordInit): data_base = {} if not data: data = {} - if not getattr(self, 'finds', None): + if not getattr(self, "finds", None): self.finds = [] - if not getattr(self, 'base_finds', None): + if not getattr(self, "base_finds", None): self.base_finds = [] - default = {'label': "Base find"} + default = {"label": "Base find"} if user: - data_base['history_modifier'] = user - elif not data_base.get('history_modifier') or not data_base[ - 'history_modifier'].pk: + data_base["history_modifier"] = user + elif ( + not data_base.get("history_modifier") + or not data_base["history_modifier"].pk + ): user = self.get_default_user() user.save() - data_base['history_modifier'] = user - if force or not data_base.get('context_record'): - data_base['context_record'] = self.get_default_context_record( - force=force, user=user) + data_base["history_modifier"] = user + if force or not data_base.get("context_record"): + data_base["context_record"] = self.get_default_context_record( + force=force, user=user + ) default.update(data_base) base_find = models.BaseFind.objects.create(**default) self.base_finds.append(base_find) @@ -106,14 +145,14 @@ class FindInit(ContextRecordInit): def tearDown(self): super(FindInit, self).tearDown() - if hasattr(self, 'finds'): + if hasattr(self, "finds"): for f in self.finds: try: f.delete() except: pass self.finds = [] - if hasattr(self, 'base_finds'): + if hasattr(self, "base_finds"): for f in self.base_finds: try: f.delete() @@ -128,12 +167,8 @@ class SerializationTest(GenericSerializationTest, FindInit, TestCase): def setUp(self): ope1 = self.create_operation()[0] ope2 = self.create_operation()[1] - cr = self.create_context_record( - data={"label": "CR 1", "operation": ope1} - )[0] - cr2 = self.create_context_record( - data={"label": "CR 2", "operation": ope2} - )[1] + cr = self.create_context_record(data={"label": "CR 1", "operation": ope1})[0] + cr2 = self.create_context_record(data={"label": "CR 2", "operation": ope2})[1] self.create_finds(data_base={"context_record": cr})[0] self.create_finds(data_base={"context_record": cr2})[1] # basket = models.FindBasket.objects.create(label="Hophop") @@ -142,164 +177,145 @@ class SerializationTest(GenericSerializationTest, FindInit, TestCase): def test_serialization(self): res = self.generic_serialization_test(serializers.find_serialization) - find_json = json.loads( - res[('finds', 'archaeological_finds__Find')] - ) + find_json = json.loads(res[("finds", "archaeological_finds__Find")]) self.assertEqual(len(find_json), 2) - bfind_json = json.loads( - res[('finds', 'archaeological_finds__BaseFind')] - ) + bfind_json = json.loads(res[("finds", "archaeological_finds__BaseFind")]) self.assertEqual(len(bfind_json), 2) result_queryset = Operation.objects.filter(uuid=self.operations[0].uuid) res = self.generic_serialization_test( - serializers.find_serialization, no_test=True, - kwargs={"operation_queryset": result_queryset} - ) - find_json = json.loads( - res[('finds', 'archaeological_finds__Find')] + serializers.find_serialization, + no_test=True, + kwargs={"operation_queryset": result_queryset}, ) + find_json = json.loads(res[("finds", "archaeological_finds__Find")]) self.assertEqual(len(find_json), 1) - bfind_json = json.loads( - res[('finds', 'archaeological_finds__BaseFind')] - ) + bfind_json = json.loads(res[("finds", "archaeological_finds__BaseFind")]) self.assertEqual(len(bfind_json), 1) result_queryset = ContextRecord.objects.filter( - uuid=self.context_records[0].uuid) - res = self.generic_serialization_test( - serializers.find_serialization, no_test=True, - kwargs={"cr_queryset": result_queryset} + uuid=self.context_records[0].uuid ) - find_json = json.loads( - res[('finds', 'archaeological_finds__Find')] + res = self.generic_serialization_test( + serializers.find_serialization, + no_test=True, + kwargs={"cr_queryset": result_queryset}, ) + find_json = json.loads(res[("finds", "archaeological_finds__Find")]) self.assertEqual(len(find_json), 1) - bfind_json = json.loads( - res[('finds', 'archaeological_finds__BaseFind')] - ) + bfind_json = json.loads(res[("finds", "archaeological_finds__BaseFind")]) self.assertEqual(len(bfind_json), 1) - result_queryset = models.Find.objects.filter( - uuid=self.finds[0].uuid) + result_queryset = models.Find.objects.filter(uuid=self.finds[0].uuid) res = self.generic_serialization_test( - serializers.find_serialization, no_test=True, - kwargs={"find_queryset": result_queryset} - ) - find_json = json.loads( - res[('finds', 'archaeological_finds__Find')] + serializers.find_serialization, + no_test=True, + kwargs={"find_queryset": result_queryset}, ) + find_json = json.loads(res[("finds", "archaeological_finds__Find")]) self.assertEqual(len(find_json), 1) - bfind_json = json.loads( - res[('finds', 'archaeological_finds__BaseFind')] - ) + bfind_json = json.loads(res[("finds", "archaeological_finds__BaseFind")]) self.assertEqual(len(bfind_json), 1) def test_ope_serialization_with_find_filter(self): res = self.generic_serialization_test( - operation_serialization, no_test=True, + operation_serialization, + no_test=True, ) ope_json = json.loads( - res[('operations', 'archaeological_operations__Operation')] + res[("operations", "archaeological_operations__Operation")] ) self.assertEqual(len(ope_json), 2) - result_queryset = models.Find.objects.filter( - uuid=self.finds[0].uuid) + result_queryset = models.Find.objects.filter(uuid=self.finds[0].uuid) res = self.generic_serialization_test( - operation_serialization, no_test=True, - kwargs={"find_queryset": result_queryset} + operation_serialization, + no_test=True, + kwargs={"find_queryset": result_queryset}, ) ope_json = json.loads( - res[('operations', 'archaeological_operations__Operation')] + res[("operations", "archaeological_operations__Operation")] ) self.assertEqual(len(ope_json), 1) def test_cr_serialization_with_find_filter(self): res = self.generic_serialization_test( - cr_serialization, no_test=True, + cr_serialization, + no_test=True, ) cr_json = json.loads( - res[('context_records', - 'archaeological_context_records__ContextRecord')] + res[("context_records", "archaeological_context_records__ContextRecord")] ) self.assertEqual(len(cr_json), 2) - result_queryset = models.Find.objects.filter( - uuid=self.finds[0].uuid) + result_queryset = models.Find.objects.filter(uuid=self.finds[0].uuid) res = self.generic_serialization_test( - cr_serialization, no_test=True, - kwargs={"find_queryset": result_queryset} + cr_serialization, no_test=True, kwargs={"find_queryset": result_queryset} ) cr_json = json.loads( - res[('context_records', - 'archaeological_context_records__ContextRecord')] + res[("context_records", "archaeological_context_records__ContextRecord")] ) self.assertEqual(len(cr_json), 1) def test_restore(self): current_number, zip_filename = self.generic_restore_test_genzip( - serializers.FIND_MODEL_LIST, - serializers.find_serialization) - self.generic_restore_test(zip_filename, current_number, - serializers.FIND_MODEL_LIST) + serializers.FIND_MODEL_LIST, serializers.find_serialization + ) + self.generic_restore_test( + zip_filename, current_number, serializers.FIND_MODEL_LIST + ) class FindWizardCreationTest(WizardTest, FindInit, TestCase): fixtures = WAREHOUSE_FIXTURES - url_name = 'find_creation' - wizard_name = 'find_wizard' + url_name = "find_creation" + wizard_name = "find_wizard" steps = views.find_creation_steps - redirect_url = "/find_modification/selec-find_modification?open_item="\ - "{last_id}" + redirect_url = "/find_modification/selec-find_modification?open_item=" "{last_id}" model = models.Find form_datas = [ FormData( - 'Find creation', + "Find creation", form_datas={ - 'selecrecord-find_creation': {'pk': 1}, - 'find-find_creation': { - 'label': 'hop', - 'checked': 'NC', - 'check_date': '2016-01-01' + "selecrecord-find_creation": {"pk": 1}, + "find-find_creation": { + "label": "hop", + "checked": "NC", + "check_date": "2016-01-01", }, - 'dating-find_creation': [ + "dating-find_creation": [ { - 'period': None, - 'start_date': '0', - 'end_date': '200', + "period": None, + "start_date": "0", + "end_date": "200", }, { - 'period': None, - 'start_date': '0', - 'end_date': '200', - } - ] + "period": None, + "start_date": "0", + "end_date": "200", + }, + ], }, - ignored=['preservation-find_creation'] + ignored=["preservation-find_creation"], ) ] def pre_wizard(self): cr = self.create_context_record( - data={'parcel': self.create_parcel()[-1]}, force=True)[-1] + data={"parcel": self.create_parcel()[-1]}, force=True + )[-1] - self.form_datas[0].form_datas['selecrecord-find_creation']['pk'] = \ - cr.pk + self.form_datas[0].form_datas["selecrecord-find_creation"]["pk"] = cr.pk period = Period.objects.all()[0].pk - self.form_datas[0].form_datas['dating-find_creation'][0]['period'] = \ - period - self.form_datas[0].form_datas['dating-find_creation'][1]['period'] = \ - period + self.form_datas[0].form_datas["dating-find_creation"][0]["period"] = period + self.form_datas[0].form_datas["dating-find_creation"][1]["period"] = period self.find_number = models.Find.objects.count() self.basefind_number = models.BaseFind.objects.count() super(FindWizardCreationTest, self).pre_wizard() def post_wizard(self): - self.assertEqual(models.BaseFind.objects.count(), - self.basefind_number + 1) - self.assertEqual(models.Find.objects.count(), - self.find_number + 1) + self.assertEqual(models.BaseFind.objects.count(), self.basefind_number + 1) + self.assertEqual(models.Find.objects.count(), self.find_number + 1) # identical datings, only one should be finaly save f = models.Find.objects.order_by("-pk").all()[0] self.assertEqual(f.datings.count(), 1) @@ -307,42 +323,44 @@ class FindWizardCreationTest(WizardTest, FindInit, TestCase): class FindWizardModificationTest(WizardTest, FindInit, TestCase): fixtures = WAREHOUSE_FIXTURES - url_name = 'find_modification' - wizard_name = url_name + '_wizard' + url_name = "find_modification" + wizard_name = url_name + "_wizard" steps = views.find_modification_steps - redirect_url = "/find_modification/selec-find_modification?open_item=" \ - "{last_id}" + redirect_url = "/find_modification/selec-find_modification?open_item=" "{last_id}" model = models.Find form_datas = [ FormData( - 'Find modification', + "Find modification", form_datas={ - 'selec-find_modification': {'pk': ''}, - 'selecrecord-find_modification': { + "selec-find_modification": {"pk": ""}, + "selecrecord-find_modification": { "get_first_base_find__context_record": "" }, - 'find-find_modification': { - 'label': 'hop', - 'checked': 'NC', - 'check_date': '2016-01-01' + "find-find_modification": { + "label": "hop", + "checked": "NC", + "check_date": "2016-01-01", }, - 'dating-find_modification': [ + "dating-find_modification": [ { - 'period': None, - 'start_date': '', - 'end_date': '', + "period": None, + "start_date": "", + "end_date": "", }, - ] + ], }, - ignored=['preservation-find_modification', - 'selecw-find_modification', - 'simplefind-find_modification'] + ignored=[ + "preservation-find_modification", + "selecw-find_modification", + "simplefind-find_modification", + ], ) ] def pre_wizard(self): profile, created = IshtarSiteProfile.objects.get_or_create( - slug='default', active=True) + slug="default", active=True + ) profile.warehouse = False profile.save() find, __ = self.get_default_find(force=True) @@ -352,29 +370,28 @@ class FindWizardModificationTest(WizardTest, FindInit, TestCase): find.save() data = self.form_datas[0].form_datas - data['selec-find_modification']['pk'] = find.pk - data['selecrecord-find_modification'][ - 'get_first_base_find__context_record'] = \ - find.base_finds.all()[0].context_record.pk + data["selec-find_modification"]["pk"] = find.pk + data["selecrecord-find_modification"][ + "get_first_base_find__context_record" + ] = find.base_finds.all()[0].context_record.pk self.period = Period.objects.all()[0] self.period2 = Period.objects.all()[1] - find.datings.add(Dating.objects.create( - period=self.period, start_date='0', end_date='200')) + find.datings.add( + Dating.objects.create(period=self.period, start_date="0", end_date="200") + ) find.datings.add(Dating.objects.create(period=self.period2)) - data['dating-find_modification'][0]['period'] = self.period.pk + data["dating-find_modification"][0]["period"] = self.period.pk self.find_number = models.Find.objects.count() self.basefind_number = models.BaseFind.objects.count() super(FindWizardModificationTest, self).pre_wizard() def post_wizard(self): # no creation - self.assertEqual(models.BaseFind.objects.count(), - self.basefind_number) - self.assertEqual(models.Find.objects.count(), - self.find_number) + self.assertEqual(models.BaseFind.objects.count(), self.basefind_number) + self.assertEqual(models.Find.objects.count(), self.find_number) f = models.Find.objects.get(pk=self.find.pk) self.assertEqual(f.datings.count(), 1) dating = f.datings.all()[0] @@ -385,109 +402,109 @@ class FindWizardModificationTest(WizardTest, FindInit, TestCase): class FindWizardDeletionWithWarehouseModTest(WizardTest, FindInit, TestCase): fixtures = WAREHOUSE_FIXTURES - url_name = 'find_deletion' - wizard_name = 'find_deletion_wizard' + url_name = "find_deletion" + wizard_name = "find_deletion_wizard" steps = views.find_deletion_steps redirect_url = "/{}/selecw-{}".format(url_name, url_name) form_datas = [ FormData( - 'Find deletion', + "Find deletion", form_datas={ - 'selecw': {}, + "selecw": {}, }, - ignored=['selec-find_deletion'] + ignored=["selec-find_deletion"], ) ] def pre_wizard(self): profile, created = IshtarSiteProfile.objects.get_or_create( - slug='default', active=True) + slug="default", active=True + ) profile.warehouse = True profile.save() find, bf = self.get_default_find(force=True) - self.form_datas[0].set('selecw', 'pks', find.pk) + self.form_datas[0].set("selecw", "pks", find.pk) self.find_number = models.Find.objects.count() super(FindWizardDeletionWithWarehouseModTest, self).pre_wizard() def post_wizard(self): - self.assertEqual(models.Find.objects.count(), - self.find_number - 1) + self.assertEqual(models.Find.objects.count(), self.find_number - 1) class TreatmentWizardCreationTest(WizardTest, FindInit, TestCase): fixtures = WAREHOUSE_FIXTURES - url_name = 'treatment_creation' - wizard_name = 'treatment_wizard' + url_name = "treatment_creation" + wizard_name = "treatment_wizard" steps = views.treatment_wizard_steps - redirect_url = "/treatment_search/general-treatment_search?" \ - "open_item={last_id}" + redirect_url = "/treatment_search/general-treatment_search?" "open_item={last_id}" model = models.Treatment form_datas = [ FormData( - 'Move treatment (planned)', + "Move treatment (planned)", form_datas={ - 'file': {}, - 'basetreatment': { - 'treatment_type': None, - 'person': 1, # doer - 'location': 1, # associated warehouse - 'year': 2016, - 'container': None, + "file": {}, + "basetreatment": { + "treatment_type": None, + "person": 1, # doer + "location": 1, # associated warehouse + "year": 2016, + "container": None, }, - 'selecfind': { - 'pk': 1, - 'resulting_pk': 1 - } + "selecfind": {"pk": 1, "resulting_pk": 1}, }, - ignored=('resultfind-treatment_creation', - 'selecbasket-treatment_creation', - 'resultfinds-treatment_creation')), + ignored=( + "resultfind-treatment_creation", + "selecbasket-treatment_creation", + "resultfinds-treatment_creation", + ), + ), FormData( - 'Move treatment (done)', + "Move treatment (done)", form_datas={ - 'file': {}, - 'basetreatment': { - 'treatment_type': None, - 'person': 1, # doer - 'location': 1, # associated warehouse - 'year': 2016, - 'container': None, + "file": {}, + "basetreatment": { + "treatment_type": None, + "person": 1, # doer + "location": 1, # associated warehouse + "year": 2016, + "container": None, }, - 'selecfind': { - 'pk': 1, - 'resulting_pk': 1 - } + "selecfind": {"pk": 1, "resulting_pk": 1}, }, - ignored=('resultfind-treatment_creation', - 'selecbasket-treatment_creation', - 'resultfinds-treatment_creation')), + ignored=( + "resultfind-treatment_creation", + "selecbasket-treatment_creation", + "resultfinds-treatment_creation", + ), + ), FormData( - 'Loan treatment (done)', + "Loan treatment (done)", form_datas={ - 'file': {}, - 'basetreatment': { - 'treatment_type': None, - 'person': 1, # doer - 'location': 1, # associated warehouse - 'year': 2016, - 'container': None, + "file": {}, + "basetreatment": { + "treatment_type": None, + "person": 1, # doer + "location": 1, # associated warehouse + "year": 2016, + "container": None, }, - 'selecfind': { - 'pk': 1, - 'resulting_pk': 1 - } + "selecfind": {"pk": 1, "resulting_pk": 1}, }, - ignored=('resultfind-treatment_creation', - 'selecbasket-treatment_creation', - 'resultfinds-treatment_creation')), + ignored=( + "resultfind-treatment_creation", + "selecbasket-treatment_creation", + "resultfinds-treatment_creation", + ), + ), ] def pre_wizard(self): q = Warehouse.objects.filter(pk=1) if not q.count(): warehouse = Warehouse.objects.create( - name="default", warehouse_type=WarehouseType.objects.all()[0]) + name="default", warehouse_type=WarehouseType.objects.all()[0] + ) warehouse.id = 1 warehouse.save() else: @@ -501,19 +518,19 @@ class TreatmentWizardCreationTest(WizardTest, FindInit, TestCase): self.container_ref = Container.objects.create( location=warehouse, responsible=warehouse, - container_type=ContainerType.objects.all()[0] + container_type=ContainerType.objects.all()[0], ) self.container1 = Container.objects.create( location=warehouse, responsible=warehouse, - container_type=ContainerType.objects.all()[0] + container_type=ContainerType.objects.all()[0], ) self.container2 = Container.objects.create( location=warehouse, responsible=warehouse, - container_type=ContainerType.objects.all()[0] + container_type=ContainerType.objects.all()[0], ) self.find, base_find = self.get_default_find(force=True) @@ -521,50 +538,44 @@ class TreatmentWizardCreationTest(WizardTest, FindInit, TestCase): self.find.container = self.container_ref self.find.save() for idx in (0, 1): - self.form_datas[idx].form_datas['selecfind']["pk"] = self.find.pk - self.form_datas[idx].form_datas['selecfind']["resulting_pk"] = \ - self.find.pk - self.form_datas[idx].set('basetreatment', 'container', - self.container1.pk) + self.form_datas[idx].form_datas["selecfind"]["pk"] = self.find.pk + self.form_datas[idx].form_datas["selecfind"]["resulting_pk"] = self.find.pk + self.form_datas[idx].set("basetreatment", "container", self.container1.pk) self.find_2, base_find = self.get_default_find(force=True) self.find_2.container_ref = self.container_ref self.find_2.container = self.container_ref self.find_2.save() - self.form_datas[2].form_datas['selecfind']["pk"] = self.find_2.pk - self.form_datas[2].form_datas['selecfind']["resulting_pk"] = \ - self.find_2.pk - self.form_datas[2].set('basetreatment', 'container', self.container2.pk) + self.form_datas[2].form_datas["selecfind"]["pk"] = self.find_2.pk + self.form_datas[2].form_datas["selecfind"]["resulting_pk"] = self.find_2.pk + self.form_datas[2].set("basetreatment", "container", self.container2.pk) - moving = models.TreatmentType.objects.get(txt_idx='moving') + moving = models.TreatmentType.objects.get(txt_idx="moving") moving.change_reference_location = True moving.change_current_location = True moving.save() - self.form_datas[0].set('basetreatment', 'treatment_type', - moving.pk) - self.form_datas[1].set('basetreatment', 'treatment_type', - moving.pk) - loan = models.TreatmentType.objects.get(txt_idx='loan') + self.form_datas[0].set("basetreatment", "treatment_type", moving.pk) + self.form_datas[1].set("basetreatment", "treatment_type", moving.pk) + loan = models.TreatmentType.objects.get(txt_idx="loan") loan.change_reference_location = False loan.change_current_location = True loan.save() - self.form_datas[2].set('basetreatment', 'treatment_type', - loan.pk) + self.form_datas[2].set("basetreatment", "treatment_type", loan.pk) planned, __ = models.TreatmentState.objects.get_or_create( - txt_idx='planned', defaults={"executed": False, "label": "Planned"} + txt_idx="planned", defaults={"executed": False, "label": "Planned"} ) planned.executed = False planned.save() - self.form_datas[0].set('basetreatment', 'treatment_state', planned.pk) + self.form_datas[0].set("basetreatment", "treatment_state", planned.pk) completed, created = models.TreatmentState.objects.get_or_create( - txt_idx='completed', defaults={"executed": True, "label": "Done"} + txt_idx="completed", defaults={"executed": True, "label": "Done"} ) completed.executed = True completed.save() - self.form_datas[1].set('basetreatment', 'treatment_state', completed.pk) - self.form_datas[2].set('basetreatment', 'treatment_state', completed.pk) + self.form_datas[1].set("basetreatment", "treatment_state", completed.pk) + self.form_datas[2].set("basetreatment", "treatment_state", completed.pk) self.treatment_number = models.Treatment.objects.count() @@ -572,8 +583,8 @@ class TreatmentWizardCreationTest(WizardTest, FindInit, TestCase): # treatment planned - no changes find = models.Find.objects.get(pk=test_object.find.pk) test_object.assertEqual(find.container, test_object.container_ref) - test_object.assertEqual(find.container_ref, - test_object.container_ref) + test_object.assertEqual(find.container_ref, test_object.container_ref) + self.form_datas[0].extra_tests = [post_first_wizard] def post_second_wizard(test_object, final_step_response): @@ -581,21 +592,21 @@ class TreatmentWizardCreationTest(WizardTest, FindInit, TestCase): find = models.Find.objects.get(pk=test_object.find.pk) test_object.assertEqual(find.container, test_object.container1) test_object.assertEqual(find.container_ref, test_object.container1) + self.form_datas[1].extra_tests = [post_second_wizard] def post_third_wizard(test_object, final_step_response): # loan done find = models.Find.objects.get(pk=test_object.find_2.pk) - test_object.assertEqual(find.container_ref, - test_object.container_ref) + test_object.assertEqual(find.container_ref, test_object.container_ref) test_object.assertEqual(find.container, test_object.container2) + self.form_datas[2].extra_tests = [post_third_wizard] super(TreatmentWizardCreationTest, self).pre_wizard() def post_wizard(self): - self.assertEqual(models.Treatment.objects.count(), - self.treatment_number + 3) + self.assertEqual(models.Treatment.objects.count(), self.treatment_number + 3) self.find = models.Find.objects.get(pk=self.find.pk) self.assertEqual(self.find.treatments.count(), 2) self.find_2 = models.Find.objects.get(pk=self.find_2.pk) @@ -608,8 +619,7 @@ class TreatmentWizardCreationTest(WizardTest, FindInit, TestCase): class ImportFindTest(ImportTest, FindInit, TestCase): fixtures = FIND_TOWNS_FIXTURES + [ - settings.ROOT_PATH + - '../archaeological_finds/tests/import_loca_test.json', + settings.ROOT_PATH + "../archaeological_finds/tests/import_loca_test.json", ] def setUp(self): @@ -623,38 +633,42 @@ class ImportFindTest(ImportTest, FindInit, TestCase): old_nb_find = models.Find.objects.count() MCC = ImporterType.objects.get(name="MCC - Mobilier") - col = ImporterColumn.objects.create(col_number=25, - importer_type_id=MCC.pk) - formater = FormaterType.objects.filter( - formater_type='FileFormater').all()[0] - ImportTarget.objects.create(target='documents__image', - formater_type_id=formater.pk, - column_id=col.pk) + col = ImporterColumn.objects.create(col_number=25, importer_type_id=MCC.pk) + formater = FormaterType.objects.filter(formater_type="FileFormater").all()[0] + ImportTarget.objects.create( + target="documents__image", formater_type_id=formater.pk, column_id=col.pk + ) mcc_file = open( - settings.ROOT_PATH + - '../archaeological_finds/tests/MCC-finds-example.csv', 'rb') + settings.ROOT_PATH + "../archaeological_finds/tests/MCC-finds-example.csv", + "rb", + ) mcc_images = open( - settings.ROOT_PATH + - '../archaeological_finds/tests/images.zip', 'rb') - file_dict = {'imported_file': SimpleUploadedFile(mcc_file.name, - mcc_file.read()), - 'imported_images': SimpleUploadedFile(mcc_images.name, - mcc_images.read())} - post_dict = {'importer_type': MCC.pk, 'skip_lines': 1, - "encoding": 'utf-8', "name": 'init_find_import', - "csv_sep": ","} - form = forms_common.NewImportForm(data=post_dict, files=file_dict, - user=self.user) + settings.ROOT_PATH + "../archaeological_finds/tests/images.zip", "rb" + ) + file_dict = { + "imported_file": SimpleUploadedFile(mcc_file.name, mcc_file.read()), + "imported_images": SimpleUploadedFile(mcc_images.name, mcc_images.read()), + } + post_dict = { + "importer_type": MCC.pk, + "skip_lines": 1, + "encoding": "utf-8", + "name": "init_find_import", + "csv_sep": ",", + } + form = forms_common.NewImportForm( + data=post_dict, files=file_dict, user=self.user + ) form.is_valid() self.assertTrue(form.is_valid()) impt = form.save(self.ishtar_user) impt.initialize() # doing manual connections - ceram = models.MaterialType.objects.get(txt_idx='ceramic').pk - glass = models.MaterialType.objects.get(txt_idx='glass').pk - self.set_target_key('material_types', 'terre-cuite', ceram) - self.set_target_key('material_types', 'verre', glass) + ceram = models.MaterialType.objects.get(txt_idx="ceramic").pk + glass = models.MaterialType.objects.get(txt_idx="glass").pk + self.set_target_key("material_types", "terre-cuite", ceram) + self.set_target_key("material_types", "verre", glass) impt.importation() # new finds has now been imported current_nb = models.BaseFind.objects.count() @@ -662,9 +676,11 @@ class ImportFindTest(ImportTest, FindInit, TestCase): current_nb = models.Find.objects.count() self.assertEqual(current_nb, (old_nb_find + 4)) self.assertEqual( - models.Find.objects.filter(material_types__pk=ceram).count(), 4) + models.Find.objects.filter(material_types__pk=ceram).count(), 4 + ) self.assertEqual( - models.Find.objects.filter(material_types__pk=glass).count(), 1) + models.Find.objects.filter(material_types__pk=glass).count(), 1 + ) images = [] for find in models.Find.objects.all(): images += [1 for im in find.images.all() if im.image.name] @@ -676,15 +692,19 @@ class ImportFindTest(ImportTest, FindInit, TestCase): bf = bfs[idx] expected_index = 4 - idx self.assertEqual( - bf.index, expected_index, + bf.index, + expected_index, "Bad index for imported base find: {} where {} is " - "expected".format(bf.index, expected_index)) + "expected".format(bf.index, expected_index), + ) f = bf.find.all()[0] self.assertEqual( - f.index, expected_index, + f.index, + expected_index, "Bad index for imported find: {} where {} is expected".format( f.index, expected_index - )) + ), + ) def test_import_locations(self): self.create_finds() @@ -701,8 +721,7 @@ class ImportFindTest(ImportTest, FindInit, TestCase): warehouse, __ = Warehouse.objects.get_or_create( external_id="warehouse-test", - defaults={"name": "Warehouse test", - "warehouse_type": wt} + defaults={"name": "Warehouse test", "warehouse_type": wt}, ) container_types = [] @@ -717,7 +736,7 @@ class ImportFindTest(ImportTest, FindInit, TestCase): WarehouseDivisionLink.objects.get_or_create( warehouse=warehouse, container_type=container_types[idx], - order=(idx + 1) * 10 + order=(idx + 1) * 10, ) old_nb = models.BaseFind.objects.count() @@ -730,29 +749,56 @@ class ImportFindTest(ImportTest, FindInit, TestCase): with open(imp_filename, "w") as impfile: w = csv.writer(impfile) - w.writerow(['External ID', "Warehouse", "Ref.", - "Container type", "Localisation 1", "Localisation 2", - "Localisation 3"]) + w.writerow( + [ + "External ID", + "Warehouse", + "Ref.", + "Container type", + "Localisation 1", + "Localisation 2", + "Localisation 3", + ] + ) for idx, ext_id in enumerate(external_ids): if idx < 2: - w.writerow([ext_id, "warehouse-test", - "Réf. {}".format((idx + 1) * 10), - container_types[-1].name, - "A", "42", idx + 1]) + w.writerow( + [ + ext_id, + "warehouse-test", + "Réf. {}".format((idx + 1) * 10), + container_types[-1].name, + "A", + "42", + idx + 1, + ] + ) else: - w.writerow([ext_id, "warehouse-test", - "Réf. {}".format((idx + 1) * 10), - container_types[-1].name, - "A", 43]) + w.writerow( + [ + ext_id, + "warehouse-test", + "Réf. {}".format((idx + 1) * 10), + container_types[-1].name, + "A", + 43, + ] + ) imp_file = open(imp_filename, "rb") - file_dict = {'imported_file': SimpleUploadedFile(imp_file.name, - imp_file.read())} - post_dict = {'importer_type': importer_type.pk, 'skip_lines': 1, - "encoding": 'utf-8', "name": 'init_find_import', - "csv_sep": ","} - form = forms_common.NewImportForm(data=post_dict, files=file_dict, - user=self.user) + file_dict = { + "imported_file": SimpleUploadedFile(imp_file.name, imp_file.read()) + } + post_dict = { + "importer_type": importer_type.pk, + "skip_lines": 1, + "encoding": "utf-8", + "name": "init_find_import", + "csv_sep": ",", + } + form = forms_common.NewImportForm( + data=post_dict, files=file_dict, user=self.user + ) form.is_valid() self.assertTrue(form.is_valid()) impt = form.save(self.ishtar_user) @@ -807,12 +853,15 @@ class ImportFindTest(ImportTest, FindInit, TestCase): self.assertIn(box.parent_id, [s.pk for s in areas]) importer_type = ImporterType.objects.get(slug="importeur-test") - cols = list(ImporterColumn.objects.filter( - importer_type=importer_type, - col_number__gte=5).values_list("id", flat=True)) + cols = list( + ImporterColumn.objects.filter( + importer_type=importer_type, col_number__gte=5 + ).values_list("id", flat=True) + ) for target in ImportTarget.objects.filter(column_id__in=cols): - target.target = target.target.replace("set_localisation", - "set_static_localisation") + target.target = target.target.replace( + "set_localisation", "set_static_localisation" + ) target.save() # delete area 43 and all boxes @@ -826,9 +875,9 @@ class ImportFindTest(ImportTest, FindInit, TestCase): self.assertEqual(len(impt.errors), 2) for error in impt.errors: self.assertEqual( - error['error'], - "The division Area 43 do not exist for the location Warehouse " - "test.") + error["error"], + "The division Area 43 do not exist for the location Warehouse " "test.", + ) def tearDown(self): self.tmpdir.cleanup() @@ -840,10 +889,9 @@ class FindTest(FindInit, TestCase): def setUp(self): self.create_finds(force=True) - self.password = 'mypassword' - self.username = 'myuser' - User.objects.create_superuser(self.username, 'myemail@test.com', - self.password) + self.password = "mypassword" + self.username = "myuser" + User.objects.create_superuser(self.username, "myemail@test.com", self.password) self.client = Client() self.client.login(username=self.username, password=self.password) @@ -853,21 +901,20 @@ class FindTest(FindInit, TestCase): self.assertEqual( find.external_id, "{}-{}".format( - find.get_first_base_find().context_record.external_id, - find.label)) + find.get_first_base_find().context_record.external_id, find.label + ), + ) self.assertEqual( base_find.external_id, - "{}-{}".format( - base_find.context_record.external_id, - base_find.label)) + "{}-{}".format(base_find.context_record.external_id, base_find.label), + ) base_find.label = "New label" base_find.save() base_find = models.BaseFind.objects.get(pk=base_find.pk) self.assertEqual( base_find.external_id, - "{}-{}".format( - base_find.context_record.external_id, - "New label")) + "{}-{}".format(base_find.context_record.external_id, "New label"), + ) cr = ContextRecord.objects.get(pk=base_find.context_record.pk) cr.label = "new-label-too" cr.skip_history_when_saving = True @@ -893,22 +940,21 @@ class FindTest(FindInit, TestCase): # default: {get_first_base_find__context_record__external_id}-{label} self.assertEqual(find.external_id, "PAT-12345-A1-new-label-too-hop") profile = get_current_profile(force=True) - profile.find_external_id = \ - "{get_first_base_find__context_record__external_id}-{label}-"\ - "{label}" + profile.find_external_id = ( + "{get_first_base_find__context_record__external_id}-{label}-" "{label}" + ) profile.save() find.save() find = models.Find.objects.get(pk=find.pk) - self.assertEqual(find.external_id, - "PAT-12345-A1-new-label-too-hop-hop") - profile.find_external_id = \ - "{get_first_base_find__context_record__external_id}-{label}-" \ + self.assertEqual(find.external_id, "PAT-12345-A1-new-label-too-hop-hop") + profile.find_external_id = ( + "{get_first_base_find__context_record__external_id}-{label}-" "{label}||lower||deduplicate" + ) profile.save() find.save() find = models.Find.objects.get(pk=find.pk) - self.assertEqual(find.external_id, - "pat-12345-a1-new-label-too-hop") + self.assertEqual(find.external_id, "pat-12345-a1-new-label-too-hop") def testIndex(self): profile = get_current_profile() @@ -918,26 +964,29 @@ class FindTest(FindInit, TestCase): op1 = self.create_operation()[-1] op2 = self.create_operation()[-1] - op1_cr1 = self.create_context_record(data={'label': "CR1", - 'operation': op1})[-1] - op1_cr2 = self.create_context_record(data={'label': "CR2", - 'operation': op1})[-1] - op2_cr1 = self.create_context_record(data={'label': "CR3", - 'operation': op2})[-1] - self.create_finds(data_base={'context_record': op1_cr1}) + op1_cr1 = self.create_context_record(data={"label": "CR1", "operation": op1})[ + -1 + ] + op1_cr2 = self.create_context_record(data={"label": "CR2", "operation": op1})[ + -1 + ] + op2_cr1 = self.create_context_record(data={"label": "CR3", "operation": op2})[ + -1 + ] + self.create_finds(data_base={"context_record": op1_cr1}) find_1 = self.finds[-1] bf_1 = models.BaseFind.objects.get(pk=self.base_finds[-1].pk) self.assertEqual(find_1.index, 1) self.assertEqual(bf_1.index, 1) # index is based on operations - self.create_finds(data_base={'context_record': op1_cr2}) + self.create_finds(data_base={"context_record": op1_cr2}) find_2 = self.finds[-1] bf_2 = models.BaseFind.objects.get(pk=self.base_finds[-1].pk) self.assertEqual(find_2.index, 2) self.assertEqual(bf_2.index, 2) - self.create_finds(data_base={'context_record': op2_cr1}) + self.create_finds(data_base={"context_record": op2_cr1}) find_3 = self.finds[-1] bf_3 = models.BaseFind.objects.get(pk=self.base_finds[-1].pk) self.assertEqual(find_3.index, 1) @@ -949,24 +998,26 @@ class FindTest(FindInit, TestCase): profile = get_current_profile(force=True) op3 = self.create_operation()[-1] - op3_cr1 = self.create_context_record(data={'label': "CR1", - 'operation': op3})[-1] - op3_cr2 = self.create_context_record(data={'label': "CR2", - 'operation': op3})[-1] - self.create_finds(data_base={'context_record': op3_cr1}) + op3_cr1 = self.create_context_record(data={"label": "CR1", "operation": op3})[ + -1 + ] + op3_cr2 = self.create_context_record(data={"label": "CR2", "operation": op3})[ + -1 + ] + self.create_finds(data_base={"context_record": op3_cr1}) find_1b = self.finds[-1] bf_1b = models.BaseFind.objects.get(pk=self.base_finds[-1].pk) self.assertEqual(find_1b.index, 1) self.assertEqual(bf_1b.index, 1) # index now based on context records - self.create_finds(data_base={'context_record': op3_cr2}) + self.create_finds(data_base={"context_record": op3_cr2}) find_2b = self.finds[-1] bf_2b = models.BaseFind.objects.get(pk=self.base_finds[-1].pk) self.assertEqual(find_2b.index, 1) self.assertEqual(bf_2b.index, 1) - self.create_finds(data_base={'context_record': op3_cr2}) + self.create_finds(data_base={"context_record": op3_cr2}) find_3b = self.finds[-1] bf_3b = models.BaseFind.objects.get(pk=self.base_finds[-1].pk) self.assertEqual(find_3b.index, 2) @@ -974,17 +1025,18 @@ class FindTest(FindInit, TestCase): def test_show(self): obj = self.finds[0] - response = self.client.get(reverse('display-find', args=[obj.pk])) + response = self.client.get(reverse("display-find", args=[obj.pk])) self.assertEqual(response.status_code, 200) - self.assertIn('load_window("/show-find/{}/");'.format(obj.pk), - response.content.decode()) + self.assertIn( + 'load_window("/show-find/{}/");'.format(obj.pk), response.content.decode() + ) c = Client() - response = c.get(reverse('show-find', kwargs={'pk': obj.pk})) + response = c.get(reverse("show-find", kwargs={"pk": obj.pk})) # empty content when not allowed self.assertRedirects(response, "/") c.login(username=self.username, password=self.password) - response = self.client.get(reverse('show-find', kwargs={'pk': obj.pk})) + response = self.client.get(reverse("show-find", kwargs={"pk": obj.pk})) self.assertEqual(response.status_code, 200) self.assertIn(b'class="card sheet"', response.content) @@ -996,11 +1048,13 @@ class FindTest(FindInit, TestCase): self.finds[0].delete() # on delete the selected base find is not deleted if another find # is related to it - self.assertEqual(models.BaseFind.objects.filter( - pk=self.base_finds[0].pk).count(), 1) + self.assertEqual( + models.BaseFind.objects.filter(pk=self.base_finds[0].pk).count(), 1 + ) self.finds[1].delete() - self.assertEqual(models.BaseFind.objects.filter( - pk=self.base_finds[0].pk).count(), 0) + self.assertEqual( + models.BaseFind.objects.filter(pk=self.base_finds[0].pk).count(), 0 + ) def test_get_material_types(self): mat0 = models.MaterialType.objects.all()[0] @@ -1014,71 +1068,68 @@ class FindTest(FindInit, TestCase): find0.material_types.add(mat1) self.assertEqual( - find0.get_material_types(), - ", ".join(sorted([mat0.label, mat1.label]))) + find0.get_material_types(), ", ".join(sorted([mat0.label, mat1.label])) + ) self.assertEqual( - find0.get_material_types_code(), - "|".join(sorted([mat0.code, mat1.code]))) + find0.get_material_types_code(), "|".join(sorted([mat0.code, mat1.code])) + ) class FindSearchTest(FindInit, TestCase, SearchText): fixtures = WAREHOUSE_FIXTURES model = models.Find - SEARCH_URL = 'get-find' + SEARCH_URL = "get-find" def setUp(self): self.create_finds(force=True) self.create_finds(force=True) - self.username = 'myuser' - self.password = 'mypassword' - User.objects.create_superuser(self.username, 'myemail@test.com', - self.password) + self.username = "myuser" + self.password = "mypassword" + User.objects.create_superuser(self.username, "myemail@test.com", self.password) self.client = Client() def test_material_type_hierarchic_search(self): find = self.finds[0] c = Client() - metal = models.MaterialType.objects.get(txt_idx='metal') - iron_metal = models.MaterialType.objects.get(txt_idx='iron_metal') - not_iron_metal = models.MaterialType.objects.get( - txt_idx='not_iron_metal') + metal = models.MaterialType.objects.get(txt_idx="metal") + iron_metal = models.MaterialType.objects.get(txt_idx="iron_metal") + not_iron_metal = models.MaterialType.objects.get(txt_idx="not_iron_metal") find.material_types.add(iron_metal) find = models.Find.objects.get(pk=find.pk) find.save() - search = {'material_types': iron_metal.pk} + search = {"material_types": iron_metal.pk} # no result when no authentication - response = c.get(reverse('get-find'), search) + response = c.get(reverse("get-find"), search) self.assertRedirects(response, "/") c.login(username=self.username, password=self.password) # one result for exact search - response = c.get(reverse('get-find'), search) + response = c.get(reverse("get-find"), search) self.assertEqual(response.status_code, 200) content = response.content.decode() res = json.loads(content) - self.assertEqual(res['recordsTotal'], 1) - self.assertEqual(res["rows"][0]["cached_materials"], - str(iron_metal)) + self.assertEqual(res["recordsTotal"], 1) + self.assertEqual(res["rows"][0]["cached_materials"], str(iron_metal)) # no result for the brother - search = {'material_types': not_iron_metal.pk} - response = c.get(reverse('get-find'), search) + search = {"material_types": not_iron_metal.pk} + response = c.get(reverse("get-find"), search) self.assertEqual(response.status_code, 200) content = response.content.decode() - self.assertEqual(json.loads(content)['recordsTotal'], 0) + self.assertEqual(json.loads(content)["recordsTotal"], 0) # one result for the father - search = {'material_types': metal.pk} - response = c.get(reverse('get-find'), search) + search = {"material_types": metal.pk} + response = c.get(reverse("get-find"), search) self.assertEqual(response.status_code, 200) content = response.content.decode() - self.assertEqual(json.loads(content)['recordsTotal'], 1) + self.assertEqual(json.loads(content)["recordsTotal"], 1) # test on text search - material_key = str(pgettext_lazy("key for text search", 'material')) + material_key = str(pgettext_lazy("key for text search", "material")) result = [ ('{}="{}"'.format(material_key, str(iron_metal)), 1), ('{}="{}"'.format(material_key, str(not_iron_metal)), 0), @@ -1093,67 +1144,67 @@ class FindSearchTest(FindInit, TestCase, SearchText): # operation with no associated find operation = create_operation(self.user, values={"year": 2017}) c.get(reverse("pin", args=["operation", operation.pk])) - response = c.get(reverse('get-find'), {}) # empty search -> check pined + response = c.get(reverse("get-find"), {}) # empty search -> check pined self.assertEqual(response.status_code, 200) content = response.content.decode() - self.assertEqual(json.loads(content)['recordsTotal'], 0) + self.assertEqual(json.loads(content)["recordsTotal"], 0) # pinned operation with current find find = self.finds[0] - c.get(reverse( - "pin", - args=["operation", - find.get_first_base_find().context_record.operation.pk])) - response = c.get(reverse('get-find'), {}) # empty search -> check pined + c.get( + reverse( + "pin", + args=[ + "operation", + find.get_first_base_find().context_record.operation.pk, + ], + ) + ) + response = c.get(reverse("get-find"), {}) # empty search -> check pined self.assertEqual(response.status_code, 200) content = response.content.decode() - self.assertEqual(json.loads(content)['recordsTotal'], 1) + self.assertEqual(json.loads(content)["recordsTotal"], 1) def test_period_hierarchic_search(self): find = self.finds[0] c = Client() - neo = Period.objects.get(txt_idx='neolithic') - final_neo = Period.objects.get(txt_idx='final-neolithic') - recent_neo = Period.objects.get(txt_idx='recent-neolithic') - dating = Dating.objects.create( - period=final_neo - ) + neo = Period.objects.get(txt_idx="neolithic") + final_neo = Period.objects.get(txt_idx="final-neolithic") + recent_neo = Period.objects.get(txt_idx="recent-neolithic") + dating = Dating.objects.create(period=final_neo) find.datings.add(dating) find = models.Find.objects.get(pk=find.pk) find.save() - search = {'datings__period': final_neo.pk} + search = {"datings__period": final_neo.pk} # no result when no authentication - response = c.get(reverse('get-find'), search) + response = c.get(reverse("get-find"), search) self.assertRedirects(response, "/") # one result for exact search c.login(username=self.username, password=self.password) - response = c.get(reverse('get-find'), search) + response = c.get(reverse("get-find"), search) self.assertEqual(response.status_code, 200) res = json.loads(response.content.decode()) - self.assertEqual(res['recordsTotal'], 1) - self.assertEqual(res["rows"][0]["cached_periods"], - str(final_neo)) + self.assertEqual(res["recordsTotal"], 1) + self.assertEqual(res["rows"][0]["cached_periods"], str(final_neo)) # no result for the brother - search = {'datings__period': recent_neo.pk} - response = c.get(reverse('get-find'), search) + search = {"datings__period": recent_neo.pk} + response = c.get(reverse("get-find"), 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 = {'datings__period': neo.pk} - response = c.get(reverse('get-find'), search) + search = {"datings__period": neo.pk} + response = c.get(reverse("get-find"), 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", 'datings-period')) + period_key = str(pgettext_lazy("key for text search", "datings-period")) result = [ ('{}="{}"'.format(period_key, str(final_neo)), 1), ('{}="{}"'.format(period_key, str(recent_neo)), 0), @@ -1176,36 +1227,36 @@ class FindSearchTest(FindInit, TestCase, SearchText): find.conservatory_state = cs2 find.save() - search = {'search_vector': f'conservatory="{cs2.name}"'} + search = {"search_vector": f'conservatory="{cs2.name}"'} # no result when no authentication - response = c.get(reverse('get-find'), search) + response = c.get(reverse("get-find"), search) self.assertRedirects(response, "/") c.login(username=self.username, password=self.password) # one result for exact search - response = c.get(reverse('get-find'), search) + response = c.get(reverse("get-find"), search) self.assertEqual(response.status_code, 200) content = response.content.decode() - self.assertEqual(json.loads(content)['recordsTotal'], 1) + self.assertEqual(json.loads(content)["recordsTotal"], 1) # no result for the brother - search = {'search_vector': f'conservatory="{cs3.name}"'} - response = c.get(reverse('get-find'), search) + search = {"search_vector": f'conservatory="{cs3.name}"'} + response = c.get(reverse("get-find"), search) self.assertEqual(response.status_code, 200) content = response.content.decode() - self.assertEqual(json.loads(content)['recordsTotal'], 0) + self.assertEqual(json.loads(content)["recordsTotal"], 0) # one result for the father - search = {'search_vector': f'conservatory="{cs1.name}"'} - response = c.get(reverse('get-find'), search) + search = {"search_vector": f'conservatory="{cs1.name}"'} + response = c.get(reverse("get-find"), search) self.assertEqual(response.status_code, 200) content = response.content.decode() - self.assertEqual(json.loads(content)['recordsTotal'], 1) + self.assertEqual(json.loads(content)["recordsTotal"], 1) # test on text search - key = str(pgettext_lazy("key for text search", 'conservatory')) + key = str(pgettext_lazy("key for text search", "conservatory")) result = [ ('{}="{}"'.format(key, str(cs2)), 1), ('{}="{}"'.format(key, str(cs3)), 0), @@ -1216,27 +1267,30 @@ class FindSearchTest(FindInit, TestCase, SearchText): def test_image_search(self): c = Client() c.login(username=self.username, password=self.password) - search = {'documents__image__isnull': 2} # 2 for nullboolfield is None - response = c.get(reverse('get-find'), search) + search = {"documents__image__isnull": 2} # 2 for nullboolfield is None + response = c.get(reverse("get-find"), search) self.assertEqual(response.status_code, 200) res = json.loads(response.content.decode()) - self.assertEqual(res['recordsTotal'], 0) + self.assertEqual(res["recordsTotal"], 0) # add an image to the first find document = Document.objects.create(title="Image!") - image_path = settings.ROOT_PATH + \ - '../ishtar_common/static/media/images/ishtar-bg.jpg' + image_path = ( + settings.ROOT_PATH + "../ishtar_common/static/media/images/ishtar-bg.jpg" + ) document.image = SimpleUploadedFile( - name='ishtar-bg.jpg', content=open(image_path, 'rb').read(), - content_type='image/jpeg') + name="ishtar-bg.jpg", + content=open(image_path, "rb").read(), + content_type="image/jpeg", + ) document.save() self.finds[0].documents.add(document) self.finds[0].save() - response = c.get(reverse('get-find'), search) + response = c.get(reverse("get-find"), search) self.assertEqual(response.status_code, 200) res = json.loads(response.content.decode()) - self.assertEqual(res['recordsTotal'], 1) + self.assertEqual(res["recordsTotal"], 1) def test_search_with_callable(self): find = self.finds[0] @@ -1244,21 +1298,21 @@ class FindSearchTest(FindInit, TestCase, SearchText): c = Client() c.login(username=self.username, password=self.password) - loan_key = str(pgettext_lazy("key for text search", 'loan')) + loan_key = str(pgettext_lazy("key for text search", "loan")) result = [ ('{}="{}"'.format(loan_key, str(_("Yes"))), 0), ('{}="{}"'.format(loan_key, str(_("No"))), 0), - ] + ] self._test_search(c, result, context="No container defined") warehouse = Warehouse.objects.create( - name="Lambda warehouse", - warehouse_type=WarehouseType.objects.all()[0]) + name="Lambda warehouse", warehouse_type=WarehouseType.objects.all()[0] + ) container = Container.objects.create( location=warehouse, responsible=warehouse, - container_type=ContainerType.objects.all()[0] + container_type=ContainerType.objects.all()[0], ) find.container_ref = container find.container = container @@ -1266,7 +1320,7 @@ class FindSearchTest(FindInit, TestCase, SearchText): container2 = Container.objects.create( location=warehouse, responsible=warehouse, - container_type=ContainerType.objects.all()[0] + container_type=ContainerType.objects.all()[0], ) find2.container_ref = container2 find2.container = container2 @@ -1276,8 +1330,9 @@ class FindSearchTest(FindInit, TestCase, SearchText): ('{}="{}"'.format(loan_key, str(_("Yes"))), 0), ('{}="{}"'.format(loan_key, str(_("No"))), 2), ] - self._test_search(c, result, context="All container in their " - "reference location") + self._test_search( + c, result, context="All container in their " "reference location" + ) find2.container = container find2.save() @@ -1285,8 +1340,9 @@ class FindSearchTest(FindInit, TestCase, SearchText): ('{}="{}"'.format(loan_key, str(_("Yes"))), 1), ('{}="{}"'.format(loan_key, str(_("No"))), 1), ] - self._test_search(c, result, context="One container in his " - "reference location") + self._test_search( + c, result, context="One container in his " "reference location" + ) class FindAutocompleteTest(FindInit, TestCase): @@ -1298,10 +1354,9 @@ class FindAutocompleteTest(FindInit, TestCase): self.create_finds(force=True) self.create_finds(force=True) self.create_finds(force=True) - self.username = 'myuser' - self.password = 'mypassword' - User.objects.create_superuser(self.username, 'myemail@test.com', - self.password) + self.username = "myuser" + self.password = "mypassword" + User.objects.create_superuser(self.username, "myemail@test.com", self.password) self.client = Client() def test_autocomplete(self): @@ -1319,14 +1374,14 @@ class FindAutocompleteTest(FindInit, TestCase): find4.save() c = Client() c.login(username=self.username, password=self.password) - response = c.get(reverse('autocomplete-find') + "?term=12") + response = c.get(reverse("autocomplete-find") + "?term=12") self.assertEqual(response.status_code, 200) content = response.content.decode() res = json.loads(content) self.assertEqual(len(res), 3) - self.assertEqual(res[0]['id'], find2.pk) # " 12" - startswith - self.assertEqual(res[1]['id'], find.pk) # 12 - endswith - self.assertEqual(res[2]['id'], find4.pk) # 12 - contains + self.assertEqual(res[0]["id"], find2.pk) # " 12" - startswith + self.assertEqual(res[1]["id"], find.pk) # 12 - endswith + self.assertEqual(res[2]["id"], find4.pk) # 12 - contains class FindPermissionTest(FindInit, TestCase): @@ -1336,23 +1391,26 @@ class FindPermissionTest(FindInit, TestCase): def setUp(self): self.username, self.password, self.user = create_superuser() self.alt_username, self.alt_password, self.alt_user = create_user() - ct_find = ContentType.objects.get(app_label='archaeological_finds', - model='find') - self.alt_user.user_permissions.add(Permission.objects.get( - codename='view_own_find', content_type=ct_find)) - self.alt_user.user_permissions.add(Permission.objects.get( - codename='change_own_find', content_type=ct_find)) + ct_find = ContentType.objects.get( + app_label="archaeological_finds", model="find" + ) + self.alt_user.user_permissions.add( + Permission.objects.get(codename="view_own_find", content_type=ct_find) + ) + self.alt_user.user_permissions.add( + Permission.objects.get(codename="change_own_find", content_type=ct_find) + ) 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'), + profile_type=ProfileType.objects.get(txt_idx="collaborator"), 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) @@ -1361,18 +1419,20 @@ class FindPermissionTest(FindInit, TestCase): self.create_operation(self.alt_user, self.orgas[0]) self.create_context_record( - user=self.user, - data={"label": "CR 1", "operation": self.operations[0]}) + user=self.user, data={"label": "CR 1", "operation": self.operations[0]} + ) self.create_context_record( - user=self.alt_user, - data={"label": "CR 2", "operation": self.operations[1]}) + user=self.alt_user, data={"label": "CR 2", "operation": self.operations[1]} + ) self.cr_1 = self.context_records[-2] self.cr_2 = self.context_records[-1] - self.create_finds(data_base={'context_record': self.cr_1}, - user=self.user, force=True) - self.create_finds(data_base={'context_record': self.cr_2}, - user=self.alt_user, force=True) + self.create_finds( + data_base={"context_record": self.cr_1}, user=self.user, force=True + ) + self.create_finds( + data_base={"context_record": self.cr_2}, user=self.alt_user, force=True + ) self.find_1 = self.finds[-2] self.find_2 = self.finds[-1] @@ -1381,27 +1441,26 @@ class FindPermissionTest(FindInit, TestCase): def test_own_search(self): # no result when no authentification c = Client() - response = c.get(reverse('get-find')) - self.assertTrue(not response.content or - not json.loads(response.content)) + response = c.get(reverse("get-find")) + self.assertTrue(not response.content or not json.loads(response.content)) # possession c = Client() c.login(username=self.alt_username, password=self.alt_password) - response = c.get(reverse('get-find')) + response = c.get(reverse("get-find")) # only one "own" context record available content = response.content.decode() self.assertTrue(json.loads(content)) - self.assertEqual(json.loads(content)['recordsTotal'], 1) + self.assertEqual(json.loads(content)["recordsTotal"], 1) # area filter c = Client() c.login(username=self.alt_username2, password=self.alt_password2) - response = c.get(reverse('get-find')) + response = c.get(reverse("get-find")) # only one "own" operation available content = response.content.decode() self.assertTrue(json.loads(content)) - self.assertEqual(json.loads(content)['recordsTotal'], 1) + self.assertEqual(json.loads(content)["recordsTotal"], 1) class FindQATest(FindInit, TestCase): @@ -1413,17 +1472,16 @@ class FindQATest(FindInit, TestCase): self.create_finds(data_base={"label": "Find 2"}, force=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='change_find')) + self.alt_user.user_permissions.add( + Permission.objects.get(codename="change_find") + ) def test_duplicate(self): t1, __ = models.Treatment.objects.get_or_create( - label="Treatment 1", - treatment_state=models.TreatmentState.objects.all()[0] + label="Treatment 1", treatment_state=models.TreatmentState.objects.all()[0] ) t2, __ = models.Treatment.objects.get_or_create( - label="Treatment 1", - treatment_state=models.TreatmentState.objects.all()[0] + label="Treatment 1", treatment_state=models.TreatmentState.objects.all()[0] ) find = self.finds[0] default_desc = "Description for duplicate" @@ -1435,9 +1493,9 @@ class FindQATest(FindInit, TestCase): find.treatments.add(t2) c = Client() - url = reverse('find-qa-duplicate', args=[find.pk]) + url = reverse("find-qa-duplicate", args=[find.pk]) response = c.get(url) - self.assertRedirects(response, '/') + self.assertRedirects(response, "/") c = Client() c.login(username=self.username, password=self.password) @@ -1449,19 +1507,16 @@ class FindQATest(FindInit, TestCase): response = c.get(url) self.assertEqual(response.status_code, 200) - data = { - "denomination": "clone", - "label": "clone - free id" - } + data = {"denomination": "clone", "label": "clone - free id"} nb_find = models.Find.objects.count() nb_bf = models.BaseFind.objects.count() response = c.post(url, data) self.assertEqual(response.status_code, 302) # success redirect self.assertEqual(models.Find.objects.count(), nb_find + 1) self.assertEqual(models.BaseFind.objects.count(), nb_bf + 1) - new = models.Find.objects.order_by('-pk').all()[0] + new = models.Find.objects.order_by("-pk").all()[0] self.assertEqual(new.description, default_desc) - new_bf = models.BaseFind.objects.order_by('-pk').all()[0] + new_bf = models.BaseFind.objects.order_by("-pk").all()[0] base_bf = find.get_first_base_find() self.assertEqual(new_bf.context_record, base_bf.context_record) self.assertNotIn(d, list(new.documents.all())) @@ -1473,17 +1528,17 @@ class FindQATest(FindInit, TestCase): def test_bulk_update(self): c = Client() pks = "{}-{}".format(self.finds[0].pk, self.finds[1].pk) - response = c.get(reverse('find-qa-bulk-update', args=[pks])) - self.assertRedirects(response, '/') + response = c.get(reverse("find-qa-bulk-update", args=[pks])) + self.assertRedirects(response, "/") c = Client() c.login(username=self.username, password=self.password) - response = c.get(reverse('find-qa-bulk-update', args=[pks])) + response = c.get(reverse("find-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('find-qa-bulk-update', args=[pks])) + response = c.get(reverse("find-qa-bulk-update", args=[pks])) self.assertEqual(response.status_code, 200) find_0 = self.finds[0] @@ -1496,51 +1551,45 @@ class FindQATest(FindInit, TestCase): find_1.save() period = Period.objects.all()[0].pk - self.assertNotIn(period, - [dating.period.pk for dating in find_0.datings.all()]) - self.assertNotIn(period, - [dating.period.pk for dating in find_1.datings.all()]) + self.assertNotIn(period, [dating.period.pk for dating in find_0.datings.all()]) + self.assertNotIn(period, [dating.period.pk for dating in find_1.datings.all()]) extra_desc = "Extra description" response = c.post( - reverse('find-qa-bulk-update-confirm', args=[pks]), - {'qa_period': period, 'qa_description': extra_desc} + reverse("find-qa-bulk-update-confirm", args=[pks]), + {"qa_period": period, "qa_description": extra_desc}, ) if response.status_code != 200: - self.assertRedirects(response, '/success/') - self.assertIn(period, - [dating.period.pk for dating in find_0.datings.all()]) - self.assertIn(period, - [dating.period.pk for dating in find_1.datings.all()]) - self.assertEqual(models.Find.objects.get(pk=find_0.pk).description, - base_desc_0 + "\n" + extra_desc) - self.assertEqual(models.Find.objects.get(pk=find_1.pk).description, - base_desc_1 + "\n" + extra_desc) + self.assertRedirects(response, "/success/") + self.assertIn(period, [dating.period.pk for dating in find_0.datings.all()]) + self.assertIn(period, [dating.period.pk for dating in find_1.datings.all()]) + self.assertEqual( + models.Find.objects.get(pk=find_0.pk).description, + base_desc_0 + "\n" + extra_desc, + ) + self.assertEqual( + models.Find.objects.get(pk=find_1.pk).description, + base_desc_1 + "\n" + extra_desc, + ) def test_basket(self): find_0 = self.finds[0] find_1 = self.finds[1] nb_basket = models.FindBasket.objects.count() - url = reverse('find-qa-basket', args=[find_0.pk]) + url = reverse("find-qa-basket", args=[find_0.pk]) c = Client() response = c.get(url) - self.assertRedirects(response, '/') + self.assertRedirects(response, "/") c.login(username=self.username, password=self.password) response = c.get(url) self.assertEqual(response.status_code, 200) label = "Test - basket" - data = { - "qa_bf_create_or_update": "create", - "qa_bf_label": label - } + data = {"qa_bf_create_or_update": "create", "qa_bf_label": label} response = c.post(url, data) if response.status_code != 200: - self.assertRedirects(response, '/success/') - self.assertEqual( - nb_basket + 1, - models.FindBasket.objects.count()) - q = models.FindBasket.objects.filter( - user=self.user.ishtaruser, label=label) + self.assertRedirects(response, "/success/") + self.assertEqual(nb_basket + 1, models.FindBasket.objects.count()) + q = models.FindBasket.objects.filter(user=self.user.ishtaruser, label=label) self.assertEqual(q.count(), 1) # no duplicate with same user, same name c.post(url, data) @@ -1549,12 +1598,9 @@ class FindQATest(FindInit, TestCase): self.assertEqual(basket.items.count(), 1) # update - url = reverse('find-qa-basket', args=[find_1.pk]) + url = reverse("find-qa-basket", args=[find_1.pk]) self.assertEqual(basket.items.count(), 1) - data = { - "qa_bf_create_or_update": "update", - "qa_bf_basket": basket.pk - } + data = {"qa_bf_create_or_update": "update", "qa_bf_basket": basket.pk} c.post(url, data) self.assertEqual(basket.items.count(), 2) self.assertIn(find_1, list(basket.items.all())) @@ -1578,11 +1624,12 @@ class FindQATest(FindInit, TestCase): find_0 = self.finds[0] find_1 = self.finds[1] pks = "{}-{}".format(find_0.pk, find_1.pk) - url = reverse('find-qa-packaging', args=[pks]) + url = reverse("find-qa-packaging", args=[pks]) response = c.get(url) - self.assertRedirects(response, '/') + self.assertRedirects(response, "/") profile, created = IshtarSiteProfile.objects.get_or_create( - slug='default', active=True) + slug="default", active=True + ) profile.warehouse = False profile.save() @@ -1603,60 +1650,61 @@ class FindQATest(FindInit, TestCase): self.assertEqual(response.status_code, 200) main_warehouse = Warehouse.objects.create( - name="Main", - warehouse_type=WarehouseType.objects.all()[0] + name="Main", warehouse_type=WarehouseType.objects.all()[0] ) container = Container.objects.create( - reference="Test", responsible=main_warehouse, + reference="Test", + responsible=main_warehouse, location=main_warehouse, - container_type=ContainerType.objects.all()[0] + container_type=ContainerType.objects.all()[0], ) container2 = Container.objects.create( - reference="Test2", responsible=main_warehouse, + reference="Test2", + responsible=main_warehouse, location=main_warehouse, - container_type=ContainerType.objects.all()[0] + container_type=ContainerType.objects.all()[0], ) - packaging = models.TreatmentType.objects.get(txt_idx='packaging') + packaging = models.TreatmentType.objects.get(txt_idx="packaging") packaging.change_reference_location = True packaging.save() data_check_lst = [ - ({ - 'qa-packaging-container': container.pk, - 'qa-packaging-container_to_change': 'reference', - }, - { - 'container_ref': container, - 'container': None - }, 0), - ({ - 'qa-packaging-container': container2.pk, - 'qa-packaging-container_to_change': 'current', - }, - { - 'container_ref': None, - 'container': container2 - }, 0), - ({ - 'qa-packaging-container': container.pk, - 'qa-packaging-container_to_change': 'current-and-reference', - }, - { - 'container_ref': container, - 'container': container - }, 0), - ({ - 'qa-packaging-container': container2.pk, - 'qa-packaging-container_to_change': 'reference', - 'qa-packaging-create_treatment': True, - 'qa-packaging-year': 2019, - 'qa-packaging-treatment_type': packaging.pk - }, - { - 'container_ref': container2, - 'container': None - }, 1), + ( + { + "qa-packaging-container": container.pk, + "qa-packaging-container_to_change": "reference", + }, + {"container_ref": container, "container": None}, + 0, + ), + ( + { + "qa-packaging-container": container2.pk, + "qa-packaging-container_to_change": "current", + }, + {"container_ref": None, "container": container2}, + 0, + ), + ( + { + "qa-packaging-container": container.pk, + "qa-packaging-container_to_change": "current-and-reference", + }, + {"container_ref": container, "container": container}, + 0, + ), + ( + { + "qa-packaging-container": container2.pk, + "qa-packaging-container_to_change": "reference", + "qa-packaging-create_treatment": True, + "qa-packaging-year": 2019, + "qa-packaging-treatment_type": packaging.pk, + }, + {"container_ref": container2, "container": None}, + 1, + ), ] for data, check, nb_treat in data_check_lst: @@ -1670,10 +1718,8 @@ class FindQATest(FindInit, TestCase): init_nb_treat = models.Treatment.objects.count() - response = c.post( - reverse('find-qa-packaging', args=[pks]), - data) - self.assertRedirects(response, '/success/') + response = c.post(reverse("find-qa-packaging", args=[pks]), data) + self.assertRedirects(response, "/success/") for k in check: find = models.Find.objects.get(pk=find_0.pk) self.assertEqual(getattr(find, k), check[k]) @@ -1696,31 +1742,29 @@ class FindHistoryTest(FindInit, TestCase): def _add_datings(self, find): d1_attrs = { - "period": Period.objects.get(txt_idx='neolithic'), + "period": Period.objects.get(txt_idx="neolithic"), "start_date": 5000, - 'end_date': 5001, - 'dating_type': DatingType.objects.get( - txt_idx='from_absolute_dating'), - "quality": DatingQuality.objects.get(txt_idx='sure'), - "precise_dating": "Blah !!!" + "end_date": 5001, + "dating_type": DatingType.objects.get(txt_idx="from_absolute_dating"), + "quality": DatingQuality.objects.get(txt_idx="sure"), + "precise_dating": "Blah !!!", } d1 = Dating.objects.create(**d1_attrs) d2_attrs = { - "period": Period.objects.get(txt_idx='paleolithic'), + "period": Period.objects.get(txt_idx="paleolithic"), } d2 = Dating.objects.create(**d2_attrs) d1_dct, d2_dct = {}, {} for k in Dating.HISTORY_ATTR: - for dct, attr in ((d1_dct, d1_attrs) , - (d2_dct, d2_attrs)): + for dct, attr in ((d1_dct, d1_attrs), (d2_dct, d2_attrs)): if k in attr: - if hasattr(attr[k], 'txt_idx'): + if hasattr(attr[k], "txt_idx"): dct[k] = attr[k].txt_idx else: dct[k] = str(attr[k]) else: - dct[k] = '' + dct[k] = "" find.datings.add(d1) find.datings.add(d2) @@ -1730,8 +1774,8 @@ class FindHistoryTest(FindInit, TestCase): find = self.finds[0] user = self.get_default_user() - ceram = models.MaterialType.objects.get(txt_idx='ceramic').pk - glass = models.MaterialType.objects.get(txt_idx='glass').pk + ceram = models.MaterialType.objects.get(txt_idx="ceramic").pk + glass = models.MaterialType.objects.get(txt_idx="glass").pk find = models.Find.objects.get(pk=find.pk) nb_hist = find.history.count() @@ -1745,49 +1789,50 @@ class FindHistoryTest(FindInit, TestCase): find = models.Find.objects.get(pk=find.pk) self.assertIsNotNone(find.history_m2m) - self.assertIn('material_types', find.history_m2m) + self.assertIn("material_types", find.history_m2m) self.assertIn( - find.history_m2m['material_types'], - [['ceramic', 'glass'], # order do not - ['glass', 'ceramic']]) # matter - self.assertIn('datings', find.history_m2m) + find.history_m2m["material_types"], + [["ceramic", "glass"], ["glass", "ceramic"]], # order do not + ) # matter + self.assertIn("datings", find.history_m2m) self.assertIn( - find.history_m2m['datings'], - [[d1_txt, d2_txt], # order do not - [d2_txt, d1_txt]]) # matter + find.history_m2m["datings"], + [[d1_txt, d2_txt], [d2_txt, d1_txt]], # order do not + ) # matter self.assertEqual(find.history.count(), nb_hist + 1) - historical_material_types = find.history_m2m['material_types'] + historical_material_types = find.history_m2m["material_types"] find = models.Find.objects.get(pk=find.pk) find.label = "hop hop hop2" find.history_modifier = user - if hasattr(find, 'skip_history_when_saving'): - delattr(find, 'skip_history_when_saving') + if hasattr(find, "skip_history_when_saving"): + delattr(find, "skip_history_when_saving") find._force_history = True find.save() find.material_types.remove(ceram) find.datings.clear() find = models.Find.objects.get(pk=find.pk) - self.assertEqual(find.history_m2m['material_types'], ['glass']) - self.assertEqual(find.history_m2m['datings'], []) + self.assertEqual(find.history_m2m["material_types"], ["glass"]) + self.assertEqual(find.history_m2m["datings"], []) self.assertEqual(find.history.count(), nb_hist + 2) - self.assertEqual(find.history.all()[1].history_m2m['material_types'], - historical_material_types) - self.assertEqual(find.history.all()[0].history_m2m['material_types'], - ["glass"]) + self.assertEqual( + find.history.all()[1].history_m2m["material_types"], + historical_material_types, + ) + self.assertEqual(find.history.all()[0].history_m2m["material_types"], ["glass"]) def _init_m2m(self, find, user): - ceram = models.MaterialType.objects.get(txt_idx='ceramic').pk - glass = models.MaterialType.objects.get(txt_idx='glass').pk + ceram = models.MaterialType.objects.get(txt_idx="ceramic").pk + glass = models.MaterialType.objects.get(txt_idx="glass").pk find = models.Find.objects.get(pk=find.pk) find.history_modifier = user find.label = "hop hop hop1" find._force_history = True - if hasattr(find, 'skip_history_when_saving'): - delattr(find, 'skip_history_when_saving') + if hasattr(find, "skip_history_when_saving"): + delattr(find, "skip_history_when_saving") find.save() find.material_types.add(ceram) find.material_types.add(glass) @@ -1797,8 +1842,8 @@ class FindHistoryTest(FindInit, TestCase): find.history_modifier = user find.label = "hop hop hop2" find._force_history = True - if hasattr(find, 'skip_history_when_saving'): - delattr(find, 'skip_history_when_saving') + if hasattr(find, "skip_history_when_saving"): + delattr(find, "skip_history_when_saving") find.save() find.datings.clear() find.material_types.remove(ceram) @@ -1810,32 +1855,35 @@ class FindHistoryTest(FindInit, TestCase): self._init_m2m(find, user) find = models.Find.objects.get(pk=find.pk) - history_date = find.history.order_by('-history_date').all()[ - 1].history_date.strftime('%Y-%m-%dT%H:%M:%S.%f') + history_date = ( + find.history.order_by("-history_date") + .all()[1] + .history_date.strftime("%Y-%m-%dT%H:%M:%S.%f") + ) c.login(username=self.username, password=self.password) - response = c.get(reverse('show-find', - kwargs={'pk': find.pk})) + response = c.get(reverse("show-find", kwargs={"pk": find.pk})) self.assertEqual(response.status_code, 200) self.assertIn(b'class="card sheet"', response.content) - content = response.content.decode('utf-8') - self.assertNotIn( - Period.objects.get(txt_idx='neolithic').label, content) + content = response.content.decode("utf-8") + self.assertNotIn(Period.objects.get(txt_idx="neolithic").label, content) self.assertNotIn("5001", content) - response = c.get(reverse('show-historized-find', - kwargs={'pk': find.pk, - 'date': history_date})) + response = c.get( + reverse( + "show-historized-find", kwargs={"pk": find.pk, "date": history_date} + ) + ) self.assertEqual(response.status_code, 200) - content = response.content.decode('utf-8') + content = response.content.decode("utf-8") self.assertIn('class="card sheet"', content) self.assertIn( - models.MaterialType.objects.get(txt_idx='ceramic').label, content, - msg="ceramic not found in historical sheet") - self.assertIn("5001", content, msg="5001 not found in historical " - "sheet") - self.assertIn( - Period.objects.get(txt_idx='neolithic').label, content) + models.MaterialType.objects.get(txt_idx="ceramic").label, + content, + msg="ceramic not found in historical sheet", + ) + self.assertIn("5001", content, msg="5001 not found in historical " "sheet") + self.assertIn(Period.objects.get(txt_idx="neolithic").label, content) def test_m2m_history_restore(self): user = self.get_default_user() @@ -1843,16 +1891,15 @@ class FindHistoryTest(FindInit, TestCase): self._init_m2m(find, user) find = models.Find.objects.get(pk=find.pk) - ceram = models.MaterialType.objects.get(txt_idx='ceramic') - glass = models.MaterialType.objects.get(txt_idx='glass') + ceram = models.MaterialType.objects.get(txt_idx="ceramic") + glass = models.MaterialType.objects.get(txt_idx="glass") materials = list(find.material_types.all()) self.assertNotIn(ceram, materials) self.assertIn(glass, materials) self.assertEqual(list(find.datings.all()), []) - history_date = find.history.order_by('-history_date').all()[ - 1].history_date + history_date = find.history.order_by("-history_date").all()[1].history_date find.rollback(history_date) find = models.Find.objects.get(pk=find.pk) @@ -1865,10 +1912,10 @@ class FindHistoryTest(FindInit, TestCase): dating_dct = {} for k in self.d1_dct.keys(): if not getattr(dating, k): - dating_dct[k] = '' + dating_dct[k] = "" continue dating_dct[k] = getattr(dating, k) - if hasattr(dating_dct[k], 'txt_idx'): + if hasattr(dating_dct[k], "txt_idx"): dating_dct[k] = dating_dct[k].txt_idx dating_dct[k] = str(dating_dct[k]) @@ -1883,31 +1930,34 @@ class TreatmentTest(FindInit, TestCase): model = models.Find def setUp(self): - base_img = settings.ROOT_PATH + \ - '../ishtar_common/static/media/images/ishtar-bg.jpg' + base_img = ( + settings.ROOT_PATH + "../ishtar_common/static/media/images/ishtar-bg.jpg" + ) temp_dir = tempfile.gettempdir() - img = os.path.join(temp_dir, 'ishtar-bg.jpg') + img = os.path.join(temp_dir, "ishtar-bg.jpg") shutil.copy2(base_img, img) self.create_finds(data_base={"label": "Find 1"}, force=True) self.create_finds(data_base={"label": "Find 2"}, force=True) image = Document.objects.create(title="Image!") - image.image.save('ishtar-bg.jpg', File(open(img, "rb"))) + image.image.save("ishtar-bg.jpg", File(open(img, "rb"))) self.finds[0].documents.add(image) self.finds[0].save() self.basket = models.FindBasket.objects.create( - label="My basket", user=IshtarUser.objects.get( - pk=self.get_default_user().pk)) + label="My basket", + user=IshtarUser.objects.get(pk=self.get_default_user().pk), + ) self.other_basket = models.FindBasket.objects.create( - label="My other basket", user=IshtarUser.objects.get( - pk=self.get_default_user().pk)) + label="My other basket", + user=IshtarUser.objects.get(pk=self.get_default_user().pk), + ) for find in self.finds: self.basket.items.add(find) self.other_basket.items.add(find) def test_packaging_with_new_find_creation(self): - treatment_type = models.TreatmentType.objects.get(txt_idx='packaging') + treatment_type = models.TreatmentType.objects.get(txt_idx="packaging") # make packaging a treatment with a new version of the find created treatment_type.create_new_find = True treatment_type.save() @@ -1918,45 +1968,52 @@ class TreatmentTest(FindInit, TestCase): first_find = self.finds[0] completed, created = models.TreatmentState.objects.get_or_create( - txt_idx='completed', defaults={"executed": True, "label": "Done"} + txt_idx="completed", defaults={"executed": True, "label": "Done"} ) completed.executed = True completed.save() treatment.treatment_state = completed treatment.save( - user=self.get_default_user(), items=self.basket, + user=self.get_default_user(), + items=self.basket, treatment_type_list=[treatment_type], ) treatment.treatment_types.add(treatment_type) - self.assertEqual(items_nb + self.basket.items.count(), - models.Find.objects.count(), - msg="Packaging doesn't generate enough new finds") + self.assertEqual( + items_nb + self.basket.items.count(), + models.Find.objects.count(), + msg="Packaging doesn't generate enough new finds", + ) resulting_find = models.Find.objects.get( upstream_treatment__upstream=first_find, - base_finds__pk=first_find.base_finds.all()[0].pk + base_finds__pk=first_find.base_finds.all()[0].pk, ) # image names used to be altered on save: check for this bug self.assertEqual( resulting_find.documents.all()[0].title, - models.Find.objects.get(pk=first_find.pk).documents.all()[0].title + models.Find.objects.get(pk=first_find.pk).documents.all()[0].title, ) # new version of the find is in the basket for item in self.basket.items.all(): self.assertNotIn( - item, self.finds, - msg="Original basket have not been upgraded after packaging") + item, + self.finds, + msg="Original basket have not been upgraded after packaging", + ) for item in self.other_basket.items.all(): self.assertNotIn( - item, self.finds, - msg="Other basket have not been upgraded after packaging") + item, + self.finds, + msg="Other basket have not been upgraded after packaging", + ) def test_simple_delete(self): - treatment_type = models.TreatmentType.objects.get(txt_idx='packaging') + treatment_type = models.TreatmentType.objects.get(txt_idx="packaging") treatment_type.create_new_find = False treatment_type.save() @@ -1966,14 +2023,15 @@ class TreatmentTest(FindInit, TestCase): initial_find = self.finds[0] completed, created = models.TreatmentState.objects.get_or_create( - txt_idx='completed', defaults={"executed": True, "label": "Done"} + txt_idx="completed", defaults={"executed": True, "label": "Done"} ) completed.executed = True completed.save() treatment.treatment_state = completed treatment.save( - user=self.get_default_user(), items=self.basket, + user=self.get_default_user(), + items=self.basket, treatment_type_list=[treatment_type], ) treatment.treatment_types.add(treatment_type) @@ -1981,8 +2039,7 @@ class TreatmentTest(FindInit, TestCase): self.assertEqual(nb_find, models.Find.objects.count()) treatment.delete() - self.assertEqual( - models.Treatment.objects.filter(pk=treatment.pk).count(), 0) + self.assertEqual(models.Treatment.objects.filter(pk=treatment.pk).count(), 0) q = models.Find.objects.filter(pk=initial_find.pk) # initial find not deleted @@ -1991,7 +2048,7 @@ class TreatmentTest(FindInit, TestCase): self.assertEqual(initial_find.upstream_treatment, None) def test_upstream_find_delete(self): - treatment_type = models.TreatmentType.objects.get(txt_idx='packaging') + treatment_type = models.TreatmentType.objects.get(txt_idx="packaging") # make packaging a treatment with a new version of the find created treatment_type.create_new_find = True treatment_type.save() @@ -2002,30 +2059,29 @@ class TreatmentTest(FindInit, TestCase): initial_find = self.finds[0] completed, created = models.TreatmentState.objects.get_or_create( - txt_idx='completed', defaults={"executed": True, "label": "Done"} + txt_idx="completed", defaults={"executed": True, "label": "Done"} ) completed.executed = True completed.save() treatment.treatment_state = completed treatment.save( - user=self.get_default_user(), items=self.basket, + user=self.get_default_user(), + items=self.basket, treatment_type_list=[treatment_type], ) treatment.treatment_types.add(treatment_type) nb_b = self.basket.items.count() - self.assertEqual( - nb_find + nb_b, models.Find.objects.count()) + self.assertEqual(nb_find + nb_b, models.Find.objects.count()) resulting_find = models.Find.objects.get( upstream_treatment__upstream=initial_find, - base_finds__pk=initial_find.base_finds.all()[0].pk + base_finds__pk=initial_find.base_finds.all()[0].pk, ) resulting_find.delete() - self.assertEqual( - models.Treatment.objects.filter(pk=treatment.pk).count(), 0) + self.assertEqual(models.Treatment.objects.filter(pk=treatment.pk).count(), 0) q = models.Find.objects.filter(pk=initial_find.pk) # initial find not deleted self.assertEqual(q.count(), 1) @@ -2033,7 +2089,7 @@ class TreatmentTest(FindInit, TestCase): self.assertEqual(initial_find.upstream_treatment, None) def test_treatment_delete(self): - treatment_type = models.TreatmentType.objects.get(txt_idx='packaging') + treatment_type = models.TreatmentType.objects.get(txt_idx="packaging") treatment_type.create_new_find = True treatment_type.save() @@ -2043,28 +2099,27 @@ class TreatmentTest(FindInit, TestCase): initial_find = self.finds[0] completed, created = models.TreatmentState.objects.get_or_create( - txt_idx='completed', defaults={"executed": True, "label": "Done"} + txt_idx="completed", defaults={"executed": True, "label": "Done"} ) completed.executed = True completed.save() treatment.treatment_state = completed treatment.save( - user=self.get_default_user(), items=self.basket, + user=self.get_default_user(), + items=self.basket, treatment_type_list=[treatment_type], ) treatment.treatment_types.add(treatment_type) nb_b = self.basket.items.count() - self.assertEqual( - nb_find + nb_b, models.Find.objects.count()) + self.assertEqual(nb_find + nb_b, models.Find.objects.count()) treatment.delete() self.assertEqual(nb_find, models.Find.objects.count()) - self.assertEqual( - models.Treatment.objects.filter(pk=treatment.pk).count(), 0) + self.assertEqual(models.Treatment.objects.filter(pk=treatment.pk).count(), 0) q = models.Find.objects.filter(pk=initial_find.pk) # initial find not deleted self.assertEqual(q.count(), 1) @@ -2081,12 +2136,12 @@ class GeomaticTest(FindInit, TestCase): self.create_finds(data_base={"label": "Find 1"}, force=True) def test_point_precision(self): - self.username = 'myuser' - self.password = 'mypassword' - User.objects.create_superuser(self.username, 'myemail@test.com', - self.password) + self.username = "myuser" + self.password = "mypassword" + User.objects.create_superuser(self.username, "myemail@test.com", self.password) profile, created = IshtarSiteProfile.objects.get_or_create( - slug='default', active=True) + slug="default", active=True + ) profile.mapping = True profile.save() wgs84 = SpatialReferenceSystem.objects.get(srid=4326) @@ -2101,19 +2156,18 @@ class GeomaticTest(FindInit, TestCase): find = base_find.find.all()[0] c = Client() c.login(username=self.username, password=self.password) - response = c.get( - reverse('show-find', kwargs={'pk': find.pk})) - self.assertIn(b'33.12999', response.content) + response = c.get(reverse("show-find", kwargs={"pk": find.pk})) + self.assertIn(b"33.12999", response.content) profile.point_precision = 2 profile.save() - response = c.get( - reverse('show-find', kwargs={'pk': find.pk})) - self.assertIn(b'33.13', response.content) + response = c.get(reverse("show-find", kwargs={"pk": find.pk})) + self.assertIn(b"33.13", response.content) def test_update_container_localisation_on_warehouse_update(self): profile, created = IshtarSiteProfile.objects.get_or_create( - slug='default', active=True) + slug="default", active=True + ) profile.mapping = True profile.save() wgs84 = SpatialReferenceSystem.objects.get(srid=4326) @@ -2122,17 +2176,15 @@ class GeomaticTest(FindInit, TestCase): base_find = find.base_finds.all()[0] self.assertEqual(base_find.x, None) - operation = Operation.objects.get( - pk=base_find.context_record.operation.pk - ) + operation = Operation.objects.get(pk=base_find.context_record.operation.pk) operation.x, operation.y = 33, 42 operation.spatial_reference_system = wgs84 operation.save() # an update is pending for the linked context record q = ContextRecord.objects.filter( - pk=base_find.context_record.pk, - need_update=True) + pk=base_find.context_record.pk, need_update=True + ) self.assertEqual(q.count(), 1) # process pending update @@ -2163,15 +2215,15 @@ class GeomaticTest(FindInit, TestCase): base_find = find.base_finds.all()[0] srs, __ = SpatialReferenceSystem.objects.get_or_create( - txt_idx='wgs84', defaults={"srid": 4326, "label": 'WGS84', - 'auth_name': 'EPSG'} + txt_idx="wgs84", + defaults={"srid": 4326, "label": "WGS84", "auth_name": "EPSG"}, ) profile = get_current_profile() profile.mapping = True profile.save() # db source - geom = GEOSGeometry('POINT({} {} {})'.format(2, 43, 1), srid=4326) + geom = GEOSGeometry("POINT({} {} {})".format(2, 43, 1), srid=4326) base_find.point = geom base_find.save() base_find = models.BaseFind.objects.get(pk=base_find.pk) @@ -2180,9 +2232,10 @@ class GeomaticTest(FindInit, TestCase): self.assertIsNotNone(base_find.x) self.assertIsNotNone(base_find.y) self.assertIsNotNone(base_find.z) - self.assertEqual(base_find.point_source, 'P') # precise - self.assertEqual(base_find.point_source_item, - str(models.BaseFind._meta.verbose_name)) + self.assertEqual(base_find.point_source, "P") # precise + self.assertEqual( + base_find.point_source_item, str(models.BaseFind._meta.verbose_name) + ) # re-save do not change sources base_find.save() @@ -2192,9 +2245,10 @@ class GeomaticTest(FindInit, TestCase): self.assertIsNotNone(base_find.x) self.assertIsNotNone(base_find.y) self.assertIsNotNone(base_find.z) - self.assertEqual(base_find.point_source, 'P') # precise - self.assertEqual(base_find.point_source_item, - str(models.BaseFind._meta.verbose_name)) + self.assertEqual(base_find.point_source, "P") # precise + self.assertEqual( + base_find.point_source_item, str(models.BaseFind._meta.verbose_name) + ) # form input base_find.x = 2 @@ -2205,17 +2259,19 @@ class GeomaticTest(FindInit, TestCase): base_find = models.BaseFind.objects.get(pk=base_find.pk) self.assertIsNotNone(base_find.point_2d) self.assertIsNotNone(base_find.point) - self.assertEqual(base_find.point_source, 'P') # precise - self.assertEqual(base_find.point_source_item, - str(models.BaseFind._meta.verbose_name)) + self.assertEqual(base_find.point_source, "P") # precise + self.assertEqual( + base_find.point_source_item, str(models.BaseFind._meta.verbose_name) + ) # re-save do not change sources base_find.save() base_find = models.BaseFind.objects.get(pk=base_find.pk) self.assertIsNotNone(base_find.point_2d) self.assertIsNotNone(base_find.point) - self.assertEqual(base_find.point_source, 'P') # precise - self.assertEqual(base_find.point_source_item, - str(models.BaseFind._meta.verbose_name)) + self.assertEqual(base_find.point_source, "P") # precise + self.assertEqual( + base_find.point_source_item, str(models.BaseFind._meta.verbose_name) + ) # reinit base_find.x = None @@ -2229,18 +2285,21 @@ class GeomaticTest(FindInit, TestCase): self.assertEqual(base_find.point_source_item, None) profile, created = IshtarSiteProfile.objects.get_or_create( - slug='default', active=True) + slug="default", active=True + ) profile.use_town_for_geo = True profile.save() # geom from context record town - center = 'POINT(6 10)' - limit = 'MULTIPOLYGON(((1 1,5 1,5 5,1 5,1 1),(2 2,2 3,3 3,3 2,2 2)),'\ - '((6 3,9 2,9 4,6 3)))' + center = "POINT(6 10)" + limit = ( + "MULTIPOLYGON(((1 1,5 1,5 5,1 5,1 1),(2 2,2 3,3 3,3 2,2 2))," + "((6 3,9 2,9 4,6 3)))" + ) cr = ContextRecord.objects.get(pk=base_find.context_record.pk) t = cr.town - t.center = 'SRID=4326;' + center - t.limit = 'SRID=4326;' + limit + t.center = "SRID=4326;" + center + t.limit = "SRID=4326;" + limit t.save() cr = ContextRecord.objects.get(pk=base_find.context_record.pk) base_find = models.BaseFind.objects.get(pk=base_find.pk) @@ -2252,9 +2311,10 @@ class GeomaticTest(FindInit, TestCase): tp.transform(4326) self.assertLess(bfp.distance(tp), 0.0001) self.assertEqual(base_find.multi_polygon, cr.town.limit) - self.assertEqual(base_find.point_source, 'T') # town - self.assertEqual(base_find.point_source_item, - str(ContextRecord._meta.verbose_name)) + self.assertEqual(base_find.point_source, "T") # town + self.assertEqual( + base_find.point_source_item, str(ContextRecord._meta.verbose_name) + ) # re-save do not change sources base_find.save() base_find = models.BaseFind.objects.get(pk=base_find.pk) @@ -2264,15 +2324,16 @@ class GeomaticTest(FindInit, TestCase): tp.transform(4326) self.assertTrue(bfp.distance(tp) < 0.0001) self.assertEqual(base_find.multi_polygon, cr.town.limit) - self.assertEqual(base_find.point_source, 'T') # town - self.assertEqual(base_find.point_source_item, - str(ContextRecord._meta.verbose_name)) + self.assertEqual(base_find.point_source, "T") # town + self.assertEqual( + base_find.point_source_item, str(ContextRecord._meta.verbose_name) + ) # geom from context record - center = 'POINT(8 6)' + center = "POINT(8 6)" cr = ContextRecord.objects.get(pk=base_find.context_record.pk) - cr.point_2d = 'SRID=4326;' + center - cr.point_source = 'P' + cr.point_2d = "SRID=4326;" + center + cr.point_source = "P" cr.point_source_item = str(ContextRecord._meta.verbose_name) cr.save() cr = ContextRecord.objects.get(pk=base_find.context_record.pk) @@ -2289,9 +2350,10 @@ class GeomaticTest(FindInit, TestCase): tp.transform(4326) self.assertTrue(bfp.distance(tp) < 0.0001) self.assertEqual(base_find.multi_polygon, cr.multi_polygon) - self.assertEqual(base_find.point_source, 'P') # precise - self.assertEqual(base_find.point_source_item, - str(ContextRecord._meta.verbose_name)) + self.assertEqual(base_find.point_source, "P") # precise + self.assertEqual( + base_find.point_source_item, str(ContextRecord._meta.verbose_name) + ) # overload of coordinates by form base_find = models.BaseFind.objects.get(pk=base_find.pk) @@ -2304,19 +2366,21 @@ class GeomaticTest(FindInit, TestCase): base_find = models.BaseFind.objects.get(pk=base_find.pk) self.assertIsNotNone(base_find.point_2d) self.assertIsNotNone(base_find.point) - self.assertEqual(base_find.point_2d.wkt, 'POINT (5 6)') - self.assertEqual(base_find.point_source, 'P') # precise - self.assertEqual(base_find.point_source_item, - str(models.BaseFind._meta.verbose_name)) + self.assertEqual(base_find.point_2d.wkt, "POINT (5 6)") + self.assertEqual(base_find.point_source, "P") # precise + self.assertEqual( + base_find.point_source_item, str(models.BaseFind._meta.verbose_name) + ) # re-save do not change sources base_find.save() base_find = models.BaseFind.objects.get(pk=base_find.pk) self.assertIsNotNone(base_find.point_2d) self.assertIsNotNone(base_find.point) - self.assertEqual(base_find.point_2d.wkt, 'POINT (5 6)') - self.assertEqual(base_find.point_source, 'P') # precise - self.assertEqual(base_find.point_source_item, - str(models.BaseFind._meta.verbose_name)) + self.assertEqual(base_find.point_2d.wkt, "POINT (5 6)") + self.assertEqual(base_find.point_source, "P") # precise + self.assertEqual( + base_find.point_source_item, str(models.BaseFind._meta.verbose_name) + ) def test_post_save_polygon(self): profile = get_current_profile() @@ -2326,16 +2390,18 @@ class GeomaticTest(FindInit, TestCase): find = self.finds[0] base_find = find.base_finds.all()[0] srs, __ = SpatialReferenceSystem.objects.get_or_create( - txt_idx='wgs84', defaults={"srid": 4326, "label": 'WGS84', - 'auth_name': 'EPSG'} + txt_idx="wgs84", + defaults={"srid": 4326, "label": "WGS84", "auth_name": "EPSG"}, ) base_find = models.BaseFind.objects.get(pk=base_find.pk) # get centroid geom from poly - limit = 'MULTIPOLYGON(((1 1,5 1,5 5,1 5,1 1),(2 2,2 3,3 3,3 2,2 2)),' \ - '((6 3,9 2,9 4,6 3)))' - base_find.multi_polygon = 'SRID=4326;' + limit + limit = ( + "MULTIPOLYGON(((1 1,5 1,5 5,1 5,1 1),(2 2,2 3,3 3,3 2,2 2))," + "((6 3,9 2,9 4,6 3)))" + ) + base_find.multi_polygon = "SRID=4326;" + limit base_find.point_source = None base_find.point_2d = None base_find.point = None @@ -2343,19 +2409,21 @@ class GeomaticTest(FindInit, TestCase): base_find = models.BaseFind.objects.get(pk=base_find.pk) self.assertIsNotNone(base_find.point_2d) - self.assertEqual(base_find.point_source, 'M') # from multi polygon + self.assertEqual(base_find.point_source, "M") # from multi polygon # resaving do not change source base_find.save() base_find = models.BaseFind.objects.get(pk=base_find.pk) self.assertIsNotNone(base_find.point_2d) - self.assertEqual(base_find.point_source, 'M') # from multi polygon + self.assertEqual(base_find.point_source, "M") # from multi polygon # geom from context record - limit = 'MULTIPOLYGON(((1 1,5 1,5 5,1 5,1 1),(2 2,2 3,3 3,3 2,2 2)),' \ - '((6 3,9 2,9 4,6 3)))' + limit = ( + "MULTIPOLYGON(((1 1,5 1,5 5,1 5,1 1),(2 2,2 3,3 3,3 2,2 2))," + "((6 3,9 2,9 4,6 3)))" + ) cr = ContextRecord.objects.get(pk=base_find.context_record.pk) - cr.multi_polygon = 'SRID=4326;' + limit - cr.multi_polygon_source = 'P' + cr.multi_polygon = "SRID=4326;" + limit + cr.multi_polygon_source = "P" cr.multi_polygon_source_item = str(ContextRecord._meta.verbose_name) cr.save() cr = ContextRecord.objects.get(pk=base_find.context_record.pk) @@ -2364,9 +2432,10 @@ class GeomaticTest(FindInit, TestCase): base_find.save() base_find = models.BaseFind.objects.get(pk=base_find.pk) self.assertEqual(base_find.multi_polygon, cr.multi_polygon) - self.assertEqual(base_find.multi_polygon_source, 'P') # precise - self.assertEqual(base_find.multi_polygon_source_item, - str(ContextRecord._meta.verbose_name)) + self.assertEqual(base_find.multi_polygon_source, "P") # precise + self.assertEqual( + base_find.multi_polygon_source_item, str(ContextRecord._meta.verbose_name) + ) base_find = models.BaseFind.objects.get(pk=base_find.pk) base_find.point_source = None @@ -2376,42 +2445,50 @@ class GeomaticTest(FindInit, TestCase): base_find.save() base_find = models.BaseFind.objects.get(pk=base_find.pk) self.assertEqual(base_find.point_2d.ewkt, "SRID=4326;POINT (42 3)") - self.assertEqual(base_find.point_source, 'P') + self.assertEqual(base_find.point_source, "P") # resaving do not change source base_find.save() base_find = models.BaseFind.objects.get(pk=base_find.pk) self.assertEqual(base_find.point_2d.ewkt, "SRID=4326;POINT (42 3)") - self.assertEqual(base_find.point_source, 'P') + self.assertEqual(base_find.point_source, "P") class AutocompleteTest(AutocompleteTestBase, TestCase): fixtures = FIND_FIXTURES models = [ - AcItem(models.ObjectType, 'autocomplete-objecttype'), - AcItem(models.MaterialType, 'autocomplete-materialtype'), - AcItem(models.TreatmentType, 'autocomplete-treatmenttype', - default_values={"virtual": False}), - AcItem(models.IntegrityType, 'autocomplete-integritytype'), - AcItem(models.TreatmentFile, 'autocomplete-treatmentfile', - prepare_func="create_treatmentfile"), - AcItem(models.FindBasket, 'autocomplete-findbasket', - prepare_func="create_findbasket"), - AcItem(models.Find, 'autocomplete-find', prepare_func="create_find"), - AcItem(models.Treatment, 'autocomplete-treatment', - prepare_func='create_treatment'), + AcItem(models.ObjectType, "autocomplete-objecttype"), + AcItem(models.MaterialType, "autocomplete-materialtype"), + AcItem( + models.TreatmentType, + "autocomplete-treatmenttype", + default_values={"virtual": False}, + ), + AcItem(models.IntegrityType, "autocomplete-integritytype"), + AcItem( + models.TreatmentFile, + "autocomplete-treatmentfile", + prepare_func="create_treatmentfile", + ), + AcItem( + models.FindBasket, + "autocomplete-findbasket", + prepare_func="create_findbasket", + ), + AcItem(models.Find, "autocomplete-find", prepare_func="create_find"), + AcItem( + models.Treatment, "autocomplete-treatment", prepare_func="create_treatment" + ), ] def create_treatmentfile(self, base_name): item, __ = models.TreatmentFile.objects.get_or_create( - name=base_name, - type=models.TreatmentFileType.objects.all()[0] + name=base_name, type=models.TreatmentFileType.objects.all()[0] ) return item, None def create_treatment(self, base_name): item, __ = models.Treatment.objects.get_or_create( - label=base_name, - treatment_state=models.TreatmentState.objects.all()[0] + label=base_name, treatment_state=models.TreatmentState.objects.all()[0] ) return item, None @@ -2425,13 +2502,9 @@ class AutocompleteTest(AutocompleteTestBase, TestCase): def create_find(self, base_name): ope, __ = Operation.objects.get_or_create( - common_name="Test", - operation_type=OperationType.objects.all()[0] - ) - cr, __ = ContextRecord.objects.get_or_create( - operation=ope, - label=base_name + common_name="Test", operation_type=OperationType.objects.all()[0] ) + cr, __ = ContextRecord.objects.get_or_create(operation=ope, label=base_name) base_find = models.BaseFind.objects.create(context_record=cr) find = models.Find.objects.create( label=base_name, @@ -2447,38 +2520,44 @@ class PublicAPITest(FindInit, APITestCase): def setUp(self): self.create_finds(data_base={"label": "Find 1"}, force=True) self.basket = models.FindBasket.objects.create( - slug="my-basket", label="My basket", - user=IshtarUser.objects.get(pk=self.get_default_user().pk)) + slug="my-basket", + label="My basket", + user=IshtarUser.objects.get(pk=self.get_default_user().pk), + ) for find in self.finds: self.basket.items.add(find) - self.username = 'myuser' - self.password = 'mypassword' - user = User.objects.create_user(self.username, 'myemail@test.com', - self.password) - self.auth_token = 'Token '+ Token.objects.create(user=user).key + self.username = "myuser" + self.password = "mypassword" + user = User.objects.create_user( + self.username, "myemail@test.com", self.password + ) + self.auth_token = "Token " + Token.objects.create(user=user).key def test_authentication(self): - url = reverse('api-public-find') + "?basket=my-basket" - response = self.client.get(url, format='json') + url = reverse("api-public-find") + "?basket=my-basket" + response = self.client.get(url, format="json") self.assertEqual(response.status_code, 401) - response = self.client.get(url, format='json', - HTTP_AUTHORIZATION=self.auth_token) + response = self.client.get( + url, format="json", HTTP_AUTHORIZATION=self.auth_token + ) self.assertEqual(response.status_code, 200) def test_basket(self): # unknown basket - url = reverse('api-public-find') + "?basket=non-exist-basket" - response = self.client.get(url, format='json', - HTTP_AUTHORIZATION=self.auth_token) + url = reverse("api-public-find") + "?basket=non-exist-basket" + response = self.client.get( + url, format="json", HTTP_AUTHORIZATION=self.auth_token + ) self.assertEqual(response.status_code, 200) content = response.content.decode() res = json.loads(content) self.assertEqual(res, []) # basket is not public - url = reverse('api-public-find') + "?basket=my-basket" - response = self.client.get(url, format='json', - HTTP_AUTHORIZATION=self.auth_token) + url = reverse("api-public-find") + "?basket=my-basket" + response = self.client.get( + url, format="json", HTTP_AUTHORIZATION=self.auth_token + ) self.assertEqual(response.status_code, 200) content = response.content.decode() res = json.loads(content) @@ -2487,8 +2566,9 @@ class PublicAPITest(FindInit, APITestCase): # ok self.basket.public = True self.basket.save() - response = self.client.get(url, format='json', - HTTP_AUTHORIZATION=self.auth_token) + response = self.client.get( + url, format="json", HTTP_AUTHORIZATION=self.auth_token + ) self.assertEqual(response.status_code, 200) content = response.content.decode() res = json.loads(content) @@ -2497,26 +2577,31 @@ class PublicAPITest(FindInit, APITestCase): def test_basket_content(self): find = self.finds[0] find.denomination = "denomination" - ceram = models.MaterialType.objects.get(txt_idx='ceramic') + ceram = models.MaterialType.objects.get(txt_idx="ceramic") find.material_types.add(ceram) find.save() - url = reverse('api-public-find') + "?basket=my-basket" + url = reverse("api-public-find") + "?basket=my-basket" self.basket.public = True self.basket.save() - response = self.client.get(url, format='json', - HTTP_AUTHORIZATION=self.auth_token) + response = self.client.get( + url, format="json", HTTP_AUTHORIZATION=self.auth_token + ) self.assertEqual(response.status_code, 200) content = response.content.decode() res = json.loads(content) expected_results = [ - ((0, 'denomination',), 'denomination'), - ((0, 'materials', 0), 'Céramique'), - ((0, 'base-finds', 0, 'context-record', 'label'), - 'Context record'), - ((0, 'base-finds', 0, 'context-record', 'town'), - 'default_town (12345)'), - ((0, 'base-finds', 0, 'context-record', 'operation', 'year'), 2010), + ( + ( + 0, + "denomination", + ), + "denomination", + ), + ((0, "materials", 0), "Céramique"), + ((0, "base-finds", 0, "context-record", "label"), "Context record"), + ((0, "base-finds", 0, "context-record", "town"), "default_town (12345)"), + ((0, "base-finds", 0, "context-record", "operation", "year"), 2010), ] for path, result in expected_results: path = list(reversed(path)) @@ -2537,19 +2622,24 @@ class LabelTest(FindInit, TestCase): def setUp(self): templates = [ - settings.ROOT_PATH + '../archaeological_finds/tests/' + t - for t in ("etiquettes-mobilier.odt", "etiquettes-mobilier", - "etiquettes-mobilier.txt", "bad_lo.zip", - "truncated_xml.zip") + settings.ROOT_PATH + "../archaeological_finds/tests/" + t + for t in ( + "etiquettes-mobilier.odt", + "etiquettes-mobilier", + "etiquettes-mobilier.txt", + "bad_lo.zip", + "truncated_xml.zip", + ) ] self.templates = [] for template in templates: filename = template.split("/")[-1] - shutil.copy(template, - os.path.join(settings.MEDIA_ROOT, filename), - follow_symlinks=True) - self.templates.append( - os.path.join(settings.MEDIA_ROOT, filename)) + shutil.copy( + template, + os.path.join(settings.MEDIA_ROOT, filename), + follow_symlinks=True, + ) + self.templates.append(os.path.join(settings.MEDIA_ROOT, filename)) def tearDown(self): for tpl in self.templates: @@ -2563,19 +2653,22 @@ class LabelTest(FindInit, TestCase): (base_tpl, base_targets, True, "OK"), (base_tpl, "", False, "no target"), (base_tpl, "-;Cadre2;Cadre3", False, "bad first target"), - (base_tpl, "Cadre1;Frame2;Frame3", True, - "first target OK, silently failed other targets"), + ( + base_tpl, + "Cadre1;Frame2;Frame3", + True, + "first target OK, silently failed other targets", + ), (missing_ext, base_targets, True, "missing extension"), (text_file, base_targets, False, "text file"), (bad_lo, base_targets, False, "missing content.xml"), (trunc_xml, base_targets, False, "truncated content.xml"), ) for tpl_file, targets, is_ok, msg in dataset: - with open(tpl_file, 'rb') as tpl: - template = SimpleUploadedFile("etiquettes-mobilier.odt", - tpl.read()) + with open(tpl_file, "rb") as tpl: + template = SimpleUploadedFile("etiquettes-mobilier.odt", tpl.read()) model, __ = ImporterModel.objects.get_or_create( - klass='archaeological_finds.models.Find' + klass="archaeological_finds.models.Find" ) q = DocumentTemplate.objects.filter(slug="test") if q.count(): @@ -2586,7 +2679,8 @@ class LabelTest(FindInit, TestCase): associated_model=model, available=True, label_targets=targets, - label_template=template) + label_template=template, + ) self.templates.append(doc.label_template.path) doc = DocumentTemplate.objects.get(pk=doc.pk) msg = "Fail on dataset: " + msg @@ -2602,22 +2696,19 @@ class TemplateTest(FindInit, TestCase): model = models.Find def setUp(self): - template = settings.ROOT_PATH + \ - '../archaeological_finds/tests/notices-panier.odt' + template = ( + settings.ROOT_PATH + "../archaeological_finds/tests/notices-panier.odt" + ) filename = template.split("/")[-1] - shutil.copy(template, - os.path.join(settings.MEDIA_ROOT, filename), - follow_symlinks=True) + shutil.copy( + template, os.path.join(settings.MEDIA_ROOT, filename), follow_symlinks=True + ) self.template = os.path.join(settings.MEDIA_ROOT, filename) self.templates = [self.template] ope1 = self.create_operation()[0] ope2 = self.create_operation()[1] - cr = self.create_context_record( - data={"label": "CR 1", "operation": ope1} - )[0] - cr2 = self.create_context_record( - data={"label": "CR 2", "operation": ope2} - )[1] + cr = self.create_context_record(data={"label": "CR 1", "operation": ope1})[0] + cr2 = self.create_context_record(data={"label": "CR 2", "operation": ope2})[1] self.create_finds(data_base={"context_record": cr})[0] self.create_finds(data_base={"context_record": cr2})[1] self.basket = models.FindBasket.objects.create(label="Hophop") @@ -2627,17 +2718,14 @@ class TemplateTest(FindInit, TestCase): location = Warehouse.objects.create(name="Warehouse", warehouse_type=wt) ct, __ = ContainerType.objects.get_or_create(label="CT", txt_idx="CT") self.container = Container.objects.create( - location=location, - reference="Reférence", - container_type=ct + location=location, reference="Reférence", container_type=ct ) def test_label(self): - with open(self.template, 'rb') as tpl: - template = SimpleUploadedFile("template.odt", - tpl.read()) + with open(self.template, "rb") as tpl: + template = SimpleUploadedFile("template.odt", tpl.read()) model, __ = ImporterModel.objects.get_or_create( - klass='archaeological_finds.models.Find' + klass="archaeological_finds.models.Find" ) q = DocumentTemplate.objects.filter(slug="test") if q.count(): @@ -2647,7 +2735,8 @@ class TemplateTest(FindInit, TestCase): slug="test", associated_model=model, available=True, - template=template) + template=template, + ) self.templates.append(doc.template.path) doc = DocumentTemplate.objects.get(pk=doc.pk) |