[blivet:master 9/9] Add a bunch of tests for mdadd.

mulhern amulhern at redhat.com
Mon Aug 4 15:56:56 UTC 2014


Signed-off-by: mulhern <amulhern at redhat.com>
---
 tests/devicelibs_test/mdraid_test.py | 178 ++++++++++++++++++++++++++---------
 tests/pylint/pylint-false-positives  |   1 +
 2 files changed, 136 insertions(+), 43 deletions(-)

diff --git a/tests/devicelibs_test/mdraid_test.py b/tests/devicelibs_test/mdraid_test.py
index e6fdf55..380d853 100755
--- a/tests/devicelibs_test/mdraid_test.py
+++ b/tests/devicelibs_test/mdraid_test.py
@@ -71,49 +71,141 @@ class MDRaidAsRootTestCase(loopbackedtestcase.LoopBackedTestCase):
 
         super(MDRaidAsRootTestCase, self).tearDown()
 
-class RAID0Test(MDRaidAsRootTestCase):
-
-    def __init__(self, methodName='runTest'):
-        super(RAID0Test, self).__init__(methodName=methodName, deviceSpec=[102400, 102400, 102400])
-
-    def testGrow(self):
-        self.assertIsNone(mdraid.mdcreate(self._dev_name, raid.RAID0, self.loopDevices[:2]))
-        time.sleep(2) # wait for raid to settle
-
-        # it is not possible to add a managed device to a non-redundant array,
-        # but it can be grown, by specifying the desired number of members
-        self.assertIsNone(mdraid.mdadd(self._dev_name, self.loopDevices[2], raid_devices=3))
-
-    def testGrowRAID1(self):
-        self.assertIsNone(mdraid.mdcreate(self._dev_name, raid.RAID1, self.loopDevices[:2]))
-        time.sleep(2) # wait for raid to settle
-
-        # a RAID1 array can be grown as well as a RAID0 array
-        self.assertIsNone(mdraid.mdadd(self._dev_name, self.loopDevices[2], raid_devices=3))
-
-    def testGrowTooBig(self):
-        self.assertIsNone(mdraid.mdcreate(self._dev_name, raid.RAID0, self.loopDevices[:2]))
-        time.sleep(2) # wait for raid to settle
-
-        # if more devices are specified than are available after the
-        # addition an error is raised
-        with self.assertRaises(MDRaidError):
-            mdraid.mdadd(self._dev_name, self.loopDevices[2], raid_devices=4)
-
-    def testGrowSmaller(self):
-        self.assertIsNone(mdraid.mdcreate(self._dev_name, raid.RAID0, self.loopDevices[:2]))
-        time.sleep(2) # wait for raid to settle
-
-        # it is ok to grow an array smaller than its devices
-        self.assertIsNone(mdraid.mdadd(self._dev_name, self.loopDevices[2], raid_devices=2))
-
-    def testGrowSimple(self):
-        self.assertIsNone(mdraid.mdcreate(self._dev_name, raid.RAID0, self.loopDevices[:2]))
-        time.sleep(2) # wait for raid to settle
-
-        # try to simply add a device and things go wrong
-        with self.assertRaises(MDRaidError):
-            mdraid.mdadd(self._dev_name, self.loopDevices[2])
+class TestCaseFactory(object):
+
+    @staticmethod
+    def _minMembersForCreation(level):
+        min_members = level.min_members
+        return min_members if min_members > 1 else 2
+
+class JustAddTestCaseFactory(TestCaseFactory):
+
+    @staticmethod
+    def makeClass(name, level):
+
+        def __init__(self, methodName='runTest'):
+            super(self.__class__, self).__init__(methodName=methodName, deviceSpec=[102400, 102400, 102400, 102400, 102400])
+            self.longMessage = True
+
+        def testAdd(self):
+            """ Tests adding, not growing, a device. """
+            initial_members = TestCaseFactory._minMembersForCreation(level)
+            self.assertIsNone(mdraid.mdcreate(self._dev_name, level, self.loopDevices[:initial_members]))
+            time.sleep(2) # wait for raid to settle
+
+            new_member = self.loopDevices[initial_members]
+
+            if level is raid.Container or level.has_redundancy():
+                info_pre = mdraid.mddetail(self._dev_name)
+                self.assertIsNone(mdraid.mdadd(self._dev_name, new_member))
+                info_post = mdraid.mddetail(self._dev_name)
+                keys = ['TOTAL DEVICES', 'WORKING DEVICES']
+                for k in keys:
+                    self.assertEqual(int(info_pre[k]) + 1, int(info_post[k]), msg="key: %s" % k)
+                if level is not raid.Container:
+                    keys = ['ACTIVE DEVICES', 'SPARE DEVICES']
+                    self.assertEqual(sum(int(info_pre[k]) for k in keys) + 1,
+                       sum(int(info_post[k]) for k in keys))
+                    self.assertEqual(info_pre['RAID DEVICES'], info_post['RAID DEVICES'])
+                    dev_info = mdraid.mdexamine(new_member)
+                    self.assertEqual(info_post['UUID'], dev_info['MD_UUID'])
+            else:
+                with self.assertRaises(MDRaidError):
+                    mdraid.mdadd(self._dev_name, new_member)
+
+        return type(
+           name,
+           (MDRaidAsRootTestCase,),
+           {
+              '__init__': __init__,
+              'testAdd': testAdd,
+           })
+
+class GrowTestCaseFactory(object):
+
+    @staticmethod
+    def makeClass(name, level):
+
+        def __init__(self, methodName='runTest'):
+            super(self.__class__, self).__init__(methodName=methodName, deviceSpec=[102400, 102400, 102400, 102400, 102400, 102400])
+            self.longMessage = True
+
+        def testGrow(self):
+            """ Tests growing a device by exactly 1. """
+            initial_members = TestCaseFactory._minMembersForCreation(level)
+            self.assertIsNone(mdraid.mdcreate(self._dev_name, level, self.loopDevices[:initial_members]))
+            time.sleep(3) # wait for raid to settle
+
+            new_member = self.loopDevices[initial_members]
+            info_pre = mdraid.mddetail(self._dev_name)
+
+            # for linear RAID the new number of devices must not be specified
+            # for all other levels the new number of devices must be specified
+            if level is raid.Linear:
+                with self.assertRaises(MDRaidError):
+                    mdraid.mdadd(self._dev_name, new_member, grow_mode=True, raid_devices=initial_members + 1)
+                self.assertIsNone(mdraid.mdadd(self._dev_name, new_member, grow_mode=True))
+            else:
+                with self.assertRaises(MDRaidError):
+                    mdraid.mdadd(self._dev_name, new_member, grow_mode=True)
+                self.assertIsNone(mdraid.mdadd(self._dev_name, new_member, grow_mode=True, raid_devices=initial_members + 1))
+
+            info_post = mdraid.mddetail(self._dev_name)
+            keys = ['RAID DEVICES', 'TOTAL DEVICES', 'WORKING DEVICES']
+            for k in keys:
+                self.assertEqual(int(info_pre[k]) + 1, int(info_post[k]), msg="key: %s" % k)
+            if level is not raid.Container:
+                keys = ['ACTIVE DEVICES', 'SPARE DEVICES']
+                self.assertEqual(sum(int(info_pre[k]) for k in keys) + 1,
+                   sum(int(info_post[k]) for k in keys),
+                   msg="%s" % " + ".join(keys))
+                dev_info = mdraid.mdexamine(new_member)
+                self.assertEqual(info_post['UUID'], dev_info['MD_UUID'], msg="key: UUID")
+
+        def testGrowBig(self):
+            """ Test growing a device beyond its size. """
+            initial_members = TestCaseFactory._minMembersForCreation(level)
+            self.assertIsNone(mdraid.mdcreate(self._dev_name, level, self.loopDevices[:initial_members]))
+            time.sleep(3) # wait for raid to settle
+
+            new_member = self.loopDevices[initial_members]
+            if level is raid.Linear:
+                self.assertIsNone(mdraid.mdadd(self._dev_name, new_member, grow_mode=True))
+            else:
+                with self.assertRaises(MDRaidError):
+                    mdraid.mdadd(self._dev_name, new_member, grow_mode=True, raid_devices=initial_members + 2)
+
+        def testGrowSmall(self):
+            """ Test decreasing size of device. """
+            initial_members = TestCaseFactory._minMembersForCreation(level) + 1
+            self.assertIsNone(mdraid.mdcreate(self._dev_name, level, self.loopDevices[:initial_members]))
+            time.sleep(2) # wait for raid to settle
+
+            new_member = self.loopDevices[initial_members]
+
+            with self.assertRaises(MDRaidError):
+                mdraid.mdadd(self._dev_name, new_member, grow_mode=True, raid_devices=initial_members - 1)
+
+        return type(
+           name,
+           (MDRaidAsRootTestCase,),
+           {
+              '__init__': __init__,
+              'testGrow': testGrow,
+              'testGrowBig' : testGrowBig,
+              'testGrowSmall': testGrowSmall
+           })
+
+
+# make some test cases for every RAID level
+levels = sorted(mdraid.RAID_levels, cmp=lambda x, y: cmp(x.name, y.name))
+for l in levels:
+    classname = "%sJustAddTestCase" % l
+    globals()[classname] = JustAddTestCaseFactory.makeClass(classname, l)
+
+    if l is not raid.Container:
+        classname = "%sGrowTestCase" % l
+        globals()[classname] = GrowTestCaseFactory.makeClass(classname, l)
 
 class SimpleRaidTest(MDRaidAsRootTestCase):
 
