xref: /aosp_15_r20/tools/asuite/atest/module_info_unittest.py (revision c2e18aaa1096c836b086f94603d04f4eb9cf37f5)

#!/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_info."""

# pylint: disable=invalid-name
# pylint: disable=missing-function-docstring
# pylint: disable=too-many-lines

import os
from pathlib import Path
import shutil
import tempfile
import unittest
from unittest import mock
from atest import constants
from atest import module_info
from atest import unittest_constants as uc
from atest import unittest_utils
from pyfakefs import fake_filesystem_unittest

JSON_FILE_PATH = os.path.join(uc.TEST_DATA_DIR, uc.JSON_FILE)
CC_DEP_PATH = os.path.join(uc.TEST_DATA_DIR, uc.CC_DEP_FILE)
JAVA_DEP_PATH = os.path.join(uc.TEST_DATA_DIR, uc.JAVA_DEP_FILE)
EXPECTED_MOD_TARGET = 'tradefed'
EXPECTED_MOD_TARGET_PATH = ['tf/core']
UNEXPECTED_MOD_TARGET = 'this_should_not_be_in_module-info.json'
MOD_NO_PATH = 'module-no-path'
PATH_TO_MULT_MODULES = 'shared/path/to/be/used'
MULT_MOODULES_WITH_SHARED_PATH = ['module2', 'module1']
PATH_TO_MULT_MODULES_WITH_MULTI_ARCH = 'shared/path/to/be/used2'
TESTABLE_MODULES_WITH_SHARED_PATH = [
    'multiarch1',
    'multiarch2',
    'multiarch3',
    'multiarch3_32',
]

ROBO_MOD_PATH = ['/shared/robo/path']
ROBO_MODULE = 'FooTests'
ASSOCIATED_ROBO_MODULE = 'RunFooTests'
ROBO_MODULE_INFO = {
    constants.MODULE_NAME: ROBO_MODULE,
    constants.MODULE_PATH: ROBO_MOD_PATH,
    constants.MODULE_CLASS: [constants.MODULE_CLASS_JAVA_LIBRARIES],
}
ASSOCIATED_ROBO_MODULE_INFO = {
    constants.MODULE_NAME: ASSOCIATED_ROBO_MODULE,
    constants.MODULE_PATH: ROBO_MOD_PATH,
    constants.MODULE_CLASS: [constants.MODULE_CLASS_ROBOLECTRIC],
}
MOD_PATH_INFO_DICT = {
    ROBO_MOD_PATH[0]: [ASSOCIATED_ROBO_MODULE_INFO, ROBO_MODULE_INFO]
}
MOD_NAME_INFO_DICT = {
    ASSOCIATED_ROBO_MODULE: ASSOCIATED_ROBO_MODULE_INFO,
    ROBO_MODULE: ROBO_MODULE_INFO,
}
MOD_NAME1 = 'mod1'
MOD_NAME2 = 'mod2'
MOD_NAME3 = 'mod3'
MOD_NAME4 = 'mod4'
MOD_INFO_DICT = {}
MODULE_INFO = {
    constants.MODULE_NAME: 'random_name',
    constants.MODULE_PATH: 'a/b/c/path',
    constants.MODULE_CLASS: ['random_class'],
}
NAME_TO_MODULE_INFO = {'random_name': MODULE_INFO}

MOBLY_MODULE = 'mobly-test'
MOBLY_MODULE_NO_TAG = 'mobly-test-no-tag'

# Mocking path allows str only, use os.path instead of Path.
with tempfile.TemporaryDirectory() as temp_dir:
  BUILD_TOP_DIR = temp_dir
SOONG_OUT_DIR = os.path.join(BUILD_TOP_DIR, 'out/soong')
PRODUCT_OUT_DIR = os.path.join(BUILD_TOP_DIR, 'out/target/product/vsoc_x86_64')
HOST_OUT_DIR = os.path.join(BUILD_TOP_DIR, 'out/host/linux-x86')


