page_runner_unittest.py revision 2a99a7e74a7f215066514fe81d2bfa6639d9eddd 
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 os
5import tempfile
6import unittest
7
8from telemetry.core import browser_finder
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.test 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_benchmark_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    results = page_test.PageTestResults()
50
51    class Test(page_test.PageTest):
52      def RunTest(self, *args):
53        pass
54
55    with page_runner.PageRunner(ps) as runner:
56      options = options_for_unittests.GetCopy()
57      possible_browser = browser_finder.FindBrowser(options)
58      runner.Run(options, possible_browser, Test('RunTest'), results)
59    self.assertEquals(0, len(results.page_successes))
60    self.assertEquals(1, len(results.page_failures))
61
62  def disabled_testCredentialsWhenLoginFails(self):
63    # This test is disabled because it runs against live sites, and needs to be
64    # fixed. crbug.com/179038
65    results = page_test.PageTestResults()
66    credentials_backend = StubCredentialsBackend(login_return_value=False)
67    did_run = self.runCredentialsTest(credentials_backend, results)
68    assert credentials_backend.did_get_login == True
69    assert credentials_backend.did_get_login_no_longer_needed == False
70    assert did_run == False
71
72  def disabled_testCredentialsWhenLoginSucceeds(self):
73    # This test is disabled because it runs against live sites, and needs to be
74    # fixed. crbug.com/179038
75    results = page_test.PageTestResults()
76    credentials_backend = StubCredentialsBackend(login_return_value=True)
77    did_run = self.runCredentialsTest(credentials_backend, results)
78    assert credentials_backend.did_get_login == True
79    assert credentials_backend.did_get_login_no_longer_needed == True
80    assert did_run
81
82  def runCredentialsTest(self, # pylint: disable=R0201
83                         credentials_backend,
84                         results):
85    ps = page_set.PageSet()
86    page = page_module.Page('http://www.google.com', ps)
87    page.credentials = "test"
88    ps.pages.append(page)
89
90    did_run = [False]
91
92    with tempfile.NamedTemporaryFile() as f:
93      f.write(SIMPLE_CREDENTIALS_STRING)
94      f.flush()
95      ps.credentials_path = f.name
96
97      class TestThatInstallsCredentialsBackend(page_test.PageTest):
98        def __init__(self, credentials_backend):
99          super(TestThatInstallsCredentialsBackend, self).__init__('RunTest')
100          self._credentials_backend = credentials_backend
101
102        def SetUpBrowser(self, browser):
103          browser.credentials.AddBackend(self._credentials_backend)
104
105        def RunTest(self, page, tab, results): # pylint: disable=W0613,R0201
106          did_run[0] = True
107
108      test = TestThatInstallsCredentialsBackend(credentials_backend)
109      with page_runner.PageRunner(ps) as runner:
110        options = options_for_unittests.GetCopy()
111        possible_browser = browser_finder.FindBrowser(options)
112        runner.Run(options, possible_browser, test, results)
113
114    return did_run[0]
115
116  def testUserAgent(self):
117    ps = page_set.PageSet()
118    page = page_module.Page(
119        'file:///' + os.path.join('..', '..', 'unittest_data', 'blank.html'),
120        ps,
121        base_dir=os.path.dirname(__file__))
122    ps.pages.append(page)
123    ps.user_agent_type = 'tablet'
124
125    class TestUserAgent(page_test.PageTest):
126      def RunTest(self, page, tab, results): # pylint: disable=W0613,R0201
127        actual_user_agent = tab.EvaluateJavaScript('window.navigator.userAgent')
128        expected_user_agent = user_agent.UA_TYPE_MAPPING['tablet']
129        assert actual_user_agent.strip() == expected_user_agent
130
131        # This is so we can check later that the test actually made it into this
132        # function. Previously it was timing out before even getting here, which
133        # should fail, but since it skipped all the asserts, it slipped by.
134        self.hasRun = True # pylint: disable=W0201
135
136    test = TestUserAgent('RunTest')
137    with page_runner.PageRunner(ps) as runner:
138      options = options_for_unittests.GetCopy()
139      possible_browser = browser_finder.FindBrowser(options)
140      results = page_test.PageTestResults()
141      runner.Run(options, possible_browser, test, results)
142
143    self.assertTrue(hasattr(test, 'hasRun') and test.hasRun)
144
145  # Ensure that page_runner forces exactly 1 tab before running a page.
146  def testOneTab(self):
147    ps = page_set.PageSet()
148    page = page_module.Page(
149        'file:///' + os.path.join('..', '..', 'unittest_data', 'blank.html'),
150        ps,
151        base_dir=os.path.dirname(__file__))
152    ps.pages.append(page)
153
154    class TestOneTab(page_test.PageTest):
155      def __init__(self,
156                   test_method_name,
157                   action_name_to_run='',
158                   needs_browser_restart_after_each_run=False):
159        super(TestOneTab, self).__init__(test_method_name, action_name_to_run,
160                                         needs_browser_restart_after_each_run)
161        self._browser = None
162
163      def SetUpBrowser(self, browser):
164        self._browser = browser
165        self._browser.tabs.New()
166
167      def RunTest(self, page, tab, results): # pylint: disable=W0613,R0201
168        assert len(self._browser.tabs) == 1
169
170    test = TestOneTab('RunTest')
171    with page_runner.PageRunner(ps) as runner:
172      options = options_for_unittests.GetCopy()
173      possible_browser = browser_finder.FindBrowser(options)
174      results = page_test.PageTestResults()
175      runner.Run(options, possible_browser, test, results)
176