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