Import tests: test limit model for context records - more explicit error message when dealing with limit model

3 files changed, 116 insertions, 36 deletions

diff --git a/archaeological_context_records/tests.py b/archaeological_context_records/tests.py
index 032861d5d..f1e6581d7 100644
--- a/archaeological_context_records/tests.py
+++ b/archaeological_context_records/tests.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-# Copyright (C) 2015 Étienne Loks  <etienne.loks_AT_peacefrogsDOTnet>
+# Copyright (C) 2015-2017 Étienne Loks  <etienne.loks_AT_peacefrogsDOTnet>
 
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License as
@@ -20,13 +20,12 @@
 import json
 
 from django.conf import settings
-from django.core.exceptions import ValidationError
-from django.core.files.uploadedfile import SimpleUploadedFile
+from django.core.exceptions import ValidationError, ImproperlyConfigured
 from django.core.urlresolvers import reverse
 from django.test import TestCase
 from django.test.client import Client
 
-from ishtar_common.models import ImporterType, IshtarSiteProfile
+from ishtar_common.models import IshtarSiteProfile, ImporterModel
 from ishtar_common.tests import create_superuser
 from archaeological_operations.tests import OperationInitTest, \
     ImportTest, ImportOperationTest
@@ -61,6 +60,87 @@ class ImportContextRecordTest(ImportTest, TestCase):
             models.ContextRecord.objects.filter(
                 unit__txt_idx='layer').count(), 1)
 
+    def test_model_limitation(self):
+        old_nb = models.ContextRecord.objects.count()
+        mcc, form = self.init_context_record_import()
+        mcc.created_models.clear()
+
+        self.assertTrue(form.is_valid())
+        impt = form.save(self.ishtar_user)
+        impt.initialize()
+
+        self.init_cr_targetkey(impt)
+        impt.importation()
+        # no model defined in created_models: normal import
+        current_nb = models.ContextRecord.objects.count()
+        self.assertEqual(current_nb, old_nb + 4)
+
+        # add an inadequate model to make created_models non empty
+        for cr in models.ContextRecord.objects.all():
+            cr.delete()
+        mcc, form = self.init_context_record_import()
+        mcc.created_models.clear()
+        mcc.created_models.add(ImporterModel.objects.get(
+            klass='ishtar_common.models.Organization'
+        ))
+        impt = form.save(self.ishtar_user)
+        impt.initialize()
+        self.init_cr_targetkey(impt)
+        # Dating is not in models that can be created but force new is
+        # set for a column that references Dating
+        with self.assertRaises(ImproperlyConfigured):
+            impt.importation()
+
+        # retry with only Dating (no context record)
+        for cr in models.ContextRecord.objects.all():
+            cr.delete()
+        mcc, form = self.init_context_record_import()
+        mcc.created_models.clear()
+        dat_model, c = ImporterModel.objects.get_or_create(
+            klass='archaeological_context_records.models.Dating',
+            defaults={"name": 'Dating'})
+        mcc.created_models.add(dat_model)
+        impt = form.save(self.ishtar_user)
+        impt.initialize()
+        self.init_cr_targetkey(impt)
+        impt.importation()
+
+        current_nb = models.ContextRecord.objects.count()
+        self.assertEqual(current_nb, 0)
+
+        # add a context record model
+        for cr in models.ContextRecord.objects.all():
+            cr.delete()
+        mcc, form = self.init_context_record_import()
+        mcc.created_models.clear()
+        mcc.created_models.add(ImporterModel.objects.get(
+            klass='archaeological_context_records.models.ContextRecord'
+        ))
+        mcc.created_models.add(dat_model)
+        impt = form.save(self.ishtar_user)
+        impt.initialize()
+        self.init_cr_targetkey(impt)
+        impt.importation()
+        current_nb = models.ContextRecord.objects.count()
+        self.assertEqual(current_nb, 4)
+        '''
+
+        # add a context record model
+        for cr in models.ContextRecord.objects.all():
+            cr.delete()
+        mcc, form = self.init_context_record_import()
+        mcc.created_models.clear()
+        mcc.created_models.add(ImporterModel.objects.get(
+            klass='archaeological_context_records.models.ContextRecord'
+        ))
+        impt = form.save(self.ishtar_user)
+        impt.initialize()
+        self.init_cr_targetkey(impt)
+        impt.importation()
+        current_nb = models.ContextRecord.objects.count()
+        self.assertEqual(current_nb, 4)
+        '''
+
 
 class ContextRecordInit(OperationInitTest):
     def create_context_record(self, user=None, data={}, force=False):
diff --git a/archaeological_context_records/tests/MCC-context-records-example.csv b/archaeological_context_records/tests/MCC-context-records-example.csv
index d246623cd..9a6ad5f09 100644
--- a/archaeological_context_records/tests/MCC-context-records-example.csv
+++ b/archaeological_context_records/tests/MCC-context-records-example.csv
@@ -1,5 +1,5 @@
 code OA,numero INSEE commune,identifiant parcelle,identifiant UE,type,description,interpretation,date ouverture,date fermeture,identifiant document georeferencement,commentaire,nature,chronologie
 4200,75101,XXXX,HC,Hors contexte,UE globale pour cette parcelle,Non-applicable,,,,UE virtuelle,,
 4200,75101,XXXX,H.-C.,HC,UE globale pour cette parcelle,NA,,,,UE virtuelle,,
