From 3a513b4d7f14406d94614643327ce2d8ab35f7eb Mon Sep 17 00:00:00 2001

From: Vojtech Trefny <vtrefny@redhat.com>

Date: Thu, 14 Mar 2019 09:34:02 +0100

Subject: [PATCH 01/10] Add a decorator for "tagging" tests

Tests function (or classes) can be tagged with one or more tags.

This provides easier way to skip slow/unstable/dangerous tests

and/or or some subset of the tests (e.g. run only unstable tests

to check if the test is still failing).

---

 tests/utils.py | 26 ++++++++++++++++++++++++++

 1 file changed, 26 insertions(+)

diff --git a/tests/utils.py b/tests/utils.py

index a9eb430..82b5494 100644

--- a/tests/utils.py

+++ b/tests/utils.py

@@ -10,6 +10,7 @@ import unittest

 import time

 import sys

 from contextlib import contextmanager

+from enum import Enum

 from itertools import chain

 from gi.repository import GLib

@@ -342,6 +343,31 @@ def unstable_test(test):

     return decorated_test

+class TestTags(Enum):

+    SLOW = 1        # slow tests

+    UNSTABLE = 2    # randomly failing tests

+    UNSAFE = 3      # tests that change system configuration

+    CORE = 4        # tests covering core functionality

+    NOSTORAGE = 5   # tests that don't work with storage

+    EXTRADEPS = 6   # tests that require special configuration and/or device to run

+    REGRESSION = 7  # regression tests

+

+

+def tag_test(*tags):

+    def decorator(func):

+        func.slow = TestTags.SLOW in tags

+        func.unstable = TestTags.UNSTABLE in tags

+        func.unsafe = TestTags.UNSAFE in tags

+        func.core = TestTags.CORE in tags

+        func.nostorage = TestTags.NOSTORAGE in tags

+        func.extradeps = TestTags.EXTRADEPS in tags

+        func.regression = TestTags.REGRESSION in tags

+

+        return func

+

+    return decorator

+

