Add a test for MySQL datasource select method

Test only select on LeObject childs without relational_filters

DataSource/MySQL/test/test_datasource.py

@@ -122,4 +122,181 @@ class DataSourceTestCase(TestCase):
                     mock_insert.assert_has_calls(expected_calls, any_order = False)
                     mock_utils_query.assert_has_calls(expected_utils_query_calls)
 
+    def test_select_leobject(self):
+        """ Test select method on leobject without relational filters """
+        from dyncode import Article, Personne, Rubrique, LeObject
+        
+        # Utils var and stuff to make tests queries write easier
+        
+        # lodel_id field name
+        lodel_id = db_utils.field_lodel_id
+        # pre-fetch tables name to make the tests_queries
+        table_names = {
+            LeObject: db_utils.objects_table_name,
+            Article: db_utils.get_table_name_from_class(Article._leclass.__name__),
+        }
+        # lodel_id name to be use in joins (leobject side)
+        join_lodel_id = db_utils.column_prefix(table_names[LeObject], lodel_id)
+        # lodel_id name to be use in joins (leclass side)
+        def cls_lodel_id(cls): return db_utils.column_prefix(table_names[cls], lodel_id)
 
+        tests_queries = [
+            # call leobject.select(fields = ['lodel_id', 'string'], filters = [])
+            (
+                #field_list details
+                {
+                    'leobject': [lodel_id, 'string'],
+                    'leclass': [],
+                },
+                #Select args
+                {
+                    'target_cls': LeObject,
+                    'filters': [],
+                    'rel_filters': [],
+                },
+                # expt args
+                {
+                    'where':{},
+                    'joins':None, #Expected call on Query.__call__ (called when we call left_join)
+                }
+            ),
+            # call leobject.select(fields = ['lodel_id', 'string'], filters = ['lodel_id = 42', 'string = "hello"', 'rank > 1'])
+            (
+                {
+                    'leobject': [lodel_id, 'string'],
+                    'leclass': [],
+                },
+                {
+                    'target_cls': LeObject,
+                    'filters': [
+                        (lodel_id,'=', 42),
+                        ('string', '=', 'Hello'),
+                        ('modification_date', '>', 1),
+                    ],
+                    'rel_filters': [],
+                },
+                {
+                    'where':{
+                        (
+                            db_utils.column_prefix(table_names[LeObject], lodel_id),
+                            '='
+                        ): 42,
+                        (
+                            db_utils.column_prefix(table_names[LeObject], 'string'),
+                            '='
+                        ): 'Hello',
+                        (
+                            db_utils.column_prefix(table_names[LeObject], 'modification_date'),
+                            '>'
+                        ): 1
+                    },
+                    'joins':None, #Expected call on Query.__call__ (called when we call left_join)
+                }
+            ),
+            # call Article.select(fields = ['lodel_id', 'titre'], filters = ['lodel_id = 42'])
+            (
+                {
+                    'leobject': [lodel_id],
+                    'leclass': ['titre'],
+                },
+                {
+                    'target_cls': Article,
+                    'filters': [ (lodel_id, '=', 42) ],
+                    'rel_filters': [],
+                },
+                {
+                    'where': {
+                        (
+                            db_utils.column_prefix(table_names[LeObject], lodel_id),
+                            '=',
+                        ): 42
+                    },
+                    'joins': call(
+                        table_names[Article],
+                        {join_lodel_id: cls_lodel_id(Article)}
+                    ),
+                }
+            ),
+            # call Article.select(fields = ['lodel_id', 'titre'], filters = ['lodel_id = 42', 'soustitre = "foobar"'])
+            (
+                {
+                    'leobject': [lodel_id],
+                    'leclass': ['titre'],
+                },
+                {
+                    'target_cls': Article,
+                    'filters': [
+                        (lodel_id, '=', 42),
+                        ('soustitre', '=', 'foobar'),
+                    ],
+                    'rel_filters': [],
+                },
+                {
+                    'where': {
+                        (
+                            db_utils.column_prefix(table_names[LeObject], lodel_id),
+                            '=',
+                        ): 42,
+                        (
+                            db_utils.column_prefix(table_names[Article], 'soustitre'),
+                            '=',
+                        ): 'foobar',
+                    },
+                    'joins': call(
+                        table_names[Article],
+                        {join_lodel_id: cls_lodel_id(Article)}
+                    ),
+                }
+            ),
+        ]
+
+        # mock the database module to avoid connection tries
+        dbmodule_mock = Mock()
+
+        datasource = DataSource(module=dbmodule_mock, conn_args = {})
+        sql_query = 'SELECT foo FROM LeObject' # Fake return of mosql.select()
+
+        for fields_details, select_args, expt_args in tests_queries:
+            mosql_query_return_value = sql_query
+            with patch.object(mosql_Query, '__call__', return_value=mosql_query_return_value) as mock_select:
+                with patch.object(db_utils, 'query') as mock_utils_query:
+                    # building the field_list argument
+                    select_args['field_list'] = copy.copy(fields_details['leobject'])
+                    select_args['field_list'] += fields_details['leclass']
+                    # call
+                    datasource.select(**select_args)
+
+                    # building the select expected argument
+                    select_arg = [ db_utils.column_prefix(db_utils.objects_table_name, fname) for fname in fields_details['leobject'] ]
+                    if len(fields_details['leclass']) > 0:
+                        leclass = select_args['target_cls']
+                        leclass = leclass._leclass if leclass.is_letype() else leclass
+                        table_name = db_utils.get_table_name_from_class(leclass.__name__)
+                        select_arg += [ db_utils.column_prefix(table_name, field_name) for field_name in fields_details['leclass'] ]
+                    
+                    if expt_args['joins'] is None:
+                        # If the call is made with LeObject as target class no joins call is made
+                        mock_select.assert_called_once_with(
+                            db_utils.objects_table_name,
+                            select= select_arg,
+                            where=expt_args['where'],
+                            joins=[]
+                        )
+                    else:
+                        # Else there has to be 2 calls, 1 for the join another for the select
+                        expected_calls = [
+                            expt_args['joins'],
+                            call(
+                                db_utils.objects_table_name,
+                                select= select_arg,
+                                where=expt_args['where'],
+                                joins=[mosql_query_return_value]
+                            )
+                        ]
+                        mock_select.assert_has_calls(expected_calls, any_order=False)
+                    
+                    # Tests that the query is really sent to the query method
+                    mock_utils_query.assert_called_once_with(
+                        datasource.connection,
+                        sql_query
+                    )