1478 lines
75 KiB
Python
Executable File
1478 lines
75 KiB
Python
Executable File
#!/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=('''
|
|
<target_preparer class="com.android.tradefed.targetprep.suite.SuiteApkInstaller">
|
|
<option name="test-file-name" value="CtsUiDeviceTestCases.apk" />
|
|
</target_preparer>
|
|
''')
|
|
)
|
|
|
|
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=('''
|
|
<target_preparer class="com.android.tradefed.targetprep.suite.SuiteApkInstaller">
|
|
<option name="test-file-name" value="CtsUiDeviceTestCases.apk" />
|
|
</target_preparer>
|
|
''')
|
|
)
|
|
|
|
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()
|