Merge branch 'newlodel' of git.labocleo.org:lodel2 into newlodel

lodel/leapi/datahandlers/datas.py

@@ -26,7 +26,7 @@ build its content'
             datas[fname] for fname in self._field_list)
         if len(ret) > self.max_length:
             warnings.warn("Format field overflow. Truncating value")
-            ret = ret[:self.max_length-1]
+            ret = ret[:self.max_length]
         return ret
     
 ##@brief Varchar validated by a regex

lodel/leapi/leobject.py

@@ -4,13 +4,14 @@ import importlib
 import warnings
 import copy
 
-from lodel.plugin import Plugin
 from lodel import logger
 from lodel.settings import Settings
 from lodel.settings.utils import SettingsError
 from .query import LeInsertQuery, LeUpdateQuery, LeDeleteQuery, LeGetQuery
 from .exceptions import *
+from lodel.plugin.exceptions import *
 from lodel.plugin.hooks import LodelHook
+from lodel.plugin import Plugin, DatasourcePlugin
 from lodel.leapi.datahandlers.base_classes import DatasConstructor
 
 ##@brief Stores the name of the field present in each LeObject that indicates
@@ -244,7 +245,7 @@ class LeObject(object):
         else:
             ro_ds, rw_ds = cls._datasource_name
         #Read only datasource initialisation
-        cls._ro_datasource = cls._init_datasource(ro_ds, True)
+        cls._ro_datasource = DatasourcePlugin.init_datasource(ro_ds, True)
         if cls._ro_datasource is None:
             log_msg = "No read only datasource set for LeObject %s"
             log_msg %= cls.__name__
@@ -254,7 +255,7 @@ class LeObject(object):
             log_msg %= (ro_ds, cls.__name__)
             logger.debug(log_msg)
         #Read write datasource initialisation
-        cls._rw_datasource = cls._init_datasource(rw_ds, False)
+        cls._rw_datasource = DatasourcePlugin.init_datasource(rw_ds, False)
         if cls._ro_datasource is None:
             log_msg = "No read/write datasource set for LeObject %s"
             log_msg %= cls.__name__
@@ -264,99 +265,6 @@ class LeObject(object):
             log_msg %= (ro_ds, cls.__name__)
             logger.debug(log_msg)
         
