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

install/loader.py

@@ -1,6 +1,6 @@
 #-*- coding: utf-8 -*-
 
-import sys, os
+import sys, os, os.path
 #
 # Bootstraping
 #
@@ -19,7 +19,8 @@ except ImportError:
 # Loading settings
 #
 from lodel.settings.settings import Settings as settings
-settings('conf.d')
+if not settings.started():
+    settings('conf.d')
 from lodel.settings import Settings
 
 #Starts hooks
@@ -36,6 +37,20 @@ def start():
 
 if __name__ == '__main__':
     start()
+
+    if Settings.runtest:
+        import unittest
+        import tests
+        loader = unittest.TestLoader()
+        test_dir = os.path.join(LODEL2_LIB_ABS_PATH, 'tests')
+        suite = loader.discover(test_dir)
+        print("DEBUG  : failfast  = ", '-f' in sys.argv, sys.argv)
+        runner = unittest.TextTestRunner(
+            failfast = '-f' in sys.argv,
+            verbosity = 2 if '-v' in sys.argv else 1)
+        runner.run(suite)
+        exit()
+
     LodelHook.call_hook('lodel2_loader_main', '__main__', None)
     #Run interative python
     import code

lodel/leapi/leobject.py

@@ -26,21 +26,23 @@ class LeObjectValues(object):
     # @param set_callback method : The LeObject.set_datas() method of corresponding LeObject class
     # @param get_callback method : The LeObject.get_datas() method of corresponding LeObject class
     def __init__(self, fieldnames_callback, set_callback, get_callback):
-        self.__setter = set_callback
-        self.__getter = get_callback
+        self._setter = set_callback
+        self._getter = get_callback
     
     ##@brief Provide read access to datas values
     # @note Read access should be provided for all fields
     # @param fname str : Field name
     def __getattribute__(self, fname):
-        return self.__getter(fname)
+        getter = super().__getattribute__('_getter')
+        return getter(fname)
     
     ##@brief Provide write access to datas values
     # @note Write acces shouldn't be provided for internal or immutable fields
     # @param fname str : Field name
     # @param fval * : the field value
     def __setattribute__(self, fname, fval):
-        return self.__setter(fname, fval)
+        setter = super().__getattribute__('_setter')
+        return setter(fname, fval)
         
 
 class LeObject(object):
@@ -56,17 +58,26 @@ class LeObject(object):
     ##@breif Read & write datasource ( see @ref lodel2_datasources )
     _rw_datasource = None
 
-    ##@brief Construct an object representing an Editorial component
-    # @note Can be considered as EmClass instance
-    def __init__(self, **kwargs):
-        if self._abstract:
-            raise NotImplementedError("%s is abstract, you cannot instanciate it." % self.__class__.__name__ )
+    def __new__(cls, **kwargs):
+        
+        self = object.__new__(cls)
         ##@brief A dict that stores fieldvalues indexed by fieldname
         self.__datas = { fname:None for fname in self._fields }
         ##@brief Store a list of initianilized fields when instanciation not complete else store True
         self.__initialized = list()
         ##@brief Datas accessor. Instance of @ref LeObjectValues
         self.d = LeObjectValues(self.fieldnames, self.set_data, self.data)
+        for fieldname, fieldval in kwargs.items():
+            self.__datas[fieldname] = fieldval
+            self.__initialized.append(fieldname)
+        self.__set_initialized()
+        return self
+
+    ##@brief Construct an object representing an Editorial component
+    # @note Can be considered as EmClass instance
+    def __init__(self, **kwargs):
+        if self._abstract:
+            raise NotImplementedError("%s is abstract, you cannot instanciate it." % self.__class__.__name__ )
 
         # Checks that uid is given
         for uid_name in self._uid:
@@ -75,25 +86,24 @@ class LeObject(object):
             self.__datas[uid_name] = kwargs[uid_name]
             del(kwargs[uid_name])
             self.__initialized.append(uid_name)
-        
+
         # Processing given fields
         allowed_fieldnames = self.fieldnames(include_ro = False)
-        err_list = list()
+        err_list = dict()
         for fieldname, fieldval in kwargs.items():
             if fieldname not in allowed_fieldnames:
                 if fieldname in self._fields:
