Test: refactor - should be a little bit faster

1 files changed, 88 insertions, 53 deletions

diff --git a/archaeological_operations/tests.py b/archaeological_operations/tests.py
index f2126a68e..040c7c3d8 100644
--- a/archaeological_operations/tests.py
+++ b/archaeological_operations/tests.py
@@ -36,35 +36,27 @@ from archaeological_operations import views
 
 from ishtar_common.models import OrganizationType, Organization, \
     ImporterType, IshtarUser, TargetKey, ImporterModel, IshtarSiteProfile, Town
+from archaeological_context_records.models import Unit
 
 from ishtar_common import forms_common
 from ishtar_common.tests import WizardTest, WizardTestFormData as FormData, \
     create_superuser, create_user
 
 
-class ImportOperationTest(TestCase):
-    fixtures = [settings.ROOT_PATH +
-                '../fixtures/initial_data-auth-fr.json',
-                settings.ROOT_PATH +
-                '../ishtar_common/fixtures/initial_data-fr.json',
-                settings.ROOT_PATH +
-                '../ishtar_common/fixtures/test_towns.json',
-                settings.ROOT_PATH +
-                '../ishtar_common/fixtures/initial_importtypes-fr.json',
-                settings.ROOT_PATH +
-                '../archaeological_operations/fixtures/initial_data-fr.json']
-    test_operations = True
+class ImportTest(object):
+    def setUp(self):
+        self.username, self.password, self.user = create_superuser()
+        self.ishtar_user = IshtarUser.objects.get(pk=self.user.pk)
 
-    def setTargetKey(self, target, key, value):
-        tg = TargetKey.objects.get(target__target=target, key=key)
+    def set_target_key(self, target, key, value, imp=None):
+        keys = {'target__target': target, 'key': key}
+        if imp:
+            keys['associated_import'] = imp
+        tg = TargetKey.objects.get(**keys)
         tg.value = value
         tg.is_set = True
         tg.save()
 
