[blivet:rhel7 1/2] Port unit test changes from master branch to rhel7 branch.

mulhern amulhern at redhat.com
Tue Mar 4 18:07:33 UTC 2014


From: David Lehman <dlehman at redhat.com>

The commits that were picked are listed below. A few were slightly modified
to achieve syntactic correctness or make a module loadable. These things
might be necessary due to changes in a function's interface, etc.

Cherry-picked from commit 01c6949ee336e3bb3861a9e94280f5ec1dcc62b4.
Cherry-picked from commit 49c86eff59c719102a9d7f34b9e87c5b39127d05.
Cherry-picked from commit aacc900d5182157ba79bef45aa087e59d019fb1f.
Cherry-picked from commit 1256be6ee0795ade15edcd75bfcdf5eee6cda9d5.
Cherry-picked from commit 02dc89b977b5463784b813d4238dd3de9dce7d08.
Cherry-picked from commit 22fca7770adf326ba5592aa48e4c14fc5f21dd84.
Cherry-picked from commit 4596ee9b3201603d9cba4367b8ef91dabf7d1b8b.
Cherry-picked from commit 46f75fd3ad76cbfa9da14d26e16757a57d18dc5e.
Cherry-picked from commit 1c9d7bde13477c2b2032328c39c438bf5509516e.
Cherry-picked from commit f3eafd12d72f8857de79c83ba54e96471215af39.
Cherry-picked from commit 3dae360e4841893f368b8ba67102c4e58c619396.
Cherry-picked from commit dd0925d7b23a3ea7760c5c8d9951fcfd2393dba9.
Cherry-picked from commit a82179ea97e347da8a707f0411c4878dcd269092.
Cherry-picked from commit b33960b1fa0ea910c5a1e36fb7038a99d6b283d4.
Cherry-picked from commit c1c47d8c2c7b2e61049ae67aa0bc11f1b09b265f.
Cherry-picked from commit 832b47324d5729e3e314d7f7bb243a7ea9c81821.
Cherry-picked from commit 3e51ef5940d54b5dd8e66da20e7fa345cf694062.

Signed-off-by: mulhern <amulhern at redhat.com>
---
 tests/__init__.py                    |   0
 tests/action_test.py                 |   1 +
 tests/clearpart_test.py              | 202 ++++++++++++++
 tests/devicefactory_test.py          |  59 ++++
 tests/devicelibs_test/__init__.py    |   0
 tests/devicelibs_test/baseclass.py   |   3 -
 tests/devicelibs_test/btrfs_test.py  | 177 ++++++++++++
 tests/devicelibs_test/crypto_test.py |   5 +-
 tests/devicelibs_test/edd_test.py    |  20 +-
 tests/devicelibs_test/lvm_test.py    |  66 +++--
 tests/devicelibs_test/mdraid_test.py | 136 +++++++---
 tests/devicelibs_test/mpath_test.py  |  86 ------
 tests/devicelibs_test/swap_test.py   |   5 +-
 tests/devices_test.py                | 511 +++++++++++++++++++++++++++++++++++
 tests/formats_test/init_test.py      |  34 +++
 tests/partitioning_test.py           |   3 -
 tests/storagetestcase.py             |   4 +-
 tests/udev_test.py                   |   3 -
 18 files changed, 1133 insertions(+), 182 deletions(-)
 create mode 100644 tests/__init__.py
 create mode 100644 tests/clearpart_test.py
 create mode 100644 tests/devicefactory_test.py
 create mode 100644 tests/devicelibs_test/__init__.py
 create mode 100755 tests/devicelibs_test/btrfs_test.py
 delete mode 100755 tests/devicelibs_test/mpath_test.py
 create mode 100644 tests/devices_test.py
 create mode 100644 tests/formats_test/init_test.py

diff --git a/tests/__init__.py b/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/action_test.py b/tests/action_test.py
index bc906c9..4861193 100644
--- a/tests/action_test.py
+++ b/tests/action_test.py
@@ -27,6 +27,7 @@ from blivet.deviceaction import ActionResizeFormat
 from blivet.deviceaction import ActionDestroyFormat
 
 """ DeviceActionTestSuite """
+
 @unittest.skip("broken")
 class DeviceActionTestCase(StorageTestCase):
     def setUp(self):
