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 import unittest
   5
   6 from measurements import page_cycler
   7 from telemetry.core import browser_options
   8 from telemetry.page import page_measurement_results
   9 from telemetry.unittest import simple_mock
  10
  11 # Allow testing protected members in the unit test.
  12 # pylint: disable=W0212
  13
  14 # Used instead of simple_mock.MockObject so that the precise order and
  15 # number of calls need not be specified.
  16 class MockMemoryMetric(object):
  17   def __init__(self):
  18     pass
  19
  20   def Start(self, page, tab):
  21     pass
  22
  23   def Stop(self, page, tab):
  24     pass
  25
  26   def AddResults(self, tab, results):
  27     pass
  28
  29   def AddSummaryResults(self, tab, results):
  30     pass
  31
  32 class PageCyclerUnitTest(unittest.TestCase):
  33
  34   # TODO(tonyg): Remove this backfill when we can assume python 2.7 everywhere.
  35   def assertIn(self, first, second, msg=None):
  36     self.assertTrue(first in second,
  37                     msg="'%s' not found in '%s'" % (first, second))
  38
  39   def setupCycler(self, args):
  40     cycler = page_cycler.PageCycler()
  41     options = browser_options.BrowserFinderOptions()
  42     parser = options.CreateParser()
  43     cycler.AddCommandLineOptions(parser)
  44     parser.parse_args(args)
  45     cycler.CustomizeBrowserOptions(options)
  46
  47     return cycler
  48
  49   def testOptionsColdLoadNoArgs(self):
  50     cycler = self.setupCycler([])
  51
  52     self.assertFalse(cycler._cold_runs_requested)
  53     self.assertEqual(cycler._number_warm_runs, 9)
  54
  55   def testOptionsColdLoadPagesetRepeat(self):
  56     cycler = self.setupCycler(['--pageset-repeat=20', '--page-repeat=2'])
  57
  58     self.assertFalse(cycler._cold_runs_requested)
  59     self.assertEqual(cycler._number_warm_runs, 38)
  60
  61   def testOptionsColdLoadRequested(self):
  62     cycler = self.setupCycler(['--pageset-repeat=21', '--page-repeat=2',
  63                                '--cold-load-percent=40'])
  64
  65     self.assertTrue(cycler._cold_runs_requested)
  66     self.assertEqual(cycler._number_warm_runs, 24)
  67
  68   def testIncompatibleOptions(self):
  69     exception_seen = False
  70     try:
  71       self.setupCycler(['--pageset-repeat=20s', '--page-repeat=2s',
  72                         '--cold-load-percent=40'])
  73     except Exception as e:
  74       exception_seen = True
  75       self.assertEqual('--cold-load-percent is incompatible with '
  76                        'timed repeat', e.args[0])
  77
  78     self.assertTrue(exception_seen)
  79
  80   def testCacheHandled(self):
  81     cycler = self.setupCycler(['--pageset-repeat=5',
  82                                '--cold-load-percent=50'])
  83
  84     # Mock out memory metrics; the real ones require a real browser.
  85     mock_memory_metric = MockMemoryMetric()
  86
  87     mock_memory_module = simple_mock.MockObject()
  88     mock_memory_module.ExpectCall(
  89       'MemoryMetric').WithArgs(simple_mock.DONT_CARE).WillReturn(
  90       mock_memory_metric)
  91
  92     real_memory_module = page_cycler.memory
  93     try:
  94       page_cycler.memory = mock_memory_module
  95       cycler.DidStartBrowser(None)
  96     finally:
  97       page_cycler.memory = real_memory_module
  98
  99     class FakePage(object):
 100       def __init__(self, url):
 101         self.url = url
 102
 103     class FakeTab(object):
 104       def __init__(self):
 105         self.clear_cache_calls = 0
 106       def ClearCache(self):
 107         self.clear_cache_calls += 1
 108       def EvaluateJavaScript(self, _):
 109         return 1
 110       def WaitForJavaScriptExpression(self, _, __):
 111         pass
 112
 113     url_name = "http://fakepage.com"
 114     page = FakePage(url_name)
 115     tab = FakeTab()
 116     results = page_measurement_results.PageMeasurementResults()
 117
 118     for i in range(5):
 119       cycler.WillNavigateToPage(page, tab)
 120       self.assertEqual(max(0, i - 2), tab.clear_cache_calls,
 121                        "Iteration %d tab.clear_cache_calls %d" %
 122                        (i, tab.clear_cache_calls))
 123       num_results = len(results.page_results)
 124       results.WillMeasurePage(page)
 125       cycler.MeasurePage(page, tab, results)
 126       results.DidMeasurePage()
 127       self.assertEqual(num_results+1, len(results.page_results))
 128       result = results[-1]
 129       self.assertEqual(result.page, page)
 130       self.assertEqual(1, len(result.values))
 131       self.assertEqual(result.values[0].trace_name, 'page_load_time')
 132       self.assertEqual(result.values[0].units, 'ms')
 133       self.assertEqual(result.values[0].chart_name,
 134                        'warm_times' if i < 3 else 'cold_times')
 135       cycler.DidNavigateToPage(page, tab)