-
-    ##@brief Replace the _datasource attribute value by a datasource instance
-    #
-    #This method is used once at dyncode load to replace the datasource string
-    #by a datasource instance to avoid doing this operation for each query
-    #@param ds_name str : The name of the datasource to instanciate
-    #@param ro bool : if true initialise the _ro_datasource attribute else
-    #initialise _rw_datasource attribute
-    #@throw SettingsError if an error occurs
-    @classmethod
-    def _init_datasource(cls, ds_name, ro):
-        expt_msg = "In LeAPI class '%s' " % cls.__name__
-        if ds_name not in Settings.datasources._fields:
-            #Checking that datasource exists
-            expt_msg += "Unknown or unconfigured datasource %s for class %s"
-            expt_msg %= (ds_name, cls.__name__)
-            raise SettingsError(expt_msg)
-        try:
-            #fetching plugin name
-            ds_plugin_name, ds_identifier = cls._get_ds_plugin_name(ds_name, ro)
-        except NameError:
-            expt_msg += "Datasource %s is missconfigured, missing identifier."
-            expt_msg %= ds_name
-            raise SettingsError(expt_msg)
-        except RuntimeError:
-            expt_msg += "Error in datasource %s configuration. Trying to use \
-a read only as a read&write datasource"
-            expt_msg %= ds_name
-            raise SettingsError(expt_msg)
-        except ValueError as e:
-            expt_msg += str(e)
-            raise SettingsError(expt_msg)
-        
-        try:
-            ds_conf = cls._get_ds_connection_conf(ds_identifier, ds_plugin_name)
-        except NameError as e:
-            expt_msg += str(e)
-            raise SettingsError(expt_msg)
-        #Checks that the datasource plugin exists
-        ds_plugin_module = Plugin.get(ds_plugin_name).loader_module()
-        try:
-            datasource_class = getattr(ds_plugin_module, "Datasource")
-        except AttributeError as e:
-            expt_msg += "The datasource plugin %s seems to be invalid. Error \
-raised when trying to import Datasource"
-            expt_msg %= ds_identifier
-            raise SettingsError(expt_msg)
-
-        return datasource_class(**ds_conf)
-
-    ##@brief Try to fetch a datasource configuration
-    #@param ds_identifier str : datasource name
-    #@param ds_plugin_name : datasource plugin name
-    #@return a dict containing datasource initialisation options
-    #@throw NameError if a datasource plugin or instance cannot be found
-    @staticmethod
-    def _get_ds_connection_conf(ds_identifier,ds_plugin_name):
-        if ds_plugin_name not in Settings.datasource._fields:
-            msg = "Unknown or unconfigured datasource plugin %s"
-            msg %= ds_plugin
-            raise NameError(msg)
-        ds_conf = getattr(Settings.datasource, ds_plugin_name)
-        if ds_identifier not in ds_conf._fields:
-            msg = "Unknown or unconfigured datasource instance %s"
-            msg %= ds_identifier
-            raise NameError(msg)
-        ds_conf = getattr(ds_conf, ds_identifier)
-        return {k: getattr(ds_conf,k) for k in ds_conf._fields }
-
-    ##@brief fetch datasource plugin name
-    #@param ds_name str : datasource name
-    #@param ro bool : if true consider the datasource as read only
-    #@return a tuple(DATASOURCE_PLUGIN_NAME, DATASOURCE_CONNECTION_NAME)
-    #@throw NameError if datasource identifier not found
-    #@throw RuntimeError if datasource is read_only but ro flag was false
-    @staticmethod
-    def _get_ds_plugin_name(ds_name, ro):
-        datasource_orig_name = ds_name
-        # fetching connection identifier given datasource name
-        ds_identifier = getattr(Settings.datasources, ds_name)
-        read_only = getattr(ds_identifier, 'read_only')
-        try:
-            ds_identifier = getattr(ds_identifier, 'identifier')
-        except NameError as e:
-            raise e
-        if read_only and not ro:
-            raise RuntimeError()
-        res = ds_identifier.split('.')
-        if len(res) != 2:
-            raise ValueError("expected value for identifier is like \
-DS_PLUGIN_NAME.DS_INSTANCE_NAME. But got %s" % ds_identifier)
-        return res
-    
     ##@brief Return the uid of the current LeObject instance
     #@return the uid value
     #@warning Broke multiple uid capabilities

lodel/plugin/__init__.py

@@ -41,3 +41,4 @@
 
 from .hooks import LodelHook
 from .plugins import Plugin, CustomMethod
+from .datasource_plugin import DatasourcePlugin

lodel/plugin/datasource_plugin.py