# TODO: (b/263199608) Suppress too-many-public-methods after refactoring.
# pylint: disable=protected-access, too-many-public-methods
class ModuleInfoUnittests(unittest.TestCase):
  """Unit tests for module_info.py"""

  def setUp(self) -> None:
    for path in [BUILD_TOP_DIR, PRODUCT_OUT_DIR, SOONG_OUT_DIR, HOST_OUT_DIR]:
      if not Path(path).is_dir():
        Path(path).mkdir(parents=True)
    shutil.copy2(JSON_FILE_PATH, PRODUCT_OUT_DIR)
    self.json_file_path = Path(PRODUCT_OUT_DIR).joinpath(uc.JSON_FILE)
    shutil.copy2(CC_DEP_PATH, SOONG_OUT_DIR)
    self.cc_dep_path = Path(SOONG_OUT_DIR).joinpath(uc.CC_DEP_FILE)
    shutil.copy2(JAVA_DEP_PATH, SOONG_OUT_DIR)
    self.java_dep_path = Path(SOONG_OUT_DIR).joinpath(uc.JAVA_DEP_FILE)
    self.merged_dep_path = Path(PRODUCT_OUT_DIR).joinpath(uc.MERGED_DEP_FILE)

  def tearDown(self) -> None:
    if self.merged_dep_path.is_file():
      os.remove(self.merged_dep_path)

  def test_target_name_is_relative_to_build_top(self):
    build_top = '/src/build_top'
    product_out = '/src/build_top/pout'
    env_mock = {
        constants.ANDROID_BUILD_TOP: build_top,
        constants.ANDROID_PRODUCT_OUT: product_out,
    }
    expected_target = os.path.relpath(
        os.path.join(product_out, 'module-info.json'), build_top
    )

    with mock.patch.dict('os.environ', env_mock, clear=True):
      actual_target = module_info.get_module_info_target()

      self.assertEqual(actual_target, expected_target)

  def test_target_name_is_in_absolute_path(self):
    build_top = '/src/build_top'
    product_out = '/somewhere/pout'
    env_mock = {
        constants.ANDROID_BUILD_TOP: build_top,
        constants.ANDROID_PRODUCT_OUT: product_out,
    }
    expected_target = os.path.join(product_out, 'module-info.json')

    with mock.patch.dict('os.environ', env_mock, clear=True):
      actual_target = module_info.get_module_info_target()

      self.assertEqual(actual_target, expected_target)

  @mock.patch.object(module_info.Loader, 'load')
  def test_get_path_to_module_info(self, mock_load_module):
    """Test that we correctly create the path to module info dict."""
    mod_one = 'mod1'
    mod_two = 'mod2'
    mod_path_one = '/path/to/mod1'
    mod_path_two = '/path/to/mod2'
    mod_info_dict = {
        mod_one: {
            constants.MODULE_PATH: [mod_path_one],
            constants.MODULE_NAME: mod_one,
        },
        mod_two: {
            constants.MODULE_PATH: [mod_path_two],
            constants.MODULE_NAME: mod_two,
        },
    }
    mock_load_module.return_value = mod_info_dict
    path_to_mod_info = {
        mod_path_one: [{
            constants.MODULE_NAME: mod_one,
            constants.MODULE_PATH: [mod_path_one],
        }],
        mod_path_two: [{
            constants.MODULE_NAME: mod_two,
            constants.MODULE_PATH: [mod_path_two],
        }],
    }
    self.assertDictEqual(
        path_to_mod_info, module_info.get_path_to_module_info(mod_info_dict)
    )

  def test_is_module(self):
    """Test that we get the module when it's properly loaded."""
    # Load up the test json file and check that module is in it
    mod_info = module_info.load_from_file(module_file=JSON_FILE_PATH)
    self.assertTrue(mod_info.is_module(EXPECTED_MOD_TARGET))
    self.assertFalse(mod_info.is_module(UNEXPECTED_MOD_TARGET))

  def test_get_path(self):
    """Test that we get the module path when it's properly loaded."""
    # Load up the test json file and check that module is in it
    mod_info = module_info.load_from_file(module_file=JSON_FILE_PATH)
    self.assertEqual(
        mod_info.get_paths(EXPECTED_MOD_TARGET), EXPECTED_MOD_TARGET_PATH
    )
    self.assertEqual(mod_info.get_paths(MOD_NO_PATH), [])

  def test_get_module_names(self):
    """test that we get the module name properly."""
    mod_info = module_info.load_from_file(module_file=JSON_FILE_PATH)
    self.assertEqual(
        mod_info.get_module_names(EXPECTED_MOD_TARGET_PATH[0]),
        [EXPECTED_MOD_TARGET],
    )
    unittest_utils.assert_strict_equal(
        self,
        mod_info.get_module_names(PATH_TO_MULT_MODULES),
        MULT_MOODULES_WITH_SHARED_PATH,
    )

  def test_path_to_mod_info(self):
    """test that we get the module name properly."""
    mod_info = module_info.load_from_file(module_file=JSON_FILE_PATH)
    module_list = []
    for path_to_mod_info in mod_info.path_to_module_info[
        PATH_TO_MULT_MODULES_WITH_MULTI_ARCH
    ]:
      module_list.append(path_to_mod_info.get(constants.MODULE_NAME))
    module_list.sort()
    TESTABLE_MODULES_WITH_SHARED_PATH.sort()
    self.assertEqual(module_list, TESTABLE_MODULES_WITH_SHARED_PATH)

  def test_is_suite_in_compatibility_suites(self):
    """Test is_suite_in_compatibility_suites."""
    mod_info = module_info.load_from_file(module_file=JSON_FILE_PATH)
    info = {'compatibility_suites': []}
    self.assertFalse(mod_info.is_suite_in_compatibility_suites('cts', info))
    info2 = {'compatibility_suites': ['cts']}
    self.assertTrue(mod_info.is_suite_in_compatibility_suites('cts', info2))
    self.assertFalse(mod_info.is_suite_in_compatibility_suites('vts10', info2))
    info3 = {'compatibility_suites': ['cts', 'vts10']}
    self.assertTrue(mod_info.is_suite_in_compatibility_suites('cts', info3))
    self.assertTrue(mod_info.is_suite_in_compatibility_suites('vts10', info3))
    self.assertFalse(mod_info.is_suite_in_compatibility_suites('ats', info3))

  def test_get_testable_modules(self):
    """Test get_testable_modules."""
    expected_testable_modules = {'Module1', 'Module2', 'Module3'}
    expected_test_suite_modules = {'Module1', 'Module2'}
    expected_null_suite_modules = {'Module3'}
    mod_info = create_module_info(
        modules=[
            test_module(name='Module1', compatibility_suites=['test-suite']),
            test_module(name='Module2', compatibility_suites=['test-suite']),
            test_module(name='Module3'),
            non_test_module(name='Dep1'),
        ]
    )

    actual_all_testable_modules = mod_info.get_testable_modules()
    actual_test_suite_modules = mod_info.get_testable_modules('test-suite')
    actual_null_suite_modules = mod_info.get_testable_modules('null-suite')

    self.assertEqual(actual_all_testable_modules, expected_testable_modules)
    self.assertEqual(actual_test_suite_modules, expected_test_suite_modules)
    self.assertEqual(actual_null_suite_modules, expected_null_suite_modules)

  @mock.patch.dict(
      'os.environ',
      {
          constants.ANDROID_BUILD_TOP: '/',
          constants.ANDROID_PRODUCT_OUT: PRODUCT_OUT_DIR,
      },
  )
  def test_is_mobly_test(self):
    """Test is_mobly_test."""
    mod_info = module_info.load_from_file(module_file=JSON_FILE_PATH)
    self.assertTrue(
        mod_info.is_mobly_module(mod_info.get_module_info(MOBLY_MODULE))
    )
    self.assertFalse(
        mod_info.is_mobly_module(mod_info.get_module_info(MOBLY_MODULE_NO_TAG))
    )

  @mock.patch.dict(
      'os.environ',
      {
          constants.ANDROID_BUILD_TOP: '/',
          constants.ANDROID_PRODUCT_OUT: PRODUCT_OUT_DIR,
      },
  )
  @mock.patch.object(module_info.ModuleInfo, 'get_robolectric_type')
  def test_is_robolectric_test(self, mock_type):
    """Test is_robolectric_test."""
    mod_info = module_info.load_from_file(module_file=JSON_FILE_PATH)
    mock_type.return_value = constants.ROBOTYPE_MODERN
    self.assertTrue(mod_info.is_robolectric_test(ROBO_MODULE))
    mock_type.return_value = constants.ROBOTYPE_LEGACY
    self.assertTrue(mod_info.is_robolectric_test(ROBO_MODULE))
    mock_type.return_value = 0
    self.assertFalse(mod_info.is_robolectric_test(ROBO_MODULE))

  @mock.patch.object(module_info.ModuleInfo, 'is_module')
  def test_is_auto_gen_test_config(self, mock_is_module):
    """Test is_auto_gen_test_config correctly detects the module."""
    mod_info = module_info.load_from_file(module_file=JSON_FILE_PATH)
    mock_is_module.return_value = True
    is_auto_test_config = {'auto_test_config': [True]}
    is_not_auto_test_config = {'auto_test_config': [False]}
    is_not_auto_test_config_again = {'auto_test_config': []}
    MOD_INFO_DICT[MOD_NAME1] = is_auto_test_config
    MOD_INFO_DICT[MOD_NAME2] = is_not_auto_test_config
    MOD_INFO_DICT[MOD_NAME3] = is_not_auto_test_config_again
    MOD_INFO_DICT[MOD_NAME4] = {}
    mod_info.name_to_module_info = MOD_INFO_DICT
    self.assertTrue(mod_info.is_auto_gen_test_config(MOD_NAME1))
    self.assertFalse(mod_info.is_auto_gen_test_config(MOD_NAME2))
    self.assertFalse(mod_info.is_auto_gen_test_config(MOD_NAME3))
    self.assertFalse(mod_info.is_auto_gen_test_config(MOD_NAME4))

  def test_merge_build_system_infos(self):
    """Test _merge_build_system_infos."""
    loader = module_info.Loader(
        module_file=JSON_FILE_PATH, need_merge_fn=lambda: True
    )
    mod_info_1 = {
        constants.MODULE_NAME: 'module_1',
        constants.MODULE_DEPENDENCIES: [],
    }
    name_to_mod_info = {'module_1': mod_info_1}
    expect_deps = ['test_dep_level_1_1', 'test_dep_level_1_2']
    name_to_mod_info = loader._merge_build_system_infos(
        name_to_mod_info, java_bp_info_path=self.java_dep_path
    )
    self.assertEqual(
        name_to_mod_info['module_1'].get(constants.MODULE_DEPENDENCIES),
        expect_deps,
    )

  def test_merge_build_system_infos_missing_keys(self):
    """Test _merge_build_system_infos for keys missing from module-info.json."""
    loader = module_info.Loader(
        module_file=JSON_FILE_PATH, need_merge_fn=lambda: True
    )
    name_to_mod_info = loader._merge_build_system_infos(
        {}, java_bp_info_path=self.java_dep_path
    )

    expect_deps = ['test_dep_level_1_1']
    self.assertEqual(
        name_to_mod_info['not_in_module_info'].get(
            constants.MODULE_DEPENDENCIES
        ),
        expect_deps,
    )

  def test_merge_dependency_with_ori_dependency(self):
    """Test _merge_dependency."""
    loader = module_info.Loader(
        module_file=JSON_FILE_PATH, need_merge_fn=lambda: True
    )
    mod_info_1 = {
        constants.MODULE_NAME: 'module_1',
        constants.MODULE_DEPENDENCIES: ['ori_dep_1'],
    }
    name_to_mod_info = {'module_1': mod_info_1}
    expect_deps = ['ori_dep_1', 'test_dep_level_1_1', 'test_dep_level_1_2']
    name_to_mod_info = loader._merge_build_system_infos(
        name_to_mod_info, java_bp_info_path=self.java_dep_path
    )
    self.assertEqual(
        name_to_mod_info['module_1'].get(constants.MODULE_DEPENDENCIES),
        expect_deps,
    )

  @mock.patch.dict(
      'os.environ',
      {
          constants.ANDROID_BUILD_TOP: uc.TEST_DATA_DIR,
          constants.ANDROID_PRODUCT_OUT: PRODUCT_OUT_DIR,
      },
  )
  def test_get_instrumentation_target_apps(self):
    mod_info = module_info.load_from_file(module_file=JSON_FILE_PATH)
    artifacts = {
        'AmSlam': {
            os.path.join(
                uc.TEST_DATA_DIR,
                'out/target/product/generic/data/app/AmSlam/AmSlam.apk',
            )
        }
    }
    # 1. If Android.bp is available, use `manifest` to determine the actual
    # manifest.
    bp_context = """android_test    {
            name: "AmSlamTests",
            manifest: 'AndroidManifest.xml',
            instrumentation_for: "AmSlam"
        }"""
    bp_file = os.path.join(uc.TEST_DATA_DIR, 'foo/bar/AmSlam/test/Android.bp')
    with open(bp_file, 'w', encoding='utf-8') as cache:
      cache.write(bp_context)
    self.assertEqual(
        mod_info.get_instrumentation_target_apps('AmSlamTests'), artifacts
    )
    os.remove(bp_file)
    # 2. If Android.bp is unavailable, search `AndroidManifest.xml`
    # arbitrarily.
    self.assertEqual(
        mod_info.get_instrumentation_target_apps('AmSlamTests'), artifacts
    )

  @mock.patch.dict(
      'os.environ',
      {
          constants.ANDROID_BUILD_TOP: uc.TEST_DATA_DIR,
          constants.ANDROID_PRODUCT_OUT: PRODUCT_OUT_DIR,
      },
  )
  def test_get_target_module_by_pkg(self):
    mod_info = module_info.load_from_file(module_file=JSON_FILE_PATH)
    self.assertEqual(
        'AmSlam',
        mod_info.get_target_module_by_pkg(
            package='c0m.andr0id.settingS',
            search_from=Path(uc.TEST_DATA_DIR).joinpath('foo/bar/AmSlam/test'),
        ),
    )

  @mock.patch.dict(
      'os.environ',
      {
          constants.ANDROID_BUILD_TOP: uc.TEST_DATA_DIR,
          constants.ANDROID_PRODUCT_OUT: PRODUCT_OUT_DIR,
      },
  )
  def test_get_artifact_map(self):
    mod_info = module_info.load_from_file(module_file=JSON_FILE_PATH)
    artifacts = {
        'AmSlam': {
            os.path.join(
                uc.TEST_DATA_DIR,
                'out/target/product/generic/data/app/AmSlam/AmSlam.apk',
            )
        }
    }
    self.assertEqual(mod_info.get_artifact_map('AmSlam'), artifacts)

  @mock.patch.dict(
      'os.environ',
      {
          constants.ANDROID_BUILD_TOP: uc.TEST_DATA_DIR,
          constants.ANDROID_PRODUCT_OUT: PRODUCT_OUT_DIR,
      },
  )
  def test_get_filepath_from_module(self):
    """Test for get_filepath_from_module."""
    mod_info = module_info.load_from_file(module_file=JSON_FILE_PATH)

    expected_filepath = Path(uc.TEST_DATA_DIR).joinpath(
        'foo/bar/AmSlam', 'AndroidManifest.xml'
    )
    self.assertEqual(
        mod_info.get_filepath_from_module('AmSlam', 'AndroidManifest.xml'),
        expected_filepath,
    )

    expected_filepath = Path(uc.TEST_DATA_DIR).joinpath(
        'foo/bar/AmSlam/test', 'AndroidManifest.xml'
    )
    self.assertEqual(
        mod_info.get_filepath_from_module('AmSlamTests', 'AndroidManifest.xml'),
        expected_filepath,
    )

  def test_get_module_dependency(self):
    """Test get_module_dependency."""
    loader = module_info.Loader(
        module_file=JSON_FILE_PATH, need_merge_fn=lambda: True
    )
    mod_info = loader.load()
    expect_deps = {
        'test_dep_level_1_1',
        'module_1',
        'test_dep_level_1_2',
        'test_dep_level_2_2',
        'test_dep_level_2_1',
        'module_2',
    }
    loader._merge_build_system_infos(
        loader.name_to_module_info, java_bp_info_path=self.java_dep_path
    )
    self.assertEqual(
        mod_info.get_module_dependency('dep_test_module'), expect_deps
    )

  def test_get_module_dependency_w_loop(self):
    """Test get_module_dependency with problem dep file."""
    loader = module_info.Loader(
        module_file=JSON_FILE_PATH, need_merge_fn=lambda: True
    )
    mod_info = loader.load()
    # Java dependency file with a endless loop define.
    java_dep_file = os.path.join(
        uc.TEST_DATA_DIR, 'module_bp_java_loop_deps.json'
    )
    expect_deps = {
        'test_dep_level_1_1',
        'module_1',
        'test_dep_level_1_2',
        'test_dep_level_2_2',
        'test_dep_level_2_1',
        'module_2',
    }
    loader._merge_build_system_infos(
        loader.name_to_module_info, java_bp_info_path=java_dep_file
    )
    self.assertEqual(
        mod_info.get_module_dependency('dep_test_module'), expect_deps
    )

  def test_get_install_module_dependency(self):
    """Test get_install_module_dependency."""
    loader = module_info.Loader(
        module_file=JSON_FILE_PATH, need_merge_fn=lambda: True
    )
    mod_info = loader.load()
    expect_deps = {'module_1', 'test_dep_level_2_1'}
    loader._merge_build_system_infos(
        loader.name_to_module_info, java_bp_info_path=self.java_dep_path
    )
    self.assertEqual(
        mod_info.get_install_module_dependency('dep_test_module'), expect_deps
    )

  def test_cc_merge_build_system_infos(self):
    """Test _merge_build_system_infos for cc."""
    loader = module_info.Loader(
        module_file=JSON_FILE_PATH, need_merge_fn=lambda: True
    )
    mod_info_1 = {
        constants.MODULE_NAME: 'module_cc_1',
        constants.MODULE_DEPENDENCIES: [],
    }
    name_to_mod_info = {'module_cc_1': mod_info_1}
    expect_deps = ['test_cc_dep_level_1_1', 'test_cc_dep_level_1_2']
    name_to_mod_info = loader._merge_build_system_infos(
        name_to_mod_info, cc_bp_info_path=self.cc_dep_path
    )
    self.assertEqual(
        name_to_mod_info['module_cc_1'].get(constants.MODULE_DEPENDENCIES),
        expect_deps,
    )

  def test_is_unit_test(self):
    """Test is_unit_test."""
    module_name = 'myModule'
    maininfo_with_unittest = {
        constants.MODULE_NAME: module_name,
        constants.MODULE_IS_UNIT_TEST: 'true',
    }

    self.assertTrue(module_info.ModuleInfo.is_unit_test(maininfo_with_unittest))

  def test_is_host_unit_test(self):
    """Test is_host_unit_test."""
    module_name = 'myModule'
    maininfo_with_host_unittest = {
        constants.MODULE_NAME: module_name,
        constants.MODULE_IS_UNIT_TEST: 'true',
        'compatibility_suites': ['host-unit-tests'],
        constants.MODULE_INSTALLED: uc.DEFAULT_INSTALL_PATH,
        'auto_test_config': ['true'],
    }

    mod_info = module_info.load_from_file(module_file=JSON_FILE_PATH)

    self.assertTrue(mod_info.is_host_unit_test(maininfo_with_host_unittest))

  def test_is_device_driven_test(self):
    module_name = 'myModule'
    maininfo_with_device_driven_test = {
        constants.MODULE_NAME: module_name,
        constants.MODULE_TEST_CONFIG: [
            os.path.join(uc.TEST_CONFIG_DATA_DIR, 'a.xml.data')
        ],
        constants.MODULE_INSTALLED: uc.DEFAULT_INSTALL_PATH,
        'supported_variants': ['DEVICE'],
    }
    mod_info = module_info.load_from_file(module_file=JSON_FILE_PATH)

    self.assertTrue(
        mod_info.is_device_driven_test(maininfo_with_device_driven_test)
    )

  def test_not_device_driven_test_when_suite_is_robolectric_test(self):
    module_name = 'myModule'
    maininfo_with_device_driven_test = {
        constants.MODULE_NAME: module_name,
        constants.MODULE_TEST_CONFIG: [
            os.path.join(uc.TEST_CONFIG_DATA_DIR, 'a.xml.data')
        ],
        constants.MODULE_INSTALLED: uc.DEFAULT_INSTALL_PATH,
        'supported_variants': ['DEVICE'],
        'compatibility_suites': ['robolectric-tests'],
    }
    mod_info = module_info.load_from_file(module_file=JSON_FILE_PATH)

    self.assertFalse(
        mod_info.is_device_driven_test(maininfo_with_device_driven_test)
    )

  def test_is_host_driven_test(self):
    """Test is_host_driven_test."""
    test_name = 'myModule'
    expected_host_driven_info = {
        constants.MODULE_NAME: test_name,
        constants.MODULE_TEST_CONFIG: [
            os.path.join(uc.TEST_CONFIG_DATA_DIR, 'a.xml.data')
        ],
        constants.MODULE_INSTALLED: uc.DEFAULT_INSTALL_PATH,
        'supported_variants': ['HOST'],
    }
    mod_info = create_module_info([
        module(
            name=test_name,
            test_config=[os.path.join(uc.TEST_CONFIG_DATA_DIR, 'a.xml.data')],
            installed=uc.DEFAULT_INSTALL_PATH,
            supported_variants=['HOST'],
        )
    ])

    return_value = mod_info.is_host_driven_test(expected_host_driven_info)

    self.assertTrue(return_value)

  # TODO: (b/264015241) Stop mocking build variables.
  # TODO: (b/263199608) Re-write the test after refactoring module-info.py
  @mock.patch.dict(
      'os.environ',
      {
          constants.ANDROID_BUILD_TOP: uc.ATEST_PKG_DIR,
          constants.ANDROID_PRODUCT_OUT: PRODUCT_OUT_DIR,
      },
  )
  def test_has_mainline_modules(self):
    """Test has_mainline_modules."""
    name1 = 'MainModule1'
    mainline_module1 = ['foo2.apk', 'foo3.apk']
    name2 = 'MainModule2'
    mainline_module2 = ['foo1.apex']
    name3 = 'MainModule3'

    mod_info = module_info.load_from_file(module_file=JSON_FILE_PATH)
    # found in 'test_mainlne_modules' attribute.
    self.assertTrue(mod_info.has_mainline_modules(name1, mainline_module1))
    # found in the value of 'mainline-param' in test_config.
    self.assertTrue(mod_info.has_mainline_modules(name2, mainline_module2))
    # cannot be found in both 'test_mainline_modules' and 'test_config'.
    self.assertFalse(mod_info.has_mainline_modules(name3, mainline_module2))

  # TODO: (b/264015241) Stop mocking build variables.
  # TODO: (b/263199608) Re-write the test after refactoring module-info.py
  @mock.patch.dict(
      'os.environ',
      {
          constants.ANDROID_BUILD_TOP: os.path.dirname(__file__),
          constants.ANDROID_PRODUCT_OUT: PRODUCT_OUT_DIR,
      },
  )
  def test_get_module_info_for_multi_lib_module(self):
    my_module_name = 'MyMultiArchTestModule'
    multi_arch_json = os.path.join(
        uc.TEST_DATA_DIR, 'multi_arch_module-info.json'
    )
    mod_info = module_info.load_from_file(module_file=multi_arch_json)

    self.assertIsNotNone(mod_info.get_module_info(my_module_name))

  def test_get_modules_by_include_deps_w_testable_module_only_false(self):
    module_1 = module(
        name='module_1',
        dependencies=['dep1', 'dep2'],
    )
    module_2 = module(name='module_2', dependencies=['dep1', 'dep3'])
    mod_info = create_module_info([module_1, module_2])

    self.assertEqual(
        {'module_1', 'module_2'},
        mod_info.get_modules_by_include_deps(
            {'dep1'}, testable_module_only=False
        ),
    )
    self.assertEqual(
        {'module_1'},
        mod_info.get_modules_by_include_deps(
            {'dep2'}, testable_module_only=False
        ),
    )
    self.assertEqual(
        {'module_2'},
        mod_info.get_modules_by_include_deps(
            {'dep3'}, testable_module_only=False
        ),
    )

  @mock.patch.object(module_info.ModuleInfo, 'get_testable_modules')
  def test_get_modules_by_include_deps_w_testable_module_only_true(
      self, _testable_modules
  ):
    module_1 = module(
        name='module_1',
        dependencies=['dep1', 'dep2'],
    )
    module_2 = module(name='module_2', dependencies=['dep1', 'dep3'])
    mod_info = create_module_info([module_1, module_2])
    _testable_modules.return_value = []

    self.assertEqual(
        set(),
        mod_info.get_modules_by_include_deps(
            {'dep1'}, testable_module_only=True
        ),
    )

  def test_get_modules_by_path_in_srcs_no_module_found(self):
    module_1 = module(
        name='module_1',
        srcs=['path/src1', 'path/src2'],
    )
    module_2 = module(name='module_2', srcs=['path/src2', 'path/src3'])
    mod_info = create_module_info([module_1, module_2])

    self.assertEqual(set(), mod_info.get_modules_by_path_in_srcs('path/src4'))

  def test_get_modules_by_path_in_srcs_one_module_found(self):
    module_1 = module(
        name='module_1',
        srcs=['path/src1', 'path/src2'],
    )
    module_2 = module(name='module_2', srcs=['path/src2', 'path/src3'])
    mod_info = create_module_info([module_1, module_2])

    self.assertEqual(
        {'module_1'}, mod_info.get_modules_by_path_in_srcs('path/src1')
    )

  def test_get_modules_by_path_in_srcs_multiple_module_found(self):
    module_1 = module(
        name='module_1',
        srcs=['path/src1', 'path/src2'],
    )
    module_2 = module(name='module_2', srcs=['path/src2', 'path/src3'])
    mod_info = create_module_info([module_1, module_2])

    self.assertEqual(
        {'module_1', 'module_2'},
        mod_info.get_modules_by_path_in_srcs('path/src2'),
    )

  def test_contains_same_mainline_modules(self):
    mainline_modules = {'A.apex', 'B.apk'}
    self.assertTrue(
        module_info.contains_same_mainline_modules(
            mainline_modules, {'B.apk+A.apex'}
        )
    )
    self.assertFalse(
        module_info.contains_same_mainline_modules(
            mainline_modules, {'B.apk+C.apex'}
        )
    )

  def test_get_installed_paths_have_abs_path(self):
    mod_info = create_module_info(
        [module(name='my_module', installed=[Path('/a/b/c/d')])]
    )

    self.assertEqual(
        mod_info.get_installed_paths('my_module'), [Path('/a/b/c/d')]
    )

  @mock.patch.dict(
      'os.environ', {constants.ANDROID_BUILD_TOP: '/mocked/build_top'}
  )
  def test_get_installed_paths_have_relative_path(self):
    mod_info = create_module_info(
        [module(name='my_module', installed=['a/b/c/d'])]
    )

    self.assertEqual(
        mod_info.get_installed_paths('my_module'),
        [Path('/mocked/build_top/a/b/c/d')],
    )

  def test_get_code_under_test_module_name_is_not_found_in_module_info(self):
    mod_info = create_module_info([
        module(
            name='my_module',
            code_under_test='code_under_test_module',
        )
    ])

    # module_that_is_not_in_module_info is not found in mod_info.
    self.assertEqual(
        mod_info.get_code_under_test('module_that_is_not_in_module_info'), [],
    )

  def test_get_code_under_test_code_under_test_is_not_defined_in_module_info(self):
    mod_info = create_module_info([module(name='my_module')])

    # my_module is found in mod_info but code_under_test is not defined.
    self.assertEqual(
        mod_info.get_code_under_test('my_module'), [],
    )

  def test_get_code_under_test_code_under_test_is_defined_in_module_info(self):
    mod_info = create_module_info([
        module(
            name='my_module',
            code_under_test='code_under_test_module',
        )
    ])

    self.assertEqual(
        mod_info.get_code_under_test('my_module'),
        'code_under_test_module',
    )


