Commit bc6540ad authored by Karol Latecki's avatar Karol Latecki Committed by Daniel Verkamp
Browse files

test/lvol: add friendly name specific tests 



Adding positive and negative lvol friendly names specific tests.
Test plan updated.
Also fix some test naming discrepancies between plan and
script while at it

Change-Id: Ifb1a62d6a231f4f4ebfb5bb6178d941fc2b9770d
Signed-off-by: default avatarKarol Latecki <karol.latecki@intel.com>
Reviewed-on: https://review.gerrithub.io/385552


Reviewed-by: default avatarTomasz Zawadzki <tomasz.zawadzki@intel.com>
Reviewed-by: default avatarMaciej Szwed <maciej.szwed@intel.com>
Reviewed-by: default avatarJim Harris <james.r.harris@intel.com>
Tested-by: default avatarSPDK Automated Test System <sys_sgsw@intel.com>
parent 3a6f8dc8

autotest.sh

+1 −1
Original line number Diff line number Diff line
@@ -149,7 +149,7 @@ fi 


if [ $SPDK_TEST_LVOL -eq 1 ]; then

	timing_enter lvol

	run_test ./test/lvol/lvol.sh --test-cases=1,2,3,5,6,7,10,11,12,13,16,17,21,22,23,24

	run_test ./test/lvol/lvol.sh --test-cases=1,2,3,4,5,7,8,9,10,13,14,15,16,17,18,21,22,25,26,27,28,29

	timing_exit lvol

fi

test/lvol/test_cases.py

+209 −78
Original line number Diff line number Diff line
@@ -26,27 +26,32 @@ def header(num): 
        1: 'construct_lvs_positive',

        2: 'construct_logical_volume_positive',

        3: 'construct_multi_logical_volumes_positive',

        4: 'resize_lvol_bdev_positive',

        5: 'destroy_lvol_store_positive',

        6: 'destroy_lvol_store_with_lvol_bdev_positive',

        7: 'destroy_multi_logical_volumes_positive',

        8: 'nested_construct_logical_volume_positive',

        9: 'destroy_after_resize_lvol_bdev_positive',

        10: 'construct_lvs_nonexistent_bdev',

        11: 'construct_lvs_on_bdev_twic_negative',

        12: 'construct_logical_volume_nonexistent_lvs_uuid',

        13: 'construct_lvol_bdev_on_full_lvol_store',

        14: 'resize_logical_volume_nonexistent_logical_volume',

        15: 'resize_logical_volume_with_size_out_of_range',

        16: 'destroy_lvol_store_nonexistent_lvs_uuid',

        17: 'destroy_lvol_store_nonexistent_bdev',

        18: 'nested_construct_lvol_bdev_on_full_lvol_store',

        19: 'nested_destroy_logical_volume_positive',

        20: 'delete_bdev_positive',

        21: 'construct_lvs_with_cluster_sz_out_of_range_max',

        22: 'construct_lvs_with_cluster_sz_out_of_range_min',

        23: 'tasting_positive',

        24: 'SIGTERM',

        4: 'construct_lvol_bdev_using_name_positive',

        5: 'construct_lvol_bdev_duplicate_names_positive',

        6: 'resize_lvol_bdev_positive',

        7: 'destroy_lvol_store_positive',

        8: 'destroy_lvol_store_use_name_positive',

        9: 'destroy_lvol_store_with_lvol_bdev_positive',

        10: 'destroy_multi_logical_volumes_positive',

        11: 'nested_construct_logical_volume_positive',

        12: 'destroy_after_resize_lvol_bdev_positive',

        13: 'construct_lvs_nonexistent_bdev',

        14: 'construct_lvs_on_bdev_twice',

        15: 'construct_lvs_name_twice',

        16: 'construct_logical_volume_nonexistent_lvs_uuid',

        17: 'construct_lvol_bdev_on_full_lvol_store',

        18: 'construct_lvol_bdev_name_twice',

        19: 'resize_logical_volume_nonexistent_logical_volume',

        20: 'resize_logical_volume_with_size_out_of_range',

        21: 'destroy_lvol_store_nonexistent_lvs_uuid',

        22: 'delete_lvol_store_underlying_bdev',

        23: 'nested_construct_lvol_bdev_on_full_lvol_store',

        24: 'nested_destroy_logical_volume_negative',

        25: 'delete_bdev_positive',

        26: 'construct_lvol_store_with_cluster_size_max',

        27: 'construct_lvol_store_with_cluster_size_min',

        28: 'tasting_positive',

        29: 'SIGTERM',

    }

    print("========================================================")

    print("Test Case {num}: Start".format(num=num))
