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

# TODO(b/338517436): Remove from PVS testplans and remove this file.

from autotest_lib.server import utils

AUTHOR = "ChromeOS Team"
NAME = "firmware_UserRequestRecovery.dev"
METADATA = {
        "contacts": ["chromeos-faft@google.com", "jbettis@chromium.org", "peep-fleet-infra-sw@google.com"],
        "bug_component": "b:792402", # ChromeOS > Platform > Enablement > Firmware > FAFT
        "criteria": "Request recovery mode and check it next reboot",
}
DEPENDENCIES = "servo_state:WORKING, servo_usb_state:NORMAL"
TIME = "SHORT"
TEST_TYPE = "server"

DOC = """
This test requires a USB disk plugged-in, which contains a ChromeOS test
image (built by "build_image --test"). On runtime, this test first requests
a recovery mode on next boot by setting the crossystem recovery_request
flag. It then triggers recovery mode by unplugging and plugging in the USB
disk and checks success of it.
"""

args_dict = utils.args_to_dict(args)
servo_args = hosts.CrosHost.get_servo_arguments(args_dict)

def run_userrequestrecovery(machine):
    host = hosts.create_host(machine, servo_args=servo_args)
    job.run_test("firmware_UserRequestRecovery", host=host, cmdline_args=args,
                 disable_sysinfo=True, dev_mode=True, tag="dev")

parallel_simple(run_userrequestrecovery, machines)
