# Copyright 2022 The ChromiumOS Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

from autotest_lib.client.common_lib import utils
from autotest_lib.server.site_tests.tast import tast

AUTHOR = 'ChromiumOS Firmware EngProd team'
NAME = 'tast.firmware-bios-lvl2'
METADATA = {
        "contacts": ["chromeos-faft@google.com", "jbettis@chromium.org"],
        "bug_component": "b:792402", # ChromeOS > Platform > Enablement > Firmware > FAFT
        "criteria": "Run Tast tests for firmware"
}
TIME = 'MEDIUM'
TEST_TYPE = 'Server'
DEPENDENCIES = 'servo_state:WORKING'
ATTRIBUTES = 'suite:faft_lv2'
MAX_RESULT_SIZE_KB = 1024 * 1024
JOB_RETRIES = 0

# tast.py uses binaries installed from autotest_server_package.tar.bz2.
REQUIRE_SSP = True

DOC = '''
Run Tast tests for AP firmware.

The tests are part of 'group:firmware'. The 'firmware_level2' sub-attribute
limits it to level 2 AP bios tests.
'''

command_args, varslist = tast.split_arguments(args)
args_dict = utils.args_to_dict(command_args)
servo_args = hosts.CrosHost.get_servo_arguments(args_dict)

def run(machine):
    job.run_test('tast',
                 host=hosts.create_host(machine, servo_args=servo_args),
                 test_exprs=['("group:firmware" && firmware_level2)'],
                 ignore_test_failures=True, max_run_sec=10800,
                 command_args=command_args,
                 varslist=varslist)

parallel_simple(run, machines)