@@ -199,6 +204,66 @@ class TestCases(object): 


    def test_case4(self):

        header(4)

        base_name = self.c.construct_malloc_bdev(self.total_size,

                                                 self.block_size)



        uuid_store = self.c.construct_lvol_store(base_name,

                                                 self.lvs_name,

                                                 self.cluster_size)



        fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,

                                                  self.cluster_size)



        uuid_bdev = self.c.construct_lvol_bdev(self.lvs_name,

                                               self.lbd_name,

                                               self.total_size - 1)

        fail_count += self.c.check_get_bdevs_methods(uuid_bdev,

                                                     self.total_size - 1)



        fail_count += self.c.delete_bdev(uuid_bdev)

        fail_count += self.c.destroy_lvol_store(uuid_store)

        fail_count += self.c.delete_bdev(base_name)

        footer(4)

        return fail_count



    def test_case5(self):

        header(5)

        base_name_1 = self.c.construct_malloc_bdev(self.total_size,

                                                   self.block_size)

        base_name_2 = self.c.construct_malloc_bdev(self.total_size,

                                                   self.block_size)



        uuid_store_1 = self.c.construct_lvol_store(base_name_1,

                                                   self.lvs_name + "1",

                                                   self.cluster_size)

        uuid_store_2 = self.c.construct_lvol_store(base_name_2,

                                                   self.lvs_name + "2",

                                                   self.cluster_size)

        fail_count = self.c.check_get_lvol_stores(base_name_1, uuid_store_1,

                                                  self.cluster_size)

        fail_count = self.c.check_get_lvol_stores(base_name_2, uuid_store_2,

                                                  self.cluster_size)



        uuid_bdev_1 = self.c.construct_lvol_bdev(uuid_store_1,

                                                 self.lbd_name,

                                                 self.total_size - 1)

        uuid_bdev_2 = self.c.construct_lvol_bdev(uuid_store_2,

                                                 self.lbd_name,

                                                 self.total_size - 1)

        fail_count += self.c.check_get_bdevs_methods(uuid_bdev_1, self.total_size - 1)

        fail_count += self.c.check_get_bdevs_methods(uuid_bdev_2, self.total_size - 1)



        fail_count += self.c.delete_bdev(uuid_bdev_1)

        fail_count += self.c.delete_bdev(uuid_bdev_2)

        fail_count += self.c.destroy_lvol_store(uuid_store_1)

        fail_count += self.c.destroy_lvol_store(uuid_store_2)

        fail_count += self.c.delete_bdev(base_name_1)

        fail_count += self.c.delete_bdev(base_name_2)

        footer(5)

        return fail_count



    def test_case6(self):

        header(6)

        base_name = self.c.construct_malloc_bdev(self.total_size,

                                                 self.block_size)

        uuid_store = self.c.construct_lvol_store(base_name,
@@ -227,11 +292,11 @@ class TestCases(object): 
        self.c.delete_bdev(uuid_bdev)

        self.c.destroy_lvol_store(uuid_store)

        self.c.delete_bdev(base_name)

        footer(4)

        footer(6)

        return fail_count



    def test_case5(self):

        header(5)

    def test_case7(self):

        header(7)

        base_name = self.c.construct_malloc_bdev(self.total_size,

                                                 self.block_size)

        uuid_store = self.c.construct_lvol_store(base_name,
@@ -242,11 +307,26 @@ class TestCases(object): 
        self.c.destroy_lvol_store(uuid_store)

        fail_count += self.c.check_get_lvol_stores("", "", "")

        self.c.delete_bdev(base_name)

        footer(5)

        footer(7)

        return fail_count



    def test_case6(self):

        header(6)

    def test_case8(self):

        header(8)

        base_name = self.c.construct_malloc_bdev(self.total_size,

                                                 self.block_size)

        uuid_store = self.c.construct_lvol_store(base_name,

                                                 self.lvs_name,

                                                 self.cluster_size)

        fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,

                                                  self.cluster_size)

        fail_count += self.c.destroy_lvol_store(self.lvs_name)

        fail_count += self.c.check_get_lvol_stores("", "", "")

        fail_count += self.c.delete_bdev(base_name)

        footer(8)

        return fail_count



    def test_case9(self):

        header(9)

        base_name = self.c.construct_malloc_bdev(self.total_size,

                                                 self.block_size)

        uuid_store = self.c.construct_lvol_store(base_name,
@@ -264,11 +344,11 @@ class TestCases(object): 


        fail_count += self.c.check_get_lvol_stores("", "", "")

        self.c.delete_bdev(base_name)

        footer(6)

        footer(9)

        return fail_count



    def test_case7(self):

        header(7)

    def test_case10(self):

        header(10)

        base_name = self.c.construct_malloc_bdev(self.total_size,

                                                 self.block_size)

        uuid_store = self.c.construct_lvol_store(base_name,
@@ -287,16 +367,16 @@ class TestCases(object): 
        self.c.destroy_lvol_store(uuid_store)

        fail_count += self.c.check_get_lvol_stores("", "", "")

        self.c.delete_bdev(base_name)

        footer(7)

        footer(10)

        return fail_count



    def test_case8(self):

    def test_case11(self):

        print("Test of this feature not yet implemented.")

        pass

        return 0



    def test_case9(self):

        header(9)

    def test_case12(self):

        header(12)

        base_name = self.c.construct_malloc_bdev(self.total_size,

                                                 self.block_size)

        uuid_store = self.c.construct_lvol_store(base_name,
@@ -322,23 +402,23 @@ class TestCases(object): 
        self.c.destroy_lvol_store(uuid_store)

        fail_count += self.c.check_get_lvol_stores("", "", "")

        self.c.delete_bdev(base_name)

        footer(9)

        footer(12)

        return fail_count



    # negative tests

    def test_case10(self):

        header(10)

    def test_case13(self):

        header(13)

        fail_count = 0

        bad_bdev_id = random.randrange(999999999)

        if self.c.construct_lvol_store(bad_bdev_id,

                                       self.lvs_name,

                                       self.cluster_size) == 0:

            fail_count += 1

        footer(10)

        footer(13)

        return fail_count



    def test_case11(self):

        header(11)

    def test_case14(self):

        header(14)

        base_name = self.c.construct_malloc_bdev(self.total_size,

                                                 self.block_size)

        uuid_store = self.c.construct_lvol_store(base_name,
@@ -352,21 +432,46 @@ class TestCases(object): 
            fail_count += 1

        self.c.destroy_lvol_store(uuid_store)

        self.c.delete_bdev(base_name)

        footer(11)

        footer(14)

        return fail_count



    def test_case12(self):

        header(12)

    def test_case15(self):

        header(15)

        fail_count = 0

        base_name_1 = self.c.construct_malloc_bdev(self.total_size,

                                                   self.block_size)

        base_name_2 = self.c.construct_malloc_bdev(self.total_size,

                                                   self.block_size)

        uuid_store_1 = self.c.construct_lvol_store(base_name_1,

                                                   self.lvs_name,

                                                   self.cluster_size)

        fail_count += self.c.check_get_lvol_stores(base_name_1,

                                                   uuid_store_1,

                                                   self.cluster_size)

        if self.c.construct_lvol_store(base_name_2,

                                       self.lvs_name,

                                       self.cluster_size) == 0:

            fail_count += 1



        fail_count += self.c.destroy_lvol_store(uuid_store_1)

        fail_count += self.c.delete_bdev(base_name_1)

        fail_count += self.c.delete_bdev(base_name_2)



        footer(15)

        return fail_count



    def test_case16(self):

        header(16)

        fail_count = 0

        if self.c.construct_lvol_bdev(self._gen_lvs_uudi(),

                                      self.lbd_name,

                                      32) == 0:

            fail_count += 1

        footer(12)

        footer(16)

        return fail_count



    def test_case13(self):

        header(13)

    def test_case17(self):

        header(17)

        base_name = self.c.construct_malloc_bdev(self.total_size,

                                                 self.block_size)

        uuid_store = self.c.construct_lvol_store(base_name,
@@ -387,19 +492,45 @@ class TestCases(object): 
        self.c.delete_bdev(uuid_bdev)

        self.c.destroy_lvol_store(uuid_store)

        self.c.delete_bdev(base_name)

        footer(13)

        footer(17)

        return fail_count



    def test_case14(self):

        header(14)

    def test_case18(self):

        header(18)

        size = (self.total_size / 2) - 1

        base_name = self.c.construct_malloc_bdev(self.total_size,

                                                 self.block_size)

        uuid_store = self.c.construct_lvol_store(base_name,

                                                 self.lvs_name,

                                                 self.cluster_size)

        fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,

                                                  self.cluster_size)

        uuid_bdev = self.c.construct_lvol_bdev(uuid_store,

                                               self.lbd_name,

                                               size)

        fail_count += self.c.check_get_bdevs_methods(uuid_bdev,

                                                     size)

        if self.c.construct_lvol_bdev(uuid_store,

                                      self.lbd_name,

                                      size) == 0:

            fail_count += 1



        self.c.delete_bdev(uuid_bdev)

        self.c.destroy_lvol_store(uuid_store)

        self.c.delete_bdev(base_name)

        footer(18)

        return fail_count



    def test_case19(self):

        header(19)

        fail_count = 0

        if self.c.resize_lvol_bdev(self._gen_lvb_uudi(), 16) == 0:

            fail_count += 1

        footer(14)

        footer(19)

        return fail_count



    def test_case15(self):

        header(15)

    def test_case20(self):

        header(20)

        base_name = self.c.construct_malloc_bdev(self.total_size,

                                                 self.block_size)

        uuid_store = self.c.construct_lvol_store(base_name,
@@ -418,19 +549,19 @@ class TestCases(object): 
        self.c.delete_bdev(uuid_bdev)

        self.c.destroy_lvol_store(uuid_store)

        self.c.delete_bdev(base_name)

        footer(15)

        footer(20)

        return fail_count



    def test_case16(self):

        header(16)

    def test_case21(self):

        header(21)

        fail_count = 0

        if self.c.destroy_lvol_store(self._gen_lvs_uudi()) == 0:

            fail_count += 1

        footer(16)

        footer(21)

        return fail_count



    def test_case17(self):

        header(17)

    def test_case22(self):

        header(22)

        base_name = self.c.construct_malloc_bdev(self.total_size,

                                                 self.block_size)

        uuid_store = self.c.construct_lvol_store(base_name,
@@ -445,21 +576,21 @@ class TestCases(object): 
        if self.c.destroy_lvol_store(uuid_store) == 0:

            fail_count += 1



        footer(17)

        footer(22)

        return fail_count



    def test_case18(self):

    def test_case23(self):

        print("Test of this feature not yet implemented.")

        pass

        return 0



    def test_case19(self):

    def test_case24(self):

        print("Test of this feature not yet implemented.")

        pass

        return 0



    def test_case20(self):

        header(20)

    def test_case25(self):

        header(25)

        base_name = self.c.construct_malloc_bdev(self.total_size,

                                                 self.block_size)

        uuid_store = self.c.construct_lvol_store(base_name,
@@ -469,11 +600,11 @@ class TestCases(object): 
                                                  self.cluster_size)

        self.c.delete_bdev(base_name)

        fail_count += self.c.check_get_lvol_stores("", "", "")

        footer(20)

        footer(25)

        return fail_count



    def test_case21(self):

        header(21)

    def test_case26(self):

        header(26)

        fail_count = 0

        base_name = self.c.construct_malloc_bdev(self.total_size,

                                                 self.block_size)
@@ -481,22 +612,22 @@ class TestCases(object): 
                                       self.lvs_name,

                                       (self.total_size * 1024 * 1024) + 1) == 0:

            fail_count += 1

        footer(21)

        footer(26)

        return fail_count



    def test_case22(self):

        header(22)

    def test_case27(self):

        header(27)

        fail_count = 0

        base_name = self.c.construct_malloc_bdev(self.total_size,

                                                 self.block_size)

        if self.c.construct_lvol_store(base_name,

                                       self.lvs_name, 0) == 0:

            fail_count += 1

        footer(22)

        footer(27)

        return fail_count



    def test_case23(self):

        header(23)

    def test_case28(self):

        header(28)

        fail_count = 0

        uuid_bdevs = []

        base_name = "Nvme0n1"
@@ -535,7 +666,7 @@ class TestCases(object): 
        remove(pid_path)

        if self._start_vhost(vhost_path, config_path, pid_path) != 0:

            fail_count += 1

            footer(23)

            footer(28)

            return fail_count



        # Check if configuration was properly loaded after tasting
@@ -562,7 +693,7 @@ class TestCases(object): 
                pprint.pprint([o, n])



        if fail_count != 0:

            footer(23)

            footer(28)

            return fail_count



        # Try modifying loaded configuration
@@ -600,11 +731,11 @@ class TestCases(object): 
        if self.c.destroy_lvol_store(uuid_store) != 0:

            fail_count += 1



        footer(23)

        footer(28)

        return fail_count



    def test_case24(self):

        header(24)

    def test_case29(self):

        header(29)

        pid_path = path.join(self.path, 'vhost.pid')



        base_name = self.c.construct_malloc_bdev(self.total_size,
@@ -616,5 +747,5 @@ class TestCases(object): 
                                                  self.cluster_size)



        fail_count += self._stop_vhost(pid_path)

        footer(24)

        footer(29)

        return fail_count

test/lvol/test_plan.md

+117 −21

File changed.

Preview size limit exceeded, changes collapsed.