| #!/usr/bin/env fuchsia-vendored-python | |
| # Copyright 2026 The Fuchsia Authors. All rights reserved. | |
| # Use of this source code is governed by a BSD-style license that can be | |
| # found in the LICENSE file. | |
| import json | |
| import os | |
| import re | |
| import shutil | |
| import tempfile | |
| import unittest | |
| from pathlib import Path | |
| _SCRIPT_DIR = Path(__file__).parent | |
| from build.bazel.scripts import bazel_tests_utils, build_utils | |
| from build.bazel.scripts.bazel_test_packages import export_path_for_manifest | |
| from build.bazel.scripts.build_utils import BazelPaths, MockCommandRunner | |
| class BazelTestsUtilsTest(unittest.TestCase): | |
| def setUp(self) -> None: | |
| self._td = tempfile.TemporaryDirectory() | |
| self.fuchsia_dir = Path(self._td.name) / "fuchsia" | |
| self.fuchsia_dir.mkdir() | |
| (self.fuchsia_dir / ".jiri_manifest").write_text("") | |
| self.build_dir = self.fuchsia_dir / "out" / "build_dir" | |
| self.build_dir.mkdir(parents=True) | |
| BazelPaths.write_topdir_config_for_test( | |
| self.fuchsia_dir, "gen/build/bazel" | |
| ) | |
| self.bazel_paths = BazelPaths(self.fuchsia_dir, self.build_dir) | |
| # Create the directories that BazelPaths properties expect | |
| self.bazel_paths.launcher.parent.mkdir(parents=True, exist_ok=True) | |
| self.bazel_paths.launcher.write_text("#!/bin/bash\nexit 0") | |
| self.bazel_paths.execroot.mkdir(parents=True, exist_ok=True) | |
| ( | |
| self.bazel_paths.ninja_build_dir / "bazel_host_test_suites.txt" | |
| ).write_text("//fake/test1\n//fake/test2") | |
| ( | |
| self.bazel_paths.ninja_build_dir | |
| / "ungrouped_bazel_target_test_suites.txt" | |
| ).write_text("") | |
| ( | |
| self.bazel_paths.ninja_build_dir | |
| / "target_tests.gn_targets_manifest.json" | |
| ).write_text("[]") | |
| ( | |
| self.bazel_paths.ninja_build_dir / "bazel_target_infos.json" | |
| ).write_text( | |
| json.dumps( | |
| [ | |
| { | |
| "bazel_target": "//build/bazel/target_tests:target_tests_stamp", | |
| "gn_targets_manifest": "target_tests.gn_targets_manifest.json", | |
| } | |
| ] | |
| ) | |
| ) | |
| def tearDown(self) -> None: | |
| self._td.cleanup() | |
| def test_generate_tests_json(self) -> None: | |
| mock_runner = MockCommandRunner() | |
| # Create some fake test info that matches what cquery would return | |
| test_info = { | |
| "label": "//src/my_test:my_test", | |
| "launcher_execroot_path": "bin/my_test", | |
| "runtime_deps_json_execroot_path": "bin/my_test.runtime_deps.json", | |
| "os": "linux", | |
| "cpu": "x64", | |
| "list_cases_argument": "", | |
| } | |
| mock_runner.push_result(stdout=json.dumps(test_info)) | |
| tests_json = bazel_tests_utils.generate_tests_json( | |
| self.bazel_paths, command_runner=mock_runner | |
| ).tests | |
| self.assertEqual(len(tests_json), 1) | |
| entry = tests_json[0] | |
| self.assertEqual(entry["test"]["name"], "//src/my_test:my_test") | |
| self.assertEqual(entry["test"]["label"], "//src/my_test:my_test") | |
| self.assertEqual(entry["test"]["source_label"], "//src/my_test:my_test") | |
| # Verify path conversion | |
| # bazel_paths.execroot is fuchsia_dir/out/build_dir/gen/bazel/output_base/execroot/_main | |
| # path is relative to ninja_build_dir (fuchsia_dir/out/build_dir) | |
| expected_path = os.path.relpath( | |
| self.bazel_paths.execroot / "bin/my_test", | |
| self.bazel_paths.ninja_build_dir, | |
| ) | |
| self.assertEqual(entry["test"]["path"], expected_path) | |
| expected_deps_path = os.path.relpath( | |
| self.bazel_paths.execroot / "bin/my_test.runtime_deps.json", | |
| self.bazel_paths.ninja_build_dir, | |
| ) | |
| self.assertEqual(entry["test"]["runtime_deps"], expected_deps_path) | |
| def test_generate_tests_json_multiple_entries(self) -> None: | |
| mock_runner = MockCommandRunner() | |
| test1 = { | |
| "name": "test1", | |
| "label": "//t1", | |
| "source_label": "//t1", | |
| "launcher_execroot_path": "p1", | |
| "runtime_deps_json_execroot_path": "d1", | |
| "os": "linux", | |
| "cpu": "x64", | |
| "list_cases_argument": "", | |
| } | |
| test2 = { | |
| "name": "test2", | |
| "label": "//t2", | |
| "source_label": "//t2", | |
| "launcher_execroot_path": "p2", | |
| "runtime_deps_json_execroot_path": "d2", | |
| "os": "linux", | |
| "cpu": "x64", | |
| "list_cases_argument": "list_mock_unittests", | |
| } | |
| mock_runner.push_result( | |
| stdout=json.dumps(test1) + "\n" + json.dumps(test2) | |
| ) | |
| tests_json = bazel_tests_utils.generate_tests_json( | |
| self.bazel_paths, command_runner=mock_runner | |
| ).tests | |
| self.assertEqual(len(tests_json), 2) | |
| self.assertEqual(tests_json[0]["test"]["name"], "//t1") | |
| self.assertEqual(tests_json[1]["test"]["name"], "//t2") | |
| execroot_path = "gen/build/bazel/output_base/execroot/_main" | |
| self.assertEqual( | |
| tests_json[0], | |
| { | |
| "environments": [ | |
| { | |
| "dimensions": { | |
| "os": "Linux", | |
| "cpu": "x64", | |
| } | |
| } | |
| ], | |
| "expects_ssh": False, | |
| "test": { | |
| "name": f"//t1", | |
| "label": "//t1", | |
| "source_label": "//t1", | |
| "path": f"{execroot_path}/p1", | |
| "runtime_deps": f"{execroot_path}/d1", | |
| "os": "linux", | |
| "cpu": "x64", | |
| }, | |
| }, | |
| ) | |
| self.assertEqual( | |
| tests_json[1], | |
| { | |
| "environments": [ | |
| { | |
| "dimensions": { | |
| "os": "Linux", | |
| "cpu": "x64", | |
| } | |
| } | |
| ], | |
| "expects_ssh": False, | |
| "test": { | |
| "name": f"//t2", | |
| "label": "//t2", | |
| "source_label": "//t2", | |
| "path": f"{execroot_path}/p2", | |
| "runtime_deps": f"{execroot_path}/d2", | |
| "os": "linux", | |
| "cpu": "x64", | |
| "list_cases_argument": "list_mock_unittests", | |
| }, | |
| }, | |
| ) | |
| def test_generate_tests_json_failure(self) -> None: | |
| mock_runner = MockCommandRunner() | |
| mock_runner.push_result(returncode=1, stderr="Bazel error") | |
| with self.assertRaisesRegex( | |
| RuntimeError, "Failed to run bazel query: Bazel error" | |
| ): | |
| bazel_tests_utils.generate_tests_json( | |
| self.bazel_paths, command_runner=mock_runner | |
| ) | |
| def test_generate_tests_json_starlark_evaluation_error(self) -> None: | |
| self._setUpDeviceTests(["//fake/device_tests"]) | |
| mock_runner = MockCommandRunner() | |
| mock_runner.push_result( | |
| returncode=0, | |
| stderr="ERROR: Starlark evaluation error for //foo:bar: " | |
| "'FuchsiaTestInfo' value has no field or method 'baz'", | |
| ) | |
| with self.assertRaisesRegex( | |
| RuntimeError, "Starlark evaluation error for //foo:bar" | |
| ): | |
| bazel_tests_utils.generate_tests_json( | |
| self.bazel_paths, command_runner=mock_runner | |
| ) | |
| def test_generate_tests_json_missing_fuchsia_host_test_info(self) -> None: | |
| mock_runner = MockCommandRunner() | |
| missing_info = { | |
| "error": "missing_fuchsia_host_test_info", | |
| "label": "//tools/check-licenses:v2_config_test", | |
| } | |
| mock_runner.push_result(stdout=json.dumps(missing_info)) | |
| with self.assertRaisesRegex( | |
| RuntimeError, | |
| r"Target '//tools/check-licenses:v2_config_test' included in the bazel_host_test_suites GN group is a test target but does not provide FuchsiaHostTestInfo", | |
| ): | |
| bazel_tests_utils.generate_tests_json( | |
| self.bazel_paths, command_runner=mock_runner | |
| ) | |
| def test_generate_tests_json_multiple_missing_fuchsia_host_test_info( | |
| self, | |
| ) -> None: | |
| mock_runner = MockCommandRunner() | |
| missing_info1 = { | |
| "error": "missing_fuchsia_host_test_info", | |
| "label": "//tools/check-licenses:v2_config_test", | |
| } | |
| missing_info2 = { | |
| "error": "missing_fuchsia_host_test_info", | |
| "label": "//tools/whereiscl:whereiscl_test", | |
| } | |
| mock_runner.push_result( | |
| stdout=json.dumps(missing_info1) + "\n" + json.dumps(missing_info2) | |
| ) | |
| with self.assertRaisesRegex( | |
| RuntimeError, | |
| r"The following targets included in the bazel_host_test_suites GN group are test targets but do not provide FuchsiaHostTestInfo:\n - //tools/check-licenses:v2_config_test\n - //tools/whereiscl:whereiscl_test", | |
| ): | |
| bazel_tests_utils.generate_tests_json( | |
| self.bazel_paths, command_runner=mock_runner | |
| ) | |
| def test_generate_tests_json_with_debug_symbols(self) -> None: | |
| mock_runner = MockCommandRunner() | |
| test_info = { | |
| "label": "//src/my_test:my_test", | |
| "launcher_execroot_path": "bin/my_test", | |
| "runtime_deps_json_execroot_path": "bin/my_test.runtime_deps.json", | |
| "unstripped_binary_execroot_path": "bin/my_test_unstripped", | |
| "os": "linux", | |
| "cpu": "x64", | |
| "list_cases_argument": "", | |
| } | |
| mock_runner.push_result(stdout=json.dumps(test_info)) | |
| bazel_tests_utils.generate_tests_json( | |
| self.bazel_paths, command_runner=mock_runner | |
| ) | |
| manifest_file = ( | |
| self.bazel_paths.ninja_build_dir | |
| / "bazel_host_tests.debug_symbols.json" | |
| ) | |
| self.assertTrue(manifest_file.exists()) | |
| execroot_path = "gen/build/bazel/output_base/execroot/_main" | |
| self.assertEqual( | |
| json.loads(manifest_file.read_text()), | |
| [ | |
| { | |
| "cpu": "x64", | |
| "debug": f"{execroot_path}/bin/my_test_unstripped", | |
| "label": "//src/my_test:my_test", | |
| "os": "linux", | |
| } | |
| ], | |
| ) | |
| def _setUpDeviceTests(self, suites: list[str]) -> None: | |
| """Make only the device cquery run, over the given test suite labels.""" | |
| ( | |
| self.bazel_paths.ninja_build_dir / "bazel_host_test_suites.txt" | |
| ).write_text("") | |
| ( | |
| self.bazel_paths.ninja_build_dir | |
| / "ungrouped_bazel_target_test_suites.txt" | |
| ).write_text("\n".join(suites)) | |
| def test_generate_device_tests_json(self) -> None: | |
| self._setUpDeviceTests(["//fake/device_tests"]) | |
| mock_runner = MockCommandRunner() | |
| test_info = { | |
| "label": "@@//src/my_test:my_test", | |
| "package_manifest_execroot_path": "bazel-out/my_test/package_manifest.json", | |
| "os": "fuchsia", | |
| "cpu": "x64", | |
| "test_components": [ | |
| { | |
| "component_name": "my_test", | |
| "package_url": "fuchsia-pkg://fuchsia.com/my-test-package#meta/my_test.cm", | |
| }, | |
| { | |
| "component_name": "my_other_test", | |
| "package_url": "fuchsia-pkg://fuchsia.com/my-test-package#meta/my_other_test.cm", | |
| }, | |
| ], | |
| } | |
| mock_runner.push_result(stdout=json.dumps(test_info)) | |
| tests_json = bazel_tests_utils.generate_tests_json( | |
| self.bazel_paths, command_runner=mock_runner | |
| ).tests | |
| package_manifest = export_path_for_manifest( | |
| "bazel-out/my_test/package_manifest.json" | |
| ) | |
| self.assertEqual( | |
| tests_json, | |
| [ | |
| { | |
| "environments": [], | |
| "expects_ssh": True, | |
| "test": { | |
| "build_rule": "fx_test", | |
| "cpu": "x64", | |
| "label": "@@//src/my_test:my_test", | |
| "source_label": "//src/my_test:my_test", | |
| "name": f"fuchsia-pkg://fuchsia.com/my-test-package#meta/{component}.cm", | |
| "os": "fuchsia", | |
| "package_url": f"fuchsia-pkg://fuchsia.com/my-test-package#meta/{component}.cm", | |
| "package_manifests": [package_manifest], | |
| "log_settings": {"max_severity": "WARN"}, | |
| }, | |
| } | |
| for component in ("my_test", "my_other_test") | |
| ], | |
| ) | |
| packages_list = ( | |
| self.bazel_paths.ninja_build_dir / "bazel_test_packages.list" | |
| ) | |
| self.assertEqual( | |
| json.loads(packages_list.read_text()), | |
| {"content": {"manifests": [package_manifest]}, "version": "1"}, | |
| ) | |
| query_command = mock_runner.commands[-1] | |
| self.assertIn("cquery", query_command) | |
| self.assertIn("--config=fuchsia_platform", query_command) | |
| self.assertIn("FuchsiaTestInfo.cquery", query_command) | |
| def test_generate_device_tests_json_with_debug_symbols(self) -> None: | |
| self._setUpDeviceTests(["//fake/device_tests"]) | |
| mock_runner = MockCommandRunner() | |
| test1 = { | |
| "label": "@@//src/my_test:my_test", | |
| "package_manifest_execroot_path": "bazel-out/my_test/package_manifest.json", | |
| "unstripped_binary_execroot_paths": [ | |
| "bazel-out/my_test/bin/my_test_bin", | |
| "bazel-out/shared/bin/sdk/lib/fdio/libfdio.so", | |
| ], | |
| "os": "fuchsia", | |
| "cpu": "x64", | |
| "test_components": [ | |
| { | |
| "component_name": "my_test", | |
| "package_url": "fuchsia-pkg://fuchsia.com/my-test#meta/my_test.cm", | |
| }, | |
| ], | |
| } | |
| test2 = { | |
| "label": "@@//src/other_test:other_test", | |
| "package_manifest_execroot_path": "bazel-out/other_test/package_manifest.json", | |
| "unstripped_binary_execroot_paths": [ | |
| "bazel-out/other_test/bin/other_test_bin", | |
| "bazel-out/shared/bin/sdk/lib/fdio/libfdio.so", | |
| ], | |
| "os": "fuchsia", | |
| "cpu": "x64", | |
| "test_components": [ | |
| { | |
| "component_name": "other_test", | |
| "package_url": "fuchsia-pkg://fuchsia.com/other-test#meta/other_test.cm", | |
| }, | |
| ], | |
| } | |
| mock_runner.push_result( | |
| stdout=json.dumps(test1) + "\n" + json.dumps(test2) | |
| ) | |
| bazel_tests_utils.generate_tests_json( | |
| self.bazel_paths, command_runner=mock_runner | |
| ) | |
| manifest_file = ( | |
| self.bazel_paths.ninja_build_dir | |
| / "bazel_device_tests.debug_symbols.json" | |
| ) | |
| self.assertTrue(manifest_file.exists()) | |
| execroot_path = "gen/build/bazel/output_base/execroot/_main" | |
| # Shared libraries (e.g. libfdio.so) referenced by multiple test | |
| # packages must be deduplicated in bazel_device_tests.debug_symbols.json. | |
| self.assertEqual( | |
| json.loads(manifest_file.read_text()), | |
| [ | |
| { | |
| "cpu": "x64", | |
| "debug": f"{execroot_path}/bazel-out/my_test/bin/my_test_bin", | |
| "label": "@@//src/my_test:my_test", | |
| "os": "fuchsia", | |
| }, | |
| { | |
| "cpu": "x64", | |
| "debug": f"{execroot_path}/bazel-out/shared/bin/sdk/lib/fdio/libfdio.so", | |
| "label": "@@//src/my_test:my_test", | |
| "os": "fuchsia", | |
| }, | |
| { | |
| "cpu": "x64", | |
| "debug": f"{execroot_path}/bazel-out/other_test/bin/other_test_bin", | |
| "label": "@@//src/other_test:other_test", | |
| "os": "fuchsia", | |
| }, | |
| ], | |
| ) | |
| def test_generate_device_tests_json_build_only(self) -> None: | |
| self._setUpDeviceTests(["//fake/device_tests"]) | |
| mock_runner = MockCommandRunner() | |
| mock_runner.push_result( | |
| stdout=json.dumps( | |
| { | |
| "label": "@@//src/my_test:my_test", | |
| "package_manifest_execroot_path": "bazel-out/my_test/package_manifest.json", | |
| "os": "fuchsia", | |
| "cpu": "x64", | |
| "build_only": True, | |
| "test_components": [ | |
| { | |
| "component_name": "my_test", | |
| "package_url": "fuchsia-pkg://fuchsia.com/my-test-package#meta/my_test.cm", | |
| }, | |
| ], | |
| } | |
| ) | |
| ) | |
| tests_json = bazel_tests_utils.generate_tests_json( | |
| self.bazel_paths, command_runner=mock_runner | |
| ).tests | |
| self.assertTrue(tests_json[0]["build_only"]) | |
| self.assertNotIn("environments", tests_json[0]) | |
| def test_generate_device_tests_json_extra_suite_files(self) -> None: | |
| self._setUpDeviceTests([]) | |
| group1_file = self.bazel_paths.ninja_build_dir / "group1_suites.txt" | |
| group2_file = self.bazel_paths.ninja_build_dir / "group2_suites.txt" | |
| empty_group_file = ( | |
| self.bazel_paths.ninja_build_dir / "empty_group_suites.txt" | |
| ) | |
| group1_file.write_text("//fake/device_tests\n") | |
| group2_file.write_text("//fake/device_tests\n") | |
| empty_group_file.write_text("") | |
| mock_runner = MockCommandRunner() | |
| mock_runner.push_result( | |
| stdout=json.dumps( | |
| { | |
| "label": "@@//src/my_test:my_test", | |
| "package_manifest_execroot_path": "bazel-out/my_test/package_manifest.json", | |
| "os": "fuchsia", | |
| "cpu": "x64", | |
| "test_components": [ | |
| { | |
| "component_name": "my_test", | |
| "package_url": "fuchsia-pkg://fuchsia.com/my-test-package#meta/my_test.cm", | |
| }, | |
| ], | |
| } | |
| ) | |
| ) | |
| result = bazel_tests_utils.generate_tests_json( | |
| self.bazel_paths, | |
| command_runner=mock_runner, | |
| extra_device_suite_files=[ | |
| group1_file, | |
| group2_file, | |
| empty_group_file, | |
| ], | |
| ) | |
| tests_json = result.tests | |
| grouped_tests = result.grouped_tests | |
| self.assertEqual(tests_json, []) | |
| # Duplicate suite tuples across groups only run a single cquery. | |
| self.assertEqual(len(mock_runner.commands), 1) | |
| self.assertEqual(grouped_tests[empty_group_file], []) | |
| self.assertEqual(len(grouped_tests[group1_file]), 1) | |
| self.assertEqual(grouped_tests[group1_file], grouped_tests[group2_file]) | |
| # Mutating one group's test entry must not affect the other group. | |
| grouped_tests[group1_file][0]["test"]["name"] = "mutated" | |
| self.assertEqual( | |
| grouped_tests[group2_file][0]["test"]["name"], | |
| "fuchsia-pkg://fuchsia.com/my-test-package#meta/my_test.cm", | |
| ) | |
| packages_list = ( | |
| self.bazel_paths.ninja_build_dir / "bazel_test_packages.list" | |
| ) | |
| self.assertEqual( | |
| json.loads(packages_list.read_text()), | |
| { | |
| "content": { | |
| "manifests": [ | |
| export_path_for_manifest( | |
| "bazel-out/my_test/package_manifest.json" | |
| ) | |
| ] | |
| }, | |
| "version": "1", | |
| }, | |
| ) | |
| def test_generate_device_tests_json_distinct_groups_and_all_suites( | |
| self, | |
| ) -> None: | |
| # Top-level has a direct fx_test label; group1 has both a direct fx_test | |
| # label and a test_suite() label; bazel_target_test_suites_to_build.txt | |
| # also has a barriered test (e.g. from additional_build_targets) that is not | |
| # in any tests.json group. | |
| self._setUpDeviceTests(["//src/top:top_test"]) | |
| ( | |
| self.bazel_paths.ninja_build_dir | |
| / "bazel_target_test_suites_to_build.txt" | |
| ).write_text( | |
| "//src/top:top_test\n" | |
| "//src/group:suite\n" | |
| "//src/barriered:barriered_test\n" | |
| ) | |
| group1_file = self.bazel_paths.ninja_build_dir / "group1_suites.txt" | |
| # List the suite first to check that the group's tests follow the | |
| # cquery's order rather than the order of the group's labels. | |
| group1_file.write_text("//src/group:suite\n//src/top:top_test\n") | |
| barriered_build_dir = self.bazel_paths.fuchsia_dir / "src/barriered" | |
| barriered_build_dir.mkdir(parents=True) | |
| barriered_build_file = barriered_build_dir / "BUILD.bazel" | |
| barriered_build_file.write_text("") | |
| def make_cquery_entry(name: str, label: str) -> str: | |
| return json.dumps( | |
| { | |
| "label": label, | |
| "package_manifest_execroot_path": f"bazel-out/{name}/package_manifest.json", | |
| "os": "fuchsia", | |
| "cpu": "x64", | |
| "test_components": [ | |
| { | |
| "component_name": name, | |
| "package_url": f"fuchsia-pkg://fuchsia.com/{name}#meta/{name}.cm", | |
| }, | |
| ], | |
| } | |
| ) | |
| mock_runner = MockCommandRunner() | |
| # Single cquery over the union of all suites. | |
| cquery_stdout = "\n".join( | |
| [ | |
| make_cquery_entry("top_test", "@@//src/top:top_test"), | |
| make_cquery_entry("suite_test", "@@//src/group:suite_test"), | |
| make_cquery_entry( | |
| "barriered_test", "@@//src/barriered:barriered_test" | |
| ), | |
| ] | |
| ) | |
| # Then one loading-phase `bazel query` to expand group1, which | |
| # contains a test_suite() label. | |
| query_expressions: list[str] = [] | |
| def command_filter(args: list[str]) -> build_utils.CommandResult: | |
| if "cquery" in args: | |
| return build_utils.CommandResult( | |
| returncode=0, stdout=cquery_stdout, stderr="" | |
| ) | |
| query_file = next( | |
| a.removeprefix("--query_file=") | |
| for a in args | |
| if a.startswith("--query_file=") | |
| ) | |
| query_expressions.append(Path(query_file).read_text()) | |
| return build_utils.CommandResult( | |
| returncode=0, | |
| stdout="//src/group:suite_test\n//src/top:top_test\n", | |
| stderr="", | |
| ) | |
| mock_runner.set_command_filter(command_filter) | |
| result = bazel_tests_utils.generate_tests_json( | |
| self.bazel_paths, | |
| command_runner=mock_runner, | |
| extra_device_suite_files=[group1_file], | |
| ) | |
| tests_json = result.tests | |
| grouped_tests = result.grouped_tests | |
| inputs = result.inputs | |
| # Exactly 1 cquery + 1 loading-phase query for the group. | |
| self.assertEqual(len(mock_runner.commands), 2) | |
| self.assertIn("cquery", mock_runner.commands[0]) | |
| self.assertIn(" query ", mock_runner.commands[1]) | |
| self.assertEqual( | |
| query_expressions, | |
| ["tests(set(//src/group:suite //src/top:top_test))"], | |
| ) | |
| self.assertEqual( | |
| [t["test"]["source_label"] for t in tests_json], | |
| ["//src/top:top_test"], | |
| ) | |
| self.assertEqual( | |
| [t["test"]["source_label"] for t in grouped_tests[group1_file]], | |
| ["//src/top:top_test", "//src/group:suite_test"], | |
| ) | |
| # The barriered test is excluded from tests_json and grouped_tests, but | |
| # its package manifest is included in bazel_test_packages.list and its | |
| # BUILD.bazel is tracked in inputs. | |
| packages_list = ( | |
| self.bazel_paths.ninja_build_dir / "bazel_test_packages.list" | |
| ) | |
| self.assertEqual( | |
| json.loads(packages_list.read_text()), | |
| { | |
| "content": { | |
| "manifests": [ | |
| export_path_for_manifest( | |
| "bazel-out/barriered_test/package_manifest.json" | |
| ), | |
| export_path_for_manifest( | |
| "bazel-out/suite_test/package_manifest.json" | |
| ), | |
| export_path_for_manifest( | |
| "bazel-out/top_test/package_manifest.json" | |
| ), | |
| ] | |
| }, | |
| "version": "1", | |
| }, | |
| ) | |
| self.assertIn(barriered_build_file, inputs) | |
| def test_generate_device_tests_json_group_query_failure(self) -> None: | |
| self._setUpDeviceTests(["//src/top:top_test"]) | |
| group1_file = self.bazel_paths.ninja_build_dir / "group1_suites.txt" | |
| group1_file.write_text("//src/group:suite\n") | |
| def command_filter(args: list[str]) -> build_utils.CommandResult: | |
| if "cquery" in args: | |
| return build_utils.CommandResult( | |
| returncode=0, stdout="", stderr="" | |
| ) | |
| return build_utils.CommandResult( | |
| returncode=1, stdout="", stderr="Bazel error" | |
| ) | |
| mock_runner = MockCommandRunner() | |
| mock_runner.set_command_filter(command_filter) | |
| with self.assertRaisesRegex( | |
| RuntimeError, "Failed to run bazel query: Bazel error" | |
| ): | |
| bazel_tests_utils.generate_tests_json( | |
| self.bazel_paths, | |
| command_runner=mock_runner, | |
| extra_device_suite_files=[group1_file], | |
| ) | |
| def test_generate_device_tests_json_log_settings(self) -> None: | |
| self._setUpDeviceTests(["//fake/device_tests"]) | |
| mock_runner = MockCommandRunner() | |
| mock_runner.push_result( | |
| stdout=json.dumps( | |
| { | |
| "label": "@@//src/my_test:my_test", | |
| "package_manifest_execroot_path": "bazel-out/my_test/package_manifest.json", | |
| "os": "fuchsia", | |
| "cpu": "riscv64", | |
| "max_log_severity": "ERROR", | |
| "min_log_severity": "TRACE", | |
| "test_components": [ | |
| { | |
| "component_name": "my_test", | |
| "package_url": "fuchsia-pkg://fuchsia.com/my-test-package#meta/my_test.cm", | |
| }, | |
| ], | |
| } | |
| ) | |
| ) | |
| tests_json = bazel_tests_utils.generate_tests_json( | |
| self.bazel_paths, command_runner=mock_runner | |
| ).tests | |
| self.assertEqual(len(tests_json), 1) | |
| self.assertEqual( | |
| tests_json[0]["test"]["log_settings"], | |
| {"max_severity": "ERROR", "min_severity": "TRACE"}, | |
| ) | |
| # Environments are resolved later by build_tests_json.py, for any CPU. | |
| self.assertEqual(tests_json[0]["environments"], []) | |
| self.assertEqual(tests_json[0]["test"]["cpu"], "riscv64") | |
| def test_generate_device_tests_json_environments(self) -> None: | |
| self._setUpDeviceTests(["//fake/device_tests"]) | |
| custom_envs = [ | |
| {"dimensions": {"device_type": "AEMU"}}, | |
| {"dimensions": {"device_type": "Intel NUC Kit NUC11TNHv5"}}, | |
| ] | |
| mock_runner = MockCommandRunner() | |
| mock_runner.push_result( | |
| stdout=json.dumps( | |
| { | |
| "label": "@@//src/my_test:my_test", | |
| "package_manifest_execroot_path": "bazel-out/my_test/package_manifest.json", | |
| "os": "fuchsia", | |
| "cpu": "x64", | |
| "environments": custom_envs, | |
| "test_components": [ | |
| { | |
| "component_name": "my_test", | |
| "package_url": "fuchsia-pkg://fuchsia.com/my-test-package#meta/my_test.cm", | |
| }, | |
| { | |
| "component_name": "my_other_test", | |
| "package_url": "fuchsia-pkg://fuchsia.com/my-test-package#meta/my_other_test.cm", | |
| }, | |
| ], | |
| } | |
| ) | |
| ) | |
| tests_json = bazel_tests_utils.generate_tests_json( | |
| self.bazel_paths, command_runner=mock_runner | |
| ).tests | |
| self.assertEqual(len(tests_json), 2) | |
| self.assertEqual(tests_json[0]["environments"], custom_envs) | |
| self.assertEqual(tests_json[1]["environments"], custom_envs) | |
| def test_generate_device_tests_json_realm(self) -> None: | |
| self._setUpDeviceTests(["//fake/device_tests"]) | |
| mock_runner = MockCommandRunner() | |
| mock_runner.push_result( | |
| stdout=json.dumps( | |
| { | |
| "label": "@@//src/my_test:my_test", | |
| "package_manifest_execroot_path": "bazel-out/my_test/package_manifest.json", | |
| "os": "fuchsia", | |
| "cpu": "x64", | |
| "test_components": [ | |
| { | |
| "component_name": "starnix_test", | |
| "package_url": "fuchsia-pkg://fuchsia.com/my-test-package#meta/starnix_test.cm", | |
| "realm": "/core/testing/starnix-tests", | |
| }, | |
| { | |
| "component_name": "hermetic_test", | |
| "package_url": "fuchsia-pkg://fuchsia.com/my-test-package#meta/hermetic_test.cm", | |
| "realm": None, | |
| }, | |
| ], | |
| } | |
| ) | |
| ) | |
| tests_json = bazel_tests_utils.generate_tests_json( | |
| self.bazel_paths, command_runner=mock_runner | |
| ).tests | |
| self.assertEqual(len(tests_json), 2) | |
| self.assertEqual( | |
| tests_json[0]["test"].get("realm"), | |
| "/core/testing/starnix-tests", | |
| ) | |
| self.assertNotIn("realm", tests_json[1]["test"]) | |
| def test_generate_device_tests_json_create_no_exception_channel( | |
| self, | |
| ) -> None: | |
| self._setUpDeviceTests(["//fake/device_tests"]) | |
| mock_runner = MockCommandRunner() | |
| mock_runner.push_result( | |
| stdout="\n".join( | |
| [ | |
| json.dumps( | |
| { | |
| "label": "@@//src/my_test:no_exc_test", | |
| "package_manifest_execroot_path": "bazel-out/no_exc_test/package_manifest.json", | |
| "os": "fuchsia", | |
| "cpu": "x64", | |
| "create_no_exception_channel": True, | |
| "test_components": [ | |
| { | |
| "component_name": "no_exc_test", | |
| "package_url": "fuchsia-pkg://fuchsia.com/no-exc-test#meta/no_exc_test.cm", | |
| }, | |
| ], | |
| } | |
| ), | |
| json.dumps( | |
| { | |
| "label": "@@//src/my_test:normal_test", | |
| "package_manifest_execroot_path": "bazel-out/normal_test/package_manifest.json", | |
| "os": "fuchsia", | |
| "cpu": "x64", | |
| "create_no_exception_channel": False, | |
| "test_components": [ | |
| { | |
| "component_name": "normal_test", | |
| "package_url": "fuchsia-pkg://fuchsia.com/normal-test#meta/normal_test.cm", | |
| }, | |
| ], | |
| } | |
| ), | |
| ] | |
| ) | |
| ) | |
| tests_json = bazel_tests_utils.generate_tests_json( | |
| self.bazel_paths, command_runner=mock_runner | |
| ).tests | |
| self.assertEqual(len(tests_json), 2) | |
| self.assertIs( | |
| tests_json[0]["test"].get("create_no_exception_channel"), True | |
| ) | |
| self.assertNotIn("create_no_exception_channel", tests_json[1]["test"]) | |
| def test_generate_device_tests_json_parallel(self) -> None: | |
| self._setUpDeviceTests(["//fake/device_tests"]) | |
| mock_runner = MockCommandRunner() | |
| mock_runner.push_result( | |
| stdout="\n".join( | |
| [ | |
| json.dumps( | |
| { | |
| "label": "@@//src/my_test:serial_test", | |
| "package_manifest_execroot_path": "bazel-out/serial_test/package_manifest.json", | |
| "os": "fuchsia", | |
| "cpu": "x64", | |
| "parallel": 1, | |
| "test_components": [ | |
| { | |
| "component_name": "serial_test", | |
| "package_url": "fuchsia-pkg://fuchsia.com/serial-test#meta/serial_test.cm", | |
| }, | |
| ], | |
| } | |
| ), | |
| json.dumps( | |
| { | |
| "label": "@@//src/my_test:default_test", | |
| "package_manifest_execroot_path": "bazel-out/default_test/package_manifest.json", | |
| "os": "fuchsia", | |
| "cpu": "x64", | |
| "parallel": 0, | |
| "test_components": [ | |
| { | |
| "component_name": "default_test", | |
| "package_url": "fuchsia-pkg://fuchsia.com/default-test#meta/default_test.cm", | |
| }, | |
| ], | |
| } | |
| ), | |
| ] | |
| ) | |
| ) | |
| tests_json = bazel_tests_utils.generate_tests_json( | |
| self.bazel_paths, command_runner=mock_runner | |
| ).tests | |
| self.assertEqual(len(tests_json), 2) | |
| self.assertEqual(tests_json[0]["test"].get("parallel"), 1) | |
| self.assertNotIn("parallel", tests_json[1]["test"]) | |
| def test_generate_device_tests_json_build_file_inputs(self) -> None: | |
| self._setUpDeviceTests(["//fake/device_tests:suite"]) | |
| suite_build = self.fuchsia_dir / "fake" / "device_tests" / "BUILD.bazel" | |
| suite_build.parent.mkdir(parents=True) | |
| suite_build.write_text("") | |
| test_build = self.fuchsia_dir / "src" / "my_test" / "BUILD" | |
| test_build.parent.mkdir(parents=True) | |
| test_build.write_text("") | |
| mock_runner = MockCommandRunner() | |
| mock_runner.push_result( | |
| stdout=json.dumps( | |
| { | |
| "label": "@@//src/my_test:my_test", | |
| "package_manifest_execroot_path": "bazel-out/my_test/package_manifest.json", | |
| "os": "fuchsia", | |
| "cpu": "x64", | |
| "test_components": [ | |
| { | |
| "component_name": "my_test", | |
| "package_url": "fuchsia-pkg://fuchsia.com/my-test-package#meta/my_test.cm", | |
| }, | |
| ], | |
| } | |
| ) | |
| ) | |
| inputs = bazel_tests_utils.generate_tests_json( | |
| self.bazel_paths, command_runner=mock_runner | |
| ).inputs | |
| self.assertIn(suite_build, inputs) | |
| self.assertIn(test_build, inputs) | |
| def test_generate_device_tests_json_missing_test_info(self) -> None: | |
| self._setUpDeviceTests(["//fake/device_tests"]) | |
| mock_runner = MockCommandRunner() | |
| mock_runner.push_result( | |
| stdout=json.dumps( | |
| { | |
| "error": "missing_fuchsia_test_info", | |
| "label": "@@//src/my_test:my_test", | |
| } | |
| ) | |
| ) | |
| with self.assertRaisesRegex( | |
| RuntimeError, | |
| r"do not provide FuchsiaTestInfo:\n - //src/my_test:my_test", | |
| ): | |
| bazel_tests_utils.generate_tests_json( | |
| self.bazel_paths, command_runner=mock_runner | |
| ) | |
| def test_generate_device_tests_json_unexpected_error(self) -> None: | |
| self._setUpDeviceTests(["//fake/device_tests"]) | |
| mock_runner = MockCommandRunner() | |
| mock_runner.push_result( | |
| stdout=json.dumps( | |
| { | |
| "error": "something_else", | |
| "label": "@@//src/my_test:my_test", | |
| } | |
| ) | |
| ) | |
| with self.assertRaisesRegex( | |
| RuntimeError, r"Unexpected error in cquery output" | |
| ): | |
| bazel_tests_utils.generate_tests_json( | |
| self.bazel_paths, command_runner=mock_runner | |
| ) | |
| def test_bazel_test_packages_list_written_when_no_device_tests( | |
| self, | |
| ) -> None: | |
| mock_runner = MockCommandRunner() | |
| mock_runner.push_result(stdout="") | |
| bazel_tests_utils.generate_tests_json( | |
| self.bazel_paths, command_runner=mock_runner | |
| ) | |
| packages_list = ( | |
| self.bazel_paths.ninja_build_dir / "bazel_test_packages.list" | |
| ) | |
| self.assertEqual( | |
| json.loads(packages_list.read_text()), | |
| {"content": {"manifests": []}, "version": "1"}, | |
| ) | |
| device_debug_manifest = ( | |
| self.bazel_paths.ninja_build_dir | |
| / "bazel_device_tests.debug_symbols.json" | |
| ) | |
| self.assertEqual(json.loads(device_debug_manifest.read_text()), []) | |
| # `build/bazel/tests_json.gn_targets` is also populated so that direct | |
| # `fx build --fuchsia_platform <label>` invocations can use it even when | |
| # no suites are in `ungrouped_bazel_target_test_suites.txt`. | |
| self.assertTrue( | |
| ( | |
| self.bazel_paths.ninja_build_dir | |
| / "build/bazel/tests_json.gn_targets/BUILD.bazel" | |
| ).is_file() | |
| ) | |
| def test_missing_target_tests_stamp_entry_raises(self) -> None: | |
| self._setUpDeviceTests([]) | |
| ( | |
| self.bazel_paths.ninja_build_dir / "bazel_target_infos.json" | |
| ).write_text("[]") | |
| with self.assertRaisesRegex( | |
| RuntimeError, | |
| r"No entry for //build/bazel/target_tests:target_tests_stamp found in", | |
| ): | |
| bazel_tests_utils.generate_tests_json( | |
| self.bazel_paths, command_runner=MockCommandRunner() | |
| ) | |
| def test_merges_host_tests_gn_targets_manifest(self) -> None: | |
| self._setUpDeviceTests([]) | |
| host_tool = self.bazel_paths.ninja_build_dir / "host-tools/ffx" | |
| host_tool.parent.mkdir(parents=True, exist_ok=True) | |
| host_tool.write_text("#!/bin/sh\n") | |
| host_spdx = self.bazel_paths.ninja_build_dir / "ffx.licenses.spdx.json" | |
| host_spdx.write_text("{}") | |
| ( | |
| self.bazel_paths.ninja_build_dir | |
| / "host_tests.gn_targets_manifest.json" | |
| ).write_text( | |
| json.dumps( | |
| [ | |
| { | |
| "bazel_name": "test_data", | |
| "bazel_package": "toolchain_host_x64/src/developer/ffx", | |
| "generator_label": "//src/developer/ffx:host(//build/toolchain:host_x64)", | |
| "license_spdx_file": "ffx.licenses.spdx.json", | |
| "output_files": ["host-tools/ffx"], | |
| } | |
| ] | |
| ) | |
| ) | |
| ( | |
| self.bazel_paths.ninja_build_dir / "bazel_target_infos.json" | |
| ).write_text( | |
| json.dumps( | |
| [ | |
| { | |
| "bazel_target": "//build/bazel/target_tests:target_tests_stamp", | |
| "gn_targets_manifest": "target_tests.gn_targets_manifest.json", | |
| }, | |
| { | |
| "bazel_target": "//build/bazel/host_tests:host_tests_stamp", | |
| "gn_targets_manifest": "host_tests.gn_targets_manifest.json", | |
| }, | |
| ] | |
| ) | |
| ) | |
| bazel_tests_utils.generate_tests_json( | |
| self.bazel_paths, command_runner=MockCommandRunner() | |
| ) | |
| ffx_gn_targets_build = ( | |
| self.bazel_paths.ninja_build_dir | |
| / "build/bazel/tests_json.gn_targets/toolchain_host_x64/src/developer/ffx/BUILD.bazel" | |
| ) | |
| self.assertTrue(ffx_gn_targets_build.is_file()) | |
| self.assertIn("test_data", ffx_gn_targets_build.read_text()) | |
| def test_write_bazel_test_packages_list_only_writes_if_changed( | |
| self, | |
| ) -> None: | |
| packages_list = ( | |
| self.bazel_paths.ninja_build_dir / "bazel_test_packages.list" | |
| ) | |
| bazel_tests_utils.write_bazel_test_packages_list( | |
| self.bazel_paths.ninja_build_dir, ["obj/foo/package_manifest.json"] | |
| ) | |
| os.utime(packages_list, (1000, 1000)) | |
| bazel_tests_utils.write_bazel_test_packages_list( | |
| self.bazel_paths.ninja_build_dir, ["obj/foo/package_manifest.json"] | |
| ) | |
| self.assertEqual(packages_list.stat().st_mtime, 1000) | |
| bazel_tests_utils.write_bazel_test_packages_list( | |
| self.bazel_paths.ninja_build_dir, ["obj/bar/package_manifest.json"] | |
| ) | |
| self.assertNotEqual(packages_list.stat().st_mtime, 1000) | |
| def test_generate_tests_json_preserves_gn_targets_when_unchanged( | |
| self, | |
| ) -> None: | |
| mock_runner = MockCommandRunner() | |
| mock_runner.push_result(stdout="") | |
| bazel_tests_utils.generate_tests_json( | |
| self.bazel_paths, command_runner=mock_runner | |
| ) | |
| gn_targets_dir = ( | |
| self.bazel_paths.ninja_build_dir | |
| / "build/bazel/tests_json.gn_targets" | |
| ) | |
| module_bazel = gn_targets_dir / "MODULE.bazel" | |
| os.utime(module_bazel, (1000, 1000)) | |
| gn_targets_symlink = ( | |
| self.bazel_paths.workspace | |
| / "fuchsia_build_generated/gn_targets_dir" | |
| ) | |
| self.assertTrue(gn_targets_symlink.is_symlink()) | |
| self.assertEqual(gn_targets_symlink.resolve(), gn_targets_dir.resolve()) | |
| symlink_ino = gn_targets_symlink.lstat().st_ino | |
| mock_runner.push_result(stdout="") | |
| bazel_tests_utils.generate_tests_json( | |
| self.bazel_paths, command_runner=mock_runner | |
| ) | |
| self.assertEqual(module_bazel.stat().st_mtime, 1000) | |
| self.assertEqual(gn_targets_symlink.lstat().st_ino, symlink_ino) | |
| self.assertTrue((gn_targets_dir / "all_licenses.spdx.json").exists()) | |
| # Deleting `tests_json.gn_targets` while leaving its | |
| # `.generated-info.json` intact must still repopulate the directory. | |
| shutil.rmtree(gn_targets_dir) | |
| mock_runner.push_result(stdout="") | |
| bazel_tests_utils.generate_tests_json( | |
| self.bazel_paths, command_runner=mock_runner | |
| ) | |
| self.assertTrue(module_bazel.is_file()) | |
| self.assertTrue((gn_targets_dir / "all_licenses.spdx.json").exists()) | |
| class FuchsiaTestInfoCqueryTest(unittest.TestCase): | |
| """Checks that FuchsiaTestInfo.cquery only reads declared provider fields. | |
| Reading an undeclared field makes `bazel cquery` skip the target while | |
| still exiting 0. Bazel doesn't allow load() in cquery formatter files, so | |
| the formatter can't be exercised against the real provider at build time; | |
| compare the field names textually instead. The provider's `init` already | |
| guarantees that every declared field is set. | |
| This is admittedly a hack: it regex-matches source text rather than | |
| parsing Starlark, so it only sees direct `test_info.<field>` reads. It | |
| misses aliases (`info = test_info; info.foo`), `getattr()` calls, and | |
| fields of the nested `test_components` structs, and it depends on the | |
| formatting of `_FUCHSIA_TEST_INFO_FIELDS`. The cquery stderr check in | |
| `bazel_tests_utils._check_starlark_cquery_result()` is the backstop for | |
| anything this test can't see. | |
| """ | |
| def test_cquery_reads_only_declared_fields(self) -> None: | |
| fx_test_bzl = (_SCRIPT_DIR / "../rules/testing/fx_test.bzl").read_text() | |
| fields_block = re.search( | |
| r"^_FUCHSIA_TEST_INFO_FIELDS = \{\n(.*?)^\}", | |
| fx_test_bzl, | |
| re.MULTILINE | re.DOTALL, | |
| ) | |
| assert fields_block, "_FUCHSIA_TEST_INFO_FIELDS not found" | |
| declared = set( | |
| re.findall(r'^ "(\w+)":', fields_block.group(1), re.MULTILINE) | |
| ) | |
| self.assertIn("test_label", declared) | |
| cquery = ( | |
| _SCRIPT_DIR / "../starlark/FuchsiaTestInfo.cquery" | |
| ).read_text() | |
| read = set(re.findall(r"\btest_info\.(\w+)", cquery)) | |
| self.assertIn("test_label", read) | |
| self.assertEqual(read - declared, set()) | |
| if __name__ == "__main__": | |
| unittest.main() |