src/chrome/test/functional/ntp.py

   1 #!/usr/bin/env python
   2 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
   3 # Use of this source code is governed by a BSD-style license that can be
   4 # found in the LICENSE file.
   5
   6 import copy
   7 import os
   8
   9 import pyauto_functional  # Must be imported before pyauto
  10 import pyauto
  11 import test_utils
  12
  13
  14 class NTPTest(pyauto.PyUITest):
  15   """Test of the NTP."""
  16
  17   # Default apps are registered in ProfileImpl::RegisterComponentExtensions().
  18   _EXPECTED_DEFAULT_APPS = [
  19     {u'title': u'Chrome Web Store'},
  20   ]
  21   if pyauto.PyUITest.IsChromeOS():
  22     _EXPECTED_DEFAULT_APPS.append({u'title': u'Files'})
  23     _EXPECTED_DEFAULT_APPS.append({u'title': u'Chrome'})
  24   else:
  25     _EXPECTED_DEFAULT_APPS.append({u'title': u'Cloud Print'})
  26
  27   # Default menu and thumbnail mode preferences are set in
  28   # ShownSectionsHandler::RegisterUserPrefs.
  29   if pyauto.PyUITest.IsChromeOS():
  30     _EXPECTED_DEFAULT_THUMB_INFO = {
  31       u'apps': True,
  32       u'most_visited': False
  33     }
  34     _EXPECTED_DEFAULT_MENU_INFO = {
  35       u'apps': False,
  36       u'most_visited': True,
  37       u'recently_closed': True
  38     }
  39   else:
  40     _EXPECTED_DEFAULT_THUMB_INFO = {
  41       u'apps': False,
  42       u'most_visited': True
  43     }
  44     _EXPECTED_DEFAULT_MENU_INFO = {
  45       u'apps': False,
  46       u'most_visited': False,
  47       u'recently_closed': False
  48     }
  49
  50   def Debug(self):
  51     """Test method for experimentation.
  52
  53     This method is not run automatically.
  54     """
  55     while True:
  56       raw_input('Interact with the browser and hit <enter> to dump NTP info...')
  57       print '*' * 20
  58       self.pprint(self._GetNTPInfo())
  59
  60   def __init__(self, methodName='runTest'):
  61     super(NTPTest, self).__init__(methodName)
  62
  63     # Create some dummy file urls we can use in the tests.
  64     filenames = ['title1.html', 'title2.html']
  65     titles = [u'', u'Title Of Awesomeness']
  66     urls = map(lambda name: self.GetFileURLForDataPath(name), filenames)
  67     self.PAGES = map(lambda url, title: {'url': url, 'title': title},
  68                      urls, titles)
  69
  70   def _NTPContainsThumbnail(self, check_thumbnail):
  71     """Returns whether the NTP's Most Visited section contains the given
  72     thumbnail."""
  73     for thumbnail in self.GetNTPThumbnails():
  74       if check_thumbnail['url'] == thumbnail['url']:
  75         return True
  76     return False
  77
  78   def testFreshProfile(self):
  79     """Tests that the NTP with a fresh profile is correct"""
  80     thumbnails = self.GetNTPThumbnails()
  81     default_sites = self.GetNTPDefaultSites()
  82     self.assertEqual(len(default_sites), len(thumbnails))
  83     for thumbnail, default_site in zip(thumbnails, default_sites):
  84       self.assertEqual(thumbnail['url'], default_site)
  85     self.assertEqual(0, len(self.GetNTPRecentlyClosed()))
  86
  87   def testRemoveDefaultThumbnails(self):
  88     """Tests that the default thumbnails can be removed"""
  89     self.RemoveNTPDefaultThumbnails()
  90     self.assertFalse(self.GetNTPThumbnails())
  91     self.RestoreAllNTPThumbnails()
  92     self.assertEqual(len(self.GetNTPDefaultSites()),
  93                      len(self.GetNTPThumbnails()))
  94     self.RemoveNTPDefaultThumbnails()
  95     self.assertFalse(self.GetNTPThumbnails())
  96
  97   def testOneMostVisitedSite(self):
  98     """Tests that a site is added to the most visited sites"""
  99     self.RemoveNTPDefaultThumbnails()
 100     self.NavigateToURL(self.PAGES[1]['url'])
 101     thumbnail = self.GetNTPThumbnails()[0]
 102     self.assertEqual(self.PAGES[1]['url'], thumbnail['url'])
 103     self.assertEqual(self.PAGES[1]['title'], thumbnail['title'])
 104
 105   def testRemoveThumbnail(self):
 106     """Tests removing a thumbnail works"""
 107     self.RemoveNTPDefaultThumbnails()
 108     for page in self.PAGES:
 109       self.AppendTab(pyauto.GURL(page['url']))
 110
 111     thumbnails = self.GetNTPThumbnails()
 112     for thumbnail in thumbnails:
 113       self.assertEquals(thumbnail, self.GetNTPThumbnails()[0])
 114       self.RemoveNTPThumbnail(thumbnail)
 115       self.assertFalse(self._NTPContainsThumbnail(thumbnail))
 116     self.assertFalse(self.GetNTPThumbnails())
 117
 118   def testIncognitoNotAppearInMostVisited(self):
 119     """Tests that visiting a page in incognito mode does cause it to appear in
 120     the Most Visited section"""
 121     self.RemoveNTPDefaultThumbnails()
 122     self.RunCommand(pyauto.IDC_NEW_INCOGNITO_WINDOW)
 123     self.NavigateToURL(self.PAGES[0]['url'], 1, 0)
 124     self.assertFalse(self.GetNTPThumbnails())
 125
 126   def testDifferentProfileNotAppearInMostVisited(self):
 127     """Tests that visiting a page in one profile does not cause it to appear in
 128     the Most Visited section of another."""
 129     self.RemoveNTPDefaultThumbnails()
 130     self.OpenNewBrowserWindowWithNewProfile()
 131     self.NavigateToURL(self.PAGES[0]['url'], 1, 0)
 132     self.assertFalse(self.GetNTPThumbnails())
 133
 134   def testThumbnailPersistence(self):
 135     """Tests that thumbnails persist across Chrome restarts"""
 136     self.RemoveNTPDefaultThumbnails()
 137     for page in self.PAGES:
 138       self.AppendTab(pyauto.GURL(page['url']))
 139     thumbnails = self.GetNTPThumbnails()
 140     self.RestartBrowser(clear_profile=False)
 141     self.assertEqual(thumbnails, self.GetNTPThumbnails())
 142
 143   def testRestoreAllRemovedThumbnails(self):
 144     """Tests restoring all removed thumbnails"""
 145     for page in self.PAGES:
 146       self.AppendTab(pyauto.GURL(page['url']))
 147
 148     thumbnails = self.GetNTPThumbnails()
 149     for thumbnail in thumbnails:
 150       self.RemoveNTPThumbnail(thumbnail)
 151
 152     self.RestoreAllNTPThumbnails()
 153     self.assertEquals(thumbnails, self.GetNTPThumbnails())
 154
 155   def testThumbnailRanking(self):
 156     """Tests that the thumbnails are ordered according to visit count"""
 157     self.RemoveNTPDefaultThumbnails()
 158     for page in self.PAGES:
 159       self.AppendTab(pyauto.GURL(page['url']))
 160     thumbnails = self.GetNTPThumbnails()
 161     self.assertEqual(self.PAGES[0]['url'], self.GetNTPThumbnails()[0]['url'])
 162     self.AppendTab(pyauto.GURL(self.PAGES[1]['url']))
 163     self.assertEqual(self.PAGES[1]['url'], self.GetNTPThumbnails()[0]['url'])
 164     self.AppendTab(pyauto.GURL(self.PAGES[0]['url']))
 165     self.AppendTab(pyauto.GURL(self.PAGES[0]['url']))
 166     self.assertEqual(self.PAGES[0]['url'], self.GetNTPThumbnails()[0]['url'])
 167
 168   def testThumbnailTitleChangeAfterPageTitleChange(self):
 169     """Tests that once a page title changes, the thumbnail title changes too"""
 170     self.RemoveNTPDefaultThumbnails()
 171     self.NavigateToURL(self.PAGES[0]['url'])
 172     self.assertEqual(self.PAGES[0]['title'],
 173                      self.GetNTPThumbnails()[0]['title'])
 174     self.ExecuteJavascript('window.domAutomationController.send(' +
 175                            'document.title = "new title")')
 176     self.assertEqual('new title', self.GetNTPThumbnails()[0]['title'])
 177
 178   def testCloseOneTab(self):
 179     """Tests that closing a tab populates the recently closed list"""
 180     self.RemoveNTPDefaultThumbnails()
 181     self.AppendTab(pyauto.GURL(self.PAGES[1]['url']))
 182     self.CloseTab(tab_index=1)
 183     self.assertEqual(self.PAGES[1]['url'],
 184                      self.GetNTPRecentlyClosed()[0]['url'])
 185     self.assertEqual(self.PAGES[1]['title'],
 186                      self.GetNTPRecentlyClosed()[0]['title'])
 187
 188   def testCloseOneWindow(self):
 189     """Tests that closing a window populates the recently closed list"""
 190     self.RemoveNTPDefaultThumbnails()
 191     self.OpenNewBrowserWindow(True)
 192     self.NavigateToURL(self.PAGES[0]['url'], 1, 0)
 193     self.AppendTab(pyauto.GURL(self.PAGES[1]['url']), 1)
 194     self.CloseBrowserWindow(1)
 195     expected = [{ u'type': u'window',
 196                   u'tabs': [
 197                   { u'type': u'tab',
 198                     u'url': self.PAGES[0]['url'],
 199                     u'direction': u'ltr' },
 200                   { u'type': u'tab',
 201                     u'url': self.PAGES[1]['url']}]
 202                 }]
 203     self.assertEquals(expected, test_utils.StripUnmatchedKeys(
 204         self.GetNTPRecentlyClosed(), expected))
 205
 206   def testCloseMultipleTabs(self):
 207     """Tests closing multiple tabs populates the Recently Closed section in
 208     order"""
 209     self.RemoveNTPDefaultThumbnails()
 210     self.AppendTab(pyauto.GURL(self.PAGES[0]['url']))
 211     self.AppendTab(pyauto.GURL(self.PAGES[1]['url']))
 212     self.CloseTab(tab_index=2)
 213     self.CloseTab(tab_index=1)
 214     expected = [{ u'type': u'tab',
 215                   u'url': self.PAGES[0]['url']
 216                 },
 217                 { u'type': u'tab',
 218                   u'url': self.PAGES[1]['url']
 219                 }]
 220     self.assertEquals(expected, test_utils.StripUnmatchedKeys(
 221         self.GetNTPRecentlyClosed(), expected))
 222
 223   def testCloseWindowWithOneTab(self):
 224     """Tests that closing a window with only one tab only shows up as a tab in
 225     the Recently Closed section"""
 226     self.RemoveNTPDefaultThumbnails()
 227     self.OpenNewBrowserWindow(True)
 228     self.NavigateToURL(self.PAGES[0]['url'], 1, 0)
 229     self.CloseBrowserWindow(1)
 230     expected = [{ u'type': u'tab',
 231                   u'url': self.PAGES[0]['url']
 232                 }]
 233     self.assertEquals(expected, test_utils.StripUnmatchedKeys(
 234         self.GetNTPRecentlyClosed(), expected))
 235
 236   def testCloseMultipleWindows(self):
 237     """Tests closing multiple windows populates the Recently Closed list"""
 238     self.RemoveNTPDefaultThumbnails()
 239     self.OpenNewBrowserWindow(True)
 240     self.NavigateToURL(self.PAGES[0]['url'], 1, 0)
 241     self.AppendTab(pyauto.GURL(self.PAGES[1]['url']), 1)
 242     self.OpenNewBrowserWindow(True)
 243     self.NavigateToURL(self.PAGES[1]['url'], 2, 0)
 244     self.AppendTab(pyauto.GURL(self.PAGES[0]['url']), 2)
 245     self.CloseBrowserWindow(2)
 246     self.CloseBrowserWindow(1)
 247     expected = [{ u'type': u'window',
 248                   u'tabs': [
 249                   { u'type': u'tab',
 250                     u'url': self.PAGES[0]['url'],
 251                     u'direction': u'ltr' },
 252                   { u'type': u'tab',
 253                     u'url': self.PAGES[1]['url']}]
 254                 },
 255                 { u'type': u'window',
 256                   u'tabs': [
 257                   { u'type': u'tab',
 258                     u'url': self.PAGES[1]['url'],
 259                     u'direction': u'ltr' },
 260                   { u'type': u'tab',
 261                     u'url': self.PAGES[0]['url']}]
 262                 }]
 263     self.assertEquals(expected, test_utils.StripUnmatchedKeys(
 264         self.GetNTPRecentlyClosed(), expected))
 265
 266   def testRecentlyClosedIncognito(self):
 267     """Tests that we don't record closure of Incognito tabs or windows"""
 268     #self.RemoveNTPDefaultThumbnails()
 269     self.RunCommand(pyauto.IDC_NEW_INCOGNITO_WINDOW)
 270     self.NavigateToURL(self.PAGES[0]['url'], 1, 0)
 271     self.AppendTab(pyauto.GURL(self.PAGES[0]['url']), 1)
 272     self.AppendTab(pyauto.GURL(self.PAGES[1]['url']), 1)
 273     self.CloseTab(windex=1)
 274     self.assertFalse(self.GetNTPRecentlyClosed())
 275     self.CloseBrowserWindow(1)
 276     self.assertFalse(self.GetNTPRecentlyClosed())
 277
 278   def _VerifyAppInfo(self, actual_info, expected_info):
 279     """Ensures that the actual app info contains the expected app info.
 280
 281     This method assumes that both the actual and expected information for each
 282     app contains at least the 'title' attribute.  Both sets of info are
 283     considered to match if the actual info contains at least the specified
 284     expected info (if the actual info contains additional values that are not
 285     specified in the expected info, that's ok).  This function will fail the
 286     current test if both sets of info don't match.
 287
 288     Args:
 289       actual_info: A list of dictionaries representing the information from
 290                    all apps that would currently be displayed on the NTP.
 291       expected_info: A corrresponding list of dictionaries representing the
 292                      information that is expected.
 293     """
 294     # Ensure all app info dictionaries contain at least the 'title' attribute.
 295     self.assertTrue(all(map(lambda app: 'title' in app, actual_info)) and
 296                     all(map(lambda app: 'title' in app, expected_info)),
 297                     msg='At least one app is missing the "title" attribute.')
 298
 299     # Sort both app lists by title to ensure they're in a known order.
 300     actual_info = sorted(actual_info, key=lambda app: app['title'])
 301     expected_info = sorted(expected_info, key=lambda app: app['title'])
 302
 303     # Ensure the expected info matches the actual info.
 304     self.assertTrue(len(actual_info) == len(expected_info),
 305                     msg='Expected %d app(s) on NTP, but got %d instead.' % (
 306                         len(expected_info), len(actual_info)))
 307     for i, expected_app in enumerate(expected_info):
 308       for attribute in expected_app:
 309         self.assertTrue(attribute in actual_info[i],
 310                         msg='Expected attribute "%s" not found in app info.' % (
 311                             attribute))
 312         self.assertTrue(expected_app[attribute] == actual_info[i][attribute],
 313                         msg='For attribute "%s", expected value "%s", but got '
 314                             '"%s".' % (attribute, expected_app[attribute],
 315                                        actual_info[i][attribute]))
 316
 317   def _InstallAndVerifySamplePackagedApp(self):
 318     """Installs a sample packaged app and verifies the install is successful.
 319
 320     Returns:
 321       The string ID of the installed app.
 322     """
 323     app_crx_file = os.path.abspath(os.path.join(
 324         self.DataDir(), 'pyauto_private', 'apps', 'countdown.crx'))
 325     return self.InstallExtension(app_crx_file)
 326
 327   def testGetAppsInNewProfile(self):
 328     """Ensures that the only app in a new profile is the Web Store app."""
 329     app_info = self.GetNTPApps()
 330     self._VerifyAppInfo(app_info, self._EXPECTED_DEFAULT_APPS)
 331
 332   def testGetAppsWhenInstallApp(self):
 333     """Ensures that an installed app is reflected in the app info in the NTP."""
 334     self._InstallAndVerifySamplePackagedApp()
 335     app_info = self.GetNTPApps()
 336     expected_app_info = [
 337       {
 338         u'title': u'Countdown'
 339       }
 340     ]
 341     expected_app_info.extend(self._EXPECTED_DEFAULT_APPS)
 342     self._VerifyAppInfo(app_info, expected_app_info)
 343
 344   def testGetAppsWhenInstallNonApps(self):
 345     """Ensures installed non-apps are not reflected in the NTP app info."""
 346     # Install a regular extension and a theme.
 347     ext_crx_file = os.path.abspath(os.path.join(self.DataDir(), 'extensions',
 348                                                 'page_action.crx'))
 349     self.InstallExtension(ext_crx_file)
 350     theme_crx_file = os.path.abspath(os.path.join(self.DataDir(), 'extensions',
 351                                                   'theme.crx'))
 352     self.SetTheme(theme_crx_file)
 353     # Verify that no apps are listed on the NTP except for the Web Store.
 354     app_info = self.GetNTPApps()
 355     self._VerifyAppInfo(app_info, self._EXPECTED_DEFAULT_APPS)
 356
 357   def testUninstallApp(self):
 358     """Ensures that an uninstalled app is reflected in the NTP app info."""
 359     # First, install an app and verify that it exists in the NTP app info.
 360     installed_app_id = self._InstallAndVerifySamplePackagedApp()
 361     app_info = self.GetNTPApps()
 362     expected_app_info = [
 363       {
 364         u'title': u'Countdown'
 365       }
 366     ]
 367     expected_app_info.extend(self._EXPECTED_DEFAULT_APPS)
 368     self._VerifyAppInfo(app_info, expected_app_info)
 369
 370     # Next, uninstall the app and verify that it is removed from the NTP.
 371     self.assertTrue(self.UninstallExtensionById(installed_app_id),
 372                     msg='Call to UninstallExtensionById() returned False.')
 373     app_info = self.GetNTPApps()
 374     self._VerifyAppInfo(app_info, self._EXPECTED_DEFAULT_APPS)
 375
 376   def testCannotUninstallWebStore(self):
 377     """Ensures that the WebStore app cannot be uninstalled."""
 378     # Verify that the WebStore app is already installed in a fresh profile.
 379     app_info = self.GetNTPApps()
 380     self._VerifyAppInfo(app_info, self._EXPECTED_DEFAULT_APPS)
 381     self.assertTrue(app_info and 'id' in app_info[0],
 382                     msg='Cannot identify ID of WebStore app.')
 383     webstore_id = app_info[0]['id']
 384
 385     # Attempt to uninstall the WebStore app and verify that it still exists
 386     # in the App info of the NTP even after we try to uninstall it.
 387     self.assertFalse(self.UninstallExtensionById(webstore_id),
 388                      msg='Call to UninstallExtensionById() returned True.')
 389     self._VerifyAppInfo(self.GetNTPApps(), self._EXPECTED_DEFAULT_APPS)
 390
 391   def testLaunchAppWithDefaultSettings(self):
 392     """Verifies that an app can be launched with the default settings."""
 393     # Install an app.
 394     installed_app_id = self._InstallAndVerifySamplePackagedApp()
 395
 396     # Launch the app from the NTP.
 397     self.LaunchApp(installed_app_id)
 398
 399     # Verify that the second tab in the first window is the app launch URL.
 400     # It should be the second tab, not the first, since the call to LaunchApp
 401     # should have first opened the NTP in a new tab, and then launched the app
 402     # from there.
 403     info = self.GetBrowserInfo()
 404     actual_tab_url = info['windows'][0]['tabs'][1]['url']
 405     expected_app_url_start = 'chrome-extension://' + installed_app_id
 406     self.assertTrue(actual_tab_url.startswith(expected_app_url_start),
 407                     msg='The app was not launched.')
 408
 409   def testLaunchAppRegularTab(self):
 410     """Verifies that an app can be launched in a regular tab."""
 411     installed_app_id = self._InstallAndVerifySamplePackagedApp()
 412
 413     self.SetAppLaunchType(installed_app_id, 'regular', windex=0)
 414     self.LaunchApp(installed_app_id)
 415
 416     # Verify that the second tab in the first window is the app launch URL.
 417     info = self.GetBrowserInfo()
 418     actual_tab_url = info['windows'][0]['tabs'][1]['url']
 419     expected_app_url_start = 'chrome-extension://' + installed_app_id
 420     self.assertTrue(actual_tab_url.startswith(expected_app_url_start),
 421                     msg='The app was not launched in a regular tab.')
 422
 423   def testLaunchAppPinnedTab(self):
 424     """Verifies that an app can be launched in a pinned tab."""
 425     installed_app_id = self._InstallAndVerifySamplePackagedApp()
 426
 427     self.SetAppLaunchType(installed_app_id, 'pinned', windex=0)
 428     self.LaunchApp(installed_app_id)
 429
 430     # Verify that the first tab in the first window is the app launch URL, and
 431     # that it is a pinned tab.
 432     info = self.GetBrowserInfo()
 433     actual_tab_url = info['windows'][0]['tabs'][0]['url']
 434     expected_app_url_start = 'chrome-extension://' + installed_app_id
 435     self.assertTrue(actual_tab_url.startswith(expected_app_url_start) and
 436                     info['windows'][0]['tabs'][0]['pinned'],
 437                     msg='The app was not launched in a pinned tab.')
 438
 439   def testLaunchAppFullScreen(self):
 440     """Verifies that an app can be launched in fullscreen mode."""
 441     installed_app_id = self._InstallAndVerifySamplePackagedApp()
 442
 443     self.SetAppLaunchType(installed_app_id, 'fullscreen', windex=0)
 444     self.LaunchApp(installed_app_id)
 445
 446     # Verify that the second tab in the first window is the app launch URL, and
 447     # that the window is fullscreen.
 448     info = self.GetBrowserInfo()
 449     actual_tab_url = info['windows'][0]['tabs'][1]['url']
 450     expected_app_url_start = 'chrome-extension://' + installed_app_id
 451     self.assertTrue(actual_tab_url.startswith(expected_app_url_start) and
 452                     info['windows'][0]['fullscreen'],
 453                     msg='The app was not launched in fullscreen mode.')
 454
 455   def testLaunchAppNewWindow(self):
 456     """Verifies that an app can be launched in a new window."""
 457     installed_app_id = self._InstallAndVerifySamplePackagedApp()
 458
 459     self.SetAppLaunchType(installed_app_id, 'window', windex=0)
 460     self.LaunchApp(installed_app_id)
 461
 462     # Verify that a second window exists (at index 1), and that its first tab
 463     # is the app launch URL.
 464     info = self.GetBrowserInfo()
 465     self.assertTrue(len(info['windows']) == 2,
 466                     msg='A second window does not exist.')
 467     actual_tab_url = info['windows'][1]['tabs'][0]['url']
 468     expected_app_url_start = 'chrome-extension://' + installed_app_id
 469     self.assertTrue(actual_tab_url.startswith(expected_app_url_start),
 470                     msg='The app was not launched in the new window.')
 471
 472 if __name__ == '__main__':
 473   pyauto_functional.Main()