src/chrome/test/telemetry/chromeos/login_unittest.py

   1 # Copyright (c) 2012 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 import json
   5 import logging
   6 import os
   7 import unittest
   8
   9 from telemetry.core import browser_finder
  10 from telemetry.core import exceptions
  11 from telemetry.core import extension_to_load
  12 from telemetry.core import util
  13 from telemetry.core.backends.chrome import cros_interface
  14 from telemetry.unittest import options_for_unittests
  15
  16 class CrOSAutoTest(unittest.TestCase):
  17   def setUp(self):
  18     options = options_for_unittests.GetCopy()
  19     self._cri = cros_interface.CrOSInterface(options.cros_remote,
  20                                              options.cros_ssh_identity)
  21     self._is_guest = options.browser_type == 'cros-chrome-guest'
  22     self._email = '' if self._is_guest else 'test@test.test'
  23
  24   def _IsCryptohomeMounted(self):
  25     """Returns True if cryptohome is mounted"""
  26     cryptohomeJSON, _ = self._cri.RunCmdOnDevice(['/usr/sbin/cryptohome',
  27                                                  '--action=status'])
  28     cryptohomeStatus = json.loads(cryptohomeJSON)
  29     return (cryptohomeStatus['mounts'] and
  30             cryptohomeStatus['mounts'][0]['mounted'])
  31
  32   def _CreateBrowser(self, with_autotest_ext):
  33     """Finds and creates a browser for tests. if with_autotest_ext is True,
  34     also loads the autotest extension"""
  35     options = options_for_unittests.GetCopy()
  36
  37     if with_autotest_ext:
  38       extension_path = os.path.join(os.path.dirname(__file__), 'autotest_ext')
  39       self._load_extension = extension_to_load.ExtensionToLoad(
  40           path=extension_path,
  41           browser_type=options.browser_type,
  42           is_component=True)
  43       options.extensions_to_load = [self._load_extension]
  44       options.browser_options.create_browser_with_oobe = True
  45
  46     browser_to_create = browser_finder.FindBrowser(options)
  47     self.assertTrue(browser_to_create)
  48     b = browser_to_create.Create()
  49     b.Start()
  50     return b
  51
  52   def _GetAutotestExtension(self, browser):
  53     """Returns the autotest extension instance"""
  54     extension = browser.extensions[self._load_extension]
  55     self.assertTrue(extension)
  56     return extension
  57
  58   def _GetLoginStatus(self, browser):
  59       extension = self._GetAutotestExtension(browser)
  60       self.assertTrue(extension.EvaluateJavaScript(
  61           "typeof('chrome.autotestPrivate') != 'undefined'"))
  62       extension.ExecuteJavaScript('''
  63         window.__login_status = null;
  64         chrome.autotestPrivate.loginStatus(function(s) {
  65           window.__login_status = s;
  66         });
  67       ''')
  68       return util.WaitFor(
  69           lambda: extension.EvaluateJavaScript('window.__login_status'), 10)
  70
  71   def testCryptohomeMounted(self):
  72     """Verifies cryptohome mount status for regular and guest user and when
  73     logged out"""
  74     with self._CreateBrowser(False) as b:
  75       self.assertEquals(1, len(b.tabs))
  76       self.assertTrue(b.tabs[0].url)
  77       self.assertTrue(self._IsCryptohomeMounted())
  78
  79       chronos_fs = self._cri.FilesystemMountedAt('/home/chronos/user')
  80       self.assertTrue(chronos_fs)
  81       if self._is_guest:
  82         self.assertEquals(chronos_fs, 'guestfs')
  83       else:
  84         home, _ = self._cri.RunCmdOnDevice(['/usr/sbin/cryptohome-path',
  85                                             'user', self._email])
  86         self.assertEquals(self._cri.FilesystemMountedAt(home.rstrip()),
  87                           chronos_fs)
  88
  89     self.assertFalse(self._IsCryptohomeMounted())
  90     self.assertEquals(self._cri.FilesystemMountedAt('/home/chronos/user'),
  91                       '/dev/mapper/encstateful')
  92
  93   def testLoginStatus(self):
  94     """Tests autotestPrivate.loginStatus"""
  95     with self._CreateBrowser(True) as b:
  96       login_status = self._GetLoginStatus(b)
  97       self.assertEquals(type(login_status), dict)
  98
  99       self.assertEquals(not self._is_guest, login_status['isRegularUser'])
 100       self.assertEquals(self._is_guest, login_status['isGuest'])
 101       self.assertEquals(login_status['email'], self._email)
 102       self.assertFalse(login_status['isScreenLocked'])
 103
 104   def _IsScreenLocked(self, browser):
 105     return self._GetLoginStatus(browser)['isScreenLocked']
 106
 107   def _LockScreen(self, browser):
 108       self.assertFalse(self._IsScreenLocked(browser))
 109
 110       extension = self._GetAutotestExtension(browser)
 111       self.assertTrue(extension.EvaluateJavaScript(
 112           "typeof chrome.autotestPrivate.lockScreen == 'function'"))
 113       logging.info('Locking screen')
 114       extension.ExecuteJavaScript('chrome.autotestPrivate.lockScreen();')
 115
 116       logging.info('Waiting for the lock screen')
 117       def ScreenLocked():
 118         return (browser.oobe and
 119             browser.oobe.EvaluateJavaScript("typeof Oobe == 'function'") and
 120             browser.oobe.EvaluateJavaScript(
 121             "typeof Oobe.authenticateForTesting == 'function'"))
 122       util.WaitFor(ScreenLocked, 10)
 123       self.assertTrue(self._IsScreenLocked(browser))
 124
 125   def _AttemptUnlockBadPassword(self, browser):
 126       logging.info('Trying a bad password')
 127       def ErrorBubbleVisible():
 128         return not browser.oobe.EvaluateJavaScript('''
 129             document.getElementById('bubble').hidden
 130         ''')
 131       self.assertFalse(ErrorBubbleVisible())
 132       browser.oobe.ExecuteJavaScript('''
 133           Oobe.authenticateForTesting('test@test.test', 'bad');
 134       ''')
 135       util.WaitFor(ErrorBubbleVisible, 10)
 136       self.assertTrue(self._IsScreenLocked(browser))
 137
 138   def _UnlockScreen(self, browser):
 139       logging.info('Unlocking')
 140       browser.oobe.ExecuteJavaScript('''
 141           Oobe.authenticateForTesting('test@test.test', '');
 142       ''')
 143       util.WaitFor(lambda: not browser.oobe, 10)
 144       self.assertFalse(self._IsScreenLocked(browser))
 145
 146   def testScreenLock(self):
 147     """Tests autotestPrivate.screenLock"""
 148     with self._CreateBrowser(True) as browser:
 149       self._LockScreen(browser)
 150       self._AttemptUnlockBadPassword(browser)
 151       self._UnlockScreen(browser)
 152
 153
 154   def testLogout(self):
 155     """Tests autotestPrivate.logout"""
 156     with self._CreateBrowser(True) as b:
 157       extension = self._GetAutotestExtension(b)
 158       try:
 159         extension.ExecuteJavaScript('chrome.autotestPrivate.logout();')
 160       except (exceptions.BrowserConnectionGoneException,
 161               exceptions.BrowserGoneException):
 162         pass
 163       util.WaitFor(lambda: not self._IsCryptohomeMounted(), 20)