ivampiresp/Spdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

test/lvol: Reordering existing test cases.

Browse Source 
It will allow to put another test cases
in specifig group.

Change-Id: Id352aa516676f78cdb102f8eac70144f115976a5
Signed-off-by: Pawel Kaminski <pawelx.kaminski@intel.com>
Reviewed-on: https://review.gerrithub.io/389098
Tested-by: SPDK Automated Test System <sys_sgsw@intel.com>
Reviewed-by: Karol Latecki <karol.latecki@intel.com>
Reviewed-by: Jim Harris <james.r.harris@intel.com>
Reviewed-by: Daniel Verkamp <daniel.verkamp@intel.com>
This commit is contained in:
Pawel Kaminski 2017-11-27 17:42:39 +01:00 committed by Jim Harris
parent 415a1485cf
commit 23782bc43c
3 changed files with 405 additions and 403 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
autotest.sh
View File

@ -154,7 +154,9 @@ fi
if [ $SPDK_TEST_LVOL -eq 1 ]; then
timing_enter lvol
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
test_cases="1,50,51,52,53,100,101,102,250,251,252,253,"
test_cases+="300,301,450,451,452,550,600,601,650,700"
run_test ./test/lvol/lvol.sh --test-cases=$test_cases
timing_exit lvol
fi

431
test/lvol/test_cases.py
View File

