Use "require_disk" mark

Signed-off-by: Robert Baldyga <robert.baldyga@intel.com>

test/functional/tests/io_class/io_class_common.py

@@ -16,14 +16,8 @@ mountpoint = "/tmp/cas1-1"
 
 def prepare():
     ioclass_config.remove_ioclass_config()
-    cache_device = next(filter(
-        lambda disk: disk.disk_type in [DiskType.optane, DiskType.nand],
-        TestRun.dut.disks
-    ))
-    core_device = next(filter(
-        lambda disk: disk.disk_type.value > cache_device.disk_type.value,
-        TestRun.dut.disks
-    ))
+    cache_device = TestRun.disks['cache']
+    core_device = TestRun.disks['core']
 
     cache_device.create_partitions([Size(500, Unit.MebiByte)])
     core_device.create_partitions([Size(1, Unit.GibiByte)])

test/functional/tests/io_class/test_io_class_directory.py

@@ -14,14 +14,14 @@ from test_tools.disk_utils import Filesystem
 from test_utils.filesystem.directory import Directory
 from test_utils.filesystem.file import File
 from test_utils.os_utils import drop_caches, DropCachesMode, sync, Udev
+from storage_devices.disk import DiskType, DiskTypeSet, DiskTypeLowerThan
 from .io_class_common import *
 
 
+@pytest.mark.require_disk("cache", DiskTypeSet([DiskType.optane, DiskType.nand]))
+@pytest.mark.require_disk("core", DiskTypeLowerThan("cache"))
 @pytest.mark.parametrize("filesystem", Filesystem)
-@pytest.mark.parametrize(
-    "prepare_and_cleanup", [{"core_count": 1, "cache_count": 1}], indirect=True
-)
-def test_ioclass_directory_depth(prepare_and_cleanup, filesystem):
+def test_ioclass_directory_depth(filesystem):
     """
     Test if directory classification works properly for deeply nested directories for read and
     write operations.
@@ -109,11 +109,10 @@ def test_ioclass_directory_depth(prepare_and_cleanup, filesystem):
         f"Expected: {base_occupancy + test_file_2.size}, actual: {new_occupancy}"
 
 
+@pytest.mark.require_disk("cache", DiskTypeSet([DiskType.optane, DiskType.nand]))
+@pytest.mark.require_disk("core", DiskTypeLowerThan("cache"))
 @pytest.mark.parametrize("filesystem", Filesystem)
-@pytest.mark.parametrize(
-    "prepare_and_cleanup", [{"core_count": 1, "cache_count": 1}], indirect=True
-)
-def test_ioclass_directory_dir_operations(prepare_and_cleanup, filesystem):
+def test_ioclass_directory_dir_operations(filesystem):
     """
     Test if directory classification works properly after directory operations like move or rename.
     The operations themselves should not cause reclassification but IO after those operations
@@ -280,11 +279,10 @@ def test_ioclass_directory_dir_operations(prepare_and_cleanup, filesystem):
         directory=dir_1, with_delay=True)
 
 
+@pytest.mark.require_disk("cache", DiskTypeSet([DiskType.optane, DiskType.nand]))
+@pytest.mark.require_disk("core", DiskTypeLowerThan("cache"))
 @pytest.mark.parametrize("filesystem", Filesystem)
