src/tools/perf/measurements/page_cycler_unittest.py

   1 # Copyright 2013 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 unittest
   6
   7 from telemetry.core import browser_options
   8 from telemetry.page import page_runner
   9 from telemetry.results import page_test_results
  10 from telemetry.unittest import simple_mock
  11
  12 from measurements import page_cycler
  13
  14
  15 # Allow testing protected members in the unit test.
  16 # pylint: disable=W0212
  17
  18 class MockMemoryMetric(object):
  19   """Used instead of simple_mock.MockObject so that the precise order and
  20   number of calls need not be specified."""
  21   def __init__(self):
  22     pass
  23
  24   def Start(self, page, tab):
  25     pass
  26
  27   def Stop(self, page, tab):
  28     pass
  29
  30   def AddResults(self, tab, results):
  31     pass
  32
  33   def AddSummaryResults(self, tab, results):
  34     pass
  35
  36
  37 class FakePage(object):
  38   """Used to mock loading a page."""
  39   def __init__(self, url):
  40     self.url = url
  41
  42
  43 class FakeTab(object):
  44   """Used to mock a browser tab."""
  45   def __init__(self):
  46     self.clear_cache_calls = 0
  47   def ClearCache(self, force=False):
  48     assert force
  49     self.clear_cache_calls += 1
  50   def EvaluateJavaScript(self, _):
  51     return 1
  52   def WaitForJavaScriptExpression(self, _, __):
  53     pass
  54   @property
  55   def browser(self):
  56     return FakeBrowser()
  57
  58 class FakeBrowser(object):
  59   _iteration = 0
  60
  61   @property
  62   def cpu_stats(self):
  63     FakeBrowser._iteration += 1
  64     return {
  65         'Browser': {'CpuProcessTime': FakeBrowser._iteration,
  66                     'TotalTime': FakeBrowser._iteration * 2},
  67         'Renderer': {'CpuProcessTime': FakeBrowser._iteration,
  68                     'TotalTime': FakeBrowser._iteration * 3},
  69         'Gpu': {'CpuProcessTime': FakeBrowser._iteration,
  70                  'TotalTime': FakeBrowser._iteration * 4}
  71     }
  72   @property
  73   def platform(self):
  74     return FakePlatform()
  75
  76
  77 class FakePlatform(object):
  78   def GetOSName(self):
  79     return 'fake'
  80   def CanMonitorPower(self):
  81     return False
  82
  83
  84 class PageCyclerUnitTest(unittest.TestCase):
  85
  86   def SetUpCycler(self, args, setup_memory_module=False):
  87     cycler = page_cycler.PageCycler()
  88     options = browser_options.BrowserFinderOptions()
  89     options.browser_options.platform = FakePlatform()
  90     parser = options.CreateParser()
  91     page_runner.AddCommandLineArgs(parser)
  92     cycler.AddCommandLineArgs(parser)
  93     cycler.SetArgumentDefaults(parser)
  94     parser.parse_args(args)
  95     page_runner.ProcessCommandLineArgs(parser, options)
  96     cycler.ProcessCommandLineArgs(parser, options)
  97     cycler.CustomizeBrowserOptions(options.browser_options)
  98
  99     if setup_memory_module:
 100       # Mock out memory metrics; the real ones require a real browser.
 101       mock_memory_metric = MockMemoryMetric()
 102
 103       mock_memory_module = simple_mock.MockObject()
 104       mock_memory_module.ExpectCall(
 105         'MemoryMetric').WithArgs(simple_mock.DONT_CARE).WillReturn(
 106         mock_memory_metric)
 107
 108       real_memory_module = page_cycler.memory
 109       try:
 110         page_cycler.memory = mock_memory_module
 111         browser = FakeBrowser()
 112         cycler.WillStartBrowser(browser)
 113         cycler.DidStartBrowser(browser)
 114       finally:
 115         page_cycler.memory = real_memory_module
 116
 117     return cycler
 118
 119   def testOptionsColdLoadNoArgs(self):
 120     cycler = self.SetUpCycler([])
 121
 122     self.assertEquals(cycler._cold_run_start_index, 5)
 123
 124   def testOptionsColdLoadPagesetRepeat(self):
 125     cycler = self.SetUpCycler(['--pageset-repeat=20', '--page-repeat=2'])
 126
 127     self.assertEquals(cycler._cold_run_start_index, 20)
 128
 129   def testOptionsColdLoadRequested(self):
 130     cycler = self.SetUpCycler(['--pageset-repeat=21', '--page-repeat=2',
 131                                '--cold-load-percent=40'])
 132
 133     self.assertEquals(cycler._cold_run_start_index, 26)
 134
 135   def testCacheHandled(self):
 136     cycler = self.SetUpCycler(['--pageset-repeat=5',
 137                                '--cold-load-percent=50'],
 138                               True)
 139
 140     url_name = 'http://fakepage.com'
 141     page = FakePage(url_name)
 142     tab = FakeTab()
 143
 144     for i in range(5):
 145       results = page_test_results.PageTestResults()
 146       results.WillRunPage(page)
 147       cycler.WillNavigateToPage(page, tab)
 148       self.assertEqual(max(0, i - 2), tab.clear_cache_calls,
 149                        'Iteration %d tab.clear_cache_calls %d' %
 150                        (i, tab.clear_cache_calls))
 151       cycler.ValidateAndMeasurePage(page, tab, results)
 152       results.DidRunPage(page)
 153
 154       values = results.all_page_specific_values
 155       self.assertGreater(len(values), 2)
 156
 157       self.assertEqual(values[0].page, page)
 158       chart_name = 'cold_times' if i == 0 or i > 2 else 'warm_times'
 159       self.assertEqual(values[0].name, '%s.page_load_time' % chart_name)
 160       self.assertEqual(values[0].units, 'ms')
 161
 162       cycler.DidNavigateToPage(page, tab)
 163
 164   def testColdWarm(self):
 165     cycler = self.SetUpCycler(['--pageset-repeat=3'], True)
 166     pages = [FakePage('http://fakepage1.com'), FakePage('http://fakepage2.com')]
 167     tab = FakeTab()
 168     for i in range(3):
 169       for page in pages:
 170         results = page_test_results.PageTestResults()
 171         results.WillRunPage(page)
 172         cycler.WillNavigateToPage(page, tab)
 173         cycler.ValidateAndMeasurePage(page, tab, results)
 174         results.DidRunPage(page)
 175
 176         values = results.all_page_specific_values
 177         self.assertGreater(len(values), 2)
 178
 179         self.assertEqual(values[0].page, page)
 180
 181         chart_name = 'cold_times' if i == 0 or i > 1 else 'warm_times'
 182         self.assertEqual(values[0].name, '%s.page_load_time' % chart_name)
 183         self.assertEqual(values[0].units, 'ms')
 184
 185         cycler.DidNavigateToPage(page, tab)
 186
 187   def testResults(self):
 188     cycler = self.SetUpCycler([], True)
 189
 190     pages = [FakePage('http://fakepage1.com'), FakePage('http://fakepage2.com')]
 191     tab = FakeTab()
 192
 193     for i in range(2):
 194       for page in pages:
 195         results = page_test_results.PageTestResults()
 196         results.WillRunPage(page)
 197         cycler.WillNavigateToPage(page, tab)
 198         cycler.ValidateAndMeasurePage(page, tab, results)
 199         results.DidRunPage(page)
 200
 201         values = results.all_page_specific_values
 202         self.assertEqual(4, len(values))
 203
 204         self.assertEqual(values[0].page, page)
 205         chart_name = 'cold_times' if i == 0 else 'warm_times'
 206         self.assertEqual(values[0].name, '%s.page_load_time' % chart_name)
 207         self.assertEqual(values[0].units, 'ms')
 208
 209         for value, expected in zip(values[1:], ['gpu', 'renderer', 'browser']):
 210           self.assertEqual(value.page, page)
 211           self.assertEqual(value.name,
 212                            'cpu_utilization.cpu_utilization_%s' % expected)
 213           self.assertEqual(value.units, '%')
 214
 215         cycler.DidNavigateToPage(page, tab)