Add {Will,Did}StartBrowser to record_wpr

tools/telemetry/telemetry/page/record_wpr_unittest.py

 # Copyright 2014 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import os
 import sys
 
 from telemetry import benchmark
 from telemetry.core import util
 from telemetry.core import wpr_modes
 from telemetry.page import page as page_module
 from telemetry.page import page_set as page_set_module
 from telemetry.page import page_test
 from telemetry.page import record_wpr
 from telemetry.unittest import tab_test_case
 
 
 class MockPage(page_module.Page):
+
   def __init__(self, page_set, url):
     super(MockPage, self).__init__(url=url,
                                    page_set=page_set,
                                    base_dir=util.GetUnittestDataDir())
     self.func_calls = []
 
   def RunNavigateSteps(self, action_runner):
     self.func_calls.append('RunNavigateSteps')
     super(MockPage, self).RunNavigateSteps(action_runner)
 
   def RunFoo(self, _):
     self.func_calls.append('RunFoo')
 
   def RunBar(self, _):
     self.func_calls.append('RunBar')
 
   def RunBaz(self, _):
     self.func_calls.append('RunBaz')
 
 
 class MockPageSet(page_set_module.PageSet):
+
   def __init__(self, url=''):
     super(MockPageSet, self).__init__(archive_data_file='data/test.json')
     self.AddPage(MockPage(self, url))
 
 
 class MockPageTest(page_test.PageTest):
+
   def __init__(self):
     super(MockPageTest, self).__init__()
-    self._action_name_to_run = "RunBaz"
+    self._action_name_to_run = 'RunBaz'
     self.func_calls = []
 
   @classmethod
   def AddCommandLineArgs(cls, parser):
-    parser.add_option('--mock-page-test-option', action="store_true")
+    parser.add_option('--mock-page-test-option', action='store_true')
 
   def WillNavigateToPage(self, page, tab):
     self.func_calls.append('WillNavigateToPage')
 
   def DidNavigateToPage(self, page, tab):
     self.func_calls.append('DidNavigateToPage')
 
+  def WillStartBrowser(self, browser):
+    self.func_calls.append('WillStartBrowser')
+
+  def DidStartBrowser(self, browser):
+    self.func_calls.append('DidStartBrowser')
+
   def WillRunActions(self, page, tab):
     self.func_calls.append('WillRunActions')
 
   def DidRunActions(self, page, tab):
     self.func_calls.append('DidRunActions')
 
   def ValidatePage(self, page, tab, results):
     self.func_calls.append('ValidatePage')
 
 
 class MockBenchmark(benchmark.Benchmark):
   test = MockPageTest
 
   @classmethod
   def AddTestCommandLineArgs(cls, group):
     group.add_option('', '--mock-benchmark-url', action='store', type='string')
 
   def CreatePageSet(self, options):
     kwargs = {}
-    if (options.mock_benchmark_url):
+    if options.mock_benchmark_url:
       kwargs['url'] = options.mock_benchmark_url
     return MockPageSet(**kwargs)
 
 
 class RecordWprUnitTests(tab_test_case.TabTestCase):
 
   _base_dir = util.GetUnittestDataDir()
   _test_data_dir = os.path.join(util.GetUnittestDataDir(), 'page_measurements')
 
   @classmethod
   def setUpClass(cls):
     sys.path.extend([cls._base_dir, cls._test_data_dir])
     super(RecordWprUnitTests, cls).setUpClass()
     cls._browser.SetHTTPServerDirectories(util.GetUnittestDataDir())
     blank_html_path = os.path.join(util.GetUnittestDataDir(), 'blank.html')
     cls._url = cls._browser.http_server.UrlOf(blank_html_path)
 
   # When the RecorderPageTest is created from a PageSet, we do not have a
   # PageTest to use. In this case, we will record every available action.
   def testRunPage_AllActions(self):
-    record_page_test = record_wpr.RecorderPageTest(["RunFoo", "RunBar"])
+    record_page_test = record_wpr.RecorderPageTest(['RunFoo', 'RunBar'])
     page = MockPage(page_set=MockPageSet(url=self._url), url=self._url)
     record_page_test.RunPage(page, self._tab, results=None)
     self.assertTrue('RunFoo' in page.func_calls)
     self.assertTrue('RunBar' in page.func_calls)
     self.assertFalse('RunBaz' in page.func_calls)
 
   def testRunPage_DontReloadSingleActions(self):
