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

   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.
   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.core.backends.chrome import extension_dict_backend
  15 from telemetry.unittest import options_for_unittests
  16
  17
  18 class ExtensionTest(unittest.TestCase):
  19   def setUp(self):
  20     extension_path = os.path.join(util.GetUnittestDataDir(), 'simple_extension')
  21     options = options_for_unittests.GetCopy()
  22     load_extension = extension_to_load.ExtensionToLoad(
  23         extension_path, options.browser_type)
  24     options.extensions_to_load = [load_extension]
  25     browser_to_create = browser_finder.FindBrowser(options)
  26
  27     self._browser = None
  28     self._extension = None
  29     if not browser_to_create:
  30       # May not find a browser that supports extensions.
  31       return
  32     self._browser = browser_to_create.Create()
  33     self._browser.Start()
  34     self._extension = self._browser.extensions[load_extension]
  35     self.assertTrue(self._extension)
  36
  37   def tearDown(self):
  38     if self._browser:
  39       self._browser.Close()
  40
  41   def testExtensionBasic(self):
  42     """Test ExtensionPage's ExecuteJavaScript and EvaluateJavaScript."""
  43     if not self._extension:
  44       logging.warning('Did not find a browser that supports extensions, '
  45                       'skipping test.')
  46       return
  47     self.assertTrue(
  48         self._extension.EvaluateJavaScript('chrome.runtime != null'))
  49     self._extension.ExecuteJavaScript('setTestVar("abcdef")')
  50     self.assertEquals('abcdef',
  51                       self._extension.EvaluateJavaScript('_testVar'))
  52
  53   def testDisconnect(self):
  54     """Test that ExtensionPage.Disconnect exists by calling it.
  55     EvaluateJavaScript should reconnect."""
  56     if not self._extension:
  57       logging.warning('Did not find a browser that supports extensions, '
  58                       'skipping test.')
  59       return
  60     self._extension.Disconnect()
  61     self.assertEquals(2, self._extension.EvaluateJavaScript('1+1'))
  62
  63 class NonExistentExtensionTest(unittest.TestCase):
  64   def testNonExistentExtensionPath(self):
  65     """Test that a non-existent extension path will raise an exception."""
  66     extension_path = os.path.join(util.GetUnittestDataDir(), 'foo')
  67     options = options_for_unittests.GetCopy()
  68     self.assertRaises(extension_to_load.ExtensionPathNonExistentException,
  69                       lambda: extension_to_load.ExtensionToLoad(
  70                           extension_path, options.browser_type))
  71
  72   def testExtensionNotLoaded(self):
  73     """Querying an extension that was not loaded will return None"""
  74     extension_path = os.path.join(util.GetUnittestDataDir(), 'simple_extension')
  75     options = options_for_unittests.GetCopy()
  76     load_extension = extension_to_load.ExtensionToLoad(
  77         extension_path, options.browser_type)
  78     browser_to_create = browser_finder.FindBrowser(options)
  79     with browser_to_create.Create() as b:
  80       b.Start()
  81       if b.supports_extensions:
  82         self.assertRaises(extension_dict_backend.ExtensionNotFoundException,
  83                           lambda: b.extensions[load_extension])
  84
  85 class MultipleExtensionTest(unittest.TestCase):
  86   def setUp(self):
  87     """ Copy the manifest and background.js files of simple_extension to a
  88     number of temporary directories to load as extensions"""
  89     self._extension_dirs = [tempfile.mkdtemp()
  90                             for i in range(3)] # pylint: disable=W0612
  91     src_extension_dir = os.path.join(
  92         util.GetUnittestDataDir(), 'simple_extension')
  93     manifest_path = os.path.join(src_extension_dir, 'manifest.json')
  94     script_path = os.path.join(src_extension_dir, 'background.js')
  95     for d in self._extension_dirs:
  96       shutil.copy(manifest_path, d)
  97       shutil.copy(script_path, d)
  98     options = options_for_unittests.GetCopy()
  99     self._extensions_to_load = [extension_to_load.ExtensionToLoad(
 100                                     d, options.browser_type)
 101                                 for d in self._extension_dirs]
 102     options.extensions_to_load = self._extensions_to_load
 103     browser_to_create = browser_finder.FindBrowser(options)
 104     self._browser = None
 105     # May not find a browser that supports extensions.
 106     if browser_to_create:
 107       self._browser = browser_to_create.Create()
 108       self._browser.Start()
 109
 110   def tearDown(self):
 111     if self._browser:
 112       self._browser.Close()
 113     for d in self._extension_dirs:
 114       shutil.rmtree(d)
 115
 116   def testMultipleExtensions(self):
 117     if not self._browser:
 118       logging.warning('Did not find a browser that supports extensions, '
 119                       'skipping test.')
 120       return
 121
 122     # Test contains.
 123     loaded_extensions = filter(lambda e: e in self._browser.extensions,
 124                                self._extensions_to_load)
 125     self.assertEqual(len(loaded_extensions), len(self._extensions_to_load))
 126
 127     for load_extension in self._extensions_to_load:
 128       extension = self._browser.extensions[load_extension]
 129       assert extension
 130       self.assertTrue(
 131           extension.EvaluateJavaScript('chrome.runtime != null'))
 132       extension.ExecuteJavaScript('setTestVar("abcdef")')
 133       self.assertEquals('abcdef', extension.EvaluateJavaScript('_testVar'))
 134
 135
 136 class ComponentExtensionTest(unittest.TestCase):
 137   def testComponentExtensionBasic(self):
 138     extension_path = os.path.join(
 139         util.GetUnittestDataDir(), 'component_extension')
 140     options = options_for_unittests.GetCopy()
 141     load_extension = extension_to_load.ExtensionToLoad(
 142         extension_path, options.browser_type, is_component=True)
 143
 144     options.extensions_to_load = [load_extension]
 145     browser_to_create = browser_finder.FindBrowser(options)
 146     if not browser_to_create:
 147       logging.warning('Did not find a browser that supports extensions, '
 148                       'skipping test.')
 149       return
 150
 151     with browser_to_create.Create() as b:
 152       b.Start()
 153       extension = b.extensions[load_extension]
 154       self.assertTrue(
 155           extension.EvaluateJavaScript('chrome.runtime != null'))
 156       extension.ExecuteJavaScript('setTestVar("abcdef")')
 157       self.assertEquals('abcdef', extension.EvaluateJavaScript('_testVar'))
 158
 159   def testComponentExtensionNoPublicKey(self):
 160     # simple_extension does not have a public key.
 161     extension_path = os.path.join(util.GetUnittestDataDir(), 'simple_extension')
 162     options = options_for_unittests.GetCopy()
 163     self.assertRaises(extension_to_load.MissingPublicKeyException,
 164                       lambda: extension_to_load.ExtensionToLoad(
 165                           extension_path,
 166                           browser_type=options.browser_type,
 167                           is_component=True))