# Lint as: python2, python3 # Copyright 2017 The Chromium OS 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 logging from autotest_lib.client.bin import utils from autotest_lib.client.common_lib import error from autotest_lib.client.common_lib import lsbrelease_utils from autotest_lib.client.common_lib.cros import chrome from autotest_lib.client.cros.cellular import test_environment from autotest_lib.client.cros.update_engine import nebraska_wrapper from autotest_lib.client.cros.update_engine import update_engine_test class autoupdate_StartOOBEUpdate(update_engine_test.UpdateEngineTest): """Starts a forced update at OOBE. ChromeOS will restart when the update is complete so this test will just start the update. The rest of the processing will be done in a server side test. """ version = 1 def initialize(self): """Test setup.""" super(autoupdate_StartOOBEUpdate, self).initialize() self._clear_custom_lsb_release() def _navigate_to_oobe_update_screen(self): """Navigates to the OOBE update check screen.""" timeout = 30 self._oobe.WaitForJavaScriptCondition( "typeof Oobe == 'function' && typeof OobeAPI == 'object' && " "Oobe.readyForTesting", timeout=timeout) self._oobe.WaitForJavaScriptCondition( "OobeAPI.screens.WelcomeScreen.isVisible()", timeout=timeout) self._oobe.ExecuteJavaScript( "OobeAPI.screens.WelcomeScreen.clickNext()") if not self._oobe.EvaluateJavaScript( "OobeAPI.screens.NetworkScreen.shouldSkip()"): self._oobe.WaitForJavaScriptCondition( "OobeAPI.screens.NetworkScreen.isVisible()", timeout=timeout) self._oobe.ExecuteJavaScript( "OobeAPI.screens.NetworkScreen.clickNext()") if not self._oobe.EvaluateJavaScript( "OobeAPI.screens.EulaScreen.shouldSkip()"): self._oobe.WaitForJavaScriptCondition( "OobeAPI.screens.EulaScreen.isVisible()", timeout=timeout) self._oobe.WaitForJavaScriptCondition( "OobeAPI.screens.EulaScreen.nextButton.isEnabled()", timeout=timeout) self._oobe.ExecuteJavaScript( "OobeAPI.screens.EulaScreen.clickNext()") # TODO(yunkez): remove this check after M92 is in stable if self._oobe.EvaluateJavaScript( "typeof OobeAPI.screens.UpdateScreen == 'object'"): self._oobe.WaitForJavaScriptCondition( "OobeAPI.screens.UpdateScreen.isVisible()", timeout=timeout) else: self._oobe.WaitForJavaScriptCondition("!$('oobe-update').hidden", timeout=timeout) def _start_oobe_update(self, update_url, critical_update): """ Jump to the update check screen at OOBE and wait for update to start. @param update_url: The omaha update URL we expect to call. @param critical_update: True if the update is critical. """ self._create_custom_lsb_release(update_url) # Start chrome instance to interact with OOBE. extra_browser_args = [] if lsbrelease_utils.get_device_type() != 'CHROMEBOOK': extra_browser_args.append('--disable-hid-detection-on-oobe') self._chrome = chrome.Chrome(auto_login=False, extra_browser_args=extra_browser_args) self._oobe = self._chrome.browser.oobe self._navigate_to_oobe_update_screen() timeout = 180 err_str = 'Update did not start within %d seconds.' % timeout try: utils.poll_for_condition(self._is_update_started, error.TestFail(err_str), timeout=timeout) except error.TestFail as e: if critical_update: if not self._get_update_requests(): raise error.TestFail('%s There were no update requests in' ' update_engine.log. OOBE update' ' screen was missed.' % err_str) err_code = self._get_last_error_string() if err_code is not None: raise error.TestFail('%s %s' % (err_str, err_code)) else: raise e def run_once(self, payload_url=None, cellular=False, critical_update=True, full_payload=None, interrupt_network=False, interrupt_progress=0.0): """ Test that will start a forced update at OOBE. @param payload_url: Payload url to pass to Nebraska. @param cellular: True if we should run this test using a sim card. @param critical_update: True if we should have deadline:now in omaha response. @param full_payload: Whether the payload is full or delta. None if we don't have to care about it. @param interrupt_network: True to cause a network interruption after starting the update. Should only be used during a critical update. @param interrupt_progress: If interrupt_network is True, we will wait for the update progress to reach this value before interrupting. Should be expressed as a number between 0 and 1. """ with nebraska_wrapper.NebraskaWrapper( log_dir=self.resultsdir, payload_url=payload_url, persist_metadata=True) as nebraska: config = { 'critical_update': critical_update, 'full_payload': full_payload } nebraska.update_config(**config) update_url = nebraska.get_update_url() # Create a nebraska config, which causes nebraska to start up before update_engine. # This will allow nebraska to be up right after system startup so it can be used in interruption tests. nebraska.create_startup_config(**config) if not cellular: self._start_oobe_update(update_url, critical_update) if interrupt_network: self._wait_for_progress(interrupt_progress) self._take_screenshot(self._BEFORE_INTERRUPT_FILENAME) completed = self._get_update_progress() self._disconnect_reconnect_network_test() self._take_screenshot(self._AFTER_INTERRUPT_FILENAME) if self._is_update_engine_idle(): raise error.TestFail( 'The update was IDLE after interrupt.') if not self._update_continued_where_it_left_off(completed): raise error.TestFail( 'The update did not continue where ' 'it left off after interruption.') # Remove screenshots since the interrupt test succeeded. self._remove_screenshots() return try: with test_environment.CellularOTATestEnvironment() as test_env: service = test_env.shill.wait_for_cellular_service_object() if not service: raise error.TestError('No cellular service found.') connect_timeout = 120 test_env.shill.connect_service_synchronous(service, connect_timeout) self._start_oobe_update(update_url, critical_update) # Set the nebraska startup config's no_update=True for the # post-reboot update check, just in case we don't have time # to server-side. config['no_update'] = True nebraska.create_startup_config(**config) self._clear_custom_lsb_release() # Need to return from this client test before OOBE reboots # or the server test will hang. Cannot return immediately # when the OOBE update starts because all code for cellular # connections is client side and the test will switch to # ethernet. So wait for FINALIZING so payload is downloaded # via cellular and won't ping omaha again. After reboot, # there is a final ping to omaha and login screen is shown. self._wait_for_update_status( self._UPDATE_STATUS_FINALIZING) except error.TestError as e: logging.error('Failure setting up sim card.') raise error.TestFail(e)