@@ -0,0 +1,133 @@
+from .plugins import Plugin
+from .exceptions import *
+from lodel.settings.validator import SettingValidator
+
+##@brief Designed to handles datasources plugins
+#
+#A datasource provide data access to LeAPI typically a connector on a DB
+#or an API
+#@note For the moment implementation is done with a retro-compatibilities
+#priority and not with a convenience priority.
+#@todo Refactor and rewrite lodel2 datasource handling
+class DatasourcePlugin(Plugin):
+    
+    ##@brief Stores confspecs indicating where DatasourcePlugin list is stored
+    _plist_confspecs = {
+        'section': 'lodel2',
+        'key': 'datasources',
+        'default': None,
+        'validator': SettingValidator('list', none_is_valid = False) }
+    
+    def __init__(self, name):
+        super().__init__(name)
+        self.__datasource_cls = None
+
+    def datasource_cls(self):
+        if self.__datasource_cls is None:
+            self.__datasource_cls = self.loader_module().Datasource
+        return self.__datasource_cls
+
+    def migration_handler(self):
+        return self.loader_module().migration_handler_class()
+
+    @classmethod
+    def plist_confspec(cls):
+        return copy.copy(cls._plist_confspecs)
+
+    ##@brief Return an initialized Datasource instance
+    #@param ds_name str : The name of the datasource to instanciate
+    #@param ro bool
+    #@return A properly initialized Datasource instance
+    #@throw SettingsError if an error occurs in settings
+    #@throw DatasourcePluginError for various errors
+    @classmethod
+    def init_datasource(cls, ds_name, ro):
+        plugin_name, ds_identifier = cls.plugin_name(ds_name, ro)
+        ds_conf = cls._get_ds_connection_conf(ds_identifier, plugin_name)
+        ds_cls = cls.get_datasource(plugin_name)
+        return ds_cls(**ds_conf)
+
+    ##@brief Given a datasource name returns a DatasourcePlugin name
+    #@param ds_name str : datasource name
+    #@param ro bool : if true consider the datasource as readonly
+    #@return a DatasourcePlugin name
+    #@throw PluginError if datasource name not found
+    #@throw DatasourcePermError if datasource is read_only but ro flag arg is
+    #false
+    @staticmethod
+    def plugin_name(ds_name, ro):
+        from lodel.settings import Settings
+        # fetching connection identifier given datasource name
+        try:
+            ds_identifier = getattr(Settings.datasources, ds_name)
+        except (NameError, AttributeError):
+            raise DatasourcePluginError("Unknown or unconfigured datasource \
+'%s'" % ds_name)
+        # fetching read_only flag
+        try:
+            read_only = getattr(ds_identifier, 'read_only')
+        except (NameError, AttributeError):
+            raise SettingsError("Malformed datasource configuration for '%s' \
+: missing read_only key" % ds_name)
+        # fetching datasource identifier
+        try:
+            ds_identifier = getattr(ds_identifier, 'identifier')
+        except (NameError,AttributeError) as e:
+            raise SettingsError("Malformed datasource configuration for '%s' \
+: missing identifier key" % ds_name)
+        # settings and ro arg consistency check
+        if read_only and not ro:
+            raise DatasourcePluginError("ro argument was set to False but \
+True found in settings for datasource '%s'" % ds_name)
+        res = ds_identifier.split('.')
+        if len(res) != 2:
+            raise SettingsError("expected value for identifier is like \
+DS_PLUGIN_NAME.DS_INSTANCE_NAME. But got %s" % ds_identifier)
+        return res
+
+    ##@brief Try to fetch a datasource configuration
+    #@param ds_identifier str : datasource name
+    #@param ds_plugin_name : datasource plugin name
+    #@return a dict containing datasource initialisation options
+    #@throw NameError if a datasource plugin or instance cannot be found
+    @staticmethod
+    def _get_ds_connection_conf(ds_identifier,ds_plugin_name):
+        from lodel.settings import Settings
+        if ds_plugin_name not in Settings.datasource._fields:
+            msg = "Unknown or unconfigured datasource plugin %s"
+            msg %= ds_plugin
+            raise DatasourcePluginError(msg)
+        ds_conf = getattr(Settings.datasource, ds_plugin_name)
+        if ds_identifier not in ds_conf._fields:
+            msg = "Unknown or unconfigured datasource instance %s"
+            msg %= ds_identifier
+            raise DatasourcePluginError(msg)
+        ds_conf = getattr(ds_conf, ds_identifier)
+        return {k: getattr(ds_conf,k) for k in ds_conf._fields }
+
+    ##@brief DatasourcePlugin instance accessor
+    #@param ds_name str : plugin name
+    #@return a DatasourcePlugin instance
+    #@throw PluginError if no plugin named ds_name found
+    #@throw PluginTypeError if ds_name ref to a plugin that is not a 
+    #DatasourcePlugin
+    @classmethod
+    def get(cls, ds_name):
+        pinstance = super().get(ds_name) #Will raise PluginError if bad name
+        if not isinstance(pinstance, DatasourcePlugin):
+           raise PluginTypeErrror("A name of a DatasourcePlugin was excepted \
+but %s is a %s" % (ds_name, pinstance.__class__.__name__))
+        return pinstance
+
+    ##@brief Return a datasource class given a datasource name
+    #@param ds_name str : datasource plugin name
+    #@throw PluginError if ds_name is not an existing plugin name
+    #@throw PluginTypeError if ds_name is not the name of a DatasourcePlugin
+    @classmethod
+    def get_datasource(cls, ds_plugin_name):
+        return cls.get(ds_plugin_name).datasource_cls()
+
+    @classmethod
+    def get_migration_handler(cls, ds_plugin_name):
+        return cls.get(ds_plugin_name).migration_handler_class()
+ 

