First test on multi datasource queries + em_test update + query.py debug

- Modified again the em_test to fit with testing purpose
- First test on multi datasource query written
- debugging of query.py

em_test.py

@@ -321,49 +321,21 @@ index_value = index_abstract.new_field(
         'fre': 'valeur'},
     data_handler = 'varchar')
 
-index_text = em.new_class(
-    'indextext',
-    display_name = {
-        'eng': 'Index Text',
-        'fre': 'Index Texte'},
-    help_text = {
-        'eng': 'Represent a link between a text and an index',
-        'fre': 'Represente le lien entre une entrée d\'index et un texte'},
-    parents = None,
-    abstract = False,
-    datasource = 'default')
-
-bref_indextext_text = index_text.new_field(
-    'text',
-    display_name = {
-        'eng': 'Text with this index',
-        'fre': 'Texte comportant cet index'},
-    data_handler = 'link',
-    allowed_classes = [text],
-    group = index_group)
-
-bref_indextext_index = index_text.new_field(
-    'index',
-    display_name = {
-        'eng': 'Index within the referencend text',
-        'fre': 'Reference vers l\'index concerné'},
-    data_handler = 'link',
-    allowed_classes = [index_abstract],
-    group = index_group)
-
 text.new_field( 'indexes',
     display_name = {
         'eng': 'Indexes',
         'fre': 'Indexes'},
     data_handler = 'list',
-    back_reference = ('Indextext', 'text'))
+    back_reference = ('Indexabs', 'texts'),
+    allowed_classes = [index_abstract])
 
 index_abstract.new_field( 'texts',
     display_name = {
         'eng': 'Text referenced by this index',
         'fre': 'Texte contenant cette index'},
     data_handler = 'list',
-    back_reference = ('Indextext', 'index'))
+    back_reference = ('Text', 'indexes'),
+    allowed_classes = [text])
 
 index_theme = em.new_class(
     'indexTheme',

lodel/leapi/datahandlers/base_classes.py

@@ -190,7 +190,7 @@ class Reference(DataHandler):
     # @param internal bool : if False, the field is not internal
     # @param **kwargs : other arguments
     def __init__(self, allowed_classes = None, back_reference = None, internal=False, **kwargs):
-        self.__allowed_classes = None if allowed_classes is None else set(allowed_classes)
+        self.__allowed_classes = [] if allowed_classes is None else set(allowed_classes)
         if back_reference is not None:
             if len(back_reference) != 2:
                 raise ValueError("A tuple (classname, fieldname) expected but got '%s'" % back_reference)

lodel/leapi/leobject.py

@@ -153,7 +153,7 @@ class LeObject(object):
         if not fieldname in cls._fields:
             raise NameError("No field named '%s' in %s" % (fieldname, cls.__name__))
         return cls._fields[fieldname]
- 
+    
     ##@brief Return a LeObject child class from a name
     # @warning This method has to be called from dynamically generated LeObjects
     # @param leobject_name str : LeObject name

lodel/leapi/query.py

@@ -212,9 +212,10 @@ class LeFilteredQuery(LeQuery):
                 for tclass, tfield in ref_dict.items():
                     query = LeGetQuery(
                         target_class = tclass,
-                        query_filter = [(rfield, op, value)],
+                        query_filter = [(tfield, op, value)],
                         field_list = [tfield])
                     subq.append((rfield, query))
+        self.subqueries = subq
     
     ##@return informations
     def dump_infos(self):
@@ -387,10 +388,10 @@ field to use for the relational filter"
     def _check_field(cls, target_class, fieldname):
         try:
             target_class.field(fieldname)
-        except NameError:
-            tc_name = target_class.__name__
-            return ValueError("No such field '%s' in %s" % (    fieldname,
-                                                                tc_name))
+        except NameError as e:
+            msg = "No field named '%s' in %s'"
+            msg %= (fieldname, target_class.__name__)
+            return NameError(msg)
 
     ##@brief Prepare a relational filter
     #
@@ -445,11 +446,13 @@ field to use for the relational filter"
                 if ref_field in ref_class.fieldnames(True):
                     ref_dict[ref_class] = ref_field
                 else:
-                    logger.debug("Warning the class %s is not considered in \
-the relational filter %s" % ref_class.__name__)
+                    msg = "Warning the class %s is not considered in \
+the relational filter %s"
+                    msg %= (ref_class.__name__, ref_field)
+                    logger.debug(msg)
         if len(ref_dict) == 0:
-            return NameError(   "No field named '%s' in referenced objects"
-                                % ref_field)
+            return NameError(   "No field named '%s' in referenced objects %s"
+                                % (ref_field, ref_class.__name__))
         return (fieldname, ref_dict)
  
 
@@ -668,8 +671,15 @@ class LeGetQuery(LeFilteredQuery):
         return ret
 
     def __repr__(self):
-        ret = "<LeGetQuery target={target_class} filter={query_filter} \
+        res = "<LeGetQuery target={target_class} filter={query_filter} \
 field_list={field_list} order={order} group={group} limit={limit} \
-offset={offset}>"
-        return ret.format(**self.dump_infos())
+offset={offset}"
+        res = res.format(**self.dump_infos())
+        if len(self.subqueries) > 0:
+            for n,subq in enumerate(self.subqueries):
+                res += "\n\tSubquerie %d : %s"
+                res %= (n, subq)
+        res += ">"
+        return res
+
 

tests/leapi/query/test_filtered.py

@@ -104,3 +104,29 @@ class LeFilteredQueryTestCase(unittest.TestCase):
             qinfos = get_q.dump_infos()
             self.assertEqual(   qinfos['query_filter'],
                                 e_qfilter)
+
+class LeFilteredQueryMultiDataHandlerTestCase(unittest.TestCase):
+    """ Testing LeFilteredQuery behavior when relational fields implies
+        different datasources """
+
+    q_classes = [LeDeleteQuery, LeUpdateQuery, LeGetQuery]
+    
+    def test_basic(self):
+        """ Testing a LeGetQuery with a relationnal field implying another
+            datasource """
+        getq = LeGetQuery(
+            dyncode.Indextheme,
+            "texts.title = super titre !")
+        qinfos = getq.dump_infos()
+        # The single query filter should be in subquery
+        self.assertEqual(qinfos['query_filter'], ([],[]))
+        self.assertEqual(len(qinfos['subqueries']), 1)
+        rfield, subq = qinfos['subqueries'][0]
+        # Checking subquery
+        self.assertEqual(rfield, 'texts') # The reference field of the subquery
+        qinfos = subq.dump_infos()
+        self.assertEqual(qinfos['target_class'], dyncode.Text)
+        self.assertEqual(
+            qinfos['query_filter'],
+            ([('title', '=', 'super titre !')],[])) 
+        self.assertEqual(qinfos['field_list'], ['title'])

tests/tests_conf.d/lodel2.ini

@@ -10,7 +10,7 @@ filename = -
 context = False
 
 [lodel2.editorialmodel]
-groups = 
+groups = index_group
 emfile = examples/em_test.pickle
 dyncode = leapi_dyncode.py
 editormode = True