tests: refactor fault injection test

Signed-off-by: Kamil Gierszewski <kamil.gierszewski@huawei.com>

Author: Kamil Gierszewski

test/functional/tests/fault_injection/test_fault_injection_interrupts.py

@@ -25,102 +25,138 @@
 from test_tools.udev import Udev
 from type_def.size import Size, Unit
 from tests.lazy_writes.recovery.recovery_tests_methods import compare_files
+from test_utils.filesystem.file import File
 
 mount_point = "/mnt/cas"
 test_file_path = f"{mount_point}/test_file"
 iterations_per_config = 10
-cache_size = Size(16, Unit.GibiByte)
+cache_size = Size(2, Unit.GibiByte)
 
 
-@pytest.mark.parametrizex("filesystem", Filesystem)
 @pytest.mark.parametrizex("cache_mode", CacheMode.with_traits(CacheModeTrait.LazyWrites))
+@pytest.mark.parametrizex("filesystem", Filesystem)
 @pytest.mark.require_disk("cache", DiskTypeSet([DiskType.optane, DiskType.nand]))
 @pytest.mark.require_disk("core", DiskTypeLowerThan("cache"))
-def test_interrupt_core_flush(cache_mode, filesystem):
+def test_interrupt_core_flush(cache_mode: CacheMode, filesystem: Filesystem):
     """
-    title: Test if OpenCAS works correctly after core's flushing interruption.
+    title: Test for core's flush interruption.
     description: |
-      Negative test of the ability of OpenCAS to handle core flushing interruption.
+        Test the ability to handle core flush interruption.
     pass_criteria:
       - No system crash.
       - Flushing would be stopped after interruption.
       - Md5sum are correct during all test steps.
       - Dirty blocks quantity after interruption is equal or lower but non-zero.
     """
-    with TestRun.step("Prepare cache and core."):
-        cache_part, core_part = prepare()
+    cache_size = Size(2, Unit.GibiByte)
+    iterations_per_config = 10
+
+    with TestRun.step("Prepare cache and core devices"):
+        cache_dev = TestRun.disks["cache"]
+        core_dev = TestRun.disks["core"]
+
+        cache_dev.create_partitions([cache_size])
+        core_dev.create_partitions([cache_size * 2])
+
+        cache_part = cache_dev.partitions[0]
+        core_part = core_dev.partitions[0]
+
+    with TestRun.step("Disable udev"):
+        Udev.disable()
 
     for _ in TestRun.iteration(
         range(iterations_per_config), f"Reload cache configuration {iterations_per_config} times."
     ):
 
-        with TestRun.step("Start cache."):
-            cache = casadm.start_cache(cache_part, cache_mode, force=True)
+        with TestRun.step("Start cache"):
+            cache = casadm.start_cache(cache_dev=cache_part, cache_mode=cache_mode, force=True)
 
-        with TestRun.step("Set cleaning policy to NOP."):
+        with TestRun.step("Disable cleaning"):
             cache.set_cleaning_policy(CleaningPolicy.nop)
 
-        with TestRun.step(f"Add core device with {filesystem} filesystem and mount it."):
-            core_part.create_filesystem(filesystem)
+        with TestRun.step(f"Create {filesystem} filesystem on core device"):
+            core_part.create_filesystem(fs_type=filesystem)
+
+        with TestRun.step("Add core to the cache"):
             core = cache.add_core(core_part)
+
+        with TestRun.step(f"Mount core"):
             core.mount(mount_point)
 
-        with TestRun.step(f"Create test file in mount point of exported object."):
-            test_file = create_test_file()
+        with TestRun.step("Create test file in mount point of exported object"):
+            bs = Size(512, Unit.KibiByte)
+            count = int(cache_size.value / bs.value)
+            test_file = File.create_file(test_file_path)
 
-        with TestRun.step("Check md5 sum of test file."):
+            dd = (
+                Dd()
+                .input("/dev/zero")
+                .output(test_file_path)
+                .block_size(bs)
+                .count(count)
+                .oflag("direct")
+            )
+            dd.run()
+
+            test_file.refresh_item()
+
+        with TestRun.step("Calculate checksum of test file"):
             test_file_md5sum_before = test_file.md5sum()
 
-        with TestRun.step("Get number of dirty data on exported object before interruption."):
+        with TestRun.step("Get number of dirty data on exported object before interruption"):
             sync()
             drop_caches(DropCachesMode.ALL)
             core_dirty_blocks_before = core.get_dirty_blocks()
 