-4200,59350,YY55,XXXXXX,HC,UE globale pour cette parcelle,,,,,UE virtuelle,,
+4200,59350,YY55,XXXXXX,HC,UE globale pour cette parcelle,,,,,UE virtuelle,,paleolithic
 4200,59350,YY55,US17,couche,couche de cendre,comblement,,,,présence de charbons,,indéterminé
diff --git a/ishtar_common/data_importer.py b/ishtar_common/data_importer.py
index 79259b76d..859feade9 100644
--- a/ishtar_common/data_importer.py
+++ b/ishtar_common/data_importer.py
@@ -727,6 +727,28 @@ class Importer(object):
                     comment=line.comment)
         return True
 
+    def _get_improperly_conf_error(self, model):
+        from ishtar_common.models import ImporterModel
+        cls_name = model.__module__ + "." + model.__name__
+        q = ImporterModel.objects.filter(klass=cls_name)
+        if q.count():
+            cls_name = q.all()[0].name
+        return ImproperlyConfigured(
+            unicode(self.ERRORS['improperly_configured']).format(cls_name))
+
+    def _get_does_not_exist_in_db_error(self, model, data):
+        from ishtar_common.models import ImporterModel
+        cls_name = model.__module__ + "." + model.__name__
+        q = ImporterModel.objects.filter(klass=cls_name)
+        if q.count():
+            cls_name = q.all()[0].name
+        values = u", ".join(
+            [u"{}: {}".format(k, data[k]) for k in data]
+        )
+        raise ImporterError(
+            unicode(self.ERRORS['does_not_exist_in_db']
+                    ).format(cls_name, values))
+
     def __init__(self, skip_lines=0, reference_header=None,
                  check_col_num=False, test=False, history_modifier=None,
                  output='silent', import_instance=None,
@@ -1025,9 +1047,7 @@ class Importer(object):
             if '__force_new' in data:
                 if self.MODEL_CREATION_LIMIT and \
                                 through_cls not in self.MODEL_CREATION_LIMIT:
-                    raise ImproperlyConfigured(
-                        unicode(self.ERRORS[ 'improperly_configured']).format(
-                            through_cls))
+                    raise self._get_improperly_conf_error(through_cls)
                 created = data.pop('__force_new')
                 t_obj = through_cls.objects.create(**data)
             else:
@@ -1041,12 +1061,8 @@ class Importer(object):
                     try:
                         t_obj = through_cls.objects.get(**get_data)
                     except through_cls.DoesNotExist:
-                        values = u", ".join(
-                            [u"{}: {}".format(k, get_data[k]) for k in get_data]
-                        )
-                        raise ImporterError(
-                            unicode(self.ERRORS['does_not_exist_in_db']
-                                    ).format(through_cls, values))
+                        raise self._get_does_not_exist_in_db_error(
+                            through_cls, get_data)
             if not created and 'defaults' in data:
                 for k in data['defaults']:
                     setattr(t_obj, k, data['defaults'][k])
@@ -1282,10 +1298,7 @@ class Importer(object):
                             if has_values:
                                 if self.MODEL_CREATION_LIMIT and \
                                         model not in self.MODEL_CREATION_LIMIT:
-                                    raise ImproperlyConfigured(
-                                        unicode(
-                                            self.ERRORS['improperly_configured']
-                                        ).format(model))
+                                    raise self._get_improperly_conf_error(model)
                                 v = model.objects.create(**v)
                             else:
                                 continue
@@ -1311,15 +1324,8 @@ class Importer(object):
                                 try:
                                     v = model.objects.get(**get_v)
                                 except model.DoesNotExist:
-                                    values = u", ".join(
-                                        [u"{}: {}".format(k, get_v[k])
-                                         for k in get_v]
-                                    )
-                                    raise ImporterError(
-                                        unicode(
-                                            self.ERRORS[
-                                                'does_not_exist_in_db']
-                                        ).format(model, values))
+                                    raise self._get_does_not_exist_in_db_error(
+                                        model, get_v)
                             changed = False
                             for k in extra_fields.keys():
                                 if extra_fields[k]:
@@ -1408,9 +1414,7 @@ class Importer(object):
                         new_dct.update(dct)
                         if self.MODEL_CREATION_LIMIT and \
                                 cls not in self.MODEL_CREATION_LIMIT:
-                            raise ImproperlyConfigured(
-                                unicode(self.ERRORS[ 'improperly_configured']
-                                        ).format(cls))
+                            raise self._get_improperly_conf_error(cls)
                         obj = cls.objects.create(**new_dct)
                     else:
                         # manage UNICITY_KEYS - only level 1
@@ -1428,12 +1432,8 @@ class Importer(object):
                                 obj = cls.objects.get(**dct)
                                 dct['defaults'] = defaults.copy()
                             except cls.DoesNotExist:
-                                values = u", ".join(
-                                    [u"{}: {}".format(k, dct[k]) for k in dct]
-                                )
-                                raise ImporterError(
-                                    unicode(self.ERRORS['does_not_exist_in_db']
-                                            ).format(cls, values))
+                                raise self._get_does_not_exist_in_db_error(
+                                    cls, dct)
 
                         if not created and not path and self.UNICITY_KEYS:
                             changed = False