diff --git a/tests/clearpart_test.py b/tests/clearpart_test.py
new file mode 100644
index 0000000..1486bde
--- /dev/null
+++ b/tests/clearpart_test.py
@@ -0,0 +1,202 @@
+import unittest
+import mock
+
+import blivet
+from pykickstart.constants import *
+from parted import PARTITION_NORMAL
+from blivet.flags import flags
+
+class ClearPartTestCase(unittest.TestCase):
+    def setUp(self):
+        flags.testing = True
+
+    def testShouldClear(self):
+        """ Test the Blivet.shouldClear method. """
+        b = blivet.Blivet()
+
+        DiskDevice = blivet.devices.DiskDevice
+        PartitionDevice = blivet.devices.PartitionDevice
+
+        # sda is a disk with an existing disklabel containing two partitions
+        sda = DiskDevice("sda", size=100000, exists=True)
+        sda.format = blivet.formats.getFormat("disklabel", device=sda.path,
+                                              exists=True)
+        sda.format._partedDisk = mock.Mock()
+        sda.format._partedDevice = mock.Mock()
+        b.devicetree._addDevice(sda)
+
+        # sda1 is a partition containing an existing ext4 filesystem
+        sda1 = PartitionDevice("sda1", size=500, exists=True,
+                               parents=[sda])
+        sda1._partedPartition = mock.Mock(**{'type': PARTITION_NORMAL,
+                                             'getFlag.return_value': 0})
+        sda1.format = blivet.formats.getFormat("ext4", mountpoint="/boot",
+                                               device=sda1.path,
+                                               exists=True)
+        b.devicetree._addDevice(sda1)
+
+        # sda2 is a partition containing an existing vfat filesystem
+        sda2 = PartitionDevice("sda2", size=10000, exists=True,
+                               parents=[sda])
+        sda2._partedPartition = mock.Mock(**{'type': PARTITION_NORMAL,
+                                             'getFlag.return_value': 0})
+        sda2.format = blivet.formats.getFormat("vfat", mountpoint="/foo",
+                                               device=sda2.path,
+                                               exists=True)
+        b.devicetree._addDevice(sda2)
+
+        # sdb is an unpartitioned disk containing an xfs filesystem
+        sdb = DiskDevice("sdb", size=100000, exists=True)
+        sdb.format = blivet.formats.getFormat("xfs", device=sdb.path,
+                                              exists=True)
+        b.devicetree._addDevice(sdb)
+
+        # sdc is an unformatted/uninitialized/empty disk
+        sdc = DiskDevice("sdc", size=100000, exists=True)
+        b.devicetree._addDevice(sdc)
+
+        # sdd is a disk containing an existing disklabel with no partitions
+        sdd = DiskDevice("sdd", size=100000, exists=True)
+        sdd.format = blivet.formats.getFormat("disklabel", device=sdd.path,
+                                              exists=True)
+        b.devicetree._addDevice(sdd)
+
+        #
+        # clearpart type none
+        #
+        b.config.clearPartType = CLEARPART_TYPE_NONE
+        self.assertFalse(b.shouldClear(sda1),
+                         msg="type none should not clear any partitions")
+        self.assertFalse(b.shouldClear(sda2),
+                         msg="type none should not clear any partitions")
+
+        b.config.initializeDisks = False
+        self.assertFalse(b.shouldClear(sda),
+                         msg="type none should not clear non-empty disks")
+        self.assertFalse(b.shouldClear(sdb),
+                         msg="type none should not clear formatting from "
+                             "unpartitioned disks")
+
+        self.assertFalse(b.shouldClear(sdc),
+                         msg="type none should not clear empty disk without "
+                             "initlabel")
+        self.assertFalse(b.shouldClear(sdd),
+                         msg="type none should not clear empty partition table "
+                             "without initlabel")
+
+        b.config.initializeDisks = True
+        self.assertFalse(b.shouldClear(sda),
+                         msg="type none should not clear non-empty disks even "
+                             "with initlabel")
+        self.assertFalse(b.shouldClear(sdb),
+                         msg="type non should not clear formatting from "
+                             "unpartitioned disks even with initlabel")
+        self.assertTrue(b.shouldClear(sdc),
+                        msg="type none should clear empty disks when initlabel "
+                            "is set")
+        self.assertTrue(b.shouldClear(sdd),
+                        msg="type none should clear empty partition table when "
+                            "initlabel is set")
+
+        #
+        # clearpart type linux
+        #
+        b.config.clearPartType = CLEARPART_TYPE_LINUX
+        self.assertTrue(b.shouldClear(sda1),
+                        msg="type linux should clear partitions containing "
+                            "ext4 filesystems")
+        self.assertFalse(b.shouldClear(sda2),
+                         msg="type linux should not clear partitions "
+                             "containing vfat filesystems")
+
+        b.config.initializeDisks = False
+        self.assertFalse(b.shouldClear(sda),
+                         msg="type linux should not clear non-empty disklabels")
+        self.assertTrue(b.shouldClear(sdb),
+                        msg="type linux should clear linux-native whole-disk "
+                            "formatting regardless of initlabel setting")
+        self.assertFalse(b.shouldClear(sdc),
+                         msg="type linux should not clear unformatted disks "
+                             "unless initlabel is set")
+        self.assertFalse(b.shouldClear(sdd),
+                         msg="type linux should not clear disks with empty "
+                             "partition tables unless initlabel is set")
+
+        b.config.initializeDisks = True
+        self.assertFalse(b.shouldClear(sda),
+                         msg="type linux should not clear non-empty disklabels")
+        self.assertTrue(b.shouldClear(sdb),
+                        msg="type linux should clear linux-native whole-disk "
+                            "formatting regardless of initlabel setting")
+        self.assertTrue(b.shouldClear(sdc),
+                         msg="type linux should clear unformatted disks when "
+                             "initlabel is set")
+        self.assertTrue(b.shouldClear(sdd),
+                         msg="type linux should clear disks with empty "
+                             "partition tables when initlabel is set")
+
+        sda1.protected = True
+        self.assertFalse(b.shouldClear(sda1),
+                         msg="protected devices should never be cleared")
+        self.assertFalse(b.shouldClear(sda),
+                         msg="disks containing protected devices should never "
+                             "be cleared")
+        sda1.protected = False
+
+        #
+        # clearpart type all
+        #
+        b.config.clearPartType = CLEARPART_TYPE_ALL
+        self.assertTrue(b.shouldClear(sda1),
+                        msg="type all should clear all partitions")
+        self.assertTrue(b.shouldClear(sda2),
+                        msg="type all should clear all partitions")
+
+        b.config.initializeDisks = False
+        self.assertTrue(b.shouldClear(sda),
+                        msg="type all should initialize all disks")
+        self.assertTrue(b.shouldClear(sdb),
+                        msg="type all should initialize all disks")
+        self.assertTrue(b.shouldClear(sdc),
+                        msg="type all should initialize all disks")
+        self.assertTrue(b.shouldClear(sdd),
+                        msg="type all should initialize all disks")
+
+        b.config.initializeDisks = True
+        self.assertTrue(b.shouldClear(sda),
+                        msg="type all should initialize all disks")
+        self.assertTrue(b.shouldClear(sdb),
+                        msg="type all should initialize all disks")
+        self.assertTrue(b.shouldClear(sdc),
+                        msg="type all should initialize all disks")
+        self.assertTrue(b.shouldClear(sdd),
+                        msg="type all should initialize all disks")
+
+        sda1.protected = True
+        self.assertFalse(b.shouldClear(sda1),
+                         msg="protected devices should never be cleared")
+        self.assertFalse(b.shouldClear(sda),
+                         msg="disks containing protected devices should never "
+                             "be cleared")
+        sda1.protected = False
+
+        #
+        # clearpart type list
+        #
+        # TODO
+
+    def tearDown(self):
+        flags.testing = False
+
+    def testInitializeDisk(self):
+        """
+            magic partitions
+            non-empty partition table
+        """
+        pass
+
+    def testRecursiveRemove(self):
+        """
+            protected device at various points in stack
+        """
+        pass
diff --git a/tests/devicefactory_test.py b/tests/devicefactory_test.py
new file mode 100644
index 0000000..67f8c1a
--- /dev/null
+++ b/tests/devicefactory_test.py
@@ -0,0 +1,59 @@
+#!/usr/bin/python
+
+import unittest
+
+import blivet
+
+from blivet import devicefactory
+from blivet import devices
+from blivet.devicelibs import mdraid
+
+class MDFactoryTestCase(unittest.TestCase):
+    """Note that these tests postdate the code that they test.
+       Therefore, they capture the behavior of the code as it is now,
+       not necessarily its intended or its correct behavior. See the
+       initial commit message for this file for further details.
+    """
+    def setUp(self):
+        self.b = blivet.Blivet()
+        self.factory1 = devicefactory.get_device_factory(self.b,
+           devicefactory.DEVICE_TYPE_MD,
+           1024)
+
+        self.factory2 = devicefactory.get_device_factory(self.b,
+           devicefactory.DEVICE_TYPE_MD,
+           1024,
+           raid_level=0)
+
+    def testMDFactory(self):
+        self.assertRaisesRegexp(mdraid.MDRaidError,
+           "invalid raid level",
+           self.factory1._get_device_space)
+
+        self.assertRaisesRegexp(mdraid.MDRaidError,
+           "invalid raid level",
+           self.factory1._set_raid_level)
+
+        self.assertEqual(self.factory1.container_list, [])
+
+        self.assertIsNone(self.factory1.get_container())
+
+        self.assertRaisesRegexp(mdraid.MDRaidError,
+           "invalid raid level",
+           self.factory1._get_new_device,
+           parents=[])
+
+        self.assertRaisesRegexp(mdraid.MDRaidError,
+           "requires at least",
+           self.factory2._get_device_space)
+
+        self.assertEqual(self.factory2.container_list, [])
+
+        self.assertIsNone(self.factory2.get_container())
+
+def suite():
+    return unittest.TestLoader().loadTestsFromTestCase(MDFactoryTestCase)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/devicelibs_test/__init__.py b/tests/devicelibs_test/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/devicelibs_test/baseclass.py b/tests/devicelibs_test/baseclass.py
index 06adef9..0209898 100644
--- a/tests/devicelibs_test/baseclass.py
+++ b/tests/devicelibs_test/baseclass.py
@@ -63,9 +63,6 @@ class DevicelibsTestCase(unittest.TestCase):
     _LOOP_DEVICES = ["/tmp/test-virtdev0", "/tmp/test-virtdev1"]
 
     def __init__(self, *args, **kwargs):
-        import pyanaconda.anaconda_log
-        pyanaconda.anaconda_log.init()
-
         unittest.TestCase.__init__(self, *args, **kwargs)
         self._loopMap = {}
 
