# Copyright (c) 2011 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.

"""Base class for using Chrome PyAuto Automation in autotest tests.

This class takes care of getting the automation framework ready for work.

Things this class does:
  - Enable automation and restart chrome with appropriate flags
  - Log in to default account

The PyAuto framework must be installed on the machine for this to work,
under .../autotest/deps/pyauto_dep/test_src/chrome/pyautolib'. This is
built by the chromeos-chrome ebuild.
"""

import logging
from optparse import OptionParser
import os
import shutil
import subprocess
import sys

from autotest_lib.client.bin import test, utils
from autotest_lib.client.common_lib import error
from autotest_lib.client.cros import constants, cros_ui, cryptohome


class PyAutoTest(test.test):
    """Base autotest class for tests which require the PyAuto framework.

    Inherit this class to make calls to the PyUITest framework.

    Each test begins with a clean browser profile. (ie clean /home/chronos).
    For each test:
      - /home/chronos is cleared before firing up chrome
      - the default test user's cryptohome vault is cleared
      - login as default test user
    Beware however that:
      - chrome sync is still enabled, so the browser might fetch data/prefs over
        the air.
      - Settings not stored in /home/chronos might persist across tests

    Sample test:
        from autotest_lib.client.cros import pyauto_test

        class desktopui_UrlFetch(pyauto_test.PyAutoTest):
            version = 1

            def run_once(self):
                self.pyauto.NavigateToURL('http://www.google.com')
                self.assertEqual('Google', self.pyauto.GetActiveTabTitle)

    This test will login (with the default test account), then navigate to
    Google and verify its title.
    """
    def __init__(self, job, bindir, outputdir):
        test.test.__init__(self, job, bindir, outputdir)

        # Handle to pyauto, for chrome automation.
        self.pyauto = None
        self.pyauto_suite = None

        self._pyauto_dep = 'pyauto_dep'
        self._pyauto_dep_dir = os.path.join(self.autodir, 'deps',
                                            self._pyauto_dep)
        self._test_binary_dir = os.path.join(
            self._pyauto_dep_dir, 'test_src', 'out', 'Release')


    def SetupDeps(self):
        """Set up deps needed for running pyauto."""
        try:
            self.job.install_pkg(self._pyauto_dep, 'dep', self._pyauto_dep_dir)
        except error.PackageInstallError, e:
           raise error.PackageInstallError('%s.  Use --use_emerged?' % e)
        # Make pyauto importable.
        # This can be done only after pyauto_dep dependency has been installed.
        pyautolib_dir = os.path.join(
            os.path.dirname(__file__), os.pardir, 'deps', 'pyauto_dep',
            'test_src', 'chrome', 'test', 'pyautolib')
        if not os.path.isdir(pyautolib_dir):
            raise error.TestError('%s missing.' % pyautolib_dir)
        sys.path.append(pyautolib_dir)

        # Create symlinks to chrome
        try:
            setup_cmd = '/bin/sh %s/%s' % (self._test_binary_dir,
                                           'setup_test_links.sh')
            utils.system(setup_cmd)  # this might raise an exception
        except error.CmdError, e:
            raise error.TestError(e)
        self._SetupSuidPython()


    def _SetupSuidPython(self):
        """Setup suid python which can enable chrome testing interface.

        This is required when running pyauto as non-privileged user (chronos).
        """
        suid_python = os.path.join(self._test_binary_dir, 'suid-python')
        py_path = subprocess.Popen(['which', 'python'],
                                   stdout=subprocess.PIPE).communicate()[0]
        py_path = py_path.strip()
        assert os.path.exists(py_path), 'Could not find python'
        if os.path.islink(py_path):
            linkto = os.readlink(py_path)
            py_path = os.path.join(os.path.dirname(py_path), linkto)
        shutil.copy(py_path, suid_python)
        os.chown(suid_python, 0, 0)
        os.chmod(suid_python, 04755)


    def initialize(self, auto_login=True, extra_chrome_flags=[]):
        """Initialize.

        Expects session_manager to be alive.

        Args:
            auto_login: should we auto login using $default account?
            extra_chrome_flags: Extra chrome flags to pass to chrome, if any.
        """
        assert os.geteuid() == 0, 'Need superuser privileges'

        self.SetupDeps()
        import pyauto

        class PyUITestInAutotest(pyauto.PyUITest):
            """Adaptation of PyUITest for use in Autotest."""
            def runTest(self):
                # unittest framework expects runTest.
                pass

            def ExtraChromeFlags(self):
                args = pyauto.PyUITest.ExtraChromeFlags(self)
                return args + extra_chrome_flags

        parser = OptionParser()
        pyauto._OPTIONS, args = parser.parse_args([])
        pyauto._OPTIONS.channel_id = ''
        pyauto._OPTIONS.no_http_server = True
        pyauto._OPTIONS.remote_host = None

        self.pyauto_suite = pyauto.PyUITestSuite([])
        self.pyauto = PyUITestInAutotest()

        # Enable chrome testing interface and log in to default account
        self.pyauto.setUp()  # connects to pyauto automation
        if auto_login:
            self.LoginToDefaultAccount()


    def LoginToDefaultAccount(self):
        """Login to ChromeOS using $default testing account."""
        creds = constants.CREDENTIALS['$default']
        username = cryptohome.canonicalize(creds[0])
        passwd = creds[1]
        err_mesg = self.pyauto.Login(username, passwd)
        if err_mesg or not self.pyauto.GetLoginInfo()['is_logged_in']:
             raise error.TestError(
                 'Error during Login(%s): %s' % (username, err_mesg))
        logging.info('Logged in as %s' % username)


    def cleanup(self):
        """Clean up after running the test.

        We restart chrome and restart the login manager
        """
        if self.pyauto:
            self.pyauto.tearDown()
            del self.pyauto
        if self.pyauto_suite:
            del self.pyauto_suite

        # Reset the UI.
        cros_ui.restart()

        test.test.cleanup(self)