[master 10/10] Update md and btrfs unit tests to run with recent size changes.

dwlehman installerbot-noreply at redhat.com
Mon Jul 20 21:39:31 UTC 2015


From: David Lehman <dlehman at redhat.com>

It also fixes several of the MD property tests that weren't doing
anything useful.
---
 tests/devices_test/dependencies_test.py      |   6 +-
 tests/devices_test/device_properties_test.py | 182 +++++++++++++--------------
 2 files changed, 90 insertions(+), 98 deletions(-)

diff --git a/tests/devices_test/dependencies_test.py b/tests/devices_test/dependencies_test.py
index 78d3416..1547d28 100644
--- a/tests/devices_test/dependencies_test.py
+++ b/tests/devices_test/dependencies_test.py
@@ -15,6 +15,8 @@
 
 from blivet.formats import getFormat
 
+from blivet.size import Size
+
 from blivet.tasks import availability
 
 class DeviceDependenciesTestCase(unittest.TestCase):
@@ -37,10 +39,10 @@ class MockingDeviceDependenciesTestCase(unittest.TestCase):
     """Test availability of external device dependencies. """
 
     def setUp(self):
-        dev1 = DiskDevice("name", fmt=getFormat("mdmember"))
+        dev1 = DiskDevice("name", fmt=getFormat("mdmember"), size=Size("1 GiB"))
         dev2 = DiskDevice("other")
         self.part = PartitionDevice("part", fmt=getFormat("mdmember"), parents=[dev2])
-        self.dev = MDRaidArrayDevice("dev", level="raid1", parents=[dev1, self.part], fmt=getFormat("luks"))
+        self.dev = MDRaidArrayDevice("dev", level="raid1", parents=[dev1, self.part], fmt=getFormat("luks"), totalDevices=2, memberDevices=2)
         self.luks = LUKSDevice("luks", parents=[self.dev], fmt=getFormat("ext4"))
 
         self.mdraid_method = availability.BLOCKDEV_MDRAID_PLUGIN._method
diff --git a/tests/devices_test/device_properties_test.py b/tests/devices_test/device_properties_test.py
index a72f27d..db51110 100644
--- a/tests/devices_test/device_properties_test.py
+++ b/tests/devices_test/device_properties_test.py
@@ -25,10 +25,13 @@
 from blivet.devices import StorageDevice
 from blivet.devices import ParentList
 from blivet.devicelibs import btrfs
+from blivet.devicelibs import mdraid
 from blivet.size import Size
 
 from blivet.formats import getFormat
 
