page_runner_unittest.py revision ca12bfac764ba476d6cd062bf1dde12cc64c3f40 
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    page = 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)
70
71    class Test(page_test.PageTest):
72      @property
73      def discard_first_result(self):
74        return True
75      def RunTest(self, *args):
76        pass
77
78    options = options_for_unittests.GetCopy()
79    options.output_format = 'none'
80    results = page_runner.Run(Test('RunTest'), ps, expectations, options)
81    self.assertEquals(0, len(results.successes))
82    self.assertEquals(0, len(results.failures))
83
84  def testCredentialsWhenLoginFails(self):
85    credentials_backend = StubCredentialsBackend(login_return_value=False)
86    did_run = self.runCredentialsTest(credentials_backend)
87    assert credentials_backend.did_get_login == True
88    assert credentials_backend.did_get_login_no_longer_needed == False
89    assert did_run == False
90
91  def testCredentialsWhenLoginSucceeds(self):
92    credentials_backend = StubCredentialsBackend(login_return_value=True)
93    did_run = self.runCredentialsTest(credentials_backend)
94    assert credentials_backend.did_get_login == True
95    assert credentials_backend.did_get_login_no_longer_needed == True
96    assert did_run
97
98  def runCredentialsTest(self, # pylint: disable=R0201
99                         credentials_backend):
100    ps = page_set.PageSet()
101    expectations = test_expectations.TestExpectations()
102    page = page_module.Page(
103        'file:///' + os.path.join('..', '..', 'unittest_data', 'blank.html'),
104        ps,
105        base_dir=os.path.dirname(__file__))
106    page.credentials = "test"
107    ps.pages.append(page)
108
109    did_run = [False]
110
111    try:
112      with tempfile.NamedTemporaryFile(delete=False) as f:
113        f.write(SIMPLE_CREDENTIALS_STRING)
114        ps.credentials_path = f.name
115
116      class TestThatInstallsCredentialsBackend(page_test.PageTest):
117        def __init__(self, credentials_backend):
118          super(TestThatInstallsCredentialsBackend, self).__init__('RunTest')
119          self._credentials_backend = credentials_backend
120
121        def SetUpBrowser(self, browser):
122          browser.credentials.AddBackend(self._credentials_backend)
123
124        def RunTest(self, page, tab, results): # pylint: disable=W0613,R0201
125          did_run[0] = True
126
127      test = TestThatInstallsCredentialsBackend(credentials_backend)
128      options = options_for_unittests.GetCopy()
129      options.output_format = 'none'
130      page_runner.Run(test, ps, expectations, options)
131    finally:
132      os.remove(f.name)
133
134    return did_run[0]
135
136  def testUserAgent(self):
137    ps = page_set.PageSet()
138    expectations = test_expectations.TestExpectations()
139    page = page_module.Page(
140        'file:///' + os.path.join('..', '..', 'unittest_data', 'blank.html'),
141        ps,
142        base_dir=os.path.dirname(__file__))
143    ps.pages.append(page)
144    ps.user_agent_type = 'tablet'
145
146    class TestUserAgent(page_test.PageTest):
147      def RunTest(self, page, tab, results): # pylint: disable=W0613,R0201
148        actual_user_agent = tab.EvaluateJavaScript('window.navigator.userAgent')
149        expected_user_agent = user_agent.UA_TYPE_MAPPING['tablet']
150        assert actual_user_agent.strip() == expected_user_agent
151
152        # This is so we can check later that the test actually made it into this
153        # function. Previously it was timing out before even getting here, which
154        # should fail, but since it skipped all the asserts, it slipped by.
155        self.hasRun = True # pylint: disable=W0201
156
157    test = TestUserAgent('RunTest')
158    options = options_for_unittests.GetCopy()
159    options.output_format = 'none'
160    page_runner.Run(test, ps, expectations, options)
161
162    self.assertTrue(hasattr(test, 'hasRun') and test.hasRun)
163
164  # Ensure that page_runner forces exactly 1 tab before running a page.
165  def testOneTab(self):
166    ps = page_set.PageSet()
167    expectations = test_expectations.TestExpectations()
168    page = page_module.Page(
169        'file:///' + os.path.join('..', '..', 'unittest_data', 'blank.html'),
170        ps,
171        base_dir=os.path.dirname(__file__))
172    ps.pages.append(page)
173
174    class TestOneTab(page_test.PageTest):
175      def __init__(self,
176                   test_method_name,
177                   action_name_to_run='',
178                   needs_browser_restart_after_each_run=False):
179        super(TestOneTab, self).__init__(test_method_name, action_name_to_run,
180                                         needs_browser_restart_after_each_run)
181        self._browser = None
182
183      def SetUpBrowser(self, browser):
184        self._browser = browser
185        if self._browser.supports_tab_control:
186          self._browser.tabs.New()
187
188      def RunTest(self, page, tab, results): # pylint: disable=W0613,R0201
189        if not self._browser.supports_tab_control:
190          logging.warning('Browser does not support tab control, skipping test')
191          return
192        assert len(self._browser.tabs) == 1
193
194    test = TestOneTab('RunTest')
195    options = options_for_unittests.GetCopy()
196    options.output_format = 'none'
197    page_runner.Run(test, ps, expectations, options)
198