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