src/tools/telemetry/telemetry/core/extension_unittest.py

   1 # Copyright 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.
   4
   5 import logging
   6 import os
   7 import shutil
   8 import tempfile
   9 import unittest
  10
  11 from telemetry.core import browser_finder
  12 from telemetry.core import extension_to_load
  13 from telemetry.core import util
  14 from telemetry.unittest import options_for_unittests
  15
  16
  17 class 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
  83 class 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
 103 class 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
 153 class 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))