Allow setting of user and device policies in functional tests

chrome/test/functional/policy.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium 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 logging
 import os
 
 import pyauto_functional  # must come before pyauto.
 import policy_base
@@ skipping 86 matching lines @@
     return ret == 'ok'
 
   def _RestartRenderer(self, windex=0):
     """Kills the current renderer, and reloads it again."""
     info = self.GetBrowserInfo()
     tab = self.GetActiveTabIndex()
     pid = info['windows'][windex]['tabs'][tab]['renderer_pid']
     self.KillRendererProcess(pid)
     self.ReloadActiveTab()
 
+  def setUp(self):
+    policy_base.PolicyTestBase.setUp(self)
+    if self.IsChromeOS():
+      self.LoginWithTestAccount()
+
   def testPolicyToPrefMapping(self):
     """Verify that simple user policies map to corresponding prefs.
 
     Also verify that once these policies are in effect, the prefs cannot be
     modified by the user.
     """
     total = 0
     fails = []
     policy_prefs = policy_test_cases.PolicyPrefsTestCases
     for policy, values in policy_prefs.policies.iteritems():
       pref = values[policy_prefs.INDEX_PREF]
       value = values[policy_prefs.INDEX_VALUE]
       os = values[policy_prefs.INDEX_OS]
       if not pref or self.GetPlatform() not in os:
         continue
-      self.SetPolicies({policy: value})
+      self.SetUserPolicy({policy: value})
       error = self._GetPrefIsManagedError(getattr(pyauto, pref), value)
       if error:
         fails.append('%s: %s' % (policy, error))
       total += 1
     self.assertFalse(fails, msg='%d of %d policies failed.\n%s' %
                      (len(fails), total, '\n'.join(fails)))
 
   def testBlacklistPolicy(self):
     """Tests the URLBlacklist and URLWhitelist policies."""
     # This is an end to end test and not an exaustive test of the filter format.
     policy = {
       'URLBlacklist': [
         'news.google.com',
         'chromium.org',
       ],
       'URLWhitelist': [
         'dev.chromium.org',
         'chromium.org/chromium-os',
       ]
     }
-    self.SetPolicies(policy)
+    self.SetUserPolicy(policy)
 
     self.assertTrue(self._IsBlocked('http://news.google.com/'))
     self.assertFalse(self._IsBlocked('http://www.google.com/'))
     self.assertFalse(self._IsBlocked('http://google.com/'))
 
     self.assertTrue(self._IsBlocked('http://chromium.org/'))
     self.assertTrue(self._IsBlocked('http://www.chromium.org/'))
     self.assertFalse(self._IsBlocked('http://dev.chromium.org/'))
     self.assertFalse(self._IsBlocked('http://chromium.org/chromium-os/testing'))
 
   def testBookmarkBarPolicy(self):
     """Tests the BookmarkBarEnabled policy."""
     self.NavigateToURL('about:blank')
     self.assertFalse(self.GetBookmarkBarVisibility())
     self.assertFalse(self.IsBookmarkBarDetached())
 
     # It should be visible in detached state, in the NTP.
     self.NavigateToURL('chrome://newtab')
     self.assertFalse(self.GetBookmarkBarVisibility())
     self.assertTrue(self.IsBookmarkBarDetached())
 
     policy = {
       'BookmarkBarEnabled': True
     }
-    self.SetPolicies(policy)
+    self.SetUserPolicy(policy)
 
     self.assertTrue(self.WaitForBookmarkBarVisibilityChange(True))
     self.assertTrue(self.GetBookmarkBarVisibility())
     self.assertFalse(self.IsBookmarkBarDetached())
     # The accelerator should be disabled by the policy.
     self.ApplyAccelerator(pyauto.IDC_SHOW_BOOKMARK_BAR)
     self.assertTrue(self.WaitForBookmarkBarVisibilityChange(True))
     self.assertTrue(self.GetBookmarkBarVisibility())
     self.assertFalse(self.IsBookmarkBarDetached())
 
     policy['BookmarkBarEnabled'] = False
