def get_destroy_status(self):
"""
Return the current status of destroy operation
"""
self.navigate_clusters_page(timeout=300)
time.sleep(10)
locator = format_locator(self.acm_page_nav["cc_table_entry"],
self.cluster_name)
if not self.check_element_presence(
(locator[1], locator[0]), timeout=300):
# Cluster deletion has happened
self.destroy_status = "Done"
else:
self.do_click(locator=locator, timeout=300)
loc = format_locator(
self.acm_page_nav["cc_cluster_being_destroyed_heading"],
self.cluster_name,
)
if not self.check_element_presence(
locator=(By.XPATH, loc[0]),
timeout=300,
):
log.error("Cluster destroy status msg missing")
self.destroy_status = "Failed"
else:
elapsed_time = int(time.time() - self.destroy_start_time)
if elapsed_time > self.cluster_destroy_timeout:
self.destroy_status = "Failed"
self.destroy_failed_reason = "timeout"
def create_pvc_ui(self, project_name, sc_name, pvc_name, access_mode,
pvc_size, vol_mode):
"""
Create PVC via UI.
Args:
project_name (str): name of test project
sc_name (str): storage class name
pvc_name (str): the name of pvc
access_mode (str): access mode
pvc_size (str): the size of pvc (GB)
vol_mode (str): volume mode type
"""
self.navigate_persistentvolumeclaims_page()
logger.info(f"Search test project {project_name}")
self.do_click(self.pvc_loc["pvc_project_selector"])
self.do_send_keys(self.pvc_loc["search-project"], text=project_name)
logger.info(f"Select test project {project_name}")
self.do_click(
format_locator(self.pvc_loc["test-project-link"], project_name))
logger.info("Click on 'Create Persistent Volume Claim'")
self.do_click(self.pvc_loc["pvc_create_button"])
logger.info("Select Storage Class")
self.do_click(self.pvc_loc["pvc_storage_class_selector"])
self.do_click(
format_locator(self.pvc_loc["storage_class_name"], sc_name))
logger.info("Select PVC name")
self.do_send_keys(self.pvc_loc["pvc_name"], pvc_name)
logger.info("Select Access Mode")
self.do_click(self.pvc_loc[access_mode])
logger.info("Select PVC size")
self.do_send_keys(self.pvc_loc["pvc_size"], text=pvc_size)
if (sc_name != constants.DEFAULT_STORAGECLASS_CEPHFS
and access_mode == "ReadWriteOnce"):
logger.info(
f"Test running on OCP version: {get_running_ocp_version()}")
logger.info(f"Selecting Volume Mode of type {vol_mode}")
self.do_click(self.pvc_loc[vol_mode])
logger.info("Create PVC")
self.do_click(self.pvc_loc["pvc_create"])
time.sleep(1)
def verify_pvc_resize_ui(self, project_name, pvc_name, expected_capacity):
"""
Verifying PVC resize via UI
Args:
project_name (str): name of test project
pvc_name (str): the name of pvc
expected_capacity (str): the new size of pvc (GiB)
"""
self.navigate_persistentvolumeclaims_page()
logger.info(f"Search and Select test project {project_name}")
self.do_click(self.pvc_loc["pvc_project_selector"])
self.do_send_keys(self.pvc_loc["search-project"], text=project_name)
self.do_click(
format_locator(self.pvc_loc["test-project-link"], project_name))
logger.info(
f"Search for {pvc_name} inside test project {project_name}")
self.do_send_keys(self.pvc_loc["search_pvc"], text=pvc_name)
logger.info(f"Go to PVC {pvc_name} Page")
self.do_click(get_element_type(pvc_name))
is_expected_capacity = self.wait_until_expected_text_is_found(
format_locator(self.pvc_loc["expected-capacity"],
expected_capacity),
expected_text=expected_capacity,
timeout=300,
)
is_capacity = self.wait_until_expected_text_is_found(
format_locator(self.pvc_loc["new-capacity"], expected_capacity),
expected_text=expected_capacity,
timeout=300,
)
if not is_expected_capacity:
logger.error("Expected capacity text is not found")
if not is_capacity:
logger.error("Capacity text is not found")
if is_expected_capacity and is_capacity:
return True
else:
return False
def delete_pvc_ui(self, pvc_name, project_name):
"""
Delete pvc via UI
Args:
pvc_name (str): Name of the pvc
project_name (str): name of test project
"""
self.navigate_persistentvolumeclaims_page()
logger.info(f"Select test project {project_name}")
self.do_click(self.pvc_loc["pvc_project_selector"])
self.do_send_keys(self.pvc_loc["search-project"], text=project_name)
self.do_click(
format_locator(self.pvc_loc["test-project-link"], project_name))
logger.info(
f"Search for {pvc_name} inside test project {project_name}")
self.do_send_keys(self.pvc_loc["search_pvc"], text=pvc_name)
logger.info(f"Go to PVC {pvc_name} Page")
self.do_click(get_element_type(pvc_name))
logger.info("Click on Actions")
self.do_click(self.pvc_loc["pvc_actions"])
logger.info("Click on 'Delete PVC'")
self.do_click(self.pvc_loc["pvc_delete"])
logger.info("Confirm PVC Deletion")
self.do_click(self.pvc_loc["confirm_pvc_deletion"])
time.sleep(1)
def submariner_validation_ui(self):
"""
Checks available status of imported clusters after submariner creation
"""
self.navigate_clusters_page()
self.page_has_loaded(retries=15, sleep_time=5)
self.do_click(locator=self.acm_page_nav["Clusters_page"])
log.info("Click on Cluster sets")
self.do_click(self.page_nav["cluster-sets"])
self.page_has_loaded(retries=15, sleep_time=5)
log.info("Click on the cluster set created")
self.do_click(
format_locator(
locator=self.page_nav["cluster-set-selection"],
string_to_insert=cluster_set_name,
))
log.info("Click on 'Submariner add-ons' tab")
self.do_click(self.page_nav["submariner-tab"])
log.info("Checking connection status of both the imported clusters")
self.wait_until_expected_text_is_found(
locator=self.page_nav["connection-status-1"],
expected_text="Healthy",
timeout=600,
)
self.wait_until_expected_text_is_found(
locator=self.page_nav["connection-status-2"],
expected_text="Healthy",
timeout=600,
)
log.info("Checking agent status of both the imported clusters")
self.wait_until_expected_text_is_found(
locator=self.page_nav["agent-status-1"],
expected_text="Healthy",
timeout=600,
)
self.wait_until_expected_text_is_found(
locator=self.page_nav["agent-status-2"],
expected_text="Healthy",
timeout=600,
)
log.info(
"Checking if nodes of both the imported clusters are labeled or not"
)
self.wait_until_expected_text_is_found(
locator=self.page_nav["node-label-1"],
expected_text="Nodes labeled",
timeout=600,
)
self.wait_until_expected_text_is_found(
locator=self.page_nav["node-label-2"],
expected_text="Nodes labeled",
timeout=600,
)
self.take_screenshot()
log.info("Submariner add-ons creation is successful")
def goto_cluster_details_page(self):
self.navigate_clusters_page()
locator = format_locator(self.acm_page_nav["cc_table_entry"],
self.cluster_name)
self.do_click(locator=locator)
self.do_click(locator=self.acm_page_nav["cc_cluster_details_page"],
timeout=100)
self.choose_expanded_mode(True,
self.acm_page_nav["cc_details_toggle_icon"])
def create_pvc_ui(self, project_name, sc_name, pvc_name, access_mode,
pvc_size, vol_mode):
"""
Create PVC via UI.
Args:
project_name (str): name of test project
sc_name (str): storage class name
pvc_name (str): the name of pvc
access_mode (str): access mode
pvc_size (str): the size of pvc (GB)
vol_mode (str): volume mode type
"""
self.navigate_persistentvolumeclaims_page()
logger.info(f"Search test project {project_name}")
self.do_click(self.pvc_loc["pvc_project_selector"])
self.do_send_keys(self.pvc_loc["search-project"], text=project_name)
self.wait_for_namespace_selection(project_name=project_name)
logger.info("Click on 'Create Persistent Volume Claim'")
self.do_click(self.pvc_loc["pvc_create_button"])
logger.info("Click on Storage Class selection")
self.do_click(self.pvc_loc["pvc_storage_class_selector"])
logger.info("Select the Storage Class type")
self.do_click(
format_locator(self.pvc_loc["storage_class_name"], sc_name))
logger.info("Enter PVC name")
self.do_send_keys(self.pvc_loc["pvc_name"], pvc_name)
logger.info("Select Access Mode")
self.do_click(self.pvc_loc[access_mode])
logger.info("Select PVC size")
self.do_send_keys(self.pvc_loc["pvc_size"], text=pvc_size)
ocs_version = version.get_semantic_ocs_version_from_config()
if (not self.ocp_version_full == version.VERSION_4_6
and not ocs_version == version.VERSION_4_6):
if (sc_name != constants.DEFAULT_STORAGECLASS_CEPHFS
and access_mode == "ReadWriteOnce"):
if (sc_name !=
constants.DEFAULT_EXTERNAL_MODE_STORAGECLASS_CEPHFS
and access_mode == "ReadWriteOnce"):
logger.info(
f"Test running on OCP version: {get_running_ocp_version()}"
)
logger.info(f"Selecting Volume Mode of type {vol_mode}")
self.do_click(self.pvc_loc[vol_mode])
logger.info("Create PVC")
self.do_click(self.pvc_loc["pvc_create"])
def verify_pvc_ui(
self, pvc_size, access_mode, vol_mode, sc_type, pvc_name, project_name
):
"""
Verifying PVC details via UI
Args:
pvc_size (str): the size of pvc (GB)
access_mode (str): access mode
vol_mode (str): volume mode type
sc_type (str): storage class type
pvc_name (str): the name of pvc
project_name (str): name of test project
"""
self.navigate_persistentvolumeclaims_page()
logger.info(f"Search and Select test project {project_name}")
self.do_click(self.pvc_loc["pvc_project_selector"])
self.do_send_keys(self.pvc_loc["search-project"], text=project_name)
self.do_click(format_locator(self.pvc_loc["test-project-link"], project_name))
logger.info(f"Search for {pvc_name} inside test project {project_name}")
self.do_send_keys(self.pvc_loc["search_pvc"], text=pvc_name)
logger.info(f"Go to PVC {pvc_name} Page")
self.do_click(self.pvc_loc[pvc_name])
logger.info("Checking status of Pvc")
self.wait_until_expected_text_is_found(
locator=self.pvc_loc["pvc-status"], expected_text="Bound"
)
pvc_size_new = f"{pvc_size} GiB"
self.check_element_text(expected_text=pvc_size_new)
logger.info(f"Verifying pvc size : {pvc_size_new}")
pvc_access_mode_new = f"{access_mode}"
self.check_element_text(expected_text=pvc_access_mode_new)
logger.info(f"Verifying access mode : {pvc_access_mode_new}")
if (
sc_type
in (
constants.DEFAULT_STORAGECLASS_RBD_THICK,
constants.DEFAULT_STORAGECLASS_RBD,
)
and (access_mode == "ReadWriteOnce")
):
pvc_vol_mode_new = f"{vol_mode}"
self.check_element_text(expected_text=pvc_vol_mode_new)
logger.info(f"Verifying volume mode : {pvc_vol_mode_new}")
def wait_for_namespace_selection(self, project_name):
"""
If you have already navigated to namespace drop-down, this function waits for namespace selection on UI.
It would be useful to avoid test failures in case of delays/latency in populating the list of projects under the
namespace drop-down.
The timeout is hard-coded to 10 seconds in the below function call which is more than sufficient.
Args:
project_name (str): Name of the project to be selected
Returns:
bool: True if the project is found, raises NoSuchElementException otherwise with a log message
"""
from ocs_ci.ocs.ui.helpers_ui import format_locator
if self.ocp_version_full >= version.VERSION_4_10:
default_projects_is_checked = self.driver.find_element_by_xpath(
"//span[@class='pf-c-switch__toggle']"
)
if (
default_projects_is_checked.get_attribute("data-checked-state")
== "false"
):
logger.info("Show default projects")
self.do_click(self.page_nav["show-default-projects"])
pvc_loc = locators[self.ocp_version]["pvc"]
logger.info(f"Wait and select namespace {project_name}")
wait_for_project = self.wait_until_expected_text_is_found(
locator=format_locator(pvc_loc["test-project-link"], project_name),
expected_text=f"{project_name}",
timeout=10,
)
if wait_for_project:
self.do_click(format_locator(pvc_loc["test-project-link"], project_name))
logger.info(f"Namespace {project_name} selected")
else:
raise NoSuchElementException(f"Namespace {project_name} not found on UI")
def destroy_cluster(self):
"""
ACM UI based destroy cluster,
select the cluster from UI, click on destroy
"""
# Navigate to Clusters page
self.navigate_clusters_page()
# Click on cluster name from the table
locator = format_locator(self.acm_page_nav["cc_table_entry"],
self.cluster_name)
self.do_click(locator=locator)
# Click on 'Actions' dropdown
action_dropdown = format_locator(
self.acm_page_nav["cc_delete_cluster_action_dropdown"],
f"{self.cluster_name}-actions",
)
self.do_click(action_dropdown, timeout=300)
# From the 'Actions' dropdown click on 'Destroy Cluster'
self.do_click(locator=self.acm_page_nav["cc_destroy_cluster"],
timeout=300)
# A confirmation window pops up
# Fill cluster name in the confirmation window's text box
self.do_click(self.acm_page_nav["cc_destroy_cluster_confirm_textbox"],
timeout=300)
self.do_send_keys(
self.acm_page_nav["cc_destroy_cluster_confirm_textbox"],
self.cluster_name)
# Click on destroy button
self.do_click(self.acm_page_nav["cc_destroy_button"], timeout=300)
loc = format_locator(
self.acm_page_nav["cc_cluster_being_destroyed_heading"],
self.cluster_name)
if not self.check_element_presence(locator=(By.XPATH, loc[0]),
timeout=600):
raise ACMClusterDeployException(
"Something went wrong with destroy action "
f"for the cluster {self.cluster_name}")
self.destroy_status = "Destroying"
self.destroy_start_time = time.time()
def click_platform_and_credentials(self):
self.navigate_create_clusters_page()
self.do_click(
locator=self.acm_page_nav[PLATFORM_XPATH_MAP[self.platform]],
timeout=100)
self.do_click(
locator=self.
acm_page_nav["cc_infrastructure_provider_creds_dropdown"])
credential = format_locator(
self.acm_page_nav["cc_infrastructure_provider_creds_select_creds"],
self.platform_credential_name,
)
self.do_click(locator=credential)
def pvc_resize_ui(self, project_name, pvc_name, new_size):
"""
Resizing pvc via UI
Args:
project_name (str): name of test project
pvc_name (str): the name of pvc
new_size (int): the new size of pvc (GB)
"""
self.navigate_persistentvolumeclaims_page()
logger.info(f"Search and Select test project {project_name}")
self.do_click(self.pvc_loc["pvc_project_selector"])
self.do_send_keys(self.pvc_loc["search-project"], text=project_name)
self.do_click(
format_locator(self.pvc_loc["test-project-link"], project_name))
logger.info(
f"Search for {pvc_name} inside test project {project_name}")
self.do_send_keys(self.pvc_loc["search_pvc"], text=pvc_name)
logger.info(f"Go to PVC {pvc_name} Page")
self.do_click(get_element_type(pvc_name))
logger.info("Click on Actions")
self.do_click(self.pvc_loc["pvc_actions"])
logger.info("Click on Expand PVC from dropdown options")
self.do_click(self.pvc_loc["expand_pvc"])
logger.info("Clear the size of existing pvc")
self.do_clear(self.pvc_loc["resize-value"])
logger.info("Enter the size of new pvc")
self.do_send_keys(self.pvc_loc["resize-value"], text=new_size)
logger.info("Click on Expand Button")
self.do_click(self.pvc_loc["expand-btn"])
def create_cluster_prereq(self, timeout=600):
"""
Perform all prereqs before vsphere cluster creation from ACM
Args:
timeout (int): Timeout for any UI operations
"""
# Create vsphre credentials
# Click on 'Add credential' in 'Infrastructure provider' page
self.navigate_create_clusters_page()
self.refresh_page()
hard_timeout = config.ENV_DATA.get("acm_ui_hard_deadline", 1200)
remaining = hard_timeout
while True:
ret = self.check_element_presence(
(By.XPATH,
self.acm_page_nav[PLATFORM_XPATH_MAP[self.platform]][0]),
timeout=300,
)
if ret:
log.info("Found platform icon")
break
else:
if remaining < 0:
raise TimeoutException(
"Timedout while waiting for platform icon")
else:
remaining -= timeout
self.navigate_create_clusters_page()
self.refresh_page()
self.do_click(
locator=self.acm_page_nav[PLATFORM_XPATH_MAP[self.platform]],
timeout=100)
# "Basic vsphere credential info"
# 1. credential name
# 2. Namespace
# 3. Base DNS domain
self.do_click(locator=self.acm_page_nav["cc_provider_credentials"],
timeout=100)
parent_tab = self.driver.current_window_handle
tabs = self.driver.window_handles
self.driver.switch_to.window(tabs[1])
self.do_click(locator=self.acm_page_nav["cc_provider_creds_vsphere"])
basic_cred_dict = {
self.acm_page_nav["cc_provider_creds_vsphere_cred_name"]:
self.platform_credential_name,
self.acm_page_nav["cc_provider_creds_vsphere_base_dns"]:
f"{self.cluster_conf.ENV_DATA['base_domain']}",
}
self.fill_multiple_textbox(basic_cred_dict)
# Credential Namespace is not a text box but a dropdown
self.do_click(
self.acm_page_nav["cc_provider_creds_vsphere_cred_namespace"])
self.do_click(self.acm_page_nav["cc_provider_creds_default_namespace"])
# click on 'Next' button at the bottom
self.click_next_button()
# Detailed VMWare credentials section
# 1. vCenter server
# 2. vCenter username
# 3. vCenter password
# 4. cVenter root CA certificate
# 5. vSphere cluster name
# 6. vSphere datacenter
# 7. vSphere default Datastore
with open(VSPHERE_CA_FILE_PATH, "r") as fp:
vsphere_ca = fp.read()
vsphere_creds_dict = {
self.acm_page_nav["cc_provider_creds_vsphere_vcenter_server"]:
f"{self.cluster_conf.ENV_DATA['vsphere_server']}",
self.acm_page_nav["cc_provider_creds_vsphere_username"]:
f"{self.cluster_conf.ENV_DATA['vsphere_user']}",
self.acm_page_nav["cc_provider_creds_vsphere_password"]:
f"{self.cluster_conf.ENV_DATA['vsphere_password']}",
self.acm_page_nav["cc_provider_creds_vsphere_rootca"]:
f"{vsphere_ca}",
self.acm_page_nav["cc_provider_creds_vsphere_clustername"]:
f"{self.cluster_conf.ENV_DATA['vsphere_cluster']}",
self.acm_page_nav["cc_provider_creds_vsphere_dc"]:
f"{self.cluster_conf.ENV_DATA['vsphere_datacenter']}",
self.acm_page_nav["cc_provider_creds_vsphere_datastore"]:
f"{self.cluster_conf.ENV_DATA['vsphere_datastore']}",
}
self.fill_multiple_textbox(vsphere_creds_dict)
self.click_next_button()
# Pull Secret and SSH
# 1. Pull secret
# 2. SSH Private key
# 3. SSH Public key
with open(os.path.join(DATA_DIR, "pull-secret"), "r") as fp:
pull_secret = fp.read()
ssh_pub_key_path = os.path.expanduser(
self.cluster_conf.DEPLOYMENT["ssh_key"])
ssh_priv_key_path = os.path.expanduser(
self.cluster_conf.DEPLOYMENT["ssh_key_private"])
with open(ssh_pub_key_path, "r") as fp:
ssh_pub_key = fp.read()
with open(ssh_priv_key_path, "r") as fp:
ssh_priv_key = fp.read()
pull_secret_and_ssh = {
self.acm_page_nav["cc_provider_creds_vsphere_pullsecret"]:
f"{pull_secret}",
self.acm_page_nav["cc_provider_creds_vsphere_ssh_privkey"]:
f"{ssh_priv_key}",
self.acm_page_nav["cc_provider_creds_vsphere_ssh_pubkey"]:
f"{ssh_pub_key}",
}
self.fill_multiple_textbox(pull_secret_and_ssh)
self.click_next_button()
self.do_click(
locator=self.acm_page_nav["cc_provider_creds_vsphere_add_button"])
# Go to credentials tab
self.do_click(locator=self.acm_page_nav["Credentials"])
credential_table_entry = format_locator(
self.acm_page_nav["cc_table_entry"], self.platform_credential_name)
if not self.check_element_presence(
(By.XPATH, credential_table_entry[0]), timeout=20):
raise ACMClusterDeployException(
"Could not create credentials for vsphere")
else:
log.info(
f"vsphere credential successfully created {self.platform_credential_name}"
)
# Get the ips in prereq itself
from ocs_ci.deployment import vmware
# Switch context to cluster which we are about to create
prev_ctx = config.cur_index
config.switch_ctx(self.cluster_conf.MULTICLUSTER["multicluster_index"])
self.ips = vmware.assign_ips(self.nvips)
vmware.create_dns_records(self.ips)
config.switch_ctx(prev_ctx)
self.driver.close()
self.driver.switch_to.window(parent_tab)
self.driver.switch_to.default_content()
def install_submariner_ui(self):
"""
Installs the Submariner on the ACM Hub cluster and expects 2 OCP clusters to be already imported
on the Hub Cluster to create a link between them
"""
self.navigate_clusters_page()
self.page_has_loaded(retries=15, sleep_time=5)
self.do_click(locator=self.acm_page_nav["Clusters_page"])
log.info("Click on Cluster sets")
self.do_click(self.page_nav["cluster-sets"])
self.page_has_loaded(retries=15, sleep_time=5)
log.info("Click on Create cluster set")
self.do_click(self.page_nav["create-cluster-set"])
global cluster_set_name
cluster_set_name = create_unique_resource_name("submariner",
"clusterset")
log.info(f"Send Cluster set name '{cluster_set_name}'")
self.do_send_keys(self.page_nav["cluster-set-name"],
text=cluster_set_name)
log.info("Click on Create")
self.do_click(self.page_nav["click-create"], enable_screenshot=True)
time.sleep(1)
log.info("Click on Manage resource assignments")
self.do_click(self.page_nav["click-manage-resource-assignments"],
enable_screenshot=True)
log.info(f"Search and select cluster '{cluster_name_a}'")
self.do_send_keys(self.page_nav["search-cluster"], text=cluster_name_a)
self.do_click(self.page_nav["select-first-checkbox"],
enable_screenshot=True)
log.info("Clear search by clicking on cross mark")
self.do_click(self.page_nav["clear-search"])
log.info(f"Search and select cluster '{cluster_name_b}'")
self.do_send_keys(self.page_nav["search-cluster"], text=cluster_name_b)
self.do_click(self.page_nav["select-first-checkbox"],
enable_screenshot=True)
log.info("Clear search by clicking on cross mark [2]")
self.do_click(self.page_nav["clear-search"])
log.info("Click on 'Review'")
self.do_click(self.page_nav["review-btn"], enable_screenshot=True)
log.info("Click on 'Save' to confirm the changes")
self.do_click(self.page_nav["confirm-btn"], enable_screenshot=True)
time.sleep(3)
log.info("Click on 'Submariner add-ons' tab")
self.do_click(self.page_nav["submariner-tab"])
log.info("Click on 'Install Submariner add-ons' button")
self.do_click(self.page_nav["install-submariner-btn"])
log.info("Click on 'Target clusters'")
self.do_click(self.page_nav["target-clusters"])
log.info(f"Select 1st cluster which is {cluster_name_a}")
self.do_click(
format_locator(
locator=self.page_nav["cluster-name-selection"],
string_to_insert=cluster_name_a,
))
log.info(f"Select 2nd cluster which is {cluster_name_b}")
self.do_click(
format_locator(
locator=self.page_nav["cluster-name-selection"],
string_to_insert=cluster_name_b,
),
enable_screenshot=True,
)
log.info("Click on Next button")
self.do_click(self.page_nav["next-btn"])
log.info("Click on 'Enable NAT-T' to uncheck it")
self.do_click(self.page_nav["nat-t-checkbox"])
log.info(
"Increase the gateway count to 3 by clicking twice on the gateway count add button"
)
self.do_click(self.page_nav["gateway-count-btn"])
self.do_click(self.page_nav["gateway-count-btn"])
log.info("Click on Next button")
self.do_click(self.page_nav["next-btn"])
log.info("Click on 'Enable NAT-T' to uncheck it [2]")
self.do_click(self.page_nav["nat-t-checkbox"])
log.info(
"Increase the gateway count to 3 by clicking twice on the gateway count add button [2]"
)
self.do_click(self.page_nav["gateway-count-btn"])
self.do_click(self.page_nav["gateway-count-btn"])
log.info("Click on Next button [2]")
self.do_click(self.page_nav["next-btn"])
self.take_screenshot()
log.info("Click on 'Install'")
self.do_click(self.page_nav["install-btn"])
def pvc_clone_ui(
self,
project_name,
pvc_name,
cloned_pvc_access_mode=constants.ACCESS_MODE_RWO,
cloned_pvc_name=None,
):
"""
Clone PVC via UI
Args:
project_name (str): The name of project
pvc_name (str): The name of PVC
cloned_pvc_access_mode (str): Access mode for cloned PVC
cloned_pvc_name (str): The name for cloned PVC
"""
clone_name = cloned_pvc_name or f"{pvc_name}-clone"
self.navigate_persistentvolumeclaims_page()
logger.info(f"Search and select the project {project_name}")
self.do_click(self.pvc_loc["pvc_project_selector"])
self.do_send_keys(self.pvc_loc["search-project"], text=project_name)
self.wait_for_namespace_selection(project_name=project_name)
logger.info(f"Search for PVC {pvc_name}")
self.do_send_keys(self.pvc_loc["search_pvc"], text=pvc_name)
logger.info(f"Go to PVC {pvc_name} page")
self.do_click(get_element_type(pvc_name))
logger.info("Click on Actions")
self.do_click(self.pvc_loc["pvc_actions"])
logger.info("Click on Clone PVC from dropdown options")
self.do_click(self.pvc_loc["clone_pvc"], enable_screenshot=True)
logger.info("Clear the default name of clone PVC")
ocs_version = version.get_semantic_ocs_version_from_config()
if (self.ocp_version_full == version.VERSION_4_6
and ocs_version == version.VERSION_4_6):
self.do_clear(
format_locator(self.pvc_loc["clone_name_input"], clone_name))
else:
self.do_clear(self.pvc_loc["clone_name_input"])
logger.info("Enter the name of clone PVC")
if (self.ocp_version_full == version.VERSION_4_6
and ocs_version == version.VERSION_4_6):
self.do_send_keys(
format_locator(self.pvc_loc["clone_name_input"], clone_name),
text=clone_name,
)
else:
self.do_send_keys(self.pvc_loc["clone_name_input"],
text=clone_name)
if (not self.ocp_version_full == version.VERSION_4_6
and ocs_version == version.VERSION_4_6):
logger.info("Select Access Mode of clone PVC")
self.do_click(self.pvc_loc[cloned_pvc_access_mode])
logger.info("Click on Clone button")
self.do_click(generic_locators["confirm_action"],
enable_screenshot=True)