-    def setUp(self):
-        self.username, self.password, self.user = create_superuser()
-        self.ishtar_user = IshtarUser.objects.get(pk=self.user.pk)
-
     def init_ope_import(self):
         mcc_operation = ImporterType.objects.get(name=u"MCC - Opérations")
         mcc_operation_file = open(
@@ -102,33 +94,95 @@ class ImportOperationTest(TestCase):
         target.is_set = True
         target.save()
 
-    def test_mcc_import_operation(self, test=True):
-        # MCC opérations
-        if self.test_operations is False:
-            test = False
+    def init_ope(self):
+        importer, form = self.init_ope_import()
+        impt = form.save(self.ishtar_user)
+        impt.initialize()
+        self.init_ope_targetkey(imp=impt)
+        impt.importation()
+
+    def init_parcel_import(self):
+        self.init_ope()
+        mcc_parcel = ImporterType.objects.get(name=u"MCC - Parcelles")
+        mcc_file = open(
+            settings.ROOT_PATH +
+            '../archaeological_operations/tests/MCC-parcelles-example.csv',
+            'rb')
+        file_dict = {'imported_file': SimpleUploadedFile(mcc_file.name,
+                                                         mcc_file.read())}
+        post_dict = {'importer_type': mcc_parcel.pk, 'skip_lines': 1,
+                     "encoding": 'utf-8'}
+        form = forms_common.NewImportForm(data=post_dict, files=file_dict)
+        form.is_valid()
+        return mcc_parcel, form
+
+    def init_parcel(self):
+        importer, form = self.init_parcel_import()
+        impt = form.save(self.ishtar_user)
+        impt.initialize()
+        impt.importation()
+
+    def init_context_record_import(self):
+        self.init_parcel()
+        mcc = ImporterType.objects.get(name=u"MCC - UE")
+        mcc_file = open(
+            settings.ROOT_PATH +
+            '../archaeological_context_records/tests/'
+            'MCC-context-records-example.csv', 'rb')
+        file_dict = {'imported_file': SimpleUploadedFile(mcc_file.name,
+                                                         mcc_file.read())}
+        post_dict = {'importer_type': mcc.pk, 'skip_lines': 1,
+                     "encoding": 'utf-8'}
+        form = forms_common.NewImportForm(data=post_dict, files=file_dict)
+        form.is_valid()
+        return mcc, form
+
+    def init_cr_targetkey(self, imp):
+        hc = Unit.objects.get(txt_idx='not_in_context').pk
+        self.set_target_key('unit', 'hc', hc, imp=imp)
+        self.set_target_key('unit', 'hors-contexte', hc, imp=imp)
+        layer = Unit.objects.get(txt_idx='layer').pk
+        self.set_target_key('unit', 'couche', layer, imp=imp)
+
+    def init_context_record(self):
+        mcc, form = self.init_context_record_import()
+        impt = form.save(self.ishtar_user)
+        impt.initialize()
+        self.init_cr_targetkey(impt)
+        impt.importation()
+
+
+class ImportOperationTest(ImportTest, TestCase):
+    fixtures = [settings.ROOT_PATH +
+                '../fixtures/initial_data-auth-fr.json',
+                settings.ROOT_PATH +
+                '../ishtar_common/fixtures/initial_data-fr.json',
+                settings.ROOT_PATH +
+                '../ishtar_common/fixtures/test_towns.json',
+                settings.ROOT_PATH +
+                '../ishtar_common/fixtures/initial_importtypes-fr.json',
+                settings.ROOT_PATH +
+                '../archaeological_operations/fixtures/initial_data-fr.json']
+
+    def test_mcc_import_operation(self):
         first_ope_nb = models.Operation.objects.count()
         importer, form = self.init_ope_import()
-        if test:
-            self.assertTrue(form.is_valid())
+        self.assertTrue(form.is_valid())
         impt = form.save(self.ishtar_user)
         target_key_nb = TargetKey.objects.count()
         impt.initialize()
         # new key have to be set
-        if test:
-            self.assertTrue(TargetKey.objects.count() > target_key_nb)
+        self.assertTrue(TargetKey.objects.count() > target_key_nb)
 
         # first try to import
         impt.importation()
         current_ope_nb = models.Operation.objects.count()
         # no new operation imported because of a missing connection for
         # operation_type value
-        if test:
-            self.assertTrue(current_ope_nb == first_ope_nb)
+        self.assertTrue(current_ope_nb == first_ope_nb)
         self.init_ope_targetkey(imp=impt)
 
         impt.importation()
-        if not test:
-            return
         # a new operation has now been imported
         current_ope_nb = models.Operation.objects.count()
         self.assertTrue(current_ope_nb == (first_ope_nb + 1))
@@ -195,33 +249,16 @@ class ImportOperationTest(TestCase):
         current_ope_nb = models.Operation.objects.count()
         self.assertEqual(current_ope_nb, init_ope_number + 1)
 
-    def testMCCImportParcels(self, test=True):
-        if self.test_operations is False:
-            test = False
-        self.test_mcc_import_operation(test=False)
+    def test_mcc_import_parcels(self):
         old_nb = models.Parcel.objects.count()
-        MCC_PARCEL = ImporterType.objects.get(name=u"MCC - Parcelles")
-        mcc_file = open(
-            settings.ROOT_PATH +
-            '../archaeological_operations/tests/MCC-parcelles-example.csv',
-            'rb')
-        file_dict = {'imported_file': SimpleUploadedFile(mcc_file.name,
-                                                         mcc_file.read())}
-        post_dict = {'importer_type': MCC_PARCEL.pk, 'skip_lines': 1,
-                     "encoding": 'utf-8'}
-        form = forms_common.NewImportForm(data=post_dict, files=file_dict,
-                                          instance=None)
-        form.is_valid()
-        if test:
-            self.assertTrue(form.is_valid())
+        mcc_parcel, form = self.init_parcel_import()
         impt = form.save(self.ishtar_user)
         impt.initialize()
         impt.importation()
-        if not test:
-            return
         # new parcels has now been imported
         current_nb = models.Parcel.objects.count()
-        self.assertTrue(current_nb == (old_nb + 2))
+        self.assertEqual(current_nb, old_nb + 2)
+
         # and well imported
         last_parcels = models.Parcel.objects.order_by('-pk').all()[0:2]
         external_ids = sorted(['4200-59350-YY55', '4200-75101-XXXX'])
@@ -249,8 +286,6 @@ class ImportOperationTest(TestCase):
         self.assertEqual(parcel_count - 2, models.Parcel.objects.count())
 
     def testParseParcels(self):
-        if not self.test_operations:
-            return
         # the database needs to be initialised before importing
         from archaeological_operations.import_from_csv import parse_parcels
         # default_town = Town.objects.create(numero_insee="12345",