-@pytest.mark.parametrize(
-    "prepare_and_cleanup", [{"core_count": 1, "cache_count": 1}], indirect=True
-)
-def test_ioclass_directory_file_operations(prepare_and_cleanup, filesystem):
+def test_ioclass_directory_file_operations(filesystem):
     """
     Test if directory classification works properly after file operations like move or rename.
     The operations themselves should not cause reclassification but IO after those operations

test/functional/tests/io_class/test_io_class_file.py

@@ -11,13 +11,13 @@ from test_tools.dd import Dd
 from test_tools.disk_utils import Filesystem
 from test_utils.filesystem.file import File
 from test_utils.os_utils import sync, Udev, DropCachesMode, drop_caches
+from storage_devices.disk import DiskType, DiskTypeSet, DiskTypeLowerThan
 from .io_class_common import *
 
 
-@pytest.mark.parametrize(
-    "prepare_and_cleanup", [{"core_count": 1, "cache_count": 1}], indirect=True
-)
-def test_ioclass_file_extension(prepare_and_cleanup):
+@pytest.mark.require_disk("cache", DiskTypeSet([DiskType.optane, DiskType.nand]))
+@pytest.mark.require_disk("core", DiskTypeLowerThan("cache"))
+def test_ioclass_file_extension():
     cache, core = prepare()
     iterations = 50
     ioclass_id = 1
@@ -77,10 +77,9 @@ def test_ioclass_file_extension(prepare_and_cleanup):
         assert stats["dirty"].get_value(Unit.Blocks4096) == 0
 
 
-@pytest.mark.parametrize(
-    "prepare_and_cleanup", [{"core_count": 1, "cache_count": 1}], indirect=True
-)
-def test_ioclass_file_extension_preexisting_filesystem(prepare_and_cleanup):
+@pytest.mark.require_disk("cache", DiskTypeSet([DiskType.optane, DiskType.nand]))
+@pytest.mark.require_disk("core", DiskTypeLowerThan("cache"))
+def test_ioclass_file_extension_preexisting_filesystem():
     """Create files on filesystem, add device with filesystem as a core,
         write data to files and check if they are cached properly"""
     cache, core = prepare()
@@ -143,10 +142,9 @@ def test_ioclass_file_extension_preexisting_filesystem(prepare_and_cleanup):
         )
 
 
-@pytest.mark.parametrize(
-    "prepare_and_cleanup", [{"core_count": 1, "cache_count": 1}], indirect=True
-)
-def test_ioclass_file_offset(prepare_and_cleanup):
+@pytest.mark.require_disk("cache", DiskTypeSet([DiskType.optane, DiskType.nand]))
+@pytest.mark.require_disk("core", DiskTypeLowerThan("cache"))
+def test_ioclass_file_offset():
     cache, core = prepare()
 
     ioclass_id = 1
@@ -220,11 +218,10 @@ def test_ioclass_file_offset(prepare_and_cleanup):
         ), f"Inappropriately cached offset: {file_offset}"
 
 
+@pytest.mark.require_disk("cache", DiskTypeSet([DiskType.optane, DiskType.nand]))
+@pytest.mark.require_disk("core", DiskTypeLowerThan("cache"))
 @pytest.mark.parametrize("filesystem", Filesystem)
-@pytest.mark.parametrize(
-    "prepare_and_cleanup", [{"core_count": 1, "cache_count": 1}], indirect=True
-)
-def test_ioclass_file_size(prepare_and_cleanup, filesystem):
+def test_ioclass_file_size(filesystem):
     """
     File size IO class rules are configured in a way that each tested file size is unambiguously
     classified.

test/functional/tests/io_class/test_io_class_process.py

@@ -9,13 +9,13 @@ import pytest
 
 from test_tools.dd import Dd
 from test_utils.os_utils import sync, Udev
+from storage_devices.disk import DiskType, DiskTypeSet, DiskTypeLowerThan
 from .io_class_common import *
 
 
-@pytest.mark.parametrize(
-    "prepare_and_cleanup", [{"core_count": 1, "cache_count": 1}], indirect=True
-)
-def test_ioclass_process_name(prepare_and_cleanup):
+@pytest.mark.require_disk("cache", DiskTypeSet([DiskType.optane, DiskType.nand]))
+@pytest.mark.require_disk("core", DiskTypeLowerThan("cache"))
+def test_ioclass_process_name():
     """Check if data generated by process with particular name is cached"""
     cache, core = prepare()
 
@@ -54,10 +54,9 @@ def test_ioclass_process_name(prepare_and_cleanup):
         assert stats["dirty"].get_value(Unit.Blocks4096) == (i + 1) * dd_count
 
 
-@pytest.mark.parametrize(
-    "prepare_and_cleanup", [{"core_count": 1, "cache_count": 1}], indirect=True
-)
-def test_ioclass_pid(prepare_and_cleanup):
+@pytest.mark.require_disk("cache", DiskTypeSet([DiskType.optane, DiskType.nand]))
+@pytest.mark.require_disk("core", DiskTypeLowerThan("cache"))
+def test_ioclass_pid():
     cache, core = prepare()
 
     ioclass_id = 1

test/functional/tests/io_class/test_io_classification.py

@@ -14,13 +14,13 @@ from test_tools.fio.fio import Fio
 from test_tools.fio.fio_param import ReadWrite, IoEngine
 from test_utils.filesystem.file import File
 from test_utils.os_utils import sync, Udev
+from storage_devices.disk import DiskType, DiskTypeSet, DiskTypeLowerThan
 from .io_class_common import *
 
 
-@pytest.mark.parametrize(
-    "prepare_and_cleanup", [{"core_count": 1, "cache_count": 1}], indirect=True
-)
-def test_ioclass_lba(prepare_and_cleanup):
+@pytest.mark.require_disk("cache", DiskTypeSet([DiskType.optane, DiskType.nand]))
+@pytest.mark.require_disk("core", DiskTypeLowerThan("cache"))
+def test_ioclass_lba():
     """Write data to random lba and check if it is cached according to range
     defined in ioclass rule"""
     cache, core = prepare()
@@ -92,10 +92,9 @@ def test_ioclass_lba(prepare_and_cleanup):
         ), f"Inappropriately cached lba: {rand_lba}"
 
 
