src/tools/telemetry/telemetry/core/backends/chrome/cros_unittest.py

   1 # Copyright 2014 The Chromium Authors. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4
   5 import logging
   6 import os
   7 import unittest
   8
   9 from telemetry import test
  10 from telemetry.core import browser_finder
  11 from telemetry.core import exceptions
  12 from telemetry.core import extension_to_load
  13 from telemetry.core import util
  14 from telemetry.core.backends.chrome import cros_interface
  15 from telemetry.unittest import options_for_unittests
  16
  17 class CrOSTest(unittest.TestCase):
  18   def setUp(self):
  19     options = options_for_unittests.GetCopy()
  20     self._cri = cros_interface.CrOSInterface(options.cros_remote,
  21                                              options.cros_ssh_identity)
  22     self._is_guest = options.browser_type == 'cros-chrome-guest'
  23     self._username = options.browser_options.username
  24     self._password = options.browser_options.password
  25     self._load_extension = None
  26
  27   def _CreateBrowser(self, autotest_ext=False, auto_login=True):
  28     """Finds and creates a browser for tests. if autotest_ext is True,
  29     also loads the autotest extension"""
  30     options = options_for_unittests.GetCopy()
  31
  32     if autotest_ext:
  33       extension_path = os.path.join(util.GetUnittestDataDir(), 'autotest_ext')
  34       assert os.path.isdir(extension_path)
  35       self._load_extension = extension_to_load.ExtensionToLoad(
  36           path=extension_path,
  37           browser_type=options.browser_type,
  38           is_component=True)
  39       options.extensions_to_load = [self._load_extension]
  40
  41     browser_to_create = browser_finder.FindBrowser(options)
  42     self.assertTrue(browser_to_create)
  43     options.browser_options.create_browser_with_oobe = True
  44     options.browser_options.auto_login = auto_login
  45     return browser_to_create.Create()
  46
  47   def _GetAutotestExtension(self, browser):
  48     """Returns the autotest extension instance"""
  49     extension = browser.extensions[self._load_extension]
  50     self.assertTrue(extension)
  51     return extension
  52
  53   def _IsCryptohomeMounted(self):
  54     """Returns True if cryptohome is mounted. as determined by the cmd
  55     cryptohome --action=is_mounted"""
  56     return self._cri.RunCmdOnDevice(
  57         ['/usr/sbin/cryptohome', '--action=is_mounted'])[0].strip() == 'true'
  58
  59   @test.Enabled('chromeos')
  60   def testCryptohome(self):
  61     """Verifies cryptohome mount status for regular and guest user and when
  62     logged out"""
  63     with self._CreateBrowser() as b:
  64       self.assertEquals(1, len(b.tabs))
  65       self.assertTrue(b.tabs[0].url)
  66       self.assertTrue(self._IsCryptohomeMounted())
  67
  68       # TODO(achuith): Remove dependency on /home/chronos/user.
  69       chronos_fs = self._cri.FilesystemMountedAt('/home/chronos/user')
  70       self.assertTrue(chronos_fs)
  71       if self._is_guest:
  72         self.assertEquals(chronos_fs, 'guestfs')
  73       else:
  74         crypto_fs = self._cri.FilesystemMountedAt(
  75             self._cri.CryptohomePath(self._username))
  76         self.assertEquals(crypto_fs, chronos_fs)
  77
  78     self.assertFalse(self._IsCryptohomeMounted())
  79     self.assertEquals(self._cri.FilesystemMountedAt('/home/chronos/user'),
  80                       '/dev/mapper/encstateful')
  81
  82   def _GetLoginStatus(self, browser):
  83     extension = self._GetAutotestExtension(browser)
  84     self.assertTrue(extension.EvaluateJavaScript(
  85         "typeof('chrome.autotestPrivate') != 'undefined'"))
  86     extension.ExecuteJavaScript('''
  87         window.__login_status = null;
  88         chrome.autotestPrivate.loginStatus(function(s) {
  89           window.__login_status = s;
  90         });
  91     ''')
  92     return util.WaitFor(
  93         lambda: extension.EvaluateJavaScript('window.__login_status'), 10)
  94
  95   @test.Enabled('chromeos')
  96   def testLoginStatus(self):
  97     """Tests autotestPrivate.loginStatus"""
  98     if self._is_guest:
  99       return
 100     with self._CreateBrowser(autotest_ext=True) as b:
 101       login_status = self._GetLoginStatus(b)
 102       self.assertEquals(type(login_status), dict)
 103
 104       self.assertEquals(not self._is_guest, login_status['isRegularUser'])
 105       self.assertEquals(self._is_guest, login_status['isGuest'])
 106       self.assertEquals(login_status['email'], self._username)
 107       self.assertFalse(login_status['isScreenLocked'])
 108
 109   def _IsScreenLocked(self, browser):
 110     return self._GetLoginStatus(browser)['isScreenLocked']
 111
 112   def _LockScreen(self, browser):
 113     self.assertFalse(self._IsScreenLocked(browser))
 114
 115     extension = self._GetAutotestExtension(browser)
 116     self.assertTrue(extension.EvaluateJavaScript(
 117         "typeof chrome.autotestPrivate.lockScreen == 'function'"))
 118     logging.info('Locking screen')
 119     extension.ExecuteJavaScript('chrome.autotestPrivate.lockScreen();')
 120
 121     logging.info('Waiting for the lock screen')
 122     def ScreenLocked():
 123       return (browser.oobe_exists and
 124           browser.oobe.EvaluateJavaScript("typeof Oobe == 'function'") and
 125           browser.oobe.EvaluateJavaScript(
 126           "typeof Oobe.authenticateForTesting == 'function'"))
 127     util.WaitFor(ScreenLocked, 10)
 128     self.assertTrue(self._IsScreenLocked(browser))
 129
 130   def _AttemptUnlockBadPassword(self, browser):
 131     logging.info('Trying a bad password')
 132     def ErrorBubbleVisible():
 133       return not browser.oobe.EvaluateJavaScript('''
 134           document.getElementById('bubble').hidden
 135       ''')
 136     self.assertFalse(ErrorBubbleVisible())
 137     browser.oobe.ExecuteJavaScript('''
 138         Oobe.authenticateForTesting('%s', 'bad');
 139     ''' % self._username)
 140     util.WaitFor(ErrorBubbleVisible, 10)
 141     self.assertTrue(self._IsScreenLocked(browser))
 142
 143   def _UnlockScreen(self, browser):
 144     logging.info('Unlocking')
 145     browser.oobe.ExecuteJavaScript('''
 146         Oobe.authenticateForTesting('%s', '%s');
 147     ''' % (self._username, self._password))
 148     util.WaitFor(lambda: not browser.oobe, 10)
 149     self.assertFalse(self._IsScreenLocked(browser))
 150
 151   @test.Enabled('chromeos')
 152   def testScreenLock(self):
 153     """Tests autotestPrivate.screenLock"""
 154     if self._is_guest:
 155       return
 156     with self._CreateBrowser(autotest_ext=True) as browser:
 157       self._LockScreen(browser)
 158       self._AttemptUnlockBadPassword(browser)
 159       self._UnlockScreen(browser)
 160
 161   @test.Enabled('chromeos')
 162   def testLogout(self):
 163     """Tests autotestPrivate.logout"""
 164     if self._is_guest:
 165       return
 166     with self._CreateBrowser(autotest_ext=True) as b:
 167       extension = self._GetAutotestExtension(b)
 168       try:
 169         extension.ExecuteJavaScript('chrome.autotestPrivate.logout();')
 170       except (exceptions.BrowserConnectionGoneException,
 171               exceptions.BrowserGoneException):
 172         pass
 173       util.WaitFor(lambda: not self._IsCryptohomeMounted(), 20)