1#!/usr/bin/env python3 2# 3# Copyright 2018, The Android Open Source Project 4# 5# Licensed under the Apache License, Version 2.0 (the "License"); 6# you may not use this file except in compliance with the License. 7# You may obtain a copy of the License at 8# 9# http://www.apache.org/licenses/LICENSE-2.0 10# 11# Unless required by applicable law or agreed to in writing, software 12# distributed under the License is distributed on an "AS IS" BASIS, 13# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14# See the License for the specific language governing permissions and 15# limitations under the License. 16 17"""Unittests for source_locator.""" 18 19import os 20import shutil 21import tempfile 22import unittest 23from unittest import mock 24 25from aidegen import constant 26from aidegen import unittest_constants as uc 27from aidegen.lib import source_locator 28 29_MODULE_NAME = 'test' 30_MODULE_PATH = 'packages/apps/test' 31_MODULE_INFO = { 32 'path': [_MODULE_PATH], 33 'srcs': [ 34 'packages/apps/test/src/main/java/com/android/java.java', 35 'packages/apps/test/tests/com/android/test.java', 36 'packages/apps/test/tests/test.srcjar' 37 ], 38 'dependencies': [], 39 'installed': [] 40} 41_MODULE_DEPTH = 0 42 43 44# pylint: disable=protected-access 45# pylint: disable=invalid-name 46class SourceLocatorUnittests(unittest.TestCase): 47 """Unit tests for source_locator.py""" 48 49 def test_collect_srcs_paths(self): 50 """Test _collect_srcs_paths create the source path list.""" 51 result_source = set(['packages/apps/test/src/main/java']) 52 result_test = set(['packages/apps/test/tests']) 53 constant.ANDROID_ROOT_PATH = uc.TEST_DATA_PATH 54 module_data = source_locator.ModuleData(_MODULE_NAME, _MODULE_INFO, 55 _MODULE_DEPTH) 56 module_data._collect_srcs_paths() 57 self.assertEqual(module_data.src_dirs, result_source) 58 self.assertEqual(module_data.test_dirs, result_test) 59 60 def test_get_source_folder(self): 61 """Test _get_source_folder process.""" 62 # Test for getting the source path by parse package name from a java. 63 test_java = 'packages/apps/test/src/main/java/com/android/java.java' 64 result_source = 'packages/apps/test/src/main/java' 65 constant.ANDROID_ROOT_PATH = uc.TEST_DATA_PATH 66 module_data = source_locator.ModuleData(_MODULE_NAME, _MODULE_INFO, 67 _MODULE_DEPTH) 68 src_path = module_data._get_source_folder(test_java) 69 self.assertEqual(src_path, result_source) 70 71 # Return path is None if the java file doesn't exist. 72 test_java = 'file_not_exist.java' 73 src_path = module_data._get_source_folder(test_java) 74 self.assertEqual(src_path, None) 75 76 # Return path is None on the java file without package name. 77 test_java = ('packages/apps/test/src/main/java/com/android/' 78 'wrong_package.java') 79 src_path = module_data._get_source_folder(test_java) 80 self.assertEqual(src_path, None) 81 82 def test_append_jar_file(self): 83 """Test _append_jar_file process.""" 84 # Append an existing jar file path to module_data.jar_files. 85 test_jar_file = os.path.join(_MODULE_PATH, 'test.jar') 86 result_jar_list = set([test_jar_file]) 87 constant.ANDROID_ROOT_PATH = uc.TEST_DATA_PATH 88 module_data = source_locator.ModuleData(_MODULE_NAME, _MODULE_INFO, 89 _MODULE_DEPTH) 90 module_data._append_jar_file(test_jar_file) 91 self.assertEqual(module_data.jar_files, result_jar_list) 92 93 # Skip if the jar file doesn't exist. 94 test_jar_file = os.path.join(_MODULE_PATH, 'jar_not_exist.jar') 95 module_data.jar_files = set() 96 module_data._append_jar_file(test_jar_file) 97 self.assertEqual(module_data.jar_files, set()) 98 99 # Skip if it's not a jar file. 100 test_jar_file = os.path.join(_MODULE_PATH, 'test.java') 101 module_data.jar_files = set() 102 module_data._append_jar_file(test_jar_file) 103 self.assertEqual(module_data.jar_files, set()) 104 105 def test_append_jar_from_installed(self): 106 """Test _append_jar_from_installed handling.""" 107 # Test appends the first jar file of 'installed'. 108 module_info = dict(_MODULE_INFO) 109 module_info['installed'] = [ 110 os.path.join(_MODULE_PATH, 'test.aar'), 111 os.path.join(_MODULE_PATH, 'test.jar'), 112 os.path.join(_MODULE_PATH, 'tests/test_second.jar') 113 ] 114 result_jar_list = set([os.path.join(_MODULE_PATH, 'test.jar')]) 115 constant.ANDROID_ROOT_PATH = uc.TEST_DATA_PATH 116 module_data = source_locator.ModuleData(_MODULE_NAME, module_info, 117 _MODULE_DEPTH) 118 module_data._append_jar_from_installed() 119 self.assertEqual(module_data.jar_files, result_jar_list) 120 121 # Test on the jar file path matches the path prefix. 122 module_data.jar_files = set() 123 result_jar_list = set( 124 [os.path.join(_MODULE_PATH, 'tests/test_second.jar')]) 125 module_data._append_jar_from_installed( 126 os.path.join(_MODULE_PATH, 'tests/')) 127 self.assertEqual(module_data.jar_files, result_jar_list) 128 129 def test_set_jars_jarfile(self): 130 """Test _set_jars_jarfile handling.""" 131 # Combine the module path with jar file name in 'jars' and then append 132 # it to module_data.jar_files. 133 module_info = dict(_MODULE_INFO) 134 module_info['jars'] = [ 135 'test.jar', 136 'src/test.jar', # This jar file doesn't exist. 137 'tests/test_second.jar' 138 ] 139 result_jar_list = set([ 140 os.path.join(_MODULE_PATH, 'test.jar'), 141 os.path.join(_MODULE_PATH, 'tests/test_second.jar') 142 ]) 143 constant.ANDROID_ROOT_PATH = uc.TEST_DATA_PATH 144 module_data = source_locator.ModuleData(_MODULE_NAME, module_info, 145 _MODULE_DEPTH) 146 module_data._set_jars_jarfile() 147 self.assertEqual(module_data.jar_files, result_jar_list) 148 149 def test_locate_sources_path(self): 150 """Test locate_sources_path handling.""" 151 # Test collect source path. 152 module_info = dict(_MODULE_INFO) 153 result_src_list = set(['packages/apps/test/src/main/java', 154 'out/target/common/R']) 155 result_test_list = set(['packages/apps/test/tests']) 156 result_jar_list = set() 157 constant.ANDROID_ROOT_PATH = uc.TEST_DATA_PATH 158 module_data = source_locator.ModuleData(_MODULE_NAME, module_info, 159 _MODULE_DEPTH) 160 module_data.locate_sources_path() 161 self.assertEqual(module_data.src_dirs, result_src_list) 162 self.assertEqual(module_data.test_dirs, result_test_list) 163 self.assertEqual(module_data.jar_files, result_jar_list) 164 165 # Test find jar files. 166 jar_file = ('out/soong/.intermediates/packages/apps/test/test/' 167 'android_common/test.jar') 168 module_info['jarjar_rules'] = ['jarjar-rules.txt'] 169 module_info['installed'] = [jar_file] 170 result_jar_list = set([jar_file]) 171 module_data = source_locator.ModuleData(_MODULE_NAME, module_info, 172 _MODULE_DEPTH) 173 module_data.locate_sources_path() 174 self.assertEqual(module_data.jar_files, result_jar_list) 175 176 # Test find jar by srcjar. 177 module_info = dict(_MODULE_INFO) 178 module_info['srcs'].extend( 179 [('out/soong/.intermediates/packages/apps/test/test/android_common/' 180 'gen/test.srcjar')]) 181 module_info['installed'] = [ 182 ('out/soong/.intermediates/packages/apps/test/test/android_common/' 183 'test.jar') 184 ] 185 result_jar_list = set([ 186 jar_file, 187 ('out/soong/.intermediates/packages/apps/test/test/' 188 'android_common/test.jar') 189 ]) 190 module_data = source_locator.ModuleData(_MODULE_NAME, module_info, 191 _MODULE_DEPTH) 192 module_data.locate_sources_path() 193 self.assertEqual(module_data.jar_files, result_jar_list) 194 195 def test_collect_jar_by_depth_value(self): 196 """Test parameter --depth handling.""" 197 # Test find jar by module's depth greater than the --depth value from 198 # command line. 199 depth_by_source = 2 200 module_info = dict(_MODULE_INFO) 201 module_info['depth'] = 3 202 module_info['installed'] = [ 203 ('out/soong/.intermediates/packages/apps/test/test/android_common/' 204 'test.jar') 205 ] 206 result_src_list = set() 207 result_jar_list = set( 208 [('out/soong/.intermediates/packages/apps/test/test/' 209 'android_common/test.jar')]) 210 constant.ANDROID_ROOT_PATH = uc.TEST_DATA_PATH 211 module_data = source_locator.ModuleData(_MODULE_NAME, module_info, 212 depth_by_source) 213 module_data.locate_sources_path() 214 self.assertEqual(module_data.src_dirs, result_src_list) 215 self.assertEqual(module_data.jar_files, result_jar_list) 216 217 # Test find source folder when module's depth equal to the --depth value 218 # from command line. 219 depth_by_source = 2 220 module_info = dict(_MODULE_INFO) 221 module_info['depth'] = 2 222 result_src_list = set(['packages/apps/test/src/main/java', 223 'out/target/common/R']) 224 result_test_list = set(['packages/apps/test/tests']) 225 result_jar_list = set() 226 module_data = source_locator.ModuleData(_MODULE_NAME, module_info, 227 depth_by_source) 228 module_data.locate_sources_path() 229 self.assertEqual(module_data.src_dirs, result_src_list) 230 self.assertEqual(module_data.test_dirs, result_test_list) 231 self.assertEqual(module_data.jar_files, result_jar_list) 232 233 # Test find source folder when module's depth smaller than the --depth 234 # value from command line. 235 depth_by_source = 3 236 module_info = dict(_MODULE_INFO) 237 module_info['depth'] = 2 238 result_src_list = set(['packages/apps/test/src/main/java', 239 'out/target/common/R']) 240 result_test_list = set(['packages/apps/test/tests']) 241 result_jar_list = set() 242 module_data = source_locator.ModuleData(_MODULE_NAME, module_info, 243 depth_by_source) 244 module_data.locate_sources_path() 245 self.assertEqual(module_data.src_dirs, result_src_list) 246 self.assertEqual(module_data.test_dirs, result_test_list) 247 self.assertEqual(module_data.jar_files, result_jar_list) 248 249 @mock.patch('aidegen.lib.project_info.ProjectInfo') 250 @mock.patch('atest.atest_utils.build') 251 def test_locate_source(self, mock_atest_utils_build, mock_project_info): 252 """Test locate_source handling.""" 253 mock_atest_utils_build.build.return_value = True 254 test_root_path = os.path.join(tempfile.mkdtemp(), 'test') 255 shutil.copytree(uc.TEST_DATA_PATH, test_root_path) 256 constant.ANDROID_ROOT_PATH = test_root_path 257 generated_jar = ('out/soong/.intermediates/packages/apps/test/test/' 258 'android_common/generated.jar') 259 module_info = dict(_MODULE_INFO) 260 module_info['srcs'].extend( 261 [('out/soong/.intermediates/packages/apps/test/test/android_common/' 262 'gen/test.srcjar')]) 263 module_info['installed'] = [generated_jar] 264 mock_project_info.dep_modules = {'test': module_info} 265 mock_project_info.source_path = { 266 'source_folder_path': set(), 267 'test_folder_path': set(), 268 'jar_path': set(), 269 'jar_module_path': dict(), 270 } 271 # Show warning when the jar not exists after build the module. 272 result_jar = set() 273 source_locator.locate_source(mock_project_info, False, 0, 274 constant.IDE_INTELLIJ, True) 275 self.assertEqual(mock_project_info.source_path['jar_path'], result_jar) 276 277 # Test on jar exists. 278 jar_abspath = os.path.join(test_root_path, generated_jar) 279 result_jar = set([generated_jar]) 280 result_jar_module_path = dict({generated_jar: module_info['path'][0]}) 281 try: 282 open(jar_abspath, 'w').close() 283 source_locator.locate_source(mock_project_info, False, 0, 284 constant.IDE_INTELLIJ, False) 285 self.assertEqual(mock_project_info.source_path['jar_path'], 286 result_jar) 287 self.assertEqual(mock_project_info.source_path['jar_module_path'], 288 result_jar_module_path) 289 finally: 290 shutil.rmtree(test_root_path) 291 292 # Test collects source and test folders. 293 result_source = set(['packages/apps/test/src/main/java', 294 'out/target/common/R']) 295 result_test = set(['packages/apps/test/tests']) 296 self.assertEqual(mock_project_info.source_path['source_folder_path'], 297 result_source) 298 self.assertEqual(mock_project_info.source_path['test_folder_path'], 299 result_test) 300 301 # Test loading jar from dependencies parameter. 302 default_jar = os.path.join(_MODULE_PATH, 'test.jar') 303 module_info['dependencies'] = [default_jar] 304 result_jar = set([generated_jar, default_jar]) 305 source_locator.locate_source(mock_project_info, False, 0, 306 constant.IDE_INTELLIJ, False) 307 self.assertEqual(mock_project_info.source_path['jar_path'], result_jar) 308 309 310if __name__ == '__main__': 311 unittest.main() 312