class ModuleInfoTestFixture(fake_filesystem_unittest.TestCase):
  """Fixture for ModuleInfo tests."""

  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.load_from_file(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


class HasTestConfonfigTest(ModuleInfoTestFixture):
  """Tests has_test_config in various conditions."""

  def test_return_true_if_test_config_is_not_empty(self):
    test_module_info = module(test_config=['config_file'])
    mod_info = self.create_module_info()

    return_value = mod_info.has_test_config(test_module_info)

    self.assertTrue(return_value)

  def test_return_true_if_auto_test_config_is_not_empty(self):
    test_module_info = module(auto_test_config=['no_empty'])
    mod_info = self.create_module_info()

    return_value = mod_info.has_test_config(test_module_info)

    self.assertTrue(return_value)

  def test_return_false_if_auto_test_config_and_test_config_empty(self):
    test_module_info = module(test_config=[], auto_test_config=[])
    mod_info = self.create_module_info()

    return_value = mod_info.has_test_config(test_module_info)

    self.assertFalse(return_value)


class ModuleInfoCompatibilitySuiteTest(ModuleInfoTestFixture):
  """Tests the compatibility suite in the module info."""

  def test_return_true_if_suite_in_test(self):
    test_module_info = module(compatibility_suites=['test_suite'])
    mod_info = self.create_module_info()

    return_value = mod_info.is_suite_in_compatibility_suites(
        'test_suite', test_module_info
    )

    self.assertTrue(return_value)

  def test_return_false_if_suite_not_in_test(self):
    test_module_info = module(compatibility_suites=['no_suite'])
    mod_info = self.create_module_info()

    return_value = mod_info.is_suite_in_compatibility_suites(
        'test_suite', test_module_info
    )

    self.assertFalse(return_value)

  def test_return_false_when_mod_info_is_empty(self):
    test_module_info = None
    mod_info = self.create_module_info()

    return_value = mod_info.is_suite_in_compatibility_suites(
        'test_suite', test_module_info
    )

    self.assertFalse(return_value)

  def test_return_false_when_mod_info_is_not_a_dict(self):
    test_module_info = ['no_a_dict']
    mod_info = self.create_module_info()

    return_value = mod_info.is_suite_in_compatibility_suites(
        'test_suite', test_module_info
    )

    self.assertFalse(return_value)


class RobolectricTestNameTest(ModuleInfoTestFixture):
  """Tests the Robolectric test name in the module info."""

  def test_return_empty_for_a_modern_robolectric_test(self):
    module_name = 'hello_world_test'
    info = modern_robolectric_test_module(name=f'{module_name}')
    mod_info = self.create_module_info(modules=[info])

    return_module = mod_info.get_robolectric_test_name(info)

    self.assertEqual('', return_module)

  def test_return_related_robolectric_run_module_name(self):
    module_name = 'hello_world_test'
    run_module_name = f'Run{module_name}'
    module_path = 'robolectric_path'
    info = non_test_module(name=f'{module_name}', path=module_path)
    mod_info = self.create_module_info(
        modules=[
            info,
            robolectric_class_non_test_module(
                name=f'{run_module_name}', path=module_path
            ),
        ]
    )

    return_module = mod_info.get_robolectric_test_name(info)

    self.assertEqual(run_module_name, return_module)

  def test_return_empty_when_no_related_robolectic_class_module(self):
    module_name = 'hello_world_test'
    run_module_name = f'Run{module_name}'
    module_path = 'robolectric_path'
    info = non_test_module(name=f'{module_name}', path=module_path)
    mod_info = self.create_module_info(
        modules=[
            info,
            non_test_module(name=f'{run_module_name}', path=module_path),
        ]
    )

    return_module = mod_info.get_robolectric_test_name(info)

    self.assertEqual('', return_module)

  def test_return_empty_if_related_module_name_not_start_with_Run(self):
    module_name = 'hello_world_test'
    run_module_name = f'Not_Run{module_name}'
    module_path = 'robolectric_path'
    info = robolectric_class_non_test_module(
        name=f'{run_module_name}', path=module_path
    )
    mod_info = self.create_module_info(
        modules=[
            non_test_module(name=f'{module_name}', path=module_path),
            info,
        ]
    )

    return_module = mod_info.get_robolectric_test_name(info)

    self.assertEqual('', return_module)

  def test_return_itself_for_a_robolectric_class_test_module(self):
    module_name = 'Run_hello_world_test'
    info = robolectric_class_non_test_module(name=f'{module_name}')
    mod_info = self.create_module_info(modules=[info])

    return_module = mod_info.get_robolectric_test_name(info)

    self.assertEqual(module_name, return_module)

  def test_return_empty_if_robolectric_class_module_not_start_with_Run(self):
    module_name = 'hello_world_test'
    info = robolectric_class_non_test_module(name=f'{module_name}')
    mod_info = self.create_module_info(modules=[info])

    return_module = mod_info.get_robolectric_test_name(info)

    self.assertEqual('', return_module)

  def test_return_0_when_no_mod_info(self):
    module_name = 'hello_world_test'
    info = non_test_module(name=module_name)
    mod_info = self.create_module_info(modules=[info])

    return_module = mod_info.get_robolectric_test_name(info)

    self.assertEqual('', return_module)


class RobolectricTestTypeTest(ModuleInfoTestFixture):
  """Tests the Robolectric test type in the module info."""

  def test_modern_robolectric_test_type(self):
    module_name = 'hello_world_test'
    mod_info = self.create_module_info(
        modules=[
            modern_robolectric_test_module(name=f'{module_name}'),
        ]
    )

    return_value = mod_info.get_robolectric_type(module_name)

    self.assertEqual(return_value, constants.ROBOTYPE_MODERN)

  def test_return_modern_if_compliant_with_modern_and_legacy(self):
    module_name = 'hello_world_test'
    module_path = 'robolectric_path'
    run_module_name = f'Run{module_name}'
    mod_info = self.create_module_info(
        modules=[
            modern_robolectric_test_module(
                name=f'{module_name}', path=module_path
            ),
            robolectric_class_non_test_module(
                name=f'{run_module_name}', path=module_path
            ),
        ]
    )

    return_value = mod_info.get_robolectric_type(module_name)

    self.assertEqual(return_value, constants.ROBOTYPE_MODERN)

  def test_not_modern_robolectric_test_if_suite_is_not_robolectric(self):
    module_name = 'hello_world_test'
    mod_info = self.create_module_info(
        modules=[
            non_test_module(
                name=f'{module_name}',
                compatibility_suites='not_robolectric_tests',
            ),
        ]
    )

    return_value = mod_info.get_robolectric_type(module_name)

    self.assertEqual(return_value, 0)

  def test_legacy_robolectric_test_type_if_has_related_run_robolectric_class_module(
      self,
  ):
    module_name = 'hello_world_test'
    run_module_name = f'Run{module_name}'
    module_path = 'robolectric_path'
    mod_info = self.create_module_info(
        modules=[
            non_test_module(name=f'{module_name}', path=module_path),
            robolectric_class_non_test_module(
                name=f'{run_module_name}', path=module_path
            ),
        ]
    )

    return_value = mod_info.get_robolectric_type(module_name)

    self.assertEqual(return_value, constants.ROBOTYPE_LEGACY)

  def test_not_legacy_robolectric_test_type_if_module_is_tradefed_testable(
      self,
  ):
    module_name = 'hello_world_test'
    run_module_name = f'Run{module_name}'
    module_path = 'robolectric_path'
    mod_info = self.create_module_info(
        modules=[
            test_module(name=f'{module_name}', path=module_path),
            robolectric_class_test_module(
                name=f'{run_module_name}', path=module_path
            ),
        ]
    )

    return_value = mod_info.get_robolectric_type(module_name)

    self.assertEqual(return_value, 0)

  def test_robolectric_class_test_module(self):
    module_name = 'Run_hello_world_test'
    mod_info = self.create_module_info(
        modules=[
            robolectric_class_non_test_module(name=f'{module_name}'),
        ]
    )

    return_value = mod_info.get_robolectric_type(module_name)

    self.assertEqual(return_value, constants.ROBOTYPE_LEGACY)

  def test_not_robolectric_test_if_module_name_not_start_with_Run(self):
    module_name = 'hello_world_test'
    mod_info = self.create_module_info(
        modules=[
            robolectric_class_non_test_module(name=f'{module_name}'),
        ]
    )

    return_value = mod_info.get_robolectric_type(module_name)

    self.assertEqual(return_value, 0)

  def test_return_0_when_no_related_robolectic_class_module(self):
    module_name = 'hello_world_test'
    run_module_name = f'Run{module_name}'
    module_path = 'robolectric_path'
    mod_info = self.create_module_info(
        modules=[
            non_test_module(name=f'{module_name}', path=module_path),
            non_test_module(name=f'{run_module_name}', path=module_path),
        ]
    )

    return_value = mod_info.get_robolectric_type(module_name)

    self.assertEqual(return_value, 0)

  def test_return_0_when_no_related_module_name_start_with_Run(self):
    module_name = 'hello_world_test'
    run_module_name = f'Not_Run{module_name}'
    module_path = 'robolectric_path'
    mod_info = self.create_module_info(
        modules=[
            non_test_module(name=f'{module_name}', path=module_path),
            robolectric_class_non_test_module(
                name=f'{run_module_name}', path=module_path
            ),
        ]
    )

    return_value = mod_info.get_robolectric_type(module_name)

    self.assertEqual(return_value, 0)

  def test_return_0_when_no_mod_info(self):
    module_name = 'hello_world_test'
    mod_info = self.create_module_info()

    return_value = mod_info.get_robolectric_type(module_name)

    self.assertEqual(return_value, 0)


class IsLegacyRobolectricClassTest(ModuleInfoTestFixture):
  """Tests is_legacy_robolectric_class in various conditions."""

  def test_return_true_if_module_class_is_robolectric(self):
    test_module_info = module(classes=[constants.MODULE_CLASS_ROBOLECTRIC])
    mod_info = self.create_module_info()

    return_value = mod_info.is_legacy_robolectric_class(test_module_info)

    self.assertTrue(return_value)

  def test_return_false_if_module_class_is_not_robolectric(self):
    test_module_info = module(classes=['not_robolectric'])
    mod_info = self.create_module_info()

    return_value = mod_info.is_legacy_robolectric_class(test_module_info)

    self.assertFalse(return_value)

  def test_return_false_if_module_class_is_empty(self):
    test_module_info = module(classes=[])
    mod_info = self.create_module_info()

    return_value = mod_info.is_legacy_robolectric_class(test_module_info)

    self.assertFalse(return_value)


class IsTestableModuleTest(ModuleInfoTestFixture):
  """Tests is_testable_module in various conditions."""

  def test_return_true_for_tradefed_testable_module(self):
    info = test_module()
    mod_info = self.create_module_info()

    return_value = mod_info.is_testable_module(info)

    self.assertTrue(return_value)

  def test_return_true_for_modern_robolectric_test_module(self):
    info = modern_robolectric_test_module()
    mod_info = self.create_module_info()

    return_value = mod_info.is_testable_module(info)

    self.assertTrue(return_value)

  def test_return_true_for_legacy_robolectric_test_module(self):
    info = legacy_robolectric_test_module()
    mod_info = self.create_module_info(modules=[info])

    return_value = mod_info.is_testable_module(info)

    self.assertTrue(return_value)

  def test_return_false_for_non_tradefed_testable_module(self):
    info = module(
        auto_test_config=[], test_config=[], installed=['installed_path']
    )
    mod_info = self.create_module_info()

    return_value = mod_info.is_testable_module(info)

    self.assertFalse(return_value)

  def test_return_false_for_no_installed_path_module(self):
    info = module(auto_test_config=['true'], installed=[])
    mod_info = self.create_module_info()

    return_value = mod_info.is_testable_module(info)

    self.assertFalse(return_value)

  def test_return_false_if_module_info_is_empty(self):
    info = {}
    mod_info = self.create_module_info()

    return_value = mod_info.is_testable_module(info)

    self.assertFalse(return_value)


def create_module_info(modules=None):
  name_to_module_info = {}
  modules = modules or []

  for m in modules:
    name_to_module_info[m['module_name']] = m

  return module_info.load_from_dict(name_to_module_info)


def test_module(**kwargs):
  kwargs.setdefault('name', 'hello_world_test')
  return test(module(**kwargs))


def non_test_module(**kwargs):
  kwargs.setdefault('name', 'not_a_test')
  return non_test(module(**kwargs))


def modern_robolectric_test_module(**kwargs):
  kwargs.setdefault('name', 'hello_world_test')
  return test(robolectric_tests_suite(module(**kwargs)))


def legacy_robolectric_test_module(**kwargs):
  kwargs.setdefault('name', 'Run_hello_world_test')
  return robolectric_class_non_test_module(**kwargs)


def robolectric_class_test_module(**kwargs):
  kwargs.setdefault('name', 'hello_world_test')
  return test(robolectric_class(module(**kwargs)))


def robolectric_class_non_test_module(**kwargs):
  kwargs.setdefault('name', 'hello_world_test')
  return non_test(robolectric_class(module(**kwargs)))


# pylint: disable=too-many-arguments, too-many-locals
def module(
    name=None,
    path=None,
    installed=None,
    classes=None,
    auto_test_config=None,
    test_config=None,
    shared_libs=None,
    dependencies=None,
    runtime_dependencies=None,
    data=None,
    data_dependencies=None,
    compatibility_suites=None,
    host_dependencies=None,
    srcs=None,
    supported_variants=None,
    code_under_test=None,
):
  name = name or 'libhello'

  m = {}

  m['module_name'] = name
  m['class'] = classes or ['ETC']
  m['path'] = [path or '']
  m['installed'] = installed or []
  m['is_unit_test'] = 'false'
  m['auto_test_config'] = auto_test_config or []
  m['test_config'] = 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 []
  m['supported_variants'] = supported_variants or []
  m['code_under_test'] = code_under_test or []
  return m


def test(info):
  info['auto_test_config'] = ['true']
  info['installed'] = ['installed_path']
  return info


def non_test(info):
  info['auto_test_config'] = []
  info['installed'] = []
  return info


def robolectric_class(info):
  info['class'] = ['ROBOLECTRIC']
  return info


def robolectric_tests_suite(info):
  info = test(info)
  info.setdefault('compatibility_suites', []).append('robolectric-tests')
  return info


if __name__ == '__main__':
  unittest.main()