def test_store_creation_and_deletion(
self, setup_ui_class, cld_mgr, cloud_uls_factory, kind
):
"""
Test creation and deletion of MCG stores via the UI
"""
uls_name = list(cloud_uls_factory({"aws": [(1, "us-east-2")]})["aws"])[0]
store_name = create_unique_resource_name(
resource_description="ui", resource_type=kind
)
store_ui_obj = MCGStoreUI(setup_ui_class)
store_ui_obj.create_store_ui(
kind, store_name, cld_mgr.aws_client.secret.name, uls_name
)
assert store_ui_obj.verify_current_page_resource_status(
constants.STATUS_READY
), f"Created {kind} was not ready in time"
logger.info(f"Delete {store_name}")
store_ui_obj.delete_store_ui(kind, store_name)
test_store = OCP(
namespace=config.ENV_DATA["cluster_namespace"],
kind=kind,
resource_name=store_name,
)
assert test_store.check_resource_existence(should_exist=False)
def test_standard_bc_creation_and_deletion(
self,
setup_ui,
backingstore_factory,
policy,
bs_amount,
):
"""
Test creation and deletion of a BS via the UI
"""
test_stores = backingstore_factory("oc",
{"aws": [(bs_amount, "us-east-2")]})
bc_name = create_unique_resource_name(resource_description="ui",
resource_type="bucketclass")
bc_ui_obj = BucketClassUI(setup_ui)
bc_ui_obj.create_standard_bucketclass_ui(
bc_name, policy, [bs.name for bs in test_stores])
assert bc_ui_obj.verify_current_page_resource_status(
constants.STATUS_READY
), "Created bucketclass was not ready in time"
logger.info(f"Delete {bc_name}")
bc_ui_obj.delete_bucketclass_ui(bc_name)
test_bc = OCP(
namespace=config.ENV_DATA["cluster_namespace"],
kind="bucketclass",
resource_name=bc_name,
)
assert test_bc.check_resource_existence(should_exist=False)
def test_obc_creation_and_deletion(self, setup_ui_class, storageclass, bucketclass):
"""
Test creation and deletion of an OBC via the UI
"""
obc_name = create_unique_resource_name(
resource_description="ui", resource_type="obc"
)
obc_ui_obj = ObcUI(setup_ui_class)
obc_ui_obj.create_obc_ui(obc_name, storageclass, bucketclass)
assert obc_ui_obj.verify_current_page_resource_status(
constants.STATUS_BOUND
), "Created OBC was not ready in time"
test_obc = OCP(
namespace=config.ENV_DATA["cluster_namespace"],
kind="obc",
resource_name=obc_name,
)
test_obc_obj = test_obc.get()
obc_storageclass = test_obc_obj.get("spec").get("storageClassName")
obc_bucketclass = (
test_obc_obj.get("spec").get("additionalConfig").get("bucketclass")
)
assert (
obc_storageclass == storageclass
), f"StorageClass mismatch. Expected: {storageclass}, found: {obc_storageclass}"
assert (
obc_bucketclass == bucketclass
), f"BucketClass mismatch. Expected: {bucketclass}, found: {obc_bucketclass}"
logger.info(f"Delete {obc_name}")
obc_ui_obj.delete_obc_ui(obc_name)
assert test_obc.check_resource_existence(should_exist=False)
def test_del_mon_svc(
self, multi_pvc_factory, validate_all_mon_svc_are_up_at_teardown
):
"""
Test to verify same mon comes up and running
after deleting mon services manually and joins the quorum
1. Delete the mon services
2. Restart the rook operator
3. Make sure all mon pods are running,
and same service or endpoints are running
4. Make sure ceph health Ok and storage pods are running
5. Create PVC, should succeeded.
"""
self.sanity_helpers = Sanity()
# Get all mon services
mon_svc_before = get_services_by_label(
label=constants.MON_APP_LABEL,
namespace=constants.OPENSHIFT_STORAGE_NAMESPACE,
)
# Get all mon pods
mon_pods = get_mon_pods()
# Delete the mon services one by one
svc_obj = OCP(
kind=constants.SERVICE, namespace=constants.OPENSHIFT_STORAGE_NAMESPACE
)
mon_svc_ip_before = []
for svc in mon_svc_before:
svc_name = svc["metadata"]["name"]
mon_svc_ip_before.append(svc["spec"]["clusterIP"])
log.info(f"Delete mon service {svc_name}")
svc_obj.delete(resource_name=svc_name)
# Verify mon services deleted
svc_obj.wait_for_delete(resource_name=svc_name)
# Restart the rook-operator pod
operator_pod_obj = get_operator_pods()
delete_pods(pod_objs=operator_pod_obj)
POD_OBJ.wait_for_resource(
condition=constants.STATUS_RUNNING, selector=constants.OPERATOR_LABEL
)
# Verify same mon services are created again
for svc in mon_svc_before:
svc_name = svc["metadata"]["name"]
svc_obj.check_resource_existence(
should_exist=True, timeout=300, resource_name=svc_name
)
log.info("Same old mon services are recreated")
# Validate all mons are running
log.info("Validate all mons are up and running")
POD_OBJ.wait_for_resource(
condition=constants.STATUS_RUNNING,
selector=constants.MON_APP_LABEL,
resource_count=len(mon_pods),
timeout=600,
sleep=3,
)
# Validate same mon services are running
log.info("Validate same mon services are running")
mon_svc_after = get_services_by_label(
label=constants.MON_APP_LABEL,
namespace=constants.OPENSHIFT_STORAGE_NAMESPACE,
)
mon_svc_ip_after = [svc["spec"]["clusterIP"] for svc in mon_svc_after]
assert len(set(mon_svc_ip_after) ^ set(mon_svc_ip_before)) == 0, (
"Different mon services are running. "
f"Before mon services list: {mon_svc_ip_before}, "
f"After mon services list: {mon_svc_ip_after}"
)
log.info("Same old mon services are running and all mons are in running state")
# Verify everything running fine
log.info("Verifying All resources are Running and matches expected result")
self.sanity_helpers.health_check(tries=120)
# Validate all storage pods are running
wait_for_storage_pods()
# Create and delete resources
self.sanity_helpers.create_pvc_delete(multi_pvc_factory=multi_pvc_factory)
