[PATCH 4/4] Add some tests for Chunk and Request class hierarchy.

David Lehman dlehman at redhat.com
Wed Jul 9 18:08:48 UTC 2014


---
 tests/partitioning_test.py | 138 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 138 insertions(+)

diff --git a/tests/partitioning_test.py b/tests/partitioning_test.py
index 2a6100f..abedde9 100644
--- a/tests/partitioning_test.py
+++ b/tests/partitioning_test.py
@@ -7,6 +7,14 @@ import parted
 
 from blivet.partitioning import getNextPartitionType
 from blivet.partitioning import doPartitioning
+from blivet.partitioning import Request
+from blivet.partitioning import Chunk
+from blivet.partitioning import LVRequest
+from blivet.partitioning import VGChunk
+
+from blivet.devices import StorageDevice
+from blivet.devices import LVMVolumeGroupDevice
+from blivet.devices import LVMLogicalVolumeDevice
 
 from tests.imagebackedtestcase import ImageBackedTestCase
 from blivet.formats import getFormat
@@ -124,6 +132,136 @@ class PartitioningTestCase(unittest.TestCase):
         disk = self.getDisk(disk_type="mac")
         self.assertEqual(getNextPartitionType(disk, no_primary=True), None)
 
+    def testChunk(self):
+        dev1 = Mock()
+        attrs = {"req_grow": True,
+                 "id": 1,
+                 "name": "req1"}
+        dev1.configure_mock(**attrs)
+
+        req1 = Request(dev1)
+        req1.base = 10
+
+        dev2 = Mock()
+        attrs = {"req_grow": False,
+                 "id": 2,
+                 "name": "req2"}
+        dev2.configure_mock(**attrs)
+
+        req2 = Request(dev2)
+        req2.base = 20
+
+        chunk = Chunk(110, requests=[req1, req2])
+        self.assertEqual(chunk.pool, 80)
+        self.assertEqual(chunk.base, 10)
+
+        dev3 = Mock()
+        attrs = {"req_grow": True,
+                 "id": 3,
+                 "name": "req3"}
+        dev3.configure_mock(**attrs)
+
+        req3 = Request(dev3)
+        req3.base = 20
+        req3.max_growth = 35
+
+        chunk.addRequest(req3)
+        self.assertEqual(chunk.pool, 60)
+        self.assertEqual(chunk.base, 30)
+
+        self.assertEqual(chunk.lengthToSize(30), 30)
+        self.assertEqual(chunk.sizeToLength(40), 40)
+        self.assertEqual(chunk.hasGrowable, True)
+
+        chunk.growRequests()
+
+        # the chunk is done growing since its pool has been exhausted
+        self.assertEqual(chunk.done, True)
+
+        # there is still one request remaining since req1 has no maximum growth
+        self.assertEqual(chunk.remaining, 1)
+
+        # req1 is 10 units and growable with no limit
+        # req2 is 20 units and not growable
+        # req3 is 20 units and growable with a limits of 35 units of growth
+        #
+        # Requests are grown at rates proportional to their share of the
+        # combined base size of all growable requests. If req3 had no max growth
+        # it would get 40 units and req1 would get 20. Since req3 has a limit,
+        # it will get 35 and req1 will get its 20 plus the leftovers from req3,
+        # which comes out to 25.
+        self.assertEqual(req1.growth, 25)
+        self.assertEqual(req2.growth, 0)
+        self.assertEqual(req3.growth, 35)
+
+    def testVGChunk(self):
+        pv = StorageDevice("pv1", size=Size("40 GiB"),
+                           fmt=getFormat("lvmpv"))
+        vg = LVMVolumeGroupDevice("vg", parents=[pv])
+        lv1 = LVMLogicalVolumeDevice("lv1", parents=[vg],
+                                     size=Size("1 GiB"), grow=True)
+        lv2 = LVMLogicalVolumeDevice("lv2", parents=[vg],
+                                     size=Size("10 GiB"), grow=True)
+        lv3 = LVMLogicalVolumeDevice("lv3", parents=[vg],
+                                     size=Size("10 GiB"), grow=True,
+                                     maxsize=Size("12 GiB"))
+
+        req1 = LVRequest(lv1)
+        req2 = LVRequest(lv2)
+        req3 = LVRequest(lv3)
+        chunk = VGChunk(vg, requests=[req1, req2, req3])
+
+        self.assertEqual(chunk.length, vg.extents)
+        self.assertEqual(chunk.pool, vg.freeExtents)
+        base_size = vg.align(sum(lv.size for lv in vg.lvs), roundup=True)
+        base = base_size / vg.peSize
+        self.assertEqual(chunk.base, base)
+
+        # default extent size is 4 MiB
+        self.assertEqual(chunk.lengthToSize(4), Size("16 MiB"))
+        self.assertEqual(chunk.sizeToLength(Size("33 MiB")), 8)
+        self.assertEqual(chunk.hasGrowable, True)
+
+        self.assertEqual(chunk.remaining, 3)
+        self.assertEqual(chunk.done, False)
+
+        chunk.growRequests()
+
+        # the chunk is done growing since its pool has been exhausted
+        self.assertEqual(chunk.done, True)
+
+        # there is still one request remaining since req1 has no maximum growth
+        self.assertEqual(chunk.remaining, 2)
+
+        #
+        # validate the resulting growth
+        #
+        # lv1 has size 1 GiB (256 extents) and is growable with no limit
+        # lv2 has size 10 GiB (2560 extents) and is growable with no limit
+        # lv3 has size 10 GiB (2560 extents) and is growable with a max size of
+        #     12 GiB (max growth of 512 extents)
+        #
+        # The vg initially has 4863 free extents.
+        # The growth ratio should be 1:10:10.
+        #
+        # The first pass through should allocate 231 extents to lv1 and 2315
+        # extents to each of lv2 and lv3, leaving one remaining extent, but
+        # it should reclaim 1803 extents from lv3 since it has a maximum growth
+        # of 512 extents (2 GiB).
+        #
+        # The second pass should then split up the remaining 1805 extents
+        # between lv1 and lv2 at a ratio of 1:10, which ends up being 164 for
+        # lv1 and 1640 for lv2. The remaining extent goes to lv2 because it is
+        # first in the list after sorting with blivet.partitioning.lvCompare.
+        #
+        # Grand totals should be as follows:
+        # lv1 should grow by 395 extents, or 1.54 GiB
+        # lv2 should grow by 3956 extents, or 15.45 GiB
+        # lv3 should grow by 512 extents, or 2 GiB
+        self.assertEqual(req1.growth, 395)
+        self.assertEqual(req2.growth, 3956)
+        self.assertEqual(req3.growth, 512)
+
 class ExtendedPartitionTestCase(ImageBackedTestCase):
 
     disks = {"disk1": Size("2 GiB")}
-- 
1.9.3



More information about the anaconda-patches mailing list