lodel/plugin/exceptions.py

@@ -1,5 +1,11 @@
 class PluginError(Exception):
     pass
 
+class PluginTypeErrror(PluginError):
+    pass
+
 class LodelScriptError(Exception):
     pass
+
+class DatasourcePluginError(PluginError):
+    pass

lodel/plugin/plugins.py

@@ -8,8 +8,9 @@ import json
 from importlib.machinery import SourceFileLoader, SourcelessFileLoader
 
 import plugins
-from .exceptions import *
 from lodel import logger
+from lodel.settings.utils import SettingsError
+from .exceptions import *
 
 ## @package lodel.plugins Lodel2 plugins management
 #
@@ -26,7 +27,7 @@ VIRTUAL_TEMP_PACKAGE_NAME = 'lodel.plugin_tmp'
 ##@brief Plugin init filename
 INIT_FILENAME = '__init__.py' # Loaded with settings
 PLUGIN_NAME_VARNAME = '__plugin_name__'
-PLUGIN_TYPE_VARNAME = '__type__'
+PLUGIN_TYPE_VARNAME = '__plugin_type__'
 PLUGIN_VERSION_VARNAME = '__version__'
 CONFSPEC_FILENAME_VARNAME = '__confspec__'
 CONFSPEC_VARNAME = 'CONFSPEC'
@@ -41,8 +42,8 @@ DEFAULT_PLUGINS_PATH_LIST = ['./plugins']
 MANDATORY_VARNAMES = [PLUGIN_NAME_VARNAME, LOADER_FILENAME_VARNAME, 
     PLUGIN_VERSION_VARNAME]
 
-EXTENSIONS = 'default'
-PLUGINS_TYPES = [EXTENSIONS, 'datasource', 'session_handler', 'ui']
+DEFAULT_PLUGIN_TYPE = 'extension'
+PLUGINS_TYPES = [DEFAULT_PLUGIN_TYPE, 'datasource', 'session_handler', 'ui']
 
 
 ##@brief Describe and handle version numbers
@@ -147,6 +148,35 @@ to generic PluginVersion comparison function : '%s'" % cmp_fun_name)
         return {'major': self.major, 'minor': self.minor,
             'revision': self.revision}
 
+##@brief Stores plugin class registered
+__all_ptypes = list()
+
+##@brief Plugin metaclass that allows to "catch" child class
+#declaration
+#
+#Automatic script registration on child class declaration
+class MetaPlugType(type):
+    
+    def __init__(self, name, bases, attrs):
+        #Here we can store all child classes of Plugin
+        super().__init__(name, bases, attrs)
+        if len(bases) == 1 and bases[0] == object:
+            print("Dropped : ", name, bases)
+            return
+        self.__register_types()
+        #list_name= [cls.__name__ for cls in __all_ptypes] 
+        #if self.name in list_name:
+        #    return
+        #else:
+        #    plug_type_register(self)
+
+    def __register_types(self):
+        plug_type_register(self)
+
+def plug_type_register(cls):
+    __all_ptypes.append(cls)
+    logger.info("New child class registered : %s" % cls.__name__)
+
 
 ##@brief Handle plugins
 #
@@ -157,7 +187,7 @@ to generic PluginVersion comparison function : '%s'" % cmp_fun_name)
 # 1. Settings call start method to instanciate all plugins found in confs
 # 2. Settings fetch all confspecs
 # 3. the loader call load_all to register hooks etc
-class Plugin(object):
+class Plugin(object, metaclass=MetaPlugType):
     
     ##@brief Stores plugin directories paths
     _plugin_directories = None
@@ -171,6 +201,9 @@ class Plugin(object):
 
     ##@brief Attribute that stores plugins list from discover cache file
     _plugin_list = None