+

 def run(cmd_string):

     """

     Run the a command with file descriptors closed as lvm is trying to

-- 

2.20.1

From f3648fed9c98e779c9f265262a4a77a905689fe7 Mon Sep 17 00:00:00 2001

From: Vojtech Trefny <vtrefny@redhat.com>

Date: Thu, 14 Mar 2019 09:37:18 +0100

Subject: [PATCH 02/10] Use test tags for skipping tests

This loads all individual test functions from the suite and checks

the tags to decide whether the test should be skippend or not.

We are abusing some unittest internal API to do this, but all

private functions works with Python 2 and Python 3 and general

looks like "stable enough" API.

---

 tests/run_tests.py | 130 ++++++++++++++++++++++++++++++++++++++++++---

 1 file changed, 124 insertions(+), 6 deletions(-)

diff --git a/tests/run_tests.py b/tests/run_tests.py

index 6f74430..5301d07 100644

--- a/tests/run_tests.py

+++ b/tests/run_tests.py

@@ -16,6 +16,82 @@ LIBDIRS = 'src/utils/.libs:src/plugins/.libs:src/plugins/fs/.libs:src/lib/.libs'

 GIDIR = 'src/lib'

+def _get_tests_from_suite(suite, tests):

+    """ Extract tests from the test suite """

+    # 'tests' we get from 'unittest.defaultTestLoader.discover' are "wrapped"

+    # in multiple 'unittest.suite.TestSuite' classes/lists so we need to "unpack"

+    # the indivudual test cases

+    for test in suite:

+        if isinstance(test, unittest.suite.TestSuite):

+            _get_tests_from_suite(test, tests)

+

+        if isinstance(test, unittest.TestCase):

+            tests.append(test)

+

+    return tests

+

+

+def _get_test_tags(test):

+    """ Get test tags for single test case """

+

+    tags = []

+

+    # test failed to load, usually some ImportError or something really broken

+    # in the test file, just return empty list and let it fail

+    # with python2 the loader will raise an exception directly without returning

+    # a "fake" FailedTest test case

+    if six.PY3 and isinstance(test, unittest.loader._FailedTest):

+        return tags

+

+    test_fn = getattr(test, test._testMethodName)

+

+    # it is possible to either tag a test funcion or the class so we need to

+    # check both for the tag

+    if getattr(test_fn, "slow", False) or getattr(test_fn.__self__, "slow", False):

+        tags.append(TestTags.SLOW)

+    if getattr(test_fn, "unstable", False) or getattr(test_fn.__self__, "unstable", False):

+        tags.append(TestTags.UNSTABLE)

+    if getattr(test_fn, "unsafe", False) or getattr(test_fn.__self__, "unsafe", False):

+        tags.append(TestTags.UNSAFE)

+    if getattr(test_fn, "core", False) or getattr(test_fn.__self__, "core", False):

+        tags.append(TestTags.CORE)

+    if getattr(test_fn, "nostorage", False) or getattr(test_fn.__self__, "nostorage", False):

+        tags.append(TestTags.NOSTORAGE)

+    if getattr(test_fn, "extradeps", False) or getattr(test_fn.__self__, "extradeps", False):

+        tags.append(TestTags.EXTRADEPS)

+    if getattr(test_fn, "regression", False) or getattr(test_fn.__self__, "regression", False):

+        tags.append(TestTags.REGRESSION)

+

+    return tags

+

+

+def _print_skip_message(test, skip_tag):

+

+    # test.id() looks like 'crypto_test.CryptoTestResize.test_luks2_resize'

+    # and we want to print 'test_luks2_resize (crypto_test.CryptoTestResize)'

+    test_desc = test.id().split(".")

+    test_name = test_desc[-1]

+    test_module = ".".join(test_desc[:-1])

+

+    if skip_tag == TestTags.SLOW:

+        reason = "skipping slow tests"

+    elif skip_tag == TestTags.UNSTABLE:

+        reason = "skipping unstable tests"

+    elif skip_tag == TestTags.UNSAFE:

+        reason = "skipping test that modifies system configuration"

+    elif skip_tag == TestTags.EXTRADEPS:

+        reason = "skipping test that requires special configuration"

+    elif skip_tag == TestTags.CORE:

+        reason = "skipping non-core test"

+    else:

+        reason = "unknown reason"  # just to be sure there is some default value

+

+    if test._testMethodDoc:

+        print("%s (%s)\n%s ... skipped '%s'" % (test_name, test_module, test._testMethodDoc, reason))

+    else:

+        print("%s (%s) ... skipped '%s'" % (test_name, test_module, reason))

+

+

 if __name__ == '__main__':

     testdir = os.path.abspath(os.path.dirname(__file__))

@@ -45,6 +121,9 @@ if __name__ == '__main__':

     argparser.add_argument('-j', '--jenkins', dest='jenkins',

                            help='run also tests that should run only in a CI environment',

                            action='store_true')

+    argparser.add_argument('-c', '--core', dest='core',

+                           help='run tests that cover basic functionality of the library and regression tests',

+                           action='store_true')

     argparser.add_argument('-s', '--stop', dest='stop',

                            help='stop executing after first failed test',

                            action='store_true')

@@ -57,21 +136,60 @@ if __name__ == '__main__':

     if args.jenkins:

         os.environ['JENKINS_HOME'] = ''

+    # read the environmental variables for backwards compatibility

+    if 'JENKINS_HOME' in os.environ:

+        args.jenkins = True

+    if 'SKIP_SLOW' in os.environ:

+        args.fast = True

+    if 'FEELINGLUCKY' in os.environ:

+        args.lucky = True

+

     sys.path.append(testdir)

     sys.path.append(projdir)

     sys.path.append(os.path.join(projdir, 'src/python'))

     start_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")

+    loader = unittest.defaultTestLoader

     suite = unittest.TestSuite()

+

     if args.testname:

-        loader = unittest.TestLoader()

-        tests = loader.loadTestsFromNames(args.testname)

-        suite.addTests(tests)

+        test_cases = loader.loadTestsFromNames(args.testname)

     else:

-        loader = unittest.TestLoader()

-        tests = loader.discover(start_dir=testdir, pattern='*_test*.py')

-        suite.addTests(tests)

+        test_cases = loader.discover(start_dir=testdir, pattern='*_test*.py')

+

+    # extract list of test classes so we can check/run them manually one by one

+    tests = []

+    tests = _get_tests_from_suite(test_cases, tests)

+

+    # for some reason overrides_hack will fail if we import this at the start

+    # of the file

+    from utils import TestTags

+

+    for test in tests:

+        # get tags and (possibly) skip the test

+        tags = _get_test_tags(test)

+

+        if TestTags.SLOW in tags and args.fast:

+            _print_skip_message(test, TestTags.SLOW)

+            continue

+        if TestTags.UNSTABLE in tags and not args.lucky:

+            _print_skip_message(test, TestTags.UNSTABLE)

+            continue

+        if TestTags.UNSAFE in tags or TestTags.EXTRADEPS in tags and not args.jenkins:

+            _print_skip_message(test, TestTags.UNSAFE)

+            continue

+        if TestTags.EXTRADEPS in tags and not args.jenkins:

+            _print_skip_message(test, TestTags.EXTRADEPS)

+            continue

+

+        if args.core and TestTags.CORE not in tags and TestTags.REGRESSION not in tags:

+            _print_skip_message(test, TestTags.CORE)

+            continue

+

+        # finally add the test to the suite

+        suite.addTest(test)

+

     result = unittest.TextTestRunner(verbosity=2, failfast=args.stop).run(suite)

     # dump cropped journal to log file

-- 

2.20.1

From f4dd0bfff61d117096c1802ab793b3ab9a31dae3 Mon Sep 17 00:00:00 2001

From: Vojtech Trefny <vtrefny@redhat.com>

Date: Thu, 14 Mar 2019 09:43:37 +0100

Subject: [PATCH 03/10] Use the new test tags in tests

---

 tests/btrfs_test.py     | 14 ++++++--

 tests/crypto_test.py    | 73 +++++++++++++++++++++--------------------

 tests/dm_test.py        |  5 ++-

 tests/fs_test.py        | 18 +++++++---

 tests/kbd_test.py       | 24 +++++++-------

 tests/library_test.py   | 13 +++++---

 tests/loop_test.py      |  5 ++-

 tests/lvm_dbus_tests.py | 44 ++++++++++++++++---------

 tests/lvm_test.py       | 44 ++++++++++++++++---------

 tests/mdraid_test.py    | 38 ++++++++++++---------

 tests/mpath_test.py     |  5 ++-

 tests/nvdimm_test.py    |  9 +++--

 tests/overrides_test.py |  5 +++

 tests/part_test.py      | 11 ++++++-

 tests/s390_test.py      |  6 +++-

 tests/swap_test.py      |  7 +++-

 tests/utils_test.py     | 10 ++++--

 tests/vdo_test.py       | 13 ++++++--

 18 files changed, 227 insertions(+), 117 deletions(-)

diff --git a/tests/btrfs_test.py b/tests/btrfs_test.py

index ac1594f..eab25db 100644

--- a/tests/btrfs_test.py

+++ b/tests/btrfs_test.py

@@ -10,7 +10,7 @@ from distutils.version import LooseVersion

 from distutils.spawn import find_executable

 import overrides_hack

-from utils import create_sparse_tempfile, create_lio_device, delete_lio_device, fake_utils, fake_path, skip_on, mount, umount, run_command

+from utils import create_sparse_tempfile, create_lio_device, delete_lio_device, fake_utils, fake_path, mount, umount, run_command, TestTags, tag_test

 from gi.repository import GLib, BlockDev

 TEST_MNT = "/tmp/libblockdev_test_mnt"

@@ -74,6 +74,7 @@ class BtrfsTestCase(unittest.TestCase):

         return LooseVersion(m.groups()[0])

 class BtrfsTestCreateQuerySimple(BtrfsTestCase):

+    @tag_test(TestTags.CORE)

     def test_create_and_query_volume(self):

         """Verify that btrfs volume creation and querying works"""

@@ -180,6 +181,7 @@ class BtrfsTestAddRemoveDevice(BtrfsTestCase):

         self.assertEqual(len(devs), 1)

 class BtrfsTestCreateDeleteSubvolume(BtrfsTestCase):

+    @tag_test(TestTags.CORE)

     def test_create_delete_subvolume(self):

         """Verify that it is possible to create/delete subvolume"""

@@ -306,6 +308,7 @@ class BtrfsTestSetDefaultSubvolumeID(BtrfsTestCase):

         self.assertEqual(ret, 5)

 class BtrfsTestListDevices(BtrfsTestCase):

+    @tag_test(TestTags.CORE)

     def test_list_devices(self):

         """Verify that it is possible to get info about devices"""

@@ -324,6 +327,7 @@ class BtrfsTestListDevices(BtrfsTestCase):

         self.assertTrue(devs[1].used >= 0)

 class BtrfsTestListSubvolumes(BtrfsTestCase):

+    @tag_test(TestTags.CORE)

     def test_list_subvolumes(self):

         """Verify that it is possible to get info about subvolumes"""

@@ -344,6 +348,7 @@ class BtrfsTestListSubvolumes(BtrfsTestCase):

         self.assertEqual(subvols[0].path, "subvol1")

 class BtrfsTestFilesystemInfo(BtrfsTestCase):

+    @tag_test(TestTags.CORE)

     def test_filesystem_info(self):

         """Verify that it is possible to get filesystem info"""

@@ -376,6 +381,7 @@ class BtrfsTestFilesystemInfoNoLabel(BtrfsTestCase):

         self.assertTrue(info.used >= 0)

 class BtrfsTestMkfs(BtrfsTestCase):

+    @tag_test(TestTags.CORE)

     def test_mkfs(self):

         """Verify that it is possible to create a btrfs filesystem"""

@@ -489,7 +495,6 @@ class BtrfsTooSmallTestCase (BtrfsTestCase):

             pass

         os.unlink(self.dev_file2)

-    @skip_on("fedora", "25", reason="Min sizes for Btrfs are different on F25")

     def test_create_too_small(self):

         """Verify that an attempt to create BTRFS on a too small device fails"""

@@ -527,7 +532,6 @@ class BtrfsJustBigEnoughTestCase (BtrfsTestCase):

             pass

         os.unlink(self.dev_file2)

-    @skip_on("fedora", "25", reason="Min sizes for Btrfs are different on F25")

     def test_create_just_enough(self):

         """Verify that creating BTRFS on a just big enough devices works"""

@@ -541,6 +545,7 @@ class FakeBtrfsUtilsTestCase(BtrfsTestCase):

     def setUp(self):

         pass

+    @tag_test(TestTags.NOSTORAGE)

     def test_list_subvols_weird_docker_data(self):

         """Verify that list_subvolumes works as expected on weird data from one Docker use case"""

@@ -562,6 +567,7 @@ class BTRFSUnloadTest(BtrfsTestCase):

         # tests

         self.addCleanup(BlockDev.reinit, self.requested_plugins, True, None)

+    @tag_test(TestTags.NOSTORAGE)

     def test_check_low_version(self):

         """Verify that checking the minimum BTRFS version works as expected"""

@@ -579,6 +585,7 @@ class BTRFSUnloadTest(BtrfsTestCase):

         self.assertTrue(BlockDev.reinit(self.requested_plugins, True, None))

         self.assertIn("btrfs", BlockDev.get_available_plugin_names())

+    @tag_test(TestTags.NOSTORAGE)

     def test_check_new_version_format(self):

         """Verify that checking the minimum BTRFS version works as expected with the new format"""

@@ -594,6 +601,7 @@ class BTRFSUnloadTest(BtrfsTestCase):

         BlockDev.reinit(self.requested_plugins, True, None)

         self.assertIn("btrfs", BlockDev.get_available_plugin_names())

+    @tag_test(TestTags.NOSTORAGE)

     def test_check_no_btrfs(self):

         """Verify that checking btrfs tool availability works as expected"""

diff --git a/tests/crypto_test.py b/tests/crypto_test.py

index 7320e74..b062505 100644

--- a/tests/crypto_test.py

+++ b/tests/crypto_test.py

@@ -9,7 +9,7 @@ import locale

 import re

 import tarfile

-from utils import create_sparse_tempfile, create_lio_device, delete_lio_device, skip_on, get_avail_locales, requires_locales, run_command, read_file

+from utils import create_sparse_tempfile, create_lio_device, delete_lio_device, skip_on, get_avail_locales, requires_locales, run_command, read_file, TestTags, tag_test

 from gi.repository import BlockDev, GLib

 PASSWD = "myshinylittlepassword"

@@ -92,6 +92,7 @@ class CryptoTestGenerateBackupPassphrase(CryptoTestCase):

         # we don't need block devices for this test

         pass

+    @tag_test(TestTags.NOSTORAGE)

     def test_generate_backup_passhprase(self):

         """Verify that backup passphrase generation works as expected"""

@@ -101,7 +102,7 @@ class CryptoTestGenerateBackupPassphrase(CryptoTestCase):

             six.assertRegex(self, bp, exp)

 class CryptoTestFormat(CryptoTestCase):

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW, TestTags.CORE)

     def test_luks_format(self):

         """Verify that formating device as LUKS works"""

@@ -121,7 +122,7 @@ class CryptoTestFormat(CryptoTestCase):

         succ = BlockDev.crypto_luks_format_blob(self.loop_dev, "aes-cbc-essiv:sha256", 0, [ord(c) for c in PASSWD], 0)

         self.assertTrue(succ)

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW, TestTags.CORE)

     @unittest.skipUnless(HAVE_LUKS2, "LUKS 2 not supported")

     def test_luks2_format(self):

         """Verify that formating device as LUKS 2 works"""

@@ -222,7 +223,7 @@ class CryptoTestFormat(CryptoTestCase):

         self.assertEqual(int(m.group(1)), 5)

 class CryptoTestResize(CryptoTestCase):

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW)

     def test_luks_resize(self):

         """Verify that resizing LUKS device works"""

@@ -244,7 +245,7 @@ class CryptoTestResize(CryptoTestCase):

         succ = BlockDev.crypto_luks_close("libblockdevTestLUKS")

         self.assertTrue(succ)

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW)

     @unittest.skipUnless(HAVE_LUKS2, "LUKS 2 not supported")

     def test_luks2_resize(self):

         """Verify that resizing LUKS 2 device works"""

@@ -304,11 +305,11 @@ class CryptoTestOpenClose(CryptoTestCase):

         succ = BlockDev.crypto_luks_close("libblockdevTestLUKS")

         self.assertTrue(succ)

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW, TestTags.CORE)

     def test_luks_open_close(self):

         self._luks_open_close(self._luks_format)

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW, TestTags.CORE)

     @unittest.skipUnless(HAVE_LUKS2, "LUKS 2 not supported")

     def test_luks2_open_close(self):

         self._luks_open_close(self._luks2_format)

@@ -329,11 +330,11 @@ class CryptoTestAddKey(CryptoTestCase):

         succ = BlockDev.crypto_luks_add_key_blob(self.loop_dev, [ord(c) for c in PASSWD2], [ord(c) for c in PASSWD3])

         self.assertTrue(succ)

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW)

     def test_luks_add_key(self):

         self._add_key(self._luks_format)

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW)

     @unittest.skipUnless(HAVE_LUKS2, "LUKS 2 not supported")

     def test_luks2_add_key(self):

         self._add_key(self._luks2_format)

@@ -360,11 +361,11 @@ class CryptoTestRemoveKey(CryptoTestCase):

         succ = BlockDev.crypto_luks_remove_key_blob(self.loop_dev, [ord(c) for c in PASSWD2])

         self.assertTrue(succ)

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW)

     def test_luks_remove_key(self):

         self._remove_key(self._luks_format)

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW)

     @unittest.skipUnless(HAVE_LUKS2, "LUKS 2 not supported")

     def test_luks2_remove_key(self):

         self._remove_key(self._luks2_format)

@@ -380,7 +381,7 @@ class CryptoTestErrorLocale(CryptoTestCase):

         if self._orig_loc:

             locale.setlocale(locale.LC_ALL, self._orig_loc)

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW)

     @requires_locales({"cs_CZ.UTF-8"})

     def test_error_locale_key(self):

         """Verify that the error msg is locale agnostic"""

@@ -407,11 +408,11 @@ class CryptoTestChangeKey(CryptoTestCase):

         succ = BlockDev.crypto_luks_change_key_blob(self.loop_dev, [ord(c) for c in PASSWD2], [ord(c) for c in PASSWD3])

         self.assertTrue(succ)

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW)

     def test_luks_change_key(self):

         self._change_key(self._luks_format)

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW)

     @unittest.skipUnless(HAVE_LUKS2, "LUKS 2 not supported")

     def test_luks2_change_key(self):

         self._change_key(self._luks2_format)

@@ -432,11 +433,11 @@ class CryptoTestIsLuks(CryptoTestCase):

         is_luks = BlockDev.crypto_device_is_luks(self.loop_dev2)

         self.assertFalse(is_luks)

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW)

     def test_is_luks(self):

         self._is_luks(self._luks_format)

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW)

     @unittest.skipUnless(HAVE_LUKS2, "LUKS 2 not supported")

     def test_is_luks2(self):

         self._is_luks(self._luks2_format)

@@ -468,11 +469,11 @@ class CryptoTestLuksStatus(CryptoTestCase):

         with self.assertRaises(GLib.GError):

             BlockDev.crypto_luks_status("libblockdevTestLUKS")

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW)

     def test_luks_status(self):

         self._luks_status(self._luks_format)

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW)

     @unittest.skipUnless(HAVE_LUKS2, "LUKS 2 not supported")

     def test_luks2_status(self):

         self._luks_status(self._luks2_format)

@@ -490,18 +491,18 @@ class CryptoTestGetUUID(CryptoTestCase):

         with self.assertRaises(GLib.GError):

             uuid = BlockDev.crypto_luks_uuid(self.loop_dev2)

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW)

     def test_luks_get_uuid(self):

         self._get_uuid(self._luks_format)

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW)

     @unittest.skipUnless(HAVE_LUKS2, "LUKS 2 not supported")

     def test_luks2_get_uuid(self):

         self._get_uuid(self._luks2_format)

 class CryptoTestGetMetadataSize(CryptoTestCase):

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW)

     @unittest.skipUnless(HAVE_LUKS2, "LUKS 2 not supported")

     def test_luks2_get_metadata_size(self):

         """Verify that getting LUKS 2 device metadata size works"""

@@ -521,7 +522,7 @@ class CryptoTestGetMetadataSize(CryptoTestCase):

         offset = int(m.group(1))

         self.assertEquals(meta_size, offset, "LUKS 2 metadata sizes differ")

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW)

     def test_luks_get_metadata_size(self):

         """Verify that getting LUKS device metadata size works"""

@@ -570,11 +571,11 @@ class CryptoTestLuksOpenRW(CryptoTestCase):

         succ = BlockDev.crypto_luks_close("libblockdevTestLUKS")

         self.assertTrue(succ)

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW)

     def test_luks_open_rw(self):

         self._luks_open_rw(self._luks_format)

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW)

     @unittest.skipUnless(HAVE_LUKS2, "LUKS 2 not supported")

     def test_luks2_open_rw(self):

         self._luks_open_rw(self._luks2_format)

@@ -609,7 +610,7 @@ class CryptoTestEscrow(CryptoTestCase):

             '-a', '-o', self.public_cert])

         self.addCleanup(os.unlink, self.public_cert)

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW)

     @skip_on(("centos", "enterprise_linux"), "7", reason="volume_key asks for password in non-interactive mode on this release")

     @skip_on("debian", reason="volume_key asks for password in non-interactive mode on this release")

     def test_escrow_packet(self):

@@ -654,7 +655,7 @@ class CryptoTestEscrow(CryptoTestCase):

         succ = BlockDev.crypto_luks_open(self.loop_dev, 'libblockdevTestLUKS', PASSWD3, None)

         self.assertTrue(succ)

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW)

     def test_backup_passphrase(self):

         """Verify that a backup passphrase can be created for a device"""

         succ = BlockDev.crypto_luks_format(self.loop_dev, None, 0, PASSWD, None, 0)

@@ -735,12 +736,12 @@ class CryptoTestSuspendResume(CryptoTestCase):

         succ = BlockDev.crypto_luks_close("libblockdevTestLUKS")

         self.assertTrue(succ)

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW)

     def test_luks_suspend_resume(self):

         """Verify that suspending/resuming LUKS device works"""

         self._luks_suspend_resume(self._luks_format)

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW)

     @unittest.skipUnless(HAVE_LUKS2, "LUKS 2 not supported")

     def test_luks2_suspend_resume(self):

         """Verify that suspending/resuming LUKS 2 device works"""

@@ -781,12 +782,12 @@ class CryptoTestKillSlot(CryptoTestCase):

         succ = BlockDev.crypto_luks_close("libblockdevTestLUKS")

         self.assertTrue(succ)

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW)

     def test_luks_kill_slot(self):

         """Verify that killing a key slot on LUKS device works"""

         self._luks_kill_slot(self._luks_format)

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW)

     @unittest.skipUnless(HAVE_LUKS2, "LUKS 2 not supported")

     def test_luks2_kill_slot(self):

         """Verify that killing a key slot on LUKS 2 device works"""

@@ -836,19 +837,19 @@ class CryptoTestHeaderBackupRestore(CryptoTestCase):

         succ = BlockDev.crypto_luks_close("libblockdevTestLUKS")

         self.assertTrue(succ)

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW)

     def test_luks_header_backup_restore(self):

         """Verify that header backup/restore with LUKS works"""

         self._luks_header_backup_restore(self._luks_format)

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW)

     @unittest.skipUnless(HAVE_LUKS2, "LUKS 2 not supported")

     def test_luks2_header_backup_restore(self):

         """Verify that header backup/restore with LUKS2 works"""

         self._luks_header_backup_restore(self._luks2_format)

 class CryptoTestInfo(CryptoTestCase):

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW, TestTags.CORE)

     def test_luks_format(self):

         """Verify that we can get information about a LUKS device"""

@@ -872,7 +873,7 @@ class CryptoTestInfo(CryptoTestCase):

         succ = BlockDev.crypto_luks_close("libblockdevTestLUKS")

         self.assertTrue(succ)

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW, TestTags.CORE)

     @unittest.skipUnless(HAVE_LUKS2, "LUKS 2 not supported")

     def test_luks2_format(self):

         """Verify that we can get information about a LUKS 2 device"""

@@ -903,7 +904,7 @@ class CryptoTestInfo(CryptoTestCase):

         self.assertTrue(succ)

 class CryptoTestIntegrity(CryptoTestCase):

-    @unittest.skipIf("SKIP_SLOW" in os.environ, "skipping slow tests")

+    @tag_test(TestTags.SLOW)

     @unittest.skipUnless(HAVE_LUKS2, "LUKS 2 not supported")

     def test_luks2_integrity(self):

         """Verify that we can get create a LUKS 2 device with integrity"""

@@ -983,6 +984,7 @@ class CryptoTestTrueCrypt(CryptoTestCase):

         if not succ:

             raise RuntimeError("Failed to tear down loop device used for testing")

+    @tag_test(TestTags.NOSTORAGE)

     def test_truecrypt_open_close(self):

         """Verify that opening/closing TrueCrypt device works"""

@@ -1003,6 +1005,7 @@ class CryptoTestTrueCrypt(CryptoTestCase):

         self.assertTrue(succ)

         self.assertFalse(os.path.exists("/dev/mapper/libblockdevTestTC"))

+    @tag_test(TestTags.NOSTORAGE)

     def test_veracrypt_open_close(self):

         """Verify that opening/closing VeraCrypt device works"""

diff --git a/tests/dm_test.py b/tests/dm_test.py

index 0dd1861..936e305 100644

--- a/tests/dm_test.py

+++ b/tests/dm_test.py

@@ -2,7 +2,7 @@ import unittest

 import os

 import overrides_hack

-from utils import run, create_sparse_tempfile, create_lio_device, delete_lio_device, fake_utils, fake_path

+from utils import run, create_sparse_tempfile, create_lio_device, delete_lio_device, fake_utils, fake_path, TestTags, tag_test

 from gi.repository import BlockDev, GLib

@@ -65,6 +65,7 @@ class DevMapperGetSubsystemFromName(DevMapperTestCase):

         self.assertEqual(subsystem, "CRYPT")

 class DevMapperCreateRemoveLinear(DevMapperTestCase):

+    @tag_test(TestTags.CORE)

     def test_create_remove_linear(self):

         """Verify that it is possible to create new linear mapping and remove it"""

@@ -120,6 +121,7 @@ class DMUnloadTest(DevMapperTestCase):

         # tests

         self.addCleanup(BlockDev.reinit, self.requested_plugins, True, None)

+    @tag_test(TestTags.NOSTORAGE)

     def test_check_low_version(self):

         """Verify that checking the minimum dmsetup version works as expected"""

@@ -137,6 +139,7 @@ class DMUnloadTest(DevMapperTestCase):

         self.assertTrue(BlockDev.reinit(self.requested_plugins, True, None))

         self.assertIn("dm", BlockDev.get_available_plugin_names())

+    @tag_test(TestTags.NOSTORAGE)

     def test_check_no_dm(self):

         """Verify that checking dmsetup tool availability works as expected"""

diff --git a/tests/fs_test.py b/tests/fs_test.py

index d3f3353..adcf312 100644

--- a/tests/fs_test.py

+++ b/tests/fs_test.py