+BTRFS_MIN_MEMBER_SIZE = getFormat("btrfs").minSize
+
 def xform(func):
     """ Simple wrapper function that transforms a function that takes
         a precalculated value and a message to a function that takes
@@ -125,16 +128,22 @@ def __init__(self, methodName='runTest'):
         self._state_functions.update(state_functions)
 
     def setUp(self):
+        self.md_chunk_size = mdraid.MD_CHUNK_SIZE
+        mdraid.MD_CHUNK_SIZE = Size("1 MiB")
+        self.get_super_block_size = MDRaidArrayDevice.getSuperBlockSize
+        MDRaidArrayDevice.getSuperBlockSize = lambda a, s: Size(0)
+
         parents = [
            DiskDevice("name1", fmt=getFormat("mdmember"))
         ]
-        self.dev1 = MDContainerDevice("dev1", level="container", parents=parents)
+        self.dev1 = MDContainerDevice("dev1", level="container", parents=parents, totalDevices=1, memberDevices=1)
 
         parents = [
-           DiskDevice("name1", fmt=getFormat("mdmember")),
-           DiskDevice("name2", fmt=getFormat("mdmember"))
+           DiskDevice("name1", fmt=getFormat("mdmember"), size=Size("1 GiB")),
+           DiskDevice("name2", fmt=getFormat("mdmember"), size=Size("1 GiB"))
         ]
-        self.dev2 = MDRaidArrayDevice("dev2", level="raid0", parents=parents)
+        self.dev2 = MDRaidArrayDevice("dev2", level="raid0", parents=parents,
+                                      totalDevices=2, memberDevices=2)
 
         parents = [
            DiskDevice("name1", fmt=getFormat("mdmember")),
@@ -176,29 +185,23 @@ def setUp(self):
 
 
         parents_1 = [
-           DiskDevice("name1", fmt=getFormat("mdmember"))
+           DiskDevice("name1", fmt=getFormat("mdmember")),
+           DiskDevice("name2", fmt=getFormat("mdmember"))
         ]
         dev_1 = MDContainerDevice(
            "parent",
            level="container",
-           parents=parents_1
-        )
-        parents_2 = [
-           DiskDevice("name1", fmt=getFormat("mdmember")),
-           DiskDevice("name2", fmt=getFormat("mdmember"))
-        ]
-        dev_2 = MDRaidArrayDevice(
-           "other",
-           level=0,
-           fmt=getFormat("mdmember"),
-           parents=parents_2
+           parents=parents_1,
+           totalDevices=2,
+           memberDevices=2
         )
         self.dev9 = MDBiosRaidArrayDevice(
            "dev9",
            level="raid0",
-           memberDevices=2,
-           parents=[dev_1, dev_2],
-           totalDevices=2
+           memberDevices=1,
+           parents=[dev_1],
+           totalDevices=1,
+           exists=True
         )
 
         parents = [
@@ -212,55 +215,34 @@ def setUp(self):
            size=Size("32 MiB"))
 
         parents_1 = [
-           DiskDevice("name1", fmt=getFormat("mdmember"))
+           DiskDevice("name1", fmt=getFormat("mdmember")),
+           DiskDevice("name2", fmt=getFormat("mdmember"))
         ]
         dev_1 = MDContainerDevice(
            "parent",
            level="container",
-           parents=parents
-        )
-        parents_2 = [
-           DiskDevice("name1", fmt=getFormat("mdmember")),
-           DiskDevice("name2", fmt=getFormat("mdmember"))
-        ]
-        dev_2 = MDRaidArrayDevice(
-           "other",
-           level=0,
-           fmt=getFormat("mdmember"),
-           parents=parents_2
+           parents=parents,
+           totalDevices=2,
+           memberDevices=2
         )
         self.dev11 = MDBiosRaidArrayDevice(
            "dev11",
            level=1,
-           memberDevices=2,
-           parents=[dev_1, dev_2],
-           size=Size("32 MiB"),
-           totalDevices=2)
-
-        self.dev12 = MDBiosRaidArrayDevice(
-           "dev12",
-           level=1,
-           memberDevices=2,
-           parents=[
-              Mock(**{"type": "mdcontainer",
-                      "size": Size("4 MiB"),
-                      "format": getFormat(None)}),
-              Mock(**{"size": Size("2 MiB"),
-                      "format": getFormat("mdmember")})],
-           size=Size("32 MiB"),
-           totalDevices=2)
+           exists=True,
+           parents=[dev_1],
+           size=Size("32 MiB"))
 
         self.dev13 = MDRaidArrayDevice(
            "dev13",
            level=0,
-           memberDevices=3,
+           memberDevices=2,
            parents=[
               Mock(**{"size": Size("4 MiB"),
                       "format": getFormat("mdmember")}),
               Mock(**{"size": Size("2 MiB"),
                       "format": getFormat("mdmember")})],
            size=Size("32 MiB"),
-           totalDevices=3)
+           totalDevices=2)
 
         self.dev14 = MDRaidArrayDevice(
            "dev14",
@@ -355,6 +337,10 @@ def setUp(self):
            uuid='Just-pretending'
         )
 
+    def tearDown(self):
+        mdraid.MD_CHUNK_SIZE = self.md_chunk_size
+        MDRaidArrayDevice.getSuperBlockSize = self.get_super_block_size
+
     def testMDRaidArrayDeviceInit(self):
         """Tests the state of a MDRaidArrayDevice after initialization.
            For some combinations of arguments the initializer will throw