diff --git a/tests/devicelibs_test/btrfs_test.py b/tests/devicelibs_test/btrfs_test.py
new file mode 100755
index 0000000..ae3f57b
--- /dev/null
+++ b/tests/devicelibs_test/btrfs_test.py
@@ -0,0 +1,177 @@
+#!/usr/bin/python
+import baseclass
+import os
+import os.path
+import subprocess
+import tempfile
+import unittest
+
+import blivet.devicelibs.btrfs as btrfs
+import blivet.util as util
+
+class BTRFSMountDevice(baseclass.DevicelibsTestCase):
+    """A superclass that mounts and unmounts the filesystem.
+       It must create the filesystem on its chosen devices before mounting.
+       It always mounts the filesystem using self.device at self.mountpoint.
+    """
+    def __init__(self, *args, **kwargs):
+        baseclass.DevicelibsTestCase.__init__(self, *args, **kwargs)
+        self.device = None
+        self.mountpoint = None
+
+    def setUp(self):
+        """After the DevicelibsTestCase setup, creates the filesystem on both
+           devices and mounts on a tmp directory.
+
+           Chooses the device to specify to mount command arbitrarily.
+        """
+        baseclass.DevicelibsTestCase.setUp(self)
+
+        btrfs.create_volume(self._loopMap.values())
+        self.device = self._loopMap.values()[0]
+
+        self.mountpoint = tempfile.mkdtemp()
+        rc = subprocess.call(["mount", self.device, self.mountpoint])
+        if rc:
+            raise OSError, "mount failed to mount device %s" % device
+
+    def tearDown(self):
+        """Before the DevicelibsTestCase cleanup unmount the device and
+           remove the temporary mountpoint.
+        """
+        proc = subprocess.Popen(["umount", self.device])
+        while True:
+            (out, err) = proc.communicate()
+            if proc.returncode is not None:
+                rc = proc.returncode
+                break
+        if rc:
+            raise OSError, "failed to unmount device %s" % self.device
+
+        os.rmdir(self.mountpoint)
+        baseclass.DevicelibsTestCase.tearDown(self)
+
+class BTRFSAsRootTestCase1(baseclass.DevicelibsTestCase):
+
+    @unittest.skipUnless(os.geteuid() == 0, "requires root privileges")
+    def testUnmountedBTRFS(self):
+        """A series of simple tests on an unmounted file system.
+
+           These tests are limited to simple creating and scanning.
+        """
+        _LOOP_DEV0 = self._loopMap[self._LOOP_DEVICES[0]]
+        _LOOP_DEV1 = self._loopMap[self._LOOP_DEVICES[1]]
+
+        ##
+        ## create_volume
+        ##
+        # no devices specified
+        self.assertRaisesRegexp(ValueError,
+           "no devices specified",
+           btrfs.create_volume, [], data=0)
+
+        # non-existant device
+        self.assertRaisesRegexp(ValueError,
+           "one or more specified devices not present",
+           btrfs.create_volume,
+           ["/not/existing/device"])
+
+        # bad data
+        self.assertRaisesRegexp(btrfs.BTRFSError,
+           "1",
+           btrfs.create_volume,
+           [_LOOP_DEV0], data="RaID7")
+
+        # bad metadata
+        self.assertRaisesRegexp(btrfs.BTRFSError,
+           "1",
+           btrfs.create_volume,
+           [_LOOP_DEV0], metadata="RaID7")
+
+        # pass
+        self.assertEqual(btrfs.create_volume(self._loopMap.values()), 0)
+
+        # already created
+        self.assertRaisesRegexp(btrfs.BTRFSError,
+           "1",
+           btrfs.create_volume,
+           [_LOOP_DEV0], metadata="RaID7")
+
+    @unittest.skipUnless(os.geteuid() == 0, "requires root privileges")
+    def testMkfsDefaults(self):
+        _LOOP_DEV0 = self._loopMap[self._LOOP_DEVICES[0]]
+        _LOOP_DEV1 = self._loopMap[self._LOOP_DEVICES[1]]
+
+        btrfs.create_volume(self._loopMap.values())
+
+class BTRFSAsRootTestCase2(BTRFSMountDevice):
+    """Tests which require mounting the device."""
+
+    @unittest.skipUnless(os.geteuid() == 0, "requires root privileges")
+    def testSubvolume(self):
+        """Tests which focus on subvolumes."""
+        _LOOP_DEV0 = self._loopMap[self._LOOP_DEVICES[0]]
+        _LOOP_DEV1 = self._loopMap[self._LOOP_DEVICES[1]]
+
+        # no subvolumes yet
+        self.assertEqual(btrfs.list_subvolumes(self.mountpoint), [])
+
+        # a new subvolume can be added succesfully below the mountpoint
+        self.assertEqual(btrfs.create_subvolume(self.mountpoint, "SV1"), 0)
+
+        # expect one subvolume
+        subvolumes = btrfs.list_subvolumes(self.mountpoint)
+        self.assertEqual(len(subvolumes), 1)
+        self.assertEqual(subvolumes[0]['path'], 'SV1')
+        self.assertEqual(subvolumes[0]['parent'], btrfs.MAIN_VOLUME_ID)
+
+        # the same subvolume can be deleted
+        self.assertEqual(btrfs.delete_subvolume(self.mountpoint, "SV1"), 0)
+
+        # deleted subvolume is no longer present
+        subvolumes = btrfs.list_subvolumes(self.mountpoint)
+        self.assertNotIn("SV1", [v['path'] for v in subvolumes])
+
+        # two distinct subvolumes, so both should be present
+        self.assertEqual(btrfs.create_subvolume(self.mountpoint, "SV1"), 0)
+        self.assertEqual(btrfs.create_subvolume(self.mountpoint, "SV2"), 0)
+        subvolumes = btrfs.list_subvolumes(self.mountpoint)
+        self.assertIn("SV1", [v['path'] for v in subvolumes])
+        self.assertIn("SV2", [v['path'] for v in subvolumes])
+
+        # we can remove one subvolume
+        self.assertEqual(btrfs.delete_subvolume(self.mountpoint, "SV1"), 0)
+        subvolumes = btrfs.list_subvolumes(self.mountpoint)
+        self.assertNotIn("SV1", [v['path'] for v in subvolumes])
+
+        # if the subvolume is already gone,  an error is raised by btrfs
+        self.assertRaisesRegexp(btrfs.BTRFSError,
+           "1",
+           btrfs.delete_subvolume,
+           self.mountpoint, "SV1")
+
+        # if the subvolume is already there, an error is raise by btrfs
+        self.assertRaisesRegexp(btrfs.BTRFSError,
+           "1",
+           btrfs.create_subvolume,
+           self.mountpoint, "SV2")
+
+        # if we create SV1 once again it's back
+        self.assertEqual(btrfs.create_subvolume(self.mountpoint, "SV1"), 0)
+        subvolumes = btrfs.list_subvolumes(self.mountpoint)
+        self.assertIn("SV1", [v['path'] for v in subvolumes])
+
+        # we can create an additional subvolume beneath SV1
+        self.assertEqual(btrfs.create_subvolume(os.path.join(self.mountpoint, "SV1"), "SV1.1"), 0)
+        subvolumes = btrfs.list_subvolumes(self.mountpoint)
+        self.assertEqual(len([v for v in subvolumes if v['path'].find("SV1.1") != -1]), 1)
+
+
+def suite():
+    suite1 = unittest.TestLoader().loadTestsFromTestCase(BTRFSAsRootTestCase1)
+    suite1 = unittest.TestLoader().loadTestsFromTestCase(BTRFSAsRootTestCase2)
+    return unittest.TestSuite([suite1, suite2])
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/devicelibs_test/crypto_test.py b/tests/devicelibs_test/crypto_test.py
index 9e82de5..7ef49fe 100755
--- a/tests/devicelibs_test/crypto_test.py
+++ b/tests/devicelibs_test/crypto_test.py
@@ -1,22 +1,19 @@
 #!/usr/bin/python
 import baseclass
 import unittest
-from mock import acceptance
 
 import tempfile
 import os
 
 class CryptoTestCase(baseclass.DevicelibsTestCase):
 
+    @unittest.skipUnless(os.geteuid() == 0, "requires root privileges")
     def testCrypto(self):
         _LOOP_DEV0 = self._loopMap[self._LOOP_DEVICES[0]]
         _LOOP_DEV1 = self._loopMap[self._LOOP_DEVICES[1]]
 
         import blivet.devicelibs.crypto as crypto
 
-
-    @acceptance
-    def testCrypto(self):
         ##
         ## is_luks
         ##
diff --git a/tests/devicelibs_test/edd_test.py b/tests/devicelibs_test/edd_test.py
index 25fa070..ec402ac 100644
--- a/tests/devicelibs_test/edd_test.py
+++ b/tests/devicelibs_test/edd_test.py
@@ -1,18 +1,14 @@
+import unittest
 import mock
 
-class EddTestCase(mock.TestCase):
-    def setUp(self):
-        self.setupModules(
-            ['_isys', 'logging', 'pyanaconda.anaconda_log', 'block'])
-
-    def tearDown(self):
-        self.tearDownModules()
-
+class EddTestCase(unittest.TestCase):
+    @unittest.skip("not implemented")
     def test_biosdev_to_edd_dir(self):
         from blivet.devicelibs import edd
         path = edd.biosdev_to_edd_dir(138)
         self.assertEqual("/sys/firmware/edd/int13_dev8a", path)
 
+    @unittest.skip("not implemented")
     def test_collect_edd_data(self):
         from blivet.devicelibs import edd
 
@@ -41,6 +37,7 @@ class EddTestCase(mock.TestCase):
         self.assertEqual(edd_dict[0x80].ata_device, 0)
         self.assertEqual(edd_dict[0x80].mbr_signature, "0x000ccb01")
 
+    @unittest.skip("not implemented")
     def test_collect_edd_data_cciss(self):
         from blivet.devicelibs import edd
         fs = EddTestFS(self, edd).sda_cciss()
@@ -49,6 +46,7 @@ class EddTestCase(mock.TestCase):
         self.assertEqual(edd_dict[0x80].pci_dev, None)
         self.assertEqual(edd_dict[0x80].channel, None)
 
+    @unittest.skip("not implemented")
     def test_edd_entry_str(self):
         from blivet.devicelibs import edd
         fs = EddTestFS(self, edd).sda_vda()
@@ -59,6 +57,7 @@ class EddTestCase(mock.TestCase):
 \tscsi_lun: None, sectors: 2097152"""
         self.assertEqual(str(edd_dict[0x80]), expected_output)
 
+    @unittest.skip("not implemented")
     def test_matcher_device_path(self):
         from blivet.devicelibs import edd
         fs = EddTestFS(self, edd).sda_vda()
@@ -72,6 +71,7 @@ class EddTestCase(mock.TestCase):
         path = analyzer.devname_from_pci_dev()
         self.assertEqual(path, "vda")
 
+    @unittest.skip("not implemented")
     def test_bad_device_path(self):
         from blivet.devicelibs import edd
         fs = EddTestFS(self, edd).sda_vda_no_pcidev()
@@ -81,6 +81,7 @@ class EddTestCase(mock.TestCase):
         path = analyzer.devname_from_pci_dev()
         self.assertEqual(path, None)
 
+    @unittest.skip("not implemented")
     def test_bad_host_bus(self):
         from blivet.devicelibs import edd
         fs = EddTestFS(self, edd).sda_vda_no_host_bus()
@@ -97,6 +98,7 @@ class EddTestCase(mock.TestCase):
         devname = analyzer.devname_from_pci_dev()
         self.assertEqual(devname, "vda")
 
+    @unittest.skip("not implemented")
     def test_get_edd_dict_1(self):
         """ Test get_edd_dict()'s pci_dev matching. """
         from blivet.devicelibs import edd
@@ -105,6 +107,7 @@ class EddTestCase(mock.TestCase):
                          {'sda' : 0x80,
                           'vda' : 0x81})
 
