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_measurement_results
   9 from telemetry.page import page_runner
  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
  55
  56 class FakeBrowser(object):
  57   _iteration = 0
  58
  59   @property
  60   def cpu_stats(self):
  61     FakeBrowser._iteration += 1
  62     return {
  63         'Browser': {'CpuProcessTime': FakeBrowser._iteration,
  64                     'TotalTime': FakeBrowser._iteration * 2},
  65         'Renderer': {'CpuProcessTime': FakeBrowser._iteration,
  66                     'TotalTime': FakeBrowser._iteration * 3},
  67         'Gpu': {'CpuProcessTime': FakeBrowser._iteration,
  68                  'TotalTime': FakeBrowser._iteration * 4}
  69     }
  70
  71
  72 class PageCyclerUnitTest(unittest.TestCase):
  73
  74   def SetUpCycler(self, args, setup_memory_module=False):
  75     cycler = page_cycler.PageCycler()
  76     options = browser_options.BrowserFinderOptions()
  77     parser = options.CreateParser()
  78     page_runner.AddCommandLineArgs(parser)
  79     cycler.AddCommandLineArgs(parser)
  80     cycler.SetArgumentDefaults(parser)
  81     parser.parse_args(args)
  82     page_runner.ProcessCommandLineArgs(parser, options)
  83     cycler.ProcessCommandLineArgs(parser, options)
  84     cycler.CustomizeBrowserOptions(options)
  85
  86     if setup_memory_module:
  87       # Mock out memory metrics; the real ones require a real browser.
  88       mock_memory_metric = MockMemoryMetric()
  89
  90       mock_memory_module = simple_mock.MockObject()
  91       mock_memory_module.ExpectCall(
  92         'MemoryMetric').WithArgs(simple_mock.DONT_CARE).WillReturn(
  93         mock_memory_metric)
  94
  95       real_memory_module = page_cycler.memory
  96       try:
  97         page_cycler.memory = mock_memory_module
  98         cycler.DidStartBrowser(FakeBrowser())
  99       finally:
 100         page_cycler.memory = real_memory_module
 101
 102     return cycler
 103
 104   def testOptionsColdLoadNoArgs(self):
 105     cycler = self.SetUpCycler([])
 106
 107     self.assertEquals(cycler._cold_run_start_index, 5)
 108
 109   def testOptionsColdLoadPagesetRepeat(self):
 110     cycler = self.SetUpCycler(['--pageset-repeat=20', '--page-repeat=2'])
 111
 112     self.assertEquals(cycler._cold_run_start_index, 20)
 113
 114   def testOptionsColdLoadRequested(self):
 115     cycler = self.SetUpCycler(['--pageset-repeat=21', '--page-repeat=2',
 116                                '--cold-load-percent=40'])
 117
 118     self.assertEquals(cycler._cold_run_start_index, 26)
 119
 120   def testCacheHandled(self):
 121     cycler = self.SetUpCycler(['--pageset-repeat=5',
 122                                '--cold-load-percent=50'],
 123                               True)
 124
 125     url_name = 'http://fakepage.com'
 126     page = FakePage(url_name)
 127     tab = FakeTab()
 128     results = page_measurement_results.PageMeasurementResults()
 129
 130     for i in range(5):
 131       cycler.WillNavigateToPage(page, tab)
 132       self.assertEqual(max(0, i - 2), tab.clear_cache_calls,
 133                        'Iteration %d tab.clear_cache_calls %d' %
 134                        (i, tab.clear_cache_calls))
 135       results.WillMeasurePage(page)
 136       cycler.MeasurePage(page, tab, results)
 137
 138       values = results.page_specific_values_for_current_page
 139       results.DidMeasurePage()
 140
 141       self.assertGreater(len(values), 2)
 142
 143       self.assertEqual(values[0].page, page)
 144       chart_name = 'cold_times' if i == 0 or i > 2 else 'warm_times'
 145       self.assertEqual(values[0].name, '%s.page_load_time' % chart_name)
 146       self.assertEqual(values[0].units, 'ms')
 147
 148       cycler.DidNavigateToPage(page, tab)
 149
 150   def testColdWarm(self):
 151     cycler = self.SetUpCycler(['--pageset-repeat=3'], True)
 152     pages = [FakePage('http://fakepage1.com'), FakePage('http://fakepage2.com')]
 153     tab = FakeTab()
 154     results = page_measurement_results.PageMeasurementResults()
 155     for i in range(3):
 156       for page in pages:
 157         cycler.WillNavigateToPage(page, tab)
 158         results.WillMeasurePage(page)
 159         cycler.MeasurePage(page, tab, results)
 160
 161         values = results.page_specific_values_for_current_page
 162         results.DidMeasurePage()
 163
 164         self.assertGreater(len(values), 2)
 165
 166         self.assertEqual(values[0].page, page)
 167
 168         chart_name = 'cold_times' if i == 0 or i > 1 else 'warm_times'
 169         self.assertEqual(values[0].name, '%s.page_load_time' % chart_name)
 170         self.assertEqual(values[0].units, 'ms')
 171
 172         cycler.DidNavigateToPage(page, tab)
 173
 174   def testResults(self):
 175     cycler = self.SetUpCycler([], True)
 176
 177     pages = [FakePage('http://fakepage1.com'), FakePage('http://fakepage2.com')]
 178     tab = FakeTab()
 179     results = page_measurement_results.PageMeasurementResults()
 180
 181     for i in range(2):
 182       for page in pages:
 183         cycler.WillNavigateToPage(page, tab)
 184         results.WillMeasurePage(page)
 185         cycler.MeasurePage(page, tab, results)
 186
 187         values = results.page_specific_values_for_current_page
 188         results.DidMeasurePage()
 189
 190         self.assertEqual(4, len(values))
 191
 192         self.assertEqual(values[0].page, page)
 193         chart_name = 'cold_times' if i == 0 else 'warm_times'
 194         self.assertEqual(values[0].name, '%s.page_load_time' % chart_name)
 195         self.assertEqual(values[0].units, 'ms')
 196
 197         for value, expected in zip(values[1:], ['gpu', 'renderer', 'browser']):
 198           self.assertEqual(value.page, page)
 199           self.assertEqual(value.name,
 200                            'cpu_utilization.cpu_utilization_%s' % expected)
 201           self.assertEqual(value.units, '%')
 202
 203
 204         cycler.DidNavigateToPage(page, tab)