@@ -367,14 +353,19 @@ def testMDRaidArrayDeviceInit(self):
         self.stateCheck(self.dev1,
            level=xform(lambda x, m: self.assertEqual(x.name, "container", m)),
            parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
-           mediaPresent=xform(self.assertFalse),
+           memberDevices=xform(lambda x, m: self.assertEqual(x, 1, m)),
            members=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
+           mediaPresent=xform(self.assertFalse),
+           totalDevices=xform(lambda x, m: self.assertEqual(x, 1, m)),
            type=xform(lambda x, m: self.assertEqual(x, "mdcontainer", m)))
         self.stateCheck(self.dev2,
            createBitmap=xform(self.assertFalse),
            level=xform(lambda x, m: self.assertEqual(x.number, 0, m)),
+           memberDevices=xform(lambda x, m: self.assertEqual(x, 2, m)),
            members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
-           parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)))
+           size=xform(lambda x, m: self.assertEqual(x, Size("2 GiB"), m)),
+           parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+           totalDevices=xform(lambda x, m: self.assertEqual(x, 2, m)))
         self.stateCheck(self.dev3,
            level=xform(lambda x, m: self.assertEqual(x.number, 1, m)),
            members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
@@ -411,9 +402,11 @@ def testMDRaidArrayDeviceInit(self):
         self.stateCheck(self.dev9,
            createBitmap=xform(self.assertFalse),
            isDisk=xform(self.assertTrue),
+           exists=xform(self.assertTrue),
            level=xform(lambda x, m: self.assertEqual(x.number, 0, m)),
            memberDevices=xform(lambda x, m: self.assertEqual(x, 2, m)),
            members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+           metadataVersion=xform(lambda x, m: self.assertEqual(x, None, m)),
            parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
            partitionable=xform(self.assertTrue),
            totalDevices=xform(lambda x, m: self.assertEqual(x, 2, m)),
@@ -431,35 +424,29 @@ def testMDRaidArrayDeviceInit(self):
 
         self.stateCheck(self.dev11,
            isDisk=xform(self.assertTrue),
+           exists=xform(lambda x, m: self.assertEqual(x, True, m)),
            level=xform(lambda x, m: self.assertEqual(x.number, 1, 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)),
            memberDevices=xform(lambda x, m: self.assertEqual(x, 2, m)),
            members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+           metadataVersion=xform(lambda x, m: self.assertEqual(x, None, m)),
            parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
            partitionable=xform(self.assertTrue),
+           size=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
            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,
-           isDisk=xform(self.assertTrue),
-           level=xform(lambda x, m: self.assertEqual(x.number, 1, m)),
-           memberDevices=xform(lambda x, m: self.assertEqual(x, 2, m)),
-           members=xform(lambda x, m: self.assertEqual(len(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=xform(self.assertFalse),
            level=xform(lambda x, m: self.assertEqual(x.number, 0, m)),
-           memberDevices=xform(lambda x, m: self.assertEqual(x, 3, m)),
+           memberDevices=xform(lambda x, m: self.assertEqual(x, 2, m)),
            members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
            parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
-           size=xform(lambda x, m: self.assertEqual(x, Size("3 MiB"), m)),
+           size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)),
            targetSize=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
-           totalDevices=xform(lambda x, m: self.assertEqual(x, 3, m)))
+           totalDevices=xform(lambda x, m: self.assertEqual(x, 2, m)))
 
         self.stateCheck(self.dev14,
            createBitmap=xform(self.assertTrue),
@@ -467,7 +454,7 @@ def testMDRaidArrayDeviceInit(self):
            memberDevices=xform(lambda x, m: self.assertEqual(x, 3, m)),
            members=xform(lambda x, m: self.assertEqual(len(x), 3, m)),
            parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
-           size=xform(lambda x, m: self.assertEqual(x, Size("2 MiB"), m)),
+           size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)),
            totalDevices=xform(lambda x, m: self.assertEqual(x, 3, m)))
 
         self.stateCheck(self.dev15,
@@ -476,7 +463,7 @@ def testMDRaidArrayDeviceInit(self):
            memberDevices=xform(lambda x, m: self.assertEqual(x, 3, m)),
            members=xform(lambda x, m: self.assertEqual(len(x), 3, m)),
            parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
-           size=xform(lambda x, m: self.assertEqual(x, Size("2 MiB"), m)),
+           size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)),
            totalDevices=xform(lambda x, m: self.assertEqual(x, 3, m)))
 
         self.stateCheck(self.dev16,
@@ -485,7 +472,7 @@ def testMDRaidArrayDeviceInit(self):
            memberDevices=xform(lambda x, m: self.assertEqual(x, 4, m)),
            members=xform(lambda x, m: self.assertEqual(len(x), 4, m)),
            parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
-           size=xform(lambda x, m: self.assertEqual(x, Size("2 MiB"), m)),
+           size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)),
            totalDevices=xform(lambda x, m: self.assertEqual(x, 4, m)))
 
         self.stateCheck(self.dev17,
@@ -494,7 +481,7 @@ def testMDRaidArrayDeviceInit(self):
            memberDevices=xform(lambda x, m: self.assertEqual(x, 4, m)),
            members=xform(lambda x, m: self.assertEqual(len(x), 4, m)),
            parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
-           size=xform(lambda x, m: self.assertEqual(x, Size("2 MiB"), m)),
+           size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)),
            totalDevices=xform(lambda x, m: self.assertEqual(x, 4, m)))
 
         self.stateCheck(self.dev18,
@@ -503,7 +490,7 @@ def testMDRaidArrayDeviceInit(self):
            memberDevices=xform(lambda x, m: self.assertEqual(x, 4, m)),
            members=xform(lambda x, m: self.assertEqual(len(x), 4, m)),
            parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
-           size=xform(lambda x, m: self.assertEqual(x, Size("2 MiB"), m)),
+           size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)),
            spares=xform(lambda x, m: self.assertEqual(x, 1, m)),
            totalDevices=xform(lambda x, m: self.assertEqual(x, 5, m)))
 
