[blivet:master 06/10] Move getting the attribute into the check methods.
mulhern
amulhern at redhat.com
Tue Oct 7 13:42:27 UTC 2014
The idea is that one thing the test methods might want to check is
if the attribute is there at all.
Uses a higher order function because it is simpler and clearer and easier
to do the edit.
Signed-off-by: mulhern <amulhern at redhat.com>
---
tests/devices_test.py | 352 ++++++++++++++++++++++++++------------------------
1 file changed, 183 insertions(+), 169 deletions(-)
diff --git a/tests/devices_test.py b/tests/devices_test.py
index 01ee668..90ae5fc 100644
--- a/tests/devices_test.py
+++ b/tests/devices_test.py
@@ -28,6 +28,20 @@ from blivet.size import Size
from blivet.formats import getFormat
+def xform(func):
+ """ Simple wrapper function that transforms a function that takes
+ a precalculated value and a message to a function that takes
+ a device and an attribute name, evaluates the attribute, and
+ passes the value and the attribute name as the message to the
+ original function.
+
+ :param func: The function to be transformed.
+ :type func: (object * str) -> None
+ :returns: a function that gets the attribute and passes it to func
+ :rtype: (object * str) -> None
+ """
+ return lambda d, a: func(getattr(d, a), a)
+
class DeviceStateTestCase(unittest.TestCase):
"""A class which implements a simple method of checking the state
of a device object.
@@ -50,15 +64,15 @@ class DeviceStateTestCase(unittest.TestCase):
self.longMessage = True
for k,v in self._state_functions.items():
if k in kwargs:
- key = kwargs[k]
- if key is None:
+ test_func = kwargs[k]
+ if test_func is None:
import pdb
pdb.set_trace()
getattr(device, k)
else:
- kwargs[k](getattr(device, k), k)
+ test_func(device, k)
else:
- v(getattr(device, k), k)
+ v(device, k)
class MDRaidArrayDeviceTestCase(DeviceStateTestCase):
"""Note that these tests postdate the code that they test.
@@ -69,37 +83,37 @@ class MDRaidArrayDeviceTestCase(DeviceStateTestCase):
def setUp(self):
self._state_functions = {
- "createBitmap" : self.assertFalse,
- "currentSize" : lambda x, m: self.assertEqual(x, Size(0), m),
- "description" : self.assertIsNotNone,
- "devices" : lambda x, m: self.assertEqual(len(x), 0, m) and
- self.assertIsInstance(x, ParentList, m),
- "exists" : self.assertFalse,
- "format" : self.assertIsNotNone,
- "formatArgs" : lambda x, m: self.assertEqual(x, [], m),
- "formatClass" : self.assertIsNotNone,
- "isDisk" : self.assertFalse,
- "level" : self.assertIsNone,
- "major" : lambda x, m: self.assertEqual(x, 0, m),
- "maxSize" : lambda x, m: self.assertEqual(x, Size(0), m),
- "mediaPresent" : self.assertFalse,
- "metadataVersion" : lambda x, m: self.assertEqual(x, "default", m),
- "minor" : lambda x, m: self.assertEqual(x, 0, m),
- "parents" : lambda x, m: self.assertEqual(len(x), 0, m) and
- self.assertIsInstance(x, ParentList, m),
- "path" : lambda x, m: self.assertRegexpMatches(x, "^/dev", m),
- "partitionable" : self.assertFalse,
- "raw_device" : self.assertIsNotNone,
- "resizable" : self.assertFalse,
- "size" : lambda x, m: self.assertEqual(x, Size(0), m),
- "spares" : lambda x, m: self.assertEqual(x, 0, m),
- "status" : self.assertFalse,
- "sysfsPath" : lambda x, m: self.assertEqual(x, "", m),
- "targetSize" : lambda x, m: self.assertEqual(x, Size(0), m),
- "uuid" : self.assertIsNone,
- "memberDevices" : lambda x, m: self.assertEqual(x, 0, m),
- "totalDevices" : lambda x, m: self.assertEqual(x, 0, m),
- "type" : lambda x, m: self.assertEqual(x, "mdarray", m) }
+ "createBitmap" : xform(lambda d, a: self.assertFalse),
+ "currentSize" : xform(lambda x, m: self.assertEqual(x, Size(0), m)),
+ "description" : xform(self.assertIsNotNone),
+ "devices" : xform(lambda x, m: self.assertEqual(len(x), 0, m) and
+ self.assertIsInstance(x, ParentList, m)),
+ "exists" : xform(self.assertFalse),
+ "format" : xform(self.assertIsNotNone),
+ "formatArgs" : xform(lambda x, m: self.assertEqual(x, [], m)),
+ "formatClass" : xform(self.assertIsNotNone),
+ "isDisk" : xform(self.assertFalse),
+ "level" : xform(self.assertIsNone),
+ "major" : xform(lambda x, m: self.assertEqual(x, 0, m)),
+ "maxSize" : xform(lambda x, m: self.assertEqual(x, Size(0), m)),
+ "mediaPresent" : xform(self.assertFalse),
+ "metadataVersion" : xform(lambda x, m: self.assertEqual(x, "default", m)),
+ "minor" : xform(lambda x, m: self.assertEqual(x, 0, m)),
+ "parents" : xform(lambda x, m: self.assertEqual(len(x), 0, m) and
+ self.assertIsInstance(x, ParentList, m)),
+ "path" : xform(lambda x, m: self.assertRegexpMatches(x, "^/dev", m)),
+ "partitionable" : xform(self.assertFalse),
+ "raw_device" : xform(self.assertIsNotNone),
+ "resizable" : xform(self.assertFalse),
+ "size" : xform(lambda x, m: self.assertEqual(x, Size(0), m)),
+ "spares" : xform(lambda x, m: self.assertEqual(x, 0, m)),
+ "status" : xform(self.assertFalse),
+ "sysfsPath" : xform(lambda x, m: self.assertEqual(x, "", m)),
+ "targetSize" : xform(lambda x, m: self.assertEqual(x, Size(0), m)),
+ "uuid" : xform(self.assertIsNone),
+ "memberDevices" : xform(lambda x, m: self.assertEqual(x, 0, m)),
+ "totalDevices" : xform(lambda x, m: self.assertEqual(x, 0, m)),
+ "type" : xform(lambda x, m: self.assertEqual(x, "mdarray", m))}
parents = [
DiskDevice("name1", fmt=getFormat("mdmember"))
@@ -322,149 +336,149 @@ class MDRaidArrayDeviceTestCase(DeviceStateTestCase):
## level tests
##
self.stateCheck(self.dev1,
- devices=lambda x, m: self.assertEqual(len(x), 1, m),
- level=lambda x, m: self.assertEqual(x.name, "container", m),
- parents=lambda x, m: self.assertEqual(len(x), 1, m),
- type=lambda x, m: self.assertEqual(x, "mdcontainer", m))
+ devices=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
+ level=xform(lambda x, m: self.assertEqual(x.name, "container", m)),
+ parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
+ type=xform(lambda x, m: self.assertEqual(x, "mdcontainer", m)))
self.stateCheck(self.dev2,
- createBitmap=self.assertFalse,
- devices=lambda x, m: self.assertEqual(len(x), 2, m),
- level=lambda x, m: self.assertEqual(x.number, 0, m),
- parents=lambda x, m: self.assertEqual(len(x), 2, m))
+ createBitmap=xform(self.assertFalse),
+ devices=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+ level=xform(lambda x, m: self.assertEqual(x.number, 0, m)),
+ parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)))
self.stateCheck(self.dev3,
- devices=lambda x, m: self.assertEqual(len(x), 2, m),
- level=lambda x, m: self.assertEqual(x.number, 1, m),
- parents=lambda x, m: self.assertEqual(len(x), 2, m))
+ devices=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+ level=xform(lambda x, m: self.assertEqual(x.number, 1, m)),
+ parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)))
self.stateCheck(self.dev4,
- devices=lambda x, m: self.assertEqual(len(x), 3, m),
- level=lambda x, m: self.assertEqual(x.number, 4, m),
- parents=lambda x, m: self.assertEqual(len(x), 3, m))
+ devices=xform(lambda x, m: self.assertEqual(len(x), 3, m)),
+ level=xform(lambda x, m: self.assertEqual(x.number, 4, m)),
+ parents=xform(lambda x, m: self.assertEqual(len(x), 3, m)))
self.stateCheck(self.dev5,
- devices=lambda x, m: self.assertEqual(len(x), 3, m),
- level=lambda x, m: self.assertEqual(x.number, 5, m),
- parents=lambda x, m: self.assertEqual(len(x), 3, m))
+ devices=xform(lambda x, m: self.assertEqual(len(x), 3, m)),
+ level=xform(lambda x, m: self.assertEqual(x.number, 5, m)),
+ parents=xform(lambda x, m: self.assertEqual(len(x), 3, m)))
self.stateCheck(self.dev6,
- devices=lambda x, m: self.assertEqual(len(x), 4, m),
- level=lambda x, m: self.assertEqual(x.number, 6, m),
- parents=lambda x, m: self.assertEqual(len(x), 4, m))
+ devices=xform(lambda x, m: self.assertEqual(len(x), 4, m)),
+ level=xform(lambda x, m: self.assertEqual(x.number, 6, m)),
+ parents=xform(lambda x, m: self.assertEqual(len(x), 4, m)))
self.stateCheck(self.dev7,
- devices=lambda x, m: self.assertEqual(len(x), 4, m),
- level=lambda x, m: self.assertEqual(x.number, 10, m),
- parents=lambda x, m: self.assertEqual(len(x), 4, m))
+ devices=xform(lambda x, m: self.assertEqual(len(x), 4, m)),
+ level=xform(lambda x, m: self.assertEqual(x.number, 10, m)),
+ parents=xform(lambda x, m: self.assertEqual(len(x), 4, m)))
##
## existing device tests
##
self.stateCheck(self.dev8,
- exists=self.assertTrue,
- level=lambda x, m: self.assertEqual(x.number, 1, m),
- metadataVersion=self.assertIsNone)
+ exists=xform(self.assertTrue),
+ level=xform(lambda x, m: self.assertEqual(x.number, 1, m)),
+ metadataVersion=xform(self.assertIsNone))
##
## mdbiosraidarray tests
##
self.stateCheck(self.dev9,
- createBitmap=self.assertFalse,
- devices=lambda x, m: self.assertEqual(len(x), 2, m),
- isDisk=self.assertTrue,
- level=lambda x, m: self.assertEqual(x.number, 0, m),
- mediaPresent=self.assertTrue,
- memberDevices=lambda x, m: self.assertEqual(x, 2, m),
- parents=lambda x, m: self.assertNotEqual(x, [], m),
- partitionable=self.assertTrue,
- totalDevices=lambda x, m: self.assertEqual(x, 2, m),
- type = lambda x, m: self.assertEqual(x, "mdbiosraidarray", m))
+ createBitmap=xform(self.assertFalse),
+ devices=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+ isDisk=xform(self.assertTrue),
+ level=xform(lambda x, m: self.assertEqual(x.number, 0, m)),
+ mediaPresent=xform(self.assertTrue),
+ memberDevices=xform(lambda x, m: self.assertEqual(x, 2, m)),
+ parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
+ partitionable=xform(self.assertTrue),
+ totalDevices=xform(lambda x, m: self.assertEqual(x, 2, m)),
+ type = xform(lambda x, m: self.assertEqual(x, "mdbiosraidarray", m)))
##
## size tests
##
self.stateCheck(self.dev10,
- createBitmap=self.assertFalse,
- devices=lambda x, m: self.assertEqual(len(x), 2, m),
- level=lambda x, m: self.assertEqual(x.number, 0, m),
- parents=lambda x, m: self.assertEqual(len(x), 2, m),
- targetSize=lambda x, m: self.assertEqual(x, Size("32 MiB"), m))
+ createBitmap=xform(self.assertFalse),
+ devices=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+ level=xform(lambda x, m: self.assertEqual(x.number, 0, m)),
+ parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+ targetSize=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)))
self.stateCheck(self.dev11,
- devices=lambda x, m: self.assertEqual(len(x), 2, m),
- isDisk=self.assertTrue,
- level=lambda x, m: self.assertEqual(x.number, 1, m),
- mediaPresent=self.assertTrue,
- memberDevices=lambda x, m: self.assertEqual(x, 2, m),
- parents=lambda x, m: self.assertNotEqual(x, [], m),
- partitionable=self.assertTrue,
- targetSize=lambda x, m: self.assertEqual(x, Size("32 MiB"), m),
- totalDevices=lambda x, m: self.assertEqual(x, 2, m),
- type=lambda x, m: self.assertEqual(x, "mdbiosraidarray", m))
+ devices=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+ isDisk=xform(self.assertTrue),
+ level=xform(lambda x, m: self.assertEqual(x.number, 1, m)),
+ mediaPresent=xform(self.assertTrue),
+ memberDevices=xform(lambda x, m: self.assertEqual(x, 2, m)),
+ parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
+ partitionable=xform(self.assertTrue),
+ targetSize=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
+ totalDevices=xform(lambda x, m: self.assertEqual(x, 2, m)),
+ type=xform(lambda x, m: self.assertEqual(x, "mdbiosraidarray", m)))
self.stateCheck(self.dev12,
- devices=lambda x, m: self.assertEqual(len(x), 2, m),
- isDisk=self.assertTrue,
- level=lambda x, m: self.assertEqual(x.number, 1, m),
- mediaPresent=self.assertTrue,
- memberDevices=lambda x, m: self.assertEqual(x, 2, m),
- parents=lambda x, m: self.assertNotEqual(x, [], m),
- partitionable=self.assertTrue,
- targetSize=lambda x, m: self.assertEqual(x, Size("32 MiB"), m),
- totalDevices=lambda x, m: self.assertEqual(x, 2, m),
- type = lambda x, m: self.assertEqual(x, "mdbiosraidarray", m))
+ devices=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+ isDisk=xform(self.assertTrue),
+ level=xform(lambda x, m: self.assertEqual(x.number, 1, m)),
+ mediaPresent=xform(self.assertTrue),
+ memberDevices=xform(lambda x, m: self.assertEqual(x, 2, m)),
+ parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
+ partitionable=xform(self.assertTrue),
+ targetSize=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
+ totalDevices=xform(lambda x, m: self.assertEqual(x, 2, m)),
+ type = xform(lambda x, m: self.assertEqual(x, "mdbiosraidarray", m)))
self.stateCheck(self.dev13,
- createBitmap=self.assertFalse,
- devices=lambda x, m: self.assertEqual(len(x), 2, m),
- level=lambda x, m: self.assertEqual(x.number, 0, m),
- memberDevices=lambda x, m: self.assertEqual(x, 3, m),
- parents=lambda x, m: self.assertNotEqual(x, [], m),
- size=lambda x, m: self.assertEqual(x, Size("3 MiB"), m),
- targetSize=lambda x, m: self.assertEqual(x, Size("32 MiB"), m),
- totalDevices=lambda x, m: self.assertEqual(x, 3, m))
+ createBitmap=xform(self.assertFalse),
+ devices=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+ level=xform(lambda x, m: self.assertEqual(x.number, 0, m)),
+ memberDevices=xform(lambda x, m: self.assertEqual(x, 3, m)),
+ parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
+ size=xform(lambda x, m: self.assertEqual(x, Size("3 MiB"), m)),
+ targetSize=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
+ totalDevices=xform(lambda x, m: self.assertEqual(x, 3, m)))
self.stateCheck(self.dev14,
- createBitmap=self.assertTrue,
- devices=lambda x, m: self.assertEqual(len(x), 3, m),
- level=lambda x, m: self.assertEqual(x.number, 4, m),
- memberDevices=lambda x, m: self.assertEqual(x, 3, m),
- parents=lambda x, m: self.assertNotEqual(x, [], m),
- size=lambda x, m: self.assertEqual(x, Size("2 MiB"), m),
- totalDevices=lambda x, m: self.assertEqual(x, 3, m))
+ createBitmap=xform(self.assertTrue),
+ devices=xform(lambda x, m: self.assertEqual(len(x), 3, m)),
+ level=xform(lambda x, m: self.assertEqual(x.number, 4, m)),
+ memberDevices=xform(lambda x, m: self.assertEqual(x, 3, m)),
+ parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
+ size=xform(lambda x, m: self.assertEqual(x, Size("2 MiB"), m)),
+ totalDevices=xform(lambda x, m: self.assertEqual(x, 3, m)))
self.stateCheck(self.dev15,
- createBitmap=self.assertTrue,
- devices=lambda x, m: self.assertEqual(len(x), 3, m),
- level=lambda x, m: self.assertEqual(x.number, 5, m),
- memberDevices=lambda x, m: self.assertEqual(x, 3, m),
- parents=lambda x, m: self.assertNotEqual(x, [], m),
- size=lambda x, m: self.assertEqual(x, Size("2 MiB"), m),
- totalDevices=lambda x, m: self.assertEqual(x, 3, m))
+ createBitmap=xform(self.assertTrue),
+ devices=xform(lambda x, m: self.assertEqual(len(x), 3, m)),
+ level=xform(lambda x, m: self.assertEqual(x.number, 5, m)),
+ memberDevices=xform(lambda x, m: self.assertEqual(x, 3, m)),
+ parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
+ size=xform(lambda x, m: self.assertEqual(x, Size("2 MiB"), m)),
+ totalDevices=xform(lambda x, m: self.assertEqual(x, 3, m)))
self.stateCheck(self.dev16,
- createBitmap=self.assertTrue,
- devices=lambda x, m: self.assertEqual(len(x), 4, m),
- level=lambda x, m: self.assertEqual(x.number, 6, m),
- memberDevices=lambda x, m: self.assertEqual(x, 4, m),
- parents=lambda x, m: self.assertNotEqual(x, [], m),
- size=lambda x, m: self.assertEqual(x, Size("2 MiB"), m),
- totalDevices=lambda x, m: self.assertEqual(x, 4, m))
+ createBitmap=xform(self.assertTrue),
+ devices=xform(lambda x, m: self.assertEqual(len(x), 4, m)),
+ level=xform(lambda x, m: self.assertEqual(x.number, 6, m)),
+ memberDevices=xform(lambda x, m: self.assertEqual(x, 4, m)),
+ parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
+ size=xform(lambda x, m: self.assertEqual(x, Size("2 MiB"), m)),
+ totalDevices=xform(lambda x, m: self.assertEqual(x, 4, m)))
self.stateCheck(self.dev17,
- createBitmap=self.assertTrue,
- devices=lambda x, m: self.assertEqual(len(x), 4, m),
- level=lambda x, m: self.assertEqual(x.number, 10, m),
- memberDevices=lambda x, m: self.assertEqual(x, 4, m),
- parents=lambda x, m: self.assertNotEqual(x, [], m),
- size=lambda x, m: self.assertEqual(x, Size("2 MiB"), m),
- totalDevices=lambda x, m: self.assertEqual(x, 4, m))
+ createBitmap=xform(self.assertTrue),
+ devices=xform(lambda x, m: self.assertEqual(len(x), 4, m)),
+ level=xform(lambda x, m: self.assertEqual(x.number, 10, m)),
+ memberDevices=xform(lambda x, m: self.assertEqual(x, 4, m)),
+ parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
+ size=xform(lambda x, m: self.assertEqual(x, Size("2 MiB"), m)),
+ totalDevices=xform(lambda x, m: self.assertEqual(x, 4, m)))
self.stateCheck(self.dev18,
- createBitmap=self.assertTrue,
- devices=lambda x, m: self.assertEqual(len(x), 4, m),
- level=lambda x, m: self.assertEqual(x.number, 10, m),
- memberDevices=lambda x, m: self.assertEqual(x, 4, m),
- parents=lambda x, m: self.assertNotEqual(x, [], m),
- size=lambda x, m: self.assertEqual(x, Size("2 MiB"), m),
- spares=lambda x, m: self.assertEqual(x, 1, m),
- totalDevices=lambda x, m: self.assertEqual(x, 5, m))
+ createBitmap=xform(self.assertTrue),
+ devices=xform(lambda x, m: self.assertEqual(len(x), 4, m)),
+ level=xform(lambda x, m: self.assertEqual(x.number, 10, m)),
+ memberDevices=xform(lambda x, m: self.assertEqual(x, 4, m)),
+ parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
+ size=xform(lambda x, m: self.assertEqual(x, Size("2 MiB"), m)),
+ spares=xform(lambda x, m: self.assertEqual(x, 1, m)),
+ totalDevices=xform(lambda x, m: self.assertEqual(x, 5, m)))
with self.assertRaisesRegexp(DeviceError, "invalid"):
MDRaidArrayDevice("dev")
@@ -506,28 +520,28 @@ class BTRFSDeviceTestCase(DeviceStateTestCase):
def setUp(self):
self._state_functions = {
- "currentSize" : lambda x, m: self.assertEqual(x, Size(0), m),
- "exists" : self.assertFalse,
- "format" : self.assertIsNotNone,
- "formatArgs" : lambda x, m: self.assertEqual(x, [], m),
- "fstabSpec" : self.assertIsNotNone,
- "isDisk" : self.assertFalse,
- "major" : lambda x, m: self.assertEqual(x, 0, m),
- "maxSize" : lambda x, m: self.assertEqual(x, Size(0), m),
- "mediaPresent" : self.assertTrue,
- "minor" : lambda x, m: self.assertEqual(x, 0, m),
- "parents" : lambda x, m: self.assertEqual(len(x), 0, m) and
- self.assertIsInstance(x, ParentList, m),
- "partitionable" : self.assertFalse,
- "path" : lambda x, m: self.assertRegexpMatches(x, "^/dev", m),
- "resizable" : lambda x, m: self.assertFalse,
- "size" : lambda x, m: self.assertEqual(x, Size(0), m),
- "status" : self.assertFalse,
- "sysfsPath" : lambda x, m: self.assertEqual(x, "", m),
- "targetSize" : lambda x, m: self.assertEqual(x, Size(0), m),
- "type" : lambda x, m: self.assertEqual(x, "btrfs", m),
- "uuid" : self.assertIsNone,
- "vol_id" : lambda x, m: self.assertEqual(x, btrfs.MAIN_VOLUME_ID, m)}
+ "currentSize" : xform(lambda x, m: self.assertEqual(x, Size(0), m)),
+ "exists" : xform(self.assertFalse),
+ "format" : xform(self.assertIsNotNone),
+ "formatArgs" : xform(lambda x, m: self.assertEqual(x, [], m)),
+ "fstabSpec" : xform(self.assertIsNotNone),
+ "isDisk" : xform(self.assertFalse),
+ "major" : xform(lambda x, m: self.assertEqual(x, 0, m)),
+ "maxSize" : xform(lambda x, m: self.assertEqual(x, Size(0), m)),
+ "mediaPresent" : xform(self.assertTrue),
+ "minor" : xform(lambda x, m: self.assertEqual(x, 0, m)),
+ "parents" : xform(lambda x, m: self.assertEqual(len(x), 0, m) and
+ self.assertIsInstance(x, ParentList, m)),
+ "partitionable" : xform(self.assertFalse),
+ "path" : xform(lambda x, m: self.assertRegexpMatches(x, "^/dev", m)),
+ "resizable" : xform(lambda x, m: self.assertFalse),
+ "size" : xform(lambda x, m: self.assertEqual(x, Size(0), m)),
+ "status" : xform(self.assertFalse),
+ "sysfsPath" : xform(lambda x, m: self.assertEqual(x, "", m)),
+ "targetSize" : xform(lambda x, m: self.assertEqual(x, Size(0), m)),
+ "type" : xform(lambda x, m: self.assertEqual(x, "btrfs", m)),
+ "uuid" : xform(self.assertIsNone),
+ "vol_id" : xform(lambda x, m: self.assertEqual(x, btrfs.MAIN_VOLUME_ID, m))}
self.dev1 = BTRFSVolumeDevice("dev1",
parents=[OpticalDevice("deva",
@@ -548,15 +562,15 @@ class BTRFSDeviceTestCase(DeviceStateTestCase):
"""
self.stateCheck(self.dev1,
- parents=lambda x, m: self.assertEqual(len(x), 1, m),
- type=lambda x, m: self.assertEqual(x, "btrfs volume", m))
+ parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
+ type=xform(lambda x, m: self.assertEqual(x, "btrfs volume", m)))
self.stateCheck(self.dev3,
- currentSize=lambda x, m: self.assertEqual(x, Size("32 MiB"), m),
- maxSize=lambda x, m: self.assertEqual(x, Size("32 MiB"), m),
- parents=lambda x, m: self.assertEqual(len(x), 1, m),
- size=lambda x, m: self.assertEqual(x, Size("32 MiB"), m),
- type=lambda x, m: self.assertEqual(x, "btrfs volume", m))
+ currentSize=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
+ maxSize=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
+ parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
+ size=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
+ type=xform(lambda x, m: self.assertEqual(x, "btrfs volume", m)))
with self.assertRaisesRegexp(ValueError, "BTRFSDevice.*must have at least one parent"):
BTRFSVolumeDevice("dev")
--
1.9.3
More information about the anaconda-patches
mailing list