# 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. """ Module Info class used to hold cached module-info.json. """ import json import logging import os import atest_utils import constants # JSON file generated by build system that lists all buildable targets. _MODULE_INFO = 'module-info.json' class ModuleInfo(object): """Class that offers fast/easy lookup for Module related details.""" def __init__(self, force_build=False, module_file=None): """Initialize the ModuleInfo object. Load up the module-info.json file and initialize the helper vars. Args: force_build: Boolean to indicate if we should rebuild the module_info file regardless if it's created or not. module_file: String of path to file to load up. Used for testing. """ module_info_target, name_to_module_info = self._load_module_info_file( force_build, module_file) self.name_to_module_info = name_to_module_info self.module_info_target = module_info_target self.path_to_module_info = self._get_path_to_module_info( self.name_to_module_info) self.root_dir = os.environ.get(constants.ANDROID_BUILD_TOP) @staticmethod def _discover_mod_file_and_target(force_build): """Find the module file. Args: force_build: Boolean to indicate if we should rebuild the module_info file regardless if it's created or not. Returns: Tuple of module_info_target and path to module file. """ module_info_target = None root_dir = os.environ.get(constants.ANDROID_BUILD_TOP, '/') out_dir = os.environ.get(constants.ANDROID_PRODUCT_OUT, root_dir) module_file_path = os.path.join(out_dir, _MODULE_INFO) # Check if the user set a custom out directory by comparing the out_dir # to the root_dir. if out_dir.find(root_dir) == 0: # Make target is simply file path relative to root module_info_target = os.path.relpath(module_file_path, root_dir) else: # If the user has set a custom out directory, generate an absolute # path for module info targets. logging.debug('User customized out dir!') module_file_path = os.path.join( os.environ.get(constants.ANDROID_PRODUCT_OUT), _MODULE_INFO) module_info_target = module_file_path if not os.path.isfile(module_file_path) or force_build: logging.debug('Generating %s - this is required for ' 'initial runs.', _MODULE_INFO) build_env = dict(constants.ATEST_BUILD_ENV) atest_utils.build([module_info_target], verbose=logging.getLogger().isEnabledFor(logging.DEBUG), env_vars=build_env) return module_info_target, module_file_path def _load_module_info_file(self, force_build, module_file): """Load the module file. Args: force_build: Boolean to indicate if we should rebuild the module_info file regardless if it's created or not. module_file: String of path to file to load up. Used for testing. Returns: Tuple of module_info_target and dict of json. """ # If module_file is specified, we're testing so we don't care if # module_info_target stays None. module_info_target = None file_path = module_file if not file_path: module_info_target, file_path = self._discover_mod_file_and_target( force_build) with open(file_path) as json_file: mod_info = json.load(json_file) return module_info_target, mod_info @staticmethod def _get_path_to_module_info(name_to_module_info): """Return the path_to_module_info dict. Args: name_to_module_info: Dict of module name to module info dict. Returns: Dict of module path to module info dict. """ path_to_module_info = {} for mod_name, mod_info in name_to_module_info.items(): # Cross-compiled and multi-arch modules actually all belong to # a single target so filter out these extra modules. if mod_name != mod_info.get(constants.MODULE_NAME, ''): continue for path in mod_info.get(constants.MODULE_PATH, []): mod_info[constants.MODULE_NAME] = mod_name # There could be multiple modules in a path. if path in path_to_module_info: path_to_module_info[path].append(mod_info) else: path_to_module_info[path] = [mod_info] return path_to_module_info def is_module(self, name): """Return True if name is a module, False otherwise.""" return name in self.name_to_module_info def get_paths(self, name): """Return paths of supplied module name, Empty list if non-existent.""" info = self.name_to_module_info.get(name) if info: return info.get(constants.MODULE_PATH, []) return [] def get_module_names(self, rel_module_path): """Get the modules that all have module_path. Args: rel_module_path: path of module in module-info.json Returns: List of module names. """ return [m.get(constants.MODULE_NAME) for m in self.path_to_module_info.get(rel_module_path, [])] def get_module_info(self, mod_name): """Return dict of info for given module name, None if non-existent.""" module_info = self.name_to_module_info.get(mod_name) # Android's build system will automatically adding 2nd arch bitness # string at the end of the module name which will make atest could not # finding matched module. Rescan the module-info with matched module # name without bitness. if not module_info: for _, module_info in self.name_to_module_info.items(): if mod_name == module_info.get(constants.MODULE_NAME, ''): break return module_info def is_suite_in_compatibility_suites(self, suite, mod_info): """Check if suite exists in the compatibility_suites of module-info. Args: suite: A string of suite name. mod_info: Dict of module info to check. Returns: True if it exists in mod_info, False otherwise. """ return suite in mod_info.get(constants.MODULE_COMPATIBILITY_SUITES, []) def get_testable_modules(self, suite=None): """Return the testable modules of the given suite name. Args: suite: A string of suite name. Set to None to return all testable modules. Returns: List of testable modules. Empty list if non-existent. If suite is None, return all the testable modules in module-info. """ modules = set() for _, info in self.name_to_module_info.items(): if self.is_testable_module(info): if suite: if self.is_suite_in_compatibility_suites(suite, info): modules.add(info.get(constants.MODULE_NAME)) else: modules.add(info.get(constants.MODULE_NAME)) return modules def is_testable_module(self, mod_info): """Check if module is something we can test. A module is testable if: - it's installed, or - it's a robolectric module (or shares path with one). Args: mod_info: Dict of module info to check. Returns: True if we can test this module, False otherwise. """ if not mod_info: return False if mod_info.get(constants.MODULE_INSTALLED) and self.has_test_config(mod_info): return True if self.is_robolectric_test(mod_info.get(constants.MODULE_NAME)): return True return False def has_test_config(self, mod_info): """Validate if this module has a test config. A module can have a test config in the following manner: - AndroidTest.xml at the module path. - test_config be set in module-info.json. - Auto-generated config via the auto_test_config key in module-info.json. Args: mod_info: Dict of module info to check. Returns: True if this module has a test config, False otherwise. """ # Check if test_config in module-info is set. for test_config in mod_info.get(constants.MODULE_TEST_CONFIG, []): if os.path.isfile(os.path.join(self.root_dir, test_config)): return True # Check for AndroidTest.xml at the module path. for path in mod_info.get(constants.MODULE_PATH, []): if os.path.isfile(os.path.join(self.root_dir, path, constants.MODULE_CONFIG)): return True # Check if the module has an auto-generated config. return self.is_auto_gen_test_config(mod_info.get(constants.MODULE_NAME)) def get_robolectric_test_name(self, module_name): """Returns runnable robolectric module name. There are at least 2 modules in every robolectric module path, return the module that we can run as a build target. Arg: module_name: String of module. Returns: String of module that is the runnable robolectric module, None if none could be found. """ module_name_info = self.name_to_module_info.get(module_name) if not module_name_info: return None module_paths = module_name_info.get(constants.MODULE_PATH, []) if module_paths: for mod in self.get_module_names(module_paths[0]): mod_info = self.get_module_info(mod) if self.is_robolectric_module(mod_info): return mod return None def is_robolectric_test(self, module_name): """Check if module is a robolectric test. A module can be a robolectric test if the specified module has their class set as ROBOLECTRIC (or shares their path with a module that does). Args: module_name: String of module to check. Returns: True if the module is a robolectric module, else False. """ # Check 1, module class is ROBOLECTRIC mod_info = self.get_module_info(module_name) if self.is_robolectric_module(mod_info): return True # Check 2, shared modules in the path have class ROBOLECTRIC_CLASS. if self.get_robolectric_test_name(module_name): return True return False def is_auto_gen_test_config(self, module_name): """Check if the test config file will be generated automatically. Args: module_name: A string of the module name. Returns: True if the test config file will be generated automatically. """ if self.is_module(module_name): mod_info = self.name_to_module_info.get(module_name) auto_test_config = mod_info.get('auto_test_config', []) return auto_test_config and auto_test_config[0] return False def is_robolectric_module(self, mod_info): """Check if a module is a robolectric module. Args: mod_info: ModuleInfo to check. Returns: True if module is a robolectric module, False otherwise. """ if mod_info: return (mod_info.get(constants.MODULE_CLASS, [None])[0] == constants.MODULE_CLASS_ROBOLECTRIC) return False def is_native_test(self, module_name): """Check if the input module is a native test. Args: module_name: A string of the module name. Returns: True if the test is a native test, False otherwise. """ mod_info = self.get_module_info(module_name) return constants.MODULE_CLASS_NATIVE_TESTS in mod_info.get( constants.MODULE_CLASS, [])