def test_dynamic(self, value_sc):
LOGGER.info(
f"Testing Dynamic Provisioning with following PVC parameters {str(self.value_pvc)}"
)
d.set_test_namespace_value(self.test_ns)
sc_name = d.get_random_name("sc")
config.load_kube_config(config_file=kubeconfig_value)
d.create_storage_class(value_sc, self.config_file, sc_name)
d.check_storage_class(sc_name)
for num in range(0, len(self.value_pvc)):
value_pvc_pass = copy.deepcopy(self.value_pvc[num])
if (check_key(value_sc, "reason")):
if not (check_key(value_pvc_pass, "reason")):
value_pvc_pass["reason"] = value_sc["reason"]
LOGGER.info(100 * "=")
pvc_name = d.get_random_name("pvc")
d.create_pvc(value_pvc_pass, sc_name, pvc_name)
val = d.check_pvc(value_pvc_pass, sc_name, pvc_name)
if val is True:
for num2 in range(0, len(self.value_pod)):
LOGGER.info(100 * "-")
pod_name = d.get_random_name("pod")
d.create_pod(self.value_pod[num2], pvc_name, pod_name)
d.check_pod(self.value_pod[num2], sc_name, pvc_name,
pod_name)
d.delete_pod(pod_name)
d.check_pod_deleted(pod_name)
LOGGER.info(100 * "-")
d.delete_pvc(pvc_name)
d.check_pvc_deleted(pvc_name)
LOGGER.info(100 * "=")
if d.check_storage_class(sc_name):
d.delete_storage_class(sc_name)
d.check_storage_class_deleted(sc_name)
def one_pvc_two_pod(self, value_sc):
d.set_test_namespace_value(self.test_ns)
sc_name = d.get_random_name("sc")
config.load_kube_config(config_file=kubeconfig_value)
d.create_storage_class(value_sc, self.config_file, sc_name)
d.check_storage_class(sc_name)
value_pvc_pass = copy.deepcopy(self.value_pvc[0])
pvc_name = d.get_random_name("pvc")
d.create_pvc(value_pvc_pass, sc_name, pvc_name)
val = d.check_pvc(value_pvc_pass, sc_name, pvc_name)
if val is True:
pod_name_1 = d.get_random_name("pod")
d.create_pod(self.value_pod[0], pvc_name, pod_name_1)
d.check_pod(self.value_pod[0], sc_name, pvc_name, pod_name_1)
pod_name_2 = d.get_random_name("pod")
d.create_pod(self.value_pod[0], pvc_name, pod_name_2)
d.check_pod(self.value_pod[0], sc_name, pvc_name, pod_name_2)
d.delete_pod(pod_name_1)
d.check_pod_deleted(pod_name_1)
d.delete_pod(pod_name_2)
d.check_pod_deleted(pod_name_2)
d.delete_pvc(pvc_name)
d.check_pvc_deleted(pvc_name)
if d.check_storage_class(sc_name):
d.delete_storage_class(sc_name)
d.check_storage_class_deleted(sc_name)
def sequential_pvc(self, value_sc, num_of_pvc):
created_objects = get_cleanup_dict()
sc_name = d.get_random_name("sc")
config.load_kube_config(config_file=self.kubeconfig)
d.create_storage_class(value_sc, sc_name, created_objects)
d.check_storage_class(sc_name)
pvc_names = []
number_of_pvc = num_of_pvc
common_pvc_name = d.get_random_name("pvc")
for num in range(0, number_of_pvc):
pvc_names.append(common_pvc_name+"-"+str(num))
value_pvc_pass = copy.deepcopy(self.value_pvc[0])
LOGGER.info(100*"-")
value_pvc_pass["parallel"] = "True"
for pvc_name in pvc_names:
LOGGER.info(100*"-")
d.create_pvc(value_pvc_pass, sc_name, pvc_name, created_objects)
for pvc_name in pvc_names:
LOGGER.info(100*"-")
d.check_pvc(value_pvc_pass, pvc_name, created_objects)
pod_names = []
for pvc_name in pvc_names:
LOGGER.info(100*"-")
pod_name = d.get_random_name("pod")
pod_names.append(pod_name)
d.create_pod(self.value_pod[0], pvc_name, pod_name, created_objects, self.image_name)
d.check_pod(self.value_pod[0], pod_name, created_objects)
cleanup.clean_with_created_objects(created_objects)
def test_dynamic(self, value_sc, value_pvc_passed=None, value_pod_passed=None, value_clone_passed=None):
created_objects = get_cleanup_dict()
if value_pvc_passed is None:
value_pvc_passed = copy.deepcopy(self.value_pvc)
if value_pod_passed is None:
value_pod_passed = copy.deepcopy(self.value_pod)
if "permissions" in value_sc.keys() and not(ff.feature_available("permissions")):
LOGGER.warning("Min required Spectrum Scale version for permissions in storageclass support with CSI is 5.1.1-2")
LOGGER.warning("Skipping Testcase")
return
LOGGER.info(
f"Testing Dynamic Provisioning with following PVC parameters {str(value_pvc_passed)}")
sc_name = d.get_random_name("sc")
config.load_kube_config(config_file=self.kubeconfig)
d.create_storage_class(value_sc, sc_name, created_objects)
d.check_storage_class(sc_name)
for num, _ in enumerate(value_pvc_passed):
value_pvc_pass = copy.deepcopy(value_pvc_passed[num])
if (check_key(value_sc, "reason")):
if not(check_key(value_pvc_pass, "reason")):
value_pvc_pass["reason"] = value_sc["reason"]
LOGGER.info(100*"=")
pvc_name = d.get_random_name("pvc")
d.create_pvc(value_pvc_pass, sc_name, pvc_name, created_objects)
val = d.check_pvc(value_pvc_pass, pvc_name, created_objects)
if val is True:
if "permissions" in value_sc.keys():
d.check_permissions_for_pvc(pvc_name, value_sc["permissions"], created_objects)
for num2, _ in enumerate(value_pod_passed):
LOGGER.info(100*"-")
pod_name = d.get_random_name("pod")
if value_sc.keys() >= {"permissions", "gid", "uid"}:
value_pod_passed[num2]["gid"] = value_sc["gid"]
value_pod_passed[num2]["uid"] = value_sc["uid"]
d.create_pod(value_pod_passed[num2], pvc_name, pod_name, created_objects, self.image_name)
d.check_pod(value_pod_passed[num2], pod_name, created_objects)
if "volume_expansion_storage" in value_pvc_pass:
d.expand_and_check_pvc(sc_name, pvc_name, value_pvc_pass, "volume_expansion_storage",
pod_name, value_pod_passed[num2], created_objects)
if value_clone_passed is not None:
d.clone_and_check_pvc(sc_name, value_sc, pvc_name, pod_name, value_pod_passed[num2], value_clone_passed, created_objects)
cleanup.delete_pod(pod_name, created_objects)
cleanup.check_pod_deleted(pod_name, created_objects)
if ((value_pvc_pass["access_modes"] == "ReadWriteOnce") and (self.keep_objects is True) and (num2 < (len(value_pod_passed)-1))):
pvc_name = d.get_random_name("pvc")
d.create_pvc(value_pvc_pass, sc_name, pvc_name, created_objects)
val = d.check_pvc(value_pvc_pass, pvc_name, created_objects)
if val is not True:
break
LOGGER.info(100*"-")
vol_name = cleanup.delete_pvc(pvc_name, created_objects)
cleanup.check_pvc_deleted(pvc_name, vol_name, created_objects)
LOGGER.info(100*"=")
cleanup.clean_with_created_objects(created_objects)
def test_dynamic(self, value_sc, test_restore, value_vs_class=None, number_of_snapshots=None, reason=None):
if value_vs_class is None:
value_vs_class = self.value_vs_class
if number_of_snapshots is None:
number_of_snapshots = self.number_of_snapshots
number_of_restore = 1
for pvc_value in self.value_pvc:
created_objects = get_cleanup_dict()
LOGGER.info("-"*100)
sc_name = d.get_random_name("sc")
d.create_storage_class(value_sc, sc_name, created_objects)
d.check_storage_class(sc_name)
pvc_name = d.get_random_name("pvc")
d.create_pvc(pvc_value, sc_name, pvc_name, created_objects)
d.check_pvc(pvc_value, pvc_name, created_objects)
pod_name = d.get_random_name("snap-start-pod")
value_pod = {"mount_path": "/usr/share/nginx/html/scale", "read_only": "False"}
d.create_pod(value_pod, pvc_name, pod_name, created_objects, self.image_name)
d.check_pod(value_pod, pod_name, created_objects)
d.create_file_inside_pod(value_pod, pod_name, created_objects)
vs_class_name = d.get_random_name("vsclass")
snapshot.create_vs_class(vs_class_name, value_vs_class, created_objects)
snapshot.check_vs_class(vs_class_name)
vs_name = d.get_random_name("vs")
for num in range(0, number_of_snapshots):
snapshot.create_vs(vs_name+"-"+str(num), vs_class_name, pvc_name, created_objects)
snapshot.check_vs_detail(vs_name+"-"+str(num), pvc_name, value_vs_class, reason, created_objects)
if not(ff.snapshot_restore_available()):
pvc_value["reason"] = "Min required Spectrum Scale version is 5.0.5.2"
if test_restore:
for num in range(0, number_of_restore):
restored_pvc_name = "restored-pvc"+vs_name[2:]+"-"+str(num)
snap_pod_name = "snap-end-pod"+vs_name[2:]
d.create_pvc_from_snapshot(pvc_value, sc_name, restored_pvc_name, vs_name+"-"+str(num), created_objects)
val = d.check_pvc(pvc_value, restored_pvc_name, created_objects)
if val is True:
d.create_pod(value_pod, restored_pvc_name, snap_pod_name, created_objects, self.image_name)
d.check_pod(value_pod, snap_pod_name, created_objects)
d.check_file_inside_pod(value_pod, snap_pod_name, created_objects)
cleanup.delete_pod(snap_pod_name, created_objects)
cleanup.check_pod_deleted(snap_pod_name, created_objects)
vol_name=cleanup.delete_pvc(restored_pvc_name, created_objects)
cleanup.check_pvc_deleted(restored_pvc_name,vol_name, created_objects)
cleanup.clean_with_created_objects(created_objects)
def one_pvc_two_pod(self, value_sc, value_pvc_pass, value_ds_pass):
created_objects = get_cleanup_dict()
sc_name = d.get_random_name("sc")
config.load_kube_config(config_file=self.kubeconfig)
d.create_storage_class(value_sc, sc_name, created_objects)
d.check_storage_class(sc_name)
pvc_name = d.get_random_name("pvc")
d.create_pvc(value_pvc_pass, sc_name, pvc_name, created_objects)
val = d.check_pvc(value_pvc_pass, pvc_name, created_objects)
if val is True:
ds_name = d.get_random_name("ds")
d.create_ds(value_ds_pass, ds_name, pvc_name, created_objects)
d.check_ds(ds_name, value_ds_pass, created_objects)
cleanup.clean_with_created_objects(created_objects)
def test_dynamic(self,
value_sc,
value_pvc_passed=None,
value_pod_passed=None):
created_objects = get_cleanup_dict()
if value_pvc_passed is None:
value_pvc_passed = self.value_pvc
if value_pod_passed is None:
value_pod_passed = self.value_pod
LOGGER.info(
f"Testing Dynamic Provisioning with following PVC parameters {str(value_pvc_passed)}"
)
sc_name = d.get_random_name("sc")
config.load_kube_config(config_file=self.kubeconfig)
d.create_storage_class(value_sc, sc_name, created_objects)
d.check_storage_class(sc_name)
for num in range(0, len(value_pvc_passed)):
value_pvc_pass = copy.deepcopy(value_pvc_passed[num])
if (check_key(value_sc, "reason")):
if not (check_key(value_pvc_pass, "reason")):
value_pvc_pass["reason"] = value_sc["reason"]
LOGGER.info(100 * "=")
pvc_name = d.get_random_name("pvc")
d.create_pvc(value_pvc_pass, sc_name, pvc_name, created_objects)
val = d.check_pvc(value_pvc_pass, pvc_name, created_objects)
if val is True:
for num2 in range(0, len(value_pod_passed)):
LOGGER.info(100 * "-")
pod_name = d.get_random_name("pod")
d.create_pod(value_pod_passed[num2], pvc_name, pod_name,
created_objects, self.image_name)
d.check_pod(value_pod_passed[num2], pod_name,
created_objects)
cleanup.delete_pod(pod_name, created_objects)
cleanup.check_pod_deleted(pod_name, created_objects)
if value_pvc_pass[
"access_modes"] == "ReadWriteOnce" and self.keep_objects is True:
if num2 < (len(value_pod_passed) - 1):
pvc_name = d.get_random_name("pvc")
d.create_pvc(value_pvc_pass, sc_name, pvc_name,
created_objects)
val = d.check_pvc(value_pvc_pass, pvc_name,
created_objects)
if val is not True:
break
LOGGER.info(100 * "-")
vol_name = cleanup.delete_pvc(pvc_name, created_objects)
cleanup.check_pvc_deleted(pvc_name, vol_name, created_objects)
LOGGER.info(100 * "=")
cleanup.clean_with_created_objects(created_objects)
def parallel_pvc_process(self, sc_name):
value_pvc_pass = copy.deepcopy(self.value_pvc[0])
LOGGER.info(100 * "-")
value_pvc_pass["parallel"] = "True"
pvc_name = d.get_random_name("pvc")
d.create_pvc(value_pvc_pass, sc_name, pvc_name)
val = d.check_pvc(value_pvc_pass, sc_name, pvc_name)
if val is True:
pod_name = d.get_random_name("pod")
d.create_pod(self.value_pod[0], pvc_name, pod_name)
d.check_pod(self.value_pod[0], sc_name, pvc_name, pod_name)
d.delete_pod(pod_name)
d.check_pod_deleted(pod_name)
d.delete_pvc(pvc_name)
d.check_pvc_deleted(pvc_name)
def one_pvc_two_pod(self, value_sc):
created_objects = get_cleanup_dict()
sc_name = d.get_random_name("sc")
config.load_kube_config(config_file=self.kubeconfig)
d.create_storage_class(value_sc, sc_name, created_objects)
d.check_storage_class(sc_name)
value_pvc_pass = copy.deepcopy(self.value_pvc[0])
pvc_name = d.get_random_name("pvc")
d.create_pvc(value_pvc_pass, sc_name, pvc_name, created_objects)
val = d.check_pvc(value_pvc_pass, pvc_name, created_objects)
if val is True:
pod_name_1 = d.get_random_name("pod")
d.create_pod(self.value_pod[0], pvc_name, pod_name_1,
created_objects, self.image_name)
d.check_pod(self.value_pod[0], pod_name_1, created_objects)
pod_name_2 = d.get_random_name("pod")
d.create_pod(self.value_pod[0], pvc_name, pod_name_2,
created_objects, self.image_name)
d.check_pod(self.value_pod[0], pod_name_2, created_objects)
cleanup.delete_pod(pod_name_1, created_objects)
cleanup.check_pod_deleted(pod_name_1, created_objects)
cleanup.delete_pod(pod_name_2, created_objects)
cleanup.check_pod_deleted(pod_name_2, created_objects)
cleanup.clean_with_created_objects(created_objects)
def parallel_pvc(self, value_sc):
d.set_test_namespace_value(self.test_ns)
sc_name = d.get_random_name("sc")
config.load_kube_config(config_file=kubeconfig_value)
d.create_storage_class(value_sc, self.config_file, sc_name)
d.check_storage_class(sc_name)
p = []
number_of_pvc = self.config_file["number_of_parallel_pvc"]
for num in range(0, number_of_pvc):
p.append(
multiprocessing.Process(target=self.parallel_pvc_process,
args=[sc_name]))
p[num].start()
for num in range(0, number_of_pvc - 1):
p[num].join()
LOGGER.info(100 * "-")
if d.check_storage_class(sc_name):
d.delete_storage_class(sc_name)
d.check_storage_class_deleted(sc_name)
def test_static(self, value_sc, test_restore, value_vs_class=None, number_of_snapshots=None, restore_sc=None, restore_pvc=None):
if value_vs_class is None:
value_vs_class = self.value_vs_class
if number_of_snapshots is None:
number_of_snapshots = self.number_of_snapshots
number_of_restore = 1
for pvc_value in self.value_pvc:
created_objects = get_cleanup_dict()
LOGGER.info("-"*100)
sc_name = d.get_random_name("sc")
d.create_storage_class(value_sc, sc_name, created_objects)
d.check_storage_class(sc_name)
pvc_name = d.get_random_name("pvc")
d.create_pvc(pvc_value, sc_name, pvc_name, created_objects)
d.check_pvc(pvc_value, pvc_name, created_objects)
pod_name = d.get_random_name("snap-start-pod")
value_pod = {"mount_path": "/usr/share/nginx/html/scale", "read_only": "False"}
d.create_pod(value_pod, pvc_name, pod_name, created_objects, self.image_name)
d.check_pod(value_pod, pod_name, created_objects)
d.create_file_inside_pod(value_pod, pod_name, created_objects)
snapshot_name = d.get_random_name("snapshot")
volume_name = snapshot.get_pv_name(pvc_name, created_objects)
FSUID = ff.get_FSUID()
cluster_id = self.cluster_id
vs_content_name = d.get_random_name("vscontent")
vs_name = d.get_random_name("vs")
for num in range(0, number_of_snapshots):
ff.create_snapshot(snapshot_name+"-"+str(num), volume_name, created_objects)
if ff.check_snapshot(snapshot_name+"-"+str(num), volume_name):
LOGGER.info(f"snapshot {snapshot_name} exists for {volume_name}")
else:
LOGGER.error(f"snapshot {snapshot_name} does not exists for {volume_name}")
cleanup.clean_with_created_objects(created_objects)
assert False
snapshot_handle = cluster_id+';'+FSUID+';'+volume_name+';'+snapshot_name+"-"+str(num)
body_params = {"deletionPolicy": "Retain", "snapshotHandle": snapshot_handle}
snapshot.create_vs_content(vs_content_name+"-"+str(num), vs_name+"-"+str(num), body_params, created_objects)
snapshot.check_vs_content(vs_content_name+"-"+str(num))
snapshot.create_vs_from_content(vs_name+"-"+str(num), vs_content_name+"-"+str(num), created_objects)
snapshot.check_vs_detail_for_static(vs_name+"-"+str(num), created_objects)
if not(ff.feature_available("snapshot")):
pvc_value["reason"] = "Min required Spectrum Scale version for snapshot support with CSI is 5.1.1-0"
if test_restore:
if restore_sc is not None:
sc_name = "restore-" + sc_name
d.create_storage_class(restore_sc, sc_name, created_objects)
d.check_storage_class(sc_name)
if restore_pvc is not None:
pvc_value = restore_pvc
for num in range(0, number_of_restore):
restored_pvc_name = "restored-pvc"+vs_name[2:]+"-"+str(num)
snap_pod_name = "snap-end-pod"+vs_name[2:]
d.create_pvc_from_snapshot(pvc_value, sc_name, restored_pvc_name, vs_name+"-"+str(num), created_objects)
val = d.check_pvc(pvc_value, restored_pvc_name, created_objects)
if val is True:
d.create_pod(value_pod, restored_pvc_name, snap_pod_name, created_objects, self.image_name)
d.check_pod(value_pod, snap_pod_name, created_objects)
d.check_file_inside_pod(value_pod, snap_pod_name, created_objects, volume_name)
cleanup.delete_pod(snap_pod_name, created_objects)
cleanup.check_pod_deleted(snap_pod_name, created_objects)
vol_name = cleanup.delete_pvc(restored_pvc_name, created_objects)
cleanup.check_pvc_deleted(restored_pvc_name, vol_name, created_objects)
cleanup.clean_with_created_objects(created_objects)
def test_dynamic(self, value_sc, test_restore, value_vs_class=None, number_of_snapshots=None, reason=None, restore_sc=None, restore_pvc=None, value_pod=None, value_pvc=None, value_clone_passed=None):
if value_vs_class is None:
value_vs_class = self.value_vs_class
if number_of_snapshots is None:
number_of_snapshots = self.number_of_snapshots
number_of_restore = 1
if "permissions" in value_sc.keys() and not(ff.feature_available("permissions")):
LOGGER.warning("Min required Spectrum Scale version for permissions in storageclass support with CSI is 5.1.1-2")
LOGGER.warning("Skipping Testcase")
return
if value_pvc is None:
value_pvc = copy.deepcopy(self.value_pvc)
for pvc_value in value_pvc:
created_objects = get_cleanup_dict()
LOGGER.info("-"*100)
sc_name = d.get_random_name("sc")
d.create_storage_class(value_sc, sc_name, created_objects)
d.check_storage_class(sc_name)
pvc_name = d.get_random_name("pvc")
d.create_pvc(pvc_value, sc_name, pvc_name, created_objects)
val = d.check_pvc(pvc_value, pvc_name, created_objects)
if val is True and "permissions" in value_sc.keys():
d.check_permissions_for_pvc(pvc_name, value_sc["permissions"], created_objects)
pod_name = d.get_random_name("snap-start-pod")
if value_pod is None:
value_pod = {"mount_path": "/usr/share/nginx/html/scale", "read_only": "False"}
if value_sc.keys() >= {"permissions", "gid", "uid"}:
value_pod["gid"] = value_sc["gid"]
value_pod["uid"] = value_sc["uid"]
d.create_pod(value_pod, pvc_name, pod_name, created_objects, self.image_name)
d.check_pod(value_pod, pod_name, created_objects)
d.create_file_inside_pod(value_pod, pod_name, created_objects)
if "presnap_volume_expansion_storage" in pvc_value:
d.expand_and_check_pvc(sc_name, pvc_name, pvc_value, "presnap_volume_expansion_storage",
pod_name, value_pod, created_objects)
vs_class_name = d.get_random_name("vsclass")
snapshot.create_vs_class(vs_class_name, value_vs_class, created_objects)
snapshot.check_vs_class(vs_class_name)
if not(ff.feature_available("snapshot")):
if reason is None:
reason = "Min required Spectrum Scale version for snapshot support with CSI is 5.1.1-0"
test_restore = False
vs_name = d.get_random_name("vs")
for num in range(0, number_of_snapshots):
snapshot.create_vs(vs_name+"-"+str(num), vs_class_name, pvc_name, created_objects)
snapshot.check_vs_detail(vs_name+"-"+str(num), pvc_name, value_vs_class, reason, created_objects)
if test_restore:
restore_sc_name = sc_name
if restore_sc is not None:
restore_sc_name = "restore-" + restore_sc_name
d.create_storage_class(restore_sc, restore_sc_name, created_objects)
d.check_storage_class(restore_sc_name)
else:
restore_sc = value_sc
if restore_pvc is not None:
pvc_value = restore_pvc
for num in range(0, number_of_restore):
restored_pvc_name = "restored-pvc"+vs_name[2:]+"-"+str(num)
snap_pod_name = "snap-end-pod"+vs_name[2:]
d.create_pvc_from_snapshot(pvc_value, restore_sc_name, restored_pvc_name, vs_name+"-"+str(num), created_objects)
val = d.check_pvc(pvc_value, restored_pvc_name, created_objects)
if val is True and "permissions" in value_sc.keys():
d.check_permissions_for_pvc(pvc_name, value_sc["permissions"], created_objects)
if val is True:
d.create_pod(value_pod, restored_pvc_name, snap_pod_name, created_objects, self.image_name)
d.check_pod(value_pod, snap_pod_name, created_objects)
d.check_file_inside_pod(value_pod, snap_pod_name, created_objects)
if "postsnap_volume_expansion_storage" in pvc_value:
d.expand_and_check_pvc(restore_sc_name, restored_pvc_name, pvc_value, "postsnap_volume_expansion_storage",
snap_pod_name, value_pod, created_objects)
if "post_presnap_volume_expansion_storage" in pvc_value:
d.expand_and_check_pvc(sc_name, pvc_name, pvc_value, "post_presnap_volume_expansion_storage",
pod_name, value_pod, created_objects)
if value_clone_passed is not None:
d.clone_and_check_pvc(restore_sc_name, restore_sc, restored_pvc_name, snap_pod_name, value_pod, value_clone_passed, created_objects)
cleanup.delete_pod(snap_pod_name, created_objects)
cleanup.check_pod_deleted(snap_pod_name, created_objects)
vol_name = cleanup.delete_pvc(restored_pvc_name, created_objects)
cleanup.check_pvc_deleted(restored_pvc_name, vol_name, created_objects)
cleanup.clean_with_created_objects(created_objects)
def test_static(self, pv_value, pvc_value, sc_value=False, wrong=None, root_volume=False):
config.load_kube_config(config_file=self.kubeconfig)
created_objects = get_cleanup_dict()
sc_name = ""
if sc_value is not False:
sc_name = d.get_random_name("sc")
d.create_storage_class(sc_value, sc_name, created_objects)
d.check_storage_class(sc_name)
FSUID = ff.get_FSUID()
cluster_id = self.cluster_id
if wrong is not None:
if wrong["id_wrong"] is True:
cluster_id = int(cluster_id)+1
cluster_id = str(cluster_id)
if wrong["FSUID_wrong"] is True:
FSUID = "AAAA"
mount_point = ff.get_mount_point()
if root_volume is False:
dir_name = d.get_random_name("dir")
ff.create_dir(dir_name)
created_objects["dir"].append(dir_name)
pv_value["volumeHandle"] = cluster_id+";"+FSUID + \
";path="+mount_point+"/"+dir_name
elif root_volume is True:
pv_value["volumeHandle"] = cluster_id+";"+FSUID + \
";path="+mount_point
if pvc_value == "Default":
pvc_value = copy.deepcopy(self.value_pvc)
num_final = len(pvc_value)
for num in range(0, num_final):
pv_name = d.get_random_name("pv")
d.create_pv(pv_value, pv_name, created_objects, sc_name)
d.check_pv(pv_name)
value_pvc_pass = copy.deepcopy(pvc_value[num])
if (check_key(pv_value, "reason")):
if not(check_key(value_pvc_pass, "reason")):
value_pvc_pass["reason"] = pv_value["reason"]
LOGGER.info(100*"=")
pvc_name = d.get_random_name("pvc")
d.create_pvc(value_pvc_pass, sc_name, pvc_name, created_objects, pv_name)
val = d.check_pvc(value_pvc_pass, pvc_name, created_objects, pv_name)
if val is True:
for num2 in range(0, len(self.value_pod)):
LOGGER.info(100*"-")
pod_name = d.get_random_name("pod")
d.create_pod(self.value_pod[num2], pvc_name, pod_name, created_objects, self.image_name)
d.check_pod(self.value_pod[num2], pod_name, created_objects)
cleanup.delete_pod(pod_name, created_objects)
cleanup.check_pod_deleted(pod_name, created_objects)
if value_pvc_pass["access_modes"] == "ReadWriteOnce" and self.keep_objects is True:
break
LOGGER.info(100*"-")
vol_name = cleanup.delete_pvc(pvc_name, created_objects)
cleanup.check_pvc_deleted(pvc_name, vol_name, created_objects)
cleanup.delete_pv(pv_name, created_objects)
cleanup.check_pv_deleted(pv_name, created_objects)
LOGGER.info(100*"=")
cleanup.clean_with_created_objects(created_objects)
def test_static(self,
pv_value,
pvc_value,
sc_value=False,
wrong=None,
root_volume=False):
config.load_kube_config(config_file=kubeconfig_value)
d.set_test_namespace_value(self.test_ns)
sc_name = ""
if sc_value is not False:
sc_name = d.get_random_name("sc")
d.create_storage_class(sc_value, self.config_file, sc_name)
d.check_storage_class(sc_name)
FSUID = get_FSUID(self.config_file)
cluster_id = self.config_file["id"]
if wrong is not None:
if wrong["id_wrong"] is True:
cluster_id = int(cluster_id) + 1
cluster_id = str(cluster_id)
if wrong["FSUID_wrong"] is True:
FSUID = "AAAA"
mount_point = get_mount_point(self.config_file)
if root_volume is False:
dir_name = d.get_random_name("dir")
create_dir(self.config_file, dir_name)
pv_value["volumeHandle"] = cluster_id+";"+FSUID + \
";path="+mount_point+"/"+dir_name
elif root_volume is True:
pv_value["volumeHandle"] = cluster_id+";"+FSUID + \
";path="+mount_point
dir_name = "nodiravailable"
if pvc_value == "Default":
pvc_value = copy.deepcopy(self.value_pvc)
num_final = len(pvc_value)
for num in range(0, num_final):
pv_name = d.get_random_name("pv")
d.create_pv(pv_value, pv_name, sc_name)
d.check_pv(pv_name)
value_pvc_pass = copy.deepcopy(pvc_value[num])
if (check_key(pv_value, "reason")):
if not (check_key(value_pvc_pass, "reason")):
value_pvc_pass["reason"] = pv_value["reason"]
LOGGER.info(100 * "=")
pvc_name = d.get_random_name("pvc")
d.create_pvc(value_pvc_pass, sc_name, pvc_name, self.config_file,
pv_name)
val = d.check_pvc(value_pvc_pass, sc_name, pvc_name, dir_name,
pv_name)
if val is True:
for num2 in range(0, len(self.value_pod)):
LOGGER.info(100 * "-")
pod_name = d.get_random_name("pod")
d.create_pod(self.value_pod[num2], pvc_name, pod_name)
d.check_pod(self.value_pod[num2], sc_name, pvc_name,
pod_name, dir_name, pv_name)
d.delete_pod(pod_name)
d.check_pod_deleted(pod_name)
LOGGER.info(100 * "-")
d.delete_pvc(pvc_name)
d.check_pvc_deleted(pvc_name)
d.delete_pv(pv_name)
d.check_pv_deleted(pv_name)
LOGGER.info(100 * "=")
delete_dir(self.config_file, dir_name)
if d.check_storage_class(sc_name):
d.delete_storage_class(sc_name)
d.check_storage_class_deleted(sc_name)