-                    err_list.append(
-                        LeApiError("Value given for internal field : '%s'" % fieldname)
-                    )
+                    err_list[fieldname] = LeApiError(
+                        "Value given but the field is internal")
                 else:
-                    err_list.append(
-                        LeApiError("Unknown fieldname : '%s'" % fieldname)
-                    )
+                    err_list[fieldname] = LeApiError(
+                        "Unknown fieldname : '%s'" % fieldname)
             else:
                 self.__datas[fieldname] = fieldval
                 self.__initialized.append(fieldname)
         if len(err_list) > 0:
-            raise LeApiErrors(err_list)
+            raise LeApiErrors(msg = "Unable to __init__ %s" % self.__class__,
+                exceptions = err_list)
         self.__set_initialized()
     
     #-----------------------------------#
@@ -268,8 +278,8 @@ raised when trying to import Datasource"
     
     ##@brief Read only access to all datas
     #@return a dict representing datas of current instance
-    def datas(self):
-        return [self.data(fname) for fname in self.fieldnames(True)]
+    def datas(self, internal = False):
+        return {fname:self.data(fname) for fname in self.fieldnames(internal)}
         
     
     ##@brief Datas setter
@@ -485,7 +495,7 @@ raised when trying to import Datasource"
     ## @brief Update an instance of LeObject
     #
     #@param datas : list of new datas 
-    def update(self, datas):
+    def update(self, datas = None):
         datas = self.datas(internal=False) if datas is None else datas
         uids = self._uid
         query_filter = list()
@@ -493,7 +503,7 @@ raised when trying to import Datasource"
             query_filter.append((uid, '=', self.data(uid)))
         
         try:
-            query = LeUpdateQuery(cls, query_filter)
+            query = LeUpdateQuery(self.__class__, query_filter)
         except Exception as err:
             raise err
             
@@ -538,43 +548,6 @@ raised when trying to import Datasource"
             deleted += result
         return deleted
             
-    
-    ## @brief Load an instance of LeObject
-    #@param uid a list of tuple (uid_field_nane, value) ou a single value
-    #@return an instance of a subclass of LeObject
-    @classmethod
-    def load(cls, uid_tuples):
-        query_filter = list()
-        uids = cls._uid
-        if uids.isinstance(tuple):
-            if not uid_tuples.isinstance(list):
-                raise AttributeError ("In %s:load : uid must be a list of tuple" % cls.__name__)
-            elif len(uid_tuples) != len(uids):
-                raise AttributeError ("In %s:load : must have %d uid fields" % len(uids))
-            for fieldname, fieldvalue in uid_tuples:
-                if fieldname in uids:
-                    dhdl = cls.data_handler(fieldname)
-                    if dhdl.check_data_value(fieldvalue)[1] is None:
-                        query_filter.append((fieldname, '=', fieldvalue))
-                    else:
-                        raise AttributeError("n %s:load :%s not a valid value for %s" % (fieldvalue, fieldname))
-                else:
-                    raise AttributeError ("In %s:load :%s not a uid field for class %s" % (fieldname, cls.__name__))
-        else:
-            dhdl = cls.data_handler(uids)
-            if dhdl.check_data_value(uid_tuples)[1] is None:
-                query_filter.append((uids, '=', uid_tuples))
-            else:
-                raise AttributeError("n %s:load :%s not a valid value for %s" % (uid_tuples, uids))
-        query = LeGetQuery(cls, query_filter, limit = 1)
-        try:
-            result=query.execute()
-        except LeQueryError as err:
-            print("Unable to load object of type %s" % cls.__name__)
-            raise err
-        
-        return cls.name2class(res[CLASS_IDENTIFIER])(result[0])
-        
     ## @brief Get instances of LeObject
     #
     #@param target_class LeObject : class of object the query is about
@@ -590,16 +563,19 @@ raised when trying to import Datasource"
     #@return a list of items (lists of (fieldname, fieldvalue))
     @classmethod
     def get(cls, query_filters, field_list=None, order=None, group=None, limit=None, offset=0):
-        if isinstance(cls._uids, tuple):
-            for uid in cls._uids:
-                if uid not in field_list:
-                    raise AttributeError("In %s:get : Cannot instanciate a LeObject without it's identifier" % cls.__name__)
+        if field_list is None:
+            field_list = cls.fieldnames(True)
         else:
