src/tools/telemetry/telemetry/core/browser_unittest.py

   1 # Copyright 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
   5 import logging
   6 import unittest
   7
   8 from telemetry import test
   9 from telemetry.core import browser_finder
  10 from telemetry.core import gpu_device
  11 from telemetry.core import gpu_info
  12 from telemetry.core import system_info
  13 from telemetry.core import util
  14 from telemetry.unittest import options_for_unittests
  15
  16
  17 class BrowserTest(unittest.TestCase):
  18   def setUp(self):
  19     self._browser = None
  20
  21   def CreateBrowser(self,
  22                     extra_browser_args=None,
  23                     profile_type=None):
  24     assert not self._browser
  25
  26     options = options_for_unittests.GetCopy()
  27
  28     if profile_type:
  29       # TODO(jeremy): crbug.com/243912 profiles are only implemented on
  30       # Desktop.
  31       is_running_on_desktop = not (
  32         options.browser_type.startswith('android') or
  33         options.browser_type.startswith('cros'))
  34       if not is_running_on_desktop:
  35         logging.warn("Desktop-only test, skipping.")
  36         return None
  37       options.browser_options.profile_type = profile_type
  38
  39     if extra_browser_args:
  40       options.AppendExtraBrowserArgs(extra_browser_args)
  41
  42     browser_to_create = browser_finder.FindBrowser(options)
  43     if not browser_to_create:
  44       raise Exception('No browser found, cannot continue test.')
  45     self._browser = browser_to_create.Create()
  46     self._browser.Start()
  47
  48     self._browser.SetHTTPServerDirectories(util.GetUnittestDataDir())
  49
  50     return self._browser
  51
  52   def tearDown(self):
  53     if self._browser:
  54       self._browser.Close()
  55
  56   def testBrowserCreation(self):
  57     b = self.CreateBrowser()
  58     self.assertEquals(1, len(b.tabs))
  59
  60     # Different browsers boot up to different things.
  61     assert b.tabs[0].url
  62
  63   def testCommandLineOverriding(self):
  64     # This test starts the browser with --user-agent=telemetry. This tests
  65     # whether the user agent is then set.
  66     flag1 = '--user-agent=telemetry'
  67     b = self.CreateBrowser(extra_browser_args=[flag1])
  68     t = b.tabs[0]
  69     t.Navigate(b.http_server.UrlOf('blank.html'))
  70     t.WaitForDocumentReadyStateToBeInteractiveOrBetter()
  71     self.assertEquals(t.EvaluateJavaScript('navigator.userAgent'),
  72                       'telemetry')
  73
  74   def testVersionDetection(self):
  75     b = self.CreateBrowser()
  76     v = b._browser_backend._inspector_protocol_version # pylint: disable=W0212
  77     self.assertTrue(v > 0)
  78
  79     v = b._browser_backend.chrome_branch_number # pylint: disable=W0212
  80     self.assertTrue(v > 0)
  81
  82   def testNewCloseTab(self):
  83     b = self.CreateBrowser()
  84     if not b.supports_tab_control:
  85       logging.warning('Browser does not support tab control, skipping test.')
  86       return
  87     existing_tab = b.tabs[0]
  88     self.assertEquals(1, len(b.tabs))
  89     existing_tab_url = existing_tab.url
  90
  91     new_tab = b.tabs.New()
  92     self.assertEquals(2, len(b.tabs))
  93     self.assertEquals(existing_tab.url, existing_tab_url)
  94     self.assertEquals(new_tab.url, 'about:blank')
  95
  96     new_tab.Close()
  97     self.assertEquals(1, len(b.tabs))
  98     self.assertEquals(existing_tab.url, existing_tab_url)
  99
 100   def testMultipleTabCalls(self):
 101     b = self.CreateBrowser()
 102     b.tabs[0].Navigate(b.http_server.UrlOf('blank.html'))
 103     b.tabs[0].WaitForDocumentReadyStateToBeInteractiveOrBetter()
 104
 105   def testTabCallByReference(self):
 106     b = self.CreateBrowser()
 107     tab = b.tabs[0]
 108     tab.Navigate(b.http_server.UrlOf('blank.html'))
 109     b.tabs[0].WaitForDocumentReadyStateToBeInteractiveOrBetter()
 110
 111   # Test flaky on windows: http://crbug.com/321527
 112   @test.Disabled('win')
 113   def testCloseReferencedTab(self):
 114     b = self.CreateBrowser()
 115     if not b.supports_tab_control:
 116       logging.warning('Browser does not support tab control, skipping test.')
 117       return
 118     b.tabs.New()
 119     tab = b.tabs[0]
 120     tab.Navigate(b.http_server.UrlOf('blank.html'))
 121     tab.Close()
 122     self.assertEquals(1, len(b.tabs))
 123
 124   def testForegroundTab(self):
 125     b = self.CreateBrowser()
 126     if not b.supports_tab_control:
 127       logging.warning('Browser does not support tab control, skipping test.')
 128       return
 129     # Should be only one tab at this stage, so that must be the foreground tab
 130     original_tab = b.tabs[0]
 131     self.assertEqual(b.foreground_tab, original_tab)
 132     new_tab = b.tabs.New()
 133     # New tab shouls be foreground tab
 134     self.assertEqual(b.foreground_tab, new_tab)
 135     # Make sure that activating the background tab makes it the foreground tab
 136     original_tab.Activate()
 137     self.assertEqual(b.foreground_tab, original_tab)
 138     # Closing the current foreground tab should switch the foreground tab to the
 139     # other tab
 140     original_tab.Close()
 141     self.assertEqual(b.foreground_tab, new_tab)
 142
 143   def testDirtyProfileCreation(self):
 144     b = self.CreateBrowser(profile_type = 'small_profile')
 145
 146     # TODO(jeremy): crbug.com/243912 profiles are only implemented on Desktop
 147     if not b:
 148       return
 149
 150     self.assertEquals(1, len(b.tabs))
 151
 152   def testGetSystemInfo(self):
 153     b = self.CreateBrowser()
 154     if not b.supports_system_info:
 155       logging.warning(
 156           'Browser does not support getting system info, skipping test.')
 157       return
 158
 159     info = b.GetSystemInfo()
 160
 161     self.assertTrue(isinstance(info, system_info.SystemInfo))
 162     self.assertTrue(hasattr(info, 'model_name'))
 163     self.assertTrue(hasattr(info, 'gpu'))
 164     self.assertTrue(isinstance(info.gpu, gpu_info.GPUInfo))
 165     self.assertTrue(hasattr(info.gpu, 'devices'))
 166     self.assertTrue(len(info.gpu.devices) > 0)
 167     for g in info.gpu.devices:
 168       self.assertTrue(isinstance(g, gpu_device.GPUDevice))
 169
 170   def testGetSystemTotalMemory(self):
 171     b = self.CreateBrowser()
 172     self.assertTrue(b.memory_stats['SystemTotalPhysicalMemory'] > 0)
 173
 174   def testIsTracingRunning(self):
 175     b = self.CreateBrowser()
 176     if not b.supports_tracing:
 177       return
 178     self.assertFalse(b.is_tracing_running)
 179     b.StartTracing()
 180     self.assertTrue(b.is_tracing_running)
 181     b.StopTracing()
 182     self.assertFalse(b.is_tracing_running)