-    self.SetPolicies(policy)
+    self.SetUserPolicy(policy)
 
     self.assertTrue(self.WaitForBookmarkBarVisibilityChange(False))
     self.assertFalse(self.GetBookmarkBarVisibility())
     self.ApplyAccelerator(pyauto.IDC_SHOW_BOOKMARK_BAR)
     self.assertTrue(self.WaitForBookmarkBarVisibilityChange(False))
     self.assertFalse(self.GetBookmarkBarVisibility())
     # When disabled by policy, it should never be displayed at all,
     # not even on the NTP.
     self.assertFalse(self.IsBookmarkBarDetached())
 
   def testJavascriptPolicies(self):
     """Tests the Javascript policies."""
     # The navigation to about:blank after each policy reset is to reset the
     # content settings state.
     policy = {}
-    self.SetPolicies(policy)
+    self.SetUserPolicy(policy)
     self.assertTrue(self._IsJavascriptEnabled())
     self.assertTrue(self.IsMenuCommandEnabled(pyauto.IDC_DEV_TOOLS))
     self.assertTrue(self.IsMenuCommandEnabled(pyauto.IDC_DEV_TOOLS_CONSOLE))
 
     policy['DeveloperToolsDisabled'] = True
-    self.SetPolicies(policy)
+    self.SetUserPolicy(policy)
     self.assertTrue(self._IsJavascriptEnabled())
     self.assertFalse(self.IsMenuCommandEnabled(pyauto.IDC_DEV_TOOLS))
     self.assertFalse(self.IsMenuCommandEnabled(pyauto.IDC_DEV_TOOLS_CONSOLE))
 
     policy['DeveloperToolsDisabled'] = False
-    self.SetPolicies(policy)
+    self.SetUserPolicy(policy)
     self.assertTrue(self._IsJavascriptEnabled())
     self.assertTrue(self.IsMenuCommandEnabled(pyauto.IDC_DEV_TOOLS))
     self.assertTrue(self.IsMenuCommandEnabled(pyauto.IDC_DEV_TOOLS_CONSOLE))
 
     # The Developer Tools still work when javascript is disabled.
     policy['JavascriptEnabled'] = False
-    self.SetPolicies(policy)
+    self.SetUserPolicy(policy)
     self.NavigateToURL('about:blank')
     self.assertFalse(self._IsJavascriptEnabled())
     self.assertTrue(self.IsMenuCommandEnabled(pyauto.IDC_DEV_TOOLS))
     self.assertTrue(self.IsMenuCommandEnabled(pyauto.IDC_DEV_TOOLS_CONSOLE))
     # Javascript is always enabled for internal Chrome pages.
     self.NavigateToURL('chrome://settings-frame')
     self.assertTrue(self._IsJavascriptEnabled())
 
     # The Developer Tools can be explicitly disabled.
     policy['DeveloperToolsDisabled'] = True
-    self.SetPolicies(policy)
+    self.SetUserPolicy(policy)
     self.NavigateToURL('about:blank')
     self.assertFalse(self._IsJavascriptEnabled())
     self.assertFalse(self.IsMenuCommandEnabled(pyauto.IDC_DEV_TOOLS))
     self.assertFalse(self.IsMenuCommandEnabled(pyauto.IDC_DEV_TOOLS_CONSOLE))
 
     # Javascript can also be disabled with content settings policies.
     policy = {
       'DefaultJavaScriptSetting': 2,
     }
-    self.SetPolicies(policy)
+    self.SetUserPolicy(policy)
     self.NavigateToURL('about:blank')
     self.assertFalse(self._IsJavascriptEnabled())
     self.assertTrue(self.IsMenuCommandEnabled(pyauto.IDC_DEV_TOOLS))
     self.assertTrue(self.IsMenuCommandEnabled(pyauto.IDC_DEV_TOOLS_CONSOLE))
 
     # The content setting overrides JavascriptEnabled.
     policy = {
       'DefaultJavaScriptSetting': 1,
       'JavascriptEnabled': False,
     }
-    self.SetPolicies(policy)
+    self.SetUserPolicy(policy)
     self.NavigateToURL('about:blank')
     self.assertTrue(self._IsJavascriptEnabled())
 
   def testDisable3DAPIs(self):
     """Tests the policy that disables the 3D APIs."""
     self.assertFalse(self.GetPrefsInfo().Prefs(pyauto.kDisable3DAPIs))
     self.assertTrue(self._IsWebGLEnabled())
 
