236 lines
9.2 KiB
Python
236 lines
9.2 KiB
Python
# Copyright (C) 2016 Intel Corporation
|
|
# Released under the MIT license (see COPYING.MIT)
|
|
|
|
import os
|
|
import sys
|
|
import unittest
|
|
|
|
from oeqa.core.utils.path import findFile
|
|
from oeqa.core.utils.test import getSuiteModules, getCaseID
|
|
|
|
from oeqa.core.case import OETestCase
|
|
from oeqa.core.decorator import decoratorClasses, OETestDecorator, \
|
|
OETestFilter, OETestDiscover
|
|
|
|
def _make_failed_test(classname, methodname, exception, suiteClass):
|
|
"""
|
|
When loading tests unittest framework stores the exception in a new
|
|
class created for be displayed into run().
|
|
|
|
For our purposes will be better to raise the exception in loading
|
|
step instead of wait to run the test suite.
|
|
"""
|
|
raise exception
|
|
unittest.loader._make_failed_test = _make_failed_test
|
|
|
|
def _find_duplicated_modules(suite, directory):
|
|
for module in getSuiteModules(suite):
|
|
path = findFile('%s.py' % module, directory)
|
|
if path:
|
|
raise ImportError("Duplicated %s module found in %s" % (module, path))
|
|
|
|
class OETestLoader(unittest.TestLoader):
|
|
caseClass = OETestCase
|
|
|
|
kwargs_names = ['testMethodPrefix', 'sortTestMethodUsing', 'suiteClass',
|
|
'_top_level_dir']
|
|
|
|
def __init__(self, tc, module_paths, modules, tests, modules_required,
|
|
filters, *args, **kwargs):
|
|
self.tc = tc
|
|
|
|
self.modules = modules
|
|
self.tests = tests
|
|
self.modules_required = modules_required
|
|
|
|
self.filters = filters
|
|
self.decorator_filters = [d for d in decoratorClasses if \
|
|
issubclass(d, OETestFilter)]
|
|
self._validateFilters(self.filters, self.decorator_filters)
|
|
self.used_filters = [d for d in self.decorator_filters
|
|
for f in self.filters
|
|
if f in d.attrs]
|
|
|
|
if isinstance(module_paths, str):
|
|
module_paths = [module_paths]
|
|
elif not isinstance(module_paths, list):
|
|
raise TypeError('module_paths must be a str or a list of str')
|
|
self.module_paths = module_paths
|
|
|
|
for kwname in self.kwargs_names:
|
|
if kwname in kwargs:
|
|
setattr(self, kwname, kwargs[kwname])
|
|
|
|
self._patchCaseClass(self.caseClass)
|
|
|
|
def _patchCaseClass(self, testCaseClass):
|
|
# Adds custom attributes to the OETestCase class
|
|
setattr(testCaseClass, 'tc', self.tc)
|
|
setattr(testCaseClass, 'td', self.tc.td)
|
|
setattr(testCaseClass, 'logger', self.tc.logger)
|
|
|
|
def _validateFilters(self, filters, decorator_filters):
|
|
# Validate if filter isn't empty
|
|
for key,value in filters.items():
|
|
if not value:
|
|
raise TypeError("Filter %s specified is empty" % key)
|
|
|
|
# Validate unique attributes
|
|
attr_filters = [attr for clss in decorator_filters \
|
|
for attr in clss.attrs]
|
|
dup_attr = [attr for attr in attr_filters
|
|
if attr_filters.count(attr) > 1]
|
|
if dup_attr:
|
|
raise TypeError('Detected duplicated attribute(s) %s in filter'
|
|
' decorators' % ' ,'.join(dup_attr))
|
|
|
|
# Validate if filter is supported
|
|
for f in filters:
|
|
if f not in attr_filters:
|
|
classes = ', '.join([d.__name__ for d in decorator_filters])
|
|
raise TypeError('Found "%s" filter but not declared in any of '
|
|
'%s decorators' % (f, classes))
|
|
|
|
def _registerTestCase(self, case):
|
|
case_id = case.id()
|
|
self.tc._registry['cases'][case_id] = case
|
|
|
|
def _handleTestCaseDecorators(self, case):
|
|
def _handle(obj):
|
|
if isinstance(obj, OETestDecorator):
|
|
if not obj.__class__ in decoratorClasses:
|
|
raise Exception("Decorator %s isn't registered" \
|
|
" in decoratorClasses." % obj.__name__)
|
|
obj.bind(self.tc._registry, case)
|
|
|
|
def _walk_closure(obj):
|
|
if hasattr(obj, '__closure__') and obj.__closure__:
|
|
for f in obj.__closure__:
|
|
obj = f.cell_contents
|
|
_handle(obj)
|
|
_walk_closure(obj)
|
|
method = getattr(case, case._testMethodName, None)
|
|
_walk_closure(method)
|
|
|
|
def _filterTest(self, case):
|
|
"""
|
|
Returns True if test case must be filtered, False otherwise.
|
|
"""
|
|
if self.filters:
|
|
filters = self.filters.copy()
|
|
case_decorators = [cd for cd in case.decorators
|
|
if cd.__class__ in self.used_filters]
|
|
|
|
# Iterate over case decorators to check if needs to be filtered.
|
|
for cd in case_decorators:
|
|
if cd.filtrate(filters):
|
|
return True
|
|
|
|
# Case is missing one or more decorators for all the filters
|
|
# being used, so filter test case.
|
|
if filters:
|
|
return True
|
|
|
|
return False
|
|
|
|
def _getTestCase(self, testCaseClass, tcName):
|
|
if not hasattr(testCaseClass, '__oeqa_loader'):
|
|
# In order to support data_vars validation
|
|
# monkey patch the default setUp/tearDown{Class} to use
|
|
# the ones provided by OETestCase
|
|
setattr(testCaseClass, 'setUpClassMethod',
|
|
getattr(testCaseClass, 'setUpClass'))
|
|
setattr(testCaseClass, 'tearDownClassMethod',
|
|
getattr(testCaseClass, 'tearDownClass'))
|
|
setattr(testCaseClass, 'setUpClass',
|
|
testCaseClass._oeSetUpClass)
|
|
setattr(testCaseClass, 'tearDownClass',
|
|
testCaseClass._oeTearDownClass)
|
|
|
|
# In order to support decorators initialization
|
|
# monkey patch the default setUp/tearDown to use
|
|
# a setUpDecorators/tearDownDecorators that methods
|
|
# will call setUp/tearDown original methods.
|
|
setattr(testCaseClass, 'setUpMethod',
|
|
getattr(testCaseClass, 'setUp'))
|
|
setattr(testCaseClass, 'tearDownMethod',
|
|
getattr(testCaseClass, 'tearDown'))
|
|
setattr(testCaseClass, 'setUp', testCaseClass._oeSetUp)
|
|
setattr(testCaseClass, 'tearDown', testCaseClass._oeTearDown)
|
|
|
|
setattr(testCaseClass, '__oeqa_loader', True)
|
|
|
|
case = testCaseClass(tcName)
|
|
setattr(case, 'decorators', [])
|
|
|
|
return case
|
|
|
|
def loadTestsFromTestCase(self, testCaseClass):
|
|
"""
|
|
Returns a suite of all tests cases contained in testCaseClass.
|
|
"""
|
|
if issubclass(testCaseClass, unittest.suite.TestSuite):
|
|
raise TypeError("Test cases should not be derived from TestSuite." \
|
|
" Maybe you meant to derive from TestCase?")
|
|
if not issubclass(testCaseClass, self.caseClass):
|
|
raise TypeError("Test cases need to be derived from %s" % \
|
|
self.caseClass.__name__)
|
|
|
|
|
|
testCaseNames = self.getTestCaseNames(testCaseClass)
|
|
if not testCaseNames and hasattr(testCaseClass, 'runTest'):
|
|
testCaseNames = ['runTest']
|
|
|
|
suite = []
|
|
for tcName in testCaseNames:
|
|
case = self._getTestCase(testCaseClass, tcName)
|
|
# Filer by case id
|
|
if not (self.tests and not 'all' in self.tests
|
|
and not getCaseID(case) in self.tests):
|
|
self._handleTestCaseDecorators(case)
|
|
|
|
# Filter by decorators
|
|
if not self._filterTest(case):
|
|
self._registerTestCase(case)
|
|
suite.append(case)
|
|
|
|
return self.suiteClass(suite)
|
|
|
|
def discover(self):
|
|
big_suite = self.suiteClass()
|
|
for path in self.module_paths:
|
|
_find_duplicated_modules(big_suite, path)
|
|
suite = super(OETestLoader, self).discover(path,
|
|
pattern='*.py', top_level_dir=path)
|
|
big_suite.addTests(suite)
|
|
|
|
cases = None
|
|
discover_classes = [clss for clss in decoratorClasses
|
|
if issubclass(clss, OETestDiscover)]
|
|
for clss in discover_classes:
|
|
cases = clss.discover(self.tc._registry)
|
|
|
|
return self.suiteClass(cases) if cases else big_suite
|
|
|
|
# XXX After Python 3.5, remove backward compatibility hacks for
|
|
# use_load_tests deprecation via *args and **kws. See issue 16662.
|
|
if sys.version_info >= (3,5):
|
|
def loadTestsFromModule(self, module, *args, pattern=None, **kws):
|
|
if not self.modules or "all" in self.modules or \
|
|
module.__name__ in self.modules:
|
|
return super(OETestLoader, self).loadTestsFromModule(
|
|
module, *args, pattern=pattern, **kws)
|
|
else:
|
|
return self.suiteClass()
|
|
else:
|
|
def loadTestsFromModule(self, module, use_load_tests=True):
|
|
"""
|
|
Returns a suite of all tests cases contained in module.
|
|
"""
|
|
if not self.modules or "all" in self.modules or \
|
|
module.__name__ in self.modules:
|
|
return super(OETestLoader, self).loadTestsFromModule(
|
|
module, use_load_tests)
|
|
else:
|
|
return self.suiteClass()
|