@@ -573,7 +560,7 @@ def setUp(self):
         self.dev1 = BTRFSVolumeDevice("dev1",
            parents=[StorageDevice("deva",
               fmt=blivet.formats.getFormat("btrfs"),
-              size=btrfs.MIN_MEMBER_SIZE)])
+              size=BTRFS_MIN_MEMBER_SIZE)])
 
         self.dev2 = BTRFSSubVolumeDevice("dev2",
            parents=[self.dev1],
@@ -581,7 +568,7 @@ def setUp(self):
 
         dev = StorageDevice("deva",
            fmt=blivet.formats.getFormat("btrfs"),
-           size=Size("32 MiB"))
+           size=Size("500 MiB"))
         self.dev3 = BTRFSVolumeDevice("dev3",
            parents=[dev])
 
@@ -592,51 +579,53 @@ def testBTRFSDeviceInit(self):
         """
 
         self.stateCheck(self.dev1,
-           currentSize=xform(lambda x, m: self.assertEqual(x, btrfs.MIN_MEMBER_SIZE, m)),
+           currentSize=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
            dataLevel=xform(self.assertIsNone),
            isleaf=xform(self.assertFalse),
-           maxSize=xform(lambda x, m: self.assertEqual(x, btrfs.MIN_MEMBER_SIZE, m)),
+           maxSize=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
            metaDataLevel=xform(self.assertIsNone),
            parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
-           size=xform(lambda x, m: self.assertEqual(x, btrfs.MIN_MEMBER_SIZE, m)),
+           size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
            type=xform(lambda x, m: self.assertEqual(x, "btrfs volume", m)))
 
         self.stateCheck(self.dev2,
-           currentSize=xform(lambda x, m: self.assertEqual(x, btrfs.MIN_MEMBER_SIZE, m)),
-           maxSize=xform(lambda x, m: self.assertEqual(x, btrfs.MIN_MEMBER_SIZE, m)),
+           targetSize=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+           currentSize=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+           maxSize=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
            parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
-           size=xform(lambda x, m: self.assertEqual(x, btrfs.MIN_MEMBER_SIZE, m)),
+           size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
            type=xform(lambda x, m: self.assertEqual(x, "btrfs subvolume", m)),
            vol_id=xform(self.assertIsNone))
 
         self.stateCheck(self.dev3,
-           currentSize=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
+           currentSize=xform(lambda x, m: self.assertEqual(x, Size("500 MiB"), m)),
            dataLevel=xform(self.assertIsNone),
-           maxSize=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
+           maxSize=xform(lambda x, m: self.assertEqual(x, Size("500 MiB"), m)),
            metaDataLevel=xform(self.assertIsNone),
            parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
-           size=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
+           size=xform(lambda x, m: self.assertEqual(x, Size("500 MiB"), m)),
            type=xform(lambda x, m: self.assertEqual(x, "btrfs volume", m)))
 
         with self.assertRaisesRegex(ValueError, "BTRFSDevice.*must have at least one parent"):
             BTRFSVolumeDevice("dev")
 
         with self.assertRaisesRegex(ValueError, "format"):
-            BTRFSVolumeDevice("dev", parents=[StorageDevice("deva", size=btrfs.MIN_MEMBER_SIZE)])
+            BTRFSVolumeDevice("dev", parents=[StorageDevice("deva", size=BTRFS_MIN_MEMBER_SIZE)])
 
         with self.assertRaisesRegex(DeviceError, "btrfs subvolume.*must be a btrfs volume"):
             fmt = blivet.formats.getFormat("btrfs")
-            device = StorageDevice("deva", fmt=fmt, size=btrfs.MIN_MEMBER_SIZE)
+            device = StorageDevice("deva", fmt=fmt, size=BTRFS_MIN_MEMBER_SIZE)
             BTRFSSubVolumeDevice("dev1", parents=[device])
 
-        deva = OpticalDevice("deva", fmt=blivet.formats.getFormat("btrfs"))
+        deva = OpticalDevice("deva", fmt=blivet.formats.getFormat("btrfs", exists=True),
+                             exists=True)
         with self.assertRaisesRegex(BTRFSValueError, "at least"):
             BTRFSVolumeDevice("dev1", dataLevel="raid1", parents=[deva])
 
-        deva = StorageDevice("deva", fmt=blivet.formats.getFormat("btrfs"), size=btrfs.MIN_MEMBER_SIZE)
+        deva = StorageDevice("deva", fmt=blivet.formats.getFormat("btrfs"), size=BTRFS_MIN_MEMBER_SIZE)
         self.assertIsNotNone(BTRFSVolumeDevice("dev1", metaDataLevel="dup", parents=[deva]))
 
-        deva = StorageDevice("deva", fmt=blivet.formats.getFormat("btrfs"), size=btrfs.MIN_MEMBER_SIZE)
+        deva = StorageDevice("deva", fmt=blivet.formats.getFormat("btrfs"), size=BTRFS_MIN_MEMBER_SIZE)
         with self.assertRaisesRegex(BTRFSValueError, "invalid"):
             BTRFSVolumeDevice("dev1", dataLevel="dup", parents=[deva])
 
@@ -663,10 +652,10 @@ def testBTRFSDeviceMethods(self):
 
         # size
         with self.assertRaisesRegex(RuntimeError, "cannot directly set size of btrfs volume"):
-            self.dev1.size = 32
+            self.dev1.size = Size("500 MiB")
 
     def testBTRFSSnapShotDeviceInit(self):
-        parents = [StorageDevice("p1", fmt=blivet.formats.getFormat("btrfs"), size=btrfs.MIN_MEMBER_SIZE)]
+        parents = [StorageDevice("p1", fmt=blivet.formats.getFormat("btrfs"), size=BTRFS_MIN_MEMBER_SIZE)]
         vol = BTRFSVolumeDevice("test", parents=parents)
         with self.assertRaisesRegex(ValueError, "non-existent btrfs snapshots must have a source"):
             BTRFSSnapShotDevice("snap1", parents=[vol])
@@ -677,7 +666,7 @@ def testBTRFSSnapShotDeviceInit(self):
         with self.assertRaisesRegex(ValueError, "btrfs snapshot source must be a btrfs subvolume"):
             BTRFSSnapShotDevice("snap1", parents=[vol], source=parents[0])
 
-        parents2 = [StorageDevice("p1", fmt=blivet.formats.getFormat("btrfs"), size=btrfs.MIN_MEMBER_SIZE)]
+        parents2 = [StorageDevice("p1", fmt=blivet.formats.getFormat("btrfs"), size=BTRFS_MIN_MEMBER_SIZE)]
         vol2 = BTRFSVolumeDevice("test2", parents=parents2, exists=True)
         with self.assertRaisesRegex(ValueError, ".*snapshot and source must be in the same volume"):
             BTRFSSnapShotDevice("snap1", parents=[vol], source=vol2)
@@ -688,21 +677,22 @@ def testBTRFSSnapShotDeviceInit(self):
            parents=[vol],
            source=vol)
         self.stateCheck(snap,
-           currentSize=xform(lambda x, m: self.assertEqual(x, btrfs.MIN_MEMBER_SIZE, m)),
-           maxSize=xform(lambda x, m: self.assertEqual(x, btrfs.MIN_MEMBER_SIZE, m)),
+           currentSize=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+           targetSize=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+           maxSize=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
            parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
-           size=xform(lambda x, m: self.assertEqual(x, btrfs.MIN_MEMBER_SIZE, m)),
+           size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
            type=xform(lambda x, m: self.assertEqual(x, "btrfs snapshot", m)),
            vol_id=xform(self.assertIsNone))
         self.stateCheck(vol,
-           currentSize=xform(lambda x, m: self.assertEqual(x, btrfs.MIN_MEMBER_SIZE, m)),
+           currentSize=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
            dataLevel=xform(self.assertIsNone),
            exists=xform(self.assertTrue),
            isleaf=xform(self.assertFalse),
-           maxSize=xform(lambda x, m: self.assertEqual(x, btrfs.MIN_MEMBER_SIZE, m)),
+           maxSize=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
            metaDataLevel=xform(self.assertIsNone),
            parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
-           size=xform(lambda x, m: self.assertEqual(x, btrfs.MIN_MEMBER_SIZE, m)),
+           size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
            type=xform(lambda x, m: self.assertEqual(x, "btrfs volume", m)))
 
         self.assertEqual(snap.isleaf, True)


-- 
To view this commit on github, visit https://github.com/rhinstaller/blivet/commit/0a37278145f22fb3fa2ab7bfbdc918b0e9091def


More information about the anaconda-patches mailing list