| # Copyright 2018 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 json |
| import logging |
| import time |
| |
| from autotest_lib.client.bin import test |
| from autotest_lib.client.bin import utils |
| from autotest_lib.client.common_lib import error |
| from autotest_lib.client.common_lib.cros import chrome |
| from autotest_lib.client.cros import cryptohome |
| from autotest_lib.client.cros.input_playback import input_playback |
| |
| |
| class desktopui_CheckRlzPingSent(test.test): |
| """Tests creating a new user, doing a google search, checking RLZ Data.""" |
| version = 1 |
| |
| _RLZ_DATA_FILE = "/home/chronos/user/RLZ Data" |
| |
| def _verify_rlz_data(self, expect_caf_ping=True): |
| """ |
| Checks the RLZ data file for CAI and CAF ping events. |
| |
| @param expect_caf_ping: True if expecting the CAF event to be in the |
| RLZ data file, False if not expecting it. |
| |
| """ |
| def rlz_data_exists(): |
| """Check rlz data exists.""" |
| rlz_data = json.loads(utils.run('cat "%s"' % |
| self._RLZ_DATA_FILE).stdout) |
| logging.debug('rlz data: %s', rlz_data) |
| if 'stateful_events' in rlz_data: |
| cai_present = 'CAI' in rlz_data['stateful_events']['C']['_'] |
| caf_present = 'CAF' in rlz_data['stateful_events']['C']['_'] |
| return cai_present and (caf_present == expect_caf_ping) |
| return False |
| |
| utils.poll_for_condition(rlz_data_exists, timeout=120) |
| |
| |
| def _check_url_for_rlz(self, cr): |
| """ |
| Does a Google search and ensures there is an rlz parameter. |
| |
| @param cr: Chrome instance. |
| |
| """ |
| timeout_minutes = 2 |
| timeout = time.time() + 60 * timeout_minutes |
| |
| # Setup a keyboard emulator to open new tabs and type a search. |
| with input_playback.InputPlayback() as player: |
| player.emulate(input_type='keyboard') |
| player.find_connected_inputs() |
| |
| while True: |
| # Open a new tab, search in the omnibox. |
| player.blocking_playback_of_default_file( |
| input_type='keyboard', filename='keyboard_ctrl+t') |
| player.blocking_playback_of_default_file( |
| input_type='keyboard', filename='keyboard_b+a+d+enter') |
| logging.info(cr.browser.tabs[-1].url) |
| if 'rlz=' in cr.browser.tabs[-1].url: |
| break |
| else: |
| if time.time() > timeout: |
| raise error.TestFail('RLZ ping did not send in %d ' |
| 'minutes.' % timeout_minutes) |
| time.sleep(10) |
| |
| |
| def _wait_for_rlz_lock(self): |
| """Waits for the DUT to get into locked state after login.""" |
| def get_install_lockbox_finalized_status(): |
| status = cryptohome.get_tpm_more_status() |
| return status.get('install_lockbox_finalized') |
| |
| try: |
| utils.poll_for_condition( |
| lambda: get_install_lockbox_finalized_status(), |
| exception=utils.TimeoutError(), |
| timeout=120) |
| except utils.TimeoutError: |
| raise error.TestFail('Timed out trying to lock the device') |
| |
| |
| def run_once(self, ping_timeout=30, logged_in=True, expect_caf_ping=True): |
| """ |
| Tests whether or not the RLZ install event (CAI) and first-use event |
| (CAF) pings are sent. After the first user login, the CAI ping will |
| be sent after a certain delay. This delay is 24 hours by default, but |
| can be overridden by specifying the rlz-ping-delay flag in |
| /etc/chrome_dev.conf, or by using the --rlz-ping-delay argument to |
| Chrome. Then, if two RW_VPD settings have the correct values |
| (should_send_rlz_ping == 1, rlz_embargo_end_date has passed OR not |
| specified), the CAF ping will be sent as well. Ping status is checked |
| in the /home/chronos/user/'RLZ Data' file, which will contain entries |
| for CAI and CAF pings in the 'stateful_events' section. |
| |
| @param logged_in: True for real login or False for guest mode. |
| @param ping_timeout: Delay time (seconds) before any RLZ pings are |
| sent. |
| @param expect_caf_ping: True if expecting the first-use event (CAF) |
| ping to be sent, False if not expecting it. |
| The ping would not be expected if the relevant |
| RW_VPD settings do not have the right |
| combination of values. |
| |
| """ |
| # Browser arg to make DUT send rlz ping after a short delay. |
| rlz_flag = '--rlz-ping-delay=%d' % ping_timeout |
| |
| # If we are testing the ping is sent in guest mode (logged_in=False), |
| # we need to first do a real login and wait for the DUT to become |
| # 'locked' for rlz. Then logout and enter guest mode. |
| if not logged_in: |
| with chrome.Chrome(logged_in=True, extra_browser_args=rlz_flag): |
| self._wait_for_rlz_lock() |
| |
| with chrome.Chrome(logged_in=logged_in, |
| extra_browser_args=rlz_flag) as cr: |
| self._check_url_for_rlz(cr) |
| self._verify_rlz_data(expect_caf_ping=expect_caf_ping) |