# 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 datetime

from autotest_lib.client.common_lib import error
from autotest_lib.client.common_lib.cros import tpm_utils
from autotest_lib.client.common_lib.cros import vpd_utils
from autotest_lib.server import autotest
from autotest_lib.server import test


class rlz_CheckPing(test.test):
    """
    Tests if we are sending RLZ install (CAI) and first-use (CAF) pings in a
    variety of different circumstances. Refer to the TestTracker RLZ test plan
    for more information:
    https://testtracker.googleplex.com/testplans/details/25301

    """
    version = 1

    _CLIENT_TEST = 'desktopui_CheckRlzPingSent'
    _PING_VPD = 'should_send_rlz_ping'
    _DATE_VPD = 'rlz_embargo_end_date'

    def _check_rlz_brand_code(self):
        """Checks that we have an rlz brand code."""
        try:
            self._host.run('cros_config / brand-code')
        except error.AutoservRunError as e:
            raise error.TestFail('DUT is missing brand_code: %s.' %
                                 e.result_obj.stderr)


    def _set_vpd_values(self, should_send_rlz_ping, rlz_embargo_end_date):
        """
        Sets the required vpd values for the test.

        @param should_send_rlz_ping: Value to set should_send_rlz_ping. 1 to
                                     send the ping, 0 to not send it, None to
                                     clear it from the VPD.
        @param embargo_date: Date for rlz_embargo_end_date value. This should
                             be a datetime.date object with the desired date
                             for rlz_embargo_end_date, or None to clear it and
                             proceed with rlz_embargo_end_date not set.

        """
        to_set = {}
        if should_send_rlz_ping is not None:
            to_set[self._PING_VPD] = should_send_rlz_ping
        else:
            vpd_utils.vpd_delete(host=self._host, key=self._PING_VPD,
                                 dump=True, force_dump=True)

        if rlz_embargo_end_date:
            to_set[self._DATE_VPD] = rlz_embargo_end_date.isoformat()
        else:
            vpd_utils.vpd_delete(host=self._host, key=self._DATE_VPD,
                                 dump=True, force_dump=True)

        if to_set:
            vpd_utils.vpd_set(host=self._host, vpd_dict=to_set, dump=True,
                              force_dump=True)


    def _check_rlz_vpd_settings_post_ping(self, should_send_rlz_ping,
                                          rlz_embargo_end_date):
        """
        Checks that rlz related vpd settings are correct after the test.
        In the typical case where the first-use event (CAF) ping is sent
        successfully, both should_send_rlz_ping and rlz_embargo_end_date VPD
        values should be cleared. If the CAF ping is not sent, they will
        remain unchanged.

        @param should_send_rlz_ping: Expected value for the
                                     should_send_rlz_ping VPD setting
                                     (0 or 1). If None, we expect no setting
                                     to be present.
        @param rlz_embargo_end_date: Expected value of the
                                     rlz_embargo_end_date VPD setting.
                                     This argument should be None if expecting
                                     the value to be cleared, and a
                                     datetime.date object containing the
                                     expected date otherwise.

        """
        check_should_send_ping = vpd_utils.vpd_get(host=self._host,
                                                   key=self._PING_VPD)
        if check_should_send_ping is not None:
            check_should_send_ping = int(check_should_send_ping)

        check_date = vpd_utils.vpd_get(host=self._host,
                                       key=self._DATE_VPD)

        if rlz_embargo_end_date:
            rlz_embargo_end_date = rlz_embargo_end_date.isoformat()

        if check_date != rlz_embargo_end_date:
            raise error.TestFail('Unexpected value for rlz_embargo_end_date:'
                                 ' %s' % check_date)

        if check_should_send_ping != should_send_rlz_ping:
            raise error.TestFail('Unexpected value for should_send_rlz_ping:'
                                 ' %s' % check_should_send_ping)


    def run_once(self, host, ping_timeout=30, pre_login=None,
                 rlz_embargo_end_date=None, should_send_rlz_ping=1,
                 check_ping_not_resent=False, reboot=False):
        """
        Configures the DUT to send RLZ pings. Checks for the RLZ client
        install (CAI) and first-use (CAF) pings.

        @param host: Host to run test on.
        @param ping_timeout: Delay time (seconds) before both CAI and CAF
                             pings are sent.
        @param pre_login: Whether or not to login before the main RLZ ping
                          test, and for how long. Should be one of
                          ['lock', 'no_lock', None]. 'lock' is meant for guest
                          mode testing, where a non-guest user must login to
                          'lock' the device for RLZ before the ping can be
                          sent in guest mode. 'no_lock' is to log in with a
                          different user account and log out immediately to
                          ensure no ping is sent. Used to verify that the ping
                          can be sent from subsequent user logins if it has
                          not already been sent.
        @param rlz_embargo_end_date: Date for rlz_embargo_end_date VPD
                                     setting. If None, no value will be set
                                     for rlz_embargo_end_date, and any
                                     existing value will be cleared. For a
                                     specific rlz_embargo_end_date, this
                                     argument should be a datetime.date
                                     object containing the desired date.
        @param should_send_rlz_ping: Value of the should_send_rlz_ping VPD
                                     setting. 1 to send the first-use (CAF)
                                     ping, 0 to not send it. The ping should
                                     not be sent when the VPD value is 0,
                                     which in the normal use-case occurs after
                                     the CAF ping has been sent. It is set to
                                     0 after the CAF ping to ensure it is not
                                     sent again in the device's lifetime.
                                     This argument can also be None, in which
                                     case the should_send_rlz_ping VPD setting
                                     will be cleared. No CAF ping should be
                                     sent in this case, either.
        @param check_ping_not_resent: True to perform a second RLZ check with
                                      a different user account for tests that
                                      confirm the first-use (CAF) ping is not
                                      resent. The second check assumes the CAF
                                      ping was sent successfully, so the
                                      should_send_rlz_ping and
                                      rlz_embargo_end_date parameters should
                                      be a combination that ensures it was
                                      sent.
        @param reboot: True to reboot after the first RLZ check.

        """
        self._host = host
        self._check_rlz_brand_code()

        # Clear TPM owner so we have no users on DUT.
        tpm_utils.ClearTPMOwnerRequest(self._host)

        # Set VPD settings that control if the DUT will send a first-use ping.
        self._set_vpd_values(should_send_rlz_ping=should_send_rlz_ping,
                             rlz_embargo_end_date=rlz_embargo_end_date)
        self._host.reboot()

        # We expect first-use (CAF) ping to be sent when:
        # 1. should_send_rlz_ping exists and is 1
        # 2. rlz_embargo_end_date is missing or in the past
        expect_caf = bool(should_send_rlz_ping)
        if rlz_embargo_end_date:
            expect_caf = (expect_caf and
                (datetime.date.today() - rlz_embargo_end_date).days > 0)

        # Login, do a Google search, verify events in RLZ Data file.
        client_at = autotest.Autotest(self._host)
        client_at.run_test(self._CLIENT_TEST, ping_timeout=ping_timeout,
                           expect_caf_ping=expect_caf, pre_login=pre_login,
                           pre_login_username='rlz_user')
        client_at._check_client_test_result(self._host, self._CLIENT_TEST)

        if expect_caf:
            self._check_rlz_vpd_settings_post_ping(
                should_send_rlz_ping=0, rlz_embargo_end_date=None)
        else:
            self._check_rlz_vpd_settings_post_ping(
                should_send_rlz_ping=should_send_rlz_ping,
                rlz_embargo_end_date=rlz_embargo_end_date)

        if reboot:
            self._host.reboot()

        # Log in with another user and verify CAF ping is not resent. This
        # portion of the test assumes a successful run above where expect_caf
        # was True.
        if check_ping_not_resent:
            client_at.run_test(self._CLIENT_TEST, ping_timeout=ping_timeout,
                               expect_caf_ping=False, username='rlz_user',
                               tag="check_ping_not_resent")

            # Confirm VPD settings are also unchanged
            self._check_rlz_vpd_settings_post_ping(
                should_send_rlz_ping=0, rlz_embargo_end_date=None)