-@pytest.mark.parametrize(
-    "prepare_and_cleanup", [{"core_count": 1, "cache_count": 1}], indirect=True
-)
-def test_ioclass_request_size(prepare_and_cleanup):
+@pytest.mark.require_disk("cache", DiskTypeSet([DiskType.optane, DiskType.nand]))
+@pytest.mark.require_disk("core", DiskTypeLowerThan("cache"))
+def test_ioclass_request_size():
     cache, core = prepare()
 
     ioclass_id = 1
@@ -161,11 +160,10 @@ def test_ioclass_request_size(prepare_and_cleanup):
         assert stats["dirty"].get_value(Unit.Blocks4096) == 0
 
 
+@pytest.mark.require_disk("cache", DiskTypeSet([DiskType.optane, DiskType.nand]))
+@pytest.mark.require_disk("core", DiskTypeLowerThan("cache"))
 @pytest.mark.parametrize("filesystem", list(Filesystem) + [False])
-@pytest.mark.parametrize(
-    "prepare_and_cleanup", [{"core_count": 1, "cache_count": 1}], indirect=True
-)
-def test_ioclass_direct(prepare_and_cleanup, filesystem):
+def test_ioclass_direct(filesystem):
     """
     Perform buffered/direct IO to/from files or raw block device.
     Data from buffered IO should be cached.
@@ -247,11 +245,10 @@ def test_ioclass_direct(prepare_and_cleanup, filesystem):
         f"Expected: {base_occupancy + io_size}, actual: {new_occupancy}"
 
 
+@pytest.mark.require_disk("cache", DiskTypeSet([DiskType.optane, DiskType.nand]))
+@pytest.mark.require_disk("core", DiskTypeLowerThan("cache"))
 @pytest.mark.parametrize("filesystem", Filesystem)
-@pytest.mark.parametrize(
-    "prepare_and_cleanup", [{"core_count": 1, "cache_count": 1}], indirect=True
-)
-def test_ioclass_metadata(prepare_and_cleanup, filesystem):
+def test_ioclass_metadata(filesystem):
     """
     Perform operations on files that cause metadata update.
     Determine if every such operation results in increased writes to cached metadata.
@@ -338,11 +335,10 @@ def test_ioclass_metadata(prepare_and_cleanup, filesystem):
         pytest.xfail("No requests to metadata while deleting directory with files!")
 
 
+@pytest.mark.require_disk("cache", DiskTypeSet([DiskType.optane, DiskType.nand]))
+@pytest.mark.require_disk("core", DiskTypeLowerThan("cache"))
 @pytest.mark.parametrize("filesystem", Filesystem)
-@pytest.mark.parametrize(
-    "prepare_and_cleanup", [{"core_count": 1, "cache_count": 1}], indirect=True
-)
-def test_ioclass_id_as_condition(prepare_and_cleanup, filesystem):
+def test_ioclass_id_as_condition(filesystem):
     """
     Load config in which IO class ids are used as conditions in other IO class definitions.
     Check if performed IO is properly classified.
@@ -478,11 +474,10 @@ def test_ioclass_id_as_condition(prepare_and_cleanup, filesystem):
         f"Expected: {base_occupancy + ioclass_file_size}, actual: {new_occupancy}"
 
 
+@pytest.mark.require_disk("cache", DiskTypeSet([DiskType.optane, DiskType.nand]))
+@pytest.mark.require_disk("core", DiskTypeLowerThan("cache"))
 @pytest.mark.parametrize("filesystem", Filesystem)
-@pytest.mark.parametrize(
-    "prepare_and_cleanup", [{"core_count": 1, "cache_count": 1}], indirect=True
-)
-def test_ioclass_conditions_or(prepare_and_cleanup, filesystem):
+def test_ioclass_conditions_or(filesystem):
     """
     Load config with IO class combining 5 contradicting conditions connected by OR operator.
     Check if every IO fulfilling one condition is classified properly.
@@ -527,11 +522,10 @@ def test_ioclass_conditions_or(prepare_and_cleanup, filesystem):
             f"Expected: {base_occupancy + file_size}, actual: {new_occupancy}"
 
 
+@pytest.mark.require_disk("cache", DiskTypeSet([DiskType.optane, DiskType.nand]))
+@pytest.mark.require_disk("core", DiskTypeLowerThan("cache"))
 @pytest.mark.parametrize("filesystem", Filesystem)
-@pytest.mark.parametrize(
-    "prepare_and_cleanup", [{"core_count": 1, "cache_count": 1}], indirect=True
-)
-def test_ioclass_conditions_and(prepare_and_cleanup, filesystem):
+def test_ioclass_conditions_and(filesystem):
     """
     Load config with IO class combining 5 conditions contradicting at least one other condition
     connected by AND operator.