Merge branch 'master' into v0.9

Conflicts:
	ishtar_common/migrations/0030_auto__add_state__chg_field_sourcetype_txt_idx__chg_field_authortype_tx.py

1 files changed, 82 insertions, 43 deletions

diff --git a/archaeological_operations/tests.py b/archaeological_operations/tests.py
index 040c7c3d8..364cc4c8e 100644
--- a/archaeological_operations/tests.py
+++ b/archaeological_operations/tests.py
@@ -34,8 +34,9 @@ import models
 
 from archaeological_operations import views
 
-from ishtar_common.models import OrganizationType, Organization, \
-    ImporterType, IshtarUser, TargetKey, ImporterModel, IshtarSiteProfile, Town
+from ishtar_common.models import OrganizationType, Organization, ItemKey, \
+    ImporterType, IshtarUser, TargetKey, ImporterModel, IshtarSiteProfile, \
+    Town, ImporterColumn, Person
 from archaeological_context_records.models import Unit
 
 from ishtar_common import forms_common
@@ -73,26 +74,30 @@ class ImportTest(object):
 
     def init_ope_targetkey(self, imp):
         # doing manually connections
-        tg = TargetKey.objects.filter(target__target='operation_type'
-                                      ).order_by('-pk').all()[0]
-        tg.value = models.OperationType.objects.get(
+        target = TargetKey.objects.filter(
+            target__target='operation_type').order_by('-pk').all()[0]
+        target.value = models.OperationType.objects.get(
             txt_idx='prog_excavation').pk
-        tg.is_set = True
-        tg.save()
-
-        target = TargetKey.objects.get(key='gallo-romain',
-                                       associated_import=imp)
-        gallo = models.Period.objects.get(txt_idx='gallo-roman')
-        target.value = gallo.pk
         target.is_set = True
+        target.associated_import = imp
         target.save()
 
-        target = TargetKey.objects.get(key='age-du-fer',
-                                       associated_import=imp)
+        target2 = TargetKey.objects.get(key='gallo-romain',
+                                        associated_import=imp)
+        gallo = models.Period.objects.get(txt_idx='gallo-roman')
+        target2.value = gallo.pk
+        target2.is_set = True
+        target2.associated_import = imp
+        target2.save()
+
+        target3 = TargetKey.objects.get(key='age-du-fer',
+                                        associated_import=imp)
         iron = models.Period.objects.get(txt_idx='iron_age')
-        target.value = iron.pk
-        target.is_set = True
-        target.save()
+        target3.value = iron.pk
+        target3.is_set = True
+        target3.associated_import = imp
+        target3.save()
+        return [target, target2, target3]
 
     def init_ope(self):
         importer, form = self.init_ope_import()
@@ -166,6 +171,7 @@ class ImportOperationTest(ImportTest, TestCase):
 
     def test_mcc_import_operation(self):
         first_ope_nb = models.Operation.objects.count()
+        first_person_nb = Person.objects.count()
         importer, form = self.init_ope_import()
         self.assertTrue(form.is_valid())
         impt = form.save(self.ishtar_user)
@@ -179,18 +185,20 @@ class ImportOperationTest(ImportTest, TestCase):
         current_ope_nb = models.Operation.objects.count()
         # no new operation imported because of a missing connection for
         # operation_type value
-        self.assertTrue(current_ope_nb == first_ope_nb)
+        self.assertEqual(current_ope_nb, first_ope_nb)
         self.init_ope_targetkey(imp=impt)
 
         impt.importation()
-        # a new operation has now been imported
+        # new operations have now been imported
         current_ope_nb = models.Operation.objects.count()
-        self.assertTrue(current_ope_nb == (first_ope_nb + 1))
+        self.assertEqual(current_ope_nb, first_ope_nb + 2)
+        current_person_nb = Person.objects.count()
+        self.assertEqual(current_person_nb, first_person_nb + 1)
         # and well imported
         last_ope = models.Operation.objects.order_by('-pk').all()[0]
         self.assertEqual(last_ope.name, u"Oppìdum de Paris")
-        self.assertTrue(last_ope.code_patriarche == 4200)
-        self.assertTrue(last_ope.operation_type.txt_idx == 'prog_excavation')
+        self.assertEqual(last_ope.code_patriarche, 4200)
+        self.assertEqual(last_ope.operation_type.txt_idx, 'prog_excavation')
         self.assertEqual(last_ope.periods.count(), 2)
         periods = [period.txt_idx for period in last_ope.periods.all()]
         self.assertIn('iron_age', periods)
@@ -199,9 +207,43 @@ class ImportOperationTest(ImportTest, TestCase):
         # a second importation will be not possible: no two same patriarche
         # code
         impt.importation()
-        models.Operation.objects.count()
-        self.assertTrue(last_ope ==
-                        models.Operation.objects.order_by('-pk').all()[0])
+        self.assertEqual(last_ope,
+                         models.Operation.objects.order_by('-pk').all()[0])
+
+    def test_keys_limitation(self):
+        # each key association is associated to the import
+        init_ope_number = models.Operation.objects.count()
+        importer, form = self.init_ope_import()
+        impt = form.save(self.ishtar_user)
+        impt.initialize()
+        self.init_ope_targetkey(imp=impt)
+
+        importer, form = self.init_ope_import()
+        other_imp = form.save(self.ishtar_user)
+        # associate with another import
+        for ik in ItemKey.objects.filter(importer=impt).all():
+            ik.importer = other_imp
+            ik.save()
+
+        impt.importation()
+        current_ope_nb = models.Operation.objects.count()
+        # no new operation
+        self.assertEqual(current_ope_nb, init_ope_number)
+
+    def test_bad_configuration(self):
+        importer, form = self.init_ope_import()
+        col = ImporterColumn.objects.get(importer_type=importer, col_number=1)
+        target = col.targets.all()[0]
+        target.target = "cody"  # random and not appropriate string
+        target.save()
+        # self.init_ope()
+        # importer, form = self.init_ope_import()
+        impt = form.save(self.ishtar_user)
+        impt.initialize()
+        self.init_ope_targetkey(imp=impt)
+        impt.importation()
+        self.assertEqual(len(impt.errors), 2)
+        self.assertIn("Importer configuration error", impt.errors[0]['error'])
 
     def test_model_limitation(self):
         importer, form = self.init_ope_import()
@@ -214,10 +256,10 @@ class ImportOperationTest(ImportTest, TestCase):
         init_ope_number = models.Operation.objects.count()
         impt.importation()
         current_ope_nb = models.Operation.objects.count()
-        self.assertEqual(current_ope_nb, init_ope_number + 1)
+        self.assertEqual(current_ope_nb, init_ope_number + 2)
 
-        last_ope = models.Operation.objects.order_by('-pk').all()[0]
-        last_ope.delete()
+        for ope in models.Operation.objects.order_by('-pk').all()[:2]:
+            ope.delete()
 
         importer, form = self.init_ope_import()
         # add an inadequate model to make created_models non empty
@@ -247,7 +289,7 @@ class ImportOperationTest(ImportTest, TestCase):
         # import of operations
         impt.importation()
         current_ope_nb = models.Operation.objects.count()
-        self.assertEqual(current_ope_nb, init_ope_number + 1)
+        self.assertEqual(current_ope_nb, init_ope_number + 2)
 
     def test_mcc_import_parcels(self):
         old_nb = models.Parcel.objects.count()
@@ -793,7 +835,6 @@ class OperationSearchTest(TestCase, OperationInitTest):
         self.assertEqual(response.status_code, 200)
         self.assertEqual(json.loads(response.content)['total'], 1)
 
-
     def testOwnSearch(self):
         c = Client()
         response = c.get(reverse('get-operation'), {'year': '2010'})
@@ -895,12 +936,10 @@ class OperationWizardCreationTest(WizardTest, OperationInitTest, TestCase):
             return super(OperationWizardCreationTest, self).pre_wizard()
         town = self.create_towns()[0]
         town_data = {'town': town.pk}
-        self.form_datas[0].form_datas['townsgeneral-operation_creation'].append(
-            town_data
-        )
-        self.form_datas[1].form_datas['townsgeneral-operation_creation'].append(
-            town_data
-        )
+        self.form_datas[0].form_datas[
+            'townsgeneral-operation_creation'].append(town_data)
+        self.form_datas[1].form_datas[
+            'townsgeneral-operation_creation'].append(town_data)
         parcel_data = {
             'town': town.pk, 'year': 2017, 'section': 'S',
             'parcel_number': '42'}
@@ -981,7 +1020,8 @@ class OperationWizardClosingTest(OperationWizardCreationTest):
         self.assertFalse(ope.is_active())
         self.assertEqual(
             ope.closing()['date'].strftime('%Y-%d-%m'),
-            self.form_datas[0].form_datas['date-operation_closing']['end_date'])
+            self.form_datas[0].form_datas['date-operation_closing']['end_date']
+        )
 
 
 class OperationAdminActWizardCreationTest(WizardTest, OperationInitTest,
@@ -1001,12 +1041,11 @@ class OperationAdminActWizardCreationTest(WizardTest, OperationInitTest,
         FormData(
             "Admin act creation",
             form_datas={
-                    'selec-operation_administrativeactop': {
-                    },
-                    'administrativeact-operation_administrativeactop': {
-                        'signature_date': str(datetime.date.today())
-                    }
-                },
+                'selec-operation_administrativeactop': {},
+                'administrativeact-operation_administrativeactop': {
+                    'signature_date': str(datetime.date.today())
+                }
+            },
         )
     ]