[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