13842dac7333e42aa44531eda34ba55200b99ccf8Daniel Jacobowitz# Copyright 2012 The Chromium Authors. All rights reserved.
23842dac7333e42aa44531eda34ba55200b99ccf8Daniel Jacobowitz# Use of this source code is governed by a BSD-style license that can be
33842dac7333e42aa44531eda34ba55200b99ccf8Daniel Jacobowitz# found in the LICENSE file.
43842dac7333e42aa44531eda34ba55200b99ccf8Daniel Jacobowitz
53842dac7333e42aa44531eda34ba55200b99ccf8Daniel Jacobowitzimport logging
6import os
7import shutil
8import tempfile
9import unittest
10
11from telemetry.core import browser_finder
12from telemetry.core import extension_to_load
13from telemetry.core import util
14from telemetry.unittest import options_for_unittests
15
16
17class ExtensionTest(unittest.TestCase):
18  def setUp(self):
19    self._browser = None
20    self._extension = None
21    self._extension_id = None
22
23  def CreateBrowserWithExtension(self, ext_path):
24    extension_path = os.path.join(util.GetUnittestDataDir(), ext_path)
25    options = options_for_unittests.GetCopy()
26    load_extension = extension_to_load.ExtensionToLoad(
27        extension_path, options.browser_type)
28    options.extensions_to_load = [load_extension]
29    browser_to_create = browser_finder.FindBrowser(options)
30
31    if not browser_to_create:
32      # May not find a browser that supports extensions.
33      return False
34    self._browser = browser_to_create.Create()
35    self._extension = self._browser.extensions[load_extension]
36    self._extension_id = load_extension.extension_id
37    self.assertTrue(self._extension)
38    return True
39
40  def tearDown(self):
41    if self._browser:
42      self._browser.Close()
43
44  def testExtensionBasic(self):
45    """Test ExtensionPage's ExecuteJavaScript and EvaluateJavaScript."""
46    if not self.CreateBrowserWithExtension('simple_extension'):
47      logging.warning('Did not find a browser that supports extensions, '
48                      'skipping test.')
49      return
50    self.assertTrue(
51        self._extension.EvaluateJavaScript('chrome.runtime != null'))
52    self._extension.ExecuteJavaScript('setTestVar("abcdef")')
53    self.assertEquals('abcdef',
54                      self._extension.EvaluateJavaScript('_testVar'))
55
56  def testExtensionGetByExtensionId(self):
57    """Test GetByExtensionId for a simple extension with a background page."""
58    if not self.CreateBrowserWithExtension('simple_extension'):
59      logging.warning('Did not find a browser that supports extensions, '
60                      'skipping test.')
61      return
62    ext = self._browser.extensions.GetByExtensionId(self._extension_id)
63    self.assertEqual(1, len(ext))
64    self.assertEqual(ext[0], self._extension)
65    self.assertTrue(
66        ext[0].EvaluateJavaScript('chrome.runtime != null'))
67
68  def testWebApp(self):
69    """Tests GetByExtensionId for a web app with multiple pages."""
70    if not self.CreateBrowserWithExtension('simple_app'):
71      logging.warning('Did not find a browser that supports extensions, '
72                      'skipping test.')
73      return
74    extensions = self._browser.extensions.GetByExtensionId(self._extension_id)
75    extension_urls = set([ext.EvaluateJavaScript('location.href;')
76                          for ext in extensions])
77    expected_urls = set(['chrome-extension://' + self._extension_id + '/' + path
78                         for path in ['main.html', 'second.html',
79                                      '_generated_background_page.html']])
80
81    self.assertEqual(expected_urls, extension_urls)
82
83class NonExistentExtensionTest(unittest.TestCase):
84  def testNonExistentExtensionPath(self):
85    """Test that a non-existent extension path will raise an exception."""
86    extension_path = os.path.join(util.GetUnittestDataDir(), 'foo')
87    options = options_for_unittests.GetCopy()
88    self.assertRaises(extension_to_load.ExtensionPathNonExistentException,
89                      lambda: extension_to_load.ExtensionToLoad(
90                          extension_path, options.browser_type))
91
92  def testExtensionNotLoaded(self):
93    """Querying an extension that was not loaded will return None"""
94    extension_path = os.path.join(util.GetUnittestDataDir(), 'simple_extension')
95    options = options_for_unittests.GetCopy()
96    load_extension = extension_to_load.ExtensionToLoad(
97        extension_path, options.browser_type)
98    browser_to_create = browser_finder.FindBrowser(options)
99    with browser_to_create.Create() as b:
100      if b.supports_extensions:
101        self.assertRaises(KeyError, lambda: b.extensions[load_extension])
102
103class MultipleExtensionTest(unittest.TestCase):
104  def setUp(self):
105    """ Copy the manifest and background.js files of simple_extension to a
106    number of temporary directories to load as extensions"""
107    self._extension_dirs = [tempfile.mkdtemp()
108                            for i in range(3)] # pylint: disable=W0612
109    src_extension_dir = os.path.join(
110        util.GetUnittestDataDir(), 'simple_extension')
111    manifest_path = os.path.join(src_extension_dir, 'manifest.json')
112    script_path = os.path.join(src_extension_dir, 'background.js')
113    for d in self._extension_dirs:
114      shutil.copy(manifest_path, d)
115      shutil.copy(script_path, d)
116    options = options_for_unittests.GetCopy()
117    self._extensions_to_load = [extension_to_load.ExtensionToLoad(
118                                    d, options.browser_type)
119                                for d in self._extension_dirs]
120    options.extensions_to_load = self._extensions_to_load
121    browser_to_create = browser_finder.FindBrowser(options)
122    self._browser = None
123    # May not find a browser that supports extensions.
124    if browser_to_create:
125      self._browser = browser_to_create.Create()
126
127  def tearDown(self):
128    if self._browser:
129      self._browser.Close()
130    for d in self._extension_dirs:
131      shutil.rmtree(d)
132
133  def testMultipleExtensions(self):
134    if not self._browser:
135      logging.warning('Did not find a browser that supports extensions, '
136                      'skipping test.')
137      return
138
139    # Test contains.
140    loaded_extensions = filter(lambda e: e in self._browser.extensions,
141                               self._extensions_to_load)
142    self.assertEqual(len(loaded_extensions), len(self._extensions_to_load))
143
144    for load_extension in self._extensions_to_load:
145      extension = self._browser.extensions[load_extension]
146      assert extension
147      self.assertTrue(
148          extension.EvaluateJavaScript('chrome.runtime != null'))
149      extension.ExecuteJavaScript('setTestVar("abcdef")')
150      self.assertEquals('abcdef', extension.EvaluateJavaScript('_testVar'))
151
152
153class ComponentExtensionTest(unittest.TestCase):
154  def testComponentExtensionBasic(self):
155    extension_path = os.path.join(
156        util.GetUnittestDataDir(), 'component_extension')
157    options = options_for_unittests.GetCopy()
158    load_extension = extension_to_load.ExtensionToLoad(
159        extension_path, options.browser_type, is_component=True)
160
161    options.extensions_to_load = [load_extension]
162    browser_to_create = browser_finder.FindBrowser(options)
163    if not browser_to_create:
164      logging.warning('Did not find a browser that supports extensions, '
165                      'skipping test.')
166      return
167
168    with browser_to_create.Create() as b:
169      extension = b.extensions[load_extension]
170      self.assertTrue(
171          extension.EvaluateJavaScript('chrome.runtime != null'))
172      extension.ExecuteJavaScript('setTestVar("abcdef")')
173      self.assertEquals('abcdef', extension.EvaluateJavaScript('_testVar'))
174
175  def testComponentExtensionNoPublicKey(self):
176    # simple_extension does not have a public key.
177    extension_path = os.path.join(util.GetUnittestDataDir(), 'simple_extension')
178    options = options_for_unittests.GetCopy()
179    self.assertRaises(extension_to_load.MissingPublicKeyException,
180                      lambda: extension_to_load.ExtensionToLoad(
181                          extension_path,
182                          browser_type=options.browser_type,
183                          is_component=True))
184