+    
+    ##@brief Store dict representation of discover cache content
+    _discover_cache = None
 
     ##@brief Plugin class constructor
     #
@@ -248,7 +281,7 @@ init file. Malformed plugin"
         try:
             self.__type = getattr(self.module, PLUGIN_TYPE_VARNAME)
         except AttributeError:
-            self.__type = EXTENSIONS
+            self.__type = DEFAULT_PLUGIN_TYPE
         self.__type = str(self.__type).lower()
         if self.__type not in PLUGINS_TYPES:
             raise PluginError("Unknown plugin type '%s'" % self.__type)
@@ -426,6 +459,50 @@ name differ from the one found in plugin's init file"
     def confspecs(self):
         return copy.copy(self.__confspecs)
 
+    ##@brief Retrieves plugin list confspecs
+    #
+    #This method ask for each Plugin child class the confspecs specifying where
+    #the wanted plugin list is stored. (For example DatasourcePlugin expect
+    #that a list of ds plugin to load stored in lodel2 section, datasources key
+    # etc...
+    @classmethod
+    def plugin_list_confspec(cls):
+        from lodel.settings.validator import confspec_append
+        res = dict()
+        for pcls in cls.plugin_types():
+            plcs = pcls.plist_confspec()
+            confspec_append(res, plcs)
+        return res
+
+    ##@brief Attempt to read plugin discover cache
+    #@note If no cache yet make a discover with default plugin directory
+    #@return a dict (see @ref _discover() )
+    @classmethod
+    def plugin_cache(cls):
+        if cls._discover_cache is None:
+            if not os.path.isfile(DISCOVER_CACHE_FILENAME):
+                cls.discover()
+            with open(DISCOVER_CACHE_FILENAME) as pdcache_fd:
+                res = json.load(pdcache_fd)
+            #Check consistency of loaded cache
+            if 'path_list' not in res:
+                raise LodelFatalError("Malformed plugin's discover cache file \
+: '%s'. Unable to find plugin's paths list." % DISCOVER_CACHE_FILENAME)
+            expected_keys = ['type', 'path', 'version']
+            for pname in res['plugins']:
+                for ekey in expected_keys:
+                    if ekey not in res['plugins'][pname]:
+                        #Bad cache !
+                        logger.warning("Malformed plugin's discover cache \
+file : '%s'. Running discover again..." % DISCOVER_CACHE_FILENAME)
+                        cls._discover_cache = cls.discover(res['path_list'])
+                        break
+            else:
+                #The cache we just read was OK
+                cls._discover_cache = res
+                
+        return cls._discover_cache
+
     ##@brief Register a new plugin
     # 
     #@param plugin_name str : The plugin name
@@ -433,11 +510,23 @@ name differ from the one found in plugin's init file"
     #@throw PluginError
     @classmethod
     def register(cls, plugin_name):
+        from .datasource_plugin import DatasourcePlugin
         if plugin_name in cls._plugin_instances:
             msg = "Plugin allready registered with same name %s"
             msg %= plugin_name
             raise PluginError(msg)
-        plugin = cls(plugin_name)
+        #Here we check that previous discover found a plugin with that name
+        pdcache = cls.plugin_cache()
+        if plugin_name not in pdcache['plugins']:
+            raise PluginError("No plugin named %s found" % plugin_name)
+        pinfos = pdcache['plugins'][plugin_name]
+        ptype = pinfos['type']
+        if ptype == 'datasource':
+            pcls = DatasourcePlugin
+        else:
+            pcls = cls
+        print(plugin_name, ptype, pcls)
+        plugin = pcls(plugin_name)
         cls._plugin_instances[plugin_name] = plugin
         logger.debug("Plugin %s available." % plugin)
         return plugin
@@ -530,8 +619,7 @@ name differ from the one found in plugin's init file"
         result = dict()
         for pinfos in tmp_res:
             pname = pinfos['name']
