• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1#!/usr/bin/env python
2#
3# Copyright 2018, The Android Open Source Project
4#
5# Licensed under the Apache License, Version 2.0 (the "License");
6# you may not use this file except in compliance with the License.
7# You may obtain a copy of the License at
8#
9#     http://www.apache.org/licenses/LICENSE-2.0
10#
11# Unless required by applicable law or agreed to in writing, software
12# distributed under the License is distributed on an "AS IS" BASIS,
13# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14# See the License for the specific language governing permissions and
15# limitations under the License.
16
17"""Unittests for module_finder."""
18
19import re
20import unittest
21import os
22import mock
23
24# pylint: disable=import-error
25import atest_error
26import constants
27import module_info
28import unittest_constants as uc
29import unittest_utils
30from test_finders import module_finder
31from test_finders import test_finder_utils
32from test_finders import test_info
33from test_runners import atest_tf_test_runner as atf_tr
34
35MODULE_CLASS = '%s:%s' % (uc.MODULE_NAME, uc.CLASS_NAME)
36MODULE_PACKAGE = '%s:%s' % (uc.MODULE_NAME, uc.PACKAGE)
37CC_MODULE_CLASS = '%s:%s' % (uc.CC_MODULE_NAME, uc.CC_CLASS_NAME)
38FLAT_METHOD_INFO = test_info.TestInfo(
39    uc.MODULE_NAME,
40    atf_tr.AtestTradefedTestRunner.NAME,
41    uc.MODULE_BUILD_TARGETS,
42    data={constants.TI_FILTER: frozenset([uc.FLAT_METHOD_FILTER]),
43          constants.TI_REL_CONFIG: uc.CONFIG_FILE})
44MODULE_CLASS_METHOD = '%s#%s' % (MODULE_CLASS, uc.METHOD_NAME)
45CC_MODULE_CLASS_METHOD = '%s#%s' % (CC_MODULE_CLASS, uc.CC_METHOD_NAME)
46CLASS_INFO_MODULE_2 = test_info.TestInfo(
47    uc.MODULE2_NAME,
48    atf_tr.AtestTradefedTestRunner.NAME,
49    uc.CLASS_BUILD_TARGETS,
50    data={constants.TI_FILTER: frozenset([uc.CLASS_FILTER]),
51          constants.TI_REL_CONFIG: uc.CONFIG2_FILE})
52CC_CLASS_INFO_MODULE_2 = test_info.TestInfo(
53    uc.CC_MODULE2_NAME,
54    atf_tr.AtestTradefedTestRunner.NAME,
55    uc.CLASS_BUILD_TARGETS,
56    data={constants.TI_FILTER: frozenset([uc.CC_CLASS_FILTER]),
57          constants.TI_REL_CONFIG: uc.CC_CONFIG2_FILE})
58DEFAULT_INSTALL_PATH = ['/path/to/install']
59ROBO_MOD_PATH = ['/shared/robo/path']
60NON_RUN_ROBO_MOD_NAME = 'robo_mod'
61RUN_ROBO_MOD_NAME = 'run_robo_mod'
62NON_RUN_ROBO_MOD = {constants.MODULE_NAME: NON_RUN_ROBO_MOD_NAME,
63                    constants.MODULE_PATH: ROBO_MOD_PATH,
64                    constants.MODULE_CLASS: ['random_class']}
65RUN_ROBO_MOD = {constants.MODULE_NAME: RUN_ROBO_MOD_NAME,
66                constants.MODULE_PATH: ROBO_MOD_PATH,
67                constants.MODULE_CLASS: [constants.MODULE_CLASS_ROBOLECTRIC]}
68
69SEARCH_DIR_RE = re.compile(r'^find ([^ ]*).*$')
70
71#pylint: disable=unused-argument
72def classoutside_side_effect(find_cmd, shell=False):
73    """Mock the check output of a find cmd where class outside module path."""
74    search_dir = SEARCH_DIR_RE.match(find_cmd).group(1).strip()
75    if search_dir == uc.ROOT:
76        return uc.FIND_ONE
77    return None
78
79
80#pylint: disable=protected-access
81class ModuleFinderUnittests(unittest.TestCase):
82    """Unit tests for module_finder.py"""
83
84    def setUp(self):
85        """Set up stuff for testing."""
86        self.mod_finder = module_finder.ModuleFinder()
87        self.mod_finder.module_info = mock.Mock(spec=module_info.ModuleInfo)
88        self.mod_finder.module_info.path_to_module_info = {}
89        self.mod_finder.root_dir = uc.ROOT
90
91    def test_is_vts_module(self):
92        """Test _load_module_info_file regular operation."""
93        mod_name = 'mod'
94        is_vts_module_info = {'compatibility_suites': ['vts', 'tests']}
95        self.mod_finder.module_info.get_module_info.return_value = is_vts_module_info
96        self.assertTrue(self.mod_finder._is_vts_module(mod_name))
97
98        is_not_vts_module = {'compatibility_suites': ['vts', 'cts']}
99        self.mod_finder.module_info.get_module_info.return_value = is_not_vts_module
100        self.assertFalse(self.mod_finder._is_vts_module(mod_name))
101
102    # pylint: disable=unused-argument
103    @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets',
104                       return_value=uc.MODULE_BUILD_TARGETS)
105    def test_find_test_by_module_name(self, _get_targ):
106        """Test find_test_by_module_name."""
107        self.mod_finder.module_info.is_robolectric_test.return_value = False
108        self.mod_finder.module_info.has_test_config.return_value = True
109        mod_info = {'installed': ['/path/to/install'],
110                    'path': [uc.MODULE_DIR],
111                    constants.MODULE_CLASS: []}
112        self.mod_finder.module_info.get_module_info.return_value = mod_info
113        unittest_utils.assert_equal_testinfos(
114            self,
115            self.mod_finder.find_test_by_module_name(uc.MODULE_NAME),
116            uc.MODULE_INFO)
117        self.mod_finder.module_info.get_module_info.return_value = None
118        self.mod_finder.module_info.is_testable_module.return_value = False
119        self.assertIsNone(self.mod_finder.find_test_by_module_name('Not_Module'))
120
121    @mock.patch.object(module_finder.ModuleFinder, '_is_vts_module',
122                       return_value=False)
123    @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets')
124    @mock.patch('subprocess.check_output', return_value=uc.FIND_ONE)
125    @mock.patch.object(test_finder_utils, 'get_fully_qualified_class_name',
126                       return_value=uc.FULL_CLASS_NAME)
127    @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect)
128    @mock.patch('os.path.isdir', return_value=True)
129    #pylint: disable=unused-argument
130    def test_find_test_by_class_name(self, _isdir, _isfile, _fqcn,
131                                     mock_checkoutput, mock_build,
132                                     _vts):
133        """Test find_test_by_class_name."""
134        mock_build.return_value = uc.CLASS_BUILD_TARGETS
135        self.mod_finder.module_info.is_auto_gen_test_config.return_value = False
136        self.mod_finder.module_info.is_robolectric_test.return_value = False
137        self.mod_finder.module_info.has_test_config.return_value = True
138        self.mod_finder.module_info.get_module_names.return_value = [uc.MODULE_NAME]
139        self.mod_finder.module_info.get_module_info.return_value = {
140            constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH,
141            constants.MODULE_NAME: uc.MODULE_NAME,
142            constants.MODULE_CLASS: []}
143        unittest_utils.assert_equal_testinfos(
144            self, self.mod_finder.find_test_by_class_name(uc.CLASS_NAME), uc.CLASS_INFO)
145
146        # with method
147        mock_build.return_value = uc.MODULE_BUILD_TARGETS
148        class_with_method = '%s#%s' % (uc.CLASS_NAME, uc.METHOD_NAME)
149        unittest_utils.assert_equal_testinfos(
150            self,
151            self.mod_finder.find_test_by_class_name(class_with_method),
152            uc.METHOD_INFO)
153        mock_build.return_value = uc.MODULE_BUILD_TARGETS
154        class_methods = '%s,%s' % (class_with_method, uc.METHOD2_NAME)
155        unittest_utils.assert_equal_testinfos(
156            self, self.mod_finder.find_test_by_class_name(class_methods),
157            FLAT_METHOD_INFO)
158        # module and rel_config passed in
159        mock_build.return_value = uc.CLASS_BUILD_TARGETS
160        unittest_utils.assert_equal_testinfos(
161            self, self.mod_finder.find_test_by_class_name(
162                uc.CLASS_NAME, uc.MODULE_NAME, uc.CONFIG_FILE), uc.CLASS_INFO)
163        # find output fails to find class file
164        mock_checkoutput.return_value = ''
165        self.assertIsNone(self.mod_finder.find_test_by_class_name('Not class'))
166        # class is outside given module path
167        mock_checkoutput.side_effect = classoutside_side_effect
168        unittest_utils.assert_equal_testinfos(
169            self, self.mod_finder.find_test_by_class_name(uc.CLASS_NAME,
170                                                          uc.MODULE2_NAME,
171                                                          uc.CONFIG2_FILE),
172            CLASS_INFO_MODULE_2)
173
174    @mock.patch.object(module_finder.ModuleFinder, '_is_vts_module',
175                       return_value=False)
176    @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets')
177    @mock.patch('subprocess.check_output', return_value=uc.FIND_ONE)
178    @mock.patch.object(test_finder_utils, 'get_fully_qualified_class_name',
179                       return_value=uc.FULL_CLASS_NAME)
180    @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect)
181    #pylint: disable=unused-argument
182    def test_find_test_by_module_and_class(self, _isfile, _fqcn,
183                                           mock_checkoutput, mock_build,
184                                           _vts):
185        """Test find_test_by_module_and_class."""
186        # Native test was tested in test_find_test_by_cc_class_name().
187        self.mod_finder.module_info.is_native_test.return_value = False
188        self.mod_finder.module_info.is_auto_gen_test_config.return_value = False
189        self.mod_finder.module_info.is_robolectric_test.return_value = False
190        self.mod_finder.module_info.has_test_config.return_value = True
191        mock_build.return_value = uc.CLASS_BUILD_TARGETS
192        mod_info = {constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH,
193                    constants.MODULE_PATH: [uc.MODULE_DIR],
194                    constants.MODULE_CLASS: []}
195        self.mod_finder.module_info.get_module_info.return_value = mod_info
196        t_info = self.mod_finder.find_test_by_module_and_class(MODULE_CLASS)
197        unittest_utils.assert_equal_testinfos(self, t_info, uc.CLASS_INFO)
198        # with method
199        mock_build.return_value = uc.MODULE_BUILD_TARGETS
200        t_info = self.mod_finder.find_test_by_module_and_class(MODULE_CLASS_METHOD)
201        unittest_utils.assert_equal_testinfos(self, t_info, uc.METHOD_INFO)
202        self.mod_finder.module_info.is_testable_module.return_value = False
203        # bad module, good class, returns None
204        bad_module = '%s:%s' % ('BadMod', uc.CLASS_NAME)
205        self.mod_finder.module_info.get_module_info.return_value = None
206        self.assertIsNone(self.mod_finder.find_test_by_module_and_class(bad_module))
207        # find output fails to find class file
208        mock_checkoutput.return_value = ''
209        bad_class = '%s:%s' % (uc.MODULE_NAME, 'Anything')
210        self.mod_finder.module_info.get_module_info.return_value = mod_info
211        self.assertIsNone(self.mod_finder.find_test_by_module_and_class(bad_class))
212
213    @mock.patch.object(module_finder.ModuleFinder, '_is_vts_module',
214                       return_value=False)
215    @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets')
216    @mock.patch('subprocess.check_output', return_value=uc.FIND_CC_ONE)
217    @mock.patch.object(test_finder_utils, 'find_class_file',
218                       side_effect=[None, None, '/'])
219    @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect)
220    #pylint: disable=unused-argument
221    def test_find_test_by_module_and_class_part_2(self, _isfile, mock_fcf,
222                                                  mock_checkoutput, mock_build,
223                                                  _vts):
224        """Test find_test_by_module_and_class for MODULE:CC_CLASS."""
225        # Native test was tested in test_find_test_by_cc_class_name()
226        self.mod_finder.module_info.is_native_test.return_value = False
227        self.mod_finder.module_info.is_auto_gen_test_config.return_value = False
228        self.mod_finder.module_info.is_robolectric_test.return_value = False
229        self.mod_finder.module_info.has_test_config.return_value = True
230        mock_build.return_value = uc.CLASS_BUILD_TARGETS
231        mod_info = {constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH,
232                    constants.MODULE_PATH: [uc.CC_MODULE_DIR],
233                    constants.MODULE_CLASS: []}
234        self.mod_finder.module_info.get_module_info.return_value = mod_info
235        t_info = self.mod_finder.find_test_by_module_and_class(CC_MODULE_CLASS)
236        unittest_utils.assert_equal_testinfos(self, t_info, uc.CC_MODULE_CLASS_INFO)
237        # with method
238        mock_build.return_value = uc.MODULE_BUILD_TARGETS
239        mock_fcf.side_effect = [None, None, '/']
240        t_info = self.mod_finder.find_test_by_module_and_class(CC_MODULE_CLASS_METHOD)
241        unittest_utils.assert_equal_testinfos(self, t_info, uc.CC_METHOD_INFO)
242        # bad module, good class, returns None
243        bad_module = '%s:%s' % ('BadMod', uc.CC_CLASS_NAME)
244        self.mod_finder.module_info.get_module_info.return_value = None
245        self.mod_finder.module_info.is_testable_module.return_value = False
246        self.assertIsNone(self.mod_finder.find_test_by_module_and_class(bad_module))
247
248    @mock.patch.object(module_finder.ModuleFinder, '_is_vts_module',
249                       return_value=False)
250    @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets')
251    @mock.patch('subprocess.check_output', return_value=uc.FIND_PKG)
252    @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect)
253    @mock.patch('os.path.isdir', return_value=True)
254    #pylint: disable=unused-argument
255    def test_find_test_by_package_name(self, _isdir, _isfile, mock_checkoutput,
256                                       mock_build, _vts):
257        """Test find_test_by_package_name."""
258        self.mod_finder.module_info.is_auto_gen_test_config.return_value = False
259        self.mod_finder.module_info.is_robolectric_test.return_value = False
260        self.mod_finder.module_info.has_test_config.return_value = True
261        mock_build.return_value = uc.CLASS_BUILD_TARGETS
262        self.mod_finder.module_info.get_module_names.return_value = [uc.MODULE_NAME]
263        self.mod_finder.module_info.get_module_info.return_value = {
264            constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH,
265            constants.MODULE_NAME: uc.MODULE_NAME,
266            constants.MODULE_CLASS: []}
267        unittest_utils.assert_equal_testinfos(
268            self, self.mod_finder.find_test_by_package_name(uc.PACKAGE),
269            uc.PACKAGE_INFO)
270        # with method, should raise
271        pkg_with_method = '%s#%s' % (uc.PACKAGE, uc.METHOD_NAME)
272        self.assertRaises(atest_error.MethodWithoutClassError,
273                          self.mod_finder.find_test_by_package_name,
274                          pkg_with_method)
275        # module and rel_config passed in
276        unittest_utils.assert_equal_testinfos(
277            self, self.mod_finder.find_test_by_package_name(
278                uc.PACKAGE, uc.MODULE_NAME, uc.CONFIG_FILE), uc.PACKAGE_INFO)
279        # find output fails to find class file
280        mock_checkoutput.return_value = ''
281        self.assertIsNone(self.mod_finder.find_test_by_package_name('Not pkg'))
282
283    @mock.patch.object(module_finder.ModuleFinder, '_is_vts_module',
284                       return_value=False)
285    @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets')
286    @mock.patch('subprocess.check_output', return_value=uc.FIND_PKG)
287    @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect)
288    #pylint: disable=unused-argument
289    def test_find_test_by_module_and_package(self, _isfile, mock_checkoutput,
290                                             mock_build, _vts):
291        """Test find_test_by_module_and_package."""
292        self.mod_finder.module_info.is_auto_gen_test_config.return_value = False
293        self.mod_finder.module_info.is_robolectric_test.return_value = False
294        self.mod_finder.module_info.has_test_config.return_value = True
295        mock_build.return_value = uc.CLASS_BUILD_TARGETS
296        mod_info = {constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH,
297                    constants.MODULE_PATH: [uc.MODULE_DIR],
298                    constants.MODULE_CLASS: []}
299        self.mod_finder.module_info.get_module_info.return_value = mod_info
300        t_info = self.mod_finder.find_test_by_module_and_package(MODULE_PACKAGE)
301        unittest_utils.assert_equal_testinfos(self, t_info, uc.PACKAGE_INFO)
302        # with method, raises
303        module_pkg_with_method = '%s:%s#%s' % (uc.MODULE2_NAME, uc.PACKAGE,
304                                               uc.METHOD_NAME)
305        self.assertRaises(atest_error.MethodWithoutClassError,
306                          self.mod_finder.find_test_by_module_and_package,
307                          module_pkg_with_method)
308        # bad module, good pkg, returns None
309        self.mod_finder.module_info.is_testable_module.return_value = False
310        bad_module = '%s:%s' % ('BadMod', uc.PACKAGE)
311        self.mod_finder.module_info.get_module_info.return_value = None
312        self.assertIsNone(self.mod_finder.find_test_by_module_and_package(bad_module))
313        # find output fails to find package path
314        mock_checkoutput.return_value = ''
315        bad_pkg = '%s:%s' % (uc.MODULE_NAME, 'Anything')
316        self.mod_finder.module_info.get_module_info.return_value = mod_info
317        self.assertIsNone(self.mod_finder.find_test_by_module_and_package(bad_pkg))
318
319    @mock.patch.object(test_finder_utils, 'has_cc_class',
320                       return_value=True)
321    @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets')
322    @mock.patch.object(module_finder.ModuleFinder, '_is_vts_module',
323                       return_value=False)
324    @mock.patch.object(test_finder_utils, 'get_fully_qualified_class_name',
325                       return_value=uc.FULL_CLASS_NAME)
326    @mock.patch('os.path.realpath',
327                side_effect=unittest_utils.realpath_side_effect)
328    @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect)
329    @mock.patch.object(test_finder_utils, 'find_parent_module_dir')
330    @mock.patch('os.path.exists')
331    #pylint: disable=unused-argument
332    def test_find_test_by_path(self, mock_pathexists, mock_dir, _isfile, _real,
333                               _fqcn, _vts, mock_build, _has_cc_class):
334        """Test find_test_by_path."""
335        self.mod_finder.module_info.is_robolectric_test.return_value = False
336        self.mod_finder.module_info.has_test_config.return_value = True
337        mock_build.return_value = set()
338        # Check that we don't return anything with invalid test references.
339        mock_pathexists.return_value = False
340        unittest_utils.assert_equal_testinfos(
341            self, None, self.mod_finder.find_test_by_path('bad/path'))
342        mock_pathexists.return_value = True
343        mock_dir.return_value = None
344        unittest_utils.assert_equal_testinfos(
345            self, None, self.mod_finder.find_test_by_path('no/module'))
346        self.mod_finder.module_info.get_module_names.return_value = [uc.MODULE_NAME]
347        self.mod_finder.module_info.get_module_info.return_value = {
348            constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH,
349            constants.MODULE_NAME: uc.MODULE_NAME,
350            constants.MODULE_CLASS: []}
351
352        # Happy path testing.
353        mock_dir.return_value = uc.MODULE_DIR
354
355        class_path = '%s.kt' % uc.CLASS_NAME
356        mock_build.return_value = uc.CLASS_BUILD_TARGETS
357        unittest_utils.assert_equal_testinfos(
358            self, uc.CLASS_INFO, self.mod_finder.find_test_by_path(class_path))
359
360        class_path = '%s.java' % uc.CLASS_NAME
361        mock_build.return_value = uc.CLASS_BUILD_TARGETS
362        unittest_utils.assert_equal_testinfos(
363            self, uc.CLASS_INFO, self.mod_finder.find_test_by_path(class_path))
364
365        class_with_method = '%s#%s' % (class_path, uc.METHOD_NAME)
366        mock_build.return_value = uc.MODULE_BUILD_TARGETS
367        unittest_utils.assert_equal_testinfos(
368            self, self.mod_finder.find_test_by_path(class_with_method), uc.METHOD_INFO)
369
370        class_with_methods = '%s,%s' % (class_with_method, uc.METHOD2_NAME)
371        mock_build.return_value = uc.MODULE_BUILD_TARGETS
372        unittest_utils.assert_equal_testinfos(
373            self, self.mod_finder.find_test_by_path(class_with_methods),
374            FLAT_METHOD_INFO)
375
376        # Cc path testing.
377        self.mod_finder.module_info.get_module_names.return_value = [uc.CC_MODULE_NAME]
378        self.mod_finder.module_info.get_module_info.return_value = {
379            constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH,
380            constants.MODULE_NAME: uc.CC_MODULE_NAME,
381            constants.MODULE_CLASS: []}
382        mock_dir.return_value = uc.CC_MODULE_DIR
383        class_path = '%s' % uc.CC_PATH
384        mock_build.return_value = uc.CLASS_BUILD_TARGETS
385        unittest_utils.assert_equal_testinfos(
386            self, uc.CC_PATH_INFO2, self.mod_finder.find_test_by_path(class_path))
387
388    @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets',
389                       return_value=uc.MODULE_BUILD_TARGETS)
390    @mock.patch.object(module_finder.ModuleFinder, '_is_vts_module',
391                       return_value=False)
392    @mock.patch.object(test_finder_utils, 'find_parent_module_dir',
393                       return_value=os.path.relpath(uc.TEST_DATA_DIR, uc.ROOT))
394    #pylint: disable=unused-argument
395    def test_find_test_by_path_part_2(self, _find_parent, _is_vts, _get_build):
396        """Test find_test_by_path for directories."""
397        self.mod_finder.module_info.is_auto_gen_test_config.return_value = False
398        self.mod_finder.module_info.is_robolectric_test.return_value = False
399        self.mod_finder.module_info.has_test_config.return_value = True
400        # Dir with java files in it, should run as package
401        class_dir = os.path.join(uc.TEST_DATA_DIR, 'path_testing')
402        self.mod_finder.module_info.get_module_names.return_value = [uc.MODULE_NAME]
403        self.mod_finder.module_info.get_module_info.return_value = {
404            constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH,
405            constants.MODULE_NAME: uc.MODULE_NAME,
406            constants.MODULE_CLASS: []}
407        unittest_utils.assert_equal_testinfos(
408            self, uc.PATH_INFO, self.mod_finder.find_test_by_path(class_dir))
409        # Dir with no java files in it, should run whole module
410        empty_dir = os.path.join(uc.TEST_DATA_DIR, 'path_testing_empty')
411        unittest_utils.assert_equal_testinfos(
412            self, uc.EMPTY_PATH_INFO,
413            self.mod_finder.find_test_by_path(empty_dir))
414        # Dir with cc files in it, should run as cc class
415        class_dir = os.path.join(uc.TEST_DATA_DIR, 'cc_path_testing')
416        self.mod_finder.module_info.get_module_names.return_value = [uc.CC_MODULE_NAME]
417        self.mod_finder.module_info.get_module_info.return_value = {
418            constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH,
419            constants.MODULE_NAME: uc.CC_MODULE_NAME,
420            constants.MODULE_CLASS: []}
421        unittest_utils.assert_equal_testinfos(
422            self, uc.CC_PATH_INFO, self.mod_finder.find_test_by_path(class_dir))
423
424    @mock.patch.object(module_finder.ModuleFinder, '_is_vts_module',
425                       return_value=False)
426    @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets')
427    @mock.patch('subprocess.check_output', return_value=uc.CC_FIND_ONE)
428    @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect)
429    @mock.patch('os.path.isdir', return_value=True)
430    #pylint: disable=unused-argument
431    def test_find_test_by_cc_class_name(self, _isdir, _isfile,
432                                        mock_checkoutput, mock_build,
433                                        _vts):
434        """Test find_test_by_cc_class_name."""
435        mock_build.return_value = uc.CLASS_BUILD_TARGETS
436        self.mod_finder.module_info.is_auto_gen_test_config.return_value = False
437        self.mod_finder.module_info.is_robolectric_test.return_value = False
438        self.mod_finder.module_info.has_test_config.return_value = True
439        self.mod_finder.module_info.get_module_names.return_value = [uc.CC_MODULE_NAME]
440        self.mod_finder.module_info.get_module_info.return_value = {
441            constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH,
442            constants.MODULE_NAME: uc.CC_MODULE_NAME,
443            constants.MODULE_CLASS: []}
444        unittest_utils.assert_equal_testinfos(
445            self, self.mod_finder.find_test_by_cc_class_name(uc.CC_CLASS_NAME), uc.CC_CLASS_INFO)
446
447        # with method
448        mock_build.return_value = uc.MODULE_BUILD_TARGETS
449        class_with_method = '%s#%s' % (uc.CC_CLASS_NAME, uc.CC_METHOD_NAME)
450        unittest_utils.assert_equal_testinfos(
451            self,
452            self.mod_finder.find_test_by_cc_class_name(class_with_method),
453            uc.CC_METHOD_INFO)
454        mock_build.return_value = uc.MODULE_BUILD_TARGETS
455        class_methods = '%s,%s' % (class_with_method, uc.CC_METHOD2_NAME)
456        unittest_utils.assert_equal_testinfos(
457            self, self.mod_finder.find_test_by_cc_class_name(class_methods),
458            uc.CC_METHOD2_INFO)
459        # module and rel_config passed in
460        mock_build.return_value = uc.CLASS_BUILD_TARGETS
461        unittest_utils.assert_equal_testinfos(
462            self, self.mod_finder.find_test_by_cc_class_name(
463                uc.CC_CLASS_NAME, uc.CC_MODULE_NAME, uc.CC_CONFIG_FILE), uc.CC_CLASS_INFO)
464        # find output fails to find class file
465        mock_checkoutput.return_value = ''
466        self.assertIsNone(self.mod_finder.find_test_by_cc_class_name(
467            'Not class'))
468        # class is outside given module path
469        mock_checkoutput.return_value = uc.CC_FIND_ONE
470        unittest_utils.assert_equal_testinfos(
471            self, self.mod_finder.find_test_by_cc_class_name(uc.CC_CLASS_NAME,
472                                                             uc.CC_MODULE2_NAME,
473                                                             uc.CC_CONFIG2_FILE),
474            CC_CLASS_INFO_MODULE_2)
475
476    def test_get_testable_modules_with_ld(self):
477        """Test get_testable_modules_with_ld"""
478        self.mod_finder.module_info.get_testable_modules.return_value = [
479            uc.MODULE_NAME, uc.MODULE2_NAME]
480        # Without a misfit constraint
481        ld1 = self.mod_finder.get_testable_modules_with_ld(uc.TYPO_MODULE_NAME)
482        self.assertEqual([[16, uc.MODULE2_NAME], [1, uc.MODULE_NAME]], ld1)
483        # With a misfit constraint
484        ld2 = self.mod_finder.get_testable_modules_with_ld(uc.TYPO_MODULE_NAME, 2)
485        self.assertEqual([[1, uc.MODULE_NAME]], ld2)
486
487    def test_get_fuzzy_searching_modules(self):
488        """Test get_fuzzy_searching_modules"""
489        self.mod_finder.module_info.get_testable_modules.return_value = [
490            uc.MODULE_NAME, uc.MODULE2_NAME]
491        result = self.mod_finder.get_fuzzy_searching_results(uc.TYPO_MODULE_NAME)
492        self.assertEqual(uc.MODULE_NAME, result[0])
493
494
495if __name__ == '__main__':
496    unittest.main()
497