-    record_page_test = record_wpr.RecorderPageTest(["RunFoo"])
+    record_page_test = record_wpr.RecorderPageTest(['RunFoo'])
     page = MockPage(page_set=MockPageSet(url=self._url), url=self._url)
     record_page_test.RunPage(page, self._tab, results=None)
     self.assertFalse('RunNavigateSteps' in page.func_calls)
 
   def testRunPage_ReloadPageBetweenActions(self):
-    record_page_test = record_wpr.RecorderPageTest(["RunFoo", "RunBar"])
+    record_page_test = record_wpr.RecorderPageTest(['RunFoo', 'RunBar'])
     page = MockPage(page_set=MockPageSet(url=self._url), url=self._url)
     record_page_test.RunPage(page, self._tab, results=None)
     self.assertTrue('RunNavigateSteps' in page.func_calls)
 
   # When the RecorderPageTest is created from a Benchmark, the benchmark will
   # have a PageTest, specified by its test attribute.
   def testRunPage_OnlyRunBenchmarkAction(self):
-    record_page_test = record_wpr.RecorderPageTest(["RunFoo"])
+    record_page_test = record_wpr.RecorderPageTest(['RunFoo'])
     record_page_test.page_test = MockBenchmark().test()
     page = MockPage(page_set=MockPageSet(url=self._url), url=self._url)
     record_page_test.RunPage(page, self._tab, results=None)
     self.assertFalse('RunFoo' in page.func_calls)
     self.assertTrue('RunBaz' in page.func_calls)
 
   def testRunPage_CallBenchmarksPageTestsFunctions(self):
     record_page_test = record_wpr.RecorderPageTest([])
     record_page_test.page_test = MockBenchmark().test()
     page = MockPage(page_set=MockPageSet(url=self._url), url=self._url)
     record_page_test.RunPage(page, self._tab, results=None)
-    self.assertEqual(3, len(record_page_test.page_test.func_calls))
-    self.assertEqual('WillRunActions', record_page_test.page_test.func_calls[0])
-    self.assertEqual('DidRunActions', record_page_test.page_test.func_calls[1])
-    self.assertEqual('ValidatePage', record_page_test.page_test.func_calls[2])
+    self.assertEqual(['WillRunActions', 'DidRunActions', 'ValidatePage'],
+                     record_page_test.page_test.func_calls)
 
   def testWprRecorderWithPageSet(self):
     flags = []
     wpr_recorder = record_wpr.WprRecorder(self._test_data_dir,
                                           MockPageSet(url=self._url), flags)
     results = wpr_recorder.Record()
     self.assertEquals(1, len(results.successes))
     mock_page = results.successes.pop()
     self.assertTrue('RunFoo' in mock_page.func_calls)
     self.assertFalse('RunBaz' in mock_page.func_calls)
 
   def testWprRecorderWithBenchmark(self):
     flags = ['--mock-benchmark-url', self._url]
     wpr_recorder = record_wpr.WprRecorder(self._test_data_dir, MockBenchmark(),
                                           flags)
     results = wpr_recorder.Record()
     self.assertEquals(1, len(results.successes))
     mock_page = results.successes.pop()
     self.assertFalse('RunFoo' in mock_page.func_calls)
     self.assertTrue('RunBaz' in mock_page.func_calls)
+    self.assertEqual(['WillStartBrowser', 'DidStartBrowser',
+                      'WillNavigateToPage', 'DidNavigateToPage',
+                      'WillRunActions', 'DidRunActions',
+                      'ValidatePage'],
+                     wpr_recorder.page_test.func_calls)
 
   def testCommandLineFlags(self):
     flags = [
         '--page-repeat', '2',
         '--mock-benchmark-url', self._url,
         '--mock-page-test-option',
     ]
     wpr_recorder = record_wpr.WprRecorder(self._test_data_dir, MockBenchmark(),
                                           flags)
     # page_runner command-line args
@@ skipping 13 matching lines @@
                      wpr_recorder.options.browser_options.wpr_mode)
 
   def testFindAllActionNames(self):
     # The src/tools/telemetry/unittest_data/page_measurements/ has been
     # populated with three simple Page Measurement classes, the first two of
     # which have action_name_to_run defined.
     action_names_to_run = record_wpr.FindAllActionNames(self._test_data_dir)
     self.assertTrue('RunFoo' in action_names_to_run)
     self.assertTrue('RunBar' in action_names_to_run)
     self.assertFalse('RunBaz' in action_names_to_run)