-            if (
-                    pname in result 
+            if (    pname in result 
                     and pinfos['version'] > result[pname]['version'])\
                 or pname not in result:
                 result[pname] = pinfos
@@ -566,6 +654,11 @@ name differ from the one found in plugin's init file"
         cls._plugin_list = infos['plugins']
         return cls._plugin_list
 
+    ##@brief Return a list of child Class Plugin
+    @classmethod
+    def plugin_types(cls):
+        return cls.__all_ptypes
+
     ##@brief Attempt to open and load plugin discover cache
     #@return discover cache
     #@throw PluginError when open or load fails
@@ -617,16 +710,23 @@ name differ from the one found in plugin's init file"
                 log_msg %= (attr_name, INIT_FILENAME)
                 logger.debug(log_msg)
                 return False
+        #Fetching plugin's version
         try:
             pversion = getattr(initmod, PLUGIN_VERSION_VARNAME)
-        except PluginError as e:
+        except (NameError, AttributeError) as e:
             msg = "Invalid plugin version found in %s : %s"
             msg %= (path, e)
             raise PluginError(msg)
+        #Fetching plugin's type
+        try:
+            ptype = getattr(initmod, PLUGIN_TYPE_VARNAME)
+        except (NameError, AttributeError) as e:
+            ptype = DEFAULT_PLUGIN_TYPE
         pname = getattr(initmod, PLUGIN_NAME_VARNAME)
         return {'name': pname,
             'version': pversion,
-            'path': path}
+            'path': path,
+            'type': ptype}
     
     ##@brief Import init file from a plugin path
     #@param path str : Directory path
@@ -795,14 +895,13 @@ with %s" % (custom_method._method_name, custom_method))
 
 class SessionHandler(Plugin):
     __instance = None
-
-    def __new__(cls):
-        if cls.__instance == None:
-            cls.instance == object.__new__(cls)
-        return cls.__instance
         
     def __init__(self, plugin_name):
-        super(Plugin, self).__init__(plugin_name)
+        if self.__instance is None:
+            super(Plugin, self).__init__(plugin_name)
+            self.__instance = True
+        else:
+            raise RuntimeError("A SessionHandler Plugin is already plug")
 
 class InterfacePlugin(Plugin):
     def __init__(self, plugin_name):

lodel/settings/settings.py

@@ -128,7 +128,7 @@ class Settings(object, metaclass=MetaSettings):
         confkey=confname.rpartition('.')
         loader.setoption(confkey[0], confkey[2], confvalue, validator)
 
-    ##@brief This method handlers Settings instance bootstraping
+    ##@brief This method handles Settings instance bootstraping
     def __bootstrap(self):
         logger.debug("Settings bootstraping")
         lodel2_specs = LODEL2_CONF_SPECS

lodel/settings/validator.py

@@ -240,20 +240,20 @@ def emfield_val(value):
     return value
 
 def plugin_val(value):
-    if spl = value.split('.')
+    spl = value.split('.')
     if len(spl) != 2:
         msg = "Expected a value in the form PLUGIN.TYPE but got : %s"
         raise SettingsValidationError(msg % value)
     value = tuple(spl)
-        #Late validation hook
-        @LodelHook('lodel2_dyncode_bootstraped')
-        def type_check(hookname, caller, payload):
-            from lodel import plugin
-            typesname = { cls.__name__.lower():cls for cls in plugin.PLUGINS_TYPE}
-            if value[1].lower() not in typesname:
-                msg = "Following plugin type do not exist in plugin list %s : %s"
-                raise SettingsValidationError(msg % value)
-            return value
+    #Late validation hook
+    @LodelHook('lodel2_dyncode_bootstraped')
+    def type_check(hookname, caller, payload):
+        from lodel import plugin
+        typesname = { cls.__name__.lower():cls for cls in plugin.PLUGINS_TYPE}
+        if value[1].lower() not in typesname:
+            msg = "Following plugin type do not exist in plugin list %s : %s"
+            raise SettingsValidationError(msg % value)
+        return value
     plug_type_val = plugin_val(value)
     return plug_type_val
 
