| # Copyright 2018 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. |
| |
| from recipe_engine import recipe_test_api |
| |
| |
| class FuchsiaBuildTestApi(recipe_test_api.RecipeTestApi): |
| |
| def test(self, |
| name, |
| target='x64', |
| variants=(), |
| build_type='debug', |
| product='products/core.gni', |
| board='boards/x64.gni', |
| tryjob=False, |
| properties=None, |
| create_shards=True, |
| status='success', |
| test_deps=()): |
| """Returns a test case appropriate for yielding from GenTests(). |
| |
| Provides default property values for the common cases. |
| |
| Args: |
| name: Test name. |
| target (str): A build target (e.g., 'x64' or 'arm64'). |
| build_type (str): A build type (e.g., 'debug' or 'release') |
| variants (sequence[str]): Variant selectors to pass to GN. |
| packages (sequence[str]): A sequence of packages to pass to GN to build |
| product (str): A product to pass to GN to build. |
| board (str): A board to pass to GN to build. |
| properties (dict): A dict of properties to override for this test. |
| status (str): One of 'success' (default), 'failure', or |
| 'infra_failure'. The result of the test case will be required to |
| match this. |
| test_deps (sequence[str] or None): Test dependency paths. |
| |
| Returns: |
| TestData object. |
| """ |
| |
| final_properties = { |
| 'target': target, |
| 'variants': variants, |
| 'build_type': build_type, |
| 'product': product, |
| 'board': board, |
| } |
| # Provided properties override the defaults. |
| properties = properties or {} |
| final_properties.update(properties) |
| |
| # Assemble the return value. |
| ret = self.m.status_check.test(name, status=status) |
| |
| # Add buildbucket properties |
| if tryjob: |
| ret += self.m.buildbucket.try_build( |
| project='fuchsia', |
| git_repo='https://fuchsia.googlesource.com/fuchsia', |
| ) |
| else: |
| final_properties['gcs_bucket'] = '###fuchsia-build###' |
| ret += self.m.buildbucket.ci_build( |
| project='fuchsia', |
| git_repo='https://fuchsia.googlesource.com/fuchsia', |
| ) |
| |
| ret += self.m.properties(**final_properties) |
| |
| if create_shards: |
| ret += self.create_shards_step_data(shards=[ |
| self.m.testsharder.shard( |
| name='Vim2', |
| tests=[ |
| self.m.testsharder.test( |
| name='test', |
| label='//path/to/test:test(//toolchain)', |
| os='linux', |
| path='/path/to/test', |
| deps=test_deps, |
| ) |
| ], |
| dimensions=dict(device_type='Khadas Vim2 Max'), |
| ), |
| ]) |
| return ret |
| |
| def mock_image_manifest(self): |
| """Returns a mock image manifest. |
| |
| Args: |
| arch (str): The target architecture of the build. |
| """ |
| return self.m.json.output([{ |
| 'name': 'zircon-a', |
| 'type': 'zbi', |
| 'path': 'fuchsia.zbi', |
| 'bootserver_pave': ['--boot', '--zircona'], |
| }, { |
| 'name': 'storage-full', |
| 'type': 'blk', |
| 'path': 'fvm.blk', |
| }, { |
| 'name': 'storage-sparse', |
| 'type': 'blk', |
| 'path': 'fvm.sparse.blk', |
| 'bootserver_pave': ['--fvm'], |
| }, { |
| 'name': 'efi', |
| 'type': 'blk', |
| 'path': 'fuchsia.esp.blk', |
| 'bootserver_pave': ['--efi'], |
| }, { |
| 'name': 'netboot', |
| 'type': 'zbi', |
| 'path': 'netboot.zbi', |
| 'bootserver_netboot': ['--boot'], |
| }, { |
| 'name': 'archive', |
| 'path': 'build-archive.tgz', |
| 'type': 'tgz', |
| }, { |
| 'name': 'archive', |
| 'path': 'build-archive.zip', |
| 'type': 'zip', |
| }, { |
| 'name': 'qemu-kernel', |
| 'path': 'multiboot.bin', |
| 'type': 'kernel' |
| }, { |
| 'name': 'symbol-archive', |
| 'path': 'symbol-archive.tgz', |
| 'type': 'tgz', |
| }, { |
| 'name': 'zircon-r', |
| 'type': 'zbi', |
| 'path': 'zircon-r.zbi', |
| 'bootserver_pave': ['--zircon-r'], |
| }, { |
| 'name': 'zircon-r', |
| 'type': 'zbi', |
| 'path': 'zedboot.zbi', |
| 'bootserver_pave_zedboot': ['--zircona'], |
| }]) |
| |
| def mock_test_spec_manifest(self): |
| """Returns a mock manifest of test specs in a build.""" |
| return self.m.json.output([ |
| { |
| 'test': { |
| 'name': 'foo_tests', |
| 'label': '//public/lib/foo:foo_tests(//some/toolchain)', |
| 'os': 'linux', |
| 'path': 'path/on/disk/to/test', |
| } |
| }, |
| { |
| 'test': { |
| 'name': 'bar_unittests', |
| 'label': '//lib/bar:bar_unittests(//some/toolchain)', |
| 'os': 'fuchsia', |
| 'path': 'path/on/fuchsia/to/test', |
| } |
| }, |
| ]) |
| |
| def mock_tool_paths_manifest(self): |
| prebuilt_tools = [ |
| 'bazel', 'cargo', 'clang-doc', 'clang-format-diff', 'clang-format', |
| 'clang-tidy-diff', 'clang-tidy', 'dart', 'dartfmt', 'gn', 'go', 'gofmt', |
| 'llvm-cov', 'llvm-profdata', 'llvm-symbolizer', 'ninja', 'rustc', |
| 'rustdoc', 'rustfmt', 'yapf' |
| ] |
| built_zircon_tools = [ |
| 'bootserver', 'fidl-format', 'fidl-lint', 'fvm', 'minfs', 'zbi' |
| ] |
| built_tools = [ |
| 'artifactory', 'bootserver_new', 'botanist', 'covargs', 'debroot', |
| 'ninjatrace', 'seriallistener', 'size_checker', 'symbolize', |
| 'testrunner', 'testsharder', 'upload_debug_symbols' |
| ] |
| |
| def tool_entry(tool_name, os, cpu, path): |
| return { |
| 'cpu': cpu, |
| 'label': '//tools/%s' % tool_name, |
| 'name': tool_name, |
| 'os': os, |
| 'path': path |
| } |
| |
| entries = [] |
| for os in ['linux', 'mac']: |
| for cpu in ['x64', 'arm64']: |
| for tool in prebuilt_tools: |
| entries.append( |
| tool_entry( |
| tool, os, cpu, '../../prebuilt/third_party/%s/%s_%s/%s' % |
| (tool, os, cpu, tool))) |
| for tool in built_zircon_tools: |
| entries.append( |
| tool_entry(tool, os, cpu, |
| '../default.zircon/host-%s-%s/%s' % (os, cpu, tool))) |
| for tool in built_tools: |
| entries.append( |
| tool_entry(tool, os, cpu, '%s_%s/%s' % (os, cpu, tool))) |
| return self.m.json.output(entries) |
| |
| def mock_zircon_instructions(self): |
| """Returns a mock zircon.json file.""" |
| return self.m.json.output({ |
| 'dir': '../default.zircon', |
| 'targets': ['legacy-host_tests', 'manifest-$cpu'], |
| }) |
| |
| def create_shards_step_data(self, shards): |
| """Returns mock step data for test shards. |
| |
| This should be used by any test which calls api.fuchsia.test*() and expects |
| to shard tests. |
| |
| Args: |
| shards (seq[api.testsharder.Shard]): A set of example shards which should |
| be used as step data for the result of invoking the testsharder. |
| |
| Returns: |
| RecipeTestApi.step_data for the extract_results step. |
| """ |
| return self.m.testsharder.execute( |
| step_name='create test shards', shards=shards) |
| |
| def mock_zbi_test(self, target): |
| return { |
| 'cpu': target, |
| 'name': 'zbi-test-{}'.format(target), |
| 'type': 'zbi', |
| 'success_string': 'purple monkey dishwasher', |
| 'path': '../default.zircon/zbi-test-{}.zbi'.format(target), |
| 'device_types': ['QEMU', 'AEMU', 'DEVICE_TYPE'], |
| } |