#!/usr/bin/env python3 # # Copyright 2018, The Android Open Source Project # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Unittests for module_finder.""" # pylint: disable=invalid-name # pylint: disable=line-too-long # pylint: disable=missing-function-docstring # pylint: disable=too-many-lines # pylint: disable=unsubscriptable-object import copy import re import tempfile import unittest import os from pathlib import Path from unittest import mock # pylint: disable=import-error from pyfakefs import fake_filesystem_unittest from atest import atest_error from atest import atest_configs from atest import atest_utils from atest import constants from atest import module_info from atest import unittest_constants as uc from atest import unittest_utils from atest.test_finders import module_finder from atest.test_finders import test_finder_utils from atest.test_finders import test_info from atest.test_runners import atest_tf_test_runner as atf_tr MODULE_CLASS = '%s:%s' % (uc.MODULE_NAME, uc.CLASS_NAME) MODULE_PACKAGE = '%s:%s' % (uc.MODULE_NAME, uc.PACKAGE) CC_MODULE_CLASS = '%s:%s' % (uc.CC_MODULE_NAME, uc.CC_CLASS_NAME) KERNEL_TEST_CLASS = 'test_class_1' KERNEL_TEST_CONFIG = 'KernelTest.xml.data' KERNEL_MODULE_CLASS = '%s:%s' % (constants.REQUIRED_LTP_TEST_MODULES[0], KERNEL_TEST_CLASS) KERNEL_CONFIG_FILE = os.path.join(uc.TEST_DATA_DIR, KERNEL_TEST_CONFIG) KERNEL_CLASS_FILTER = test_info.TestFilter(KERNEL_TEST_CLASS, frozenset()) KERNEL_MODULE_CLASS_DATA = {constants.TI_REL_CONFIG: KERNEL_CONFIG_FILE, constants.TI_FILTER: frozenset([KERNEL_CLASS_FILTER])} KERNEL_MODULE_CLASS_INFO = test_info.TestInfo( constants.REQUIRED_LTP_TEST_MODULES[0], atf_tr.AtestTradefedTestRunner.NAME, uc.CLASS_BUILD_TARGETS, KERNEL_MODULE_CLASS_DATA) FLAT_METHOD_INFO = test_info.TestInfo( uc.MODULE_NAME, atf_tr.AtestTradefedTestRunner.NAME, uc.MODULE_BUILD_TARGETS, data={constants.TI_FILTER: frozenset([uc.FLAT_METHOD_FILTER]), constants.TI_REL_CONFIG: uc.CONFIG_FILE}) MODULE_CLASS_METHOD = '%s#%s' % (MODULE_CLASS, uc.METHOD_NAME) CC_MODULE_CLASS_METHOD = '%s#%s' % (CC_MODULE_CLASS, uc.CC_METHOD_NAME) CLASS_INFO_MODULE_2 = test_info.TestInfo( uc.MODULE2_NAME, atf_tr.AtestTradefedTestRunner.NAME, uc.CLASS_BUILD_TARGETS, data={constants.TI_FILTER: frozenset([uc.CLASS_FILTER]), constants.TI_REL_CONFIG: uc.CONFIG2_FILE}) CC_CLASS_INFO_MODULE_2 = test_info.TestInfo( uc.CC_MODULE2_NAME, atf_tr.AtestTradefedTestRunner.NAME, uc.CLASS_BUILD_TARGETS, data={constants.TI_FILTER: frozenset([uc.CC_CLASS_FILTER]), constants.TI_REL_CONFIG: uc.CC_CONFIG2_FILE}) DEFAULT_INSTALL_PATH = ['/path/to/install'] ROBO_MOD_PATH = ['/shared/robo/path'] NON_RUN_ROBO_MOD_NAME = 'robo_mod' RUN_ROBO_MOD_NAME = 'run_robo_mod' NON_RUN_ROBO_MOD = {constants.MODULE_NAME: NON_RUN_ROBO_MOD_NAME, constants.MODULE_PATH: ROBO_MOD_PATH, constants.MODULE_CLASS: ['random_class']} RUN_ROBO_MOD = {constants.MODULE_NAME: RUN_ROBO_MOD_NAME, constants.MODULE_PATH: ROBO_MOD_PATH, constants.MODULE_CLASS: [constants.MODULE_CLASS_ROBOLECTRIC]} SEARCH_DIR_RE = re.compile(r'^find ([^ ]*).*$') #pylint: disable=unused-argument def classoutside_side_effect(find_cmd, shell=False): """Mock the check output of a find cmd where class outside module path.""" search_dir = SEARCH_DIR_RE.match(find_cmd).group(1).strip() if search_dir == uc.ROOT: return uc.FIND_ONE return None class ModuleFinderFindTestByModuleName(fake_filesystem_unittest.TestCase): """Unit tests for module_finder.py""" def setUp(self): self.setUpPyfakefs() self.build_top = Path('/') self.product_out = self.build_top.joinpath('out/product') self.product_out.mkdir(parents=True, exist_ok=True) self.module_info_file = self.product_out.joinpath('atest_merged_dep.json') self.fs.create_file( self.module_info_file, contents=(''' { "CtsJankDeviceTestCases": { "class":["APPS"], "path":["foo/bar/jank"], "tags": ["optional"], "installed": ["path/to/install/CtsJankDeviceTestCases.apk"], "test_config": ["foo/bar/jank/AndroidTest.xml", "foo/bar/jank/CtsJankDeviceTestCases2.xml"], "module_name": "CtsJankDeviceTestCases" } }''') ) @mock.patch('builtins.input', return_value='1') def test_find_test_by_module_name_w_multiple_config(self, _): """Test find_test_by_module_name (test_config_select)""" atest_configs.GLOBAL_ARGS = mock.Mock() atest_configs.GLOBAL_ARGS.test_config_select = True # The original test name will be updated to the config name when multiple # configs were found. expected_test_info = create_test_info( test_name='CtsJankDeviceTestCases2', raw_test_name='CtsJankDeviceTestCases', test_runner='AtestTradefedTestRunner', module_class=['APPS'], build_targets={'MODULES-IN-foo-bar-jank', 'CtsJankDeviceTestCases'}, data={'rel_config': 'foo/bar/jank/CtsJankDeviceTestCases2.xml', 'filter': frozenset()} ) self.fs.create_file( self.build_top.joinpath('foo/bar/jank/CtsJankDeviceTestCases2.xml'), contents=(''' ''') ) mod_info = module_info.ModuleInfo(module_file=self.module_info_file) mod_finder = module_finder.ModuleFinder(module_info=mod_info) t_infos = mod_finder.find_test_by_module_name('CtsJankDeviceTestCases') self.assertEqual(len(t_infos), 1) unittest_utils.assert_equal_testinfos(self, t_infos[0], expected_test_info) def test_find_test_by_module_name_w_multiple_config_all(self): """Test find_test_by_module_name.""" atest_configs.GLOBAL_ARGS = mock.Mock() atest_configs.GLOBAL_ARGS.test_config_select = False expected_test_info = [ create_test_info( test_name='CtsJankDeviceTestCases', test_runner='AtestTradefedTestRunner', module_class=['APPS'], build_targets={'MODULES-IN-foo-bar-jank', 'CtsJankDeviceTestCases'}, data={'rel_config': 'foo/bar/jank/AndroidTest.xml', 'filter': frozenset()} ), create_test_info( test_name='CtsJankDeviceTestCases2', raw_test_name='CtsJankDeviceTestCases', test_runner='AtestTradefedTestRunner', module_class=['APPS'], build_targets={'MODULES-IN-foo-bar-jank', 'CtsJankDeviceTestCases'}, data={'rel_config': 'foo/bar/jank/CtsJankDeviceTestCases2.xml', 'filter': frozenset()} )] self.fs.create_file( self.build_top.joinpath('foo/bar/jank/AndroidTest.xml'), contents=(''' ''') ) mod_info = module_info.ModuleInfo(module_file=self.module_info_file) mod_finder = module_finder.ModuleFinder(module_info=mod_info) t_infos = mod_finder.find_test_by_module_name('CtsJankDeviceTestCases') self.assertEqual(len(t_infos), 2) unittest_utils.assert_equal_testinfos(self, t_infos[0], expected_test_info[0]) unittest_utils.assert_equal_testinfos(self, t_infos[1], expected_test_info[1]) class ModuleFinderFindTestByPath(fake_filesystem_unittest.TestCase): """Test cases that invoke find_test_by_path.""" def setUp(self): self.setUpPyfakefs() # pylint: disable=protected-access def create_empty_module_info(self): fake_temp_file_name = next(tempfile._get_candidate_names()) self.fs.create_file(fake_temp_file_name, contents='{}') return module_info.ModuleInfo(module_file=fake_temp_file_name) def create_module_info(self, modules=None): mod_info = self.create_empty_module_info() modules = modules or [] for m in modules: mod_info.name_to_module_info[m['module_name']] = m for path in m['path']: if path in mod_info.path_to_module_info: mod_info.path_to_module_info[path].append(m) else: mod_info.path_to_module_info[path] = [m] return mod_info # TODO: remove below mocks and hide unnecessary information. @mock.patch.object(module_finder.ModuleFinder, '_get_test_info_filter') @mock.patch.object(test_finder_utils, 'find_parent_module_dir', return_value=None) @mock.patch('os.path.exists') #pylint: disable=unused-argument def test_find_test_by_path_belong_to_dependencies( self, _mock_exists, _mock_find_parent, _mock_test_filter): """Test find_test_by_path if belong to test dependencies.""" test1 = module(name='test1', classes=['class'], dependencies=['lib1'], installed=['install/test1'], auto_test_config=[True]) test2 = module(name='test2', classes=['class'], dependencies=['lib2'], installed=['install/test2'], auto_test_config=[True]) lib1 = module(name='lib1', srcs=['path/src1']) lib2 = module(name='lib2', srcs=['path/src2']) mod_info = self.create_module_info( [test1, test2, lib1, lib2]) mod_finder = module_finder.ModuleFinder(module_info=mod_info) _mock_exists.return_value = True test1_filter = test_info.TestFilter('test1Filter', frozenset()) _mock_test_filter.return_value = test1_filter t_infos = mod_finder.find_test_by_path('path/src1') unittest_utils.assert_equal_testinfos( self, test_info.TestInfo( 'test1', atf_tr.AtestTradefedTestRunner.NAME, {'test1', 'MODULES-IN-'}, {constants.TI_FILTER: test1_filter, constants.TI_REL_CONFIG: 'AndroidTest.xml'}, module_class=['class']), t_infos[0]) #pylint: disable=protected-access class ModuleFinderUnittests(unittest.TestCase): """Unit tests for module_finder.py""" def setUp(self): """Set up stuff for testing.""" self.mod_finder = module_finder.ModuleFinder() self.mod_finder.module_info = mock.Mock(spec=module_info.ModuleInfo) self.mod_finder.module_info.path_to_module_info = {} self.mod_finder.root_dir = uc.ROOT def test_is_vts_module(self): """Test _load_module_info_file regular operation.""" mod_name = 'mod' is_vts_module_info = {'compatibility_suites': ['vts10', 'tests']} self.mod_finder.module_info.get_module_info.return_value = is_vts_module_info self.assertTrue(self.mod_finder._is_vts_module(mod_name)) is_not_vts_module = {'compatibility_suites': ['vts10', 'cts']} self.mod_finder.module_info.get_module_info.return_value = is_not_vts_module self.assertFalse(self.mod_finder._is_vts_module(mod_name)) # pylint: disable=unused-argument @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets', return_value=copy.deepcopy(uc.MODULE_BUILD_TARGETS)) def test_find_test_by_module_name(self, _get_targ): """Test find_test_by_module_name.""" self.mod_finder.module_info.is_robolectric_test.return_value = False self.mod_finder.module_info.get_instrumentation_target_apps.return_value = {} self.mod_finder.module_info.has_test_config.return_value = True mod_info = {'installed': ['/path/to/install'], 'path': [uc.MODULE_DIR], constants.MODULE_CLASS: [], constants.MODULE_COMPATIBILITY_SUITES: []} self.mod_finder.module_info.get_module_info.return_value = mod_info self.mod_finder.module_info.get_robolectric_type.return_value = 0 t_infos = self.mod_finder.find_test_by_module_name(uc.MODULE_NAME) unittest_utils.assert_equal_testinfos( self, t_infos[0], uc.MODULE_INFO) self.mod_finder.module_info.get_module_info.return_value = None self.mod_finder.module_info.is_testable_module.return_value = False self.assertIsNone(self.mod_finder.find_test_by_module_name('Not_Module')) @mock.patch.object(test_finder_utils, 'find_host_unit_tests', return_value=[]) @mock.patch.object(atest_utils, 'is_build_file', return_value=True) @mock.patch.object(test_finder_utils, 'is_parameterized_java_class', return_value=False) @mock.patch.object(test_finder_utils, 'has_method_in_file', return_value=True) @mock.patch.object(module_finder.ModuleFinder, '_is_vts_module', return_value=False) @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets') @mock.patch('subprocess.check_output', return_value=uc.FIND_ONE) @mock.patch.object(test_finder_utils, 'get_fully_qualified_class_name', return_value=uc.FULL_CLASS_NAME) @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect) @mock.patch('os.path.isdir', return_value=True) #pylint: disable=unused-argument def test_find_test_by_class_name(self, _isdir, _isfile, _fqcn, mock_checkoutput, mock_build, _vts, _has_method_in_file, _is_parameterized, _is_build_file, _mock_unit_tests): """Test find_test_by_class_name.""" mock_build.return_value = uc.CLASS_BUILD_TARGETS self.mod_finder.module_info.is_auto_gen_test_config.return_value = False self.mod_finder.module_info.is_robolectric_test.return_value = False self.mod_finder.module_info.get_instrumentation_target_apps.return_value = {} self.mod_finder.module_info.has_test_config.return_value = True self.mod_finder.module_info.get_module_names.return_value = [uc.MODULE_NAME] self.mod_finder.module_info.get_module_info.return_value = { constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH, constants.MODULE_NAME: uc.MODULE_NAME, constants.MODULE_CLASS: [], constants.MODULE_COMPATIBILITY_SUITES: []} self.mod_finder.module_info.get_robolectric_type.return_value = 0 t_infos = self.mod_finder.find_test_by_class_name(uc.CLASS_NAME) unittest_utils.assert_equal_testinfos( self, t_infos[0], uc.CLASS_INFO) # with method mock_build.return_value = copy.deepcopy(uc.MODULE_BUILD_TARGETS) class_with_method = '%s#%s' % (uc.CLASS_NAME, uc.METHOD_NAME) t_infos = self.mod_finder.find_test_by_class_name(class_with_method) unittest_utils.assert_equal_testinfos( self, t_infos[0], uc.METHOD_INFO) mock_build.return_value = copy.deepcopy(uc.MODULE_BUILD_TARGETS) class_methods = '%s,%s' % (class_with_method, uc.METHOD2_NAME) t_infos = self.mod_finder.find_test_by_class_name(class_methods) unittest_utils.assert_equal_testinfos( self, t_infos[0], FLAT_METHOD_INFO) # module and rel_config passed in mock_build.return_value = uc.CLASS_BUILD_TARGETS t_infos = self.mod_finder.find_test_by_class_name( uc.CLASS_NAME, uc.MODULE_NAME, uc.CONFIG_FILE) unittest_utils.assert_equal_testinfos( self, t_infos[0], uc.CLASS_INFO) # find output fails to find class file mock_checkoutput.return_value = '' self.assertIsNone(self.mod_finder.find_test_by_class_name('Not class')) # class is outside given module path mock_checkoutput.side_effect = classoutside_side_effect t_infos = self.mod_finder.find_test_by_class_name(uc.CLASS_NAME, uc.MODULE2_NAME, uc.CONFIG2_FILE) unittest_utils.assert_equal_testinfos( self, t_infos[0], CLASS_INFO_MODULE_2) @mock.patch.object(test_finder_utils, 'is_parameterized_java_class', return_value=False) @mock.patch.object(test_finder_utils, 'has_method_in_file', return_value=True) @mock.patch.object(module_finder.ModuleFinder, '_is_vts_module', return_value=False) @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets') @mock.patch('subprocess.check_output', return_value=uc.FIND_ONE) @mock.patch.object(test_finder_utils, 'get_fully_qualified_class_name', return_value=uc.FULL_CLASS_NAME) @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect) #pylint: disable=unused-argument def test_find_test_by_module_and_class(self, _isfile, _fqcn, mock_checkoutput, mock_build, _vts, _has_method_in_file, _is_parameterized): """Test find_test_by_module_and_class.""" # Native test was tested in test_find_test_by_cc_class_name(). self.mod_finder.module_info.is_native_test.return_value = False self.mod_finder.module_info.is_auto_gen_test_config.return_value = False self.mod_finder.module_info.is_robolectric_test.return_value = False self.mod_finder.module_info.has_test_config.return_value = True mock_build.return_value = uc.CLASS_BUILD_TARGETS mod_info = {constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH, constants.MODULE_PATH: [uc.MODULE_DIR], constants.MODULE_CLASS: [], constants.MODULE_COMPATIBILITY_SUITES: []} self.mod_finder.module_info.get_module_info.return_value = mod_info self.mod_finder.module_info.get_robolectric_type.return_value = 0 self.mod_finder.module_info.get_instrumentation_target_apps.return_value = {} t_infos = self.mod_finder.find_test_by_module_and_class(MODULE_CLASS) unittest_utils.assert_equal_testinfos(self, t_infos[0], uc.CLASS_INFO) # with method mock_build.return_value = copy.deepcopy(uc.MODULE_BUILD_TARGETS) t_infos = self.mod_finder.find_test_by_module_and_class(MODULE_CLASS_METHOD) unittest_utils.assert_equal_testinfos(self, t_infos[0], uc.METHOD_INFO) self.mod_finder.module_info.is_testable_module.return_value = False # bad module, good class, returns None bad_module = '%s:%s' % ('BadMod', uc.CLASS_NAME) self.mod_finder.module_info.get_module_info.return_value = None self.assertIsNone(self.mod_finder.find_test_by_module_and_class(bad_module)) # find output fails to find class file mock_checkoutput.return_value = '' bad_class = '%s:%s' % (uc.MODULE_NAME, 'Anything') self.mod_finder.module_info.get_module_info.return_value = mod_info self.assertIsNone(self.mod_finder.find_test_by_module_and_class(bad_class)) @mock.patch.object(module_finder.test_finder_utils, 'get_cc_class_info') @mock.patch.object(module_finder.ModuleFinder, 'find_test_by_kernel_class_name', return_value=None) @mock.patch.object(module_finder.ModuleFinder, '_is_vts_module', return_value=False) @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets') @mock.patch('subprocess.check_output', return_value=uc.FIND_CC_ONE) @mock.patch.object(test_finder_utils, 'find_class_file', side_effect=[None, None, '/']) @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect) #pylint: disable=unused-argument def test_find_test_by_module_and_class_part_2(self, _isfile, mock_fcf, mock_checkoutput, mock_build, _vts, _find_kernel, _class_info): """Test find_test_by_module_and_class for MODULE:CC_CLASS.""" # Native test was tested in test_find_test_by_cc_class_name() self.mod_finder.module_info.is_native_test.return_value = False self.mod_finder.module_info.is_auto_gen_test_config.return_value = False self.mod_finder.module_info.is_robolectric_test.return_value = False self.mod_finder.module_info.has_test_config.return_value = True self.mod_finder.module_info.get_paths.return_value = [] mock_build.return_value = uc.CLASS_BUILD_TARGETS mod_info = {constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH, constants.MODULE_PATH: [uc.CC_MODULE_DIR], constants.MODULE_CLASS: [], constants.MODULE_COMPATIBILITY_SUITES: []} self.mod_finder.module_info.get_module_info.return_value = mod_info _class_info.return_value = {'PFTest': {'methods':{'test1', 'test2'}, 'prefixes': set(), 'typed': False}} self.mod_finder.module_info.get_robolectric_type.return_value = 0 self.mod_finder.module_info.get_instrumentation_target_apps.return_value = {} t_infos = self.mod_finder.find_test_by_module_and_class(CC_MODULE_CLASS) unittest_utils.assert_equal_testinfos(self, t_infos[0], uc.CC_MODULE_CLASS_INFO) # with method mock_build.return_value = copy.deepcopy(uc.MODULE_BUILD_TARGETS) mock_fcf.side_effect = [None, None, '/'] t_infos = self.mod_finder.find_test_by_module_and_class(CC_MODULE_CLASS_METHOD) unittest_utils.assert_equal_testinfos(self, t_infos[0], uc.CC_METHOD3_INFO) # bad module, good class, returns None bad_module = '%s:%s' % ('BadMod', uc.CC_CLASS_NAME) self.mod_finder.module_info.get_module_info.return_value = None self.mod_finder.module_info.is_testable_module.return_value = False self.assertIsNone(self.mod_finder.find_test_by_module_and_class(bad_module)) @mock.patch.object(module_finder.ModuleFinder, '_get_module_test_config', return_value=[KERNEL_CONFIG_FILE]) @mock.patch.object(module_finder.ModuleFinder, '_is_vts_module', return_value=False) @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets') @mock.patch('subprocess.check_output', return_value=uc.FIND_CC_ONE) @mock.patch.object(test_finder_utils, 'find_class_file', side_effect=[None, None, '/']) @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect) #pylint: disable=unused-argument def test_find_test_by_module_and_class_for_kernel_test( self, _isfile, mock_fcf, mock_checkoutput, mock_build, _vts, _test_config): """Test find_test_by_module_and_class for MODULE:CC_CLASS.""" # Kernel test was tested in find_test_by_kernel_class_name() self.mod_finder.module_info.is_native_test.return_value = False self.mod_finder.module_info.is_auto_gen_test_config.return_value = False self.mod_finder.module_info.is_robolectric_test.return_value = False self.mod_finder.module_info.has_test_config.return_value = True self.mod_finder.module_info.get_paths.return_value = [] mock_build.return_value = uc.CLASS_BUILD_TARGETS mod_info = {constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH, constants.MODULE_PATH: [uc.CC_MODULE_DIR], constants.MODULE_CLASS: [], constants.MODULE_COMPATIBILITY_SUITES: []} self.mod_finder.module_info.get_module_info.return_value = mod_info self.mod_finder.module_info.get_robolectric_type.return_value = 0 self.mod_finder.module_info.get_instrumentation_target_apps.return_value = {} t_infos = self.mod_finder.find_test_by_module_and_class(KERNEL_MODULE_CLASS) unittest_utils.assert_equal_testinfos(self, t_infos[0], KERNEL_MODULE_CLASS_INFO) @mock.patch.object(test_finder_utils, 'find_host_unit_tests', return_value=[]) @mock.patch.object(module_finder.ModuleFinder, '_is_vts_module', return_value=False) @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets') @mock.patch('subprocess.check_output', return_value=uc.FIND_PKG) @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect) @mock.patch('os.path.isdir', return_value=True) #pylint: disable=unused-argument def test_find_test_by_package_name(self, _isdir, _isfile, mock_checkoutput, mock_build, _vts, _mock_unit_tests): """Test find_test_by_package_name.""" self.mod_finder.module_info.is_auto_gen_test_config.return_value = False self.mod_finder.module_info.is_robolectric_test.return_value = False self.mod_finder.module_info.has_test_config.return_value = True mock_build.return_value = uc.CLASS_BUILD_TARGETS self.mod_finder.module_info.get_module_names.return_value = [uc.MODULE_NAME] self.mod_finder.module_info.get_module_info.return_value = { constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH, constants.MODULE_NAME: uc.MODULE_NAME, constants.MODULE_CLASS: [], constants.MODULE_COMPATIBILITY_SUITES: [] } self.mod_finder.module_info.get_robolectric_type.return_value = 0 self.mod_finder.module_info.get_instrumentation_target_apps.return_value = {} t_infos = self.mod_finder.find_test_by_package_name(uc.PACKAGE) unittest_utils.assert_equal_testinfos( self, t_infos[0], uc.PACKAGE_INFO) # with method, should raise pkg_with_method = '%s#%s' % (uc.PACKAGE, uc.METHOD_NAME) self.assertRaises(atest_error.MethodWithoutClassError, self.mod_finder.find_test_by_package_name, pkg_with_method) # module and rel_config passed in t_infos = self.mod_finder.find_test_by_package_name( uc.PACKAGE, uc.MODULE_NAME, uc.CONFIG_FILE) unittest_utils.assert_equal_testinfos( self, t_infos[0], uc.PACKAGE_INFO) # find output fails to find class file mock_checkoutput.return_value = '' self.assertIsNone(self.mod_finder.find_test_by_package_name('Not pkg')) @mock.patch('os.path.isdir', return_value=False) @mock.patch.object(module_finder.ModuleFinder, '_is_vts_module', return_value=False) @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets') @mock.patch('subprocess.check_output', return_value=uc.FIND_PKG) @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect) #pylint: disable=unused-argument def test_find_test_by_module_and_package(self, _isfile, mock_checkoutput, mock_build, _vts, _isdir): """Test find_test_by_module_and_package.""" self.mod_finder.module_info.is_auto_gen_test_config.return_value = False self.mod_finder.module_info.is_robolectric_test.return_value = False self.mod_finder.module_info.has_test_config.return_value = True self.mod_finder.module_info.get_paths.return_value = [] mock_build.return_value = uc.CLASS_BUILD_TARGETS mod_info = {constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH, constants.MODULE_PATH: [uc.MODULE_DIR], constants.MODULE_CLASS: [], constants.MODULE_COMPATIBILITY_SUITES: []} self.mod_finder.module_info.get_module_info.return_value = mod_info self.mod_finder.module_info.get_instrumentation_target_apps.return_value = {} t_infos = self.mod_finder.find_test_by_module_and_package(MODULE_PACKAGE) self.assertEqual(t_infos, None) _isdir.return_value = True self.mod_finder.module_info.get_robolectric_type.return_value = 0 t_infos = self.mod_finder.find_test_by_module_and_package(MODULE_PACKAGE) unittest_utils.assert_equal_testinfos(self, t_infos[0], uc.PACKAGE_INFO) # with method, raises module_pkg_with_method = '%s:%s#%s' % (uc.MODULE2_NAME, uc.PACKAGE, uc.METHOD_NAME) self.assertRaises(atest_error.MethodWithoutClassError, self.mod_finder.find_test_by_module_and_package, module_pkg_with_method) # bad module, good pkg, returns None self.mod_finder.module_info.is_testable_module.return_value = False bad_module = '%s:%s' % ('BadMod', uc.PACKAGE) self.mod_finder.module_info.get_module_info.return_value = None self.assertIsNone(self.mod_finder.find_test_by_module_and_package(bad_module)) # find output fails to find package path mock_checkoutput.return_value = '' bad_pkg = '%s:%s' % (uc.MODULE_NAME, 'Anything') self.mod_finder.module_info.get_module_info.return_value = mod_info self.assertIsNone(self.mod_finder.find_test_by_module_and_package(bad_pkg)) # TODO: Move and rewite it to ModuleFinderFindTestByPath. @mock.patch.object(test_finder_utils, 'find_host_unit_tests', return_value=[]) @mock.patch.object(test_finder_utils, 'get_cc_class_info', return_value={}) @mock.patch.object(atest_utils, 'is_build_file', return_value=True) @mock.patch.object(test_finder_utils, 'is_parameterized_java_class', return_value=False) @mock.patch.object(test_finder_utils, 'has_method_in_file', return_value=True) @mock.patch.object(test_finder_utils, 'has_cc_class', return_value=True) @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets') @mock.patch.object(module_finder.ModuleFinder, '_is_vts_module', return_value=False) @mock.patch.object(test_finder_utils, 'get_fully_qualified_class_name', return_value=uc.FULL_CLASS_NAME) @mock.patch('os.path.realpath', side_effect=unittest_utils.realpath_side_effect) @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect) @mock.patch.object(test_finder_utils, 'find_parent_module_dir') @mock.patch('os.path.exists') #pylint: disable=unused-argument def test_find_test_by_path( self, mock_pathexists, mock_dir, _isfile, _real, _fqcn, _vts, mock_build, _has_cc_class, _has_method_in_file, _is_parameterized, _is_build_file, _get_cc_class_info, _mock_unit_tests): """Test find_test_by_path.""" self.mod_finder.module_info.is_robolectric_test.return_value = False self.mod_finder.module_info.has_test_config.return_value = True self.mod_finder.module_info.get_modules_by_include_deps.return_value = set() mock_build.return_value = set() # Check that we don't return anything with invalid test references. mock_pathexists.return_value = False unittest_utils.assert_equal_testinfos( self, None, self.mod_finder.find_test_by_path('bad/path')) mock_pathexists.return_value = True mock_dir.return_value = None unittest_utils.assert_equal_testinfos( self, None, self.mod_finder.find_test_by_path('no/module')) self.mod_finder.module_info.get_module_names.return_value = [uc.MODULE_NAME] self.mod_finder.module_info.get_module_info.return_value = { constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH, constants.MODULE_NAME: uc.MODULE_NAME, constants.MODULE_CLASS: [], constants.MODULE_COMPATIBILITY_SUITES: []} # Happy path testing. mock_dir.return_value = uc.MODULE_DIR class_path = '%s.kt' % uc.CLASS_NAME mock_build.return_value = uc.CLASS_BUILD_TARGETS self.mod_finder.module_info.get_robolectric_type.return_value = 0 self.mod_finder.module_info.get_instrumentation_target_apps.return_value = {} t_infos = self.mod_finder.find_test_by_path(class_path) unittest_utils.assert_equal_testinfos( self, uc.CLASS_INFO, t_infos[0]) class_with_method = '%s#%s' % (class_path, uc.METHOD_NAME) mock_build.return_value = copy.deepcopy(uc.MODULE_BUILD_TARGETS) t_infos = self.mod_finder.find_test_by_path(class_with_method) unittest_utils.assert_equal_testinfos( self, t_infos[0], uc.METHOD_INFO) class_path = '%s.java' % uc.CLASS_NAME mock_build.return_value = uc.CLASS_BUILD_TARGETS t_infos = self.mod_finder.find_test_by_path(class_path) unittest_utils.assert_equal_testinfos( self, uc.CLASS_INFO, t_infos[0]) class_with_method = '%s#%s' % (class_path, uc.METHOD_NAME) mock_build.return_value = copy.deepcopy(uc.MODULE_BUILD_TARGETS) t_infos = self.mod_finder.find_test_by_path(class_with_method) unittest_utils.assert_equal_testinfos( self, t_infos[0], uc.METHOD_INFO) class_with_methods = '%s,%s' % (class_with_method, uc.METHOD2_NAME) mock_build.return_value = copy.deepcopy(uc.MODULE_BUILD_TARGETS) t_infos = self.mod_finder.find_test_by_path(class_with_methods) unittest_utils.assert_equal_testinfos( self, t_infos[0], FLAT_METHOD_INFO) # Cc path testing. self.mod_finder.module_info.get_module_names.return_value = [uc.CC_MODULE_NAME] self.mod_finder.module_info.get_module_info.return_value = { constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH, constants.MODULE_NAME: uc.CC_MODULE_NAME, constants.MODULE_CLASS: [], constants.MODULE_COMPATIBILITY_SUITES: []} mock_dir.return_value = uc.CC_MODULE_DIR class_path = '%s' % uc.CC_PATH mock_build.return_value = uc.CLASS_BUILD_TARGETS t_infos = self.mod_finder.find_test_by_path(class_path) unittest_utils.assert_equal_testinfos( self, uc.CC_PATH_INFO2, t_infos[0]) # TODO: Move and rewite it to ModuleFinderFindTestByPath. @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets', return_value=copy.deepcopy(uc.MODULE_BUILD_TARGETS)) @mock.patch.object(module_finder.ModuleFinder, '_is_vts_module', return_value=False) @mock.patch.object(test_finder_utils, 'find_parent_module_dir', return_value=os.path.relpath(uc.TEST_DATA_DIR, uc.ROOT)) #pylint: disable=unused-argument def test_find_test_by_path_part_2(self, _find_parent, _is_vts, _get_build): """Test find_test_by_path for directories.""" self.mod_finder.module_info.is_auto_gen_test_config.return_value = False self.mod_finder.module_info.is_robolectric_test.return_value = False self.mod_finder.module_info.has_test_config.return_value = True # Dir with java files in it, should run as package class_dir = os.path.join(uc.TEST_DATA_DIR, 'path_testing') self.mod_finder.module_info.get_module_names.return_value = [uc.MODULE_NAME] self.mod_finder.module_info.get_module_info.return_value = { constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH, constants.MODULE_NAME: uc.MODULE_NAME, constants.MODULE_CLASS: [], constants.MODULE_COMPATIBILITY_SUITES: []} self.mod_finder.module_info.get_robolectric_type.return_value = 0 self.mod_finder.module_info.get_instrumentation_target_apps.return_value = {} t_infos = self.mod_finder.find_test_by_path(class_dir) unittest_utils.assert_equal_testinfos( self, uc.PATH_INFO, t_infos[0]) # Dir with no java files in it, should run whole module empty_dir = os.path.join(uc.TEST_DATA_DIR, 'path_testing_empty') t_infos = self.mod_finder.find_test_by_path(empty_dir) unittest_utils.assert_equal_testinfos( self, uc.EMPTY_PATH_INFO, t_infos[0]) # Dir with cc files in it, should run as cc class class_dir = os.path.join(uc.TEST_DATA_DIR, 'cc_path_testing') self.mod_finder.module_info.get_module_names.return_value = [uc.CC_MODULE_NAME] self.mod_finder.module_info.get_module_info.return_value = { constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH, constants.MODULE_NAME: uc.CC_MODULE_NAME, constants.MODULE_CLASS: [], constants.MODULE_COMPATIBILITY_SUITES: []} t_infos = self.mod_finder.find_test_by_path(class_dir) unittest_utils.assert_equal_testinfos( self, uc.CC_PATH_INFO, t_infos[0]) @mock.patch.object(module_finder.test_finder_utils, 'get_cc_class_info') @mock.patch.object(test_finder_utils, 'find_host_unit_tests', return_value=[]) @mock.patch.object(atest_utils, 'is_build_file', return_value=True) @mock.patch.object(test_finder_utils, 'has_method_in_file', return_value=True) @mock.patch.object(module_finder.ModuleFinder, '_is_vts_module', return_value=False) @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets') @mock.patch('subprocess.check_output', return_value=uc.CC_FIND_ONE) @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect) @mock.patch('os.path.isdir', return_value=True) #pylint: disable=unused-argument def test_find_test_by_cc_class_name(self, _isdir, _isfile, mock_checkoutput, mock_build, _vts, _has_method, _is_build_file, _mock_unit_tests, _class_info): """Test find_test_by_cc_class_name.""" mock_build.return_value = uc.CLASS_BUILD_TARGETS self.mod_finder.module_info.is_auto_gen_test_config.return_value = False self.mod_finder.module_info.is_robolectric_test.return_value = False self.mod_finder.module_info.has_test_config.return_value = True self.mod_finder.module_info.get_module_names.return_value = [uc.CC_MODULE_NAME] self.mod_finder.module_info.get_module_info.return_value = { constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH, constants.MODULE_NAME: uc.CC_MODULE_NAME, constants.MODULE_CLASS: [], constants.MODULE_COMPATIBILITY_SUITES: []} self.mod_finder.module_info.get_robolectric_type.return_value = 0 self.mod_finder.module_info.get_instrumentation_target_apps.return_value = {} _class_info.return_value = {'PFTest': {'methods': {'test1', 'test2'}, 'prefixes': set(), 'typed': False}} t_infos = self.mod_finder.find_test_by_cc_class_name(uc.CC_CLASS_NAME) unittest_utils.assert_equal_testinfos( self, t_infos[0], uc.CC_CLASS_INFO) # with method mock_build.return_value = copy.deepcopy(uc.MODULE_BUILD_TARGETS) class_with_method = '%s#%s' % (uc.CC_CLASS_NAME, uc.CC_METHOD_NAME) t_infos = self.mod_finder.find_test_by_cc_class_name(class_with_method) unittest_utils.assert_equal_testinfos( self, t_infos[0], uc.CC_METHOD_INFO) mock_build.return_value = copy.deepcopy(uc.MODULE_BUILD_TARGETS) class_methods = '%s,%s' % (class_with_method, uc.CC_METHOD2_NAME) t_infos = self.mod_finder.find_test_by_cc_class_name(class_methods) unittest_utils.assert_equal_testinfos( self, t_infos[0], uc.CC_METHOD2_INFO) # module and rel_config passed in mock_build.return_value = uc.CLASS_BUILD_TARGETS t_infos = self.mod_finder.find_test_by_cc_class_name( uc.CC_CLASS_NAME, uc.CC_MODULE_NAME, uc.CC_CONFIG_FILE) unittest_utils.assert_equal_testinfos( self, t_infos[0], uc.CC_CLASS_INFO) # find output fails to find class file mock_checkoutput.return_value = '' self.assertIsNone(self.mod_finder.find_test_by_cc_class_name( 'Not class')) # class is outside given module path mock_checkoutput.return_value = uc.CC_FIND_ONE t_infos = self.mod_finder.find_test_by_cc_class_name( uc.CC_CLASS_NAME, uc.CC_MODULE2_NAME, uc.CC_CONFIG2_FILE) unittest_utils.assert_equal_testinfos( self, t_infos[0], CC_CLASS_INFO_MODULE_2) def test_get_testable_modules_with_ld(self): """Test get_testable_modules_with_ld""" self.mod_finder.module_info.get_testable_modules.return_value = [ uc.MODULE_NAME, uc.MODULE2_NAME] # Without a misfit constraint ld1 = self.mod_finder.get_testable_modules_with_ld(uc.TYPO_MODULE_NAME) self.assertEqual([[16, uc.MODULE2_NAME], [1, uc.MODULE_NAME]], ld1) # With a misfit constraint ld2 = self.mod_finder.get_testable_modules_with_ld(uc.TYPO_MODULE_NAME, 2) self.assertEqual([[1, uc.MODULE_NAME]], ld2) def test_get_fuzzy_searching_modules(self): """Test get_fuzzy_searching_modules""" self.mod_finder.module_info.get_testable_modules.return_value = [ uc.MODULE_NAME, uc.MODULE2_NAME] result = self.mod_finder.get_fuzzy_searching_results(uc.TYPO_MODULE_NAME) self.assertEqual(uc.MODULE_NAME, result[0]) def test_get_build_targets_w_vts_core(self): """Test _get_build_targets.""" self.mod_finder.module_info.is_auto_gen_test_config.return_value = True self.mod_finder.module_info.get_paths.return_value = [] mod_info = {constants.MODULE_COMPATIBILITY_SUITES: [constants.VTS_CORE_SUITE]} self.mod_finder.module_info.get_module_info.return_value = mod_info self.assertEqual(self.mod_finder._get_build_targets('', ''), {constants.VTS_CORE_TF_MODULE}) def test_get_build_targets_w_mts(self): """Test _get_build_targets if module belong to mts.""" self.mod_finder.module_info.is_auto_gen_test_config.return_value = True self.mod_finder.module_info.get_paths.return_value = [] mod_info = {constants.MODULE_COMPATIBILITY_SUITES: [constants.MTS_SUITE]} self.mod_finder.module_info.get_module_info.return_value = mod_info self.assertEqual(self.mod_finder._get_build_targets('', ''), {constants.CTS_JAR}) @mock.patch.object(test_finder_utils, 'is_parameterized_java_class', return_value=False) @mock.patch.object(module_finder.ModuleFinder, '_is_vts_module', return_value=False) @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets') @mock.patch('subprocess.check_output', return_value='') @mock.patch.object(test_finder_utils, 'get_fully_qualified_class_name', return_value=uc.FULL_CLASS_NAME) @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect) @mock.patch('os.path.isdir', return_value=True) #pylint: disable=unused-argument def test_find_test_by_class_name_w_module(self, _isdir, _isfile, _fqcn, mock_checkoutput, mock_build, _vts, _is_parameterized): """Test test_find_test_by_class_name with module but without class found.""" mock_build.return_value = uc.CLASS_BUILD_TARGETS self.mod_finder.module_info.is_auto_gen_test_config.return_value = False self.mod_finder.module_info.is_robolectric_test.return_value = False self.mod_finder.module_info.has_test_config.return_value = True self.mod_finder.module_info.get_module_names.return_value = [uc.MODULE_NAME] self.mod_finder.module_info.get_module_info.return_value = { constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH, constants.MODULE_NAME: uc.MODULE_NAME, constants.MODULE_CLASS: [], constants.MODULE_COMPATIBILITY_SUITES: []} self.mod_finder.module_info.get_paths.return_value = [uc.TEST_DATA_CONFIG] self.mod_finder.module_info.get_robolectric_type.return_value = 0 self.mod_finder.module_info.get_instrumentation_target_apps.return_value = {} t_infos = self.mod_finder.find_test_by_class_name( uc.FULL_CLASS_NAME, module_name=uc.MODULE_NAME, rel_config=uc.CONFIG_FILE) unittest_utils.assert_equal_testinfos( self, t_infos[0], uc.CLASS_INFO) @mock.patch.object(module_finder.ModuleFinder, '_is_vts_module', return_value=False) @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets') @mock.patch('subprocess.check_output', return_value='') @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect) @mock.patch('os.path.isdir', return_value=True) #pylint: disable=unused-argument def test_find_test_by_package_name_w_module(self, _isdir, _isfile, mock_checkoutput, mock_build, _vts): """Test find_test_by_package_name with module but without package found.""" self.mod_finder.module_info.is_auto_gen_test_config.return_value = False self.mod_finder.module_info.is_robolectric_test.return_value = False self.mod_finder.module_info.has_test_config.return_value = True mock_build.return_value = uc.CLASS_BUILD_TARGETS self.mod_finder.module_info.get_module_names.return_value = [uc.MODULE_NAME] self.mod_finder.module_info.get_module_info.return_value = { constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH, constants.MODULE_NAME: uc.MODULE_NAME, constants.MODULE_CLASS: [], constants.MODULE_COMPATIBILITY_SUITES: [] } self.mod_finder.module_info.get_paths.return_value = [uc.TEST_DATA_CONFIG] self.mod_finder.module_info.get_robolectric_type.return_value = 0 self.mod_finder.module_info.get_instrumentation_target_apps.return_value = {} t_infos = self.mod_finder.find_test_by_package_name( uc.PACKAGE, module_name=uc.MODULE_NAME, rel_config=uc.CONFIG_FILE) unittest_utils.assert_equal_testinfos( self, t_infos[0], uc.PACKAGE_INFO) @mock.patch.object(atest_utils, 'is_build_file', return_value=True) @mock.patch.object(test_finder_utils, 'is_parameterized_java_class', return_value=True) @mock.patch.object(test_finder_utils, 'has_method_in_file', return_value=True) @mock.patch.object(test_finder_utils, 'has_cc_class', return_value=True) @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets') @mock.patch.object(module_finder.ModuleFinder, '_is_vts_module', return_value=False) @mock.patch.object(test_finder_utils, 'get_fully_qualified_class_name', return_value=uc.FULL_CLASS_NAME) @mock.patch('os.path.realpath', side_effect=unittest_utils.realpath_side_effect) @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect) @mock.patch.object(test_finder_utils, 'find_parent_module_dir') @mock.patch('os.path.exists') #pylint: disable=unused-argument def test_find_test_by_path_is_parameterized_java( self, mock_pathexists, mock_dir, _isfile, _real, _fqcn, _vts, mock_build, _has_cc_class, _has_method_in_file, _is_parameterized, _is_build_file): """Test find_test_by_path and input path is parameterized class.""" self.mod_finder.module_info.is_robolectric_test.return_value = False self.mod_finder.module_info.has_test_config.return_value = True mock_build.return_value = set() mock_pathexists.return_value = True self.mod_finder.module_info.get_module_names.return_value = [uc.MODULE_NAME] self.mod_finder.module_info.get_module_info.return_value = { constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH, constants.MODULE_NAME: uc.MODULE_NAME, constants.MODULE_CLASS: [], constants.MODULE_COMPATIBILITY_SUITES: []} self.mod_finder.module_info.get_robolectric_type.return_value = 0 self.mod_finder.module_info.get_instrumentation_target_apps.return_value = {} # Happy path testing. mock_dir.return_value = uc.MODULE_DIR class_path = '%s.java' % uc.CLASS_NAME # Input include only one method class_with_method = '%s#%s' % (class_path, uc.METHOD_NAME) mock_build.return_value = copy.deepcopy(uc.MODULE_BUILD_TARGETS) t_infos = self.mod_finder.find_test_by_path(class_with_method) unittest_utils.assert_equal_testinfos( self, t_infos[0], uc.PARAMETERIZED_METHOD_INFO) # Input include multiple methods class_with_methods = '%s,%s' % (class_with_method, uc.METHOD2_NAME) mock_build.return_value = copy.deepcopy(uc.MODULE_BUILD_TARGETS) t_infos = self.mod_finder.find_test_by_path(class_with_methods) unittest_utils.assert_equal_testinfos( self, t_infos[0], uc.PARAMETERIZED_FLAT_METHOD_INFO) @mock.patch.object(test_finder_utils, 'find_host_unit_tests', return_value=[]) @mock.patch.object(atest_utils, 'is_build_file', return_value=True) @mock.patch.object(test_finder_utils, 'is_parameterized_java_class', return_value=True) @mock.patch.object(test_finder_utils, 'has_method_in_file', return_value=True) @mock.patch.object(module_finder.ModuleFinder, '_is_vts_module', return_value=False) @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets') @mock.patch('subprocess.check_output', return_value=uc.FIND_ONE) @mock.patch.object(test_finder_utils, 'get_fully_qualified_class_name', return_value=uc.FULL_CLASS_NAME) @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect) @mock.patch('os.path.isdir', return_value=True) #pylint: disable=unused-argument def test_find_test_by_class_name_is_parameterized( self, _isdir, _isfile, _fqcn, mock_checkoutput, mock_build, _vts, _has_method_in_file, _is_parameterized, _is_build_file, _mock_unit_tests): """Test find_test_by_class_name and the class is parameterized java.""" mock_build.return_value = uc.CLASS_BUILD_TARGETS self.mod_finder.module_info.is_auto_gen_test_config.return_value = False self.mod_finder.module_info.is_robolectric_test.return_value = False self.mod_finder.module_info.get_instrumentation_target_apps.return_value = {} self.mod_finder.module_info.has_test_config.return_value = True self.mod_finder.module_info.get_module_names.return_value = [uc.MODULE_NAME] self.mod_finder.module_info.get_module_info.return_value = { constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH, constants.MODULE_NAME: uc.MODULE_NAME, constants.MODULE_CLASS: [], constants.MODULE_COMPATIBILITY_SUITES: []} # With method mock_build.return_value = copy.deepcopy(uc.MODULE_BUILD_TARGETS) self.mod_finder.module_info.get_robolectric_type.return_value = 0 class_with_method = '%s#%s' % (uc.CLASS_NAME, uc.METHOD_NAME) t_infos = self.mod_finder.find_test_by_class_name(class_with_method) unittest_utils.assert_equal_testinfos( self, t_infos[0], uc.PARAMETERIZED_METHOD_INFO) # With multiple method mock_build.return_value = copy.deepcopy(uc.MODULE_BUILD_TARGETS) class_methods = '%s,%s' % (class_with_method, uc.METHOD2_NAME) t_infos = self.mod_finder.find_test_by_class_name(class_methods) unittest_utils.assert_equal_testinfos( self, t_infos[0], uc.PARAMETERIZED_FLAT_METHOD_INFO) # pylint: disable=unused-argument @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets', return_value=copy.deepcopy(uc.MODULE_BUILD_TARGETS)) def test_find_test_by_config_name(self, _get_targ): """Test find_test_by_config_name.""" self.mod_finder.module_info.is_robolectric_test.return_value = False self.mod_finder.module_info.has_test_config.return_value = True mod_info = {'installed': ['/path/to/install'], 'path': [uc.MODULE_DIR], constants.MODULE_TEST_CONFIG: [uc.CONFIG_FILE, uc.EXTRA_CONFIG_FILE], constants.MODULE_CLASS: [], constants.MODULE_COMPATIBILITY_SUITES: []} name_to_module_info = {uc.MODULE_NAME: mod_info} self.mod_finder.module_info.name_to_module_info = name_to_module_info t_infos = self.mod_finder.find_test_by_config_name(uc.MODULE_CONFIG_NAME) unittest_utils.assert_equal_testinfos( self, t_infos[0], uc.TEST_CONFIG_MODULE_INFO) @mock.patch.object(test_finder_utils, 'is_parameterized_java_class', return_value=False) @mock.patch.object(test_finder_utils, 'has_method_in_file', return_value=True) @mock.patch.object(test_finder_utils, 'has_cc_class', return_value=True) @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets') @mock.patch.object(module_finder.ModuleFinder, '_is_vts_module', return_value=False) @mock.patch.object(test_finder_utils, 'get_fully_qualified_class_name', return_value=uc.FULL_CLASS_NAME) @mock.patch('os.path.realpath', side_effect=unittest_utils.realpath_side_effect) @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect) @mock.patch.object(test_finder_utils, 'find_parent_module_dir') @mock.patch('os.path.exists') #pylint: disable=unused-argument def test_find_test_by_path_w_src_verify( self, mock_pathexists, mock_dir, _isfile, _real, _fqcn, _vts, mock_build, _has_cc_class, _has_method_in_file, _is_parameterized): """Test find_test_by_path with src information.""" self.mod_finder.module_info.is_robolectric_test.return_value = False self.mod_finder.module_info.has_test_config.return_value = True self.mod_finder.module_info.get_module_names.return_value = [uc.MODULE_NAME] mock_build.return_value = uc.CLASS_BUILD_TARGETS # Happy path testing. mock_dir.return_value = uc.MODULE_DIR # Test path not in module's src list. class_path = '%s.java' % uc.CLASS_NAME self.mod_finder.module_info.get_module_info.return_value = { constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH, constants.MODULE_NAME: uc.MODULE_NAME, constants.MODULE_CLASS: [], constants.MODULE_COMPATIBILITY_SUITES: [], constants.MODULE_SRCS: ['not_matched_%s' % class_path]} t_infos = self.mod_finder.find_test_by_path(class_path) self.assertEqual(0, len(t_infos)) # Test input file is in module's src list. class_path = '%s.java' % uc.CLASS_NAME self.mod_finder.module_info.get_module_info.return_value = { constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH, constants.MODULE_NAME: uc.MODULE_NAME, constants.MODULE_CLASS: [], constants.MODULE_COMPATIBILITY_SUITES: [], constants.MODULE_SRCS: [class_path]} self.mod_finder.module_info.get_robolectric_type.return_value = 0 self.mod_finder.module_info.get_instrumentation_target_apps.return_value = {} t_infos = self.mod_finder.find_test_by_path(class_path) unittest_utils.assert_equal_testinfos(self, uc.CLASS_INFO, t_infos[0]) @mock.patch.object(test_finder_utils, 'get_cc_class_info') @mock.patch.object(atest_utils, 'is_build_file', return_value=True) @mock.patch.object(test_finder_utils, 'is_parameterized_java_class', return_value=False) @mock.patch.object(test_finder_utils, 'has_method_in_file', return_value=True) @mock.patch.object(test_finder_utils, 'has_cc_class', return_value=True) @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets') @mock.patch.object(module_finder.ModuleFinder, '_is_vts_module', return_value=False) @mock.patch.object(test_finder_utils, 'get_fully_qualified_class_name', return_value=uc.FULL_CLASS_NAME) @mock.patch('os.path.realpath', side_effect=unittest_utils.realpath_side_effect) @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect) @mock.patch.object(test_finder_utils, 'find_parent_module_dir') @mock.patch('os.path.exists') #pylint: disable=unused-argument def test_find_test_by_path_for_cc_file(self, mock_pathexists, mock_dir, _isfile, _real, _fqcn, _vts, mock_build, _has_cc_class, _has_method_in_file, _is_parameterized, _is_build_file, _mock_cc_class_info): """Test find_test_by_path for handling correct CC filter.""" self.mod_finder.module_info.is_robolectric_test.return_value = False self.mod_finder.module_info.has_test_config.return_value = True mock_build.return_value = set() # Check that we don't return anything with invalid test references. mock_pathexists.return_value = False mock_pathexists.return_value = True mock_dir.return_value = None self.mod_finder.module_info.get_module_names.return_value = [uc.MODULE_NAME] self.mod_finder.module_info.get_module_info.return_value = { constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH, constants.MODULE_NAME: uc.MODULE_NAME, constants.MODULE_CLASS: [], constants.MODULE_COMPATIBILITY_SUITES: []} # Happy path testing. mock_dir.return_value = uc.MODULE_DIR # Cc path testing if get_cc_class_info found those information. self.mod_finder.module_info.get_module_names.return_value = [uc.CC_MODULE_NAME] self.mod_finder.module_info.get_module_info.return_value = { constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH, constants.MODULE_NAME: uc.CC_MODULE_NAME, constants.MODULE_CLASS: [], constants.MODULE_COMPATIBILITY_SUITES: []} mock_dir.return_value = uc.CC_MODULE_DIR class_path = '%s' % uc.CC_PATH mock_build.return_value = uc.CLASS_BUILD_TARGETS # Test without parameterized test founded_classed = 'class1' founded_methods = {'method1'} founded_prefixes = set() _mock_cc_class_info.return_value = {founded_classed: { 'methods': founded_methods, 'prefixes': founded_prefixes, 'typed': False}} self.mod_finder.module_info.get_robolectric_type.return_value = 0 self.mod_finder.module_info.get_instrumentation_target_apps.return_value = {} cc_path_data = {constants.TI_REL_CONFIG: uc.CC_CONFIG_FILE, constants.TI_FILTER: frozenset( {test_info.TestFilter(class_name='class1.*', methods=frozenset())})} cc_path_info = test_info.TestInfo(uc.CC_MODULE_NAME, atf_tr.AtestTradefedTestRunner.NAME, uc.CLASS_BUILD_TARGETS, cc_path_data) t_infos = self.mod_finder.find_test_by_path(class_path) unittest_utils.assert_equal_testinfos(self, cc_path_info, t_infos[0]) # Test with paramertize test defined in input path founded_prefixes = {'class1'} _mock_cc_class_info.return_value = {founded_classed: { 'methods': founded_methods, 'prefixes': founded_prefixes, 'typed': False}} cc_path_data = {constants.TI_REL_CONFIG: uc.CC_CONFIG_FILE, constants.TI_FILTER: frozenset( {test_info.TestFilter(class_name='*/class1.*', methods=frozenset())})} cc_path_info = test_info.TestInfo(uc.CC_MODULE_NAME, atf_tr.AtestTradefedTestRunner.NAME, uc.CLASS_BUILD_TARGETS, cc_path_data) t_infos = self.mod_finder.find_test_by_path(class_path) unittest_utils.assert_equal_testinfos(self, cc_path_info, t_infos[0]) # pylint: disable=unused-argument @mock.patch.object(module_finder.ModuleFinder, '_is_vts_module', return_value=False) @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets', return_value=copy.deepcopy(uc.MODULE_BUILD_TARGETS)) def test_process_test_info(self, _get_targ, _is_vts): """Test _process_test_info.""" mod_info = {'installed': ['/path/to/install'], 'path': [uc.MODULE_DIR], constants.MODULE_CLASS: [ constants.MODULE_CLASS_JAVA_LIBRARIES], constants.MODULE_COMPATIBILITY_SUITES: []} self.mod_finder.module_info.is_robolectric_test.return_value = False self.mod_finder.module_info.is_auto_gen_test_config.return_value = True self.mod_finder.module_info.get_robolectric_type.return_value = 0 self.mod_finder.module_info.get_instrumentation_target_apps.return_value = {} self.mod_finder.module_info.get_module_info.return_value = mod_info processed_info = self.mod_finder._process_test_info( copy.deepcopy(uc.MODULE_INFO)) unittest_utils.assert_equal_testinfos( self, processed_info, uc.MODULE_INFO_W_DALVIK) # pylint: disable=unused-argument @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets') @mock.patch.object(module_info.ModuleInfo, 'get_instrumentation_target_apps') @mock.patch.object(module_info.ModuleInfo, 'get_robolectric_type') @mock.patch.object(module_info.ModuleInfo, 'is_testable_module') def test_process_test_info_with_instrumentation_target_apps( self, testable, robotype, tapps, btargets): """Test _process_test_info.""" testable.return_value = True robotype.return_value = 0 target_module = 'AmSlam' test_module = 'AmSlamTests' artifact_path = '/out/somewhere/app/AmSlam.apk' tapps.return_value = {target_module: {artifact_path}} btargets.return_value = {target_module} self.mod_finder.module_info.is_auto_gen_test_config.return_value = True self.mod_finder.module_info.get_robolectric_type.return_value = 0 test1 = module(name=target_module, classes=['APPS'], path=['foo/bar/AmSlam'], installed=[artifact_path]) test2 = module(name=test_module, classes=['APPS'], path=['foo/bar/AmSlam/test'], installed=['/out/somewhere/app/AmSlamTests.apk']) info = test_info.TestInfo(test_module, atf_tr.AtestTradefedTestRunner.NAME, set(), {constants.TI_REL_CONFIG: uc.CONFIG_FILE, constants.TI_FILTER: frozenset()}) self.mod_finder.module_info = create_module_info([test1, test2]) t_infos = self.mod_finder._process_test_info(info) self.assertTrue(target_module in t_infos.build_targets) self.assertEqual([artifact_path], t_infos.artifacts) @mock.patch.object(test_finder_utils, 'get_annotated_methods') def test_is_srcs_match_method_annotation_include_anno( self, _mock_get_anno_methods): """Test _is_srcs_match_method_annotation with include annotation.""" annotation_dict = {constants.INCLUDE_ANNOTATION: 'includeAnnotation1'} input_method = 'my_input_method' input_srcs = ['src1'] # Test if input method matched include annotation. _mock_get_anno_methods.return_value = {input_method, 'not_my_input_method'} is_matched = self.mod_finder._is_srcs_match_method_annotation( input_method, input_srcs, annotation_dict) self.assertTrue(is_matched) # Test if input method not matched include annotation. _mock_get_anno_methods.return_value = {'not_my_input_method'} is_matched = self.mod_finder._is_srcs_match_method_annotation( input_method, input_srcs, annotation_dict) self.assertFalse(is_matched) @mock.patch.object(test_finder_utils, 'get_annotated_methods') @mock.patch.object(test_finder_utils, 'get_java_methods') def test_is_srcs_match_method_exclude_anno(self, _mock_get_java_methods, _mock_get_exclude_anno_methods): """Test _is_srcs_match_method_annotation with exclude annotation.""" annotation_dict = {constants.EXCLUDE_ANNOTATION: 'excludeAnnotation1'} input_method = 'my_input_method' input_srcs = ['src1'] _mock_get_java_methods.return_value = {input_method, 'method1', 'method2'} # Test if input method matched exclude annotation. _mock_get_exclude_anno_methods.return_value = {input_method, 'method1'} is_matched = self.mod_finder._is_srcs_match_method_annotation( input_method, input_srcs, annotation_dict) self.assertFalse(is_matched) # Test if input method not matched exclude annotation. _mock_get_exclude_anno_methods.return_value = {'method2'} is_matched = self.mod_finder._is_srcs_match_method_annotation( input_method, input_srcs, annotation_dict) self.assertTrue(is_matched) @mock.patch.object(atest_utils, 'get_android_junit_config_filters') @mock.patch.object(test_finder_utils, 'get_test_config_and_srcs') def test_get_matched_test_infos_no_filter(self, _mock_get_conf_srcs, _mock_get_filters): """Test _get_matched_test_infos without test filters.""" test_info1 = 'test_info1' test_infos = [test_info1] test_config = 'test_config' test_srcs = ['src1', 'src2'] _mock_get_conf_srcs.return_value = test_config, test_srcs filter_dict = {} _mock_get_filters.return_value = filter_dict self.assertEqual( self.mod_finder._get_matched_test_infos(test_infos, {'method'}), test_infos) @mock.patch.object(module_finder.ModuleFinder, '_is_srcs_match_method_annotation') @mock.patch.object(atest_utils, 'get_android_junit_config_filters') @mock.patch.object(test_finder_utils, 'get_test_config_and_srcs') def test_get_matched_test_infos_get_filter_method_match( self, _mock_get_conf_srcs, _mock_get_filters, _mock_method_match): """Test _get_matched_test_infos with test filters and method match.""" test_infos = [KERNEL_MODULE_CLASS_INFO] test_config = 'test_config' test_srcs = ['src1', 'src2'] _mock_get_conf_srcs.return_value = test_config, test_srcs filter_dict = {'include-annotation': 'annotate1'} _mock_get_filters.return_value = filter_dict _mock_method_match.return_value = True unittest_utils.assert_strict_equal( self, self.mod_finder._get_matched_test_infos(test_infos, {'method'}), test_infos) @mock.patch.object(module_finder.ModuleFinder, '_is_srcs_match_method_annotation') @mock.patch.object(atest_utils, 'get_android_junit_config_filters') @mock.patch.object(test_finder_utils, 'get_test_config_and_srcs') def test_get_matched_test_infos_filter_method_not_match( self, _mock_get_conf_srcs, _mock_get_filters, _mock_method_match): """Test _get_matched_test_infos but method not match.""" test_infos = [KERNEL_MODULE_CLASS_INFO] test_config = 'test_config' test_srcs = ['src1', 'src2'] _mock_get_conf_srcs.return_value = test_config, test_srcs filter_dict = {'include-annotation': 'annotate1'} _mock_get_filters.return_value = filter_dict _mock_method_match.return_value = False self.assertEqual( self.mod_finder._get_matched_test_infos(test_infos, {'method'}), []) @mock.patch.object(module_finder.ModuleFinder, '_get_matched_test_infos') @mock.patch.object(module_finder.ModuleFinder, '_get_test_infos', return_value=uc.MODULE_INFO) @mock.patch.object(module_finder.ModuleFinder, '_get_test_info_filter', return_value=uc.CLASS_FILTER) @mock.patch.object(test_finder_utils, 'find_class_file', return_value=['path1']) def test_find_test_by_class_name_not_matched_filters( self, _mock_class_path, _mock_test_filters, _mock_test_infos, _mock_matched_test_infos): """Test find_test_by_class_name which has not matched filters.""" found_test_infos = [uc.MODULE_INFO, uc.MODULE_INFO2] _mock_test_infos.return_value = found_test_infos matched_test_infos = [uc.MODULE_INFO2] _mock_matched_test_infos.return_value = matched_test_infos # Test if class without method test_infos = self.mod_finder.find_test_by_class_name('my.test.class') self.assertEqual(len(test_infos), 2) unittest_utils.assert_equal_testinfos( self, test_infos[0], uc.MODULE_INFO) unittest_utils.assert_equal_testinfos( self, test_infos[1], uc.MODULE_INFO2) # Test if class with method test_infos = self.mod_finder.find_test_by_class_name( 'my.test.class#myMethod') self.assertEqual(len(test_infos), 1) unittest_utils.assert_equal_testinfos( self, test_infos[0], uc.MODULE_INFO2) @mock.patch.object(module_finder.ModuleFinder, '_get_test_infos', return_value=None) @mock.patch.object(module_finder.ModuleFinder, '_get_test_info_filter', return_value=uc.CLASS_FILTER) @mock.patch.object(test_finder_utils, 'find_class_file', return_value=['path1']) def test_find_test_by_class_name_get_test_infos_none( self, _mock_class_path, _mock_test_filters, _mock_test_infos): """Test find_test_by_class_name which has not matched test infos.""" self.assertEqual( self.mod_finder.find_test_by_class_name('my.test.class'), None) def create_empty_module_info(): with fake_filesystem_unittest.Patcher() as patcher: # pylint: disable=protected-access fake_temp_file_name = next(tempfile._get_candidate_names()) patcher.fs.create_file(fake_temp_file_name, contents='{}') return module_info.ModuleInfo(module_file=fake_temp_file_name) def create_module_info(modules=None): mod_info = create_empty_module_info() modules = modules or [] for m in modules: mod_info.name_to_module_info[m['module_name']] = m return mod_info # pylint: disable=too-many-arguments def module( name=None, path=None, installed=None, classes=None, auto_test_config=None, shared_libs=None, dependencies=None, runtime_dependencies=None, data=None, data_dependencies=None, compatibility_suites=None, host_dependencies=None, srcs=None, ): name = name or 'libhello' m = {} m['module_name'] = name m['class'] = classes m['path'] = [path or ''] m['installed'] = installed or [] m['is_unit_test'] = 'false' m['auto_test_config'] = auto_test_config or [] m['shared_libs'] = shared_libs or [] m['runtime_dependencies'] = runtime_dependencies or [] m['dependencies'] = dependencies or [] m['data'] = data or [] m['data_dependencies'] = data_dependencies or [] m['compatibility_suites'] = compatibility_suites or [] m['host_dependencies'] = host_dependencies or [] m['srcs'] = srcs or [] return m # pylint: disable=too-many-locals def create_test_info(**kwargs): test_name = kwargs.pop('test_name') test_runner = kwargs.pop('test_runner') build_targets = kwargs.pop('build_targets') data = kwargs.pop('data', None) suite = kwargs.pop('suite', None) module_class = kwargs.pop('module_class', None) install_locations = kwargs.pop('install_locations', None) test_finder = kwargs.pop('test_finder', '') compatibility_suites = kwargs.pop('compatibility_suites', None) t_info = test_info.TestInfo( test_name=test_name, test_runner=test_runner, build_targets=build_targets, data=data, suite=suite, module_class=module_class, install_locations=install_locations, test_finder=test_finder, compatibility_suites=compatibility_suites ) raw_test_name = kwargs.pop('raw_test_name', None) if raw_test_name: t_info.raw_test_name = raw_test_name artifacts = kwargs.pop('artifacts', set()) if artifacts: t_info.artifacts = artifacts robo_type = kwargs.pop('robo_type', None) if robo_type: t_info.robo_type = robo_type mainline_modules = kwargs.pop('mainline_modules', set()) if mainline_modules: t_info._mainline_modules = mainline_modules for keyword in ['from_test_mapping', 'host', 'aggregate_metrics_result']: value = kwargs.pop(keyword, 'None') if isinstance(value, bool): setattr(t_info, keyword, value) if kwargs: assert f'Unknown keyword(s) for test_info: {kwargs.keys()}' return t_info if __name__ == '__main__': unittest.main()