def test_pool_rename(self):
"""
Test pool rename
:return:
"""
pool_name = p_n()
new_name = p_n()
StratisCli.pool_create(pool_name, [DISKS[0]])
self.assertTrue(pool_name in StratisCli.pool_list())
StratisCli.pool_rename(pool_name, new_name)
pl = StratisCli.pool_list()
self.assertEqual(len(pl), 1)
self.assertTrue(new_name in pl)
def test_create_pool_used_dev(self):
"""
Ref. https://bugzilla.redhat.com/show_bug.cgi?id=1686852
:return: None
"""
pool_name = p_n()
new_name = p_n()
StratisCli.pool_create(pool_name, [DISKS[0]])
stdout, _ = exec_command(
[STRATIS_CLI, "pool", "create", new_name, DISKS[0]],
expected_exit_code=1)
# Users want the pool name in the error output
self.assertTrue(pool_name in stdout)
def test_signal_interruption(self):
"""
Send a signal in the middle of a command to ensure that we don't get
a stack trace, ref. https://bugzilla.redhat.com/show_bug.cgi?id=1686652
:return:
"""
process = Popen([STRATIS_CLI, "pool", "create",
p_n(), DISKS[0]],
stdout=PIPE,
stderr=PIPE,
close_fds=True,
env=os.environ)
time.sleep(0.05)
process.send_signal(2)
result = process.communicate()
stdout_text = ""
stderr_text = ""
if result[0]:
stdout_text = bytes(result[0]).decode("utf-8")
if result[1]:
stderr_text = bytes(result[1]).decode("utf-8")
self.assertTrue("Traceback" not in stdout_text)
self.assertTrue("Traceback" not in stderr_text)
self.assertNotEqual(process.returncode, 0)
def test_pool_create(self):
"""
Test pool create.
:return: None
"""
pool_name = p_n()
StratisCli.pool_create(pool_name, [DISKS[0]])
pools = StratisCli.pool_list()
self.assertTrue(pool_name in pools)
self.assertEqual(1, len(pools))
def test_pool_destroy(self):
"""
Test destroying a pool
:return: None
"""
pool_name = p_n()
StratisCli.pool_create(pool_name, [DISKS[0]])
StratisCli.pool_destroy(pool_name)
pools = StratisCli.pool_list()
self.assertFalse(pool_name in pools)
self.assertEqual(0, len(pools))
def test_block_dev_list(self):
"""
Test block device listing
:return:
"""
pool_name = p_n()
StratisCli.pool_create(pool_name, [DISKS[0]])
block_devs = StratisCli.blockdev_list()
self.assertTrue(DISKS[0] in block_devs)
self.assertEqual(1, len(block_devs))
self.assertEqual(pool_name, block_devs[DISKS[0]]["POOL_NAME"])
def test_pool_add_cache(self):
"""
Test adding cache to a pool
:return: None
"""
pool_name = p_n()
StratisCli.pool_create(pool_name, [DISKS[0]])
StratisCli.pool_add(pool_name, "add-cache", DISKS[1:])
block_devs = StratisCli.blockdev_list()
for d in DISKS:
self.assertTrue(d in block_devs)
def test_fs_create(self):
"""
Test creating a FS
:return: None
"""
pool_name = p_n()
fs_name = fs_n()
StratisCli.pool_create(pool_name, [DISKS[0]])
StratisCli.fs_create(pool_name, fs_name)
fs = StratisCli.fs_list()
self.assertTrue(fs_name in fs.keys())
self.assertEqual(1, len(fs))
self.assertEqual(fs[fs_name]["POOL_NAME"], pool_name)
def test_fs_snap_shot(self):
"""
Test creating a FS snap shot.
:return: None
"""
pool_name = p_n()
fs_name = fs_n()
fs_ss = fs_n()
StratisCli.pool_create(pool_name, [DISKS[0]])
StratisCli.fs_create(pool_name, fs_name)
StratisCli.fs_ss_create(pool_name, fs_name, fs_ss)
fs = StratisCli.fs_list()
self.assertTrue(fs_ss in fs)
def test_no_list_listings(self):
"""
Test that commands that optionally take a list work both ways.
:return: None
"""
pool_name = p_n()
fs_name = fs_n()
StratisCli.pool_create(pool_name, block_devices=DISKS)
StratisCli.fs_create(pool_name, fs_name)
self.assertEqual(StratisCli.pool_list(), StratisCli.pool_list(False))
self.assertEqual(StratisCli.fs_list(), StratisCli.fs_list(False))
self.assertEqual(StratisCli.blockdev_list(),
StratisCli.blockdev_list(False))
def test_fs_rename(self):
"""
Test renaming a FS
:return: None
"""
pool_name = p_n()
fs_name = fs_n()
fs_new_name = fs_n()
StratisCli.pool_create(pool_name, [DISKS[0]])
StratisCli.fs_create(pool_name, fs_name)
StratisCli.fs_rename(pool_name, fs_name, fs_new_name)
fs = StratisCli.fs_list()
self.assertTrue(fs_new_name in fs.keys())
self.assertFalse(fs_name in fs.keys())
self.assertEqual(1, len(fs))
def test_fs_destroy(self):
"""
Test destroying a FS
:return:
"""
pool_name = p_n()
fs_name = fs_n()
fs_too = fs_n()
StratisCli.pool_create(pool_name, [DISKS[0]])
StratisCli.fs_create(pool_name, fs_name)
StratisCli.fs_create(pool_name, fs_too)
StratisCli.fs_destroy(pool_name, fs_name)
fs = StratisCli.fs_list()
self.assertEqual(1, len(fs))
self.assertFalse(fs_n in fs)
self.assertTrue(fs_too in fs)
def test_simple_data_io(self):
"""
Create a pool and fs, create some files on it and validate them to
ensure very basic data path is working.
:return: None
"""
mount_path = None
try:
pool_name = p_n()
fs_name = fs_n()
StratisCli.pool_create(pool_name, block_devices=DISKS)
StratisCli.fs_create(pool_name, fs_name)
# mount the fs
mount_path = os.path.join(os.path.sep + "mnt", rs(16))
os.mkdir(mount_path)
exec_command(
["mount",
stratis_link(pool_name, fs_name), mount_path])
files = {}
total_size = 0
# Do some simple IO to it, creating at most about ~100MiB data
while total_size < 1024 * 1024 * 100:
fn, signature, size = file_create(mount_path)
total_size += size
files[fn] = signature
# Validate them
for name, signature in files.items():
self.assertTrue(file_signature(name), signature)
finally:
# Make sure we un-mount the fs before we bail as we can't clean up
# Stratis when the FS is mounted.
if mount_path:
exec_command(["umount", mount_path])
os.rmdir(mount_path)
