src/tools/telemetry/telemetry/unittest/run_tests.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 unittest
   7
   8 from telemetry import decorators
   9 from telemetry.core import browser_options
  10 from telemetry.core import discover
  11 from telemetry.core import util
  12 from telemetry.unittest import gtest_testrunner
  13 from telemetry.unittest import options_for_unittests
  14
  15
  16 def Discover(start_dir, top_level_dir=None, pattern='test*.py'):
  17   loader = unittest.defaultTestLoader
  18   loader.suiteClass = gtest_testrunner.GTestTestSuite
  19   subsuites = []
  20
  21   modules = discover.DiscoverModules(start_dir, top_level_dir, pattern)
  22   for module in modules:
  23     if hasattr(module, 'suite'):
  24       new_suite = module.suite()
  25     else:
  26       new_suite = loader.loadTestsFromModule(module)
  27     if new_suite.countTestCases():
  28       subsuites.append(new_suite)
  29   return gtest_testrunner.GTestTestSuite(subsuites)
  30
  31
  32 def FilterSuite(suite, predicate):
  33   new_suite = suite.__class__()
  34   for x in suite:
  35     if isinstance(x, unittest.TestSuite):
  36       subsuite = FilterSuite(x, predicate)
  37       if subsuite.countTestCases() == 0:
  38         continue
  39
  40       new_suite.addTest(subsuite)
  41       continue
  42
  43     assert isinstance(x, unittest.TestCase)
  44     if predicate(x):
  45       new_suite.addTest(x)
  46
  47   return new_suite
  48
  49
  50 def DiscoverAndRunTests(dir_name, args, top_level_dir, platform,
  51                         options, default_options, runner):
  52   if not runner:
  53     runner = gtest_testrunner.GTestTestRunner(inner=True)
  54   suite = Discover(dir_name, top_level_dir, '*_unittest.py')
  55   def IsTestSelected(test):
  56     if len(args) != 0:
  57       found = False
  58       for name in args:
  59         if name in test.id():
  60           found = True
  61       if not found:
  62         return False
  63     if default_options.run_disabled_tests:
  64       return True
  65     # pylint: disable=W0212
  66     if not hasattr(test, '_testMethodName'):
  67       return True
  68     method = getattr(test, test._testMethodName)
  69     return decorators.IsEnabled(method, options.GetBrowserType(), platform)
  70   filtered_suite = FilterSuite(suite, IsTestSelected)
  71   test_result = runner.run(filtered_suite)
  72   return test_result
  73
  74
  75 def RestoreLoggingLevel(func):
  76   def _LoggingRestoreWrapper(*args, **kwargs):
  77     # Cache the current logging level, this needs to be done before calling
  78     # parser.parse_args, which changes logging level based on verbosity
  79     # setting.
  80     logging_level = logging.getLogger().getEffectiveLevel()
  81     try:
  82       return func(*args, **kwargs)
  83     finally:
  84       # Restore logging level, which may be changed in parser.parse_args.
  85       logging.getLogger().setLevel(logging_level)
  86
  87   return _LoggingRestoreWrapper
  88
  89
  90 @RestoreLoggingLevel
  91 def Main(args, start_dir, top_level_dir, runner=None):
  92   """Unit test suite that collects all test cases for telemetry."""
  93   # Add unittest_data to the path so we can import packages from it.
  94   util.AddDirToPythonPath(util.GetUnittestDataDir())
  95
  96   default_options = browser_options.BrowserFinderOptions()
  97   default_options.browser_type = 'any'
  98
  99   parser = default_options.CreateParser('run_tests [options] [test names]')
 100   parser.add_option('--repeat-count', dest='run_test_repeat_count',
 101                     type='int', default=1,
 102                     help='Repeats each a provided number of times.')
 103   parser.add_option('-d', '--also-run-disabled-tests',
 104                     dest='run_disabled_tests',
 105                     action='store_true', default=False,
 106                     help='Ignore @Disabled and @Enabled restrictions.')
 107
 108   _, args = parser.parse_args(args)
 109
 110   if default_options.verbosity == 0:
 111     logging.getLogger().setLevel(logging.WARN)
 112
 113   from telemetry.core import browser_finder
 114   try:
 115     browser_to_create = browser_finder.FindBrowser(default_options)
 116   except browser_finder.BrowserFinderException, ex:
 117     logging.error(str(ex))
 118     return 1
 119
 120   if browser_to_create == None:
 121     logging.error('No browser found of type %s. Cannot run tests.',
 122                   default_options.browser_type)
 123     logging.error('Re-run with --browser=list to see available browser types.')
 124     return 1
 125
 126   options_for_unittests.Set(default_options,
 127                             browser_to_create.browser_type)
 128   try:
 129     success = True
 130     for _ in xrange(default_options.run_test_repeat_count):
 131       success = success and DiscoverAndRunTests(
 132           start_dir, args, top_level_dir, browser_to_create.platform,
 133           options_for_unittests, default_options, runner)
 134     if success:
 135       return 0
 136   finally:
 137     options_for_unittests.Set(None, None)
 138
 139   return 1