Write some test for LeRelation + __eq__ for LeObject + import bugfix in LeRelation

The test are skipped and can be unskipped as soon as LeRelation._prepare_filters() is implemented

leapi/leobject.py

@@ -51,11 +51,16 @@ class _LeObject(_LeCrud):
     
     ## @brief Dirty & quick comparison implementation
     def __cmp__(self, other):
+        return 0 if self == other else 1
+    ## @brief Dirty & quick equality implementation
+    # @todo check class
+    def __eq__(self, other):
         uid_fname = self.uidname()
         if not hasattr(other, uid_fname):
             return False
         return getattr(self, uid_fname) == getattr(other, uid_fname)
         
+        
     ## @brief Quick str cast method implementation
     def __str__(self):
         return "<%s lodel_id=%d>"%(self.__class__, getattr(self, self.uidname()))

leapi/lerelation.py

@@ -4,6 +4,7 @@ import copy
 
 import EditorialModel.fieldtypes.leo as ft_leo
 from . import lecrud
+from . import leobject
 
 ## @brief Main class for relations
 class _LeRelation(lecrud._LeCrud):
@@ -22,12 +23,12 @@ class _LeRelation(lecrud._LeCrud):
  
     @classmethod
     def sup_filter(self, leo):
-        if isinstance(leo, _LeObject):
+        if isinstance(leo, leobject._LeObject):
             return ('lesup', '=', leo)
 
     @classmethod
     def sub_filter(self, leo):
-        if isinstance(leo, _LeObject):
+        if isinstance(leo, leobject._LeObject):
             return ('lesub', '=', leo)
 
 

leapi/test/test_lerelation.py

@@ -0,0 +1,118 @@
+"""
+    Tests for _LeRelation object family
+"""
+
+import unittest
+from unittest import TestCase
+from unittest.mock import patch
+
+import EditorialModel
+import leapi
+import leapi.test.utils
+from leapi.lecrud import _LeCrud
+
+class LeRelationTestCase(TestCase):
+    @classmethod
+    def setUpClass(cls):
+        """ Write the generated code in a temporary directory and import it """
+        cls.tmpdir = leapi.test.utils.tmp_load_factory_code()
+    @classmethod
+    def tearDownClass(cls):
+        """ Remove the temporary directory created at class setup """
+        leapi.test.utils.cleanup(cls.tmpdir)
+    
+    @unittest.skip("Wating LeRelation._prepare_filters() to unskip")
+    def test_prepare_filters(self):
+        """ Testing the _prepare_filters() method """
+        from dyncode import Numero, LeObject, LeRelation
+        
+        filters = [
+            (
+                'rank = 1',
+                ('rank', '=', '1')
+            ),
+            (
+                'nature = "parent"',
+                ('nature', '=', '"parent"')
+            ),
+            (
+                'lesup = 21',
+                ('lesup', '=', LeObject(21))
+            ),
+            (
+                'lesub = 22',
+                ('lesub', '=', LeObject(22))
+            ),
+            (
+                ('rank', '=', '1'),
+                ('rank', '=', '1'),
+            ),
+            (
+                ('lesup', '=', LeObject(21)),
+                ('lesup', '=', LeObject(21)),
+            ),
+            (
+                ('lesub', '=', Numero(42)),
+                ('lesub', '=', Numero(42)),
+            ),
+        ]
+        
+        for filter_arg, filter_res in filters:
+            res, rel_res = LeRelation._prepare_filters([filter_arg])
+            self.assertEqual(len(res), 1)
+            self.assertEqual(len(rel_res), 0)
+            res = res[0]
+            
+            for i in range(3):
+               self.assertEqual(filter_res[i], res[i], "%s != %s"%(filter_res, res))
+
+
+class LeHierarch(LeRelationTestCase):
+    
+    @unittest.skip("Wait for  LeRelation._prepare_filters() to unskip")
+    @patch('leapi.datasources.dummy.DummyDatasource.select')
+    def test_get(self, dsmock):
+        from dyncode import LeCrud, Publication, Numero, Personnes, LeObject, Rubrique, LeHierarch, LeRelation
+
+        queries = [
+            (
+                ['lesup = 42', 'lesub = 24'], #filters
+                ['lesup', 'lesub', 'nature', 'rank'], #field_l
+
+                LeHierarch, #target
+                ['lesup', 'lesub', 'nature', 'rank'], #field_ds
+                [('lesup','=',LeObject(42)), ('lesub', '=', LeObject(24))], #filters_ds
+                [], #rfilters_ds
+
+            ),
+            (
+                [ LeRelation.sup_filter(Numero(42)) ],
+                [],
+
+                LeHierarch,
+                [ 'nature', 'rank', 'lesub', 'depth', 'lesup'],
+                [('lesup', '=', Numero(42))],
+                [],
+            ),
+        ]
+
+        for filters, field_l, target, field_ds, filters_ds, rfilters_ds in queries:
+            eargs = (filters, field_l, target, field_ds, filters_ds, rfilters_ds)
+
+            LeHierarch.get(filters, field_l)
+            cargs = dsmock.call_args
+
+            self.assertEqual(len(cargs), 2)
+            cargs=cargs[0]
+
+            self.assertEqual(cargs[0], target, "%s != %s"%(cargs, eargs))
+            self.assertEqual(set(cargs[1]), set(field_ds), "%s != %s"%(cargs, eargs))
+            self.assertEqual(cargs[2], filters_ds, "%s != %s"%(cargs, eargs))
+            self.assertEqual(cargs[3], rfilters_ds, "%s != %s"%(cargs, eargs))
+
+            dsmock.reset_mock()
+        
+
+class LeRel2TypeTestCase(LeRelationTestCase):
+    pass
+