[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