-        with TestRun.step("Start flushing core device."):
+        with TestRun.step("Start flushing core device"):
             flush_pid = TestRun.executor.run_in_background(
                 cli.flush_core_cmd(str(cache.cache_id), str(core.core_id))
             )
 
-        with TestRun.step("Interrupt core flushing."):
-            wait_for_flushing(cache, core)
-            percentage = casadm_parser.get_flushing_progress(cache.cache_id, core.core_id)
+        with TestRun.step("Interrupt core flushing"):
+            wait_for_flushing(cache=cache, core=core)
+            percentage = casadm_parser.get_flushing_progress(
+                cache_id=cache.cache_id, core_id=core.core_id
+            )
+
             while percentage < 50:
                 percentage = casadm_parser.get_flushing_progress(cache.cache_id, core.core_id)
-            TestRun.executor.run(f"kill -s SIGINT {flush_pid}")
 
-        with TestRun.step("Check number of dirty data on exported object after interruption."):
+            TestRun.executor.kill_process(pid=flush_pid)
+
+        with TestRun.step("Check number of dirty data on exported object after interruption"):
             core_dirty_blocks_after = core.get_dirty_blocks()
             if core_dirty_blocks_after >= core_dirty_blocks_before:
                 TestRun.LOGGER.error(
-                    "Quantity of dirty lines after core flush interruption " "should be lower."
+                    "Quantity of dirty lines after core flush interruption should be lower."
                 )
-            if int(core_dirty_blocks_after) == 0:
+            if core_dirty_blocks_after == Size.zero():
                 TestRun.LOGGER.error(
-                    "Quantity of dirty lines after core flush interruption " "should not be zero."
+                    "Quantity of dirty lines after core flush interruption should not be zero."
                 )
 
-        with TestRun.step("Unmount core and stop cache."):
+        with TestRun.step("Unmount core and stop cache"):
             core.unmount()
             cache.stop()
 
-        with TestRun.step("Mount core device."):
+        with TestRun.step("Mount core device"):
             core_part.mount(mount_point)
 
-        with TestRun.step("Check md5 sum of test file again."):
+        with TestRun.step("Compare checksum of test file"):
             if test_file_md5sum_before != test_file.md5sum():
                 TestRun.LOGGER.error(
-                    "Md5 sums before and after interrupting core flush are different."
+                    "Checksum before and after interrupting core flush are different."
                 )
 
-        with TestRun.step("Unmount core device."):
+        with TestRun.step("Unmount core device"):
             core_part.unmount()
 
 
 @pytest.mark.parametrizex("filesystem", Filesystem)
 @pytest.mark.parametrizex("cache_mode", CacheMode.with_traits(CacheModeTrait.LazyWrites))
 @pytest.mark.require_disk("cache", DiskTypeSet([DiskType.optane, DiskType.nand]))
 @pytest.mark.require_disk("core", DiskTypeLowerThan("cache"))
-def test_interrupt_cache_flush(cache_mode, filesystem):
+def test_interrupt_cache_flush(cache_mode: CacheMode, filesystem: Filesystem):
     """
     title: Test if OpenCAS works correctly after cache's flushing interruption.
     description: |
@@ -131,70 +167,101 @@ def test_interrupt_cache_flush(cache_mode, filesystem):
       - Md5sum are correct during all test steps.
       - Dirty blocks quantity after interruption is equal or lower but non-zero.
     """
-    with TestRun.step("Prepare cache and core."):
-        cache_part, core_part = prepare()
+    cache_size = Size(2, Unit.GibiByte)
+    iterations_per_config = 10
+
+    with TestRun.step("Prepare cache and core"):
+        cache_dev = TestRun.disks["cache"]
+        core_dev = TestRun.disks["core"]
+
+        cache_dev.create_partitions([cache_size])
+        core_dev.create_partitions([cache_size * 2])
+
+        cache_part = cache_dev.partitions[0]
+        core_part = core_dev.partitions[0]
+
+    with TestRun.step("Disable udev"):
+        Udev.disable()
 
     for _ in TestRun.iteration(
-        range(iterations_per_config), f"Reload cache configuration {iterations_per_config} times."
+        range(iterations_per_config), f"Reload cache configuration {iterations_per_config} times"
     ):
 
-        with TestRun.step("Start cache."):
-            cache = casadm.start_cache(cache_part, cache_mode, force=True)
+        with TestRun.step("Start cache"):
+            cache = casadm.start_cache(cache_dev=cache_part, cache_mode=cache_mode, force=True)
 