-            if uid not in field_list:
-                raise AttributeError("In %s:get : Cannot instanciate a LeObject without it's identifier" % cls.__name__)
-
+            for uid in [ uidname
+                for uidname in cls.uid_fieldname()
+                if uidname not in field_list ]:
+                field_list.append(uid)
+            if CLASS_ID_FIELDNAME not in field_list:
+                field_list.append(CLASS_ID_FIELDNAME)
         try:
-            query = LeGetQuery(cls, query_filter, field_list = field_list, order = order, group = group, limit = limit, offset = offset)
+            query = LeGetQuery(
+                cls, query_filters = query_filters, field_list = field_list,
+                order = order, group = group, limit = limit, offset = offset)
         except ValueError as err:
             raise err
             
@@ -610,7 +586,8 @@ raised when trying to import Datasource"
         
         objects = list()
         for res in result:
-            inst = cls.name2class(res[CLASS_ID_FIELDNAME])(res)
+            res_cls = cls.name2class(res[CLASS_ID_FIELDNAME])
+            inst = res_cls.__new__(res_cls,**res)
             objects.append(inst)
         
         return objects

lodel/leapi/query.py

@@ -3,6 +3,7 @@
 import re
 import copy
 import inspect
+import warnings
 
 from .exceptions import *
 from lodel.plugin.hooks import LodelHook
@@ -35,18 +36,18 @@ class LeQuery(object):
     # @return the query result
     # @see LeQuery._query()
     #
-    def execute(self, **datas):
+    def execute(self, datas):
         if not datas is None:
             self._target_class.check_datas_value(
-                                                    datas['datas'],
+                                                    datas,
                                                     **self._data_check_args)
-            self._target_class.prepare_datas(datas['datas']) #not yet implemented
+            self._target_class.prepare_datas(datas) #not yet implemented
         if self._hook_prefix is None:
             raise NotImplementedError("Abstract method")
         LodelHook.call_hook(    self._hook_prefix+'_pre',
                                 self._target_class,
                                 datas)
-        ret = self._query(**datas)
+        ret = self._query(datas = datas)
         ret = LodelHook.call_hook(  self._hook_prefix+'_post',
                                     self._target_class,
                                     ret)
@@ -119,7 +120,6 @@ class LeFilteredQuery(LeQuery):
         try:
 
             filters, rel_filters = self._query_filter
-            #res = super().execute(filters = filters, rel_filters = rel_filters)
             res = super().execute(datas)
         except Exception as e:
             #restoring filters even if an exception is raised
@@ -199,7 +199,7 @@ class LeFilteredQuery(LeQuery):
                 for tclass, tfield in ref_dict.items():
                     query = LeGetQuery(
                         target_class = tclass,
-                        query_filter = [(tfield, op, value)],
+                        query_filters = [(tfield, op, value)],
                         field_list = [tfield])
                     subq.append((rfield, query))
         self.subqueries = subq
@@ -213,7 +213,7 @@ class LeFilteredQuery(LeQuery):
 
     def __repr__(self):
         res = "<{classname} target={target_class} query_filter={query_filter}"
