page_runner_unittest.py revision a3f7b4e666c476898878fa745f637129375cd889 
1# Copyright (c) 2012 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.
4import logging
5import os
6import tempfile
7import unittest
8
9from telemetry.core import user_agent
10from telemetry.page import page as page_module
11from telemetry.page import page_set
12from telemetry.page import page_test
13from telemetry.page import page_runner
14from telemetry.unittest import options_for_unittests
15from telemetry.page import test_expectations
16
17SIMPLE_CREDENTIALS_STRING = """
18{
19  "test": {
20    "username": "example",
21    "password": "asdf"
22  }
23}
24"""
25class StubCredentialsBackend(object):
26  def __init__(self, login_return_value):
27    self.did_get_login = False
28    self.did_get_login_no_longer_needed = False
29    self.login_return_value = login_return_value
30
31  @property
32  def credentials_type(self): # pylint: disable=R0201
33    return 'test'
34
35  def LoginNeeded(self, tab, config): # pylint: disable=W0613
36    self.did_get_login = True
37    return self.login_return_value
38
39  def LoginNoLongerNeeded(self, tab): # pylint: disable=W0613
40    self.did_get_login_no_longer_needed = True
41
42class PageRunnerTests(unittest.TestCase):
43  # TODO(nduca): Move the basic "test failed, test succeeded" tests from
44  # page_measurement_unittest to here.
45
46  def testHandlingOfCrashedTab(self):
47    ps = page_set.PageSet()
48    expectations = test_expectations.TestExpectations()
49    page1 = page_module.Page('chrome://crash', ps)
50    ps.pages.append(page1)
51
52    class Test(page_test.PageTest):
53      def RunTest(self, *args):
54        pass
55
56    options = options_for_unittests.GetCopy()
57    options.output_format = 'none'
58    results = page_runner.Run(Test('RunTest'), ps, expectations, options)
59    self.assertEquals(0, len(results.successes))
60    self.assertEquals(1, len(results.errors))
61
62  def testDiscardFirstResult(self):
63    ps = page_set.PageSet()
64    expectations = test_expectations.TestExpectations()
65    ps.pages.append(page_module.Page(
66        'file:///' + os.path.join('..', '..', 'unittest_data', 'blank.html'),
67        ps,
68        base_dir=os.path.dirname(__file__)))
69    ps.pages.append(page_module.Page(
70        'file:///' + os.path.join('..', '..', 'unittest_data', 'blank.html'),
71        ps,
72        base_dir=os.path.dirname(__file__)))
73
74    class Test(page_test.PageTest):
75      @property
76      def discard_first_result(self):
77        return True
78      def RunTest(self, *args):
79        pass
80
81    options = options_for_unittests.GetCopy()
82    options.output_format = 'none'
83
84    options.repeat_options.page_repeat_iters = 1
85    options.repeat_options.pageset_repeat_iters = 1
86    results = page_runner.Run(Test('RunTest'), ps, expectations, options)
87    self.assertEquals(0, len(results.successes))
88    self.assertEquals(0, len(results.failures))
89
90    options.repeat_options.page_repeat_iters = 1
91    options.repeat_options.pageset_repeat_iters = 2
92    results = page_runner.Run(Test('RunTest'), ps, expectations, options)
93    self.assertEquals(2, len(results.successes))
94    self.assertEquals(0, len(results.failures))
95
96    options.repeat_options.page_repeat_iters = 2
97    options.repeat_options.pageset_repeat_iters = 1
98    results = page_runner.Run(Test('RunTest'), ps, expectations, options)
99    self.assertEquals(2, len(results.successes))
100    self.assertEquals(0, len(results.failures))
101
102  def testCredentialsWhenLoginFails(self):
103    credentials_backend = StubCredentialsBackend(login_return_value=False)
104    did_run = self.runCredentialsTest(credentials_backend)
105    assert credentials_backend.did_get_login == True
106    assert credentials_backend.did_get_login_no_longer_needed == False
107    assert did_run == False
108
109  def testCredentialsWhenLoginSucceeds(self):
110    credentials_backend = StubCredentialsBackend(login_return_value=True)
111    did_run = self.runCredentialsTest(credentials_backend)
112    assert credentials_backend.did_get_login == True
113    assert credentials_backend.did_get_login_no_longer_needed == True
114    assert did_run
115
116  def runCredentialsTest(self, # pylint: disable=R0201
117                         credentials_backend):
118    ps = page_set.PageSet()
119    expectations = test_expectations.TestExpectations()
120    page = page_module.Page(
121        'file:///' + os.path.join('..', '..', 'unittest_data', 'blank.html'),
122        ps,
123        base_dir=os.path.dirname(__file__))
124    page.credentials = "test"
125    ps.pages.append(page)
126
127    did_run = [False]
128
129    try:
130      with tempfile.NamedTemporaryFile(delete=False) as f:
131        f.write(SIMPLE_CREDENTIALS_STRING)
132        ps.credentials_path = f.name
133
134      class TestThatInstallsCredentialsBackend(page_test.PageTest):
135        def __init__(self, credentials_backend):
136          super(TestThatInstallsCredentialsBackend, self).__init__('RunTest')
137          self._credentials_backend = credentials_backend
138
139        def SetUpBrowser(self, browser):
140          browser.credentials.AddBackend(self._credentials_backend)
141
142        def RunTest(self, page, tab, results): # pylint: disable=W0613,R0201
143          did_run[0] = True
144
145      test = TestThatInstallsCredentialsBackend(credentials_backend)
146      options = options_for_unittests.GetCopy()
147      options.output_format = 'none'
148      page_runner.Run(test, ps, expectations, options)
149    finally:
150      os.remove(f.name)
151
152    return did_run[0]
153
154  def testUserAgent(self):
155    ps = page_set.PageSet()
156    expectations = test_expectations.TestExpectations()
157    page = page_module.Page(
158        'file:///' + os.path.join('..', '..', 'unittest_data', 'blank.html'),
159        ps,
160        base_dir=os.path.dirname(__file__))
161    ps.pages.append(page)
162    ps.user_agent_type = 'tablet'
163
164    class TestUserAgent(page_test.PageTest):
165      def RunTest(self, page, tab, results): # pylint: disable=W0613,R0201
166        actual_user_agent = tab.EvaluateJavaScript('window.navigator.userAgent')
167        expected_user_agent = user_agent.UA_TYPE_MAPPING['tablet']
168        assert actual_user_agent.strip() == expected_user_agent
169
170        # This is so we can check later that the test actually made it into this
171        # function. Previously it was timing out before even getting here, which
172        # should fail, but since it skipped all the asserts, it slipped by.
173        self.hasRun = True # pylint: disable=W0201
174
175    test = TestUserAgent('RunTest')
176    options = options_for_unittests.GetCopy()
177    options.output_format = 'none'
178    page_runner.Run(test, ps, expectations, options)
179
180    self.assertTrue(hasattr(test, 'hasRun') and test.hasRun)
181
182  # Ensure that page_runner forces exactly 1 tab before running a page.
183  def testOneTab(self):
184    ps = page_set.PageSet()
185    expectations = test_expectations.TestExpectations()
186    page = page_module.Page(
187        'file:///' + os.path.join('..', '..', 'unittest_data', 'blank.html'),
188        ps,
189        base_dir=os.path.dirname(__file__))
190    ps.pages.append(page)
191
192    class TestOneTab(page_test.PageTest):
193      def __init__(self,
194                   test_method_name,
195                   action_name_to_run='',
196                   needs_browser_restart_after_each_run=False):
197        super(TestOneTab, self).__init__(test_method_name, action_name_to_run,
198                                         needs_browser_restart_after_each_run)
199        self._browser = None
200
201      def SetUpBrowser(self, browser):
202        self._browser = browser
203        if self._browser.supports_tab_control:
204          self._browser.tabs.New()
205
206      def RunTest(self, page, tab, results): # pylint: disable=W0613,R0201
207        if not self._browser.supports_tab_control:
208          logging.warning('Browser does not support tab control, skipping test')
209          return
210        assert len(self._browser.tabs) == 1
211
212    test = TestOneTab('RunTest')
213    options = options_for_unittests.GetCopy()
214    options.output_format = 'none'
215    page_runner.Run(test, ps, expectations, options)
216