-    self.SetPolicies({
+    self.SetUserPolicy({
         'Disable3DAPIs': True
     })
     self.assertTrue(self.GetPrefsInfo().Prefs(pyauto.kDisable3DAPIs))
     # The Disable3DAPIs policy only applies updated values to new renderers.
     self._RestartRenderer()
     self.assertFalse(self._IsWebGLEnabled())
 
   def testStartupOptions(self):
     """Verify that user cannot modify the startup page options."""
     policy = {
       'RestoreOnStartup': 4,
       'RestoreOnStartupURLs': ['http://chromium.org']
     }
-    self.SetPolicies(policy)
+    self.SetUserPolicy(policy)
     # Verify startup option
     self.assertEquals(4, self.GetPrefsInfo().Prefs(pyauto.kRestoreOnStartup))
     self.assertRaises(
         pyauto.JSONInterfaceError,
         lambda: self.SetPrefs(pyauto.kRestoreOnStartup, 1))
     policy['RestoreOnStartup'] = 0
-    self.SetPolicies(policy)
+    self.SetUserPolicy(policy)
     self.assertEquals(0, self.GetPrefsInfo().Prefs(pyauto.kRestoreOnStartup))
     self.assertRaises(
         pyauto.JSONInterfaceError,
         lambda: self.SetPrefs(pyauto.kRestoreOnStartup, 1))
     # Verify URLs to open on startup
     self.assertEquals(
         ['http://chromium.org'],
         self.GetPrefsInfo().Prefs(pyauto.kURLsToRestoreOnStartup))
     self.assertRaises(
         pyauto.JSONInterfaceError,
         lambda: self.SetPrefs(pyauto.kURLsToRestoreOnStartup,
                               ['http://www.google.com']))
 
   def testHomePageOptions(self):
     """Verify that we cannot modify Homepage URL."""
     policy = {
       'HomepageLocation': 'http://chromium.org',
       'HomepageIsNewTabPage': True
     }
-    self.SetPolicies(policy)
+    self.SetUserPolicy(policy)
     # Try to configure home page URL
     self.assertEquals('http://chromium.org',
                       self.GetPrefsInfo().Prefs('homepage'))
     self.assertRaises(
         pyauto.JSONInterfaceError,
         lambda: self.SetPrefs('homepage', 'http://www.google.com'))
     # Try to remove NTP as home page
     self.assertTrue(self.GetPrefsInfo().Prefs(pyauto.kHomePageIsNewTabPage))
     self.assertRaises(
         pyauto.JSONInterfaceError,
         lambda: self.SetPrefs(pyauto.kHomePageIsNewTabPage, False))
 
   def testApplicationLocaleValue(self):
     """Verify that Chrome can be launched only in a specific locale."""
     if self.IsWin():
       policy = {'ApplicationLocaleValue': 'hi'}
-      self.SetPolicies(policy)
+      self.SetUserPolicy(policy)
       self.assertTrue(
           'hi' in self.GetPrefsInfo().Prefs()['intl']['accept_languages'],
           msg='Chrome locale is not Hindi.')
       # TODO(sunandt): Try changing the application locale to another language.
     else:
       raise NotImplementedError()
 
   def testDeveloperToolsDisabled(self):
     """Verify that devtools window cannot be launched."""
     # DevTools process can be seen by PyAuto only when it's undocked.
     policy = {'DeveloperToolsDisabled': True}
-    self.SetPolicies(policy)
+    self.SetUserPolicy(policy)
     self.SetPrefs(pyauto.kDevToolsOpenDocked, False)
     self.ApplyAccelerator(pyauto.IDC_DEV_TOOLS)
     self.assertEquals(1, len(self.GetBrowserInfo()['windows']),
                       msg='Devtools window launched.')
     policy = {'DeveloperToolsDisabled': False}
-    self.SetPolicies(policy)
+    self.SetUserPolicy(policy)
     self.ApplyAccelerator(pyauto.IDC_DEV_TOOLS)
     self.assertEquals(2, len(self.GetBrowserInfo()['windows']),
                       msg='Devtools window not launched.')
 
   def testDisableSPDY(self):
     """Verify that SPDY is disabled."""
     policy = {'DisableSpdy': True}
-    self.SetPolicies(policy)
+    self.SetUserPolicy(policy)
     self.NavigateToURL('chrome://net-internals/#spdy')
     self.assertEquals(0, self.FindInPage('SPDY Enabled: true')['match_count'])
     self.assertEquals(
         1,
         self.FindInPage('SPDY Enabled: false', tab_index=0)['match_count'],
         msg='SPDY is not disabled.')
     policy = {'DisableSpdy': False}
-    self.SetPolicies(policy)
+    self.SetUserPolicy(policy)
     self.GetBrowserWindow(0).GetTab(0).Reload()
     self.assertEquals(
         1,
         self.FindInPage('SPDY Enabled: true', tab_index=0)['match_count'],
         msg='SPDY is not disabled.')
 
   def testDisabledPlugins(self):
     """Verify that disabled plugins cannot be enabled."""
     policy = {'DisabledPlugins': ['Shockwave Flash']}
-    self.SetPolicies(policy)
+    self.SetUserPolicy(policy)
     for plugin in self.GetPluginsInfo().Plugins():
       if 'Flash' in plugin['name']:
         self.assertRaises(pyauto.JSONInterfaceError,
                           lambda: self.EnablePlugin(plugin['path']))
         return
 
   def testDisabledPluginsException(self):
     """Verify that plugins given exceptions can be managed by users.
 
     Chrome PDF Viewer is disabled using DisabledPlugins policy.
     User can still toggle the plugin setting when an exception is given for a
     plugin. So we are trying to enable Chrome PDF Viewer.
     """
     policy = {
       'DisabledPlugins': ['Chrome PDF Viewer'],
       'DisabledPluginsExceptions': ['Chrome PDF Viewer']
     }
-    self.SetPolicies(policy)
+    self.SetUserPolicy(policy)
     for plugin in self.GetPluginsInfo().Plugins():
       if 'Chrome PDF Viewer' in plugin['name']:
         self.EnablePlugin(plugin['path'])
         return
 
   def testEnabledPlugins(self):
     """Verify that enabled plugins cannot be disabled."""
     policy = {'EnabledPlugins': ['Shockwave Flash']}
-    self.SetPolicies(policy)
+    self.SetUserPolicy(policy)
     for plugin in self.GetPluginsInfo().Plugins():
       if 'Flash' in plugin['name']:
         self.assertRaises(pyauto.JSONInterfaceError,
                           lambda: self.DisablePlugin(plugin['path']))
         return
     logging.debug('Flash is not present.')
 
   def testAlwaysAuthorizePlugins(self):
     """Verify plugins are always allowed to run when policy is set."""
     policy = {'AlwaysAuthorizePlugins': True}
-    self.SetPolicies(policy)
+    self.SetUserPolicy(policy)
     url = self.GetFileURLForDataPath('plugin', 'java_new.html')
     self.NavigateToURL(url)
     self.assertFalse(self.WaitForInfobarCount(1))
     pid = self._GetPluginPID('Java')
     self.assertTrue(pid, 'No plugin process for java')
     policy = {'AlwaysAuthorizePlugins': False}
     self.NavigateToURL(url)
     self.assertFalse(self.WaitForInfobarCount(1))
     pid = self._GetPluginPID('Java')
     self.assertTrue(pid, 'No plugin process for java')
 
   def testSetDownloadDirectory(self):
     """Verify download directory and prompt cannot be modified."""
     # Check for changing the download directory location
     download_default_dir = self.GetDownloadDirectory().value()
     self.assertEqual(
         download_default_dir,
         self.GetPrefsInfo().Prefs()['download']['default_directory'],
         msg='Downloads directory is not set correctly.')
     self.SetPrefs(pyauto.kDownloadDefaultDirectory, 'download')
     new_download_dir = os.path.abspath(os.path.join(download_default_dir,
                                                     os.pardir))
     policy = {'DownloadDirectory': new_download_dir}
-    self.SetPolicies(policy)
+    self.SetUserPolicy(policy)
     self.assertEqual(
         new_download_dir,
         self.GetPrefsInfo().Prefs()['download']['default_directory'],
         msg='Downloads directory is not set correctly.')
     self.assertRaises(
         pyauto.JSONInterfaceError,
         lambda: self.SetPrefs(pyauto.kDownloadDefaultDirectory,
                               'download'))
     # Check for changing the option 'Ask for each download'
     self.assertRaises(
         pyauto.JSONInterfaceError,
         lambda: self.SetPrefs(pyauto.kPromptForDownload, True))
 
   def testIncognitoEnabled(self):
     """Verify that incognito window can be launched."""
     policy = {'IncognitoEnabled': False}
-    self.SetPolicies(policy)
+    self.SetUserPolicy(policy)
     self.RunCommand(pyauto.IDC_NEW_INCOGNITO_WINDOW)
     self.assertEquals(1, self.GetBrowserWindowCount())
     policy = {'IncognitoEnabled': True}
-    self.SetPolicies(policy)
+    self.SetUserPolicy(policy)
     self.RunCommand(pyauto.IDC_NEW_INCOGNITO_WINDOW)
     self.assertEquals(2, self.GetBrowserWindowCount())
 
   def testSavingBrowserHistoryDisabled(self):
     """Verify that browsing history is not being saved."""
     policy = {'SavingBrowserHistoryDisabled': True}
-    self.SetPolicies(policy)
+    self.SetUserPolicy(policy)
     url = self.GetFileURLForPath(os.path.join(self.DataDir(), 'empty.html'))
     self.NavigateToURL(url)
     self.assertFalse(self.GetHistoryInfo().History(),
                      msg='History is being saved.')
     policy = {'SavingBrowserHistoryDisabled': False}
-    self.SetPolicies(policy)
+    self.SetUserPolicy(policy)
     self.NavigateToURL(url)
     self.assertTrue(self.GetHistoryInfo().History(),
                      msg='History not is being saved.')
 
   def testTranslateEnabled(self):
     """Verify that translate happens if policy enables it."""
     policy = {'TranslateEnabled': True}
-    self.SetPolicies(policy)
+    self.SetUserPolicy(policy)
     self.assertTrue(self.GetPrefsInfo().Prefs(pyauto.kEnableTranslate))
     url = self.GetFileURLForDataPath('translate', 'es', 'google.html')
     self.NavigateToURL(url)
     self.assertTrue(self.WaitForInfobarCount(1))
     translate_info = self.GetTranslateInfo()
     self.assertEqual('es', translate_info['original_language'])
     self.assertFalse(translate_info['page_translated'])
     self.assertTrue(translate_info['can_translate_page'])
     self.assertTrue('translate_bar' in translate_info)
     self.assertFalse(self._GetPrefIsManagedError(pyauto.kEnableTranslate, True))
     policy = {'TranslateEnabled': False}
-    self.SetPolicies(policy)
+    self.SetUserPolicy(policy)
     self.assertFalse(self.GetPrefsInfo().Prefs(pyauto.kEnableTranslate))
     self.NavigateToURL(url)
     self.assertFalse(self.WaitForInfobarCount(1))
     self.assertFalse(self._GetPrefIsManagedError(pyauto.kEnableTranslate,
                                                  False))
 
   def testDefaultSearchProviderOptions(self):
     """Verify a default search is performed when using omnibox."""
     policy = {
       'DefaultSearchProviderEnabled': True,
       'DefaultSearchProviderEncodings': ['UTF-8', 'UTF-16', 'GB2312',
                                          'ISO-8859-1'],
       'DefaultSearchProviderIconURL': 'http://search.my.company/favicon.ico',
       'DefaultSearchProviderInstantURL': ('http://search.my.company/'
                                           'suggest?q={searchTerms}'),
       'DefaultSearchProviderKeyword': 'mis',
       'DefaultSearchProviderName': 'My Intranet Search',
       'DefaultSearchProviderSearchURL': ('http://search.my.company/'
                                          'search?q={searchTerms}'),
       'DefaultSearchProviderSuggestURL': ('http://search.my.company/'
                                           'suggest?q={searchTerms}'),
     }
-    self.SetPolicies(policy)
+    self.SetUserPolicy(policy)
     self.assertFalse(
         self._GetPrefIsManagedError(pyauto.kDefaultSearchProviderEnabled, True))
     intranet_engine = [x for x in self.GetSearchEngineInfo()
                        if x['keyword'] == 'mis']
     self.assertTrue(intranet_engine)
     self.assertTrue(intranet_engine[0]['is_default'])
     self.SetOmniboxText('google chrome')
     self.WaitUntilOmniboxQueryDone()
     self.OmniboxAcceptInput()
     self.assertTrue('search.my.company' in self.GetActiveTabURL().spec())
     policy = {
       'DefaultSearchProviderEnabled': False,
     }
-    self.SetPolicies(policy)
+    self.SetUserPolicy(policy)
     self.assertFalse(
         self._GetPrefIsManagedError(pyauto.kDefaultSearchProviderEnabled,
                                     False))
     self.SetOmniboxText('deli')
     self.WaitUntilOmniboxQueryDone()
     self.assertRaises(pyauto.JSONInterfaceError,
                       lambda: self.OmniboxAcceptInput())
 
   # Needed for extension tests
   _GOOD_CRX_ID = 'ldnnhddmnhbkjipkidpdiheffobcpfmf'
@@ skipping 70 matching lines @@
     # There is an issue where if you uninstall and reinstall and extension
     # quickly with self.InstallExtension, the reinstall fails.  This is a hack
     # to fix it.  Bug coming soon.
     self.NavigateToURL('chrome:extensions')
 
   def testExtensionInstallPopulatedBlacklist(self):
     """Verify blacklisted extensions cannot be installed."""
     # TODO(krisr): Remove this when crosbug.com/27227 is fixed.
     self._RemoveTestingExtensions()
     # Blacklist good.crx
-    self.SetPolicies({
+    self.SetUserPolicy({
       'ExtensionInstallBlacklist': [self._GOOD_CRX_ID]
     })
     self._AttemptExtensionInstallThatShouldFail('good.crx')
     # Check adblock is installed.
     self._AttemptExtensionInstallThatShouldPass('adblock.crx')
 
   def testExtensionInstallFailWithGlobalBlacklist(self):
     """Verify no extensions can be installed when all are blacklisted."""
     # TODO(krisr): Remove this when crosbug.com/27227 is fixed.
     self._RemoveTestingExtensions()
     # Block installs of all extensions
-    self.SetPolicies({
+    self.SetUserPolicy({
       'ExtensionInstallBlacklist': ['*']
     })
     self._AttemptExtensionInstallThatShouldFail('good.crx')
     self._AttemptExtensionInstallThatShouldFail('adblock.crx')
 
   def testExtensionInstallWithGlobalBlacklistAndWhitelistedExtension(self):
     """Verify whitelisted extension is installed when all are blacklisted."""
     # TODO(krisr): Remove this when crosbug.com/27227 is fixed.
     self._RemoveTestingExtensions()
     # Block installs of all extensions, but whitelist adblock.crx
-    self.SetPolicies({
+    self.SetUserPolicy({
       'ExtensionInstallBlacklist': ['*'],
       'ExtensionInstallWhitelist': [self._ADBLOCK_CRX_ID]
     })
     self._AttemptExtensionInstallThatShouldFail('good.crx')
     self._AttemptExtensionInstallThatShouldPass('adblock.crx')
 
   # TODO(krisr): Enable this test once we figure out why it isn't downloading
   # the extension, crbug.com/118123.
   def testExtensionInstallFromForceList(self):
     """Verify force install extensions are installed."""
     # TODO(krisr): Remove this when crosbug.com/27227 is fixed.
     self._RemoveTestingExtensions()
     # Force an extension download from the webstore.
-    self.SetPolicies({
+    self.SetUserPolicy({
       'ExtensionInstallForcelist': [self._SCREEN_CAPTURE_CRX_ID],
     })
     # Give the system 30 seconds to go get this extension.  We are not sure how
     # long it will take the policy to take affect and download the extension.
     self.assertTrue(self.WaitUntil(lambda:
       self._CheckForExtensionByID(self._SCREEN_CAPTURE_CRX_ID),
       expect_retval=True),
       msg='The force install extension was never installed.')
 
 
 if __name__ == '__main__':
   pyauto_functional.Main()