def discover(self, reference, which_tests=loader.DiscoverMode.DEFAULT):
tests = []
try:
root = mux.apply_filters(create_from_yaml([reference], False),
getattr(self.args, "mux_suite_only", []),
getattr(self.args, "mux_suite_out", []))
except Exception:
return []
mux_tree = mux.MuxTree(root)
for variant in mux_tree:
params = parameters.AvocadoParams(variant, ["/run/*"],
output.LOG_JOB.name)
references = params.get("test_reference")
if not isinstance(references, (list, tuple)):
references = [references]
for reference in references:
test_loader = self._get_loader(params)
if not test_loader:
continue
_tests = test_loader.discover(reference, which_tests)
self._extra_type_label_mapping.update(
test_loader.get_full_type_label_mapping())
self._extra_decorator_mapping.update(
test_loader.get_full_decorator_mapping())
name_prefix = params.get("mux_suite_test_name_prefix")
if _tests:
if isinstance(name_prefix, list):
name_prefix = "".join(name_prefix)
for tst in _tests:
if name_prefix:
tst[1]["name"] = name_prefix + tst[1]["name"]
tst[1]["params"] = (variant, ["/run/*"])
tests.extend(_tests)
return tests
def discover(self, reference, which_tests=loader.DEFAULT):
tests = []
try:
root = mux.apply_filters(create_from_yaml([reference], False),
getattr(self.args, "mux_suite_only", []),
getattr(self.args, "mux_suite_out", []))
except Exception:
return []
mux_tree = mux.MuxTree(root)
for variant in mux_tree:
params = varianter.AvocadoParams(variant, "YamlTestsuiteLoader",
["/run/*"], {})
reference = params.get("test_reference")
test_loader = self._get_loader(params)
if not test_loader:
continue
_tests = test_loader.discover(reference, which_tests)
self._extra_type_label_mapping.update(
test_loader.get_full_type_label_mapping())
self._extra_decorator_mapping.update(
test_loader.get_full_decorator_mapping())
if _tests:
for tst in _tests:
tst[1]["params"] = (variant, ["/run/*"])
tests.extend(_tests)
return tests
def test_multiple_loaders(self):
"""
Verifies that `create_from_yaml` does not affects the main yaml.Loader
"""
yaml_path = os.path.join(BASEDIR, 'tests/.data/mux-selftest.yaml')
yaml_url = '/:%s' % yaml_path
nondebug = yaml_to_mux.create_from_yaml([yaml_url])
self.assertEqual(type(nondebug), mux.MuxTreeNode)
self.assertEqual(type(nondebug.children[0]), mux.MuxTreeNode)
debug = yaml_to_mux.create_from_yaml([yaml_url], debug=True)
self.assertEqual(type(debug), mux.MuxTreeNodeDebug)
# Debug nodes are of generated "NamedTreeNodeDebug" type
self.assertEqual("<class 'avocado_varianter_yaml_to_mux.NamedTreeNodeDebug'>",
str(type(debug.children[0])))
plain = yaml.load("foo: bar")
self.assertEqual(type(plain), dict)
def discover(self, reference, which_tests=loader.DEFAULT):
tests = []
try:
root = mux.apply_filters(create_from_yaml([reference], False),
getattr(self.args, "mux_suite_only", []),
getattr(self.args, "mux_suite_out", []))
except Exception:
return []
mux_tree = mux.MuxTree(root)
for variant in mux_tree:
params = parameters.AvocadoParams(variant, ["/run/*"],
output.LOG_JOB.name)
reference = params.get("test_reference")
test_loader = self._get_loader(params)
if not test_loader:
continue
_tests = test_loader.discover(reference, which_tests)
self._extra_type_label_mapping.update(
test_loader.get_full_type_label_mapping())
self._extra_decorator_mapping.update(
test_loader.get_full_decorator_mapping())
if _tests:
for tst in _tests:
tst[1]["params"] = (variant, ["/run/*"])
tests.extend(_tests)
return tests
def test_filter_only(self):
exp = (['intel', 'scsi'], ['intel', 'virtio'])
act = yaml_to_mux.create_from_yaml(
["/:" + PATH_PREFIX + 'examples/mux-selftest.yaml'])
act = mux.apply_filters(act,
('/hw/cpu/intel', '/distro/fedora', '/hw'))
act = tuple(mux.MuxTree(act))
self.assertEqual(act, exp)
def test_filter_only(self):
exp = (['intel', 'scsi'], ['intel', 'virtio'])
act = yaml_to_mux.create_from_yaml(["/:" + PATH_PREFIX +
'selftests/.data/mux-selftest.yaml'])
act = mux.apply_filters(act, ('/hw/cpu/intel', '/distro/fedora',
'/hw'))
act = tuple(mux.MuxTree(act))
self.assertEqual(act, exp)
def test_multiple_loaders(self):
"""
Verifies that `create_from_yaml` does not affects the main yaml.Loader
"""
yaml_path = os.path.join(BASEDIR, 'tests/.data/mux-selftest.yaml')
yaml_url = '/:%s' % yaml_path
nondebug = yaml_to_mux.create_from_yaml([yaml_url])
self.assertEqual(type(nondebug), mux.MuxTreeNode)
self.assertEqual(type(nondebug.children[0]), mux.MuxTreeNode)
debug = yaml_to_mux.create_from_yaml([yaml_url], debug=True)
self.assertEqual(type(debug), mux.MuxTreeNodeDebug)
# Debug nodes are of generated "NamedTreeNodeDebug" type
self.assertEqual(
"<class 'avocado_varianter_yaml_to_mux.NamedTreeNodeDebug'>",
str(type(debug.children[0])))
plain = yaml.load("foo: bar")
self.assertEqual(type(plain), dict)
def test_multiple_loaders(self):
"""
Verifies that `create_from_yaml` does not affects the main yaml.Loader
"""
nondebug = yaml_to_mux.create_from_yaml(
['/:' + PATH_PREFIX + 'examples/mux-selftest.'
'yaml'])
self.assertEqual(type(nondebug), mux.MuxTreeNode)
self.assertEqual(type(nondebug.children[0]), mux.MuxTreeNode)
debug = yaml_to_mux.create_from_yaml(
['/:' + PATH_PREFIX + 'examples/mux-selftest.'
'yaml'], debug=True)
self.assertEqual(type(debug), mux.MuxTreeNodeDebug)
# Debug nodes are of generated "NamedTreeNodeDebug" type
self.assertEqual("<class 'avocado.core.tree.NamedTreeNodeDebug'>",
str(type(debug.children[0])))
plain = yaml.load("foo: bar")
self.assertEqual(type(plain), dict)
def test_filter_only(self):
exp = (['intel', 'scsi'], ['intel', 'virtio'])
tree_yaml_path = os.path.join(BASEDIR, 'tests/.data/mux-selftest.yaml')
tree_yaml_url = '/:%s' % tree_yaml_path
act = yaml_to_mux.create_from_yaml([tree_yaml_url])
act = mux.apply_filters(act, ('/hw/cpu/intel', '/distro/fedora',
'/hw'))
act = tuple(mux.MuxTree(act))
self.assertEqual(act, exp)
def test_filter_only(self):
exp = (['intel', 'scsi'], ['intel', 'virtio'])
tree_yaml_path = os.path.join(BASEDIR, 'tests/.data/mux-selftest.yaml')
tree_yaml_url = '/:%s' % tree_yaml_path
act = yaml_to_mux.create_from_yaml([tree_yaml_url])
act = mux.apply_filters(act,
('/hw/cpu/intel', '/distro/fedora', '/hw'))
act = tuple(mux.MuxTree(act))
self.assertEqual(act, exp)
def test_multiple_loaders(self):
"""
Verifies that `create_from_yaml` does not affects the main yaml.Loader
"""
nondebug = yaml_to_mux.create_from_yaml(['/:' + PATH_PREFIX +
'selftests/.data/mux-selftest.'
'yaml'])
self.assertEqual(type(nondebug), mux.MuxTreeNode)
self.assertEqual(type(nondebug.children[0]), mux.MuxTreeNode)
debug = yaml_to_mux.create_from_yaml(['/:' + PATH_PREFIX +
'selftests/.data/mux-selftest.'
'yaml'],
debug=True)
self.assertEqual(type(debug), mux.MuxTreeNodeDebug)
# Debug nodes are of generated "NamedTreeNodeDebug" type
self.assertEqual("<class 'avocado.core.tree.NamedTreeNodeDebug'>",
str(type(debug.children[0])))
plain = yaml.load("foo: bar")
self.assertEqual(type(plain), dict)
def setUp(self):
yamls = yaml_to_mux.create_from_yaml(["/:" + PATH_PREFIX +
'selftests/.data/mux-selftest-params.yaml'])
self.yamls = iter(mux.MuxTree(yamls))
self.params1 = varianter.AvocadoParams(self.yamls.next(), 'Unittest1',
['/ch0/*', '/ch1/*'], {})
self.yamls.next() # Skip 2nd
self.yamls.next() # and 3rd
self.params2 = varianter.AvocadoParams(self.yamls.next(), 'Unittest2',
['/ch1/*', '/ch0/*'], {})
def setUp(self):
yamls = yaml_to_mux.create_from_yaml(
["/:" + PATH_PREFIX + 'examples/mux-selftest-params.yaml'])
self.yamls = iter(mux.MuxTree(yamls))
self.params1 = varianter.AvocadoParams(self.yamls.next(), 'Unittest1',
['/ch0/*', '/ch1/*'], {})
self.yamls.next() # Skip 2nd
self.yamls.next() # and 3rd
self.params2 = varianter.AvocadoParams(self.yamls.next(), 'Unittest2',
['/ch1/*', '/ch0/*'], {})
def setUp(self):
yamls = yaml_to_mux.create_from_yaml(
["/:" + PATH_PREFIX + 'selftests/.data/mux-selftest-params.yaml'])
self.yamls = iter(mux.MuxTree(yamls))
self.params1 = parameters.AvocadoParams(next(self.yamls), 'Unittest1',
['/ch0/*', '/ch1/*'])
next(self.yamls) # Skip 2nd
next(self.yamls) # and 3rd
self.params2 = parameters.AvocadoParams(next(self.yamls), 'Unittest2',
['/ch1/*', '/ch0/*'])
def setUp(self):
yaml_path = os.path.join(BASEDIR, 'tests/.data/mux-selftest-params.yaml')
yaml_url = '/:%s' % yaml_path
yamls = yaml_to_mux.create_from_yaml([yaml_url])
self.yamls = iter(mux.MuxTree(yamls))
self.params1 = parameters.AvocadoParams(next(self.yamls),
['/ch0/*', '/ch1/*'])
next(self.yamls) # Skip 2nd
next(self.yamls) # and 3rd
self.params2 = parameters.AvocadoParams(next(self.yamls),
['/ch1/*', '/ch0/*'])
def test_multiple_loaders(self):
"""
Verifies that `create_from_yaml` does not affects the main yaml.Loader
"""
yaml_path = os.path.join(BASEDIR, 'tests/.data/mux-selftest.yaml')
yaml_url = '/:%s' % yaml_path
treenode = yaml_to_mux.create_from_yaml([yaml_url])
self.assertEqual(type(treenode), mux.MuxTreeNode)
self.assertEqual(type(treenode.children[0]), mux.MuxTreeNode)
# equivalent to yaml.load("...", Loader=yaml.SafeLoader)
plain = yaml.safe_load("foo: bar")
self.assertEqual(type(plain), dict)
def test_advanced_yaml(self):
tree2_yaml_path = os.path.join(
BASEDIR, 'tests/.data/mux-selftest-advanced.yaml')
tree2_yaml_url = '/:%s' % tree2_yaml_path
tree2 = yaml_to_mux.create_from_yaml([tree2_yaml_url])
exp = [
'intel', 'amd', 'arm', 'scsi', 'virtio', 'fedora', '6', '7',
'gentoo', u'\u0161mint', 'prod', 'new_node', 'on', 'dict'
]
act = tree2.get_leaves()
oldroot = tree2.children[0]
self.assertEqual(exp, act)
self.assertEqual(tree2.children[0].children[0].path, u"/\u0161virt/hw")
self.assertEqual({'enterprise': True},
oldroot.children[1].children[1].value)
self.assertEqual({'new_init': 'systemd'},
oldroot.children[1].children[0].value)
self.assertEqual({'is_cool': True},
oldroot.children[1].children[2].value)
self.assertEqual({'new_value': u'\u0161omething'},
oldroot.children[3].children[0].children[0].value)
# Convert values, but not keys
self.assertEqual({
'on': True,
"true": "true"
}, oldroot.children[4].value)
# Dicts as values
self.assertEqual(
{
"explicit": {
u"foo\u0161": u"\u0161bar",
"bar": "baz"
},
"in_list": [{
"foo": "bar",
"bar": "baz"
}]
}, oldroot.children[5].value)
# multiplex root (always True)
self.assertEqual(tree2.multiplex, None)
# multiplex /virt/
self.assertEqual(tree2.children[0].multiplex, None)
# multiplex /virt/hw
self.assertEqual(tree2.children[0].children[0].multiplex, None)
# multiplex /virt/distro
self.assertEqual(tree2.children[0].children[1].multiplex, True)
# multiplex /virt/env
self.assertEqual(tree2.children[0].children[2].multiplex, True)
# multiplex /virt/absolutely
self.assertEqual(tree2.children[0].children[3].multiplex, None)
# multiplex /virt/distro/fedora
self.assertEqual(tree2.children[0].children[1].children[0].multiplex,
None)
def test_filter_out(self):
act = yaml_to_mux.create_from_yaml(["/:" + PATH_PREFIX +
'selftests/.data/mux-selftest.yaml'])
act = mux.apply_filters(act, None, ('/hw/cpu/intel', '/distro/fedora',
'/distro'))
act = tuple(mux.MuxTree(act))
self.assertEqual(len(act), 4)
self.assertEqual(len(act[0]), 3)
str_act = str(act)
self.assertIn('amd', str_act)
self.assertIn('prod', str_act)
self.assertNotIn('intel', str_act)
self.assertNotIn('fedora', str_act)
def test_filter_out(self):
act = yaml_to_mux.create_from_yaml(
["/:" + PATH_PREFIX + 'examples/mux-selftest.yaml'])
act = mux.apply_filters(act, None,
('/hw/cpu/intel', '/distro/fedora', '/distro'))
act = tuple(mux.MuxTree(act))
self.assertEqual(len(act), 4)
self.assertEqual(len(act[0]), 3)
str_act = str(act)
self.assertIn('amd', str_act)
self.assertIn('prod', str_act)
self.assertNotIn('intel', str_act)
self.assertNotIn('fedora', str_act)
def test_multiple_loaders(self):
"""
Verifies that `create_from_yaml` does not affects the main yaml.Loader
"""
yaml_path = os.path.join(BASEDIR, 'tests/.data/mux-selftest.yaml')
yaml_url = '/:%s' % yaml_path
nondebug = yaml_to_mux.create_from_yaml([yaml_url])
self.assertEqual(type(nondebug), mux.MuxTreeNode)
self.assertEqual(type(nondebug.children[0]), mux.MuxTreeNode)
debug = yaml_to_mux.create_from_yaml([yaml_url], debug=True)
self.assertEqual(type(debug), mux.MuxTreeNodeDebug)
# Debug nodes are of generated "NamedTreeNodeDebug" type
if sys.version_info[0] == 3:
children_type = (
"<class 'avocado_varianter_yaml_to_mux."
"get_named_tree_cls.<locals>.NamedTreeNodeDebug'>")
else:
children_type = ("<class 'avocado_varianter_yaml_to_mux."
"NamedTreeNodeDebug'>")
self.assertEqual(children_type, str(type(debug.children[0])))
plain = yaml.load("foo: bar", Loader=yaml.SafeLoader)
self.assertEqual(type(plain), dict)
def test_filter_out(self):
tree_yaml_path = os.path.join(BASEDIR, 'tests/.data/mux-selftest.yaml')
tree_yaml_url = '/:%s' % tree_yaml_path
act = yaml_to_mux.create_from_yaml([tree_yaml_url])
act = mux.apply_filters(act, None, ('/hw/cpu/intel', '/distro/fedora',
'/distro'))
act = tuple(mux.MuxTree(act))
self.assertEqual(len(act), 4)
self.assertEqual(len(act[0]), 3)
str_act = str(act)
self.assertIn('amd', str_act)
self.assertIn('prod', str_act)
self.assertNotIn('intel', str_act)
self.assertNotIn('fedora', str_act)
def test_filter_out(self):
tree_yaml_path = os.path.join(BASEDIR, 'tests/.data/mux-selftest.yaml')
tree_yaml_url = '/:%s' % tree_yaml_path
act = yaml_to_mux.create_from_yaml([tree_yaml_url])
act = mux.apply_filters(act, None,
('/hw/cpu/intel', '/distro/fedora', '/distro'))
act = tuple(mux.MuxTree(act))
self.assertEqual(len(act), 4)
self.assertEqual(len(act[0]), 3)
str_act = str(act)
self.assertIn('amd', str_act)
self.assertIn('prod', str_act)
self.assertNotIn('intel', str_act)
self.assertNotIn('fedora', str_act)
def test_advanced_yaml(self):
tree2_yaml_path = os.path.join(BASEDIR,
'tests/.data/mux-selftest-advanced.yaml')
tree2_yaml_url = '/:%s' % tree2_yaml_path
tree2 = yaml_to_mux.create_from_yaml([tree2_yaml_url])
exp = ['intel', 'amd', 'arm', 'scsi', 'virtio', 'fedora', '6',
'7', 'gentoo', 'mint', 'prod', 'new_node', 'on', 'dict']
act = tree2.get_leaves()
oldroot = tree2.children[0]
self.assertEqual(exp, act)
self.assertEqual(tree2.children[0].children[0].path, "/virt/hw")
self.assertEqual({'enterprise': True},
oldroot.children[1].children[1].value)
self.assertEqual({'new_init': 'systemd'},
oldroot.children[1].children[0].value)
self.assertEqual({'is_cool': True},
oldroot.children[1].children[2].value)
self.assertEqual({'new_value': 'something'},
oldroot.children[3].children[0].children[0].value)
# Convert values, but not keys
self.assertEqual({'on': True, "true": "true"},
oldroot.children[4].value)
# Dicts as values
self.assertEqual({"explicit": {"foo": "bar", "bar": "baz"},
"in_list": [{"foo": "bar", "bar": "baz"}]},
oldroot.children[5].value)
# multiplex root (always True)
self.assertEqual(tree2.multiplex, None)
# multiplex /virt/
self.assertEqual(tree2.children[0].multiplex, None)
# multiplex /virt/hw
self.assertEqual(tree2.children[0].children[0].multiplex, None)
# multiplex /virt/distro
self.assertEqual(tree2.children[0].children[1].multiplex, True)
# multiplex /virt/env
self.assertEqual(tree2.children[0].children[2].multiplex, True)
# multiplex /virt/absolutely
self.assertEqual(tree2.children[0].children[3].multiplex, None)
# multiplex /virt/distro/fedora
self.assertEqual(tree2.children[0].children[1].children[0].multiplex,
None)
def test_advanced_yaml(self):
tree2 = yaml_to_mux.create_from_yaml(
['/:' + PATH_PREFIX + 'examples/mux-selftest-advanced.'
'yaml'])
exp = [
'intel', 'amd', 'arm', 'scsi', 'virtio', 'fedora', '6', '7',
'gentoo', 'mint', 'prod', 'new_node', 'on'
]
act = tree2.get_leaves()
oldroot = tree2.children[0]
self.assertEqual(exp, act)
self.assertEqual(tree2.children[0].children[0].path, "/virt/hw")
self.assertEqual({'enterprise': True},
oldroot.children[1].children[1].value)
self.assertEqual({'new_init': 'systemd'},
oldroot.children[1].children[0].value)
self.assertEqual({'is_cool': True},
oldroot.children[1].children[2].value)
self.assertEqual({'new_value': 'something'},
oldroot.children[3].children[0].children[0].value)
# Convert values, but not keys
self.assertEqual({
'on': True,
"true": "true"
}, oldroot.children[4].value)
# multiplex root (always True)
self.assertEqual(tree2.multiplex, None)
# multiplex /virt/
self.assertEqual(tree2.children[0].multiplex, None)
# multiplex /virt/hw
self.assertEqual(tree2.children[0].children[0].multiplex, None)
# multiplex /virt/distro
self.assertEqual(tree2.children[0].children[1].multiplex, True)
# multiplex /virt/env
self.assertEqual(tree2.children[0].children[2].multiplex, True)
# multiplex /virt/absolutely
self.assertEqual(tree2.children[0].children[3].multiplex, None)
# multiplex /virt/distro/fedora
self.assertEqual(tree2.children[0].children[1].children[0].multiplex,
None)
def test_advanced_yaml(self):
tree2 = yaml_to_mux.create_from_yaml(['/:' + PATH_PREFIX +
'selftests/.data/mux-selftest-advanced.'
'yaml'])
exp = ['intel', 'amd', 'arm', 'scsi', 'virtio', 'fedora', '6',
'7', 'gentoo', 'mint', 'prod', 'new_node', 'on']
act = tree2.get_leaves()
oldroot = tree2.children[0]
self.assertEqual(exp, act)
self.assertEqual(tree2.children[0].children[0].path, "/virt/hw")
self.assertEqual({'enterprise': True},
oldroot.children[1].children[1].value)
self.assertEqual({'new_init': 'systemd'},
oldroot.children[1].children[0].value)
self.assertEqual({'is_cool': True},
oldroot.children[1].children[2].value)
self.assertEqual({'new_value': 'something'},
oldroot.children[3].children[0].children[0].value)
# Convert values, but not keys
self.assertEqual({'on': True, "true": "true"},
oldroot.children[4].value)
# multiplex root (always True)
self.assertEqual(tree2.multiplex, None)
# multiplex /virt/
self.assertEqual(tree2.children[0].multiplex, None)
# multiplex /virt/hw
self.assertEqual(tree2.children[0].children[0].multiplex, None)
# multiplex /virt/distro
self.assertEqual(tree2.children[0].children[1].multiplex, True)
# multiplex /virt/env
self.assertEqual(tree2.children[0].children[2].multiplex, True)
# multiplex /virt/absolutely
self.assertEqual(tree2.children[0].children[3].multiplex, None)
# multiplex /virt/distro/fedora
self.assertEqual(tree2.children[0].children[1].children[0].multiplex,
None)
def setUp(self):
tree_yaml_path = os.path.join(BASEDIR, 'tests/.data/mux-selftest.yaml')
tree_yaml_url = '/:%s' % tree_yaml_path
self.mux_tree = yaml_to_mux.create_from_yaml([tree_yaml_url])
self.mux_full = tuple(mux.MuxTree(self.mux_tree))
class TestMuxTree(unittest.TestCase):
# Share tree with all tests
tree_yaml_path = os.path.join(BASEDIR, 'tests/.data/mux-selftest.yaml')
tree_yaml_url = '/:%s' % tree_yaml_path
tree = yaml_to_mux.create_from_yaml([tree_yaml_url])
def test_node_order(self):
self.assertIsInstance(self.tree, mux.MuxTreeNode)
self.assertEqual('hw', self.tree.children[0])
self.assertEqual({'cpu_CFLAGS': '-march=core2'},
self.tree.children[0].children[0].children[0].value)
disk = self.tree.children[0].children[1]
self.assertEqual('scsi', disk.children[0])
self.assertEqual({
'disk_type': 'scsi',
'corruptlist': ['againlist']
}, disk.children[0].value)
self.assertEqual('virtio', disk.children[1])
self.assertEqual({}, disk.children[1].value)
self.assertEqual('distro', self.tree.children[1])
self.assertEqual('env', self.tree.children[2])
self.assertEqual({'opt_CFLAGS': '-O2'},
self.tree.children[2].children[0].value)
def test_eq(self):
# Copy
tree2 = copy.deepcopy(self.tree)
self.assertEqual(self.tree, tree2)
# Additional node
child = mux.MuxTreeNode("20", {'name': 'Heisenbug'})
tree2.children[1].children[1].add_child(child)
self.assertNotEqual(self.tree, tree2)
# Should match again
child.detach()
self.assertEqual(self.tree, tree2)
# Missing node
tree2.children[1].children[1].detach()
self.assertNotEqual(self.tree, tree2)
self.assertEqual(self.tree.children[0], tree2.children[0])
# Different value
tree2.children[0].children[0].children[0].value = {'something': 'else'}
self.assertNotEqual(self.tree.children[0], tree2.children[0])
tree3 = mux.MuxTreeNode()
self.assertNotEqual(tree3, tree2)
# Merge
tree3.merge(tree2)
self.assertEqual(tree3, tree2)
# Add_child existing
tree3.add_child(tree2.children[0])
self.assertEqual(tree3, tree2)
def test_links(self):
""" Verify child->parent links """
for leaf in self.tree:
self.assertEqual(leaf.root, self.tree)
def test_basic_functions(self):
# repr
self.assertEqual("MuxTreeNode(name='hw')", repr(self.tree.children[0]))
# str
self.assertEqual(u"/distro/\u0161mint: init=systemv",
astring.to_text(self.tree.children[1].children[1]))
# len
self.assertEqual(8, len(self.tree)) # number of leaves
# __iter__
self.assertEqual(8, sum((1 for _ in self.tree))) # number of leaves
# .root
self.assertEqual(
id(self.tree),
id(self.tree.children[0].children[0].children[0].root))
# .parents
self.assertEqual(['hw', ''], self.tree.children[0].children[0].parents)
# environment / (root)
self.assertEqual({}, self.tree.environment)
# environment /hw (nodes first)
self.assertEqual({'corruptlist': ['upper_node_list']},
self.tree.children[0].environment)
cpu = self.tree.children[0].children[0]
# environment /hw/cpu (mixed env)
self.assertEqual(
{
'corruptlist': ['upper_node_list'],
'joinlist': ['first_item']
}, cpu.environment)
# environment /hw/cpu/amd (list extension)
vals = {
'corruptlist': ['upper_node_list'],
'cpu_CFLAGS': '-march=athlon64',
'joinlist': ['first_item', 'second', 'third']
}
self.assertEqual(vals, cpu.children[1].environment)
# environment /hw/cpu/arm (deep env)
vals = {
'corruptlist': ['upper_node_list'],
'joinlist': ['first_item'],
'cpu_CFLAGS': '-mabi=apcs-gnu '
'-march=armv8-a -mtune=arm8'
}
self.assertEqual(vals, cpu.children[2].environment)
# environment /hw/disk (list -> string)
vals = {'corruptlist': 'nonlist', 'disk_type': 'virtio'}
disk = self.tree.children[0].children[1]
self.assertEqual(vals, disk.environment)
# environment /hw/disk/scsi (string -> list)
vals = {'corruptlist': ['againlist'], 'disk_type': 'scsi'}
self.assertEqual(vals, disk.children[0].environment)
# environment /env
vals = {'opt_CFLAGS': '-Os'}
self.assertEqual(vals, self.tree.children[2].environment)
# leaves order
leaves = [
'intel', 'amd', 'arm', 'scsi', 'virtio', 'fedora', u'\u0161mint',
'prod'
]
self.assertEqual(leaves, self.tree.get_leaves())
tree_view = tree.tree_view(self.tree, 0, False)
# ascii treeview contains only ascii chars
tree_view.decode('ascii')
# ascii treeview contain all leaves
for leaf in leaves:
# In ascii mode we replace non-ascii character using
# xmlcharrefreplace, make sure this is performed
leaf = leaf.encode('ascii', errors='xmlcharrefreplace')
self.assertIn(leaf, tree_view,
"Leaf %s not in ascii:\n%s" % (leaf, tree_view))
def test_filters(self):
tree2 = copy.deepcopy(self.tree)
exp = ['intel', 'amd', 'arm', 'fedora', u'\u0161mint', 'prod']
act = mux.apply_filters(tree2, filter_only=['/hw/cpu',
'']).get_leaves()
self.assertEqual(exp, act)
tree2 = copy.deepcopy(self.tree)
exp = ['scsi', 'virtio', 'fedora', u'\u0161mint', 'prod']
act = mux.apply_filters(tree2, filter_out=['/hw/cpu', '']).get_leaves()
self.assertEqual(exp, act)
def test_merge_trees(self):
tree2 = copy.deepcopy(self.tree)
tree3 = mux.MuxTreeNode()
tree3.add_child(mux.MuxTreeNode('hw', {'another_value': 'bbb'}))
tree3.children[0].add_child(mux.MuxTreeNode('nic'))
tree3.children[0].children[0].add_child(mux.MuxTreeNode('default'))
tree3.children[0].children[0].add_child(
mux.MuxTreeNode('virtio', {'nic': 'virtio'}))
tree3.children[0].add_child(
mux.MuxTreeNode('cpu', {'test_value': ['z']}))
tree2.merge(tree3)
exp = [
'intel', 'amd', 'arm', 'scsi', 'virtio', 'default', 'virtio',
'fedora', u'\u0161mint', 'prod'
]
self.assertEqual(exp, tree2.get_leaves())
self.assertEqual(
{
'corruptlist': ['upper_node_list'],
'another_value': 'bbb'
}, tree2.children[0].value)
self.assertEqual({
'joinlist': ['first_item'],
'test_value': ['z']
}, tree2.children[0].children[0].value)
self.assertFalse(tree2.children[0].children[2].children[0].value)
self.assertEqual({'nic': 'virtio'},
tree2.children[0].children[2].children[1].value)
def test_advanced_yaml(self):
tree2_yaml_path = os.path.join(
BASEDIR, 'tests/.data/mux-selftest-advanced.yaml')
tree2_yaml_url = '/:%s' % tree2_yaml_path
tree2 = yaml_to_mux.create_from_yaml([tree2_yaml_url])
exp = [
'intel', 'amd', 'arm', 'scsi', 'virtio', 'fedora', '6', '7',
'gentoo', u'\u0161mint', 'prod', 'new_node', 'on', 'dict'
]
act = tree2.get_leaves()
oldroot = tree2.children[0]
self.assertEqual(exp, act)
self.assertEqual(tree2.children[0].children[0].path, u"/\u0161virt/hw")
self.assertEqual({'enterprise': True},
oldroot.children[1].children[1].value)
self.assertEqual({'new_init': 'systemd'},
oldroot.children[1].children[0].value)
self.assertEqual({'is_cool': True},
oldroot.children[1].children[2].value)
self.assertEqual({'new_value': u'\u0161omething'},
oldroot.children[3].children[0].children[0].value)
# Convert values, but not keys
self.assertEqual({
'on': True,
"true": "true"
}, oldroot.children[4].value)
# Dicts as values
self.assertEqual(
{
"explicit": {
u"foo\u0161": u"\u0161bar",
"bar": "baz"
},
"in_list": [{
"foo": "bar",
"bar": "baz"
}]
}, oldroot.children[5].value)
# multiplex root (always True)
self.assertEqual(tree2.multiplex, None)
# multiplex /virt/
self.assertEqual(tree2.children[0].multiplex, None)
# multiplex /virt/hw
self.assertEqual(tree2.children[0].children[0].multiplex, None)
# multiplex /virt/distro
self.assertEqual(tree2.children[0].children[1].multiplex, True)
# multiplex /virt/env
self.assertEqual(tree2.children[0].children[2].multiplex, True)
# multiplex /virt/absolutely
self.assertEqual(tree2.children[0].children[3].multiplex, None)
# multiplex /virt/distro/fedora
self.assertEqual(tree2.children[0].children[1].children[0].multiplex,
None)
def test_get_node(self):
self.assertRaises(ValueError, self.tree.get_node, '/non-existing-node')
def test_fingerprint_order(self):
"""
Checks whether different order changes the fingerprint
"""
children1 = (tree.TreeNode("child1"), tree.TreeNode("child2"))
tree1 = tree.TreeNode("root", children=children1)
children2 = (tree.TreeNode("child2"), tree.TreeNode("child1"))
tree2 = tree.TreeNode("root", children=children2)
mux1 = mux.MuxPlugin()
mux2 = mux.MuxPlugin()
mux1.initialize_mux(tree1, "")
mux2.initialize_mux(tree2, "")
variant1 = next(iter(mux1))
variant2 = next(iter(mux2))
self.assertNotEqual(variant1, variant2)
# test variant __str__()
str(variant1)
variant_list = []
for item in variant1:
variant_list.append("'%s': '%s'" % (item, variant1[item]))
expected_items = [
"'paths': ''", "'variant': '[TreeNode(name='child1'), "
"TreeNode(name='child2')]'", "'variant_id': 'child1-child2-f47e'"
]
for item in expected_items:
self.assertIn(item, variant_list)
variant_list.remove(item)
self.assertFalse(variant_list)
class TestMuxTree(unittest.TestCase):
# Share tree with all tests
tree = yaml_to_mux.create_from_yaml(
['/:' + PATH_PREFIX + 'examples/mux-selftest.yaml'])
def test_node_order(self):
self.assertIsInstance(self.tree, mux.MuxTreeNode)
self.assertEqual('hw', self.tree.children[0])
self.assertEqual({'cpu_CFLAGS': '-march=core2'},
self.tree.children[0].children[0].children[0].value)
disk = self.tree.children[0].children[1]
self.assertEqual('scsi', disk.children[0])
self.assertEqual({
'disk_type': 'scsi',
'corruptlist': ['againlist']
}, disk.children[0].value)
self.assertEqual('virtio', disk.children[1])
self.assertEqual({}, disk.children[1].value)
self.assertEqual('distro', self.tree.children[1])
self.assertEqual('env', self.tree.children[2])
self.assertEqual({'opt_CFLAGS': '-O2'},
self.tree.children[2].children[0].value)
def test_eq(self):
# Copy
tree2 = copy.deepcopy(self.tree)
self.assertEqual(self.tree, tree2)
# Additional node
child = mux.MuxTreeNode("20", {'name': 'Heisenbug'})
tree2.children[1].children[1].add_child(child)
self.assertNotEqual(self.tree, tree2)
# Should match again
child.detach()
self.assertEqual(self.tree, tree2)
# Missing node
tree2.children[1].children[1].detach()
self.assertNotEqual(self.tree, tree2)
self.assertEqual(self.tree.children[0], tree2.children[0])
# Different value
tree2.children[0].children[0].children[0].value = {'something': 'else'}
self.assertNotEqual(self.tree.children[0], tree2.children[0])
tree3 = mux.MuxTreeNode()
self.assertNotEqual(tree3, tree2)
# Merge
tree3.merge(tree2)
self.assertEqual(tree3, tree2)
# Add_child existing
tree3.add_child(tree2.children[0])
self.assertEqual(tree3, tree2)
def test_links(self):
""" Verify child->parent links """
for leaf in self.tree:
self.assertEqual(leaf.root, self.tree)
def test_basic_functions(self):
# repr
self.assertEqual("MuxTreeNode(name='hw')", repr(self.tree.children[0]))
# str
self.assertEqual("/distro/mint: init=systemv",
str(self.tree.children[1].children[1]))
# len
self.assertEqual(8, len(self.tree)) # number of leaves
# __iter__
self.assertEqual(8, sum((1 for _ in self.tree))) # number of leaves
# .root
self.assertEqual(
id(self.tree),
id(self.tree.children[0].children[0].children[0].root))
# .parents
self.assertEqual(['hw', ''], self.tree.children[0].children[0].parents)
# environment / (root)
self.assertEqual({}, self.tree.environment)
# environment /hw (nodes first)
self.assertEqual({'corruptlist': ['upper_node_list']},
self.tree.children[0].environment)
cpu = self.tree.children[0].children[0]
# environment /hw/cpu (mixed env)
self.assertEqual(
{
'corruptlist': ['upper_node_list'],
'joinlist': ['first_item']
}, cpu.environment)
# environment /hw/cpu/amd (list extension)
vals = {
'corruptlist': ['upper_node_list'],
'cpu_CFLAGS': '-march=athlon64',
'joinlist': ['first_item', 'second', 'third']
}
self.assertEqual(vals, cpu.children[1].environment)
# environment /hw/cpu/arm (deep env)
vals = {
'corruptlist': ['upper_node_list'],
'joinlist': ['first_item'],
'cpu_CFLAGS': '-mabi=apcs-gnu '
'-march=armv8-a -mtune=arm8'
}
self.assertEqual(vals, cpu.children[2].environment)
# environment /hw/disk (list -> string)
vals = {'corruptlist': 'nonlist', 'disk_type': 'virtio'}
disk = self.tree.children[0].children[1]
self.assertEqual(vals, disk.environment)
# environment /hw/disk/scsi (string -> list)
vals = {'corruptlist': ['againlist'], 'disk_type': 'scsi'}
self.assertEqual(vals, disk.children[0].environment)
# environment /env
vals = {'opt_CFLAGS': '-Os'}
self.assertEqual(vals, self.tree.children[2].environment)
# leaves order
leaves = [
'intel', 'amd', 'arm', 'scsi', 'virtio', 'fedora', 'mint', 'prod'
]
self.assertEqual(leaves, self.tree.get_leaves())
# ascii contain all leaves and doesn't raise any exceptions
ascii = tree.tree_view(self.tree, 0, False)
for leaf in leaves:
self.assertIn(leaf, ascii,
"Leaf %s not in asci:\n%s" % (leaf, ascii))
def test_filters(self):
tree2 = copy.deepcopy(self.tree)
exp = ['intel', 'amd', 'arm', 'fedora', 'mint', 'prod']
act = mux.apply_filters(tree2, filter_only=['/hw/cpu',
'']).get_leaves()
self.assertEqual(exp, act)
tree2 = copy.deepcopy(self.tree)
exp = ['scsi', 'virtio', 'fedora', 'mint', 'prod']
act = mux.apply_filters(tree2, filter_out=['/hw/cpu', '']).get_leaves()
self.assertEqual(exp, act)
def test_merge_trees(self):
tree2 = copy.deepcopy(self.tree)
tree3 = mux.MuxTreeNode()
tree3.add_child(mux.MuxTreeNode('hw', {'another_value': 'bbb'}))
tree3.children[0].add_child(mux.MuxTreeNode('nic'))
tree3.children[0].children[0].add_child(mux.MuxTreeNode('default'))
tree3.children[0].children[0].add_child(
mux.MuxTreeNode('virtio', {'nic': 'virtio'}))
tree3.children[0].add_child(
mux.MuxTreeNode('cpu', {'test_value': ['z']}))
tree2.merge(tree3)
exp = [
'intel', 'amd', 'arm', 'scsi', 'virtio', 'default', 'virtio',
'fedora', 'mint', 'prod'
]
self.assertEqual(exp, tree2.get_leaves())
self.assertEqual(
{
'corruptlist': ['upper_node_list'],
'another_value': 'bbb'
}, tree2.children[0].value)
self.assertEqual({
'joinlist': ['first_item'],
'test_value': ['z']
}, tree2.children[0].children[0].value)
self.assertFalse(tree2.children[0].children[2].children[0].value)
self.assertEqual({'nic': 'virtio'},
tree2.children[0].children[2].children[1].value)
def test_advanced_yaml(self):
tree2 = yaml_to_mux.create_from_yaml(
['/:' + PATH_PREFIX + 'examples/mux-selftest-advanced.'
'yaml'])
exp = [
'intel', 'amd', 'arm', 'scsi', 'virtio', 'fedora', '6', '7',
'gentoo', 'mint', 'prod', 'new_node', 'on'
]
act = tree2.get_leaves()
oldroot = tree2.children[0]
self.assertEqual(exp, act)
self.assertEqual(tree2.children[0].children[0].path, "/virt/hw")
self.assertEqual({'enterprise': True},
oldroot.children[1].children[1].value)
self.assertEqual({'new_init': 'systemd'},
oldroot.children[1].children[0].value)
self.assertEqual({'is_cool': True},
oldroot.children[1].children[2].value)
self.assertEqual({'new_value': 'something'},
oldroot.children[3].children[0].children[0].value)
# Convert values, but not keys
self.assertEqual({
'on': True,
"true": "true"
}, oldroot.children[4].value)
# multiplex root (always True)
self.assertEqual(tree2.multiplex, None)
# multiplex /virt/
self.assertEqual(tree2.children[0].multiplex, None)
# multiplex /virt/hw
self.assertEqual(tree2.children[0].children[0].multiplex, None)
# multiplex /virt/distro
self.assertEqual(tree2.children[0].children[1].multiplex, True)
# multiplex /virt/env
self.assertEqual(tree2.children[0].children[2].multiplex, True)
# multiplex /virt/absolutely
self.assertEqual(tree2.children[0].children[3].multiplex, None)
# multiplex /virt/distro/fedora
self.assertEqual(tree2.children[0].children[1].children[0].multiplex,
None)
def test_get_node(self):
self.assertRaises(ValueError, self.tree.get_node, '/non-existing-node')
def test_fingerprint_order(self):
"""
Checks whether different order changes the fingerprint
"""
children1 = (tree.TreeNode("child1"), tree.TreeNode("child2"))
tree1 = tree.TreeNode("root", children=children1)
children2 = (tree.TreeNode("child2"), tree.TreeNode("child1"))
tree2 = tree.TreeNode("root", children=children2)
mux1 = mux.MuxPlugin()
mux2 = mux.MuxPlugin()
mux1.initialize_mux(tree1, "", False)
mux2.initialize_mux(tree2, "", False)
mux1.update_defaults(tree.TreeNode())
mux2.update_defaults(tree.TreeNode())
variant1 = iter(mux1).next()
variant2 = iter(mux2).next()
self.assertNotEqual(variant1, variant2)
self.assertEqual(
str(variant1), "{'mux_path': '', 'variant': "
"[TreeNode(name='child1'), TreeNode(name="
"'child2')], 'variant_id': 'child1-child2-9154'}")
def setUp(self):
tree_yaml_path = os.path.join(BASEDIR, 'tests/.data/mux-selftest.yaml')
tree_yaml_url = '/:%s' % tree_yaml_path
self.mux_tree = yaml_to_mux.create_from_yaml([tree_yaml_url])
self.mux_full = tuple(mux.MuxTree(self.mux_tree))
def test_create_variants(self):
from_file = yaml_to_mux.create_from_yaml(
["/:" + PATH_PREFIX + 'selftests/.data/mux-selftest.yaml'])
from_file = mux.MuxTree(from_file)
self.assertEqual(self.mux_full, tuple(from_file))
def test_create_variants(self):
tree_yaml_path = os.path.join(BASEDIR, 'tests/.data/mux-selftest.yaml')
tree_yaml_url = '/:%s' % tree_yaml_path
from_file = yaml_to_mux.create_from_yaml([tree_yaml_url])
from_file = mux.MuxTree(from_file)
self.assertEqual(self.mux_full, tuple(from_file))
def test_create_variants(self):
tree_yaml_path = os.path.join(BASEDIR, 'tests/.data/mux-selftest.yaml')
tree_yaml_url = '/:%s' % tree_yaml_path
from_file = yaml_to_mux.create_from_yaml([tree_yaml_url])
from_file = mux.MuxTree(from_file)
self.assertEqual(self.mux_full, tuple(from_file))
def setUp(self):
self.mux_tree = yaml_to_mux.create_from_yaml(['/:' + PATH_PREFIX +
'selftests/.data/mux-selftest.'
'yaml'])
self.mux_full = tuple(mux.MuxTree(self.mux_tree))
def test_create_variants(self):
from_file = yaml_to_mux.create_from_yaml(
["/:" + PATH_PREFIX + 'examples/mux-selftest.yaml'])
from_file = mux.MuxTree(from_file)
self.assertEqual(self.mux_full, tuple(from_file))
def setUp(self):
self.mux_tree = yaml_to_mux.create_from_yaml(
['/:' + PATH_PREFIX + 'examples/mux-selftest.'
'yaml'])
self.mux_full = tuple(mux.MuxTree(self.mux_tree))
