def _has_both_parameters_and_variants(self):
if not self.test_parameters:
return False
for variant in self.variants.itertests():
var = variant.get("variant")
if not is_empty_variant(var):
return True
return False
def _create_params(runnable):
"""Create params for the test"""
if runnable.variant is None:
return None
# rebuild the variant tree
variant_tree_nodes = [TreeNodeEnvOnly(path, env) for path, env
in runnable.variant['variant']]
if not is_empty_variant(variant_tree_nodes):
tree_nodes = variant_tree_nodes
paths = runnable.variant['paths']
return tree_nodes, paths
def _template_to_factory(test_parameters, template, variant):
"""
Applies test params from variant to the test template
:param test_parameters: a simpler set of parameters (currently
given to the run command via "-p" parameters)
:param template: a test template, containing the class name,
followed by parameters to the class
:type template: tuple
:param variant: variant to be applied, usually containing
the keys: paths, variant and variant_id
:type variant: dict
:return: tuple(new_test_factory, applied_variant)
"""
var = variant.get("variant")
paths = variant.get("paths")
empty_variants = varianter.is_empty_variant(var)
original_params_to_klass = template[1]
if "params" not in original_params_to_klass:
params_to_klass = original_params_to_klass.copy()
if test_parameters and empty_variants:
var[0] = tree.TreeNode().get_node("/", True)
var[0].value = test_parameters
paths = ["/"]
params_to_klass["params"] = (var, paths)
factory = [template[0], params_to_klass]
return factory, variant
if not empty_variants:
raise NotImplementedError(
"Specifying test params from test loader "
"and from varianter at the same time is "
"not yet supported. Please remove either "
"variants defined by the varianter (%s) "
"or make the test loader of test %s to "
"not to fill variants." % (variant, template))
return template, {
"variant": var,
"variant_id": varianter.generate_variant_id(var),
"paths": paths
}
