Fixing tests and other classes to fit recent changes

DataSource/MySQL/migrationhandler.py

@@ -366,6 +366,7 @@ PRIMARY KEY({pk_name})
     # @param table_name str : The table name
     # @param col_name str : The columns name
     # @param col_fieldtype EmFieldype the fieldtype
+    # @return True if the column was added else return False
     def _add_column(self, table_name, col_name, col_fieldtype, drop_if_exists=False):
 
         col_name = utils.column_name(col_name)
@@ -391,6 +392,8 @@ ADD COLUMN {col_name} {col_type} {col_specs};"""
             else:
                 #LOG
                 print("Aborded, column `%s` exists" % col_name)
+                return False
+        return True
 
     ## @brief Add a foreign key
     # @param src_table_name str : The name of the table where we will add the FK
@@ -406,7 +409,7 @@ ADD COLUMN {col_name} {col_type} {col_specs};"""
         if fk_name is None:
             fk_name = utils.get_fk_name(src_table_name, dst_table_name)
 
-        self._del_fk(src_table_name, dst_table_name)
+        self._del_fk(src_table_name, dst_table_name, fk_name)
 
         self._query("""ALTER TABLE {src_table}
 ADD CONSTRAINT {fk_name}
@@ -422,12 +425,14 @@ FOREIGN KEY ({src_col}) references {dst_table}({dst_col});""".format(
     # @param src_table_name str : The name of the table where the FK is
     # @param dst_table_name str : The name of the table the FK point on
     # @warning fails silently
-    def _del_fk(self, src_table_name, dst_table_name):
+    def _del_fk(self, src_table_name, dst_table_name, fk_name = None):
+        if fk_name is None:
+            fk_name = utils.escape_idname(utils.get_fk_name(src_table_name, dst_table_name))
         try:
             self._query("""ALTER TABLE {src_table}
 DROP FOREIGN KEY {fk_name}""".format(
                 src_table=utils.escape_idname(src_table_name),
-                fk_name=utils.escape_idname(utils.get_fk_name(src_table_name, dst_table_name))
+                fk_name=fk_name
             ))
         except self._dbmodule.err.InternalError:
             # If the FK don't exists we do not care

DataSource/MySQL/test/test_datasource.py

@@ -17,10 +17,10 @@ import pymysql
 
 import leapi.test.utils #Code generation functions
 
-import Lodel.settings
+from Lodel.settings import Settings
 import DataSource.MySQL
 from DataSource.MySQL.leapidatasource import LeDataSourceSQL as DataSource
-from DataSource.MySQL.common_utils import MySQL as db_utils
+import DataSource.MySQL.utils as db_utils
 from EditorialModel.classtypes import common_fields, relations_common_fields
 
 class DataSourceTestCase(TestCase):
@@ -39,7 +39,7 @@ class DataSourceTestCase(TestCase):
         with patch.object(mosql.db.Database, '__init__', return_value=None) as mock_db:
             #Test __init__ without arguments
             DataSource()
-            conn_args = db_utils.connections['default']
+            conn_args = Settings.get('datasource')['default']
             db_module = conn_args['module']
             del(conn_args['module'])
             mock_db.assert_called_once_with(db_module, **conn_args)

DataSource/MySQL/utils.py

@@ -60,37 +60,6 @@ def escape_idname(idname):
         raise ValueError("Invalid name : '%s'" % idname)
     return '`%s`' % idname
 
-## @brief Given a fieldtype, returns a MySQL type specifier
-# @param emfieldType EmFieldType : A fieldtype
-# @return str
-def get_type_spec_from_fieldtype(emfieldtype):
-
-    ftype = emfieldtype.ftype
-
-    if ftype == 'char' or ftype == 'str':
-        res = "VARCHAR(%d)" % emfieldtype.max_length
-    elif ftype == 'text':
-        res = 'TEXT'
-    elif ftype == 'datetime':
-        res = "DATETIME"
-        # client side workaround for only one column with CURRENT_TIMESTAMP : giving NULL to timestamp that don't allows NULL
-        # cf. https://dev.mysql.com/doc/refman/5.0/en/timestamp-initialization.html#idm139961275230400
-        # The solution for the migration handler is to create triggers :
-        # CREATE TRIGGER trigger_name BEFORE INSERT ON `my_super_table`
-        # FOR EACH ROW SET NEW.my_date_column = NOW();
-        # and
-        # CREATE TRIGGER trigger_name BEFORE UPDATE ON
-    elif ftype == 'bool':
-        res = "BOOL"
-    elif ftype == 'int':
-        res = "INT"
-    elif ftype == 'rel2type':
-        res = "INT"
-    else:
-        raise ValueError("Unsupported fieldtype ftype : %s" % ftype)
-
-    return res
-
 ## Brief add table prefix to a column name
 # @param name string: column name to prefix
 # @param prefixes dict(prefix:list(name,))

EditorialModel/fieldtypes/leo.py

@@ -57,8 +57,8 @@ class EmFieldType(GenericFieldType):
     def check_sup_consistency(self, lec, fname, datas):
         if lec.implements_lerel2type():
             # Checking consistency for a rel2type relation
-            lesup = datas['lesup']
-            lesub = datas['lesub']
+            lesup = datas[lec._lesup_name]
+            lesub = datas[lec._lesub_name]
             if lesub.__class__ not in lesup._linked_types:
                 return FieldTypeError("Rel2type not authorized between %s and %s"%(lesup, lesub))
         pass

EditorialModel/fieldtypes/naturerelation.py

@@ -26,8 +26,8 @@ class EmFieldType(EmFieldType):
         #if not isinstance(lec, lerelation._LeRelation):
         #    return ValueError("A field naturerelation has to be in a LeRelation object, but this one is in a '%s'"%lec.__name__)
         nature = datas[fname]
-        lesup = datas['lesup']
-        lesub = datas['lesub']
+        lesup = datas[lec._lesup_name]
+        lesub = datas[lec._lesub_name]
         if nature is None:
             #if not isinstance(lec, lerelation.LeRel2Type):
             #Replace with a test from _LeCrud

leapi/lecrud.py

@@ -140,7 +140,7 @@ class _LeCrud(object):
     # @param cls Class: a Class or instanciated object
     @classmethod
     def implements_lerelation(cls):
-        return hasattr(cls, '_lesup_fieldtype')
+        return hasattr(cls, '_lesup_name')
     
     ## @return maybe Bool: True if cls implements LeRel2Type
     # @param cls Class: a Class or instanciated object
@@ -391,7 +391,7 @@ class _LeCrud(object):
         ret_field_list = list()
         for field in field_list:
             if cls._field_is_relational(field):
-                ret = cls._prepare_relational_field(field)
+                ret = cls._prepare_relational_fields(field)
             else:
                 ret = cls._check_field(field)
 
@@ -470,7 +470,7 @@ class _LeCrud(object):
         for field, operator, value in filters:
             if cls._field_is_relational(field):
                 #Checks relational fields
-                ret = cls._prepare_relational_field(field)
+                ret = cls._prepare_relational_fields(field)
                 if isinstance(ret, Exception):
                     err_l[field] = ret
                 else:
@@ -524,7 +524,7 @@ class _LeCrud(object):
     # @return True if the field is relational else False
     @staticmethod
     def _field_is_relational(field):
-        return field.startswith('superior.') or field.startswith('subordinate')
+        return field.startswith('superior.') or field.startswith('subordinate.')
 
 ## @page leobject_filters LeObject query filters
 # The LeObject API provide methods that accept filters allowing the user

leapi/leobject.py

@@ -119,7 +119,7 @@ class _LeObject(_LeCrud):
     # @param field str : a relational field
     # @return a nature
     @staticmethod
-    def _prepare_relational_field(field):
+    def _prepare_relational_fields(field):
         spl = field.split('.')
         if len(spl) != 2:
             return ValueError("The relationalfield '%s' is not valid"%field)
@@ -134,212 +134,6 @@ class _LeObject(_LeCrud):
         else:
             return ValueError("Invalid preffix for relationnal field : '%s'"%spl[0])
 
-    ## @brief Check if a LeType is a hierarchy root
-    @staticmethod
-    def ___is_root(leo):
-        if isinstance(leo, leapi.letype.LeType):
-            return False
-        elif isinstance(leo, LeRoot):
-            return True
-        raise ValueError("Invalid value for a LeType : %s"%leo)
-    
-    ## @brief Return a LeRoot instance
-    @staticmethod
-    def ___get_root():
-        return LeRoot()
-
-    ## @brief Link two leobject together using a rel2type field
-    # @param lesup LeType : LeType child class instance linked as superior
-    # @param lesub LeType : LeType child class instance linked as subordinate
-    # @param **rel_attr : Relation attributes
-    # @return True if linked without problems
-    # @throw LeObjectError if the link is not valid
-    # @throw LeObkectError if the link already exists
-    # @throw AttributeError if an non existing relation attribute is given as argument
-    # @throw ValueError if the relation attrivute value check fails
-    # 
-    # @todo Code factorisation on relation check
-    # @todo unit tests
-    @classmethod
-    def ___link_together(cls, lesup, lesub, rank = 'last', **rel_attr):
-        if lesub.__class__ not in lesup._linked_types.keys():
-            raise LeObjectError("Relation error : %s cannot be linked with %s"%(lesup.__class__.__name__, lesub.__class__.__name__))
-
-        for attr_name in rel_attr.keys():
-            if attr_name not in [ f for f,g in lesup._linked_types[lesub.__class__] ]:
-                raise AttributeError("A rel2type between a %s and a %s doesn't have an attribute %s"%(lesup.__class__.__name__, lesub.__class__.__name__))
-            if not sup._linked_types[lesub.__class__][1].check(rel_attr[attr_name]):
-                raise ValueError("Wrong value '%s' for attribute %s"%(rel_attr[attr_name], attr_name))
-
-        #Checks that attributes are uniq for this relation
-        rels_attr = [ attrs for lesup, lesub, attrs in cls.links_get(lesup) if lesup == lesup ]
-        for e_attrs in rels_attrs:
-            if rel_attr == e_attrs:
-                raise LeObjectError("Relation error : a relation with the same attributes already exists")
-
-        return cls._datasource.add_related(lesup, lesub, rank, **rel_attr)
-    
-    ## @brief Get related objects
-    # @param leo LeType(instance) : LeType child class instance
-    # @param letype LeType(class) : the wanted LeType child class (not instance) 
-    # @param leo_is_superior bool : if True leo is the superior in the relation
-    # @return A dict with LeType child class instance as key and dict {rel_attr_name:rel_attr_value, ...}
-    # @throw LeObjectError if the relation is not possible
-    # 
-    # @todo Code factorisation on relation check
-    # @todo unit tests
-    @classmethod
-    def ___linked_together(cls, leo, letype, leo_is_superior = True):
-        valid_link = letype in leo._linked_types.keys() if leo_is_superior else leo.__class__ in letype._linked_types.keys()
-
-        if not valid_link:
-            raise LeObjectError("Relation error : %s have no links with %s"%(
-                leo.__class__ if leo_is_superior else letype,
-                letype if leo_is_superior else leo.__class__
-            ))
-
-        return cls._datasource.get_related(leo, letype, leo_is_superior)
-    
-    ## @brief Fetch a relation and its attributes
-    # @param id_relation int : the relation identifier
-    # @return a tuple(lesup, lesub, dict_attr) or False if no relation exists with this id
-    # @throw Exception if the relation is not a rel2type relation
-    @classmethod
-    def ___link_get(cls, id_relation):
-        return cls._datasource.get_relation(id_relation)
-    
-    ## @brief Fetch all relations for an objects
-    # @param leo LeType : LeType child class instance
-    # @return a list of tuple (lesup, lesub, dict_attr)
-    def ___links_get(cls, leo):
-        return cls._datasource.get_relations(leo)
-    
-    ## @brief Remove a link (and attributes) between two LeObject
-    # @param id_relation int : Relation identifier
-    # @return True if a link has been deleted
-    # @throw LeObjectError if the relation is not a rel2type
-    #
-    # @todo Code factorisation on relation check
-    # @todo unit tests
-    @classmethod
-    def ___link_remove(cls, id_relation):
-        if lesub.__class__ not in lesup._linked_types.keys():
-            raise LeObjectError("Relation errorr : %s cannot be linked with %s"%(lesup.__class__.__name__, lesub.__class__.__name__))
-
-        return cls._datasource.del_related(lesup, lesub)
-    
-    ## @brief Add a hierarchy relation between two LeObject
-    # @param lesup LeType|LeRoot : LeType child class instance
-    # @param lesub LeType : LeType child class instance
-    # @param nature str : The nature of the relation @ref EditorialModel.classtypes
-    # @param rank str|int :  The relation rank. Can be 'last', 'first' or an integer
-    # @param replace_if_exists bool : if True delete the old superior and set the new one. If False and there is a superior raise an LeObjectQueryError
-    # @return The relation ID or False if fails
-    # @throw LeObjectQueryError replace_if_exists == False and there is a superior
-    @classmethod
-    def ___hierarchy_add(cls, lesup, lesub, nature, rank = 'last', replace_if_exists = False):
-        #Arguments check
-        if nature not in EditorialModel.classtypes.EmClassType.natures(lesub._classtype):
-            raise ValueError("Invalid nature '%s' for %s"%(nature, lesup.__class__.__name__))
-
-        if not cls.leo_is_root(lesup):
-            if nature not in EditorialModel.classtypes.EmClassType.natures(lesup._classtype):
-                raise ValueError("Invalid nature '%s' for %s"%(nature, lesup.__class__.__name__))
-            if lesup.__class__ not in lesub._superiors[nature]:
-                raise ValueError("%s is not a valid superior for %s"%(lesup.__class__, lesub.__class__))
-        #else:
-        #   lesup is not a LeType but a hierarchy root
-
-        if rank not in ['first', 'last'] and not isinstance(rank, int):
-            raise ValueError("Allowed values for rank are integers and 'first' or 'last' but '%s' found"%rank)
-
-        superiors = cls.hierarchy_get(lesub, nature, leo_is_sup = False)
-        if lesup in len(superiors) > 0:
-            if not replace_if_exists:
-                raise LeObjectQueryError("The subordinate allready has a superior")
-            #remove existig superior
-            if not cls.hierarchy_del(superiors[0], lesub, nature):
-                raise RuntimeError("Unable to delete the previous superior")
-
-        return self._datasource.add_superior(lesup, lesub, nature, rank)
-    
-    ## @brief Delete a hierarchy link between two LeObject
-    # @param lesup LeType | LeRoot : LeType child class or hierarchy root
-    # @param lesub LeType : LeType child class
-    # @param nature str : The nature of the relation @ref EditorialModel.classtypes
-    # @return True if deletion done successfully
-    # @throw ValueError when bad arguments given
-    @classmethod
-    def ___hierarchy_del(cls, lesup, lesub, nature):
-        if nature not in EditorialModel.classtypes.EmClassType.natures(lesub._classtype):
-            raise ValueError("Invalid nature '%s' for %s"%(nature, lesup.__class__.__name__))
-
-        if not cls.leo_is_root(lesup):
-            if nature not in EditorialModel.classtypes.EmClassType.natures(lesup._classtype):
-                raise ValueError("Invalid nature '%s' for %s"%(nature, lesup.__class__.__name__))
-            if lesup.__class__ not in lesub._superiors[nature]:
-                raise ValueError("%s is not a valid superior for %s"%(lesup.__class__, lesub.__class__))
-        superiors = cls.hierarchy_get(lesub, nature, leo_is_sup = False)
-        res = True
-        for _lesup in superiors:
-            if not cls._datasource.del_superior(_lesup, lesub, nature):
-                #How to handler this ?
-                res = False
-        return res
-    
-    ## @brief Fetch neighbour in hierarchy relation
-    # @param leo LeType | LeRoot : We want the neighbour of this LeObject (can be the root)
-    # @param nature str : @ref EditorialModel.classtypes
-    # @param leo_is_sup bool : if True leo is the superior and we want to fetch the subordinates else its the oposite
-    # @return A list of LeObject ordered by depth if leo_is_sup, else a list of subordinates
-    @classmethod
-    def ___hierarchy_get(cls, leo, nature, leo_is_sup = True):
-        #Checking arguments
-        if not (nature is None) and not cls.is_root(leo):
-            if nature not in EditorialModel.classtypes.EmClassType.natures(leo._classtype):
-                raise ValueError("Invalid nature '%s' for %s"%(nature, lesup.__class__.__name__))
-        
-        if leo_is_sup:
-            return cls._datasource.get_subordinates(leo, nature)
-        else:
-            return cls._datasource.get_superiors(leo, nature)
-
-    ## @brief Preparing letype and leclass arguments
-    # 
-    # This function will do multiple things : 
-    #  - Convert string to LeType or LeClass child instances
-    #  - If both letype and leclass given, check that letype inherit from leclass
-    #  - If only a letype is given, fetch the parent leclass
-    # @note If we give only a leclass as argument returned letype will be None
-    # @note Its possible to give letype=None and leclass=None. In this case the method will return tuple(None,None)
-    # @param letype LeType|str|None : LeType child instant or its name
-    # @param leclass LeClass|str|None : LeClass child instant or its name
-    # @return a tuple with 2 python classes (LeTypeChild, LeClassChild)
-    @classmethod
-    def ___prepare_targets(cls, letype = None , leclass = None):
-        warnings.warn("_LeObject._prepare_targets is deprecated", DeprecationWarning)
-        raise ValueError()
-        if not(leclass is None):
-            if isinstance(leclass, str):
-                leclass = LeFactory.leobj_from_name(leclass)
-            
-            if not isinstance(leclass, type) or not (leapi.leclass.LeClass in leclass.__bases__) or leclass.__class__ == leapi.leclass.LeClass:
-                raise ValueError("None | str | LeType child class excpected, but got : '%s' %s"%(leclass,type(leclass)))
-
-        if not(letype is None):
-            if isinstance(letype, str):
-                letype = LeFactory.leobj_from_name(letype)
-
-            if not isinstance(letype, type) or not leapi.letype.LeType in letype.__bases__ or letype.__class__ == leapi.letype.LeType:
-                raise ValueError("None | str | LeType child class excpected, but got : %s"%type(letype))
-
-            if leclass is None:
-                leclass = letype._leclass
-            elif leclass != letype._leclass:
-                raise ValueError("LeType child class %s does'nt inherite from LeClass %s"%(letype.__name__, leclass.__name__))
-
-        return (letype, leclass)
-
 ## @brief Class designed to represent the hierarchy roots
 # @see _LeObject.get_root() _LeObject.is_root()
 class LeRoot(object):

leapi/lerelation.py

@@ -37,9 +37,6 @@ class _LeRelation(lecrud._LeCrud):
         rel_ft = dict()
         rel_ft.update(cls._uid_fieldtype)
 
-        rel_ft.update(cls._lesup_fieldtype)
-        rel_ft.update(cls._lesub_fieldtype)
-
         rel_ft.update(cls._rel_fieldtypes)
         if cls.implements_lerel2type():
             rel_ft.update(cls._rel_attr_fieldtypes)
@@ -58,7 +55,7 @@ class _LeRelation(lecrud._LeCrud):
         filters, rel_filters = super()._prepare_filters(filters_l)
         res_filters = list()
         for field, op, value in filters:
-            if field in [self._lesup_name, self._lesub_name]:
+            if field in [cls._lesup_name, cls._lesub_name]:
                 if isinstance(value, str):
                     try:
                         value = int(value)

leapi/test/test_lerelation.py

@@ -38,24 +38,24 @@ class LeRelationTestCase(TestCase):
                 ('nature', '=', '"parent"')
             ),
             (
-                'lesup = 21',
-                ('lesup', '=', LeObject(21))
+                'superior = 21',
+                ('superior', '=', LeObject(21))
             ),
             (
-                'lesub = 22',
-                ('lesub', '=', LeObject(22))
+                'subordinate = 22',
+                ('subordinate', '=', LeObject(22))
             ),
             (
                 ('rank', '=', '1'),
                 ('rank', '=', '1'),
             ),
             (
-                ('lesup', '=', LeObject(21)),
-                ('lesup', '=', LeObject(21)),
+                ('superior', '=', LeObject(21)),
+                ('superior', '=', LeObject(21)),
             ),
             (
-                ('lesub', '=', Numero(42)),
-                ('lesub', '=', Numero(42)),
+                ('subordinate', '=', Numero(42)),
+                ('subordinate', '=', Numero(42)),
             ),
         ]
         
