1 # Copyright 2014 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.
8 from telemetry import benchmark
9 from telemetry import decorators
10 from telemetry.core import util
11 from telemetry.core import wpr_modes
12 from telemetry.page import page as page_module
13 from telemetry.page import page_set as page_set_module
14 from telemetry.page import page_test
15 from telemetry.page import record_wpr
16 from telemetry.unittest import tab_test_case
19 class MockPage(page_module.Page):
20 def __init__(self, page_set, url):
21 super(MockPage, self).__init__(url=url,
23 base_dir=util.GetUnittestDataDir())
26 def RunNavigateSteps(self, action_runner):
27 self.func_calls.append('RunNavigateSteps')
28 super(MockPage, self).RunNavigateSteps(action_runner)
31 self.func_calls.append('RunFoo')
34 self.func_calls.append('RunBar')
37 self.func_calls.append('RunBaz')
40 class MockPageSet(page_set_module.PageSet):
41 def __init__(self, url=''):
42 super(MockPageSet, self).__init__(archive_data_file='data/test.json')
43 self.AddPage(MockPage(self, url))
46 class MockPageTest(page_test.PageTest):
48 super(MockPageTest, self).__init__()
49 self._action_name_to_run = "RunBaz"
53 def AddCommandLineArgs(cls, parser):
54 parser.add_option('--mock-page-test-option', action="store_true")
56 def WillNavigateToPage(self, page, tab):
57 self.func_calls.append('WillNavigateToPage')
59 def DidNavigateToPage(self, page, tab):
60 self.func_calls.append('DidNavigateToPage')
62 def WillRunActions(self, page, tab):
63 self.func_calls.append('WillRunActions')
65 def DidRunActions(self, page, tab):
66 self.func_calls.append('DidRunActions')
68 def ValidatePage(self, page, tab, results):
69 self.func_calls.append('ValidatePage')
71 def WillStartBrowser(self, platform):
72 self.func_calls.append('WillStartBrowser')
74 def DidStartBrowser(self, browser):
75 self.func_calls.append('DidStartBrowser')
77 class MockBenchmark(benchmark.Benchmark):
82 def AddTestCommandLineArgs(cls, group):
83 group.add_option('', '--mock-benchmark-url', action='store', type='string')
85 def CreatePageSet(self, options):
87 if (options.mock_benchmark_url):
88 kwargs['url'] = options.mock_benchmark_url
89 self.mock_page_set = MockPageSet(**kwargs)
90 return self.mock_page_set
93 class RecordWprUnitTests(tab_test_case.TabTestCase):
95 _base_dir = util.GetUnittestDataDir()
96 _test_data_dir = os.path.join(util.GetUnittestDataDir(), 'page_tests')
100 sys.path.extend([cls._base_dir, cls._test_data_dir])
101 super(RecordWprUnitTests, cls).setUpClass()
102 cls._url = cls.UrlOfUnittestFile('blank.html')
104 # When the RecorderPageTest is created from a PageSet, we do not have a
105 # PageTest to use. In this case, we will record every available action.
106 def testRunPage_AllActions(self):
107 record_page_test = record_wpr.RecorderPageTest(["RunFoo", "RunBar"])
108 page = MockPage(page_set=MockPageSet(url=self._url), url=self._url)
109 record_page_test.RunPage(page, self._tab, results=None)
110 self.assertTrue('RunFoo' in page.func_calls)
111 self.assertTrue('RunBar' in page.func_calls)
112 self.assertFalse('RunBaz' in page.func_calls)
114 def testRunPage_DontReloadSingleActions(self):
115 record_page_test = record_wpr.RecorderPageTest(["RunFoo"])
116 page = MockPage(page_set=MockPageSet(url=self._url), url=self._url)
117 record_page_test.RunPage(page, self._tab, results=None)
118 self.assertFalse('RunNavigateSteps' in page.func_calls)
120 def testRunPage_ReloadPageBetweenActions(self):
121 record_page_test = record_wpr.RecorderPageTest(["RunFoo", "RunBar"])
122 page = MockPage(page_set=MockPageSet(url=self._url), url=self._url)
123 record_page_test.RunPage(page, self._tab, results=None)
124 self.assertTrue('RunNavigateSteps' in page.func_calls)
126 # When the RecorderPageTest is created from a Benchmark, the benchmark will
127 # have a PageTest, specified by its test attribute.
128 def testRunPage_OnlyRunBenchmarkAction(self):
129 record_page_test = record_wpr.RecorderPageTest(["RunFoo"])
130 record_page_test.page_test = MockBenchmark().test()
131 page = MockPage(page_set=MockPageSet(url=self._url), url=self._url)
132 record_page_test.RunPage(page, self._tab, results=None)
133 self.assertFalse('RunFoo' in page.func_calls)
134 self.assertTrue('RunBaz' in page.func_calls)
136 def testRunPage_CallBenchmarksPageTestsFunctions(self):
137 record_page_test = record_wpr.RecorderPageTest([])
138 record_page_test.page_test = MockBenchmark().test()
139 page = MockPage(page_set=MockPageSet(url=self._url), url=self._url)
140 record_page_test.RunPage(page, self._tab, results=None)
141 self.assertEqual(3, len(record_page_test.page_test.func_calls))
142 self.assertEqual('WillRunActions', record_page_test.page_test.func_calls[0])
143 self.assertEqual('DidRunActions', record_page_test.page_test.func_calls[1])
144 self.assertEqual('ValidatePage', record_page_test.page_test.func_calls[2])
146 @decorators.Disabled('chromeos') # crbug.com/404868.
147 def testWprRecorderWithPageSet(self):
149 mock_page_set = MockPageSet(url=self._url)
150 wpr_recorder = record_wpr.WprRecorder(self._test_data_dir,
151 mock_page_set, flags)
152 results = wpr_recorder.CreateResults()
153 wpr_recorder.Record(results)
154 self.assertEqual(set(mock_page_set.pages), results.pages_that_succeeded)
156 def testWprRecorderWithBenchmark(self):
157 flags = ['--mock-benchmark-url', self._url]
158 mock_benchmark = MockBenchmark()
159 wpr_recorder = record_wpr.WprRecorder(self._test_data_dir, mock_benchmark,
161 results = wpr_recorder.CreateResults()
162 wpr_recorder.Record(results)
163 self.assertEqual(set(mock_benchmark.mock_page_set.pages),
164 results.pages_that_succeeded)
166 def testCommandLineFlags(self):
168 '--page-repeat', '2',
169 '--mock-benchmark-url', self._url,
170 '--mock-page-test-option',
172 wpr_recorder = record_wpr.WprRecorder(self._test_data_dir, MockBenchmark(),
174 # page_runner command-line args
175 self.assertEquals(2, wpr_recorder.options.page_repeat)
176 # benchmark command-line args
177 self.assertEquals(self._url, wpr_recorder.options.mock_benchmark_url)
178 # benchmark's page_test command-line args
179 self.assertTrue(wpr_recorder.options.mock_page_test_option)
180 # invalid command-line args
181 self.assertFalse(hasattr(wpr_recorder.options, 'not_a_real_option'))
183 def testRecordingEnabled(self):
184 flags = ['--mock-benchmark-url', self._url]
185 wpr_recorder = record_wpr.WprRecorder(self._test_data_dir, MockBenchmark(),
187 self.assertEqual(wpr_modes.WPR_RECORD,
188 wpr_recorder.options.browser_options.wpr_mode)
190 def testFindAllActionNames(self):
191 # The src/tools/telemetry/unittest_data/page_tests/ has been
192 # populated with three simple Page Measurement classes, the first two of
193 # which have action_name_to_run defined.
194 action_names_to_run = record_wpr.FindAllActionNames(self._test_data_dir)
195 self.assertTrue('RunFoo' in action_names_to_run)
196 self.assertTrue('RunBar' in action_names_to_run)
197 self.assertFalse('RunBaz' in action_names_to_run)
199 # When the RecorderPageTest WillStartBrowser/DidStartBrowser function is
200 # called, it forwards the call to the PageTest
201 def testRecorderPageTest_BrowserMethods(self):
202 record_page_test = record_wpr.RecorderPageTest([])
203 record_page_test.page_test = MockBenchmark().test()
204 record_page_test.WillStartBrowser(self._tab.browser.platform)
205 record_page_test.DidStartBrowser(self._tab.browser)
206 self.assertTrue('WillStartBrowser' in record_page_test.page_test.func_calls)
207 self.assertTrue('DidStartBrowser' in record_page_test.page_test.func_calls)