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")