----- Original Message -----
From: "David Lehman" dlehman@redhat.com To: anaconda-patches@lists.fedorahosted.org Sent: Thursday, June 19, 2014 1:09:38 PM Subject: Re: [blivet:master 4/8] Rename devicetree_test file to something somewhat more appropriate.
On 06/18/2014 02:05 PM, mulhern wrote:
The tests do not actually test the devicetree classes very directly. The code does not import devicetree or use any of its methods explicitly, accessing them only through the higher level blivet package. The tests use the state of the device tree to verify other correctness properties.
They are about as close as is possible to testing most of the devicetree methods directly. What they test is exactly "does the devicetree correctly detect these device stacks?"
I don't how this change improves anything.
It did when I thought I had some actual devicetree unit tests and needed a place to put them. But since those turned out to be unworkable... I've removed this change in working copy.
- mulhern
Signed-off-by: mulhern amulhern@redhat.com
tests/devicetree_test.py | 283
tests/devicetreestate_test.py | 283 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 283 insertions(+), 283 deletions(-) delete mode 100644 tests/devicetree_test.py create mode 100644 tests/devicetreestate_test.py
diff --git a/tests/devicetree_test.py b/tests/devicetree_test.py deleted file mode 100644 index 8a1522c..0000000 --- a/tests/devicetree_test.py +++ /dev/null @@ -1,283 +0,0 @@ -import os -import unittest
-from tests.imagebackedtestcase import ImageBackedTestCase
-from blivet.size import Size -from blivet import devicelibs -from blivet import devicefactory -from blivet import util -from blivet.udev import udev_trigger -from blivet.devices import LVMSnapShotDevice, LVMThinSnapShotDevice
-"""
- TODO:
- add more lvm tests
- thin pool with separate data and metadata volumes?
- raid lvs
- raid thin pool
-"""
-def recursive_getattr(x, attr, default=None):
- """ Resolve a possibly-dot-containing attribute name. """
- val = x
- for sub_attr in attr.split("."):
try:
val = getattr(val, sub_attr)
except AttributeError:
return default
- return val
-@unittest.skipUnless(os.environ.get("JENKINS_HOME"), "jenkins only test") -class BlivetResetTestCase(ImageBackedTestCase):
- """ A class to test the results of Blivet.reset (and
DeviceTree.populate).
Create a device stack on disk images, catalog a set of attributes
of
every device we created, reset the Blivet instance, and then
verify
that the devices are all discovered and have attributes matching
those
we cataloged previously.
- """
- _validate_attrs = ["name", "type", "size",
"format.type", "format.mountpoint", "format.label"]
- """ List of StorageDevice attributes to verify match across the reset.
"""
- _identifying_attrs = ["name", "type"]
- """ List of attributes that must match to identify a device. """
- def collect_expected_data(self):
""" Collect the attribute data we plan to validate later. """
# only look at devices on the disk images -- no loops, &c
for device in (d for d in self.blivet.devices
if d.disks and
set(d.disks).issubset(set(self.blivet.disks))):
attr_dict = {}
device._partedDevice = None # force update from disk for size,
&c
for attr in self._validate_attrs:
attr_dict[attr] = recursive_getattr(device, attr)
self.device_attr_dicts.append(attr_dict)
- def setUp(self):
super(BlivetResetTestCase, self).setUp()
udev_trigger(subsystem="block", action="change")
self.device_attr_dicts = []
self.collect_expected_data()
- def tearDown(self):
""" Clean up after testing is complete. """
super(BlivetResetTestCase, self).tearDown()
# XXX The only reason for this may be lvmetad
for disk in self.blivet.disks:
self.blivet.recursiveRemove(disk)
try:
self.blivet.doIt()
except Exception:
self.blivet.reset()
raise
- def skip_attr(self, device, attr):
""" Return True if attr should not be checked for device. """
# pylint: disable=unused-argument
return False
- def find_device(self, attr_dict):
devices = self.blivet.devices #+ self.blivet.devicetree._hidden
device = None
for check in devices:
match = all(attr_dict[attr] == recursive_getattr(check, attr)
for attr in self._identifying_attrs)
if match:
device = check
break
return device
- def runTest(self):
""" Verify that the devices and their attributes match across
reset. """
#
# populate the devicetree
# XXX it would be better to test the results of a reboot
#
self.blivet.reset()
for attr_dict in self.device_attr_dicts:
#
# verify we can find the device that corresponds to this
attr_dict
#
device = self.find_device(attr_dict)
device_id = "/".join(attr_dict[attr] for attr in
self._identifying_attrs)
self.assertIsNotNone(device, msg="failed to find %s" %
device_id)
#
# verify that all attributes match across the reset
#
for attr, expected in attr_dict.iteritems():
if self.skip_attr(device, attr):
continue
actual = recursive_getattr(device, attr)
self.assertEqual(actual, expected,
msg=("attribute mismatch for %s: %s (%s/%s)"
% (device_id, attr, expected, actual)))
-class LVMTestCase(BlivetResetTestCase):
- """ Test that the devicetree can populate with the product of
autopart. """
- def _set_up_storage(self):
# This isn't exactly autopart, but it should be plenty close to
it.
self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_LVM,
Size("500 MiB"),
disks=self.blivet.disks[:],
fstype="swap")
self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_LVM,
None,
disks=self.blivet.disks[:])
-class LVMSnapShotTestCase(BlivetResetTestCase):
- def _set_up_storage(self):
self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_LVM,
Size("1 GiB"),
label="ROOT",
disks=self.blivet.disks[:],
container_name="blivet_test",
container_size=devicefactory.SIZE_POLICY_MAX)
- def setUp(self):
super(BlivetResetTestCase, self).setUp() # pylint:
disable=bad-super-call
root = self.blivet.lvs[0]
snap = LVMSnapShotDevice("rootsnap1", parents=[root.vg],
origin=root,
size=Size("768MiB"))
self.blivet.createDevice(snap)
self.blivet.doIt()
self.device_attr_dicts = []
self.collect_expected_data()
-class LVMThinpTestCase(BlivetResetTestCase):
- def _set_up_storage(self):
self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_LVM,
Size("500 MiB"),
fstype="swap",
disks=self.blivet.disks[:])
self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_LVM_THINP,
None,
label="ROOT",
disks=self.blivet.disks[:])
-class LVMThinSnapShotTestCase(LVMThinpTestCase):
- def _set_up_storage(self):
self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_LVM_THINP,
Size("1 GiB"),
label="ROOT",
disks=self.blivet.disks[:])
- def setUp(self):
super(BlivetResetTestCase, self).setUp() # pylint:
disable=bad-super-call
root = self.blivet.thinlvs[0]
snap = LVMThinSnapShotDevice("rootsnap1", parents=[root.pool],
origin=root)
self.blivet.createDevice(snap)
self.blivet.doIt()
self.device_attr_dicts = []
self.collect_expected_data()
-class LVMRaidTestCase(BlivetResetTestCase):
- def _set_up_storage(self):
# This isn't exactly autopart, but it should be plenty close to
it.
self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_LVM,
Size("500 MiB"),
disks=self.blivet.disks[:],
container_size=devicefactory.SIZE_POLICY_MAX)
- def setUp(self):
super(BlivetResetTestCase, self).setUp() # pylint:
disable=bad-super-call
vg_name = self.blivet.vgs[0].name
util.run_program(["lvcreate", "-n", "raid", "--type", "raid1",
"-L", "100%", vg_name])
self.device_attr_dicts = []
self.collect_expected_data()
-class MDRaid0TestCase(BlivetResetTestCase):
- """ Verify correct detection of MD RAID0 arrays. """
- level = "raid0"
- _validate_attrs = BlivetResetTestCase._validate_attrs + ["level",
"spares"]
- def set_up_disks(self):
level = devicelibs.mdraid.RAID_levels.raidLevel(self.level)
disk_count = level.min_members
self.disks = dict()
for i in range(disk_count):
name = "disk%d" % (i+1)
size = Size("2 GiB")
self.disks[name] = size
super(MDRaid0TestCase, self).set_up_disks()
- def skip_attr(self, device, attr):
return (attr in ["name", "path"] and
getattr(device, "metadataVersion", "").startswith("0.9"))
- def _set_up_storage(self):
device = self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_MD,
Size("200 MiB"),
disks=self.blivet.disks[:],
raid_level=self.level,
label="v090",
name="2")
device.metadataVersion = "0.90"
device = self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_MD,
Size("200 MiB"),
disks=self.blivet.disks[:],
raid_level=self.level,
label="v1",
name="one")
device.metadataVersion = "1.0"
device = self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_MD,
Size("200 MiB"),
disks=self.blivet.disks[:],
raid_level=self.level,
label="v11",
name="oneone")
device.metadataVersion = "1.1"
device = self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_MD,
Size("200 MiB"),
disks=self.blivet.disks[:],
raid_level=self.level,
label="v12",
name="onetwo")
device.metadataVersion = "1.2"
device = self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_MD,
Size("200 MiB"),
disks=self.blivet.disks[:],
raid_level=self.level,
label="vdefault",
name="default")
-class LVMOnMDTestCase(BlivetResetTestCase):
- # This also tests raid1 with the default metadata version.
- def _set_up_storage(self):
self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_LVM,
Size("200 MiB"),
disks=self.blivet.disks[:],
container_raid_level="raid1",
fstype="swap")
self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_LVM,
None,
disks=self.blivet.disks[:],
container_raid_level="raid1")
-if __name__ == "__main__":
- unittest.main()
diff --git a/tests/devicetreestate_test.py b/tests/devicetreestate_test.py new file mode 100644 index 0000000..8a1522c --- /dev/null +++ b/tests/devicetreestate_test.py @@ -0,0 +1,283 @@ +import os +import unittest
+from tests.imagebackedtestcase import ImageBackedTestCase
+from blivet.size import Size +from blivet import devicelibs +from blivet import devicefactory +from blivet import util +from blivet.udev import udev_trigger +from blivet.devices import LVMSnapShotDevice, LVMThinSnapShotDevice
+"""
- TODO:
- add more lvm tests
- thin pool with separate data and metadata volumes?
- raid lvs
- raid thin pool
+"""
+def recursive_getattr(x, attr, default=None):
- """ Resolve a possibly-dot-containing attribute name. """
- val = x
- for sub_attr in attr.split("."):
try:
val = getattr(val, sub_attr)
except AttributeError:
return default
- return val
+@unittest.skipUnless(os.environ.get("JENKINS_HOME"), "jenkins only test") +class BlivetResetTestCase(ImageBackedTestCase):
- """ A class to test the results of Blivet.reset (and
DeviceTree.populate).
Create a device stack on disk images, catalog a set of attributes
of
every device we created, reset the Blivet instance, and then
verify
that the devices are all discovered and have attributes matching
those
we cataloged previously.
- """
- _validate_attrs = ["name", "type", "size",
"format.type", "format.mountpoint", "format.label"]
- """ List of StorageDevice attributes to verify match across the reset.
"""
- _identifying_attrs = ["name", "type"]
- """ List of attributes that must match to identify a device. """
- def collect_expected_data(self):
""" Collect the attribute data we plan to validate later. """
# only look at devices on the disk images -- no loops, &c
for device in (d for d in self.blivet.devices
if d.disks and
set(d.disks).issubset(set(self.blivet.disks))):
attr_dict = {}
device._partedDevice = None # force update from disk for size,
&c
for attr in self._validate_attrs:
attr_dict[attr] = recursive_getattr(device, attr)
self.device_attr_dicts.append(attr_dict)
- def setUp(self):
super(BlivetResetTestCase, self).setUp()
udev_trigger(subsystem="block", action="change")
self.device_attr_dicts = []
self.collect_expected_data()
- def tearDown(self):
""" Clean up after testing is complete. """
super(BlivetResetTestCase, self).tearDown()
# XXX The only reason for this may be lvmetad
for disk in self.blivet.disks:
self.blivet.recursiveRemove(disk)
try:
self.blivet.doIt()
except Exception:
self.blivet.reset()
raise
- def skip_attr(self, device, attr):
""" Return True if attr should not be checked for device. """
# pylint: disable=unused-argument
return False
- def find_device(self, attr_dict):
devices = self.blivet.devices #+ self.blivet.devicetree._hidden
device = None
for check in devices:
match = all(attr_dict[attr] == recursive_getattr(check, attr)
for attr in self._identifying_attrs)
if match:
device = check
break
return device
- def runTest(self):
""" Verify that the devices and their attributes match across
reset. """
#
# populate the devicetree
# XXX it would be better to test the results of a reboot
#
self.blivet.reset()
for attr_dict in self.device_attr_dicts:
#
# verify we can find the device that corresponds to this
attr_dict
#
device = self.find_device(attr_dict)
device_id = "/".join(attr_dict[attr] for attr in
self._identifying_attrs)
self.assertIsNotNone(device, msg="failed to find %s" %
device_id)
#
# verify that all attributes match across the reset
#
for attr, expected in attr_dict.iteritems():
if self.skip_attr(device, attr):
continue
actual = recursive_getattr(device, attr)
self.assertEqual(actual, expected,
msg=("attribute mismatch for %s: %s (%s/%s)"
% (device_id, attr, expected, actual)))
+class LVMTestCase(BlivetResetTestCase):
- """ Test that the devicetree can populate with the product of
autopart. """
- def _set_up_storage(self):
# This isn't exactly autopart, but it should be plenty close to
it.
self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_LVM,
Size("500 MiB"),
disks=self.blivet.disks[:],
fstype="swap")
self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_LVM,
None,
disks=self.blivet.disks[:])
+class LVMSnapShotTestCase(BlivetResetTestCase):
- def _set_up_storage(self):
self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_LVM,
Size("1 GiB"),
label="ROOT",
disks=self.blivet.disks[:],
container_name="blivet_test",
container_size=devicefactory.SIZE_POLICY_MAX)
- def setUp(self):
super(BlivetResetTestCase, self).setUp() # pylint:
disable=bad-super-call
root = self.blivet.lvs[0]
snap = LVMSnapShotDevice("rootsnap1", parents=[root.vg],
origin=root,
size=Size("768MiB"))
self.blivet.createDevice(snap)
self.blivet.doIt()
self.device_attr_dicts = []
self.collect_expected_data()
+class LVMThinpTestCase(BlivetResetTestCase):
- def _set_up_storage(self):
self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_LVM,
Size("500 MiB"),
fstype="swap",
disks=self.blivet.disks[:])
self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_LVM_THINP,
None,
label="ROOT",
disks=self.blivet.disks[:])
+class LVMThinSnapShotTestCase(LVMThinpTestCase):
- def _set_up_storage(self):
self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_LVM_THINP,
Size("1 GiB"),
label="ROOT",
disks=self.blivet.disks[:])
- def setUp(self):
super(BlivetResetTestCase, self).setUp() # pylint:
disable=bad-super-call
root = self.blivet.thinlvs[0]
snap = LVMThinSnapShotDevice("rootsnap1", parents=[root.pool],
origin=root)
self.blivet.createDevice(snap)
self.blivet.doIt()
self.device_attr_dicts = []
self.collect_expected_data()
+class LVMRaidTestCase(BlivetResetTestCase):
- def _set_up_storage(self):
# This isn't exactly autopart, but it should be plenty close to
it.
self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_LVM,
Size("500 MiB"),
disks=self.blivet.disks[:],
container_size=devicefactory.SIZE_POLICY_MAX)
- def setUp(self):
super(BlivetResetTestCase, self).setUp() # pylint:
disable=bad-super-call
vg_name = self.blivet.vgs[0].name
util.run_program(["lvcreate", "-n", "raid", "--type", "raid1",
"-L", "100%", vg_name])
self.device_attr_dicts = []
self.collect_expected_data()
+class MDRaid0TestCase(BlivetResetTestCase):
- """ Verify correct detection of MD RAID0 arrays. """
- level = "raid0"
- _validate_attrs = BlivetResetTestCase._validate_attrs + ["level",
"spares"]
- def set_up_disks(self):
level = devicelibs.mdraid.RAID_levels.raidLevel(self.level)
disk_count = level.min_members
self.disks = dict()
for i in range(disk_count):
name = "disk%d" % (i+1)
size = Size("2 GiB")
self.disks[name] = size
super(MDRaid0TestCase, self).set_up_disks()
- def skip_attr(self, device, attr):
return (attr in ["name", "path"] and
getattr(device, "metadataVersion", "").startswith("0.9"))
- def _set_up_storage(self):
device = self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_MD,
Size("200 MiB"),
disks=self.blivet.disks[:],
raid_level=self.level,
label="v090",
name="2")
device.metadataVersion = "0.90"
device = self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_MD,
Size("200 MiB"),
disks=self.blivet.disks[:],
raid_level=self.level,
label="v1",
name="one")
device.metadataVersion = "1.0"
device = self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_MD,
Size("200 MiB"),
disks=self.blivet.disks[:],
raid_level=self.level,
label="v11",
name="oneone")
device.metadataVersion = "1.1"
device = self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_MD,
Size("200 MiB"),
disks=self.blivet.disks[:],
raid_level=self.level,
label="v12",
name="onetwo")
device.metadataVersion = "1.2"
device = self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_MD,
Size("200 MiB"),
disks=self.blivet.disks[:],
raid_level=self.level,
label="vdefault",
name="default")
+class LVMOnMDTestCase(BlivetResetTestCase):
- # This also tests raid1 with the default metadata version.
- def _set_up_storage(self):
self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_LVM,
Size("200 MiB"),
disks=self.blivet.disks[:],
container_raid_level="raid1",
fstype="swap")
self.blivet.factoryDevice(devicefactory.DEVICE_TYPE_LVM,
None,
disks=self.blivet.disks[:],
container_raid_level="raid1")
+if __name__ == "__main__":
- unittest.main()
anaconda-patches mailing list anaconda-patches@lists.fedorahosted.org https://lists.fedorahosted.org/mailman/listinfo/anaconda-patches