| #!/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 atest_utils.""" |
| |
| # pylint: disable=invalid-name |
| |
| import hashlib |
| from io import StringIO |
| import os |
| from pathlib import Path |
| import subprocess |
| import sys |
| import tempfile |
| import unittest |
| from unittest import mock |
| |
| from atest import arg_parser |
| from atest import atest_error |
| from atest import atest_utils |
| from atest import constants |
| from atest import unittest_constants |
| from atest import unittest_utils |
| from atest.atest_enum import FilterType |
| from atest.test_finders import test_info |
| from pyfakefs import fake_filesystem_unittest |
| |
| TEST_MODULE_NAME_A = 'ModuleNameA' |
| TEST_RUNNER_A = 'FakeTestRunnerA' |
| TEST_BUILD_TARGET_A = set(['bt1', 'bt2']) |
| TEST_DATA_A = {'test_data_a_1': 'a1', 'test_data_a_2': 'a2'} |
| TEST_SUITE_A = 'FakeSuiteA' |
| TEST_MODULE_CLASS_A = 'FAKE_MODULE_CLASS_A' |
| TEST_INSTALL_LOC_A = set(['host', 'device']) |
| TEST_FINDER_A = 'MODULE' |
| TEST_INFO_A = test_info.TestInfo( |
| TEST_MODULE_NAME_A, |
| TEST_RUNNER_A, |
| TEST_BUILD_TARGET_A, |
| TEST_DATA_A, |
| TEST_SUITE_A, |
| TEST_MODULE_CLASS_A, |
| TEST_INSTALL_LOC_A, |
| ) |
| TEST_INFO_A.test_finder = TEST_FINDER_A |
| TEST_ZIP_DATA_DIR = 'zip_files' |
| TEST_SINGLE_ZIP_NAME = 'single_file.zip' |
| TEST_MULTI_ZIP_NAME = 'multi_file.zip' |
| |
| REPO_INFO_OUTPUT = """Manifest branch: test_branch |
| Manifest merge branch: refs/heads/test_branch |
| Manifest groups: all,-notdefault |
| ---------------------------- |
| """ |
| |
| |
| class StreamIoOutputTest(unittest.TestCase): |
| """Class that tests the _stream_io_output function.""" |
| |
| def test_stream_io_output_no_max_lines_no_clear_line_code(self): |
| """Test when max_lines is None, no clear line code is written to the stream.""" |
| io_input = StringIO() |
| io_input.write(f'1\n' * 10) |
| io_input.seek(0) |
| io_output = StringIO() |
| |
| atest_utils.stream_io_output( |
| io_input, max_lines=None, io_output=io_output, is_io_output_atty=True |
| ) |
| |
| self.assertNotIn( |
| atest_utils._BASH_CLEAR_PREVIOUS_LINE_CODE, io_output.getvalue() |
| ) |
| |
| @mock.patch.object(atest_utils, 'get_terminal_size', return_value=(5, -1)) |
| def test_stream_io_output_wrap_long_lines(self, _): |
| """Test when max_lines is set, long lines will be wrapped.""" |
| io_input = StringIO() |
| io_input.write(f'1' * 10) |
| io_input.seek(0) |
| io_output = StringIO() |
| |
| atest_utils.stream_io_output( |
| io_input, max_lines=10, io_output=io_output, is_io_output_atty=True |
| ) |
| |
| self.assertIn('11111\n11111', io_output.getvalue()) |
| |
| @mock.patch.object(atest_utils, 'get_terminal_size', return_value=(5, -1)) |
| def test_stream_io_output_clear_lines_over_max_lines(self, _): |
| """Test when line exceeds max_lines, the previous lines are cleared.""" |
| io_input = StringIO() |
| io_input.write('1\n2\n3\n') |
| io_input.seek(0) |
| io_output = StringIO() |
| |
| atest_utils.stream_io_output( |
| io_input, max_lines=2, io_output=io_output, is_io_output_atty=True |
| ) |
| |
| self.assertIn( |
| '2\n3\n', |
| io_output.getvalue(), |
| ) |
| self.assertNotIn( |
| '1\n2\n3\n', |
| io_output.getvalue(), |
| ) |
| |
| @mock.patch.object(atest_utils, 'get_terminal_size', return_value=(5, -1)) |
| def test_stream_io_output_no_clear_lines_under_max_lines(self, _): |
| """Test when line is under max_lines, the previous lines are not cleared.""" |
| io_input = StringIO() |
| io_input.write('1\n2\n3\n') |
| io_input.seek(0) |
| io_output = StringIO() |
| |
| atest_utils.stream_io_output( |
| io_input, max_lines=4, io_output=io_output, is_io_output_atty=True |
| ) |
| |
| self.assertIn( |
| '1\n2\n3\n', |
| io_output.getvalue(), |
| ) |
| |
| @mock.patch.object(atest_utils, 'get_terminal_size', return_value=(5, -1)) |
| def test_stream_io_output_no_lines_written_no_lines_cleared(self, _): |
| """Test when nothing is written, no lines are cleared.""" |
| io_input = StringIO() |
| io_output = StringIO() |
| |
| atest_utils.stream_io_output( |
| io_input, max_lines=2, io_output=io_output, is_io_output_atty=True |
| ) |
| |
| self.assertNotIn( |
| atest_utils._BASH_CLEAR_PREVIOUS_LINE_CODE, |
| io_output.getvalue(), |
| ) |
| |
| @mock.patch.object(atest_utils, 'get_terminal_size', return_value=(5, -1)) |
| def test_stream_io_output_replace_tab_with_spaces(self, _): |
| """Test when line exceeds max_lines, the previous lines are cleared.""" |
| io_input = StringIO() |
| io_input.write('1\t2') |
| io_input.seek(0) |
| io_output = StringIO() |
| |
| atest_utils.stream_io_output( |
| io_input, max_lines=2, io_output=io_output, is_io_output_atty=True |
| ) |
| |
| self.assertNotIn( |
| '\t', |
| io_output.getvalue(), |
| ) |
| |
| |
| class ConcatenatePathTest(unittest.TestCase): |
| """Class that tests path concatenation.""" |
| |
| @classmethod |
| def setUpClass(cls): |
| """Mock the environment variables for the entire test class""" |
| cls.build_top = '/src/build_top' |
| cls.prod_out = '/src/build_top/product_out' |
| cls.host_out = '/src/build_top/host_out' |
| cls.target_out_cases = '/src/build_top/product_out/testcases' |
| cls.host_out_cases = '/src/build_top/host_out/testcases' |
| cls.target_product = 'test_target_product' |
| cls.build_variant = 'test_build_variant' |
| cls.mock_getenv = mock.patch.dict( |
| os.environ, |
| { |
| 'ANDROID_BUILD_TOP': cls.build_top, |
| 'ANDROID_PRODUCT_OUT': cls.prod_out, |
| 'ANDROID_TARGET_OUT_TESTCASES': cls.target_out_cases, |
| 'ANDROID_HOST_OUT': cls.host_out, |
| 'ANDROID_HOST_OUT_TESTCASES': cls.host_out_cases, |
| 'TARGET_PRODUCT': cls.target_product, |
| 'TARGET_BUILD_VARIANT': cls.build_variant, |
| }, |
| ) |
| cls.mock_getenv.start() |
| |
| @classmethod |
| def tearDownClass(cls): |
| """Clean up the mocks after the test class finishes""" |
| cls.mock_getenv.stop() |
| |
| def test_get_vars(self): |
| """Test the values of AndroidVariables are expected""" |
| variables = atest_utils.AndroidVariables() |
| |
| self.assertEqual(variables.build_top, self.build_top) |
| self.assertEqual(variables.product_out, self.prod_out) |
| self.assertEqual(variables.target_out_cases, self.target_out_cases) |
| self.assertEqual(variables.host_out, self.host_out) |
| self.assertEqual(variables.host_out_cases, self.host_out_cases) |
| self.assertEqual(variables.target_product, self.target_product) |
| self.assertEqual(variables.build_variant, self.build_variant) |
| |
| def test_atest_utils_get_build_top(self): |
| """Test concatenating strings with get_build_top().""" |
| expected_path = Path(self.build_top, 'path/to/project') |
| |
| return_path = atest_utils.get_build_top('path/to/project') |
| |
| self.assertEqual(expected_path, return_path) |
| |
| def test_atest_utils_get_product_out(self): |
| """Test concatenating strings with get_product_out().""" |
| expected_path = Path(self.prod_out, 'module-info.json') |
| |
| return_path = atest_utils.get_product_out('module-info.json') |
| |
| self.assertEqual(expected_path, return_path) |
| |
| def test_atest_utils_get_host_out(self): |
| """Test concatenating strings with get_host_out().""" |
| expected_path = Path(self.host_out, 'bin/adb') |
| |
| return_path = atest_utils.get_host_out('bin', 'adb') |
| |
| self.assertEqual(expected_path, return_path) |
| |
| |
| class GetBuildOutDirTests(unittest.TestCase): |
| """Test get_build_out_dir() for various conditions.""" |
| |
| def setUp(self) -> None: |
| self.abs_OUT_DIR = '/somewhere/out' |
| self.rel_OUT_DIR = 'somewhere/out' |
| self.abs_OUT_DIR_COMMON_BASE = '/somewhere/common_out' |
| self.rel_OUT_DIR_COMMON_BASE = 'somewhere/common_out' |
| |
| def test_get_build_abs_out_dir(self): |
| """Test when OUT_DIR is an absolute path.""" |
| with mock.patch.dict( |
| 'os.environ', |
| { |
| constants.ANDROID_BUILD_TOP: '/src/build/top', |
| 'OUT_DIR': self.abs_OUT_DIR, |
| }, |
| ): |
| expected_out_dir = Path(self.abs_OUT_DIR) |
| |
| returned_out_dir = atest_utils.get_build_out_dir() |
| |
| self.assertEqual(expected_out_dir, returned_out_dir) |
| |
| def test_get_build_rel_out_dir(self): |
| """Test when OUT_DIR is a relative path.""" |
| with mock.patch.dict( |
| 'os.environ', |
| { |
| constants.ANDROID_BUILD_TOP: '/src/build/top', |
| 'OUT_DIR': self.rel_OUT_DIR, |
| }, |
| ): |
| expected_out_dir = atest_utils.get_build_top(self.rel_OUT_DIR) |
| |
| returned_out_dir = atest_utils.get_build_out_dir() |
| |
| self.assertEqual(expected_out_dir, returned_out_dir) |
| |
| def test_get_build_abs_out_dir_common_base(self): |
| """Test whe OUT_DIR_COMMON_BASE is an absolute path.""" |
| build_top_path = '/src/build/top' |
| branch_name = Path(build_top_path).name |
| with mock.patch.dict( |
| 'os.environ', |
| { |
| constants.ANDROID_BUILD_TOP: build_top_path, |
| 'OUT_DIR_COMMON_BASE': self.abs_OUT_DIR_COMMON_BASE, |
| }, |
| ): |
| expected_out_dir = Path(self.abs_OUT_DIR_COMMON_BASE, branch_name) |
| |
| returned_out_dir = atest_utils.get_build_out_dir() |
| |
| self.assertEqual(expected_out_dir, returned_out_dir) |
| |
| def test_get_build_rel_out_dir_common_base(self): |
| """Test whe OUT_DIR_COMMON_BASE is a relative path.""" |
| build_top_path = '/src/build/top' |
| branch_name = Path(build_top_path).name |
| with mock.patch.dict( |
| 'os.environ', |
| { |
| constants.ANDROID_BUILD_TOP: build_top_path, |
| 'OUT_DIR_COMMON_BASE': self.rel_OUT_DIR_COMMON_BASE, |
| }, |
| ): |
| expected_out_dir = Path( |
| build_top_path, self.rel_OUT_DIR_COMMON_BASE, branch_name |
| ) |
| |
| returned_out_dir = atest_utils.get_build_out_dir() |
| |
| self.assertEqual(expected_out_dir, returned_out_dir) |
| |
| def test_get_build_out_dir(self): |
| """Test when OUT_DIR and OUT_DIR_COMMON_BASE are null.""" |
| with mock.patch.dict( |
| 'os.environ', {constants.ANDROID_BUILD_TOP: '/src/build/top'} |
| ): |
| expected_out_dir = atest_utils.get_build_top('out') |
| |
| returned_out_dir = atest_utils.get_build_out_dir() |
| |
| self.assertEqual(expected_out_dir, returned_out_dir) |
| |
| |
| # pylint: disable=protected-access |
| # pylint: disable=too-many-public-methods |
| class AtestUtilsUnittests(unittest.TestCase): |
| """Unit tests for atest_utils.py""" |
| |
| def test_capture_fail_section_has_fail_section(self): |
| """Test capture_fail_section when has fail section.""" |
| test_list = [ |
| 'AAAAAA', |
| 'FAILED: Error1', |
| '^\n', |
| 'Error2\n', |
| '[ 6% 191/2997] BBBBBB\n', |
| 'CCCCC', |
| '[ 20% 322/2997] DDDDDD\n', |
| 'EEEEE', |
| ] |
| want_list = ['FAILED: Error1', '^\n', 'Error2\n'] |
| self.assertEqual(want_list, atest_utils._capture_fail_section(test_list)) |
| |
| def test_capture_fail_section_no_fail_section(self): |
| """Test capture_fail_section when no fail section.""" |
| test_list = ['[ 6% 191/2997] XXXXX', 'YYYYY: ZZZZZ'] |
| want_list = [] |
| self.assertEqual(want_list, atest_utils._capture_fail_section(test_list)) |
| |
| def test_is_test_mapping_none_test_mapping_args(self): |
| """Test method is_test_mapping.""" |
| non_tm_args = ['--host-unit-test-only'] |
| |
| for argument in non_tm_args: |
| args = arg_parser.create_atest_arg_parser().parse_args([argument]) |
| self.assertFalse( |
| atest_utils.is_test_mapping(args), |
| 'Option %s indicates NOT a test_mapping!' % argument, |
| ) |
| |
| def test_is_test_mapping_test_mapping_args(self): |
| """Test method is_test_mapping.""" |
| tm_args = ['--test-mapping', '--include-subdirs'] |
| |
| for argument in tm_args: |
| args = arg_parser.create_atest_arg_parser().parse_args([argument]) |
| self.assertTrue( |
| atest_utils.is_test_mapping(args), |
| 'Option %s indicates a test_mapping!' % argument, |
| ) |
| |
| def test_is_test_mapping_implicit_test_mapping(self): |
| """Test method is_test_mapping.""" |
| args = arg_parser.create_atest_arg_parser().parse_args( |
| ['--test', '--build', ':postsubmit'] |
| ) |
| self.assertTrue( |
| atest_utils.is_test_mapping(args), |
| 'Option %s indicates a test_mapping!' % args, |
| ) |
| |
| def test_is_test_mapping_with_testname(self): |
| """Test method is_test_mapping.""" |
| irrelevant_args = ['--test', ':postsubmit', 'testname'] |
| |
| args = arg_parser.create_atest_arg_parser().parse_args(irrelevant_args) |
| self.assertFalse( |
| atest_utils.is_test_mapping(args), |
| 'Option %s indicates a test_mapping!' % args, |
| ) |
| |
| def test_is_test_mapping_false(self): |
| """Test method is_test_mapping.""" |
| args = arg_parser.create_atest_arg_parser().parse_args( |
| ['--test', '--build', 'hello_atest'] |
| ) |
| |
| self.assertFalse(atest_utils.is_test_mapping(args)) |
| |
| def test_has_colors(self): |
| """Test method _has_colors.""" |
| # stream is file I/O |
| stream = open('/tmp/test_has_colors.txt', 'wb') |
| self.assertFalse(atest_utils._has_colors(stream)) |
| stream.close() |
| |
| # stream is not a tty(terminal). |
| stream = mock.Mock() |
| stream.isatty.return_value = False |
| self.assertFalse(atest_utils._has_colors(stream)) |
| |
| # stream is a tty(terminal). |
| stream = mock.Mock() |
| stream.isatty.return_value = True |
| self.assertTrue(atest_utils._has_colors(stream)) |
| |
| @mock.patch('atest.atest_utils._has_colors') |
| def test_colorize(self, mock_has_colors): |
| """Test method colorize.""" |
| original_str = 'test string' |
| green_no = 2 |
| |
| # _has_colors() return False. |
| mock_has_colors.return_value = False |
| converted_str = atest_utils.colorize( |
| original_str, green_no, bp_color=constants.RED |
| ) |
| self.assertEqual(original_str, converted_str) |
| |
| # Green text with red background. |
| mock_has_colors.return_value = True |
| converted_str = atest_utils.colorize( |
| original_str, green_no, bp_color=constants.RED |
| ) |
| green_highlight_string = '\x1b[1;32;41m%s\x1b[0m' % original_str |
| self.assertEqual(green_highlight_string, converted_str) |
| |
| # Green text, no background. |
| mock_has_colors.return_value = True |
| converted_str = atest_utils.colorize(original_str, green_no) |
| green_no_highlight_string = '\x1b[1;32m%s\x1b[0m' % original_str |
| self.assertEqual(green_no_highlight_string, converted_str) |
| |
| @mock.patch('atest.atest_utils.colorful_print') |
| @mock.patch('logging.error') |
| def test_print_and_log_error_no_format_prints_and_logs( |
| self, mocked_print, locked_error_logging |
| ): |
| atest_utils.print_and_log_error('no format') |
| |
| mocked_print.assert_called_once() |
| locked_error_logging.assert_called_once() |
| |
| @mock.patch('atest.atest_utils.colorful_print') |
| def test_print_and_log_error_single_non_string_prints(self, mocked_print): |
| atest_utils.print_and_log_error(123) |
| |
| mocked_print.assert_called_once() |
| |
| @mock.patch('atest.atest_utils.colorful_print') |
| def test_print_and_log_error_with_format_prints(self, mocked_print): |
| atest_utils.print_and_log_error('1+1=%s', 2) |
| |
| mocked_print.assert_called_once() |
| |
| @mock.patch('atest.atest_utils.colorful_print') |
| def test_print_and_log_error_bad_value_no_throw_no_print(self, mocked_print): |
| atest_utils.print_and_log_error('bad format %', 'format arg') |
| |
| mocked_print.assert_not_called() |
| |
| @mock.patch('atest.atest_utils.colorful_print') |
| def test_print_and_log_error_missing_format_arg_no_print(self, mocked_print): |
| atest_utils.print_and_log_error('bad format %s %s', 'format arg') |
| |
| mocked_print.assert_not_called() |
| |
| @mock.patch('atest.atest_utils.colorful_print') |
| def test_print_and_log_error_extra_format_arg_no_print(self, mocked_print): |
| atest_utils.print_and_log_error( |
| 'bad format %s', 'format arg1', 'format arg2' |
| ) |
| |
| mocked_print.assert_not_called() |
| |
| @mock.patch('atest.atest_utils._has_colors') |
| def test_colorful_print(self, mock_has_colors): |
| """Test method colorful_print.""" |
| testing_str = 'color_print_test' |
| green_no = 2 |
| |
| # _has_colors() return False. |
| mock_has_colors.return_value = False |
| capture_output = StringIO() |
| sys.stdout = capture_output |
| atest_utils.colorful_print( |
| testing_str, green_no, bp_color=constants.RED, auto_wrap=False |
| ) |
| sys.stdout = sys.__stdout__ |
| uncolored_string = testing_str |
| self.assertEqual(capture_output.getvalue(), uncolored_string) |
| |
| # Green text with red background, but no wrap. |
| mock_has_colors.return_value = True |
| capture_output = StringIO() |
| sys.stdout = capture_output |
| atest_utils.colorful_print( |
| testing_str, green_no, bp_color=constants.RED, auto_wrap=False |
| ) |
| sys.stdout = sys.__stdout__ |
| green_highlight_no_wrap_string = '\x1b[1;32;41m%s\x1b[0m' % testing_str |
| self.assertEqual(capture_output.getvalue(), green_highlight_no_wrap_string) |
| |
| # Green text, no background, no wrap. |
| mock_has_colors.return_value = True |
| capture_output = StringIO() |
| sys.stdout = capture_output |
| atest_utils.colorful_print(testing_str, green_no, auto_wrap=False) |
| sys.stdout = sys.__stdout__ |
| green_no_high_no_wrap_string = '\x1b[1;32m%s\x1b[0m' % testing_str |
| self.assertEqual(capture_output.getvalue(), green_no_high_no_wrap_string) |
| |
| # Green text with red background and wrap. |
| mock_has_colors.return_value = True |
| capture_output = StringIO() |
| sys.stdout = capture_output |
| atest_utils.colorful_print( |
| testing_str, green_no, bp_color=constants.RED, auto_wrap=True |
| ) |
| sys.stdout = sys.__stdout__ |
| green_highlight_wrap_string = '\x1b[1;32;41m%s\x1b[0m\n' % testing_str |
| self.assertEqual(capture_output.getvalue(), green_highlight_wrap_string) |
| |
| # Green text with wrap, but no background. |
| mock_has_colors.return_value = True |
| capture_output = StringIO() |
| sys.stdout = capture_output |
| atest_utils.colorful_print(testing_str, green_no, auto_wrap=True) |
| sys.stdout = sys.__stdout__ |
| green_wrap_no_highlight_string = '\x1b[1;32m%s\x1b[0m\n' % testing_str |
| self.assertEqual(capture_output.getvalue(), green_wrap_no_highlight_string) |
| |
| def test_is_supported_mainline_module(self): |
| """Test the installed artifacts are supported.""" |
| self.assertTrue(atest_utils.is_supported_mainline_module('out/foo.apk')) |
| self.assertTrue(atest_utils.is_supported_mainline_module('out/foo.apks')) |
| self.assertTrue(atest_utils.is_supported_mainline_module('out/foo.apex')) |
| self.assertFalse(atest_utils.is_supported_mainline_module('out/foo.capex')) |
| |
| def test_get_test_and_mainline_modules(self): |
| """Test whether the given test reference is a mainline module test.""" |
| # regular test. |
| self.assertIsNone(atest_utils.get_test_and_mainline_modules('test_name')) |
| # missing trailing bracket. |
| self.assertIsNone( |
| atest_utils.get_test_and_mainline_modules('test_name[foo.apk+goo.apex') |
| ) |
| # valid mainline module syntax |
| self.assertIsNotNone( |
| atest_utils.get_test_and_mainline_modules('test_name[foo.apk]') |
| ) |
| self.assertIsNotNone( |
| atest_utils.get_test_and_mainline_modules('test_name[foo.apk+goo.apex]') |
| ) |
| |
| def test_get_test_info_cache_path(self): |
| """Test method get_test_info_cache_path.""" |
| input_file_name = 'mytest_name' |
| cache_root = '/a/b/c' |
| expect_hashed_name = ( |
| '%s.cache' % hashlib.md5(str(input_file_name).encode()).hexdigest() |
| ) |
| self.assertEqual( |
| os.path.join(cache_root, expect_hashed_name), |
| atest_utils.get_test_info_cache_path(input_file_name, cache_root), |
| ) |
| |
| def test_get_and_load_cache(self): |
| """Test method update_test_info_cache and load_test_info_cache.""" |
| test_reference = 'myTestRefA' |
| test_cache_dir = tempfile.mkdtemp() |
| atest_utils.update_test_info_cache( |
| test_reference, [TEST_INFO_A], test_cache_dir |
| ) |
| unittest_utils.assert_equal_testinfo_sets( |
| self, |
| set([TEST_INFO_A]), |
| atest_utils.load_test_info_cache(test_reference, test_cache_dir), |
| ) |
| |
| @mock.patch('subprocess.check_output') |
| def test_get_modified_files(self, mock_co): |
| """Test method get_modified_files""" |
| mock_co.side_effect = [ |
| x.encode('utf-8') |
| for x in ['/a/b/', '\n', 'test_fp1.java\nc/test_fp2.java'] |
| ] |
| self.assertEqual( |
| {'/a/b/test_fp1.java', '/a/b/c/test_fp2.java'}, |
| atest_utils.get_modified_files(''), |
| ) |
| mock_co.side_effect = [ |
| x.encode('utf-8') for x in ['/a/b/', 'test_fp4', '/test_fp3.java'] |
| ] |
| self.assertEqual( |
| {'/a/b/test_fp4', '/a/b/test_fp3.java'}, |
| atest_utils.get_modified_files(''), |
| ) |
| |
| def test_delimiter(self): |
| """Test method delimiter""" |
| self.assertEqual('\n===\n\n', atest_utils.delimiter('=', 3, 1, 2)) |
| |
| def test_has_python_module(self): |
| """Test method has_python_module""" |
| self.assertFalse(atest_utils.has_python_module('M_M')) |
| self.assertTrue(atest_utils.has_python_module('os')) |
| |
| @mock.patch.object(atest_utils, 'matched_tf_error_log', return_value=True) |
| def test_read_zip_single_text(self, _matched): |
| """Test method extract_zip_text include only one text file.""" |
| zip_path = os.path.join( |
| unittest_constants.TEST_DATA_DIR, |
| TEST_ZIP_DATA_DIR, |
| TEST_SINGLE_ZIP_NAME, |
| ) |
| expect_content = '\nfile1_line1\nfile1_line2\n' |
| self.assertEqual(expect_content, atest_utils.extract_zip_text(zip_path)) |
| |
| @mock.patch.object(atest_utils, 'matched_tf_error_log', return_value=True) |
| def test_read_zip_multi_text(self, _matched): |
| """Test method extract_zip_text include multiple text files.""" |
| zip_path = os.path.join( |
| unittest_constants.TEST_DATA_DIR, TEST_ZIP_DATA_DIR, TEST_MULTI_ZIP_NAME |
| ) |
| expect_content = '\nfile1_line1\nfile1_line2\n\nfile2_line1\nfile2_line2\n' |
| self.assertEqual(expect_content, atest_utils.extract_zip_text(zip_path)) |
| |
| def test_matched_tf_error_log(self): |
| """Test method extract_zip_text include multiple text files.""" |
| matched_content = '05-25 17:37:04 E/XXXXX YYYYY' |
| not_matched_content = '05-25 17:37:04 I/XXXXX YYYYY' |
| # Test matched content |
| self.assertEqual(True, atest_utils.matched_tf_error_log(matched_content)) |
| # Test not matched content |
| self.assertEqual( |
| False, atest_utils.matched_tf_error_log(not_matched_content) |
| ) |
| |
| # pylint: disable=no-member |
| def test_read_test_record_proto(self): |
| """Test method read_test_record.""" |
| test_record_file_path = os.path.join( |
| unittest_constants.TEST_DATA_DIR, 'test_record.proto.testonly' |
| ) |
| test_record = atest_utils.read_test_record(test_record_file_path) |
| self.assertEqual( |
| test_record.children[0].inline_test_record.test_record_id, |
| 'x86 hello_world_test', |
| ) |
| |
| def test_load_json_safely_file_inexistent(self): |
| """Test method load_json_safely if file does not exist.""" |
| json_file_path = Path(unittest_constants.TEST_DATA_DIR).joinpath( |
| 'not_exist.json' |
| ) |
| self.assertEqual({}, atest_utils.load_json_safely(json_file_path)) |
| |
| def test_load_json_safely_valid_json_format(self): |
| """Test method load_json_safely if file exists and format is valid.""" |
| json_file_path = Path(unittest_constants.TEST_DATA_DIR).joinpath( |
| 'module-info.json' |
| ) |
| content = atest_utils.load_json_safely(json_file_path) |
| self.assertEqual( |
| 'MainModule1', content.get('MainModule1').get('module_name') |
| ) |
| self.assertEqual( |
| [], content.get('MainModule2').get('test_mainline_modules') |
| ) |
| |
| def test_load_json_safely_invalid_json_format(self): |
| """Test method load_json_safely if file exist but content is invalid.""" |
| json_file_path = Path(unittest_constants.TEST_DATA_DIR).joinpath( |
| 'not-valid-module-info.json' |
| ) |
| self.assertEqual({}, atest_utils.load_json_safely(json_file_path)) |
| |
| @mock.patch('os.getenv') |
| def test_get_manifest_branch(self, mock_env): |
| """Test method get_manifest_branch""" |
| build_top = tempfile.TemporaryDirectory() |
| mock_env.return_value = build_top.name |
| repo_dir = Path(build_top.name).joinpath('.repo') |
| portal_xml = repo_dir.joinpath('manifest.xml') |
| manifest_dir = repo_dir.joinpath('manifests') |
| target_xml = manifest_dir.joinpath('Default.xml') |
| repo_dir.mkdir() |
| manifest_dir.mkdir() |
| content_portal = '<manifest><include name="Default.xml" /></manifest>' |
| content_manifest = """<manifest> |
| <remote name="aosp" fetch=".." review="https://android-review.googlesource.com/" /> |
| <default revision="MONSTER-dev" remote="aosp" sync-j="4" /> |
| </manifest>""" |
| |
| # 1. The manifest.xml(portal) contains 'include' directive: 'Default.xml'. |
| # Search revision in .repo/manifests/Default.xml. |
| with open(portal_xml, 'w') as cache: |
| cache.write(content_portal) |
| with open(target_xml, 'w') as cache: |
| cache.write(content_manifest) |
| self.assertEqual('MONSTER-dev', atest_utils.get_manifest_branch()) |
| self.assertEqual('aosp-MONSTER-dev', atest_utils.get_manifest_branch(True)) |
| os.remove(target_xml) |
| os.remove(portal_xml) |
| |
| # 2. The manifest.xml contains neither 'include' nor 'revision' directive, |
| # keep searching revision in .repo/manifests/default.xml by default. |
| with open(portal_xml, 'w') as cache: |
| cache.write('<manifest></manifest>') |
| default_xml = manifest_dir.joinpath('default.xml') |
| with open(default_xml, 'w') as cache: |
| cache.write(content_manifest) |
| self.assertEqual('MONSTER-dev', atest_utils.get_manifest_branch()) |
| os.remove(default_xml) |
| os.remove(portal_xml) |
| |
| # 3. revision was directly defined in 'manifest.xml'. |
| with open(portal_xml, 'w') as cache: |
| cache.write(content_manifest) |
| self.assertEqual('MONSTER-dev', atest_utils.get_manifest_branch()) |
| os.remove(portal_xml) |
| |
| # 4. Return None if the included xml does not exist. |
| with open(portal_xml, 'w') as cache: |
| cache.write(content_portal) |
| self.assertEqual('', atest_utils.get_manifest_branch()) |
| os.remove(portal_xml) |
| |
| def test_has_wildcard(self): |
| """Test method of has_wildcard""" |
| self.assertFalse(atest_utils.has_wildcard('test1')) |
| self.assertFalse(atest_utils.has_wildcard(['test1'])) |
| self.assertTrue(atest_utils.has_wildcard('test1?')) |
| self.assertTrue(atest_utils.has_wildcard(['test1', 'b*', 'a?b*'])) |
| |
| # pylint: disable=anomalous-backslash-in-string |
| def test_quote(self): |
| """Test method of quote()""" |
| target_str = r'TEST_(F|P)[0-9].*\w$' |
| expected_str = "'TEST_(F|P)[0-9].*\w$'" |
| self.assertEqual(atest_utils.quote(target_str), expected_str) |
| self.assertEqual(atest_utils.quote('TEST_P224'), 'TEST_P224') |
| |
| @mock.patch('builtins.input', return_value='') |
| def test_prompt_with_yn_result(self, mock_input): |
| """Test method of prompt_with_yn_result""" |
| msg = 'Do you want to continue?' |
| mock_input.return_value = '' |
| self.assertTrue(atest_utils.prompt_with_yn_result(msg, True)) |
| self.assertFalse(atest_utils.prompt_with_yn_result(msg, False)) |
| mock_input.return_value = 'y' |
| self.assertTrue(atest_utils.prompt_with_yn_result(msg, True)) |
| mock_input.return_value = 'nO' |
| self.assertFalse(atest_utils.prompt_with_yn_result(msg, True)) |
| |
| def test_get_android_junit_config_filters(self): |
| """Test method of get_android_junit_config_filters""" |
| no_filter_test_config = os.path.join( |
| unittest_constants.TEST_DATA_DIR, 'filter_configs', 'no_filter.cfg' |
| ) |
| self.assertEqual( |
| {}, atest_utils.get_android_junit_config_filters(no_filter_test_config) |
| ) |
| |
| filtered_test_config = os.path.join( |
| unittest_constants.TEST_DATA_DIR, 'filter_configs', 'filter.cfg' |
| ) |
| filter_dict = atest_utils.get_android_junit_config_filters( |
| filtered_test_config |
| ) |
| include_annotations = filter_dict.get(constants.INCLUDE_ANNOTATION) |
| include_annotations.sort() |
| self.assertEqual(['include1', 'include2'], include_annotations) |
| exclude_annotation = filter_dict.get(constants.EXCLUDE_ANNOTATION) |
| exclude_annotation.sort() |
| self.assertEqual(['exclude1', 'exclude2'], exclude_annotation) |
| |
| def test_md5sum_file_existent(self): |
| """Test method of md5sum for an existent file.""" |
| with tempfile.NamedTemporaryFile() as tmp_file: |
| with open(tmp_file.name, 'w', encoding='utf-8') as f: |
| f.write('some context') |
| expected_md5 = '6d583707b0149c07cc19a05f5fdc320c' |
| |
| actual_md5 = atest_utils.md5sum(tmp_file.name) |
| |
| self.assertEqual(actual_md5, expected_md5) |
| |
| def test_md5sum_file_inexistent(self): |
| """Test method of md5sum for an inexistent file.""" |
| inexistent_file = os.path.join('/somewhere/does/not/exist') |
| expected_md5 = '' |
| |
| actual_md5 = atest_utils.md5sum(inexistent_file) |
| |
| self.assertEqual(actual_md5, expected_md5) |
| |
| def test_check_md5(self): |
| """Test method of check_md5""" |
| file1 = os.path.join( |
| unittest_constants.TEST_DATA_DIR, unittest_constants.JSON_FILE |
| ) |
| checksum_file = '/tmp/_tmp_module-info.json' |
| atest_utils.save_md5([file1], '/tmp/_tmp_module-info.json') |
| self.assertTrue(atest_utils.check_md5(checksum_file)) |
| os.remove(checksum_file) |
| self.assertFalse(atest_utils.check_md5(checksum_file)) |
| self.assertTrue(atest_utils.check_md5(checksum_file, missing_ok=True)) |
| |
| def test_get_config_parameter(self): |
| """Test method of get_config_parameter""" |
| parameter_config = os.path.join( |
| unittest_constants.TEST_DATA_DIR, 'parameter_config', 'parameter.cfg' |
| ) |
| no_parameter_config = os.path.join( |
| unittest_constants.TEST_DATA_DIR, 'parameter_config', 'no_parameter.cfg' |
| ) |
| |
| # Test parameter empty value |
| self.assertEqual( |
| set(), atest_utils.get_config_parameter(no_parameter_config) |
| ) |
| |
| # Test parameter empty value |
| self.assertEqual( |
| {'value_1', 'value_2', 'value_3', 'value_4'}, |
| atest_utils.get_config_parameter(parameter_config), |
| ) |
| |
| def test_get_config_device(self): |
| """Test method of get_config_device""" |
| device_config = os.path.join( |
| unittest_constants.TEST_DATA_DIR, |
| 'parameter_config', |
| 'multiple_device.cfg', |
| ) |
| self.assertEqual( |
| {'device_1', 'device_2'}, atest_utils.get_config_device(device_config) |
| ) |
| |
| def test_get_mainline_param(self): |
| """Test method of get_mainline_param""" |
| mainline_param_config = os.path.join( |
| unittest_constants.TEST_DATA_DIR, |
| 'parameter_config', |
| 'mainline_param.cfg', |
| ) |
| self.assertEqual( |
| {'foo1.apex', 'foo2.apk+foo3.apk'}, |
| atest_utils.get_mainline_param(mainline_param_config), |
| ) |
| no_mainline_param_config = os.path.join( |
| unittest_constants.TEST_DATA_DIR, 'parameter_config', 'parameter.cfg' |
| ) |
| self.assertEqual( |
| set(), atest_utils.get_mainline_param(no_mainline_param_config) |
| ) |
| |
| def test_get_full_annotation_class_name(self): |
| """Test method of get_full_annotation_class_name.""" |
| app_mode_full = 'android.platform.test.annotations.AppModeFull' |
| presubmit = 'android.platform.test.annotations.Presubmit' |
| module_info = { |
| 'srcs': [ |
| os.path.join( |
| unittest_constants.TEST_DATA_DIR, |
| 'annotation_testing', |
| 'Annotation.src', |
| ) |
| ] |
| } |
| # get annotation class from keyword |
| self.assertEqual( |
| atest_utils.get_full_annotation_class_name(module_info, 'presubmit'), |
| presubmit, |
| ) |
| # get annotation class from an accurate fqcn keyword. |
| self.assertEqual( |
| atest_utils.get_full_annotation_class_name(module_info, presubmit), |
| presubmit, |
| ) |
| # accept fqcn keyword in lowercase. |
| self.assertEqual( |
| atest_utils.get_full_annotation_class_name( |
| module_info, 'android.platform.test.annotations.presubmit' |
| ), |
| presubmit, |
| ) |
| # unable to get annotation class from keyword. |
| self.assertNotEqual( |
| atest_utils.get_full_annotation_class_name( |
| module_info, 'appleModefull' |
| ), |
| app_mode_full, |
| ) |
| # do not support partial-correct keyword. |
| self.assertNotEqual( |
| atest_utils.get_full_annotation_class_name( |
| module_info, 'android.platform.test.annotations.pres' |
| ), |
| presubmit, |
| ) |
| |
| def test_has_mixed_type_filters_one_module_with_one_type_return_false(self): |
| """Test method of has_mixed_type_filters""" |
| filter_1 = test_info.TestFilter('CLASS', frozenset(['METHOD'])) |
| test_data_1 = {constants.TI_FILTER: [filter_1]} |
| test_info_1 = test_info.TestInfo( |
| 'MODULE', 'RUNNER', set(), test_data_1, 'SUITE', '', set() |
| ) |
| self.assertFalse(atest_utils.has_mixed_type_filters([test_info_1])) |
| |
| def test_has_mixed_type_filters_one_module_with_mixed_types_return_true(self): |
| """Test method of has_mixed_type_filters""" |
| filter_1 = test_info.TestFilter('CLASS', frozenset(['METHOD'])) |
| filter_2 = test_info.TestFilter('CLASS', frozenset(['METHOD*'])) |
| test_data_2 = {constants.TI_FILTER: [filter_1, filter_2]} |
| test_info_2 = test_info.TestInfo( |
| 'MODULE', 'RUNNER', set(), test_data_2, 'SUITE', '', set() |
| ) |
| self.assertTrue(atest_utils.has_mixed_type_filters([test_info_2])) |
| |
| def test_has_mixed_type_filters_two_module_with_mixed_types_return_false( |
| self, |
| ): |
| """Test method of has_mixed_type_filters""" |
| filter_1 = test_info.TestFilter('CLASS', frozenset(['METHOD'])) |
| test_data_1 = {constants.TI_FILTER: [filter_1]} |
| test_info_1 = test_info.TestInfo( |
| 'MODULE', 'RUNNER', set(), test_data_1, 'SUITE', '', set() |
| ) |
| filter_3 = test_info.TestFilter('CLASS', frozenset(['METHOD*'])) |
| test_data_3 = {constants.TI_FILTER: [filter_3]} |
| test_info_3 = test_info.TestInfo( |
| 'MODULE3', 'RUNNER', set(), test_data_3, 'SUITE', '', set() |
| ) |
| self.assertFalse( |
| atest_utils.has_mixed_type_filters([test_info_1, test_info_3]) |
| ) |
| |
| def test_get_filter_types(self): |
| """Test method of get_filter_types.""" |
| filters = set(['CLASS#METHOD']) |
| expect_types = set([FilterType.REGULAR_FILTER.value]) |
| self.assertEqual(atest_utils.get_filter_types(filters), expect_types) |
| |
| filters = set(['CLASS#METHOD*']) |
| expect_types = set([FilterType.WILDCARD_FILTER.value]) |
| self.assertEqual(atest_utils.get_filter_types(filters), expect_types) |
| |
| filters = set(['CLASS#METHOD', 'CLASS#METHOD*']) |
| expect_types = set( |
| [FilterType.WILDCARD_FILTER.value, FilterType.REGULAR_FILTER.value] |
| ) |
| self.assertEqual(atest_utils.get_filter_types(filters), expect_types) |
| |
| filters = set(['CLASS#METHOD?', 'CLASS#METHOD*']) |
| expect_types = set([FilterType.WILDCARD_FILTER.value]) |
| self.assertEqual(atest_utils.get_filter_types(filters), expect_types) |
| |
| def test_get_bp_content(self): |
| """Method get_bp_content.""" |
| # 1. "manifest" and "instrumentation_for" are defined. |
| content = """android_test { |
| // comment |
| instrumentation_for: "AmSlam", // comment |
| manifest: "AndroidManifest-test.xml", |
| name: "AmSlamTests", |
| }""" |
| expected_result = { |
| 'AmSlamTests': { |
| 'target_module': 'AmSlam', |
| 'manifest': 'AndroidManifest-test.xml', |
| } |
| } |
| temp_dir = tempfile.TemporaryDirectory() |
| tmpbp = Path(temp_dir.name).joinpath('Android.bp') |
| with open(tmpbp, 'w') as cache: |
| cache.write(content) |
| self.assertEqual( |
| atest_utils.get_bp_content(tmpbp, 'android_test'), expected_result |
| ) |
| temp_dir.cleanup() |
| |
| # 2. Only name is defined, will give default manifest and null |
| # target_module. |
| content = """android_app { |
| // comment |
| name: "AmSlam", |
| srcs: ["src1.java", "src2.java"] |
| }""" |
| expected_result = { |
| 'AmSlam': {'target_module': '', 'manifest': 'AndroidManifest.xml'} |
| } |
| temp_dir = tempfile.TemporaryDirectory() |
| tmpbp = Path(temp_dir.name).joinpath('Android.bp') |
| with open(tmpbp, 'w') as cache: |
| cache.write(content) |
| self.assertEqual( |
| atest_utils.get_bp_content(tmpbp, 'android_app'), expected_result |
| ) |
| temp_dir.cleanup() |
| |
| # 3. Not even an Android.bp. |
| content = """LOCAL_PATH := $(call my-dir) |
| # comment |
| include $(call all-subdir-makefiles) |
| LOCAL_MODULE := atest_foo_test |
| }""" |
| temp_dir = tempfile.TemporaryDirectory() |
| tmpbp = Path(temp_dir.name).joinpath('Android.mk') |
| with open(tmpbp, 'w') as cache: |
| cache.write(content) |
| self.assertEqual(atest_utils.get_bp_content(tmpbp, 'android_app'), {}) |
| temp_dir.cleanup() |
| |
| def test_get_manifest_info(self): |
| """test get_manifest_info method.""" |
| # An instrumentation test: |
| test_xml = os.path.join( |
| unittest_constants.TEST_DATA_DIR, |
| 'foo/bar/AmSlam/test/AndroidManifest.xml', |
| ) |
| expected = { |
| 'package': 'com.android.settings.tests.unit', |
| 'target_package': 'c0m.andr0id.settingS', |
| 'persistent': False, |
| } |
| self.assertEqual(expected, atest_utils.get_manifest_info(test_xml)) |
| |
| # A target module: |
| target_xml = os.path.join( |
| unittest_constants.TEST_DATA_DIR, 'foo/bar/AmSlam/AndroidManifest.xml' |
| ) |
| expected = { |
| 'package': 'c0m.andr0id.settingS', |
| 'target_package': '', |
| 'persistent': False, |
| } |
| self.assertEqual(expected, atest_utils.get_manifest_info(target_xml)) |
| |
| |
| class GetTradefedInvocationTimeTest(fake_filesystem_unittest.TestCase): |
| """Tests of get_tradefed_invocation_time for various conditions.""" |
| |
| def setUp(self): |
| self.setUpPyfakefs() |
| self.log_path = '/somewhere/atest/log' |
| |
| def test_get_tradefed_invocation_time_second_only(self): |
| """Test the parser can handle second and millisecond properly.""" |
| end_host_log_file = Path( |
| self.log_path, |
| 'inv_hashed_path', |
| 'inv_hashed_subpath', |
| 'end_host_log_test1.txt', |
| ) |
| contents = """ |
| =============== Consumed Time ============== |
| x86_64 HelloWorldTests: 1s |
| x86_64 hallo-welt: 768 ms |
| Total aggregated tests run time: 1s |
| ============== Modules Preparation Times ============== |
| x86_64 HelloWorldTests => prep = 2580 ms || clean = 298 ms |
| x86_64 hallo-welt => prep = 1736 ms || clean = 243 ms |
| Total preparation time: 4s || Total tear down time: 541 ms |
| ======================================================= |
| =============== Summary =============== |
| Total Run time: 6s |
| 2/2 modules completed |
| Total Tests : 3 |
| PASSED : 3 |
| FAILED : 0 |
| ============== End of Results ==============""" |
| self.fs.create_file(end_host_log_file, contents=contents) |
| test = 1 * 1000 + 768 |
| prep = 2580 + 1736 |
| teardown = 298 + 243 |
| expected_elapsed_time = (test, prep, teardown) |
| |
| actual_elapsed_time = atest_utils.get_tradefed_invocation_time( |
| self.log_path |
| ) |
| |
| self.assertEqual(actual_elapsed_time, expected_elapsed_time) |
| |
| def test_get_tradefed_invocation_time_from_hours_to_milliseconds(self): |
| """Test whether the parse can handle from hour to ms properly.""" |
| end_host_log_file = Path( |
| self.log_path, |
| 'inv_hashed_path', |
| 'inv_hashed_subpath', |
| 'end_host_log_test2.txt', |
| ) |
| contents = """ |
| =============== Consumed Time ============== |
| x86_64 HelloWorldTests: 27m 19s |
| x86_64 hallo-welt: 3m 2s |
| Total aggregated tests run time: 31m |
| ============== Modules Preparation Times ============== |
| x86_64 HelloWorldTests => prep = 2580 ms || clean = 1298 ms |
| x86_64 hallo-welt => prep = 1736 ms || clean = 1243 ms |
| Total preparation time: 1h 24m 17s || Total tear down time: 3s |
| ======================================================= |
| =============== Summary =============== |
| Total Run time: 2h 5m 17s |
| 2/2 modules completed |
| Total Tests : 3 |
| PASSED : 3 |
| FAILED : 0 |
| ============== End of Results ==============""" |
| self.fs.create_file(end_host_log_file, contents=contents) |
| test = (27 * 60 + 19) * 1000 + (3 * 60 + 2) * 1000 |
| prep = 2580 + 1736 |
| teardown = 1298 + 1243 |
| expected_elapsed_time = (test, prep, teardown) |
| |
| actual_elapsed_time = atest_utils.get_tradefed_invocation_time( |
| self.log_path |
| ) |
| |
| self.assertEqual(actual_elapsed_time, expected_elapsed_time) |
| |
| def test_get_tradefed_invocation_time_null_result(self): |
| """Test whether the parser returns null tuple when no keywords found.""" |
| end_host_log_file = Path( |
| self.log_path, |
| 'inv_hashed_path', |
| 'inv_hashed_subpath', |
| 'end_host_log_test4.txt', |
| ) |
| contents = 'some\ncontext' |
| self.fs.create_file(end_host_log_file, contents=contents) |
| expected_elapsed_time = (0, 0, 0) |
| |
| actual_elapsed_time = atest_utils.get_tradefed_invocation_time( |
| self.log_path |
| ) |
| |
| self.assertEqual(actual_elapsed_time, expected_elapsed_time) |
| |
| |
| if __name__ == '__main__': |
| unittest.main() |