diff --git a/tests/pylint/pylint-false-positives b/tests/pylint/pylint-false-positives
index 78e71ad..6ffaf7b 100644
--- a/tests/pylint/pylint-false-positives
+++ b/tests/pylint/pylint-false-positives
@@ -18,5 +18,6 @@
 ^blivet/__init__.py:[[:digit:]]+: \[W0612\(unused\-variable\), enable_installer_mode\] Unused variable 'ROOT_PATH'$
 ^blivet/__init__.py:[[:digit:]]+: \[W0612\(unused\-variable\), enable_installer_mode\] Unused variable 'shortProductName'$
 ^dm.c: [[:digit:]]+: not running as root returning empty list$
+^tests/devicelibs_test/mdraid_test.py:[[:digit:]]+: \[E1003\(bad\-super\-call\), ([[:alnum:]\.]+).__init__\] Bad first argument YES given to super\(\)$
 ^tests/devicelibs_test/raid_test.py:[[:digit:]]+: \[E1120\(no\-value\-for\-parameter\), [[:alnum:]\.]+\] No value [[:alnum:] ]+ 'member_count' in [[:alnum:] ]+ call$
 ^tests/devicelibs_test/raid_test.py:[[:digit:]]+: \[E1120\(no\-value\-for\-parameter\), [[:alnum:]\.]+\] No value [[:alnum:] ]+ 'smallest_member_size' in [[:alnum:] ]+ call$
-- 
1.9.3



More information about the anaconda-patches mailing list