Model construct enhancement with backend and MH inheritance

Every backend and MH are now subclasses of dummy ones. This allow to check the type with issubclass.

EditorialModel/backend/graphviz.py

 from EditorialModel.fieldgroups import EmFieldGroup
 from EditorialModel.types import EmType
 from Lodel.utils.mlstring import MlString
+from EditorialModel.backend.dummy_backend import EmBackendDummy
 
-class EmBackendGraphviz(object):
+class EmBackendGraphviz(EmBackendDummy):
 
     ## @brief Constructor
     # @param dot_fname str : The filename where we want to save the dot repr of the EM

EditorialModel/backend/json_backend.py

 import json
 import datetime
 from Lodel.utils.mlstring import MlString
+from EditorialModel.backend.dummy_backend import EmBackendDummy
 
 
 def date_cast(date):
 
 
 ## Manages a Json file based backend structure
-class EmBackendJson(object):
+class EmBackendJson(EmBackendDummy):
 
     cast_methods = {
         'uid': int,

EditorialModel/migrationhandler/django.py

 from django.db import models
 from django.db.models.loading import cache as django_cache
 from django.core.exceptions import ValidationError
+from EditorialModel.migrationhandler.dummy import DummyMigrationHandler
 
 from EditorialModel.exceptions import *
 
 #
 # Create django models according to the editorial model
 
-class DjangoMigrationHandler(object):
+class DjangoMigrationHandler(DummyMigrationHandler):
 
     ## @brief Instanciate a new DjangoMigrationHandler
     # @param app_name str : The django application name for models generation

EditorialModel/model.py

     #
     # @param backend unknown: A backend object instanciated from one of the classes in the backend module
     def __init__(self, backend, migration_handler=None):
-        self.migration_handler = DummyMigrationHandler() if migration_handler is None else migration_handler
-        self.backend = backend
+        if migration_handler is None:
+            self.migration_handler = DummyMigrationHandler()
+        elif issubclass(migration_handler.__class__, DummyMigrationHandler):
+            self.migration_handler = migration_handler
+        else:
+            raise TypeError("migration_handler should be an instance from a subclass of DummyMigrationhandler")
+        self.backend = None
+        self.set_backend(backend)
+
         self._components = {'uids': {}, 'EmClass': [], 'EmType': [], 'EmField': [], 'EmFieldGroup': []}
         self.load()
 
     #
     # @param backend unknown: A backend object
     def set_backend(self, backend):
-        self.backend = backend
+        if issubclass(backend.__class__, EmBackendDummy):
+            self.backend = backend
+        else:
+            raise TypeError('Backend should be an instance of a EmBackednDummy subclass')
 
     ## Returns a list of all the EmClass objects of the model
     def classes(self):

EditorialModel/test/test_model.py

         model = Model(EmBackendJson('EditorialModel/test/me.json'), migration_handler=DjangoMigrationHandler('LodelTestInstance', debug=False, dryrun=True))
         self.assertTrue(isinstance(model, Model))
 
+    def test_bad_init(self):
+        """ Test initialisation with bad arguments """
+        for bad in [ None, int, EmBackendDummy, DummyMigrationHandler, 'foobar' ]:
+            with self.assertRaises(TypeError, msg="Tried to instanciate a Model with a bad backend"):
+                Model(bad)
+        for bad in [ int, EmBackendDummy, DummyMigrationHandler, 'foobar' ]:
+            with self.assertRaises(TypeError, msg="Tried to instanciate a Model with a migration_handler"):
+                Model(EmBackendDummy(), bad)
+
     def test_components(self):
         """ Test components fetching """
         uid_l = list()
     def test_set_backend(self):
         """ Test the set_backend method """
 
-        for backend in [ None, EmBackendJson('EditorialModel/test/me.json'), EmBackendDummy() ]:
+        for backend in [ EmBackendJson('EditorialModel/test/me.json'), EmBackendDummy() ]:
             self.me.set_backend(backend)
             self.assertEqual(self.me.backend, backend)
 
-        for bad_backend in ['wow', int, EmBackendJson ]:
-            with self.assertRaises(AttributeError, msg="But bad argument (%s %s) was given"%(type(bad_backend),bad_backend)):
+        for bad_backend in [None, 'wow', int, EmBackendJson ]:
+            with self.assertRaises(TypeError, msg="But bad argument (%s %s) was given"%(type(bad_backend),bad_backend)):
                 self.me.set_backend(bad_backend)
     ##
     # @todo Test selected fields application
         for cls in [EmComponent, int, str]:
             self.assertFalse(Model.name_from_emclass(cls))
 
-    def test_load_save_invalid(self):
-        """ Test the behavior of a Model when no backend given but load and save are called """
-        bad_em = Model(None)
-        
-        self.assertFalse(bad_em.load())
-        self.assertFalse(bad_em.save())
-