[blivet:master 02/13] Use context manager with assertRaises*() tests.
mulhern
amulhern at redhat.com
Wed Jul 9 17:16:18 UTC 2014
Equivalent expressions that use a context manager are a lot easier to parse.
---
tests/devicefactory_test.py | 26 +++---
tests/devicelibs_test/btrfs_test.py | 47 ++++-------
tests/devicelibs_test/crypto_test.py | 74 ++++++-----------
tests/devicelibs_test/lvm_test.py | 96 ++++++++++++----------
tests/devicelibs_test/mdraid_test.py | 15 ++--
tests/devicelibs_test/raid_test.py | 37 +++++----
tests/devicelibs_test/swap_test.py | 15 ++--
tests/devices_test.py | 150 ++++++++++++-----------------------
tests/formats_test/fslabeling.py | 35 ++++----
tests/parentlist_test.py | 6 +-
tests/size_test.py | 3 +-
11 files changed, 218 insertions(+), 286 deletions(-)
diff --git a/tests/devicefactory_test.py b/tests/devicefactory_test.py
index 4b0e315..f32a9c7 100644
--- a/tests/devicefactory_test.py
+++ b/tests/devicefactory_test.py
@@ -28,20 +28,17 @@ class MDFactoryTestCase(unittest.TestCase):
raid_level=0)
def testMDFactory(self):
- self.assertRaisesRegexp(devicefactory.DeviceFactoryError,
- "must have some RAID level",
- devicefactory.get_device_factory,
- self.b,
- devicefactory.DEVICE_TYPE_MD,
- Size("1 GiB"))
+ with self.assertRaisesRegexp(devicefactory.DeviceFactoryError, "must have some RAID level"):
+ devicefactory.get_device_factory(
+ self.b,
+ devicefactory.DEVICE_TYPE_MD,
+ Size("1 GiB"))
- self.assertRaisesRegexp(RaidError,
- "requires at least",
- self.factory1._get_device_space)
+ with self.assertRaisesRegexp(RaidError, "requires at least"):
+ self.factory1._get_device_space()
- self.assertRaisesRegexp(RaidError,
- "requires at least",
- self.factory1._configure)
+ with self.assertRaisesRegexp(RaidError, "requires at least"):
+ self.factory1._configure()
self.assertEqual(self.factory1.container_list, [])
@@ -49,9 +46,8 @@ class MDFactoryTestCase(unittest.TestCase):
self.assertIsNotNone(self.factory1._get_new_device(parents=[]))
- self.assertRaisesRegexp(RaidError,
- "requires at least",
- self.factory2._get_device_space)
+ with self.assertRaisesRegexp(RaidError, "requires at least"):
+ self.factory2._get_device_space()
self.assertEqual(self.factory2.container_list, [])
diff --git a/tests/devicelibs_test/btrfs_test.py b/tests/devicelibs_test/btrfs_test.py
index c75b3d8..42e2156 100755
--- a/tests/devicelibs_test/btrfs_test.py
+++ b/tests/devicelibs_test/btrfs_test.py
@@ -66,36 +66,27 @@ class BTRFSAsRootTestCase1(loopbackedtestcase.LoopBackedTestCase):
## create_volume
##
# no devices specified
- self.assertRaisesRegexp(ValueError,
- "no devices specified",
- btrfs.create_volume, [], data=0)
+ with 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"])
+ with self.assertRaisesRegexp(ValueError, "one or more specified devices not present"):
+ btrfs.create_volume(["/not/existing/device"])
# bad data
- self.assertRaisesRegexp(BTRFSError,
- "1",
- btrfs.create_volume,
- [_LOOP_DEV0], data="RaID7")
+ with self.assertRaisesRegexp(BTRFSError, "1"):
+ btrfs.create_volume([_LOOP_DEV0], data="RaID7")
# bad metadata
- self.assertRaisesRegexp(BTRFSError,
- "1",
- btrfs.create_volume,
- [_LOOP_DEV0], metadata="RaID7")
+ with self.assertRaisesRegexp(BTRFSError, "1"):
+ btrfs.create_volume([_LOOP_DEV0], metadata="RaID7")
# pass
self.assertEqual(btrfs.create_volume(self.loopDevices), 0)
# already created
- self.assertRaisesRegexp(BTRFSError,
- "1",
- btrfs.create_volume,
- [_LOOP_DEV0], metadata="RaID7")
+ with self.assertRaisesRegexp(BTRFSError, "1"):
+ btrfs.create_volume([_LOOP_DEV0], metadata="RaID7")
def testMkfsDefaults(self):
_LOOP_DEV0 = self.loopDevices[0]
@@ -156,16 +147,12 @@ class BTRFSAsRootTestCase2(BTRFSMountDevice):
self.assertNotIn("SV1", [v['path'] for v in subvolumes])
# if the subvolume is already gone, an error is raised by btrfs
- self.assertRaisesRegexp(BTRFSError,
- "1",
- btrfs.delete_subvolume,
- self.mountpoint, "SV1")
+ with self.assertRaisesRegexp(BTRFSError, "1"):
+ btrfs.delete_subvolume(self.mountpoint, "SV1")
# if the subvolume is already there, an error is raise by btrfs
- self.assertRaisesRegexp(BTRFSError,
- "1",
- btrfs.create_subvolume,
- self.mountpoint, "SV2")
+ with self.assertRaisesRegexp(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)
@@ -187,10 +174,8 @@ class BTRFSAsRootTestCase3(loopbackedtestcase.LoopBackedTestCase):
data and metadata levels are specified differently, but not if
they are unspecified.
"""
- self.assertRaises(
- BTRFSError,
- btrfs.create_volume,
- self.loopDevices, data="single", metadata="dup")
+ with self.assertRaises(BTRFSError):
+ btrfs.create_volume(self.loopDevices, data="single", metadata="dup")
self.assertEqual(btrfs.create_volume(self.loopDevices), 0)
if __name__ == "__main__":
diff --git a/tests/devicelibs_test/crypto_test.py b/tests/devicelibs_test/crypto_test.py
index 9bf4af6..cd7de7a 100755
--- a/tests/devicelibs_test/crypto_test.py
+++ b/tests/devicelibs_test/crypto_test.py
@@ -39,10 +39,8 @@ class CryptoTestCase(loopbackedtestcase.LoopBackedTestCase):
##
# pass
self.assertEqual(crypto.is_luks(_LOOP_DEV0), -22)
- self.assertRaisesRegexp(IOError,
- "Device cannot be opened",
- crypto.is_luks,
- "/not/existing/device")
+ with self.assertRaisesRegexp(IOError, "Device cannot be opened"):
+ crypto.is_luks("/not/existing/device")
##
## luks_format
@@ -57,22 +55,16 @@ class CryptoTestCase(loopbackedtestcase.LoopBackedTestCase):
os.close(handle)
# format with key file
- self.assertRaisesRegexp(ValueError,
- "requires passphrase",
- crypto.luks_format,
- _LOOP_DEV1, key_file=keyfile)
+ with self.assertRaisesRegexp(ValueError, "requires passphrase"):
+ crypto.luks_format(_LOOP_DEV1, key_file=keyfile)
# fail
- self.assertRaisesRegexp(IOError,
- "Device cannot be opened",
- crypto.luks_format,
- "/not/existing/device", passphrase="secret", cipher="aes-cbc-essiv:sha256", key_size=256)
+ with self.assertRaisesRegexp(IOError, "Device cannot be opened"):
+ crypto.luks_format("/not/existing/device", passphrase="secret", cipher="aes-cbc-essiv:sha256", key_size=256)
# no passhprase or key file
- self.assertRaisesRegexp(ValueError,
- "requires passphrase",
- crypto.luks_format,
- _LOOP_DEV1, cipher="aes-cbc-essiv:sha256", key_size=256)
+ with self.assertRaisesRegexp(ValueError, "requires passphrase"):
+ crypto.luks_format(_LOOP_DEV1, cipher="aes-cbc-essiv:sha256", key_size=256)
##
## is_luks
@@ -88,43 +80,31 @@ class CryptoTestCase(loopbackedtestcase.LoopBackedTestCase):
self.assertEqual(crypto.luks_add_key(_LOOP_DEV0, new_passphrase="another-secret", passphrase="secret"), None)
# fail
- self.assertRaisesRegexp(CryptoError,
- "luks add key failed",
- crypto.luks_add_key,
- _LOOP_DEV0, new_passphrase="another-secret", passphrase="wrong-passphrase")
+ with self.assertRaisesRegexp(CryptoError, "luks add key failed"):
+ crypto.luks_add_key(_LOOP_DEV0, new_passphrase="another-secret", passphrase="wrong-passphrase")
##
## luks_remove_key
##
# fail
- self.assertRaisesRegexp(CryptoError,
- "luks remove key failed",
- crypto.luks_remove_key,
- _LOOP_DEV0, del_passphrase="another-secret", passphrase="wrong-pasphrase")
+ with self.assertRaisesRegexp(CryptoError, "luks remove key failed"):
+ crypto.luks_remove_key(_LOOP_DEV0, del_passphrase="another-secret", passphrase="wrong-pasphrase")
# pass
self.assertEqual(crypto.luks_remove_key(_LOOP_DEV0, del_passphrase="another-secret", passphrase="secret"), None)
# fail
- self.assertRaisesRegexp(IOError,
- "Device cannot be opened",
- crypto.luks_open,
- "/not/existing/device", "another-crypted", passphrase="secret")
+ with self.assertRaisesRegexp(IOError, "Device cannot be opened"):
+ crypto.luks_open("/not/existing/device", "another-crypted", passphrase="secret")
# no passhprase or key file
- self.assertRaisesRegexp(ValueError,
- "luks_format requires passphrase",
- crypto.luks_open,
- _LOOP_DEV1, "another-crypted")
-
- self.assertRaisesRegexp(IOError,
- "Device cannot be opened",
- crypto.luks_status,
- "another-crypted")
- self.assertRaisesRegexp(IOError,
- "Device cannot be opened",
- crypto.luks_close,
- "wrong-name")
+ with self.assertRaisesRegexp(ValueError, "luks_format requires passphrase"):
+ crypto.luks_open(_LOOP_DEV1, "another-crypted")
+
+ with self.assertRaisesRegexp(IOError, "Device cannot be opened"):
+ crypto.luks_status("another-crypted")
+ with self.assertRaisesRegexp(IOError, "Device cannot be opened"):
+ crypto.luks_close("wrong-name")
# cleanup
os.unlink(keyfile)
@@ -190,14 +170,10 @@ class CryptoTestCase2(loopbackedtestcase.LoopBackedTestCase):
self.assertEqual(crypto.luks_close(_name1), None)
# already closed
- self.assertRaisesRegexp(IOError,
- "Device cannot be opened",
- crypto.luks_close,
- "crypted")
- self.assertRaisesRegexp(IOError,
- "Device cannot be opened",
- crypto.luks_close,
- "encrypted")
+ with self.assertRaisesRegexp(IOError, "Device cannot be opened"):
+ crypto.luks_close("crypted")
+ with self.assertRaisesRegexp(IOError, "Device cannot be opened"):
+ crypto.luks_close("encrypted")
class CryptoTestCase3(unittest.TestCase):
def testPassphrase(self):
diff --git a/tests/devicelibs_test/lvm_test.py b/tests/devicelibs_test/lvm_test.py
index 3afce8b..b7000ea 100755
--- a/tests/devicelibs_test/lvm_test.py
+++ b/tests/devicelibs_test/lvm_test.py
@@ -77,7 +77,8 @@ class LVMAsRootTestCase(loopbackedtestcase.LoopBackedTestCase):
self.assertEqual(lvm.pvcreate(dev), None)
# fail
- self.assertRaises(LVMError, lvm.pvcreate, "/not/existing/device")
+ with self.assertRaises(LVMError):
+ lvm.pvcreate("/not/existing/device")
##
## pvresize
@@ -88,10 +89,8 @@ class LVMAsRootTestCase(loopbackedtestcase.LoopBackedTestCase):
self.assertEqual(lvm.pvresize(dev, Size("100MiB")), None)
# fail
- self.assertRaisesRegexp(LVMError,
- "pvresize failed",
- lvm.pvresize,
- "/not/existing/device", Size("50MiB"))
+ with self.assertRaisesRegexp(LVMError, "pvresize failed"):
+ lvm.pvresize("/not/existing/device", Size("50MiB"))
##
## vgcreate
@@ -100,20 +99,14 @@ class LVMAsRootTestCase(loopbackedtestcase.LoopBackedTestCase):
self.assertEqual(lvm.vgcreate(self._vg_name, self.loopDevices, Size("4MiB")), None)
# fail
- self.assertRaisesRegexp(LVMError,
- "vgcreate failed",
- lvm.vgcreate,
- "another-vg", ["/not/existing/device"], Size("4MiB"))
+ with self.assertRaisesRegexp(LVMError, "vgcreate failed"):
+ lvm.vgcreate("another-vg", ["/not/existing/device"], Size("4MiB"))
# vg already exists
- self.assertRaisesRegexp(LVMError,
- "vgcreate failed",
- lvm.vgcreate,
- self._vg_name, [_LOOP_DEV0], Size("4MiB"))
+ with self.assertRaisesRegexp(LVMError, "vgcreate failed"):
+ lvm.vgcreate(self._vg_name, [_LOOP_DEV0], Size("4MiB"))
# pe size must be power of 2
- self.assertRaisesRegexp(LVMError,
- "vgcreate failed",
- lvm.vgcreate,
- "another-vg", [_LOOP_DEV0], Size("5MiB"))
+ with self.assertRaisesRegexp(LVMError, "vgcreate failed"):
+ lvm.vgcreate("another-vg", [_LOOP_DEV0], Size("5MiB"))
##
## vgdeactivate
@@ -122,7 +115,8 @@ class LVMAsRootTestCase(loopbackedtestcase.LoopBackedTestCase):
self.assertEqual(lvm.vgdeactivate(self._vg_name), None)
# fail
- self.assertRaises(LVMError, lvm.vgdeactivate, "wrong-vg-name")
+ with self.assertRaises(LVMError):
+ lvm.vgdeactivate("wrong-vg-name")
##
## vgreduce
@@ -131,8 +125,10 @@ class LVMAsRootTestCase(loopbackedtestcase.LoopBackedTestCase):
self.assertEqual(lvm.vgreduce(self._vg_name, _LOOP_DEV1), None)
# fail
- self.assertRaises(LVMError, lvm.vgreduce, "wrong-vg-name", _LOOP_DEV1)
- self.assertRaises(LVMError, lvm.vgreduce, self._vg_name, "/not/existing/device")
+ with self.assertRaises(LVMError):
+ lvm.vgreduce("wrong-vg-name", _LOOP_DEV1)
+ with self.assertRaises(LVMError):
+ lvm.vgreduce(self._vg_name, "/not/existing/device")
##
## vgactivate
@@ -141,7 +137,8 @@ class LVMAsRootTestCase(loopbackedtestcase.LoopBackedTestCase):
self.assertEqual(lvm.vgactivate(self._vg_name), None)
# fail
- self.assertRaises(LVMError, lvm.vgactivate, "wrong-vg-name")
+ with self.assertRaises(LVMError):
+ lvm.vgactivate("wrong-vg-name")
##
## pvinfo
@@ -160,7 +157,8 @@ class LVMAsRootTestCase(loopbackedtestcase.LoopBackedTestCase):
self.assertEqual(lvm.vginfo(self._vg_name)['LVM2_PV_COUNT'], "1")
# fail
- self.assertRaises(LVMError, lvm.vginfo, "wrong-vg-name")
+ with self.assertRaises(LVMError):
+ lvm.vginfo("wrong-vg-name")
##
## lvcreate
@@ -169,7 +167,8 @@ class LVMAsRootTestCase(loopbackedtestcase.LoopBackedTestCase):
self.assertEqual(lvm.lvcreate(self._vg_name, self._lv_name, Size("10MiB")), None)
# fail
- self.assertRaises(LVMError, lvm.lvcreate, "wrong-vg-name", "another-lv", Size("10MiB"))
+ with self.assertRaises(LVMError):
+ lvm.lvcreate("wrong-vg-name", "another-lv", Size("10MiB"))
##
## lvdeactivate
@@ -178,9 +177,12 @@ class LVMAsRootTestCase(loopbackedtestcase.LoopBackedTestCase):
self.assertEqual(lvm.lvdeactivate(self._vg_name, self._lv_name), None)
# fail
- self.assertRaises(LVMError, lvm.lvdeactivate, self._vg_name, "wrong-lv-name")
- self.assertRaises(LVMError, lvm.lvdeactivate, "wrong-vg-name", self._lv_name)
- self.assertRaises(LVMError, lvm.lvdeactivate, "wrong-vg-name", "wrong-lv-name")
+ with self.assertRaises(LVMError):
+ lvm.lvdeactivate(self._vg_name, "wrong-lv-name")
+ with self.assertRaises(LVMError):
+ lvm.lvdeactivate("wrong-vg-name", self._lv_name)
+ with self.assertRaises(LVMError):
+ lvm.lvdeactivate("wrong-vg-name", "wrong-lv-name")
##
## lvresize
@@ -189,11 +191,15 @@ class LVMAsRootTestCase(loopbackedtestcase.LoopBackedTestCase):
self.assertEqual(lvm.lvresize(self._vg_name, self._lv_name, Size("60MiB")), None)
# fail
- self.assertRaises(LVMError, lvm.lvresize, self._vg_name, "wrong-lv-name", Size("80MiB"))
- self.assertRaises(LVMError, lvm.lvresize, "wrong-vg-name", self._lv_name, Size("80MiB"))
- self.assertRaises(LVMError, lvm.lvresize, "wrong-vg-name", "wrong-lv-name", Size("80MiB"))
+ with self.assertRaises(LVMError):
+ lvm.lvresize(self._vg_name, "wrong-lv-name", Size("80MiB"))
+ with self.assertRaises(LVMError):
+ lvm.lvresize("wrong-vg-name", self._lv_name, Size("80MiB"))
+ with self.assertRaises(LVMError):
+ lvm.lvresize("wrong-vg-name", "wrong-lv-name", Size("80MiB"))
# changing to same size
- self.assertRaises(LVMError, lvm.lvresize, self._vg_name, self._lv_name, Size("60MiB"))
+ with self.assertRaises(LVMError):
+ lvm.lvresize(self._vg_name, self._lv_name, Size("60MiB"))
##
## lvactivate
@@ -202,9 +208,12 @@ class LVMAsRootTestCase(loopbackedtestcase.LoopBackedTestCase):
self.assertEqual(lvm.lvactivate(self._vg_name, self._lv_name), None)
# fail
- self.assertRaises(LVMError, lvm.lvactivate, self._vg_name, "wrong-lv-name")
- self.assertRaises(LVMError, lvm.lvactivate, "wrong-vg-name", self._lv_name)
- self.assertRaises(LVMError, lvm.lvactivate, "wrong-vg-name", "wrong-lv-name")
+ with self.assertRaises(LVMError):
+ lvm.lvactivate(self._vg_name, "wrong-lv-name")
+ with self.assertRaises(LVMError):
+ lvm.lvactivate("wrong-vg-name", self._lv_name)
+ with self.assertRaises(LVMError):
+ lvm.lvactivate("wrong-vg-name", "wrong-lv-name")
##
## lvs
@@ -234,11 +243,15 @@ class LVMAsRootTestCase(loopbackedtestcase.LoopBackedTestCase):
self.assertEqual(lvm.lvremove(self._vg_name, self._lv_name), None)
# fail
- self.assertRaises(LVMError, lvm.lvremove, self._vg_name, "wrong-lv-name")
- self.assertRaises(LVMError, lvm.lvremove, "wrong-vg-name", self._lv_name)
- self.assertRaises(LVMError, lvm.lvremove, "wrong-vg-name", "wrong-lv-name")
+ with self.assertRaises(LVMError):
+ lvm.lvremove(self._vg_name, "wrong-lv-name")
+ with self.assertRaises(LVMError):
+ lvm.lvremove("wrong-vg-name", self._lv_name)
+ with self.assertRaises(LVMError):
+ lvm.lvremove("wrong-vg-name", "wrong-lv-name")
# lv already removed
- self.assertRaises(LVMError, lvm.lvremove, self._vg_name, self._lv_name)
+ with self.assertRaises(LVMError):
+ lvm.lvremove(self._vg_name, self._lv_name)
##
## vgremove
@@ -247,9 +260,11 @@ class LVMAsRootTestCase(loopbackedtestcase.LoopBackedTestCase):
self.assertEqual(lvm.vgremove(self._vg_name), None)
# fail
- self.assertRaises(LVMError, lvm.vgremove, "wrong-vg-name")
+ with self.assertRaises(LVMError):
+ lvm.vgremove("wrong-vg-name")
# vg already removed
- self.assertRaises(LVMError, lvm.vgremove, self._vg_name)
+ with self.assertRaises(LVMError):
+ lvm.vgremove(self._vg_name)
##
## pvremove
@@ -259,7 +274,8 @@ class LVMAsRootTestCase(loopbackedtestcase.LoopBackedTestCase):
self.assertEqual(lvm.pvremove(dev), None)
# fail
- self.assertRaises(LVMError, lvm.pvremove, "/not/existing/device")
+ with self.assertRaises(LVMError):
+ lvm.pvremove("/not/existing/device")
# pv already removed
self.assertEqual(lvm.pvremove(_LOOP_DEV0), None)
diff --git a/tests/devicelibs_test/mdraid_test.py b/tests/devicelibs_test/mdraid_test.py
index d2ad45d..f744e66 100755
--- a/tests/devicelibs_test/mdraid_test.py
+++ b/tests/devicelibs_test/mdraid_test.py
@@ -76,7 +76,8 @@ class MDRaidAsRootTestCase(loopbackedtestcase.LoopBackedTestCase):
time.sleep(2)
# fail
- self.assertRaises(MDRaidError, mdraid.mdcreate, "/dev/md1", "raid1", ["/not/existing/dev0", "/not/existing/dev1"])
+ with self.assertRaises(MDRaidError):
+ mdraid.mdcreate("/dev/md1", "raid1", ["/not/existing/dev0", "/not/existing/dev1"])
##
## mddeactivate
@@ -85,7 +86,8 @@ class MDRaidAsRootTestCase(loopbackedtestcase.LoopBackedTestCase):
self.assertEqual(mdraid.mddeactivate(self._dev_name), None)
# fail
- self.assertRaises(MDRaidError, mdraid.mddeactivate, "/not/existing/md")
+ with self.assertRaises(MDRaidError):
+ mdraid.mddeactivate("/not/existing/md")
##
## mdadd
@@ -94,14 +96,17 @@ class MDRaidAsRootTestCase(loopbackedtestcase.LoopBackedTestCase):
# TODO
# fail
- self.assertRaises(MDRaidError, mdraid.mdadd, self._dev_name, "/not/existing/device")
+ with self.assertRaises(MDRaidError):
+ mdraid.mdadd(self._dev_name, "/not/existing/device")
##
## mdactivate
##
- self.assertRaises(MDRaidError, mdraid.mdactivate, "/not/existing/md", array_uuid=32)
+ with self.assertRaises(MDRaidError):
+ mdraid.mdactivate("/not/existing/md", array_uuid=32)
# requires uuid
- self.assertRaises(MDRaidError, mdraid.mdactivate, "/dev/md1")
+ with self.assertRaises(MDRaidError):
+ mdraid.mdactivate("/dev/md1")
##
## mddestroy
diff --git a/tests/devicelibs_test/raid_test.py b/tests/devicelibs_test/raid_test.py
index 75c45f1..ef778c4 100644
--- a/tests/devicelibs_test/raid_test.py
+++ b/tests/devicelibs_test/raid_test.py
@@ -14,9 +14,8 @@ class RaidTestCase(unittest.TestCase):
def testRaid(self):
- self.assertRaisesRegexp(TypeError,
- "Can't instantiate abstract class",
- raid.ErsatzRAID)
+ with self.assertRaisesRegexp(TypeError, "Can't instantiate abstract class"):
+ raid.ErsatzRAID()
##
## get_min_members
@@ -53,7 +52,8 @@ class RaidTestCase(unittest.TestCase):
self.assertIs(self.levels.raidLevel("stripe"), raid.RAID0)
self.assertIs(self.levels.raidLevel(raid.RAID0), raid.RAID0)
- self.assertRaises(errors.RaidError, self.levels.raidLevel, "bogus")
+ with self.assertRaises(errors.RaidError):
+ self.levels.raidLevel("bogus")
##
## get_max_spares
@@ -61,7 +61,8 @@ class RaidTestCase(unittest.TestCase):
self.assertEqual(raid.RAID0.get_max_spares(1000), 0)
self.assertEqual(raid.RAID1.get_max_spares(2), 0)
- self.assertRaises(errors.RaidError, raid.RAID0.get_max_spares, 0)
+ with self.assertRaises(errors.RaidError):
+ raid.RAID0.get_max_spares(0)
##
## get_base_member_size
@@ -75,10 +76,10 @@ class RaidTestCase(unittest.TestCase):
self.assertEqual(raid.RAID10.get_base_member_size(4,5), 2)
self.assertEqual(raid.RAID10.get_base_member_size(5,5), 3)
- self.assertRaises(errors.RaidError, raid.RAID10.get_base_member_size,
- 4, 3)
- self.assertRaises(errors.RaidError, raid.RAID10.get_base_member_size,
- -4, 4)
+ with self.assertRaises(errors.RaidError):
+ raid.RAID10.get_base_member_size(4, 3)
+ with self.assertRaises(errors.RaidError):
+ raid.RAID10.get_base_member_size(-4, 4)
##
## get_net_array_size
@@ -103,7 +104,8 @@ class RaidTestCase(unittest.TestCase):
self.assertEqual(raid.RAID5.get_recommended_stride(4), 48)
self.assertIsNone(raid.Linear.get_recommended_stride(4))
- self.assertRaises(errors.RaidError, raid.RAID10.get_recommended_stride, 1)
+ with self.assertRaises(errors.RaidError):
+ raid.RAID10.get_recommended_stride(1)
##
## size
@@ -142,14 +144,11 @@ class RaidTestCase(unittest.TestCase):
##
## __init__
##
- self.assertRaisesRegexp(errors.RaidError,
- "invalid RAID level",
- self.levels_none.raidLevel, 10)
+ with self.assertRaisesRegexp(errors.RaidError, "invalid RAID level"):
+ self.levels_none.raidLevel(10)
- self.assertRaisesRegexp(errors.RaidError,
- "invalid RAID level",
- self.levels_some.raidLevel, 10)
+ with self.assertRaisesRegexp(errors.RaidError, "invalid RAID level"):
+ self.levels_some.raidLevel(10)
- self.assertRaisesRegexp(errors.RaidError,
- "invalid standard RAID level descriptor",
- raid.RAIDLevels, ["raid3.1415"])
+ with self.assertRaisesRegexp(errors.RaidError, "invalid standard RAID level descriptor"):
+ raid.RAIDLevels(["raid3.1415"])
diff --git a/tests/devicelibs_test/swap_test.py b/tests/devicelibs_test/swap_test.py
index 4862eca..1b8e1aa 100755
--- a/tests/devicelibs_test/swap_test.py
+++ b/tests/devicelibs_test/swap_test.py
@@ -20,7 +20,8 @@ class SwapTestCase(loopbackedtestcase.LoopBackedTestCase):
self.assertEqual(swap.mkswap(_LOOP_DEV0, "swap"), None)
# fail
- self.assertRaises(SwapError, swap.mkswap, "/not/existing/device")
+ with self.assertRaises(SwapError):
+ swap.mkswap("/not/existing/device")
##
## swapon
@@ -29,9 +30,11 @@ class SwapTestCase(loopbackedtestcase.LoopBackedTestCase):
self.assertEqual(swap.swapon(_LOOP_DEV0, 1), None)
# fail
- self.assertRaises(SwapError, swap.swapon, "/not/existing/device")
+ with self.assertRaises(SwapError):
+ swap.swapon("/not/existing/device")
# not a swap partition
- self.assertRaises(SwapError, swap.swapon, _LOOP_DEV1)
+ with self.assertRaises(SwapError):
+ swap.swapon(_LOOP_DEV1)
# pass
# make another swap
@@ -61,9 +64,11 @@ class SwapTestCase(loopbackedtestcase.LoopBackedTestCase):
self.assertEqual(swap.swapoff(_LOOP_DEV0), None)
# fail
- self.assertRaises(SwapError, swap.swapoff, "/not/existing/device")
+ with self.assertRaises(SwapError):
+ swap.swapoff("/not/existing/device")
# already off
- self.assertRaises(SwapError, swap.swapoff, _LOOP_DEV0)
+ with self.assertRaises(SwapError):
+ swap.swapoff(_LOOP_DEV0)
if __name__ == "__main__":
unittest.main()
diff --git a/tests/devices_test.py b/tests/devices_test.py
index a572857..0e4073d 100644
--- a/tests/devices_test.py
+++ b/tests/devices_test.py
@@ -373,45 +373,28 @@ class MDRaidArrayDeviceTestCase(DeviceStateTestCase):
spares=lambda x, m: self.assertEqual(x, 1, m),
totalDevices=lambda x, m: self.assertEqual(x, 5, m))
- self.assertRaisesRegexp(RaidError,
- "invalid RAID level",
- MDRaidArrayDevice,
- "dev")
-
- self.assertRaisesRegexp(RaidError,
- "invalid RAID level",
- MDRaidArrayDevice,
- "dev",
- level="raid2")
-
- self.assertRaisesRegexp(RaidError,
- "invalid RAID level",
- MDRaidArrayDevice,
- "dev",
- parents=[StorageDevice("parent",
- fmt=getFormat("mdmember"))])
-
- self.assertRaisesRegexp(DeviceError,
- "set requires at least 2 members",
- MDRaidArrayDevice,
- "dev",
- level="raid0",
- parents=[StorageDevice("parent",
- fmt=getFormat("mdmember"))])
-
- self.assertRaisesRegexp(RaidError,
- "invalid RAID level descriptor junk",
- MDRaidArrayDevice,
- "dev",
- level="junk")
-
- self.assertRaisesRegexp(ValueError,
- "memberDevices cannot be greater than totalDevices",
- MDRaidArrayDevice,
- "dev",
- level=0,
- memberDevices=2)
+ with self.assertRaisesRegexp(RaidError, "invalid RAID level"):
+ MDRaidArrayDevice("dev")
+ with self.assertRaisesRegexp(RaidError, "invalid RAID level"):
+ MDRaidArrayDevice("dev", level="raid2")
+
+ with self.assertRaisesRegexp(RaidError, "invalid RAID level"):
+ MDRaidArrayDevice(
+ "dev",
+ parents=[StorageDevice("parent", fmt=getFormat("mdmember"))])
+
+ with self.assertRaisesRegexp(DeviceError, "set requires at least 2 members"):
+ MDRaidArrayDevice(
+ "dev",
+ level="raid0",
+ parents=[StorageDevice("parent", fmt=getFormat("mdmember"))])
+
+ with self.assertRaisesRegexp(RaidError, "invalid RAID level descriptor junk"):
+ MDRaidArrayDevice("dev", level="junk")
+
+ with self.assertRaisesRegexp(ValueError, "memberDevices cannot be greater than totalDevices"):
+ MDRaidArrayDevice("dev", level=0, memberDevices=2)
def testMDRaidArrayDeviceMethods(self):
"""Test for method calls on initialized MDRaidDevices."""
@@ -482,22 +465,16 @@ class BTRFSDeviceTestCase(DeviceStateTestCase):
size=lambda x, m: self.assertEqual(x, Size("32 MiB"), m),
type=lambda x, m: self.assertEqual(x, "btrfs volume", m))
- self.assertRaisesRegexp(ValueError,
- "BTRFSDevice.*must have at least one parent",
- BTRFSVolumeDevice,
- "dev")
+ with self.assertRaisesRegexp(ValueError, "BTRFSDevice.*must have at least one parent"):
+ BTRFSVolumeDevice("dev")
- self.assertRaisesRegexp(ValueError,
- "member has wrong format",
- BTRFSVolumeDevice,
- "dev", parents=[OpticalDevice("deva")])
+ with self.assertRaisesRegexp(ValueError, "member has wrong format"):
+ BTRFSVolumeDevice("dev", parents=[OpticalDevice("deva")])
- parents=[OpticalDevice("deva",
- fmt=blivet.formats.getFormat("btrfs"))]
- self.assertRaisesRegexp(DeviceError,
- "btrfs subvolume.*must be a BTRFSDevice",
- BTRFSSubVolumeDevice,
- "dev1", parents=parents)
+ with self.assertRaisesRegexp(DeviceError, "btrfs subvolume.*must be a BTRFSDevice"):
+ fmt = blivet.formats.getFormat("btrfs")
+ device = OpticalDevice("deva", fmt=fmt)
+ BTRFSSubVolumeDevice("dev1", parents=[device])
self.assertEqual(self.dev1.isleaf, False)
self.assertEqual(self.dev1.direct, True)
@@ -521,34 +498,25 @@ class BTRFSDeviceTestCase(DeviceStateTestCase):
self.assertIsNotNone(self.dev2.volume)
# size
- with self.assertRaisesRegexp(RuntimeError,
- "cannot directly set size of btrfs volume"):
+ with self.assertRaisesRegexp(RuntimeError, "cannot directly set size of btrfs volume"):
self.dev1.size = 32
def testBTRFSSnapShotDeviceInit(self):
parents = [StorageDevice("p1", fmt=blivet.formats.getFormat("btrfs"))]
vol = BTRFSVolumeDevice("test", parents=parents)
- self.assertRaisesRegexp(ValueError,
- "non-existent btrfs snapshots must have a source",
- BTRFSSnapShotDevice,
- "snap1", parents=[vol])
+ with self.assertRaisesRegexp(ValueError, "non-existent btrfs snapshots must have a source"):
+ BTRFSSnapShotDevice("snap1", parents=[vol])
- self.assertRaisesRegexp(ValueError,
- "btrfs snapshot source must already exist",
- BTRFSSnapShotDevice,
- "snap1", parents=[vol], source=vol)
+ with self.assertRaisesRegexp(ValueError, "btrfs snapshot source must already exist"):
+ BTRFSSnapShotDevice("snap1", parents=[vol], source=vol)
- self.assertRaisesRegexp(ValueError,
- "btrfs snapshot source must be a btrfs subvolume",
- BTRFSSnapShotDevice,
- "snap1", parents=[vol], source=parents[0])
+ with self.assertRaisesRegexp(ValueError, "btrfs snapshot source must be a btrfs subvolume"):
+ BTRFSSnapShotDevice("snap1", parents=[vol], source=parents[0])
parents2 = [StorageDevice("p1", fmt=blivet.formats.getFormat("btrfs"))]
vol2 = BTRFSVolumeDevice("test2", parents=parents2, exists=True)
- self.assertRaisesRegexp(ValueError,
- ".*snapshot and source must be in the same volume",
- BTRFSSnapShotDevice,
- "snap1", parents=[vol], source=vol2)
+ with self.assertRaisesRegexp(ValueError, ".*snapshot and source must be in the same volume"):
+ BTRFSSnapShotDevice("snap1", parents=[vol], source=vol2)
vol.exists = True
snap = BTRFSSnapShotDevice("snap1", parents=[vol], source=vol)
@@ -568,25 +536,17 @@ class LVMDeviceTest(unittest.TestCase):
lv = LVMLogicalVolumeDevice("testlv", parents=[vg],
fmt=blivet.formats.getFormat("xfs"))
- self.assertRaisesRegexp(ValueError,
- "lvm snapshot devices require an origin lv",
- LVMSnapShotDevice,
- "snap1", parents=[vg])
+ with self.assertRaisesRegexp(ValueError, "lvm snapshot devices require an origin lv"):
+ LVMSnapShotDevice("snap1", parents=[vg])
- self.assertRaisesRegexp(ValueError,
- "lvm snapshot origin volume must already exist",
- LVMSnapShotDevice,
- "snap1", parents=[vg], origin=lv)
+ with self.assertRaisesRegexp(ValueError, "lvm snapshot origin volume must already exist"):
+ LVMSnapShotDevice("snap1", parents=[vg], origin=lv)
- self.assertRaisesRegexp(ValueError,
- "lvm snapshot origin must be a logical volume",
- LVMSnapShotDevice,
- "snap1", parents=[vg], origin=pv)
+ with self.assertRaisesRegexp(ValueError, "lvm snapshot origin must be a logical volume"):
+ LVMSnapShotDevice("snap1", parents=[vg], origin=pv)
- self.assertRaisesRegexp(ValueError,
- "only existing vorigin snapshots are supported",
- LVMSnapShotDevice,
- "snap1", parents=[vg], vorigin=True)
+ with self.assertRaisesRegexp(ValueError, "only existing vorigin snapshots are supported"):
+ LVMSnapShotDevice("snap1", parents=[vg], vorigin=True)
lv.exists = True
snap1 = LVMSnapShotDevice("snap1", parents=[vg], origin=lv)
@@ -611,20 +571,14 @@ class LVMDeviceTest(unittest.TestCase):
thinlv = LVMThinLogicalVolumeDevice("thinlv", parents=[pool],
size=Size("200 MiB"))
- self.assertRaisesRegexp(ValueError,
- "lvm thin snapshots require an origin",
- LVMThinSnapShotDevice,
- "snap1", parents=[pool])
+ with self.assertRaisesRegexp(ValueError, "lvm thin snapshots require an origin"):
+ LVMThinSnapShotDevice("snap1", parents=[pool])
- self.assertRaisesRegexp(ValueError,
- "lvm snapshot origin volume must already exist",
- LVMThinSnapShotDevice,
- "snap1", parents=[pool], origin=thinlv)
+ with self.assertRaisesRegexp(ValueError, "lvm snapshot origin volume must already exist"):
+ LVMThinSnapShotDevice("snap1", parents=[pool], origin=thinlv)
- self.assertRaisesRegexp(ValueError,
- "lvm snapshot origin must be a logical volume",
- LVMThinSnapShotDevice,
- "snap1", parents=[pool], origin=pv)
+ with self.assertRaisesRegexp(ValueError, "lvm snapshot origin must be a logical volume"):
+ LVMThinSnapShotDevice("snap1", parents=[pool], origin=pv)
# now make the constructor succeed so we can test some properties
thinlv.exists = True
diff --git a/tests/formats_test/fslabeling.py b/tests/formats_test/fslabeling.py
index f91b323..22d74ee 100644
--- a/tests/formats_test/fslabeling.py
+++ b/tests/formats_test/fslabeling.py
@@ -39,14 +39,12 @@ class LabelingAsRoot(loopbackedtestcase.LoopBackedTestCase):
an_fs = self._fs_class(device=self.loopDevices[0], label=self._invalid_label)
self.assertIsNone(an_fs.create())
- self.assertRaisesRegexp(FSError,
- "no application to read label",
- an_fs.readLabel)
+ with self.assertRaisesRegexp(FSError, "no application to read label"):
+ an_fs.readLabel()
an_fs.label = "an fs"
- self.assertRaisesRegexp(FSError,
- "no application to set label for filesystem",
- an_fs.writeLabel)
+ with self.assertRaisesRegexp(FSError, "no application to set label for filesystem"):
+ an_fs.writeLabel()
def testCreating(self):
"""Create the filesystem when passing a valid label """
@@ -82,9 +80,8 @@ class LabelingWithRelabeling(LabelingAsRoot):
an_fs = self._fs_class(device=self.loopDevices[0], label=self._invalid_label)
self.assertIsNone(an_fs.create())
- self.assertRaisesRegexp(FSError,
- "no application to read label",
- an_fs.readLabel)
+ with self.assertRaisesRegexp(FSError, "no application to read label"):
+ an_fs.readLabel()
an_fs.label = "an fs"
self.assertIsNone(an_fs.writeLabel())
@@ -93,14 +90,12 @@ class LabelingWithRelabeling(LabelingAsRoot):
self.assertIsNone(an_fs.writeLabel())
an_fs.label = None
- self.assertRaisesRegexp(FSError,
- "default label",
- an_fs.writeLabel)
+ with self.assertRaisesRegexp(FSError, "default label"):
+ an_fs.writeLabel()
an_fs.label = self._invalid_label
- self.assertRaisesRegexp(FSError,
- "bad label format",
- an_fs.writeLabel)
+ with self.assertRaisesRegexp(FSError, "bad label format"):
+ an_fs.writeLabel()
class CompleteLabelingAsRoot(LabelingAsRoot):
"""Tests where it is possible to read the label and to relabel
@@ -132,14 +127,12 @@ class CompleteLabelingAsRoot(LabelingAsRoot):
self.assertEqual(an_fs.readLabel(), an_fs.label)
an_fs.label = None
- self.assertRaisesRegexp(FSError,
- "default label",
- an_fs.writeLabel)
+ with self.assertRaisesRegexp(FSError, "default label"):
+ an_fs.writeLabel()
an_fs.label = "root___filesystem"
- self.assertRaisesRegexp(FSError,
- "bad label format",
- an_fs.writeLabel)
+ with self.assertRaisesRegexp(FSError, "bad label format"):
+ an_fs.writeLabel()
def testCreating(self):
"""Create the filesystem when passing a valid label.
diff --git a/tests/parentlist_test.py b/tests/parentlist_test.py
index 3a9e97a..bce13a0 100644
--- a/tests/parentlist_test.py
+++ b/tests/parentlist_test.py
@@ -48,11 +48,13 @@ class ParentListTestCase(unittest.TestCase):
pl = ParentList(items=items, appendfunc=pre_add, removefunc=pre_remove)
- self.assertRaises(ValueError, pl.append, 33)
+ with self.assertRaises(ValueError):
+ pl.append(33)
pl.remove(4)
pl.remove(3)
- self.assertRaises(RuntimeError, pl.remove, 2)
+ with self.assertRaises(RuntimeError):
+ pl.remove(2)
def testDeviceParents(self):
""" Verify that Device.parents functions as expected. """
diff --git a/tests/size_test.py b/tests/size_test.py
index 993c64c..e2288e0 100644
--- a/tests/size_test.py
+++ b/tests/size_test.py
@@ -37,7 +37,8 @@ class SizeTestCase(unittest.TestCase):
self.assertEqual(zero, 0.0)
s = Size(500)
- self.assertRaises(SizePlacesError, s.humanReadable, places=-1)
+ with self.assertRaises(SizePlacesError):
+ s.humanReadable(places=-1)
self.assertEqual(s.humanReadable(places=0), "500 B")
--
1.9.3
More information about the anaconda-patches
mailing list