@@ -74,7 +74,7 @@ class LeRelationTestCase(TestCase):
         from dyncode import LeCrud, Publication, Numero, Personnes, LeObject, Rubrique, LeHierarch, LeRelation
         
         LeRelation.delete([LeRelation.sup_filter(Numero(42)), 'nature = "parent"'], 'LeHierarch')
-        dsmock.assert_called_once_with(LeHierarch, [('lesup', '=', Numero(42)), ('nature','=','"parent"')])
+        dsmock.assert_called_once_with(LeHierarch, [('superior', '=', Numero(42)), ('nature','=','"parent"')])
         dsmock.reset_mock()
 
 
@@ -87,12 +87,12 @@ class LeHierarch(LeRelationTestCase):
 
         queries = [
             (
-                ['lesup = 42', 'lesub = 24'], #filters
-                ['lesup', 'lesub', 'nature', 'rank'], #field_l
+                ['superior = 42', 'subordinate = 24'], #filters
+                ['superior', 'subordinate', 'nature', 'rank'], #field_l
 
                 LeHierarch, #target
-                ['lesup', 'lesub', 'nature', 'rank'], #field_ds
-                [('lesup','=',LeObject(42)), ('lesub', '=', LeObject(24))], #filters_ds
+                ['superior', 'subordinate', 'nature', 'rank'], #field_ds
+                [('superior','=',LeObject(42)), ('subordinate', '=', LeObject(24))], #filters_ds
                 [], #rfilters_ds
 
             ),
@@ -101,8 +101,8 @@ class LeHierarch(LeRelationTestCase):
                 [],
 
                 LeHierarch,
-                [ 'nature', 'rank', 'lesub', 'depth', 'lesup', 'id_relation'],
-                [('lesup', '=', Numero(42))],
+                [ 'nature', 'rank', 'subordinate', 'depth', 'superior', 'id_relation'],
+                [('superior', '=', Numero(42))],
                 [],
             ),
         ]
