#!/usr/bin/env python3
#
# Copyright 2020, 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 IML class."""
import os
import shutil
import tempfile
import unittest
from unittest import mock
from aidegen import templates
from aidegen.lib import common_util
from aidegen.idea import iml
from atest import module_info
# pylint: disable=protected-access
class IMLGenUnittests(unittest.TestCase):
"""Unit tests for IMLGenerator class."""
_TEST_DIR = None
def setUp(self):
"""Prepare the testdata related path."""
IMLGenUnittests._TEST_DIR = tempfile.mkdtemp()
module = {
'module_name': 'test',
'iml_name': 'test_iml',
'path': ['a/b'],
'srcs': ['a/b/src'],
'tests': ['a/b/tests'],
'srcjars': ['x/y.srcjar'],
'jars': ['s.jar'],
'dependencies': ['m1']
}
with mock.patch.object(common_util, 'get_android_root_dir') as obj:
obj.return_value = IMLGenUnittests._TEST_DIR
self.iml = iml.IMLGenerator(module)
def tearDown(self):
"""Clear the testdata related path."""
self.iml = None
shutil.rmtree(IMLGenUnittests._TEST_DIR)
def test_init(self):
"""Test initialize the attributes."""
self.assertEqual(self.iml._mod_info['module_name'], 'test')
@mock.patch.object(common_util, 'get_android_root_dir')
def test_iml_path(self, mock_root_path):
"""Test iml_path."""
mock_root_path.return_value = IMLGenUnittests._TEST_DIR
iml_path = os.path.join(IMLGenUnittests._TEST_DIR, 'a/b/test_iml.iml')
self.assertEqual(self.iml.iml_path, iml_path)
@mock.patch.object(common_util, 'get_android_root_dir')
def test_create(self, mock_root_path):
"""Test create."""
mock_root_path.return_value = IMLGenUnittests._TEST_DIR
module_path = os.path.join(IMLGenUnittests._TEST_DIR, 'a/b')
src_path = os.path.join(IMLGenUnittests._TEST_DIR, 'a/b/src')
test_path = os.path.join(IMLGenUnittests._TEST_DIR, 'a/b/tests')
srcjar_path = os.path.join(IMLGenUnittests._TEST_DIR, 'x/y.srcjar')
jar_path = os.path.join(IMLGenUnittests._TEST_DIR, 's.jar')
expected = """
""".format(MODULE_PATH=module_path,
SRC_PATH=src_path,
TEST_PATH=test_path,
SRCJAR=srcjar_path,
JAR=jar_path)
self.iml.create({'srcs': True, 'srcjars': True, 'dependencies': True,
'jars': True})
gen_iml = os.path.join(IMLGenUnittests._TEST_DIR,
self.iml._mod_info['path'][0],
self.iml._mod_info['iml_name'] + '.iml')
result = common_util.read_file_content(gen_iml)
self.assertEqual(result, expected)
@mock.patch.object(common_util, 'get_android_root_dir')
def test_gen_dep_sources(self, mock_root_path):
"""Test _generate_dep_srcs."""
mock_root_path.return_value = IMLGenUnittests._TEST_DIR
src_path = os.path.join(IMLGenUnittests._TEST_DIR, 'a/b/src')
test_path = os.path.join(IMLGenUnittests._TEST_DIR, 'a/b/tests')
expected = """
""".format(SRC_PATH=src_path,
TEST_PATH=test_path)
self.iml.create({'dep_srcs': True})
gen_iml = os.path.join(IMLGenUnittests._TEST_DIR,
self.iml._mod_info['path'][0],
self.iml._mod_info['iml_name'] + '.iml')
result = common_util.read_file_content(gen_iml)
self.assertEqual(result, expected)
@mock.patch.object(iml.IMLGenerator, '_create_iml')
@mock.patch.object(iml.IMLGenerator, '_generate_dependencies')
@mock.patch.object(iml.IMLGenerator, '_generate_srcjars')
def test_skip_create_iml(self, mock_gen_srcjars, mock_gen_dep,
mock_create_iml):
"""Test skipping create_iml."""
self.iml.create({'srcjars': False, 'dependencies': False})
self.assertFalse(mock_gen_srcjars.called)
self.assertFalse(mock_gen_dep.called)
self.assertFalse(mock_create_iml.called)
@mock.patch('os.path.exists')
def test_generate_facet(self, mock_exists):
"""Test _generate_facet."""
mock_exists.return_value = False
self.iml._generate_facet()
self.assertEqual(self.iml._facet, '')
mock_exists.return_value = True
self.iml._generate_facet()
self.assertEqual(self.iml._facet, templates.FACET)
@mock.patch.object(common_util, 'get_android_root_dir')
def test_get_uniq_iml_name(self, mock_root_path):
"""Test the unique name cache mechanism.
By using the path data in module info json as input, if the count of
name data set is the same as sub folder path count, then it means
there's no duplicated name, the test PASS.
"""
root_path = '/usr/abc/code/root'
mock_root_path.return_value = root_path
# Add following test path.
test_paths = {
'cts/tests/tests/app',
'cts/tests/app',
'cts/tests/app/app1/../app',
'cts/tests/app/app2/../app',
'cts/tests/app/app3/../app',
'frameworks/base/tests/xxxxxxxxxxxx/base',
'frameworks/base',
'external/xxxxx-xxx/robolectric',
'external/robolectric',
}
# Add whole source tree test paths.
whole_source_tree_paths = {
root_path,
root_path + "/",
}
mod_info = module_info.ModuleInfo()
test_paths.update(mod_info._get_path_to_module_info(
mod_info.name_to_module_info).keys())
print('\n{} {}.'.format('Test_paths length:', len(test_paths)))
path_list = []
for path in test_paths:
path_list.append(path)
print('{} {}.'.format('path list with length:', len(path_list)))
names = [iml.IMLGenerator.get_unique_iml_name(f)
for f in path_list]
print('{} {}.'.format('Names list with length:', len(names)))
self.assertEqual(len(names), len(path_list))
dic = {}
for i, path in enumerate(path_list):
dic[names[i]] = path
print('{} {}.'.format('The size of name set is:', len(dic)))
self.assertEqual(len(dic), len(path_list))
for path in whole_source_tree_paths:
self.assertEqual(os.path.basename(root_path),
iml.IMLGenerator.get_unique_iml_name(path))
if __name__ == '__main__':
unittest.main()