@ -24,34 +24,34 @@ def test_counter():
def header(num):
test_name = {
1: 'construct_lvs_positive',
2: 'construct_logical_volume_positive',
3: 'construct_multi_logical_volumes_positive',
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',
50: 'construct_logical_volume_positive',
51: 'construct_multi_logical_volumes_positive',
52: 'construct_lvol_bdev_using_name_positive',
53: 'construct_lvol_bdev_duplicate_names_positive',
100: 'construct_logical_volume_nonexistent_lvs_uuid',
101: 'construct_lvol_bdev_on_full_lvol_store',
102: 'construct_lvol_bdev_name_twice',
150: 'resize_lvol_bdev_positive',
200: 'resize_logical_volume_nonexistent_logical_volume',
201: 'resize_logical_volume_with_size_out_of_range',
250: 'destroy_lvol_store_positive',
251: 'destroy_lvol_store_use_name_positive',
252: 'destroy_lvol_store_with_lvol_bdev_positive',
253: 'destroy_multi_logical_volumes_positive',
254: 'destroy_after_resize_lvol_bdev_positive',
300: 'destroy_lvol_store_nonexistent_lvs_uuid',
301: 'delete_lvol_store_underlying_bdev',
350: 'nested_destroy_logical_volume_negative',
400: 'nested_construct_logical_volume_positive',
450: 'construct_lvs_nonexistent_bdev',
451: 'construct_lvs_on_bdev_twice',
452: 'construct_lvs_name_twice',
500: 'nested_construct_lvol_bdev_on_full_lvol_store',
550: 'delete_bdev_positive',
600: 'construct_lvol_store_with_cluster_size_max',
601: 'construct_lvol_store_with_cluster_size_min',
650: 'tasting_positive',
700: 'SIGTERM',
}
print("========================================================")
print("Test Case {num}: Start".format(num=num))
@ -155,8 +155,8 @@ class TestCases(object):
footer(1)
return fail_count
def test_case2(self):
header(2)
def test_case50(self):
header(50)
base_name = self.c.construct_malloc_bdev(self.total_size,
self.block_size)
uuid_store = self.c.construct_lvol_store(base_name,
@ -172,11 +172,11 @@ class TestCases(object):
self.c.delete_bdev(uuid_bdev)
self.c.destroy_lvol_store(uuid_store)
self.c.delete_bdev(base_name)
footer(2)
footer(50)
return fail_count
def test_case3(self):
header(3)
def test_case51(self):
header(51)
base_name = self.c.construct_malloc_bdev(self.total_size,
self.block_size)
uuid_store = self.c.construct_lvol_store(base_name,
@ -199,11 +199,11 @@ class TestCases(object):
self.c.destroy_lvol_store(uuid_store)
self.c.delete_bdev(base_name)
footer(3)
footer(51)
return fail_count
def test_case4(self):
header(4)
def test_case52(self):
header(52)
base_name = self.c.construct_malloc_bdev(self.total_size,
self.block_size)
@ -223,11 +223,11 @@ class TestCases(object):
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)
footer(52)
return fail_count
def test_case5(self):
header(5)
def test_case53(self):
header(53)
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,
@ -259,11 +259,72 @@ class TestCases(object):
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)
footer(53)
return fail_count
def test_case6(self):
header(6)
def test_case100(self):
header(100)
fail_count = 0
if self.c.construct_lvol_bdev(self._gen_lvs_uudi(),
self.lbd_name,
32) == 0:
fail_count += 1
footer(100)
return fail_count
def test_case101(self):
header(101)
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,
self.total_size - 1)
fail_count += self.c.check_get_bdevs_methods(uuid_bdev,
self.total_size - 1)
if self.c.construct_lvol_bdev(uuid_store,
self.lbd_name + "_1",
self.total_size - 1) == 0:
fail_count += 1
self.c.delete_bdev(uuid_bdev)
self.c.destroy_lvol_store(uuid_store)
self.c.delete_bdev(base_name)
footer(101)
return fail_count
def test_case102(self):
header(102)
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(102)
return fail_count
def test_case150(self):
header(150)
base_name = self.c.construct_malloc_bdev(self.total_size,
self.block_size)
uuid_store = self.c.construct_lvol_store(base_name,
@ -292,11 +353,42 @@ class TestCases(object):
self.c.delete_bdev(uuid_bdev)
self.c.destroy_lvol_store(uuid_store)
self.c.delete_bdev(base_name)
footer(6)
footer(150)
return fail_count
def test_case7(self):
header(7)
def test_case200(self):
header(200)
fail_count = 0
if self.c.resize_lvol_bdev(self._gen_lvb_uudi(), 16) == 0:
fail_count += 1
footer(200)
return fail_count
def test_case201(self):
header(201)
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,
self.total_size - 1)
fail_count += self.c.check_get_bdevs_methods(uuid_bdev,
self.total_size - 1)
if self.c.resize_lvol_bdev(uuid_bdev, self.total_size + 1) == 0:
fail_count += 1
self.c.delete_bdev(uuid_bdev)
self.c.destroy_lvol_store(uuid_store)
self.c.delete_bdev(base_name)
footer(201)
return fail_count
def test_case250(self):
header(250)
base_name = self.c.construct_malloc_bdev(self.total_size,
self.block_size)
uuid_store = self.c.construct_lvol_store(base_name,
@ -307,11 +399,11 @@ 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(250)
return fail_count
def test_case8(self):
header(8)
def test_case251(self):
header(251)
base_name = self.c.construct_malloc_bdev(self.total_size,
self.block_size)
uuid_store = self.c.construct_lvol_store(base_name,
@ -322,11 +414,11 @@ class TestCases(object):
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)
footer(251)
return fail_count
def test_case9(self):
header(9)
def test_case252(self):
header(252)
base_name = self.c.construct_malloc_bdev(self.total_size,
self.block_size)
uuid_store = self.c.construct_lvol_store(base_name,
@ -344,11 +436,11 @@ class TestCases(object):
fail_count += self.c.check_get_lvol_stores("", "", "")
self.c.delete_bdev(base_name)
footer(9)
footer(252)
return fail_count
def test_case10(self):
header(10)
def test_case253(self):
header(253)
base_name = self.c.construct_malloc_bdev(self.total_size,
self.block_size)
uuid_store = self.c.construct_lvol_store(base_name,
@ -367,16 +459,11 @@ 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(10)
footer(253)
return fail_count
def test_case11(self):
print("Test of this feature not yet implemented.")
pass
return 0
def test_case12(self):
header(12)
def test_case254(self):
header(254)
base_name = self.c.construct_malloc_bdev(self.total_size,
self.block_size)
uuid_store = self.c.construct_lvol_store(base_name,
@ -402,23 +489,60 @@ 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(12)
footer(254)
return fail_count
def test_case300(self):
header(300)
fail_count = 0
if self.c.destroy_lvol_store(self._gen_lvs_uudi()) == 0:
fail_count += 1
footer(300)
return fail_count
def test_case301(self):
header(301)
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)
if self.c.delete_bdev(base_name) != 0:
fail_count += 1
if self.c.destroy_lvol_store(uuid_store) == 0:
fail_count += 1
footer(301)
return fail_count
def test_case350(self):
print("Test of this feature not yet implemented.")
pass
return 0
def test_case400(self):
print("Test of this feature not yet implemented.")
pass
return 0
# negative tests
def test_case13(self):
header(13)
def test_case450(self):
header(450)
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(13)
footer(450)
return fail_count
def test_case14(self):
header(14)
def test_case451(self):
header(451)
base_name = self.c.construct_malloc_bdev(self.total_size,
self.block_size)
uuid_store = self.c.construct_lvol_store(base_name,
@ -432,11 +556,11 @@ class TestCases(object):
fail_count += 1
self.c.destroy_lvol_store(uuid_store)
self.c.delete_bdev(base_name)
footer(14)
footer(451)
return fail_count
def test_case15(self):
header(15)
def test_case452(self):
header(452)
fail_count = 0
base_name_1 = self.c.construct_malloc_bdev(self.total_size,
self.block_size)
@ -457,140 +581,16 @@ class TestCases(object):
fail_count += self.c.delete_bdev(base_name_1)
fail_count += self.c.delete_bdev(base_name_2)
footer(15)
footer(452)
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(16)
return fail_count
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,
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,
self.total_size - 1)
fail_count += self.c.check_get_bdevs_methods(uuid_bdev,
self.total_size - 1)
if self.c.construct_lvol_bdev(uuid_store,
self.lbd_name + "_1",
self.total_size - 1) == 0:
fail_count += 1
self.c.delete_bdev(uuid_bdev)
self.c.destroy_lvol_store(uuid_store)
self.c.delete_bdev(base_name)
footer(17)
return fail_count
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(19)
return fail_count
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,
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,
self.total_size - 1)
fail_count += self.c.check_get_bdevs_methods(uuid_bdev,
self.total_size - 1)
if self.c.resize_lvol_bdev(uuid_bdev, self.total_size + 1) == 0:
fail_count += 1
self.c.delete_bdev(uuid_bdev)
self.c.destroy_lvol_store(uuid_store)
self.c.delete_bdev(base_name)
footer(20)
return fail_count
def test_case21(self):
header(21)
fail_count = 0
if self.c.destroy_lvol_store(self._gen_lvs_uudi()) == 0:
fail_count += 1
footer(21)
return fail_count
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,
self.lvs_name,
self.cluster_size)
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
self.cluster_size)
if self.c.delete_bdev(base_name) != 0:
fail_count += 1
if self.c.destroy_lvol_store(uuid_store) == 0:
fail_count += 1
footer(22)
return fail_count
def test_case23(self):
def test_case500(self):
print("Test of this feature not yet implemented.")
pass
return 0
def test_case24(self):
print("Test of this feature not yet implemented.")
pass
return 0
def test_case25(self):
header(25)
def test_case550(self):
header(550)
base_name = self.c.construct_malloc_bdev(self.total_size,
self.block_size)
uuid_store = self.c.construct_lvol_store(base_name,
@ -599,12 +599,13 @@ class TestCases(object):
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
self.cluster_size)
self.c.delete_bdev(base_name)
fail_count += self.c.check_get_lvol_stores("", "", "")
footer(25)
if self.c.check_get_lvol_stores("", "", "") == 1:
fail_count += 1
footer(550)
return fail_count
def test_case26(self):
header(26)
def test_case600(self):
header(600)
fail_count = 0
base_name = self.c.construct_malloc_bdev(self.total_size,
self.block_size)
@ -612,22 +613,22 @@ class TestCases(object):
self.lvs_name,
(self.total_size * 1024 * 1024) + 1) == 0:
fail_count += 1
footer(26)
footer(600)
return fail_count
def test_case27(self):
header(27)
def test_case601(self):
header(601)
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(27)
footer(601)
return fail_count
def test_case28(self):
header(28)
def test_case650(self):
header(650)
fail_count = 0
uuid_bdevs = []
base_name = "Nvme0n1"
@ -666,7 +667,7 @@ class TestCases(object):
remove(pid_path)
if self._start_vhost(vhost_path, config_path, pid_path) != 0:
fail_count += 1
footer(28)
footer(650)
return fail_count
# Check if configuration was properly loaded after tasting
@ -693,7 +694,7 @@ class TestCases(object):
pprint.pprint([o, n])
if fail_count != 0:
footer(28)
footer(650)
return fail_count
# Try modifying loaded configuration
@ -731,11 +732,11 @@ class TestCases(object):
if self.c.destroy_lvol_store(uuid_store) != 0:
fail_count += 1
footer(28)
footer(650)
return fail_count
def test_case29(self):
header(29)
def test_case700(self):
header(700)
pid_path = path.join(self.path, 'vhost.pid')
base_name = self.c.construct_malloc_bdev(self.total_size,
@ -747,5 +748,5 @@ class TestCases(object):
self.cluster_size)
fail_count += self._stop_vhost(pid_path)
footer(29)
footer(700)
return fail_count