@@ -352,6 +352,23 @@ SettingValidator.create_re_validator(
 #   Lodel 2 configuration specification
 #
 
+##@brief Append a piece of confspec
+#@note orig is modified during the process
+#@param orig dict : the confspec to update
+#@param upd dict : the confspec to add
+#@return new confspec
+def confspec_append(orig, upd):
+    for section in orig:
+        if section in upd:
+            orig[section].update(upd[section])
+        else:
+            orig[section] = upd[section]
+    return orig
+
+def confspec_add(orig, section, key, default, validator):
+    if section not in orig:
+        section[orig] = dict()
+
 ##@brief Global specifications for lodel2 settings
 LODEL2_CONF_SPECS = {
     'lodel2': {

plugins/dummy_datasource/__init__.py

@@ -1,6 +1,7 @@
 from lodel.settings.validator import SettingValidator
 from .datasource import DummyDatasource as Datasource
 
+__plugin_type__ = 'datasource'
 __plugin_name__ = "dummy_datasource"
 __version__ = '0.0.1'
 __loader__ = 'main.py'

plugins/mongodb_datasource/__init__.py

@@ -1,4 +1,5 @@
 #-*- coding: utf-8 -*-
+__plugin_type__ = 'datasource'
 __plugin_name__ = 'mongodb_datasource'
 __version__ = '0.0.1'
 __plugin_type__ = 'datasource'

tests/datahandlers/test_concat.py

@@ -0,0 +1,22 @@
+import unittest
+
+from lodel.leapi.datahandlers.datas import Concat
+from lodel.editorial_model.components import EmClass
+
+class ConcatTestCase(unittest.TestCase):
+
+    def test_construct_data(self):
+        test_class = EmClass('testing', display_name='testing class')
+        test_class.new_field('field1', 'varchar')
+        test_class.new_field('field2', 'varchar')
+
+        test_concat = Concat(['field1', 'field2'], '*')
+        concat_string_value = test_concat.construct_data(test_class, 'field', {'field1': 'o'*5, 'field2': 'k'*4}, '')
+        self.assertEqual('%s*%s' % ('o'*5, 'k'*4), concat_string_value)
+
+        test_concat.max_length=10
+        concat_string_value = test_concat.construct_data(test_class, 'field', {'field1': 'o'*5, 'field2': 'k'*10}, '')
+        test_value = '%s*%s' % ('o'*5, 'k'*10)
+        self.assertNotEqual(test_value, concat_string_value)
+        self.assertEqual(len(concat_string_value), test_concat.max_length)
+        self.assertTrue(concat_string_value in test_value)

tests/datahandlers/test_formatstring.py

@@ -0,0 +1,28 @@
+import unittest
+
+from lodel.leapi.datahandlers.datas import FormatString
+from lodel.editorial_model.components import EmClass
+
+
+class FormatStringTestCase(unittest.TestCase):
+
+    def test_construct_data(self):
+        test_class = EmClass('testing',display_name='testing class')
+        test_class.new_field('field1', 'varchar')
+        test_class.new_field('field2', 'varchar')
+
+        test_formatstring = FormatString('%s_%s',['field1', 'field2'], max_length=10)
+        formatted_string_value = test_formatstring.construct_data(test_class, 'field', {'field1': 'o'*5, 'field2': 'k'*4}, '')
+        self.assertEqual('%s_%s' % ('o'*5, 'k'*4), formatted_string_value)
+
+    def test_construct_too_long_data(self):
+        test_class = EmClass('testing', display_name='testing class')
+        test_class.new_field('field1', 'varchar')
+        test_class.new_field('field2', 'varchar')
+        test_formatstring = FormatString('%s-%s', ['field2', 'field1'], max_length=10)
+        formatted_string_value = test_formatstring.construct_data(test_class, 'field', {'field1': 'o'*300, 'field2': 'k'*500},'')
+        test_value = '%s-%s' % ('k'*500, 'o'*300)
+        self.assertNotEqual(test_value, formatted_string_value)
+        self.assertTrue(formatted_string_value in test_value)
+        self.assertTrue(len(formatted_string_value) == test_formatstring.max_length)
+        self.assertEqual(formatted_string_value, test_value[:test_formatstring.max_length])