def _validate_testcase(func): refsig = method(func.__name__, ['env', 'result']) actualsig = MethodSignature(func.__name__, getargspec(func), lambda x: x) if refsig != actualsig: raise MethodSignatureMismatch('Expected {0}, not {1}'.format( refsig, actualsig))
def _wrapper(): case_result = self.cfg.result( stdout_style=self.stdout_style, _scratch=self.scratch, ) testcase_report = TestCaseReport( name='{} - {}'.format(label, func.__name__), description=func.__doc__, ) num_args = len(callable_utils.getargspec(func).args) args = (self.resources,) if num_args == 1 else ( self.resources, case_result) with testcase_report.timer.record('run'): with testcase_report.logged_exceptions(): func(*args) testcase_report.extend(case_result.serialized_entries) if self.get_stdout_style(testcase_report.passed).display_case: self.log_testcase_status(testcase_report) self.pre_post_step_report.append(testcase_report)
def _wrapper(): case_result = self.cfg.result(stdout_style=self.stdout_style, _scratch=self.scratch) testcase_report = testplan.report.TestCaseReport( name="{} - {}".format(label, func.__name__), description=strings.get_docstring(func), ) num_args = len(callable_utils.getargspec(func).args) args = ((self.resources, ) if num_args == 1 else (self.resources, case_result)) with testcase_report.timer.record("run"): with testcase_report.logged_exceptions(): func(*args) testcase_report.extend(case_result.serialized_entries) testcase_report.attachments.extend(case_result.attachments) if self.get_stdout_style(testcase_report.passed).display_testcase: self.log_testcase_status(testcase_report) testcase_report.pass_if_empty() self.pre_post_step_report.append(testcase_report)
def _validate_skip_if_predicates(predicates): """ Check for method signature, set / extend ``skip_funcs`` attribute of the testcase method. """ for predicate in predicates: refsig = static_method(predicate.__name__, ['suite']) actualsig = MethodSignature( predicate.__name__, getargspec(predicate), lambda x: x) if refsig != actualsig: raise MethodSignatureMismatch('Expected {0}, not {1}'.format( refsig, actualsig)) return predicates
def _check_tag_func(tag_func): """Make sure ``tag_func`` is a callable that takes ``kwargs`` arguments""" if tag_func is None: return if not callable(tag_func): raise ParametrizationError("tag_func must be a callable.") argspec = callable_utils.getargspec(tag_func) if len(argspec.args) == 1: arg_1 = argspec.args[0] if arg_1 == "kwargs": return raise ParametrizationError( 'tag_func must be a callable that takes 1 argument named "kwargs".' " (e.g. def custom_tag_func(kwargs): ...")
def _check_name_func(name_func): """ Make sure ``name_func`` is a callable that takes ``func_name``, ``kwargs`` arguments. """ if not callable(name_func): raise ParametrizationError("name_func must be a callable.") argspec = callable_utils.getargspec(name_func) if len(argspec.args) == 2: arg_1, arg_2 = argspec.args if arg_1 == "func_name" and arg_2 == "kwargs": return raise ParametrizationError( "name_func must be a callable that takes 2 arguments " 'named "func_name" and "kwargs".' " (e.g. def custom_name_func(func_name, kwargs): ...")
def generate_functions( function, parameters, name, name_func, tag_dict, tag_func, docstring_func, summarize, num_passing, num_failing, key_combs_limit, execution_group, timeout, ): """ 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: Customized readable name for testcase. :type name: ``str`` :param name_func: Function for generating names of parametrized testcases, 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 tag_dict: Tag annotations to be used for each generated testcase. :type tag_dict: ``dict`` of ``set`` :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`` :param key_combs_limit: Max number of failed key combinations on fix/dict summaries that contain assertion details. :type key_combs_limit: ``int`` :param execution_group: Name of execution group in which the testcases can be executed in parallel. :type execution_group: ``str`` :param timeout: Timeout in seconds to wait for testcase to be finished. :type timeout: ``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 = callable_utils.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)) kwarg_list = _generate_kwarg_list(parameters, args, required_args, default_args) functions = [ _generate_func( function=function, name=name, name_func=name_func, tag_func=tag_func, docstring_func=docstring_func, tag_dict=tag_dict, 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 func.summarize_key_combs_limit = key_combs_limit func.execution_group = execution_group func.timeout = timeout return functions