373
test/lvol/test_plan.md
View File

@ -38,7 +38,7 @@ Expected result:
### construct_lvol_bdev - positive tests
#### TEST CASE 2 - Name: construct_logical_volume_positive
#### TEST CASE 50 - Name: construct_logical_volume_positive
Positive test for constructing a new logical volume.
Call construct_lvol_bdev with correct lvol store UUID and size in MiB for this bdev.
Steps:
@ -56,7 +56,7 @@ Expected result:
field set with the same name as returned value from call RPC method: construct_lvol_bdev
- no other operation fails
#### TEST CASE 3 - Name: construct_multi_logical_volumes_positive
#### TEST CASE 51 - Name: construct_multi_logical_volumes_positive
Positive test for constructing a multi logical volumes.
Call construct_lvol_bdev with correct lvol store UUID and
size is equal one quarter of the this bdev size.
@ -78,7 +78,7 @@ Expected result:
field set with the same name as returned from RPC call for all repeat
- no other operation fails
#### TEST CASE 4 - Name: construct_lvol_bdev_using_name_positive
#### TEST CASE 52 - Name: construct_lvol_bdev_using_name_positive
Positive test for constructing a logical volume using friendly names.
Verify that logical volumes can be created by using a friendly name
instead of uuid when referencing to lvol store.
@ -97,7 +97,7 @@ Expected result:
- calls successful, return code = 0
- no other operation fails
#### TEST CASE 5 - Name: construct_lvol_bdev_duplicate_names_positive
#### TEST CASE 53 - Name: construct_lvol_bdev_duplicate_names_positive
Positive test for constructing a logical volumes using friendly names.
Verify that logical volumes can use the same argument for friendly names
if they are created on separate logical volume stores.
@ -118,9 +118,62 @@ Expected result:
- calls successful, return code = 0
- no other operation fails
### construct_lvol_bdev - negative tests
#### TEST CASE 100 - Name: construct_logical_volume_nonexistent_lvs_uuid
Negative test for constructing a new logical_volume.
Call construct_lvol_bdev with lvs_uuid which does not
exist in configuration.
Steps:
- try to call construct_lvol_bdev with lvs_uuid which does not exist
Expected result:
- return code != 0
- ENODEV response printed to stdout
#### TEST CASE 101 - Name: construct_lvol_bdev_on_full_lvol_store
Negative test for constructing a new lvol bdev.
Call construct_lvol_bdev on a full lvol store.
Steps:
- create a malloc bdev
- construct_lvol_store on created malloc bdev
- check correct uuid values in response from get_lvol_stores command
- construct_lvol_bdev on correct lvs_uuid and size is smaller by 1 MB
from the full size malloc bdev
- try construct_lvol_bdev on the same lvs_uuid as in last step;
this call should fail as lvol store space is taken by previously created bdev
- destroy_lvol_store
- delete malloc bdev
Expected result:
- first call successful
- second construct_lvol_bdev call return code != 0
- EEXIST response printed to stdout
- no other operation fails
#### TEST CASE 102 - Name: construct_lvol_bdev_name_twice
Negative test for constructing lvol bdev using the same
friendly name twice on the same logical volume store.
Steps:
- create malloc bdev
- create logical volume store on malloc bdev
- using get_lvol_stores verify that logical volume store was correctly created
and has arguments as provided in step earlier (cluster size, friendly name, base bdev)
- construct logical volume on lvol store and verify it was correctly created
- try to create another logical volume on the same lvol store using
the same friendly name as in previous step; this step should fail
- delete existing lvol bdev
- delete existing lvol store
- delete malloc bdevs
Expected results:
- creating two logical volumes with the same friendly name within the same
lvol store should not be possible
- no other operation fails
### resize_lvol_store - positive tests
#### TEST CASE 6 - Name: resize_logical_volume_positive
#### TEST CASE 150 - Name: resize_logical_volume_positive
Positive test for resizing a logical_volume.
Call resize_lvol_bdev with correct logical_volumes name and new size.
Steps:
@ -147,9 +200,43 @@ Expected result:
- calls successful, return code = 0
- no other operation fails
### resize lvol store - negative tests
#### TEST CASE 200 - Name: resize_logical_volume_nonexistent_logical_volume
Negative test for resizing a logical_volume.
Call resize_lvol_bdev with logical volume which does not
exist in configuration.
Steps:
- try resize_lvol_store on logical volume which does not exist
Expected result:
- return code != 0
- Error code: ENODEV ("No such device") response printed to stdout
#### TEST CASE 201 - Name: resize_logical_volume_with_size_out_of_range
Negative test for resizing a logical volume.
Call resize_lvol_store with size argument bigger than size of base bdev.
Steps:
- create a malloc bdev
- construct_lvol_store on created malloc bdev
- check correct uuid values in response get_lvol_stores command
- construct_lvol_bdev on correct lvs_uuid and
size is equal one quarter of size malloc bdev
- try resize_lvol_bdev on correct lvs_uuid and size is
equal to size malloc bdev + 1MiB; this call should fail
- delete lvol bdev
- destroy lvol store
- delete malloc bdev
Expected result:
- resize_lvol_bdev call return code != 0
- Error code: ENODEV ("Not enough free clusters left on lvol store")
response printed to stdout
- no other operation fails
### destroy_lvol_store - positive tests
#### TEST CASE 7 - Name: destroy_lvol_store_positive
#### TEST CASE 250 - Name: destroy_lvol_store_positive
Positive test for destroying a logical volume store.
Call destroy_lvol_store with correct logical_volumes name
Steps:
@ -165,7 +252,7 @@ Expected result:
- get_lvol_stores: response should be of no value after destroyed lvol store
- no other operation fails
#### TEST CASE 8 - Name: destroy_lvol_store_use_name_positive
#### TEST CASE 251 - Name: destroy_lvol_store_use_name_positive
Positive test for destroying a logical volume store using
lvol store name instead of uuid for reference.
Call destroy_lvol_store with correct logical volume name
@ -182,7 +269,7 @@ Expected result:
- get_lvol_stores: response should be of no value after destroyed lvol store
- no other operation fails
#### TEST CASE 9 - Name: destroy_lvol_store_with_lvol_bdev_positive
#### TEST CASE 252 - Name: destroy_lvol_store_with_lvol_bdev_positive
Positive test for destroying a logical volume store with lvol bdev
created on top.
Call destroy_lvol_store with correct logical_volumes name
@ -200,7 +287,7 @@ Expected result:
- get_lvol_stores: response should be of no value after destroyed lvol store
- no other operation fails
#### TEST CASE 10 - Name: destroy_multi_logical_volumes_positive
#### TEST CASE 253 - Name: destroy_multi_logical_volumes_positive
Positive test for destroying a logical volume store with multiple lvol
bdevs created on top.
Call construct_lvol_bdev with correct lvol store UUID and
@ -222,38 +309,7 @@ Expected result:
field set with the same name as returned from RPC call for all repeat
- no other operation fails
### nested_construct_logical_volume - positive tests
#### TEST CASE 11 - Name: nested_construct_logical_volume_positive
Positive test for constructing a nested new lvol store.
Call construct_lvol_store with correct base bdev name.
Steps:
- create a malloc bdev
- construct_lvol_store on created malloc bdev
- check correct uuid values in response get_lvol_stores command
- construct_lvol_bdev on correct lvs_uuid and size is
equal to size malloc bdev
- construct first nested lvol store on created lvol_bdev
- check correct uuid values in response get_lvol_stores command
- construct first nested lvol bdev on correct lvs_uuid and size
- construct second nested lvol store on created first nested lvol bdev
- check correct uuid values in response get_lvol_stores command
- construct second nested lvol bdev on correct first nested lvs uuid and size
- delete nested lvol bdev and lvol store
- delete base lvol bdev and lvol store
- delete malloc bdev
Expected result:
- calls successful, return code = 0
- get_lvol_stores: backend used for construct_lvol_store has UUID
field set with the same UUID as returned from RPC call
backend used for construct_lvol_bdev has UUID
field set with the same UUID as returned from RPC call
- no other operation fails
### destroy_lvol_store - positive tests
#### TEST CASE 12 - Name: destroy_resize_logical_volume_positive
#### TEST CASE 254 - Name: destroy_resize_logical_volume_positive
Positive test for destroying a logical_volume after resizing.
Call destroy_lvol_store with correct logical_volumes name.
Steps:
@ -280,9 +336,88 @@ Expected result:
- no other operation fails
- get_lvol_stores: response should be of no value after destroyed lvol store
### destroy_lvol_store - negative tests
#### TEST CASE 300 - Name: destroy_lvol_store_nonexistent_lvs_uuid
Call destroy_lvol_store with nonexistent logical_volumes name
exist in configuration.
Steps:
- try to call destroy_lvol_store with lvs_uuid which does not exist
Expected result:
- return code != 0
- Error code response printed to stdout
#### TEST CASE 301 - Name: delete_lvol_store_underlying_bdev
Call destroy_lvol_store after deleting it's base bdev.
Lvol store should be automatically removed on deleting underlying bdev.
Steps:
- create a malloc bdev
- construct_lvol_store on created malloc bdev
- check correct uuid values in response get_lvol_stores command
- delete malloc bdev
- try to destroy lvol store; this call should fail as lvol store
is no longer present
Expected result:
- destroy_lvol_store retudn code != 0
- Error code: ENODEV ("No such device") response printed to stdout
- no other operation fails
### nested destroy_lvol_bdev - negative tests
#### TEST CASE 350 - Name: nested_destroy_logical_volume_negative
Negative test for destroying a nested first lvol store.
Call destroy_lvol_store with correct base bdev name.
Steps:
- create a malloc bdev
- construct_lvol_store on created malloc bdev
- check correct uuid values in response get_lvol_stores command
- construct_lvol_bdev on correct lvs_uuid and size is
equal to size malloc bdev
- construct first nested lvol store on created lvol_bdev
- check correct uuid values in response get_lvol_stores command
- construct first nested lvol bdev on correct lvs_uuid and size
- check size of the lvol bdev by command RPC : get_bdevs
- destroy first lvol_store
- delete malloc bdev
Expected result:
- Error code: ENODEV ("the device is busy") response printed to stdout
- no other operation fails
### nested construct_logical_volume - positive tests
#### TEST CASE 400 - Name: nested_construct_logical_volume_positive
Positive test for constructing a nested new lvol store.
Call construct_lvol_store with correct base bdev name.
Steps:
- create a malloc bdev
- construct_lvol_store on created malloc bdev
- check correct uuid values in response get_lvol_stores command
- construct_lvol_bdev on correct lvs_uuid and size is
equal to size malloc bdev
- construct first nested lvol store on created lvol_bdev
- check correct uuid values in response get_lvol_stores command
- construct first nested lvol bdev on correct lvs_uuid and size
- construct second nested lvol store on created first nested lvol bdev
- check correct uuid values in response get_lvol_stores command
- construct second nested lvol bdev on correct first nested lvs uuid and size
- delete nested lvol bdev and lvol store
- delete base lvol bdev and lvol store
- delete malloc bdev
Expected result:
- calls successful, return code = 0
- get_lvol_stores: backend used for construct_lvol_store has UUID
field set with the same UUID as returned from RPC call
backend used for construct_lvol_bdev has UUID
field set with the same UUID as returned from RPC call
- no other operation fails
### construct_lvol_store - negative tests
#### TEST CASE 13 - Name: construct_lvs_nonexistent_bdev
#### TEST CASE 450 - Name: construct_lvs_nonexistent_bdev
Negative test for constructing a new lvol store.
Call construct_lvol_store with base bdev name which does not
exist in configuration.
@ -293,7 +428,7 @@ Expected result:
- return code != 0
- Error code: ENODEV ("No such device") response printed to stdout
#### TEST CASE 14 - Name: construct_lvs_on_bdev_twice
#### TEST CASE 451 - Name: construct_lvs_on_bdev_twice
Negative test for constructing a new lvol store.
Call construct_lvol_store with base bdev name twice.
Steps:
@ -311,7 +446,7 @@ Expected result:
- EEXIST response printed to stdout
- no other operation fails
#### TEST CASE 15 - Name: construct_lvs_name_twice
#### TEST CASE 452 - Name: construct_lvs_name_twice
Negative test for constructing a new lvol store using the same
friendly name twice.
Steps:
@ -330,124 +465,9 @@ Expected results:
not be possible
- no other operation fails
### construct_lvol_bdev - negative tests
#### TEST CASE 16 - Name: construct_logical_volume_nonexistent_lvs_uuid
Negative test for constructing a new logical_volume.
Call construct_lvol_bdev with lvs_uuid which does not
exist in configuration.
Steps:
- try to call construct_lvol_bdev with lvs_uuid which does not exist
Expected result:
- return code != 0
- ENODEV response printed to stdout
#### TEST CASE 17 - Name: construct_lvol_bdev_on_full_lvol_store
Negative test for constructing a new lvol bdev.
Call construct_lvol_bdev on a full lvol store.
Steps:
- create a malloc bdev
- construct_lvol_store on created malloc bdev
- check correct uuid values in response from get_lvol_stores command
- construct_lvol_bdev on correct lvs_uuid and size is smaller by 1 MB
from the full size malloc bdev
- try construct_lvol_bdev on the same lvs_uuid as in last step;
this call should fail as lvol store space is taken by previously created bdev
- destroy_lvol_store
- delete malloc bdev
Expected result:
- first call successful
- second construct_lvol_bdev call return code != 0
- EEXIST response printed to stdout
- no other operation fails
#### TEST CASE 18 - Name: construct_lvol_bdev_name_twice
Negative test for constructing lvol bdev using the same
friendly name twice on the same logical volume store.
Steps:
- create malloc bdev
- create logical volume store on malloc bdev
- using get_lvol_stores verify that logical volume store was correctly created
and has arguments as provided in step earlier (cluster size, friendly name, base bdev)
- construct logical volume on lvol store and verify it was correctly created
- try to create another logical volume on the same lvol store using
the same friendly name as in previous step; this step should fail
- delete existing lvol bdev
- delete existing lvol store
- delete malloc bdevs
Expected results:
- creating two logical volumes with the same friendly name within the same
lvol store should not be possible
- no other operation fails
### resize_lvol_store - negative tests
#### TEST CASE 19 - Name: resize_logical_volume_nonexistent_logical_volume
Negative test for resizing a logical_volume.
Call resize_lvol_bdev with logical volume which does not
exist in configuration.
Steps:
- try resize_lvol_store on logical volume which does not exist
Expected result:
- return code != 0
- Error code: ENODEV ("No such device") response printed to stdout
#### TEST CASE 20 - Name: resize_logical_volume_with_size_out_of_range
Negative test for resizing a logical volume.
Call resize_lvol_store with size argument bigger than size of base bdev.
Steps:
- create a malloc bdev
- construct_lvol_store on created malloc bdev
- check correct uuid values in response get_lvol_stores command
- construct_lvol_bdev on correct lvs_uuid and
size is equal one quarter of size malloc bdev
- try resize_lvol_bdev on correct lvs_uuid and size is
equal to size malloc bdev + 1MiB; this call should fail
- delete lvol bdev
- destroy lvol store
- delete malloc bdev
Expected result:
- resize_lvol_bdev call return code != 0
- Error code: ENODEV ("Not enough free clusters left on lvol store")
response printed to stdout
- no other operation fails
### destroy_lvol_store - negative tests
#### TEST CASE 21 - Name: destroy_lvol_store_nonexistent_lvs_uuid
Call destroy_lvol_store with nonexistent logical_volumes name
exist in configuration.
Steps:
- try to call destroy_lvol_store with lvs_uuid which does not exist
Expected result:
- return code != 0
- Error code response printed to stdout
#### TEST CASE 22 - Name: delete_lvol_store_underlying_bdev
Call destroy_lvol_store after deleting it's base bdev.
Lvol store should be automatically removed on deleting underlying bdev.
Steps:
- create a malloc bdev
- construct_lvol_store on created malloc bdev
- check correct uuid values in response get_lvol_stores command
- delete malloc bdev
- try to destroy lvol store; this call should fail as lvol store
is no longer present
Expected result:
- destroy_lvol_store retudn code != 0
- Error code: ENODEV ("No such device") response printed to stdout
- no other operation fails
### nested construct_lvol_bdev - test negative
#### TEST CASE 23 - Name: nested_construct_lvol_bdev_on_full_lvol_store
#### TEST CASE 500 - Name: nested_construct_lvol_bdev_on_full_lvol_store
Negative test for constructing a new nested lvol bdev.
Call construct_lvol_bdev on a full lvol store.
Steps:
@ -473,31 +493,9 @@ Expected result:
- EEXIST response printed to stdout
- no other operation fails
### destroy_lvol_store - negative tests
#### TEST CASE 24 - Name: nested_destroy_logical_volume_negative
Negative test for destroying a nested first lvol store.
Call destroy_lvol_store with correct base bdev name.
Steps:
- create a malloc bdev
- construct_lvol_store on created malloc bdev
- check correct uuid values in response get_lvol_stores command
- construct_lvol_bdev on correct lvs_uuid and size is
equal to size malloc bdev
- construct first nested lvol store on created lvol_bdev
- check correct uuid values in response get_lvol_stores command
- construct first nested lvol bdev on correct lvs_uuid and size
- check size of the lvol bdev by command RPC : get_bdevs
- destroy first lvol_store
- delete malloc bdev
Expected result:
- Error code: ENODEV ("the device is busy") response printed to stdout
- no other operation fails
### delete_bdev - positive tests
#### TEST CASE 25 - Name: delete_bdev_positive
#### TEST CASE 550 - Name: delete_bdev_positive
Positive test for deleting malloc bdev.
Call construct_lvol_store with correct base bdev name.
Steps:
@ -513,7 +511,7 @@ Expected result:
### construct_lvol_store_with_cluster_size - negative tests
#### TEST CASE 26 - Name: construct_lvol_store_with_cluster_size_max
#### TEST CASE 600 - Name: construct_lvol_store_with_cluster_size_max
Negative test for constructing a new lvol store.
Call construct_lvol_store with cluster size is equal malloc bdev size + 1B.
Steps:
@ -525,7 +523,7 @@ Expected result:
- return code != 0
- Error code response printed to stdout
#### TEST CASE 27 - Name: construct_lvol_store_with_cluster_size_min
#### TEST CASE 601 - Name: construct_lvol_store_with_cluster_size_min
Negative test for constructing a new lvol store.
Call construct_lvol_store with cluster size = 0.
Steps:
@ -538,7 +536,7 @@ Expected result:
### logical volume tasting tests
#### TEST CASE 28 - Name: tasting_positive
#### TEST CASE 650 - Name: tasting_positive
Positive test for tasting a multi lvol bdev configuration.
Create a lvol store with some lvol bdevs on NVMe drive and restart vhost app.
After restarting configuration should be automatically loaded and should be exactly
@ -579,9 +577,10 @@ Expected results:
loading existing configuration
- all RPC configuration calls successful, return code = 0
- no other operation fails
### SIGTERM
#### TEST CASE 29 - Name: SIGTERM
#### TEST CASE 700 - Name: SIGTERM
Call CTRL+C (SIGTERM) occurs after creating lvol store
Steps:
- create a malloc bdev