-        res = ret.format(
+        res = res.format(
             classname=self.__class__.__name__,
             query_filter = self._query_filter,
             target_class = self._target_class)
@@ -465,8 +465,8 @@ class LeInsertQuery(LeQuery):
     def _query(self, datas):
         datas = self._target_class.prepare_datas(datas, True, False)
         nb_inserted = self._rw_datasource.insert(self._target_class,datas)
-        if nb_inserted < 0:
-            raise LeQueryError("Insertion error")
+        if nb_inserted <= 0:
+            raise LeApiQueryError("Insertion error")
         return nb_inserted
     """
     ## @brief Implements an insert query operation, with multiple insertions
@@ -475,7 +475,7 @@ class LeInsertQuery(LeQuery):
         nb_inserted = self._datasource.insert_multi(
             self._target_class,datas_list)
         if nb_inserted < 0:
-            raise LeQueryError("Multiple insertions error")
+            raise LeApiQueryError("Multiple insertions error")
         return nb_inserted
     """
 
@@ -571,14 +571,15 @@ class LeDeleteQuery(LeFilteredQuery):
         super().__init__(target_class, query_filter)
 
     ## @brief Execute the delete query
-    def execute(self):
+    def execute(self, datas = None):
         return super().execute()
     
     ##@brief Implements delete query operations
     #@param filters list : see @ref LeFilteredQuery
     #@param rel_filters list : see @ref LeFilteredQuery
     #@returns the number of deleted items
-    def _query(self, filters, rel_filters):
+    def _query(self, datas = None):
+        filters, rel_filters = self._query_filter
         nb_deleted = self._rw_datasource.delete(
             self._target_class, filters, rel_filters)
         return nb_deleted
@@ -597,8 +598,8 @@ class LeGetQuery(LeFilteredQuery):
     #@param group list : A list of field names or tuple (FIELDNAME,[ASC | DESC])
     #@param limit int : The maximum number of returned results
     #@param offset int : offset
-    def __init__(self, target_class, query_filter, **kwargs):
-        super().__init__(target_class, query_filter)
+    def __init__(self, target_class, query_filters, **kwargs):
+        super().__init__(target_class, query_filters)
         
         ##@brief The fields to get
         self.__field_list = None
@@ -630,7 +631,7 @@ class LeGetQuery(LeFilteredQuery):
             self.__group = kwargs['group']
         if 'limit' in kwargs:
             try:
-                self.__limit = int(kwargs[limit])
+                self.__limit = int(kwargs['limit'])
                 if self.__limit <= 0:
                     raise ValueError()
             except ValueError:
@@ -648,7 +649,7 @@ class LeGetQuery(LeFilteredQuery):
     ##@brief Set the field list
     # @param field_list list | None : If None use all fields
     # @return None
-    # @throw LeQueryError if unknown field given
+    # @throw LeApiQueryError if unknown field given
     def set_field_list(self, field_list):
         err_l = dict()
         for fieldname in field_list:
@@ -664,7 +665,7 @@ class LeGetQuery(LeFilteredQuery):
         self.__field_list = list(set(field_list))
     
     ##@brief Execute the get query
-    def execute(self):
+    def execute(self, datas = None):
         return super().execute()
 
     ##@brief Implements select query operations

lodel/settings/validator.py

@@ -308,6 +308,8 @@ LODEL2_CONF_SPECS = {
                         SettingValidator('strip')),
         'lib_path': (   None,
                         SettingValidator('path')),
+        'runtest': (    False,
+                        SettingValidator('bool')),
     },
     'lodel2.logging.*' : {
         'level': (  'ERROR',

plugins/dummy_datasource/datasource.py

@@ -27,7 +27,7 @@ class DummyDatasource(object):
     #@param relational_filters list : List of relational filters
     #@return int : number of deleted records
     def delete(self, target, filters, relational_filters):
-        pass
+        return 0
 
     ## @brief updates records according to given filters
     #@param target Emclass : class of the object to insert
@@ -36,18 +36,18 @@ class DummyDatasource(object):
     #@param upd_datas dict : datas to update (new values)
     #@return int : Number of updated records
     def update(self, target, filters, relational_filters, upd_datas):
-        pass
+        return 0
 
     ## @brief Inserts a record in a given collection
     # @param target Emclass : class of the object to insert
     # @param new_datas dict : datas to insert
     # @return the inserted uid
     def insert(self, target, new_datas):
-        pass
+        return 0
 
     ## @brief Inserts a list of records in a given collection
     # @param target Emclass : class of the objects inserted
     # @param datas_list list : list of dict
     # @return list : list of the inserted records' ids
     def insert_multi(self, target, datas_list):
-        pass
+        return 0

plugins/mongodb_datasource/datasource.py

@@ -2,16 +2,15 @@
 
 import re
 import warnings
-import bson
 from bson.son import SON
 from collections import OrderedDict
 import pymongo
 from pymongo.errors import BulkWriteError
-import urllib
 
 from lodel import logger
 
-from .utils import object_collection_name, connect, \
+from . import utils
+from .utils import object_collection_name,\
     MONGODB_SORT_OPERATORS_MAP, connection_string
 
 class MongoDbDataSourceError(Exception):
@@ -51,8 +50,9 @@ class MongoDbDatasource(object):
         self.__read_only = bool(read_only)
         ##@brief Uniq ID for mongodb connection
         self.__conn_hash= None
-        ##@brief Stores the connection to MongoDB
-        self.database = self.__connect(username, password)
+        ##@brief Stores the database cursor
+        self.database = self.__connect(
+            username, password, ro = self.__read_only)
 
     ##@brief Destructor that attempt to close connection to DB
     #
@@ -64,6 +64,7 @@ class MongoDbDatasource(object):
         if self._connections[self.__conn_hash]['conn_count'] <= 0:
             self._connections[self.__conn_hash]['db'].close()
             del(self._connections[self.__conn_hash])
+            logger.info("Closing connection to database")
 
     ##@brief returns a selection of documents from the datasource
     #@param target Emclass
@@ -176,12 +177,26 @@ class MongoDbDatasource(object):
     #@param ro bool : If True the Datasource is for read only, else the
     def __connect(self, username, password, ro):
         conn_string = connection_string(
-            username = username, password = password, **self.__db_infos)
-        conn_string += "__ReadOnly__:"+self.__read_only
-        self.__conf_hash = conn_h = hash(conn_string)
+            username = username, password = password,
+            host = self.__db_infos['host'],
+            port = self.__db_infos['port'])
+
+        conn_string += "__ReadOnly__:"+str(self.__read_only)
+        self.__conn_hash = conn_h = hash(conn_string)
         if conn_h in self._connections:
             self._connections[conn_h]['conn_count'] += 1
-            return self._connections[conn_h]['db']
+            return self._connections[conn_h]['db'][self.__db_infos['db_name']]
+        else:
+            logger.info("Opening a new connection to database")
+            self._connections[conn_h] = {
+                'conn_count': 1,
+                'db': utils.connection(
+                    host = self.__db_infos['host'],
+                    port = self.__db_infos['port'],
+                    username = username, 
+                    password = password)}
+            return self._connections[conn_h]['db'][self.__db_infos['db_name']]
+                    
 
     ##@brief Return a pymongo collection given a LeObject child class
     #@param leobject LeObject child class (no instance)

plugins/mongodb_datasource/migration_handler.py

@@ -2,7 +2,7 @@
 import datetime
 
 from lodel.editorial_model.components import EmClass, EmField
-
+from lodel.editorial_model.model import EditorialModel
 from .utils import get_connection_args, connect, collection_prefix, object_collection_name, mongo_fieldname
 from lodel.leapi.datahandlers.base_classes import DataHandler
 from lodel.plugin import LodelHook
@@ -16,7 +16,7 @@ class MigrationHandlerError(Exception):
     pass
 
 @LodelHook('mongodb_mh_init_db')
-def mongodb_mh_init_db(conn_args=None):
+def mongodb_mh_init_db(editorial_model, conn_args=None):
     connection_args = get_connection_args('default') if conn_args is None else get_connection_args(conn_args['name'])
     migration_handler = MongoDbMigrationHandler(connection_args)
     migration_handler._install_collections()
@@ -26,13 +26,15 @@ class MongoDbMigrationHandler(object):
 
     COMMANDS_IFEXISTS_DROP = 'drop'
     COMMANDS_IFEXISTS_NOTHING = 'nothing'
-    INIT_COLLECTIONS_NAMES = ['object', 'relation', 'entitie', 'person', 'text', 'entry']
+    #INIT_COLLECTIONS_NAMES = ['object', 'relation', 'entitie', 'person', 'text', 'entry']
     MIGRATION_HANDLER_DEFAULT_SETTINGS = {'dry_run': False, 'foreign_keys': True, 'drop_if_exists': False}
 
     ## @brief Constructs a MongoDbMigrationHandler
     # @param conn_args dict : a dictionary containing the connection options
     # @param **kwargs : extra arguments
-    def __init__(self, conn_args=None, **kwargs):
+    def __init__(self, editorial_model, conn_args=None, **kwargs):
+        self.editorial_model = editorial_model
+
         conn_args = get_connection_args() if conn_args is None else conn_args
 
         if len(conn_args.keys()) == 0:
@@ -55,11 +57,21 @@ class MongoDbMigrationHandler(object):
         self.drop_if_exists = kwargs['drop_if_exists'] if 'drop_is_exists' in kwargs else \
             MongoDbMigrationHandler.MIGRATION_HANDLER_DEFAULT_SETTINGS['drop_if_exists']
 
+        self.init_collections_names = self._set_init_collection_names()
         #self._install_collections()
 
+    def _set_init_collection_names(self):
+        collection_names = []
+        init_collections = self.editorial_model.all_classes()
+        for init_collection in init_collections.items():
+            if init_collection.abstract:
+                collection_names.append(init_collection.uid)
+        return collection_names
+
     ## @brief Installs the basis collections of the database
     def _install_collections(self):
-        for collection_name in MongoDbMigrationHandler.INIT_COLLECTIONS_NAMES:
+        init_collection_names = self.init_collections_names
+        for collection_name in init_collection_names:
             prefix = collection_prefix['object'] if collection_name != 'relation' else collection_prefix['relation']
             collection_to_create = "%s%s" % (prefix, collection_name)
             self._create_collection(collection_name=collection_to_create)
@@ -110,7 +122,7 @@ class MongoDbMigrationHandler(object):
             component_class_name = 'emfield'
 
         if component_class_name:
-            handler_func('_'+component_class_name.lower()+'_'+state_change)
+            handler_func = '_'+component_class_name.lower()+'_'+state_change
             if hasattr(self, handler_func):
                 getattr(self, handler_func)(model, uid, initial_state, new_state)
         else:
@@ -129,7 +141,7 @@ class MongoDbMigrationHandler(object):
     ## @brief deletes a collection corresponding to a given uid
     # @see register_change()
     def _emclass_delete(self, model, uid, initial_state, new_state):
-        if uid not in MongoDbMigrationHandler.INIT_COLLECTIONS_NAMES:
+        if uid not in self.init_collections_names:
             collection_name = object_collection_name(model.classes(uid))
             self._delete_collection(collection_name)
 

plugins/mongodb_datasource/utils.py

@@ -41,23 +41,36 @@ def get_connection_args(connnection_name='default'):
     return {'host': 'localhost', 'port': 28015, 'login': 'lodel_admin', 'password': 'lapwd', 'dbname': 'lodel'}
 
 
-## @brief Creates a connection to a MongoDb Database
-# @param connection_name str
-# @return MongoClient
-'''def mongodbconnect(connection_name):
-    login, password, host, port, dbname = get_connection_args(connection_name)
-    return connect(host, port, dbname, login, password)
-'''
-
-
-def connection_string(host, port, db_name, username, password):
-    return 'mongodb://%s:%s@%s:%s' % (username, password, host, port)
-
-
+def connection_string(host, port, username, password):
+    ret = 'mongodb://'
+    if username != None:
+        ret += username
+        if password != None:
+            ret += ':'+password
+        ret+='@'
+    elif password != None:
+        raise RuntimeError("Password given but no username given...")
+    host = 'localhost' if host is None else host
+    ret += host
+    if port != None:
+        ret += ':'+str(port)
+    return ret
+
+##@brief Return an instanciated MongoClient
+#@param host str : hostname or ip
+#@param port int : port
+#@param username str | None: username
+#@param password str|None : password
 def connection(host, port, username, password):
-    return MongoClient(connection_string(host, port, '', username, password))
-
-
+    conn_str = connection_string(host, port, username, password)
+    return MongoClient(conn_str)
+
+##@brief Return a database cursor
+#@param host str : hostname or ip
+#@param port int : port
+#@param db_name str : database name
+#@param username str | None: username
+#@param password str|None : password
 def connect(host, port, db_name, username, password):
     conn = connection(host, port, username, password)
     database = conn[db_name]

plugins/webui/__init__.py

@@ -1,22 +1,2 @@
-from lodel.settings.validator import SettingValidator
-
 __loader__ = 'main.py'
-
-CONFSPEC = {
-    'lodel2.webui': {
-        'standalone': ( False,
-                        SettingValidator('bool')),
-        'listen_address': ( '127.0.0.1',
-                            SettingValidator('dummy')),
-        'listen_port': (    '9090',
-                            SettingValidator('int')),
-    },
-    'lodel2.webui.sessions': {
-        'directory': (  '/tmp/lodel2_session',
-                        SettingValidator('path')),
-        'expiration': ( 900,
-                        SettingValidator('int')),
-        'file_template': (  'lodel2_%s.sess',
-                            SettingValidator('dummy')),
-    }
-}
+__confspec__ = 'confspec.py'

plugins/webui/confspec.py

@@ -0,0 +1,20 @@
+from lodel.settings.validator import SettingValidator
+
+CONFSPEC = {
+    'lodel2.webui': {
+        'standalone': ( False,
+                        SettingValidator('bool')),
+        'listen_address': ( '127.0.0.1',
+                            SettingValidator('dummy')),
+        'listen_port': (    '9090',
+                            SettingValidator('int')),
+    },
+    'lodel2.webui.sessions': {
+        'directory': (  '/tmp/lodel2_session',
+                        SettingValidator('path')),
+        'expiration': ( 900,
+                        SettingValidator('int')),
+        'file_template': (  'lodel2_%s.sess',
+                            SettingValidator('dummy')),
+    }
+}

plugins/webui/interface/controllers.py

@@ -1,26 +1,35 @@
 # -*- coding: utf-8 -*-
-import os.path
 
 from werkzeug.wrappers import Response
 from .template.loader import TemplateLoader
 
 # This module contains the web UI controllers that will be called from the web ui class
 
-def get_response(tpl, mimetype = 'text/html', status_code = 200):
+
+def get_response(tpl, mimetype='text/html', status_code=200):
     loader = TemplateLoader()
-    response = Response(    loader.render_to_response(tpl),
-                            mimetype = 'text/html')
+    response = Response(loader.render_to_response(tpl), mimetype=mimetype)
     response.status_code = status_code
     return response
 
+
 def admin(request):
     return get_response('admin/admin.html')
 
+
 def index(request):
     return get_response('index/index.html')
 
+
 def not_found(request):
-    return get_response('errors/404.html', status_code = 404)
+    return get_response('errors/404.html', status_code=404)
+
 
 def test(request):
     return get_response('test.html')
+
+
+def list_classes(request):
+    # TODO Add the method to get the classes list
+
+    return get_response('list_classes.html')

plugins/webui/interface/router.py

@@ -3,12 +3,26 @@ import re
 
 from .controllers import *
 from .urls import urls
+from lodel.settings import Settings
+
+
+def format_url_rule(url_rule):
+    if url_rule == '^$':
+        return "^%s$" % Settings.sitename
+
+    formatted_rule = ''
+    if url_rule.startswith('^'):
+        formatted_rule += "^"
+
+    formatted_rule += "%s/%s" % (Settings.sitename, url_rule)
+    return formatted_rule
 
 
 def get_controller(request):
+
     url_rules = []
     for url in urls:
-        url_rules.append((url[0], url[1]))
+        url_rules.append((format_url_rule(url[0]), url[1]))
 
     # Returning the right controller to call
     for regex, callback in url_rules:

plugins/webui/templates/errors/404.html

@@ -1,5 +1,5 @@
-{% extends "templates/base.html" %}
+{% extends "base.html" %}
 {% block title %}Error 404{% endblock %}
 {% block content %}
-    <h1>404 - File Not Found</h1>
+    <h3>404 - File Not Found</h3>
 {% endblock %}

runtest

@@ -53,6 +53,8 @@ cp -R examples $testdir
 cp -R tests $testdir
 cd $testdir
 rm -R conf.d && mv tests/tests_conf.d conf.d
-python3 -W ignore -m unittest $@
+make
+#python3 -W ignore -m unittest $@
+python3 loader.py $@
 
 rm -Rf $testdir

tests/__init__.py

@@ -1,4 +0,0 @@
-try:
-    import loader
-except ImportError:
-    print("This tests are designed to be runned with the runtest utility")

tests/leapi/test_leobject.py

@@ -3,7 +3,7 @@ from unittest import mock
 from unittest.mock import patch
 
 import tests.loader_utils
-from tests.leapi.query.utils import dyncode_module as dyncode
+import leapi_dyncode as dyncode
 
 from lodel.leapi.leobject import LeObject
 from lodel.leapi.query import LeDeleteQuery, LeUpdateQuery, LeGetQuery, \
@@ -88,10 +88,6 @@ but invalid name %s was given" % badname):
         self.assertEqual(set(fnames),
             {'lastname', 'linked_texts', 'firstname', 'alias'})
 
-    def test_insert(self):
-        """ Testing insert method """
-        dyncode.Person.insert({'lastname': 'foo', 'firstname': 'bar'})
-    
     def test_bad_insert(self):
         """ Insert with bad arguments """
         badargs = [
@@ -154,8 +150,7 @@ class LeObjectQueryMockTestCase(unittest.TestCase):
                 lodel_id = 1, firstname = "foo", lastname = "bar")
             ret = inst.delete()
             self.assertEqual(ret, 1, 'Bad return value forwarding')
-            mock_execute.assert_called_once_with(
-                dyncode.Person, [('lodel_id', '=', 1)], [])
+            mock_execute.assert_called_once_with()
 
     def test_delete_bundle(self):
         """ Checking that LeObject delete_bundle method calls LeDeleteQuery
@@ -171,9 +166,80 @@ class LeObjectQueryMockTestCase(unittest.TestCase):
                 dyncode.Person, ['lodel_id > 1'])
 
         with patch.object(
-            LeDeleteQuery, 'execute', return_value = None) as mock_execute:
+            LeDeleteQuery, 'execute', return_value = 1) as mock_execute:
             
             dyncode.Person.delete_bundle(['lodel_id > 1'])
-            mock_init.assert_called_once_with(
-                dyncode.Person, [('lodel_id', '>', 1)], [])
+            mock_execute.assert_called_once_with()
 
+    def test_update_instance(self):
+        """ Checking that LeObject update method calls LeUpdateQuery
+            correctly """
+        with patch.object(
+            LeUpdateQuery, '__init__', return_value = None) as mock_init:
+            with patch.object(
+                LeObject, 'datas', return_value = {
+                    'lodel_id': 1, 'firstname': 'foo', 'lastname': 'bar',
+                    'fullname': 'Foo Bar', 'alias': None }) as mock_datas:
+            
+                inst = dyncode.Person(
+                    lodel_id = 1, firstname = "foo", lastname = "bar")
+                try:
+                   inst.update()
+                except AttributeError:
+                    pass
+                mock_init.assert_called_once_with(
+                    dyncode.Person, [('lodel_id', '=', 1)])
+        
+        with patch.object(
+            LeUpdateQuery, 'execute', return_value = None) as mock_update:
+            with patch.object(
+                LeObject, 'datas', return_value = {
+                    'lodel_id': 1, 'firstname': 'foo', 'lastname': 'bar',
+                    'fullname': 'Foo Bar', 'alias': None }) as mock_datas:
+            
+                inst = dyncode.Person(
+                    lodel_id = 1, firstname = "foo", lastname = "bar")
+                inst.update()
+                mock_update.assert_called_once_with({
+                    'lodel_id': 1, 'firstname': 'foo', 'lastname': 'bar',
+                    'fullname': 'Foo Bar', 'alias': None })
+                    
+    
+    def test_get(self):
+        """ Checking that LeObject.get method calls LeGetQuery
+            correctly """
+        get_args = {
+            'query_filters': ['lodel_id = 1'],
+            'field_list': ['firstname'],
+            'order': ['firstname'],
+            'group': ['alias'],
+            'limit': 42,
+            'offset': 24}
+
+        with patch.object(
+            LeGetQuery, '__init__', return_value = None) as mock_init:
+            
+            try:
+                dyncode.Person.get(**get_args)
+            except AttributeError:
+                pass
+
+            mock_init.assert_called_once_with(
+                dyncode.Person,
+                **get_args)
+
+        ret_val = [{
+            'lodel_id': 1,
+            'firstname': 'foo',
+            'lastname': 'bar',
+            'fullname': 'foo bar',
+            'alias': None,
+            'classname': 'Person'}]
+        with patch.object(
+            LeGetQuery, 'execute', return_value = ret_val) as mock_execute:
+            results = dyncode.Person.get(**get_args)
+            mock_execute.assert_called_once_with()
+            res = results[0]
+            self.assertEqual(res.d.lodel_id, 1)
+            self.assertEqual(res.d.firstname, 'foo')
+            self.assertEqual(res.d.lastname, 'bar')

tests/tests_conf.d/lodel2.ini

@@ -3,6 +3,7 @@ debug = False
 sitename = noname
 plugins_path = /foo/plugins
 plugins = dummy, dummy_datasource
+runtest=True
 
 [lodel2.logging.stderr]
 level = Error