def __init__(self,
name,
description=None,
category=None,
uid=None,
entries=None,
tags=None,
part=None,
fix_spec_path=None):
super(TestGroupReport, self).__init__(name=name,
description=description,
uid=uid,
entries=entries)
# This will be used for distinguishing test
# type (Multitest, GTest etc)
self.category = category
self.tags = tagging.validate_tag_value(tags) if tags else {}
self.tags_index = copy.deepcopy(self.tags)
# A test can be split into many parts and the report of each part
# can be hold back for merging (if necessary)
self.part = part # i.e. (m, n), while 0 <= m < n and n > 1
self.part_report_lookup = {}
self.fix_spec_path = fix_spec_path
if entries:
self.propagate_tag_indices()
def _generate_func(function, name_func, tag_func, docstring_func, tag_dict,
kwargs):
"""
Generates a new function using the original function, name generation
function and parametrized kwargs.
Also attaches parametrized and explicit tags and apply custom wrappers.
"""
def _generated(self, env, result):
return function(self, env, result, **kwargs)
_generated.__doc__ = docstring_func(function.__doc__, kwargs)\
if docstring_func else None
_generated.__name__ = _name_func_wrapper(name_func=name_func,
func_name=function.__name__,
kwargs=kwargs)
# Tags generated via `tag_func` will be assigned as native tags
_generated.__tags__ = tagging.validate_tag_value(tag_func(kwargs)) \
if tag_func else {}
# Tags index will be merged tag ctx of tag_dict & generated tags
_generated.__tags_index__ = tagging.merge_tag_dicts(
_generated.__tags__, tag_dict)
_generated._parametrization_template = function.__name__
return _generated
def _generate_func(function, name_func, tag_func, docstring_func, tags,
kwargs):
"""
Generates a new function using the original function, name generation
function and parametrized kwargs.
Also attaches parametrized and explicit tags and apply custom wrappers.
"""
def _generated(self, env, result):
return function(self, env, result, **kwargs)
_generated.__doc__ = docstring_func(function.__doc__, kwargs)\
if docstring_func else None
_generated.__name__ = _name_func_wrapper(name_func=name_func,
func_name=function.__name__,
kwargs=kwargs)
# Tagging
parametrized_tags = tagging.validate_tag_value(tag_func(kwargs))\
if tag_func else {}
tagging.attach_testcase_tags(
_generated, tagging.merge_tag_dicts(tags, parametrized_tags))
_generated._parametrization_template = function.__name__
return _generated
def __init__(self,
name,
category=ReportCategories.TESTGROUP,
tags=None,
part=None,
extra_attributes=None,
fix_spec_path=None,
env_status=None,
**kwargs):
super(TestGroupReport, self).__init__(name=name, **kwargs)
# This will be used for distinguishing test type (Multitest, GTest
# etc). Expected to be one of the ReportCategories enum, otherwise
# the report node will not be correctly rendered in the UI.
self.category = category
self.tags = tagging.validate_tag_value(tags) if tags else {}
self.tags_index = copy.deepcopy(self.tags)
# A test can be split into many parts and the report of each part
# can be hold back for merging (if necessary)
self.part = part # i.e. (m, n), while 0 <= m < n and n > 1
self.part_report_lookup = {}
self.extra_attributes = extra_attributes or {}
self.fix_spec_path = fix_spec_path
if self.entries:
self.propagate_tag_indices()
# Expected to be one of ResourceStatus, or None.
self.env_status = env_status
def wrapper(klass):
"""Meta logic for suite goes here."""
if custom_name is None or isinstance(custom_name, six.string_types):
pass
elif callable(custom_name):
try:
interface.check_signature(
custom_name, ["self", "original_name"]
)
except interface.MethodSignatureMismatch as err:
_reset_globals()
raise err
else:
_reset_globals()
raise TypeError("`custom_name` should be callable or a string")
klass.custom_name = custom_name
if tags:
klass.__tags__ = tagging.validate_tag_value(tags)
klass.__tags_index__ = copy.deepcopy(klass.__tags__)
else:
klass.__tags__ = {}
klass.__tags_index__ = {}
return _testsuite(klass)
def wrapper(function):
"""Meta logic for test case goes here"""
tag_dict = tagging.validate_tag_value(tags) if tags else {}
function.__tags__ = tag_dict.copy()
function.__tags_index__ = tag_dict.copy()
if parameters is not None: # Empty tuple / dict checks happen later
function.__parametrization_template__ = True
functions = parametrization.generate_functions(
function=function,
parameters=parameters,
name_func=name_func,
docstring_func=docstring_func,
tag_func=tag_func,
tag_dict=tag_dict,
summarize=summarize,
num_passing=defaults.SUMMARY_NUM_PASSING,
num_failing=defaults.SUMMARY_NUM_FAILING)
# Register generated functions as test_cases
for func in functions:
_validate_testcase(func)
# this has to be called before wrappers otherwise wrappers can
# fail if they rely on __testcase__
_mark_function_as_testcase(func)
wrappers = custom_wrappers or []
if not isinstance(wrappers, (list, tuple)):
wrappers = [wrappers]
for wrapper_func in wrappers:
func = wrapper_func(func)
# so that CodeDetails gets the correct line number
func.wrapper_of = function
__TESTCASES__.append(func.__name__)
__GENERATED_TESTCASES__.append(func)
# Update template method's tag index with generated
# testcases' tag indices. This will have no effect of test
# filtering logic, however generated test reports
# may need this data for report filtering.
if tag_func:
update_tag_index(function,
tag_dict=collect_testcase_tags(functions))
return function
else:
function.summarize = summarize
function.summarize_num_passing = num_passing
function.summarize_num_failing = num_failing
return _testcase(function)
def wrapper(function):
"""Meta logic for test case goes here"""
tag_dict = tagging.validate_tag_value(tags) if tags else {}
function.__tags__ = copy.deepcopy(tag_dict)
if parameters is not None: # Empty tuple / dict checks happen later
function.__parametrization_template__ = True
functions = parametrization.generate_functions(
function=function,
parameters=parameters,
name_func=name_func,
docstring_func=docstring_func,
tag_func=tag_func,
tag_dict=tag_dict,
summarize=summarize,
num_passing=num_passing,
num_failing=num_failing,
key_combs_limit=key_combs_limit,
execution_group=execution_group,
timeout=timeout
)
# Register generated functions as test_cases
for func in functions:
_validate_testcase(func)
# this has to be called before wrappers otherwise wrappers can
# fail if they rely on __testcase__
_mark_function_as_testcase(func)
wrappers = custom_wrappers or []
if not isinstance(wrappers, (list, tuple)):
wrappers = [wrappers]
for wrapper_func in wrappers:
func = wrapper_func(func)
# so that CodeDetails gets the correct line number
func.wrapper_of = function
__TESTCASES__.append(func.__name__)
__GENERATED_TESTCASES__.append(func)
return function
else:
function.summarize = summarize
function.summarize_num_passing = num_passing
function.summarize_num_failing = num_failing
function.summarize_key_combs_limit = key_combs_limit
function.execution_group = execution_group
function.timeout = timeout
function.__tags_index__ = copy.deepcopy(tag_dict)
return _testcase(function)
def wrapper(klass):
"""Meta logic for suite goes here"""
if tags:
klass.__tags__ = tagging.validate_tag_value(tags)
klass.__tags_index__ = copy.deepcopy(klass.__tags__)
suite = _testsuite(klass)
return suite
def wrapper(klass):
"""Meta logic for suite goes here."""
klass.name = name
if tags:
klass.__tags__ = tagging.validate_tag_value(tags)
klass.__tags_index__ = copy.deepcopy(klass.__tags__)
else:
klass.__tags__ = {}
klass.__tags_index__ = {}
return _testsuite(klass)
def _filter_func(obj):
# Include all testcase entries, which are in dict form
if isinstance(obj, dict):
return True
tag_dict = tagging.validate_tag_value(tag_value)
if all_tags:
match_func = tagging.check_all_matching_tags
else:
match_func = tagging.check_any_matching_tags
return match_func(tag_arg_dict=tag_dict,
target_tag_dict=obj.tags_index)
def __init__(self,
name,
description=None,
uid=None,
entries=None,
tags=None):
super(TestCaseReport, self).__init__(name=name,
uid=uid,
entries=entries,
description=description)
self.tags = tagging.validate_tag_value(tags) if tags else {}
self.tags_index = copy.deepcopy(self.tags)
self.status_override = None
self.timer = timing.Timer()
def _generate_func(
function, name, name_func, tag_func, docstring_func, tag_dict, kwargs
):
"""
Generates a new function using the original function, name generation
function and parametrized kwargs.
Also attaches parametrized and explicit tags and apply custom wrappers.
"""
def _generated(self, env, result):
return function(self, env, result, **kwargs)
# If we were given a docstring function, we use it to generate the
# docstring for each testcase. Otherwise we just copy the docstring from
# the template method.
if docstring_func:
_generated.__doc__ = docstring_func(function.__doc__, kwargs)
else:
_generated.__doc__ = function.__doc__
_generated.__name__ = _parametrization_name_func_wrapper(
func_name=function.__name__, kwargs=kwargs
)
_generated.name = name_func(name, kwargs) if name_func else name
if hasattr(function, "__xfail__"):
_generated.__xfail__ = function.__xfail__
# Tags generated via `tag_func` will be assigned as native tags
_generated.__tags__ = (
tagging.validate_tag_value(tag_func(kwargs)) if tag_func else {}
)
# Tags index will be merged tag ctx of tag_dict & generated tags
_generated.__tags_index__ = tagging.merge_tag_dicts(
_generated.__tags__, tag_dict
)
_generated._parametrization_template = function.__name__
_generated._parametrization_kwargs = kwargs
return _generated
def __init__(self,
name,
description=None,
uid=None,
entries=None,
tags=None,
suite_related=False):
super(TestCaseReport, self).__init__(name=name,
uid=uid,
entries=entries,
description=description)
self.tags = tagging.validate_tag_value(tags) if tags else {}
self.tags_index = copy.deepcopy(self.tags)
self.suite_related = suite_related
self.status_override = None
self.timer = timing.Timer()
self.attachments = []
self._status = Status.READY
def __init__(self,
name,
description=None,
category=None,
uid=None,
entries=None,
tags=None):
super(TestGroupReport, self).__init__(name=name,
uid=uid,
entries=entries,
description=description)
# This will be used for distinguishing test
# type (Multitest, GTest etc)
self.category = category
self.tags = tagging.validate_tag_value(tags) if tags else {}
self.tags_index = copy.deepcopy(self.tags)
if entries:
self.propagate_tag_indices()
def __init__(self,
name,
tags=None,
suite_related=False,
status_override=None,
status_reason=None,
**kwargs):
super(TestCaseReport, self).__init__(name=name, **kwargs)
self.tags = tagging.validate_tag_value(tags) if tags else {}
self.tags_index = copy.deepcopy(self.tags)
self.suite_related = suite_related
self.status_override = status_override
self.timer = timing.Timer()
self.attachments = []
# testcase is default to passed (e.g no assertion)
self._status = Status.UNKNOWN
self._runtime_status = RuntimeStatus.READY
self.category = ReportCategories.TESTCASE
self.status_reason = status_reason
def __init__(self, tags):
self.tags_orig = tags
self.tags = tagging.validate_tag_value(tags)
def wrapper(function):
"""Meta logic for test case goes here."""
global __GENERATED_TESTCASES__
global __PARAMETRIZATION_TEMPLATE__
_validate_function_name(function)
function.name = name or function.__name__
tag_dict = tagging.validate_tag_value(tags) if tags else {}
function.__tags__ = copy.deepcopy(tag_dict)
if parameters is not None: # Empty tuple / dict checks happen later
function.__parametrization_template__ = True
__PARAMETRIZATION_TEMPLATE__.append(function.__name__)
try:
functions = parametrization.generate_functions(
function=function,
name=function.name,
parameters=parameters,
name_func=name_func,
docstring_func=docstring_func,
tag_func=tag_func,
tag_dict=tag_dict,
summarize=summarize,
num_passing=num_passing,
num_failing=num_failing,
key_combs_limit=key_combs_limit,
execution_group=execution_group,
timeout=timeout,
)
except parametrization.ParametrizationError as err:
# Testplan stops execution if `ParametrizationError` raises.
# However in our test the process will not quit but continue
# to run the next testcase, and module will not be reloaded.
# So, it is better reset globals before raising this error.
_reset_globals()
raise err
# Register generated functions as testcases
for func in functions:
_validate_testcase(func)
# this has to be called before wrappers otherwise wrappers can
# fail if they rely on __testcase__
_mark_function_as_testcase(func)
wrappers = custom_wrappers or []
if not isinstance(wrappers, (list, tuple)):
wrappers = [wrappers]
for wrapper_func in wrappers:
func = wrapper_func(func)
# so that CodeDetails gets the correct line number
func.wrapper_of = function
func.__seq_number__ = _number_of_testcases()
__GENERATED_TESTCASES__.append(func)
return function
else:
function.summarize = summarize
function.summarize_num_passing = num_passing
function.summarize_num_failing = num_failing
function.summarize_key_combs_limit = key_combs_limit
function.execution_group = execution_group
function.timeout = timeout
function.__tags_index__ = copy.deepcopy(tag_dict)
return _testcase(function)
def generate_functions(
function,
parameters,
name_func,
tags,
tag_func,
docstring_func,
summarize,
num_passing,
num_failing,
):
"""
Generate test cases using the given parameter context, use the name_func
to generate the name.
If parameters is of type ``tuple`` / ``list`` then a new testcase method
will be created for each item.
If parameters is of type ``dict`` (of ``tuple``/``list``), then a new
method will be created for each item in the Cartesian product of all
combinations of values.
:param function: A testcase method, with extra
arguments for parametrization.
:type function: ``callable``
:param parameters: Parametrization context for the test case method.
:type parameters: ``list`` or ``tuple`` of ``dict`` or ``tuple`` / ``list``
OR a ``dict`` of ``tuple`` / ``list``.
:param name_func: Function that will generate method names,
should accept ``func_name`` and ``kwargs`` as parameters.
:type name_func: ``callable``
:param docstring_func: Function that will generate docstring,
should accept ``docstring`` and ``kwargs`` as parameters.
:type docstring_func: ``callable``
:param tag_func: Function that will be used for generating tags via
parametrization kwargs. Should accept ``kwargs`` as
parameter.
:type tag_func: ``callable``
:param tags: Tag annotations to be used for each generated testcase.
:type tag_func: ``dict`` of ``frozenset``
:param summarize: Flag for enabling testcase level
summarization of all assertions.
:type summarize: ``bool``
:param num_passing: Max number of passing assertions
for testcase level assertion summary.
:type num_passing: ``int``
:param num_failing: Max number of failing assertions
for testcase level assertion summary.
:type num_failing: ``int``
:return: List of functions that is testcase compliant
(accepts ``self``, ``env``, ``result`` as arguments) and have
unique names.
:rtype: ``list``
"""
if not parameters:
raise ParametrizationError('"parameters" cannot be a empty.')
_check_name_func(name_func)
argspec = inspect.getargspec(function)
args = argspec.args[3:] # get rid of self, env, result
defaults = (argspec.defaults or [])
required_args = args[:-len(defaults)] if defaults else args
default_args = dict(zip(args[len(required_args):], defaults))
# Need to validate beforehand so we can merge with parametrized_tags
tags = tagging.validate_tag_value(tags) if tags else {}
kwarg_list = _generate_kwarg_list(parameters, args, required_args,
default_args)
functions = [
_generate_func(function=function,
name_func=name_func,
tag_func=tag_func,
docstring_func=docstring_func,
tags=tags,
kwargs=kwargs) for kwargs in kwarg_list
]
for func in functions:
func.summarize = summarize
func.summarize_num_passing = num_passing
func.summarize_num_failing = num_failing
_ensure_unique_names(functions)
return functions