-        with TestRun.step("Set cleaning policy to NOP."):
+        with TestRun.step("Set cleaning policy to NOP"):
             cache.set_cleaning_policy(CleaningPolicy.nop)
 
-        with TestRun.step(f"Add core device with {filesystem} filesystem and mount it."):
-            core_part.create_filesystem(filesystem)
+        with TestRun.step(f"Create {filesystem} filesystem on core device"):
+            core_part.create_filesystem(fs_type=filesystem)
+
+        with TestRun.step("Add core to the cache"):
             core = cache.add_core(core_part)
+
+        with TestRun.step(f"Mount core"):
             core.mount(mount_point)
 
-        with TestRun.step(f"Create test file in mount point of exported object."):
-            test_file = create_test_file()
+        with TestRun.step("Create test file in mount point of exported object"):
+            bs = Size(512, Unit.KibiByte)
+            count = int(cache_size.value / bs.value)
+            test_file = File.create_file(test_file_path)
+
+            dd = (
+                Dd()
+                .input("/dev/zero")
+                .output(test_file_path)
+                .block_size(bs)
+                .count(count)
+                .oflag("direct")
+            )
+            dd.run()
+
+            test_file.refresh_item()
 
-        with TestRun.step("Check md5 sum of test file."):
+        with TestRun.step("Check checksum of test file"):
             test_file_md5sum_before = test_file.md5sum()
 
-        with TestRun.step("Get number of dirty data on exported object before interruption."):
+        with TestRun.step("Get number of dirty data on exported object before interruption"):
             sync()
             drop_caches(DropCachesMode.ALL)
             cache_dirty_blocks_before = cache.get_dirty_blocks()
 
-        with TestRun.step("Start flushing cache."):
+        with TestRun.step("Start flushing cache"):
             flush_pid = TestRun.executor.run_in_background(cli.flush_cache_cmd(str(cache.cache_id)))
 
         with TestRun.step("Interrupt cache flushing"):
             wait_for_flushing(cache, core)
             percentage = casadm_parser.get_flushing_progress(cache.cache_id, core.core_id)
-            while percentage < 50:
+            while percentage < 20:
                 percentage = casadm_parser.get_flushing_progress(cache.cache_id, core.core_id)
-            TestRun.executor.run(f"kill -s SIGINT {flush_pid}")
+            TestRun.executor.kill_process(pid=flush_pid)
 
-        with TestRun.step("Check number of dirty data on exported object after interruption."):
+        with TestRun.step("Check number of dirty data on exported object after interruption"):
             cache_dirty_blocks_after = cache.get_dirty_blocks()
             if cache_dirty_blocks_after >= cache_dirty_blocks_before:
                 TestRun.LOGGER.error(
-                    "Quantity of dirty lines after cache flush interruption " "should be lower."
+                    "Quantity of dirty lines after cache flush interruption should be lower."
                 )
-            if int(cache_dirty_blocks_after) == 0:
+            if cache_dirty_blocks_after == Size.zero():
                 TestRun.LOGGER.error(
-                    "Quantity of dirty lines after cache flush interruption " "should not be zero."
+                    "Quantity of dirty lines after cache flush interruption should not be zero."
                 )
 
-        with TestRun.step("Unmount core and stop cache."):
+        with TestRun.step("Unmount core and stop cache"):
             core.unmount()
             cache.stop()
 
-        with TestRun.step("Mount core device."):
+        with TestRun.step("Mount core device"):
             core_part.mount(mount_point)
 
-        with TestRun.step("Check md5 sum of test file again."):
+        with TestRun.step("Check checksum of test file again"):
             if test_file_md5sum_before != test_file.md5sum():
                 TestRun.LOGGER.error(
-                    "Md5 sums before and after interrupting cache flush are different."
+                    "Checksum before and after interrupting cache flush are different."
                 )
 
-        with TestRun.step("Unmount core device."):
+        with TestRun.step("Unmount core device"):
             core_part.unmount()
 
 
@@ -527,10 +594,7 @@ def test_interrupt_attach(cache_mode):
 
     with TestRun.step("Start attaching cache in background"):
         cache_attach_pid = TestRun.executor.run_in_background(
-            attach_cache_cmd(
-                cache_id=str(cache.cache_id),
-                cache_dev=cache_dev.path
-            )
+            attach_cache_cmd(cache_id=str(cache.cache_id), cache_dev=cache_dev.path)
         )
 
     with TestRun.step("Try to interrupt cache attaching"):