@@ -129,13 +129,13 @@ class LeHierarch(LeRelationTestCase):
         queries = [
             (
                 {
-                    'lesup': Rubrique(7, class_id = Rubrique._class_id, type_id = Rubrique._type_id),
-                    'lesub': Numero(42, class_id = Numero._class_id, type_id = Numero._type_id),
+                    'superior': Rubrique(7, class_id = Rubrique._class_id, type_id = Rubrique._type_id),
+                    'subordinate': Numero(42, class_id = Numero._class_id, type_id = Numero._type_id),
                     'nature': 'parent',
                 },
                 {
-                    'lesup': Rubrique(7),
-                    'lesub': Numero(42),
+                    'superior': Rubrique(7),
+                    'subordinate': Numero(42),
                     'nature': 'parent',
                 },
             ),
@@ -143,37 +143,37 @@ class LeHierarch(LeRelationTestCase):
         """ # Those tests are not good
             (
                 {
-                    'lesup': 7,
-                    'lesub': 42,
+                    'superior': 7,
+                    'subordinate': 42,
                     'nature': 'parent',
                 },
                 {
-                    'lesup': LeObject(7),
-                    'lesub': LeObject(42),
+                    'superior': LeObject(7),
+                    'subordinate': LeObject(42),
                     'nature': 'parent',
                 }
             ),
             (
                 {
-                    'lesup': LeObject(7),
-                    'lesub': LeObject(42),
+                    'superior': LeObject(7),
+                    'subordinate': LeObject(42),
                     'nature': 'parent',
                 },
                 {
-                    'lesup': LeObject(7),
-                    'lesub': LeObject(42),
+                    'superior': LeObject(7),
+                    'subordinate': LeObject(42),
                     'nature': 'parent',
                 }
             ),
             (
                 {
-                    'lesup': LeObject(7),
-                    'lesub': 42,
+                    'superior': LeObject(7),
+                    'subordinate': 42,
                     'nature': 'parent',
                 },
                 {
-                    'lesup': LeObject(7),
-                    'lesub': LeObject(42),
+                    'superior': LeObject(7),
+                    'subordinate': LeObject(42),
                     'nature': 'parent',
                 }
             )
@@ -217,23 +217,23 @@ class LeRel2TypeTestCase(LeRelationTestCase):
 
         queries = [
             {
-                'lesup': Article(42),
-                'lesub': Personne(24),
+                'superior': Article(42),
+                'subordinate': Personne(24),
                 'adresse': None,
             },
             {
-                'lesup': Textes(42),
-                'lesub': Personne(24),
+                'superior': Textes(42),
+                'subordinate': Personne(24),
                 'adresse': None,
             },
             {
-                'lesup': Article(42),
-                'lesub': Personne(24),
+                'superior': Article(42),
+                'subordinate': Personne(24),
                 'adresse': "bar",
             },
             {
-                'lesup': Textes(42),
-                'lesub': Personne(24),
+                'superior': Textes(42),
+                'subordinate': Personne(24),
                 'adresse': "foo",
             },
         ]
@@ -243,7 +243,7 @@ class LeRel2TypeTestCase(LeRelationTestCase):
 
             eres = {'nature': None}
             eres.update(query)
-            for fname in ('lesup', 'lesub'):
+            for fname in ('superior', 'subordinate'):
                 if isinstance(eres[fname], int):
                     eres[fname] = LeObject(eres[fname])
 
@@ -262,27 +262,27 @@ class LeRel2TypeTestCase(LeRelationTestCase):
 
         queries = [
             {
-                'lesup': Rubrique(42),
-                'lesub': Personne(24),
+                'superior': Rubrique(42),
+                'subordinate': Personne(24),
                 'adresse': None,
             },
             {
                 'adresse': None,
             },
             {
-                'lesup': Rubrique(42),
-                'lesub': Rubrique(24),
+                'superior': Rubrique(42),
+                'subordinate': Rubrique(24),
                 'adresse': None,
             },
             {
-                'lesup': Article(42),
-                'lesub': Numero(24),
+                'superior': Article(42),
+                'subordinate': Numero(24),
                 'adresse': 'foo',
             },
             {
                 'id_relation': 1337,
-                'lesup': Article(42),
-                'lesub': Numero(24),
+                'superior': Article(42),
+                'subordinate': Numero(24),
                 'adresse': 'foo',
             },
         ]