+    @unittest.skip("not implemented")
     def test_get_edd_dict_2(self):
         """ Test get_edd_dict()'s pci_dev matching. """
         from blivet.devicelibs import edd
@@ -116,6 +119,7 @@ class EddTestCase(mock.TestCase):
                          {'sda' : 0x80,
                           'vda' : 0x81})
 
+    @unittest.skip("not implemented")
     def test_get_edd_dict_3(self):
         """ Test scenario when the 0x80 and 0x81 edd directories contain the
             same data and give no way to distinguish among the two devices.
diff --git a/tests/devicelibs_test/lvm_test.py b/tests/devicelibs_test/lvm_test.py
index e639a21..824c33c 100755
--- a/tests/devicelibs_test/lvm_test.py
+++ b/tests/devicelibs_test/lvm_test.py
@@ -1,19 +1,40 @@
 #!/usr/bin/python
 import baseclass
+import os
 import unittest
-from mock import acceptance
 
-class LVMTestCase(baseclass.DevicelibsTestCase):
+import blivet.devicelibs.lvm as lvm
 
-    def testLVM(self):
-        _LOOP_DEV0 = self._loopMap[self._LOOP_DEVICES[0]]
-        _LOOP_DEV1 = self._loopMap[self._LOOP_DEVICES[1]]
+class LVMTestCase(unittest.TestCase):
 
-        import storage.devicelibs.lvm as lvm
+    def testGetPossiblePhysicalExtents(self):
+        # pass
+        self.assertEqual(lvm.getPossiblePhysicalExtents(4),
+                         filter(lambda pe: pe > 4, map(lambda power: 2**power, xrange(3, 25))))
+        self.assertEqual(lvm.getPossiblePhysicalExtents(100000),
+                         filter(lambda pe: pe > 100000, map(lambda power: 2**power, xrange(3, 25))))
 
+    def testClampSize(self):
+        # pass
+        self.assertEqual(lvm.clampSize(10, 4), 8L)
+        self.assertEqual(lvm.clampSize(10, 4, True), 12L)
 
-    @acceptance
+    #def testVGUsedSpace(self):
+        # TODO
+        pass
+
+    #def testVGFreeSpace(self):
+        # TODO
+        pass
+
+
+class LVMAsRootTestCase(baseclass.DevicelibsTestCase):
+
+    @unittest.skipUnless(os.geteuid() == 0, "requires root privileges")
     def testLVM(self):
+        _LOOP_DEV0 = self._loopMap[self._LOOP_DEVICES[0]]
+        _LOOP_DEV1 = self._loopMap[self._LOOP_DEVICES[1]]
+
         ##
         ## pvcreate
         ##
@@ -202,37 +223,12 @@ class LVMTestCase(baseclass.DevicelibsTestCase):
         # pv already removed
         self.assertRaises(lvm.LVMError, lvm.pvremove, _LOOP_DEV0)
 
-    #def testGetPossiblePhysicalExtents(self):
-        # pass
-        self.assertEqual(lvm.getPossiblePhysicalExtents(4),
-                         filter(lambda pe: pe > 4, map(lambda power: 2**power, xrange(3, 25))))
-        self.assertEqual(lvm.getPossiblePhysicalExtents(100000),
-                         filter(lambda pe: pe > 100000, map(lambda power: 2**power, xrange(3, 25))))
-
-    #def testGetMaxLVSize(self):
-        # pass
-        self.assertEqual(lvm.getMaxLVSize(), 16*1024**2)
-
-    #def testSafeLVMName(self):
-        # pass
-        self.assertEqual(lvm.safeLvmName("/strange/lv*name5"), "strange_lvname5")
-
-    #def testClampSize(self):
-        # pass
-        self.assertEqual(lvm.clampSize(10, 4), 8L)
-        self.assertEqual(lvm.clampSize(10, 4, True), 12L)
-
-    #def testVGUsedSpace(self):
-        # TODO
-        pass
-
-    #def testVGFreeSpace(self):
-        # TODO
-        pass
 
 
 def suite():
-    return unittest.TestLoader().loadTestsFromTestCase(LVMTestCase)
+    suite1 = unittest.TestLoader().loadTestsFromTestCase(LVMTestCase)
+    suite2 = unittest.TestLoader().loadTestsFromTestCase(LVMAsRootTestCase)
+    return unittest.TestSuite([suite1, suite2])
 
 
 if __name__ == "__main__":
diff --git a/tests/devicelibs_test/mdraid_test.py b/tests/devicelibs_test/mdraid_test.py
index 8d81020..236b3f3 100755
--- a/tests/devicelibs_test/mdraid_test.py
+++ b/tests/devicelibs_test/mdraid_test.py
@@ -1,24 +1,15 @@
 #!/usr/bin/python
 import baseclass
+import os
 import unittest
 import time
-from mock import acceptance
 
-class MDRaidTestCase(baseclass.DevicelibsTestCase):
+import blivet.devicelibs.mdraid as mdraid
+import blivet.errors as errors
 
-    def testMDRaid(self):
-        _LOOP_DEV0 = self._loopMap[self._LOOP_DEVICES[0]]
-        _LOOP_DEV1 = self._loopMap[self._LOOP_DEVICES[1]]
+class MDRaidTestCase(unittest.TestCase):
 
-        import blivet.devicelibs.mdraid as mdraid
-
-    @acceptance
     def testMDRaid(self):
-        ##
-        ## getRaidLevels
-        ##
-        # pass
-        self.assertEqual(mdraid.getRaidLevels(), mdraid.getRaidLevels())
 
         ##
         ## get_raid_min_members
@@ -28,11 +19,13 @@ class MDRaidTestCase(baseclass.DevicelibsTestCase):
         self.assertEqual(mdraid.get_raid_min_members(mdraid.RAID1), 2)
         self.assertEqual(mdraid.get_raid_min_members(mdraid.RAID5), 3)
         self.assertEqual(mdraid.get_raid_min_members(mdraid.RAID6), 4)
-        self.assertEqual(mdraid.get_raid_min_members(mdraid.RAID10), 2)
+        self.assertEqual(mdraid.get_raid_min_members(mdraid.RAID10), 4)
 
         # fail
         # unsupported raid
-        self.assertRaises(ValueError, mdraid.get_raid_min_members, 8)
+        self.assertRaisesRegexp(errors.MDRaidError,
+           "invalid raid level",
+           mdraid.get_raid_min_members, 8)
 
         ##
         ## get_raid_max_spares
@@ -42,11 +35,91 @@ class MDRaidTestCase(baseclass.DevicelibsTestCase):
         self.assertEqual(mdraid.get_raid_max_spares(mdraid.RAID1, 5), 3)
         self.assertEqual(mdraid.get_raid_max_spares(mdraid.RAID5, 5), 2)
         self.assertEqual(mdraid.get_raid_max_spares(mdraid.RAID6, 5), 1)
-        self.assertEqual(mdraid.get_raid_max_spares(mdraid.RAID10, 5), 3)
+        self.assertEqual(mdraid.get_raid_max_spares(mdraid.RAID10, 5), 1)
+
+        # fail
+        # unsupported raid
+        self.assertRaisesRegexp(errors.MDRaidError,
+           "invalid raid level",
+           mdraid.get_raid_max_spares, 8, 5)
+
+        ##
+        ## get_raid_superblock_size
+        ##
+        self.assertEqual(mdraid.get_raid_superblock_size(256 * 1024), 128)
+        self.assertEqual(mdraid.get_raid_superblock_size(128 * 1024), 128)
+        self.assertEqual(mdraid.get_raid_superblock_size(64 * 1024), 64)
+        self.assertEqual(mdraid.get_raid_superblock_size(63 * 1024), 32)
+        self.assertEqual(mdraid.get_raid_superblock_size(10 * 1024), 8)
+        self.assertEqual(mdraid.get_raid_superblock_size(1024), 1)
+        self.assertEqual(mdraid.get_raid_superblock_size(1023), 0)
+        self.assertEqual(mdraid.get_raid_superblock_size(512), 0)
+
+        self.assertEqual(mdraid.get_raid_superblock_size(257, "version"),
+           mdraid.MD_SUPERBLOCK_SIZE)
+
+        ##
+        ## get_member_space
+        ##
+        self.assertEqual(mdraid.get_member_space(1024, 2, 0), 513 * 2)
+        self.assertEqual(mdraid.get_member_space(1024, 2, 1), 1025 * 2)
+        self.assertEqual(mdraid.get_member_space(1024, 3, 4), 513 * 3)
+        self.assertEqual(mdraid.get_member_space(1024, 3, 5), 513 * 3)
+        self.assertEqual(mdraid.get_member_space(1024, 4, 6), 513 * 4)
+        self.assertEqual(mdraid.get_member_space(1024, 5, 10), 513 * 5)
 
         # fail
         # unsupported raid
-        self.assertRaises(ValueError, mdraid.get_raid_max_spares, 8, 5)
+        self.assertRaisesRegexp(errors.MDRaidError,
+           "invalid raid level",
+           mdraid.get_member_space, 1024, 0)
+
+        # fail
+        # not enough disks
+        self.assertRaisesRegexp(errors.MDRaidError,
+           "requires at least",
+           mdraid.get_member_space, 1024, 0, 0)
+
+        ##
+        ## isRaid
+        ##
+        self.assertTrue(mdraid.isRaid(0, "RAID0"))
+        self.assertFalse(mdraid.isRaid(6, "RAID0"))
+
+        # fail
+        # invalid raid
+        self.assertRaisesRegexp(errors.MDRaidError,
+           "invalid raid level",
+           mdraid.isRaid, 7, "RAID")
+
+        ##
+        ## raidLevel
+        ##
+        self.assertEqual(mdraid.raidLevel("RAID0"), 0)
+
+        # fail
+        # invalid raid
+        self.assertRaisesRegexp(errors.MDRaidError,
+           "invalid raid level",
+           mdraid.raidLevel, "RAID")
+
+        ##
+        ## raidLevelString
+        ##
+        self.assertEqual(mdraid.raidLevelString(0), "raid0")
+
+        # fail
+        # invalid constant
+        self.assertRaisesRegexp(errors.MDRaidError,
+           "invalid raid level constant",
+          mdraid.raidLevelString, -1)
+
+class MDRaidAsRootTestCase(baseclass.DevicelibsTestCase):
+
+    @unittest.skipUnless(os.geteuid() == 0, "requires root privileges")
+    def testMDRaidAsRoot(self):
+        _LOOP_DEV0 = self._loopMap[self._LOOP_DEVICES[0]]
+        _LOOP_DEV1 = self._loopMap[self._LOOP_DEVICES[1]]
 
         ##
         ## mdcreate
@@ -80,34 +153,29 @@ class MDRaidTestCase(baseclass.DevicelibsTestCase):
         ##
         ## mdactivate
         ##
-        # pass
-        self.assertEqual(mdraid.mdactivate("/dev/md0", [_LOOP_DEV0, _LOOP_DEV1], super_minor=0), None)
-        # wait for raid to settle
-        time.sleep(2)
-
-        # fail
-        self.assertRaises(mdraid.MDRaidError, mdraid.mdactivate, "/not/existing/md", super_minor=1)
-        # requires super_minor or uuid
-        self.assertRaises(ValueError, mdraid.mdactivate, "/dev/md1")
+        self.assertRaises(mdraid.MDRaidError, mdraid.mdactivate, "/not/existing/md", uuid=32)
+        # requires uuid
+        self.assertRaises(mdraid.MDRaidError, mdraid.mdactivate, "/dev/md1")
 
         ##
         ## mddestroy
         ##
         # pass
-        # deactivate first
-        self.assertEqual(mdraid.mddeactivate("/dev/md0"), None)
-
         self.assertEqual(mdraid.mddestroy(_LOOP_DEV0), None)
         self.assertEqual(mdraid.mddestroy(_LOOP_DEV1), None)
 
-        # fail
-        # not a component
-        self.assertRaises(mdraid.MDRaidError, mdraid.mddestroy, "/dev/md0")
-        self.assertRaises(mdraid.MDRaidError, mdraid.mddestroy, "/not/existing/device")
+        # pass
+        # Note that these should fail because mdadm is unable to locate the
+        # device. The mdadm Kill function does return 2, but the mdadm process
+        # returns 0 for both tests.
+        self.assertIsNone(mdraid.mddestroy("/dev/md0"))
+        self.assertIsNone(mdraid.mddestroy("/not/existing/device"))
 
 
 def suite():
-    return unittest.TestLoader().loadTestsFromTestCase(MDRaidTestCase)
+    suite1 = unittest.TestLoader().loadTestsFromTestCase(MDRaidTestCase)
+    suite2 = unittest.TestLoader().loadTestsFromTestCase(MDRaidAsRootTestCase)
+    return unittest.TestSuite([suite1, suite2])
 
 
 if __name__ == "__main__":
diff --git a/tests/devicelibs_test/mpath_test.py b/tests/devicelibs_test/mpath_test.py
deleted file mode 100755
index 91ee10d..0000000
--- a/tests/devicelibs_test/mpath_test.py
+++ /dev/null
@@ -1,86 +0,0 @@
-#!/usr/bin/python
-import mock
-
-class MPathTestCase(mock.TestCase):
-
-    # creating devices, user_friendly_names set to yes
-    output1 = """\
-create: mpathb (1ATA     ST3120026AS                                         5M) undef ATA,ST3120026AS
-size=112G features='0' hwhandler='0' wp=undef
-`-+- policy='round-robin 0' prio=1 status=undef
-  `- 2:0:0:0 sda 8:0  undef ready running
-create: mpatha (36006016092d21800703762872c60db11) undef DGC,RAID 5
-size=10G features='1 queue_if_no_path' hwhandler='1 emc' wp=undef
-`-+- policy='round-robin 0' prio=2 status=undef
-  |- 6:0:0:0 sdb 8:16 undef ready running
-  `- 7:0:0:0 sdc 8:32 undef ready running\
-"""
-
-    # listing existing devices, user_friendly_names set to yes
-    output2 = """\
-mpathb (3600a0b800067fcc9000001f34d23ff88) dm-1 IBM,1726-4xx  FAStT
-size=100G features='0' hwhandler='1 rdac' wp=rw
-`-+- policy='round-robin 0' prio=-1 status=active
-  |- 1:0:0:0 sda 8:0  active undef running
-  `- 2:0:0:0 sdc 8:32 active undef running
-mpatha (3600a0b800067fabc000067694d23fe6e) dm-0 IBM,1726-4xx  FAStT
-size=100G features='0' hwhandler='1 rdac' wp=rw
-`-+- policy='round-robin 0' prio=-1 status=active
-  |- 1:0:0:1 sdb 8:16 active undef running
-  `- 2:0:0:1 sdd 8:48 active undef running
-"""
-
-    # creating devices, user_friendly_names set to no
-    output3 = """\
-create: 3600a0b800067fabc000067694d23fe6e undef IBM,1726-4xx  FAStT
-size=100G features='1 queue_if_no_path' hwhandler='1 rdac' wp=undef
-`-+- policy='round-robin 0' prio=6 status=undef
-  |- 1:0:0:1 sdb 8:16 undef ready running
-  `- 2:0:0:1 sdd 8:48 undef ready running
-create: 3600a0b800067fcc9000001f34d23ff88 undef IBM,1726-4xx  FAStT
-size=100G features='1 queue_if_no_path' hwhandler='1 rdac' wp=undef
-`-+- policy='round-robin 0' prio=3 status=undef
-  |- 1:0:0:0 sda 8:0  undef ready running
-  `- 2:0:0:0 sdc 8:32 undef ready running\
-"""
-
-    # listing existing devices, user_friendly_names set to no
-    output4 = """\
-3600a0b800067fcc9000001f34d23ff88 dm-1 IBM,1726-4xx  FAStT
-size=100G features='0' hwhandler='1 rdac' wp=rw
-`-+- policy='round-robin 0' prio=-1 status=active
-  |- 1:0:0:0 sda 8:0  active undef running
-  `- 2:0:0:0 sdc 8:32 active undef running
-3600a0b800067fabc000067694d23fe6e dm-0 IBM,1726-4xx  FAStT
-size=100G features='0' hwhandler='1 rdac' wp=rw
-`-+- policy='round-robin 0' prio=-1 status=active
-  |- 1:0:0:1 sdb 8:16 active undef running
-  `- 2:0:0:1 sdd 8:48 active undef running
-"""
-
-    def setUp(self):
-        self.setupModules(
-            ['_isys', 'logging', 'anaconda_log', 'block'])
-
-    def tearDown(self):
-        self.tearDownModules()
-
-    def testParse(self):
-        from blivet.devicelibs import mpath
-        topology = mpath.parseMultipathOutput(self.output1)
-        self.assertEqual(topology,
-                         {'mpatha':['sdb','sdc'], 'mpathb':['sda']})
-        topology = mpath.parseMultipathOutput(self.output2)
-        self.assertEqual(topology,
-                         {'mpathb':['sda','sdc'], 'mpatha':['sdb', 'sdd']})
-        topology = mpath.parseMultipathOutput(self.output3)
-        self.assertEqual(topology,
-                         {'3600a0b800067fabc000067694d23fe6e' : ['sdb','sdd'],
-                          '3600a0b800067fcc9000001f34d23ff88' : ['sda', 'sdc']})
-        topology = mpath.parseMultipathOutput(self.output4)
-        self.assertEqual(topology,
-                         {'3600a0b800067fabc000067694d23fe6e' : ['sdb','sdd'],
-                          '3600a0b800067fcc9000001f34d23ff88' : ['sda', 'sdc']})
-
-def suite():
-    return unittest.TestLoader().loadTestsFromTestCase(MPathTestCase)
diff --git a/tests/devicelibs_test/swap_test.py b/tests/devicelibs_test/swap_test.py
index 6df47ad..a71c1af 100755
--- a/tests/devicelibs_test/swap_test.py
+++ b/tests/devicelibs_test/swap_test.py
@@ -1,18 +1,17 @@
 #!/usr/bin/python
 import baseclass
+import os
 import unittest
-from mock import acceptance
 
 class SwapTestCase(baseclass.DevicelibsTestCase):
 
+    @unittest.skipUnless(os.geteuid() == 0, "requires root privileges")
     def testSwap(self):
         _LOOP_DEV0 = self._loopMap[self._LOOP_DEVICES[0]]
         _LOOP_DEV1 = self._loopMap[self._LOOP_DEVICES[1]]
 
         import blivet.devicelibs.swap as swap
 
-    @acceptance
-    def testSwap(self):
         ##
         ## mkswap
         ##
diff --git a/tests/devices_test.py b/tests/devices_test.py
new file mode 100644
index 0000000..76e29eb
--- /dev/null
+++ b/tests/devices_test.py
@@ -0,0 +1,511 @@
+#!/usr/bin/python
+
+import unittest
+
+from mock import Mock
+
+import blivet
+
+from blivet.errors import DeviceError
+
+from blivet.devices import Device
+from blivet.devices import BTRFSDevice
+from blivet.devices import BTRFSSubVolumeDevice
+from blivet.devices import BTRFSVolumeDevice
+from blivet.devices import MDRaidArrayDevice
+from blivet.devices import OpticalDevice
+from blivet.devices import StorageDevice
+from blivet.devices import mdraid
+from blivet.devicelibs import btrfs
+
+class DeviceStateTestCase(unittest.TestCase):
+    """A class which implements a simple method of checking the state
+       of a device object.
+    """
+
+    def setUp(self):
+        self._state_functions = []
+
+    def stateCheck(self, device, **kwargs):
+        """Checks the current state of a device by means of its
+           fields or properties.
+
+           Every kwarg should be a key which is a field or property
+           of a Device and a value which is a function of
+           two parameters and should call the appropriate assert* functions.
+           These values override those in the state_functions dict.
+
+           If the value is None, then the test starts the debugger instead.
+        """
+        self.longMessage = True
+        for k,v in self._state_functions.items():
+            if kwargs.has_key(k):
+                key = kwargs[k]
+                if key is None:
+                    import pdb
+                    pdb.set_trace()
+                    getattr(device, k)
+                else:
+                    kwargs[k](getattr(device, k), k)
+            else:
+                v(getattr(device, k), k)
+
+class MDRaidArrayDeviceTestCase(DeviceStateTestCase):
+    """Note that these tests postdate the code that they test.
+       Therefore, they capture the behavior of the code as it is now,
+       not necessarily its intended or correct behavior. See the initial
+       commit message for this file for further details.
+    """
+
+    def setUp(self):
+        self._state_functions = {
+           "createBitmap" : lambda x,m: self.assertTrue(x, m),
+           "currentSize" : lambda x, m: self.assertEqual(x, 0, m),
+           "description" : lambda x, m: self.assertEqual(x, "MDRAID set (unknown level)", m),
+           "devices" : lambda x, m: self.assertEqual(x, [], m),
+           "exists" : self.assertFalse,
+           "format" : self.assertIsNotNone,
+           "formatArgs" : lambda x, m: self.assertEqual(x, [], m),
+           "formatClass" : self.assertIsNotNone,
+           "isDisk" : self.assertFalse,
+           "level" : self.assertIsNone,
+           "major" : lambda x, m: self.assertEqual(x, 0, m),
+           "maxSize" : lambda x, m: self.assertEqual(x, 0, m),
+           "mediaPresent" : self.assertFalse,
+           "metadataVersion" : lambda x, m: self.assertEqual(x, "default", m),
+           "minor" : lambda x, m: self.assertEqual(x, 0, m),
+           "parents" : lambda x, m: self.assertEqual(x, [], m),
+           "path" : lambda x, m: self.assertRegexpMatches(x, "^/dev", m),
+           "partitionable" : self.assertFalse,
+           "rawArraySize" : lambda x, m: self.assertEqual(x, 0, m),
+           "resizable" : self.assertFalse,
+           "size" : lambda x, m: self.assertEqual(x, 0, m),
+           "smallestMember" : lambda x, m: self.assertIsNone(x, m),
+           "spares" : lambda x, m: self.assertEqual(x, 0, m),
+           "status" : self.assertFalse,
+           "superBlockSize" : lambda x, m: self.assertEqual(x, 0, m),
+           "sysfsPath" : lambda x, m: self.assertEqual(x, "", m),
+           "targetSize" : lambda x, m: self.assertEqual(x, 0, m),
+           "uuid" : self.assertIsNone,
+           "memberDevices" : lambda x, m: self.assertEqual(x, 0, m),
+           "totalDevices" : lambda x, m: self.assertEqual(x, 0, m),
+           "type" : lambda x, m: self.assertEqual(x, "mdarray", m) }
+
+        self.dev1 = MDRaidArrayDevice("dev1", level="container")
+        self.dev2 = MDRaidArrayDevice("dev2", level="raid0")
+        self.dev3 = MDRaidArrayDevice("dev3", level="raid1")
+        self.dev4 = MDRaidArrayDevice("dev4", level="raid4")
+        self.dev5 = MDRaidArrayDevice("dev5", level="raid5")
+        self.dev6 = MDRaidArrayDevice("dev6", level="raid6")
+        self.dev7 = MDRaidArrayDevice("dev7", level="raid10")
+
+        self.dev8 = MDRaidArrayDevice("dev8", level=1, exists=True)
+        self.dev9 = MDRaidArrayDevice(
+           "dev9",
+           level="raid0",
+           parents=[
+              MDRaidArrayDevice("parent", level="container"),
+              MDRaidArrayDevice("other", level=0)])
+
+        self.dev10 = MDRaidArrayDevice(
+           "dev10",
+           level="raid0",
+           size=32)
+
+        self.dev11 = MDRaidArrayDevice(
+           "dev11",
+           level=1,
+           parents=[
+              MDRaidArrayDevice("parent", level="container"),
+              MDRaidArrayDevice("other", level="raid0")],
+           size=32)
+
+        self.dev12 = MDRaidArrayDevice(
+           "dev12",
+           level=1,
+           memberDevices=2,
+           parents=[
+              Mock(**{"type": "mdcontainer",
+                      "size": 4}),
+              Mock(**{"size": 2})],
+           size=32,
+           totalDevices=2)
+
+        self.dev13 = MDRaidArrayDevice(
+           "dev13",
+           level=0,
+           memberDevices=3,
+           parents=[
+              Mock(**{"size": 4}),
+              Mock(**{"size": 2})],
+           size=32,
+           totalDevices=3)
+
+        self.dev14 = MDRaidArrayDevice(
+           "dev14",
+           level=4,
+           memberDevices=3,
+           parents=[
+              Mock(**{"size": 4}),
+              Mock(**{"size": 2}),
+              Mock(**{"size": 2})],
+           totalDevices=3)
+
+        self.dev15 = MDRaidArrayDevice(
+           "dev15",
+           level=5,
+           memberDevices=3,
+           parents=[
+              Mock(**{"size": 4}),
+              Mock(**{"size": 2}),
+              Mock(**{"size": 2})],
+           totalDevices=3)
+
+        self.dev16 = MDRaidArrayDevice(
+           "dev16",
+           level=6,
+           memberDevices=4,
+           parents=[
+              Mock(**{"size": 4}),
+              Mock(**{"size": 4}),
+              Mock(**{"size": 2}),
+              Mock(**{"size": 2})],
+           totalDevices=4)
+
+        self.dev17 = MDRaidArrayDevice(
+           "dev17",
+           level=10,
+           memberDevices=4,
+           parents=[
+              Mock(**{"size": 4}),
+              Mock(**{"size": 4}),
+              Mock(**{"size": 2}),
+              Mock(**{"size": 2})],
+           totalDevices=4)
+
+        self.dev18 = MDRaidArrayDevice(
+           "dev18",
+           level=10,
+           memberDevices=4,
+           parents=[
+              Mock(**{"size": 4}),
+              Mock(**{"size": 4}),
+              Mock(**{"size": 2}),
+              Mock(**{"size": 2})],
+           totalDevices=5)
+
+
+    def testMDRaidArrayDeviceInit(self, *args, **kwargs):
+        """Tests the state of a MDRaidArrayDevice after initialization.
+           For some combinations of arguments the initializer will throw
+           an exception.
+        """
+
+        ##
+        ## level tests
+        ##
+        self.stateCheck(self.dev1,
+                        description=lambda x, m: self.assertEqual(x, "BIOS RAID container", m),
+                        level=lambda x, m: self.assertEqual(x, "container", m),
+                        type=lambda x, m: self.assertEqual(x, "mdcontainer", m))
+        self.stateCheck(self.dev2,
+                        description=lambda x, m: self.assertEqual(x, "MDRAID set (stripe)", m),
+                        createBitmap=self.assertFalse,
+                        level=lambda x, m: self.assertEqual(x, 0, m))
+        self.stateCheck(self.dev3,
+                        description=lambda x, m: self.assertEqual(x, "MDRAID set (mirror)", m),
+                        level=lambda x, m: self.assertEqual(x, 1, m))
+        self.stateCheck(self.dev4,
+                        description=lambda x, m: self.assertEqual(x, "MDRAID set (raid4)", m),
+                        level=lambda x, m: self.assertEqual(x, 4, m))
+        self.stateCheck(self.dev5,
+                        description=lambda x, m: self.assertEqual(x, "MDRAID set (raid5)", m),
+                        level=lambda x, m: self.assertEqual(x, 5, m))
+        self.stateCheck(self.dev6,
+                        description=lambda x, m: self.assertEqual(x, "MDRAID set (raid6)", m),
+                        level=lambda x, m: self.assertEqual(x, 6, m))
+        self.stateCheck(self.dev7,
+                        description=lambda x, m: self.assertEqual(x, "MDRAID set (raid10)", m),
+                        level=lambda x, m: self.assertEqual(x, 10, m))
+
+        ##
+        ## existing device tests
+        ##
+        self.stateCheck(self.dev8,
+                        description = lambda x, m: self.assertEqual(x, "MDRAID set (mirror)", m),
+                        exists=self.assertTrue,
+                        level=lambda x, m: self.assertEqual(x, 1, m),
+                        metadataVersion=self.assertIsNone)
+
+
+        ##
+        ## mdbiosraidarray tests
+        ##
+        self.stateCheck(self.dev9,
+                        createBitmap=self.assertFalse,
+                        description=lambda x, m: self.assertEqual(x, "BIOS RAID set (stripe)", m),
+                        devices=lambda x, m: self.assertEqual(len(x), 2, m),
+                        isDisk=self.assertTrue,
+                        level=lambda x, m: self.assertEqual(x, 0, m),
+                        mediaPresent=self.assertTrue,
+                        parents=lambda x, m: self.assertNotEqual(x, [], m),
+                        partitionable=self.assertTrue,
+                        smallestMember=self.assertIsNotNone,
+                        type = lambda x, m: self.assertEqual(x, "mdbiosraidarray", m))
+
+        ##
+        ## size tests
+        ##
+        self.stateCheck(self.dev10,
+                        createBitmap=self.assertFalse,
+                        description=lambda x, m: self.assertEqual(x, "MDRAID set (stripe)", m),
+                        level=lambda x, m: self.assertEqual(x, 0, m),
+                        targetSize=lambda x, m: self.assertEqual(x, 32, m))
+
+        self.stateCheck(self.dev11,
+                        description=lambda x, m: self.assertEqual(x, "BIOS RAID set (mirror)", m),
+                        devices=lambda x, m: self.assertEqual(len(x), 2, m),
+                        isDisk=self.assertTrue,
+                        level=lambda x, m: self.assertEqual(x, 1, m),
+                        mediaPresent=self.assertTrue,
+                        parents=lambda x, m: self.assertNotEqual(x, [], m),
+                        partitionable=self.assertTrue,
+                        smallestMember=self.assertIsNotNone,
+                        targetSize=lambda x, m: self.assertEqual(x, 32, m),
+                        totalDevices=lambda x, m: self.assertEqual(x, 2, m),
+                        type=lambda x, m: self.assertEqual(x, "mdbiosraidarray", m))
+
+        ##
+        ## rawArraySize tests
+        ##
+        self.stateCheck(self.dev12,
+                        description=lambda x, m: self.assertEqual(x, "BIOS RAID set (mirror)", m),
+                        devices=lambda x, m: self.assertEqual(len(x), 2, m),
+                        isDisk=self.assertTrue,
+                        level=lambda x, m: self.assertEqual(x, 1, m),
+                        mediaPresent=self.assertTrue,
+                        memberDevices=lambda x, m: self.assertEqual(x, 2, m),
+                        parents=lambda x, m: self.assertNotEqual(x, [], m),
+                        partitionable=self.assertTrue,
+                        rawArraySize=lambda x, m: self.assertEqual(x, 2, m),
+                        smallestMember=self.assertIsNotNone,
+                        targetSize=lambda x, m: self.assertEqual(x, 32, m),
+                        totalDevices=lambda x, m: self.assertEqual(x, 2, m),
+                        type = lambda x, m: self.assertEqual(x, "mdbiosraidarray", m))
+
+        self.stateCheck(self.dev13,
+                        createBitmap=self.assertFalse,
+                        description=lambda x, m: self.assertEqual(x, "MDRAID set (stripe)", m),
+                        devices=lambda x, m: self.assertEqual(len(x), 2, m),
+                        level=lambda x, m: self.assertEqual(x, 0, m),
+                        memberDevices=lambda x, m: self.assertEqual(x, 3, m),
+                        parents=lambda x, m: self.assertNotEqual(x, [], m),
+                        rawArraySize=lambda x, m: self.assertEqual(x, 6, m),
+                        size=lambda x, m: self.assertEqual(x, 6, m),
+                        smallestMember=self.assertIsNotNone,
+                        targetSize=lambda x, m: self.assertEqual(x, 32, m),
+                        totalDevices=lambda x, m: self.assertEqual(x, 3, m))
+
+        self.stateCheck(self.dev14,
+                        description=lambda x, m: self.assertEqual(x, "MDRAID set (raid4)", m),
+                        devices=lambda x, m: self.assertEqual(len(x), 3, m),
+                        level=lambda x, m: self.assertEqual(x, 4, m),
+                        memberDevices=lambda x, m: self.assertEqual(x, 3, m),
+                        parents=lambda x, m: self.assertNotEqual(x, [], m),
+                        rawArraySize=lambda x, m: self.assertEqual(x, 4, m),
+                        size=lambda x, m: self.assertEqual(x, 4, m),
+                        smallestMember=self.assertIsNotNone,
+                        totalDevices=lambda x, m: self.assertEqual(x, 3, m))
+
+        self.stateCheck(self.dev15,
+                        description=lambda x, m: self.assertEqual(x, "MDRAID set (raid5)", m),
+                        devices=lambda x, m: self.assertEqual(len(x), 3, m),
+                        level=lambda x, m: self.assertEqual(x, 5, m),
+                        memberDevices=lambda x, m: self.assertEqual(x, 3, m),
+                        parents=lambda x, m: self.assertNotEqual(x, [], m),
+                        rawArraySize=lambda x, m: self.assertEqual(x, 4, m),
+                        size=lambda x, m: self.assertEqual(x, 4, m),
+                        smallestMember=self.assertIsNotNone,
+                        totalDevices=lambda x, m: self.assertEqual(x, 3, m))
+
+        self.stateCheck(self.dev16,
+                        description=lambda x, m: self.assertEqual(x, "MDRAID set (raid6)", m),
+                        devices=lambda x, m: self.assertEqual(len(x), 4, m),
+                        level=lambda x, m: self.assertEqual(x, 6, m),
+                        memberDevices=lambda x, m: self.assertEqual(x, 4, m),
+                        parents=lambda x, m: self.assertNotEqual(x, [], m),
+                        rawArraySize=lambda x, m: self.assertEqual(x, 4, m),
+                        size=lambda x, m: self.assertEqual(x, 4, m),
+                        smallestMember=self.assertIsNotNone,
+                        totalDevices=lambda x, m: self.assertEqual(x, 4, m))
+
+        self.stateCheck(self.dev17,
+                        description=lambda x, m: self.assertEqual(x, "MDRAID set (raid10)", m),
+                        devices=lambda x, m: self.assertEqual(len(x), 4, m),
+                        level=lambda x, m: self.assertEqual(x, 10, m),
+                        memberDevices=lambda x, m: self.assertEqual(x, 4, m),
+                        parents=lambda x, m: self.assertNotEqual(x, [], m),
+                        rawArraySize=lambda x, m: self.assertEqual(x, 4, m),
+                        size=lambda x, m: self.assertEqual(x, 4, m),
+                        smallestMember=self.assertIsNotNone,
+                        totalDevices=lambda x, m: self.assertEqual(x, 4, m))
+
+        self.stateCheck(self.dev18,
+                        description=lambda x, m: self.assertEqual(x, "MDRAID set (raid10)", m),
+                        devices=lambda x, m: self.assertEqual(len(x), 4, m),
+                        level=lambda x, m: self.assertEqual(x, 10, m),
+                        memberDevices=lambda x, m: self.assertEqual(x, 4, m),
+                        parents=lambda x, m: self.assertNotEqual(x, [], m),
+                        rawArraySize=lambda x, m: self.assertEqual(x, 4, m),
+                        size=lambda x, m: self.assertEqual(x, 4, m),
+                        smallestMember=self.assertIsNotNone,
+                        spares=lambda x, m: self.assertEqual(x, 1, m),
+                        totalDevices=lambda x, m: self.assertEqual(x, 5, m))
+
+        self.assertRaisesRegexp(mdraid.MDRaidError,
+                                "invalid raid level",
+                                MDRaidArrayDevice,
+                                "dev")
+
+        self.assertRaisesRegexp(mdraid.MDRaidError,
+                                "invalid raid level",
+                                MDRaidArrayDevice,
+                                "dev",
+                                level="raid2")
+
+        self.assertRaisesRegexp(mdraid.MDRaidError,
+                                "invalid raid level",
+                                MDRaidArrayDevice,
+                                "dev",
+                                parents=[Device("parent")])
+
+        self.assertRaisesRegexp(DeviceError,
+                                "A RAID0 set requires at least 2 members",
+                                MDRaidArrayDevice,
+                                "dev",
+                                level="raid0",
+                                parents=[Device("parent")])
+
+        self.assertRaisesRegexp(mdraid.MDRaidError,
+                                "invalid raid level descriptor junk",
+                                MDRaidArrayDevice,
+                                "dev",
+                                level="junk")
+
+        self.assertRaisesRegexp(ValueError,
+                                "memberDevices cannot be greater than totalDevices",
+                                MDRaidArrayDevice,
+                                "dev",
+                                level=0,
+                                memberDevices=2)
+
+
+    def testMDRaidArrayDeviceMethods(self, *args, **kwargs):
+        """Test for method calls on initialized MDRaidDevices."""
+        with self.assertRaisesRegexp(mdraid.MDRaidError, "invalid raid level" ):
+            self.dev7.level = "junk"
+
+        with self.assertRaisesRegexp(mdraid.MDRaidError, "invalid raid level" ):
+            self.dev7.level = None
+
+class BTRFSDeviceTestCase(DeviceStateTestCase):
+    """Note that these tests postdate the code that they test.
+       Therefore, they capture the behavior of the code as it is now,
+       not necessarily its intended or correct behavior. See the initial
+       commit message for this file for further details.
+    """
+
+    def setUp(self):
+        self._state_functions = {
+           "currentSize" : lambda x, m: self.assertEqual(x, 0, m),
+           "exists" : self.assertFalse,
+           "format" : self.assertIsNotNone,
+           "formatArgs" : lambda x, m: self.assertEqual(x, [], m),
+           "fstabSpec" : self.assertIsNotNone,
+           "isDisk" : self.assertFalse,
+           "major" : lambda x, m: self.assertEqual(x, 0, m),
+           "maxSize" : lambda x, m: self.assertEqual(x, 0, m),
+           "mediaPresent" : self.assertTrue,
+           "minor" : lambda x, m: self.assertEqual(x, 0, m),
+           "parents" : lambda x, m: self.assertEqual(x, [], m),
+           "partitionable" : self.assertFalse,
+           "path" : lambda x, m: self.assertRegexpMatches(x, "^/dev", m),
+           "resizable" : lambda x, m: self.assertFalse,
+           "size" : lambda x, m: self.assertEqual(x, 0, m),
+           "status" : self.assertFalse,
+           "sysfsPath" : lambda x, m: self.assertEqual(x, "", m),
+           "targetSize" : lambda x, m: self.assertEqual(x, 0, m),
+           "type" : lambda x, m: self.assertEqual(x, "btrfs", m),
+           "uuid" : self.assertIsNone,
+           "vol_id" : lambda x, m: self.assertEqual(x, btrfs.MAIN_VOLUME_ID, m)}
+
+        self.dev1 = BTRFSVolumeDevice("dev1",
+           parents=[OpticalDevice("deva",
+              format=blivet.formats.getFormat("btrfs"))])
+
+        self.dev2 = BTRFSSubVolumeDevice("dev2", parents=[self.dev1])
+
+        dev = StorageDevice("deva",
+           format=blivet.formats.getFormat("btrfs"),
+           size=32)
+        self.dev3 = BTRFSVolumeDevice("dev3",
+           parents=[dev])
+
+    def testBTRFSDeviceInit(self, *args, **kwargs):
+        """Tests the state of a BTRFSDevice after initialization.
+           For some combinations of arguments the initializer will throw
+           an exception.
+        """
+
+        self.stateCheck(self.dev1,
+           parents=lambda x, m: self.assertEqual(len(x), 1, m),
+           type=lambda x, m: self.assertEqual(x, "btrfs volume", m))
+
+        self.stateCheck(self.dev3,
+           currentSize=lambda x, m: self.assertEqual(x, 32, m),
+           maxSize=lambda x, m: self.assertEqual(x, 32, m),
+           parents=lambda x, m: self.assertEqual(len(x), 1, m),
+           size=lambda x, m: self.assertEqual(x, 32, m),
+           type=lambda x, m: self.assertEqual(x, "btrfs volume", m))
+
+        self.assertRaisesRegexp(ValueError,
+           "BTRFSDevice.*must have at least one parent",
+           BTRFSVolumeDevice,
+           "dev")
+
+        self.assertRaisesRegexp(ValueError,
+           "member device.*is not BTRFS",
+           BTRFSVolumeDevice,
+           "dev", parents=[OpticalDevice("deva")])
+
+        parents=[OpticalDevice("deva",
+           format=blivet.formats.getFormat("btrfs"))]
+        self.assertRaisesRegexp(DeviceError,
+           "btrfs subvolume.*must be a BTRFSDevice",
+           BTRFSSubVolumeDevice,
+           "dev1", parents=parents)
+
+    def testBTRFSDeviceMethods(self, *args, **kwargs):
+        """Test for method calls on initialized BTRFS Devices."""
+        # volumes do not have ancestor volumes
+        with self.assertRaises(AttributeError):
+            self.dev1.volume
+
+        # subvolumes do not have default subvolumes
+        with self.assertRaises(AttributeError):
+            self.dev2.defaultSubVolume
+
+        self.assertIsNotNone(self.dev2.volume)
+
+        # size
+        with self.assertRaisesRegexp(RuntimeError,
+           "cannot directly set size of btrfs volume"):
+            self.dev1.size = 32
+
+def suite():
+    return unittest.TestLoader().loadTestsFromTestCase(MDRaidArrayDeviceTestCase)
+
+
+if __name__ == "__main__":
+    unittest.main()
+
diff --git a/tests/formats_test/init_test.py b/tests/formats_test/init_test.py
new file mode 100644
index 0000000..0e174e8
--- /dev/null
+++ b/tests/formats_test/init_test.py
@@ -0,0 +1,34 @@
+#!/usr/bin/python
+import unittest
+
+import blivet.formats as formats
+import blivet.errors as errors
+
+class FormatsTestCase(unittest.TestCase):
+
+    def setUp(self):
+        pass
+
+    def testFormatsMethods(self):
+        ##
+        ## get_device_format_class
+        ##
+        format_pairs = {
+           None : formats.DeviceFormat,
+           "bogus" : formats.DeviceFormat,
+           "biosboot" : formats.biosboot.BIOSBoot,
+           "BIOS Boot" : formats.biosboot.BIOSBoot,
+           "nodev" : formats.fs.NoDevFS
+           }
+        format_names = format_pairs.keys()
+        format_values = [format_pairs[k] for k in format_names]
+
+        self.assertEqual(
+           [formats.get_device_format_class(x) for x in format_names],
+           format_values)
+
+        for name in format_names:
+            self.assertIs(formats.getFormat(name).__class__, format_pairs[name])
+
+def suite():
+    return unittest.TestLoader().loadTestsFromTestCase(FormatsTestCase)
diff --git a/tests/partitioning_test.py b/tests/partitioning_test.py
index 9d4b4c6..5c840ff 100644
--- a/tests/partitioning_test.py
+++ b/tests/partitioning_test.py
@@ -5,9 +5,6 @@ from mock import Mock
 
 import parted
 
-import pyanaconda.anaconda_log
-pyanaconda.anaconda_log.init()
-
 from blivet.partitioning import getNextPartitionType
 
 # disklabel-type-specific constants
diff --git a/tests/storagetestcase.py b/tests/storagetestcase.py
index 695bb89..9e082cb 100644
--- a/tests/storagetestcase.py
+++ b/tests/storagetestcase.py
@@ -5,10 +5,8 @@ from mock import Mock
 
 import parted
 
-import pyanaconda.anaconda_log
-pyanaconda.anaconda_log.init()
+import pyanaconda
 
-import pyanaconda.iutil
 import blivet as blivet
 from blivet.formats import getFormat
 
diff --git a/tests/udev_test.py b/tests/udev_test.py
index 4bac44f..2aa20a0 100644
--- a/tests/udev_test.py
+++ b/tests/udev_test.py
@@ -104,9 +104,6 @@ class UdevTest(unittest.TestCase):
         import blivet.udev
         # For this one we're accessing the real uevent file (twice).
         path = '/devices/virtual/block/loop1'
-        if not os.path.exists("/sys" + path):
-            self.skipTest("this test requires the presence of /dev/loop1")
-
         info = {'sysfs_path': path}
         for line in open('/sys' + path + '/uevent').readlines():
             (name, equals, value) = line.strip().partition("=")
-- 
1.8.3.1



More information about the anaconda-patches mailing list