[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