def create_pvc_and_verify_pvc_exists( sc_name, cbp_name, desired_status=constants.STATUS_BOUND, wait=True ): """ Create pvc, verify pvc is bound in state and pvc exists on ceph side """ pvc_data = templating.load_yaml_to_dict(constants.CSI_PVC_YAML) pvc_data['metadata']['name'] = helpers.create_unique_resource_name( 'test', 'pvc' ) pvc_data['spec']['storageClassName'] = sc_name pvc_data['spec']['resources']['requests']['storage'] = "10Gi" pvc_obj = pvc.PVC(**pvc_data) pvc_obj.create() if wait: assert pvc_obj.ocp.wait_for_resource( condition=desired_status, resource_name=pvc_obj.name ), f"{pvc_obj.kind} {pvc_obj.name} failed to reach" f"status {desired_status}" pvc_obj.reload() # ToDo: Add validation to check pv exists on bcaekend # Commenting the below code: https://bugzilla.redhat.com/show_bug.cgi?id=1723656 # Validate pv is created on ceph # logger.info(f"Verifying pv exists on backend") # ct_pod = pod.get_ceph_tools_pod() # pv_list = ct_pod.exec_ceph_cmd( # ceph_cmd=f"rbd ls -p {cbp_name}", format='json' # ) # _rc = pvc_obj.backed_pv in pv_list # assert _rc, f"pv doesn't exist on backend" # logger.info(f"pv {pvc_obj.backed_pv} exists on backend") return pvc_obj
def _factory(job_name=None, bucket=None, project=None, custom_options=None): """ Args: job_name (str): Name of the job bucket (obj): MCG bucket with S3 interface project (obj): OCP object representing OCP project which will be used for the job mcg_obj (obj): instance of MCG class resource_path (str): path to directory where should be created resources custom_options (dict): Dictionary of lists containing tuples with additional configuration for fio in format: {'section': [('option', 'value'),...],...} e.g. {'global':[('name','bucketname')],'create':[('time_based','1'),('runtime','48h')]} Those values can be added to the config or rewrite already existing values Returns: func: MCG workload job factory function """ job_name = job_name or create_unique_resource_name( resource_description='mcg-io', resource_type='job') bucket = bucket or bucket_factory() project = project or project_factory() job = create_workload_job(job_name, bucket, project, mcg_obj, resource_path, custom_options) instances.append(job) return job
def create_pvc_clone(sc_name, parent_pvc, clone_yaml, pvc_name=None, do_reload=True, storage_size=None): """ Create a cloned pvc from existing pvc Args: sc_name (str): The name of storage class (same for both parent and cloned pvc). parent_pvc (str): Name of the parent pvc, whose clone is to be created. pvc_name (str): The name of the PVC being created do_reload (bool): True for wait for reloading PVC after its creation, False otherwise storage_size (str): Size of the clone, if not passed will use the default "storage" value from pvc-clone.yaml Returns: PVC: PVC instance """ pvc_data = templating.load_yaml(clone_yaml) pvc_data['metadata']['name'] = (pvc_name if pvc_name else helpers.create_unique_resource_name( 'cloned', 'pvc')) pvc_data['spec']['storageClassName'] = sc_name pvc_data['spec']['dataSource']['name'] = parent_pvc if storage_size: pvc_data['spec']['resources']['requests']['storage'] = storage_size ocs_obj = PVC(**pvc_data) created_pvc = ocs_obj.create(do_reload=do_reload) assert created_pvc, f"Failed to create resource {pvc_name}" return ocs_obj
def create_pvc_and_verify_pvc_exists(sc_name, cbp_name, desired_status=constants.STATUS_BOUND, wait=True): """ Create pvc, verify pvc is bound in state and pvc exists on ceph side """ pvc_data = defaults.CSI_PVC_DICT.copy() pvc_data['metadata']['name'] = helpers.create_unique_resource_name( 'test', 'pvc') pvc_data['spec']['storageClassName'] = sc_name pvc_data['spec']['resources']['requests']['storage'] = "10Gi" pvc_obj = pvc.PVC(**pvc_data) pvc_obj.create() if wait: assert pvc_obj.ocp.wait_for_resource( condition=desired_status, resource_name=pvc_obj.name ), f"{pvc_obj.kind} {pvc_obj.name} failed to reach" f"status {desired_status}" pvc_obj.reload() # Validate pv is created on ceph logger.info(f"Verifying pv exists on backend") ct_pod = pod.get_ceph_tools_pod() pv_list = ct_pod.exec_ceph_cmd(ceph_cmd=f"rbd ls -p {cbp_name}", format='json') _rc = pvc_obj.backed_pv in pv_list assert _rc, f"pv doesn't exist on backend" logger.info(f"pv {pvc_obj.backed_pv} exists on backend") return pvc_obj
def create_new_aws_connection(self, conn_name=None): """ Creates a new NooBaa connection to an AWS backend Args: conn_name: The connection name to be used Returns: bool: False if the connection creation failed """ if conn_name is None: conn_name = create_unique_resource_name('awsconnection', 'mcgconn') params = { "auth_method": "AWS_V4", "endpoint": "https://s3.amazonaws.com", "endpoint_type": "AWS", "identity": self.aws_access_key_id, "name": conn_name, "secret": self.aws_access_key } try: for resp in TimeoutSampler(30, 3, self.send_rpc_query, 'account_api', 'add_external_connection', params): if 'error' not in resp.text: logger.info(f'Connection {conn_name} created successfully') return True else: logger.info('AWS IAM did not yet propagate') except TimeoutExpiredError: logger.error(f'Could not create connection {conn_name}') assert False
def create_buckets(request, noobaa_obj): """ Creates multiple buckets """ created_buckets = [] def verify_bucket(): """ Verifies whether buckets exists after deletion """ for bucket in created_buckets: logger.info(f"Verifying whether bucket: {bucket.name} exists" f" after deletion") assert noobaa_obj.s3_verify_bucket_exists(bucket) is False request.addfinalizer(verify_bucket) bucket_name = create_unique_resource_name( resource_description='bucket', resource_type='s3' ) logger.info(f'Creating bucket: {bucket_name}') created_buckets.append( noobaa_obj.s3_create_bucket(bucketname=bucket_name) ) return created_buckets
def test_write_file_to_bucket(self, noobaa_obj, awscli_pod, created_buckets, uploaded_objects): """ Test object IO using the S3 SDK """ # Retrieve a list of all objects on the test-objects bucket and downloads them to the pod downloaded_files = [] public_s3 = boto3.resource('s3', region_name=noobaa_obj.region) for obj in public_s3.Bucket(constants.TEST_FILES_BUCKET).objects.all(): # Download test object(s) logger.info(f'Downloading {obj.key}') awscli_pod.exec_cmd_on_pod( command=f'wget https://{constants.TEST_FILES_BUCKET}.s3.{noobaa_obj.region}.amazonaws.com/{obj.key}' ) downloaded_files.append(obj.key) bucketname = create_unique_resource_name(self.__class__.__name__.lower(), 's3-bucket') logger.info(f'Creating the test bucket - {bucketname}') created_buckets.append(noobaa_obj.s3_create_bucket(bucketname=bucketname)) # Write all downloaded objects to the new bucket logger.info(f'Writing objects to bucket') for obj_name in downloaded_files: full_object_path = f"s3://{bucketname}/{obj_name}" copycommand = f"cp {obj_name} {full_object_path}" assert 'Completed' in awscli_pod.exec_cmd_on_pod( command=craft_s3_command(noobaa_obj, copycommand), out_yaml_format=False, secrets=[noobaa_obj.access_key_id, noobaa_obj.access_key, noobaa_obj.endpoint] ) uploaded_objects.append(full_object_path)
def test_verify_all_fields_in_sc_yaml_with_oc_describe(self, interface): """ Test function to create RBD and CephFS SC, and match with oc describe sc output """ log.info(f"Creating a {interface} storage class") self.sc_data = templating.load_yaml( getattr(constants, f"CSI_{interface}_STORAGECLASS_YAML")) self.sc_data['metadata']['name'] = ( helpers.create_unique_resource_name('test', f'csi-{interface.lower()}')) global SC_OBJ SC_OBJ = OCS(**self.sc_data) assert SC_OBJ.create() log.info( f"{interface}Storage class: {SC_OBJ.name} created successfully") log.info(self.sc_data) # Get oc describe sc output describe_out = SC_OBJ.get("sc") log.info(describe_out) # Confirm that sc yaml details matches oc describe sc output value = { k: describe_out[k] for k in set(describe_out) - set(self.sc_data) } assert len(value) == 1 and value['volumeBindingMode'] == 'Immediate', ( "OC describe sc output didn't match storage class yaml") log.info("OC describe sc output matches storage class yaml") # Delete Storage Class log.info(f"Deleting Storageclass: {SC_OBJ.name}") assert SC_OBJ.delete() log.info(f"Storage Class: {SC_OBJ.name} deleted successfully") del SC_OBJ
def request_aws_credentials(self): """ Uses a CredentialsRequest CR to create an AWS IAM that allows the program to interact with S3 Returns: OCS: The CredentialsRequest resource """ awscreds_data = templating.load_yaml(constants.MCG_AWS_CREDS_YAML) req_name = create_unique_resource_name('awscredreq', 'credentialsrequests') awscreds_data['metadata']['name'] = req_name awscreds_data['metadata']['namespace'] = self.namespace awscreds_data['spec']['secretRef']['name'] = req_name awscreds_data['spec']['secretRef']['namespace'] = self.namespace creds_request = create_resource(**awscreds_data) sleep(5) secret_ocp_obj = OCP(kind='secret', namespace=self.namespace) cred_req_secret_dict = secret_ocp_obj.get(creds_request.name) aws_access_key_id = base64.b64decode( cred_req_secret_dict.get('data').get('aws_access_key_id')).decode( 'utf-8') aws_access_key = base64.b64decode( cred_req_secret_dict.get('data').get( 'aws_secret_access_key')).decode('utf-8') def _check_aws_credentials(): try: s3_res = boto3.resource( 's3', verify=False, endpoint_url="https://s3.amazonaws.com", aws_access_key_id=aws_access_key_id, aws_secret_access_key=aws_access_key) test_bucket = s3_res.create_bucket( Bucket=create_unique_resource_name('cred-verify', 's3-bucket')) test_bucket.delete() return True except ClientError: logger.info('Credentials are still not active. Retrying...') return False try: for api_test_result in TimeoutSampler(40, 5, _check_aws_credentials): if api_test_result: logger.info('AWS credentials created successfully.') break except TimeoutExpiredError: logger.error('Failed to create credentials') assert False return creds_request, aws_access_key_id, aws_access_key
def _create_buckets(amount=1, interface='S3', *args, **kwargs): """ Creates and deletes all buckets that were created as part of the test Args: amount (int): The amount of buckets to create interface (str): The interface to use for creation of buckets. S3 | OC | CLI Returns: list: A list of s3.Bucket objects, containing all the created buckets """ if interface.lower() not in bucketMap: raise RuntimeError( f'Invalid interface type received: {interface}. ' f'available types: {", ".join(bucketMap.keys())}' ) for i in range(amount): bucket_name = create_unique_resource_name( resource_description='bucket', resource_type=interface.lower() ) created_buckets.append( bucketMap[interface.lower()](mcg_obj, bucket_name, *args, **kwargs) ) return created_buckets
def setup(self): """ Create new project Create PVCs """ # Create new project self.namespace = create_unique_resource_name('test', 'namespace') self.project_obj = ocp.OCP(kind='Project', namespace=self.namespace) assert self.project_obj.new_project( self.namespace), (f'Failed to create new project {self.namespace}') # Parameters for PVC yaml as dict pvc_data = load_yaml_to_dict(constants.CSI_PVC_YAML) pvc_data['metadata']['namespace'] = self.namespace pvc_data['spec']['storageClassName'] = self.sc_obj.name pvc_data['metadata']['name'] = self.pvc_base_name # Create 100 PVCs pvc_objs = create_multiple_pvc(self.number_of_pvc, pvc_data) log.info(f'Created initial {self.number_of_pvc} PVCs') self.pvc_objs_initial = pvc_objs[:] # Verify PVCs are Bound and fetch PV names for pvc in self.pvc_objs_initial: pvc.reload() assert pvc.status == constants.STATUS_BOUND, ( f'PVC {pvc.name} is not Bound') self.initial_pvs.append(pvc.backed_pv) log.info(f'Initial {self.number_of_pvc} PVCs are in Bound state')
def test_bucket_delete_with_objects(self, mcg_obj, interface, awscli_pod): """ Negative test with deletion of bucket has objects stored in. """ bucket_map = {'s3': S3Bucket, 'oc': OCBucket, 'cli': CLIBucket} bucketname = create_unique_resource_name( resource_description='bucket', resource_type=interface.lower()) try: bucket = bucket_map[interface.lower()](mcg_obj, bucketname) logger.info(f"aws s3 endpoint is {mcg_obj.s3_endpoint}") logger.info(f"aws region is {mcg_obj.region}") data_dir = '/data' full_object_path = f"s3://{bucketname}" helpers.retrieve_test_objects_to_pod(awscli_pod, data_dir) helpers.sync_object_directory(awscli_pod, data_dir, full_object_path, mcg_obj) logger.info(f"Deleting bucket: {bucketname}") if interface == "S3": try: s3_del = mcg_obj.s3_resource.Bucket(bucketname).delete() assert not s3_del, ( "Unexpected s3 delete non-empty OBC succeed") except botocore.exceptions.ClientError as err: assert "BucketNotEmpty" in str(err), ( "Couldn't verify delete non-empty OBC with s3") logger.info( f"Delete non-empty OBC {bucketname} failed as expected" ) finally: bucket.delete()
def test_reclaim_policy_retain(self): """ Calling functions for pvc invalid name and size """ pvc_count = len(list_ceph_images(pool_name=self.cbp_obj.name)) pvc_obj = helpers.create_pvc( sc_name=self.sc_obj_retain.name, pvc_name=helpers.create_unique_resource_name('retain', 'pvc') ) helpers.wait_for_resource_state(pvc_obj, constants.STATUS_BOUND) pvc_obj.reload() pv_name = pvc_obj.get()['spec']['volumeName'] pv_namespace = pvc_obj.get()['metadata']['namespace'] pv_obj = ocp.OCP(kind='PersistentVolume', namespace=pv_namespace) assert pvc_obj.delete() pvc_obj.ocp.wait_for_delete(resource_name=pvc_obj.name) assert pv_obj.get(pv_name).get('status').get('phase') == 'Released', ( f"Status of PV {pv_obj.get(pv_name)} is not 'Released'" ) log.info("Status of PV is Released") assert pvc_count + 1 == len(list_ceph_images(pool_name=self.cbp_obj.name)) assert pv_obj.delete(resource_name=pv_name) assert pv_obj.wait_for_delete(pv_name, 60), ( f"PV {pv_name} is not deleted" )
def multiregion_mirror_setup(mcg_obj, multiregion_resources, bucket_factory): # Setup # Todo: # add region and amount parametrization - note that `us-east-1` will cause an error # as it is the default region. If usage of `us-east-1` needs to be tested, keep the 'region' field out. aws_buckets, backingstore_secrets, backingstore_objects, bucketclasses = multiregion_resources # Define backing stores backingstore1 = { 'name': create_unique_resource_name(resource_description='testbs', resource_type='s3bucket'), 'region': f'us-west-{randrange(1, 3)}' } backingstore2 = { 'name': create_unique_resource_name(resource_description='testbs', resource_type='s3bucket'), 'region': f'us-east-2' } # Create target buckets for them mcg_obj.create_new_backingstore_aws_bucket(backingstore1) mcg_obj.create_new_backingstore_aws_bucket(backingstore2) aws_buckets.extend((backingstore1['name'], backingstore2['name'])) # Create a backing store secret backingstore_secret = mcg_obj.create_aws_backingstore_secret( backingstore1['name'] + 'secret') backingstore_secrets.append(backingstore_secret) # Create AWS-backed backing stores on NooBaa backingstore_obj_1 = mcg_obj.oc_create_aws_backingstore( backingstore1['name'], backingstore1['name'], backingstore_secret.name, backingstore1['region']) backingstore_obj_2 = mcg_obj.oc_create_aws_backingstore( backingstore2['name'], backingstore2['name'], backingstore_secret.name, backingstore2['region']) backingstore_objects.extend((backingstore_obj_1, backingstore_obj_2)) # Create a new mirror bucketclass that'll use all the backing stores we created bucketclass = mcg_obj.oc_create_bucketclass( create_unique_resource_name(resource_description='testbc', resource_type='bucketclass'), [backingstore.name for backingstore in backingstore_objects], 'Mirror') bucketclasses.append(bucketclass) # Create a NooBucket that'll use the bucket class in order to test the mirroring policy bucket_name = bucket_factory(1, 'OC', bucketclass=bucketclass.name)[0].name return bucket_name, backingstore1, backingstore2
def test_s3_bucket_creation(self, noobaa_obj, created_buckets): """ Test bucket creation using the S3 SDK """ bucketname = create_unique_resource_name(self.__class__.__name__.lower(), 's3-bucket') logger.info(f'Creating new bucket - {bucketname}') created_buckets.append(noobaa_obj.s3_create_bucket(bucketname=bucketname))
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) obc_data = templating.load_yaml(constants.MCG_OBC_YAML) if self.name is None: self.name = create_unique_resource_name('oc', 'obc') obc_data['metadata']['name'] = self.name obc_data['spec']['bucketName'] = self.name obc_data['metadata']['namespace'] = self.mcg.namespace create_resource(**obc_data)
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) obc_data = templating.load_yaml(constants.MCG_OBC_YAML) if self.name is None: self.name = create_unique_resource_name('oc', 'obc') obc_data['metadata']['name'] = self.name obc_data['spec']['bucketName'] = self.name obc_data['spec']['storageClassName'] = constants.INDEPENDENT_DEFAULT_STORAGECLASS_RGW obc_data['metadata']['namespace'] = self.namespace create_resource(**obc_data)
def create_pod(request): """ Create a pod """ class_instance = request.node.cls pod_data = templating.load_yaml_to_dict(constants.CSI_RBD_POD_YAML) pod_data['metadata']['name'] = helpers.create_unique_resource_name( 'test', 'pod') pod_data['metadata']['namespace'] = defaults.ROOK_CLUSTER_NAMESPACE pod_data['spec']['volumes'][0]['persistentVolumeClaim'][ 'claimName'] = class_instance.pvc_obj.name class_instance.pod_obj = helpers.create_pod(**pod_data)
def test_basics_rbd(self, test_fixture_rbd): """ Testing basics: secret creation, storage class creation,pvc and pod with rbd """ global RBD_PVC_OBJ, RBD_POD_OBJ log.info('creating pvc for RBD ') pvc_name = helpers.create_unique_resource_name('test-rbd', 'pvc') RBD_PVC_OBJ = helpers.create_pvc(sc_name=RBD_SC_OBJ.name, pvc_name=pvc_name) if RBD_PVC_OBJ.backed_pv is None: RBD_PVC_OBJ.reload() RBD_POD_OBJ = helpers.create_pod( interface_type=constants.CEPHBLOCKPOOL, pvc_name=RBD_PVC_OBJ.name)
def test_basics_cephfs(self, test_fixture_cephfs): """ Testing basics: secret creation, storage class creation, pvc and pod with cephfs """ global CEPHFS_PVC_OBJ, CEPHFS_POD_OBJ log.info('creating pvc for CephFS ') pvc_name = helpers.create_unique_resource_name('test-cephfs', 'pvc') CEPHFS_PVC_OBJ = helpers.create_pvc(sc_name=CEPHFS_SC_OBJ.name, pvc_name=pvc_name) log.info('creating cephfs pod') CEPHFS_POD_OBJ = helpers.create_pod( interface_type=constants.CEPHFILESYSTEM, pvc_name=CEPHFS_PVC_OBJ.name)
def setup(self): """ Setting up the environment for the test """ # Create a storage class log.info("Creating a Storage Class") self.sc_data = templating.load_yaml(constants.CSI_RBD_STORAGECLASS_YAML) self.sc_data['metadata']['name'] = helpers.create_unique_resource_name( 'test', 'csi-rbd') global SC_OBJ SC_OBJ = OCS(**self.sc_data) assert SC_OBJ.create() log.info(f"Storage class: {SC_OBJ.name} created successfully") log.debug(self.sc_data)
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) obc_data = templating.load_yaml(constants.MCG_OBC_YAML) if self.name is None: self.name = create_unique_resource_name('oc', 'obc') obc_data['metadata']['name'] = self.name obc_data['spec']['bucketName'] = self.name obc_data['spec']['storageClassName'] = self.namespace + '.noobaa.io' obc_data['metadata']['namespace'] = self.namespace if 'bucketclass' in kwargs: obc_data.setdefault('spec', {}).setdefault( 'additionalConfig', {}).setdefault('bucketclass', kwargs['bucketclass']) create_resource(**obc_data)
def setup_fs(self): """ Setting up the environment for the test """ global CEPH_OBJ self.fs_data = defaults.CEPHFILESYSTEM_DICT.copy() self.fs_data['metadata']['name'] = helpers.create_unique_resource_name( 'test', 'cephfs') self.fs_data['metadata']['namespace'] = ENV_DATA['cluster_namespace'] CEPH_OBJ = OCS(**self.fs_data) CEPH_OBJ.create() assert POD.wait_for_resource(condition='Running', selector='app=rook-ceph-mds') pods = POD.get(selector='app=rook-ceph-mds')['items'] assert len(pods) == 2
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) obc_data = templating.load_yaml(constants.MCG_OBC_YAML) if self.name is None: self.name = create_unique_resource_name('oc', 'obc') obc_data['metadata']['name'] = self.name obc_data['spec']['bucketName'] = self.name if storagecluster_independent_check(): obc_data['spec'][ 'storageClassName'] = constants.DEFAULT_EXTERNAL_MODE_STORAGECLASS_RGW else: obc_data['spec'][ 'storageClassName'] = constants.DEFAULT_STORAGECLASS_RGW obc_data['metadata']['namespace'] = self.namespace create_resource(**obc_data)
def test_storageclass_invalid(self, invalid_storageclass): """ Test that Persistent Volume Claim can not be created from misconfigured CephFS Storage Class. """ pvc_data = templating.load_yaml_to_dict(constants.CSI_PVC_YAML) pvc_name = helpers.create_unique_resource_name('test', 'pvc') pvc_data['metadata']['name'] = pvc_name pvc_data['metadata']['namespace'] = defaults.ROOK_CLUSTER_NAMESPACE pvc_data['spec']['storageClassName'] = invalid_storageclass[ 'metadata']['name'] logger.info( f"Create PVC {pvc_name} " f"with storageClassName " f"{invalid_storageclass['metadata']['name']}" ) pvc = PVC(**pvc_data) pvc.create() pvc_status = pvc.status logger.debug(f"Status of PVC {pvc_name} after creation: {pvc_status}") assert pvc_status == constants.STATUS_PENDING logger.info( f"Waiting for status '{constants.STATUS_BOUND}' " f"for 60 seconds (it shouldn't change)" ) with pytest.raises(TimeoutExpiredError): # raising TimeoutExpiredError is expected behavior pvc_status_changed = pvc.ocp.wait_for_resource( resource_name=pvc_name, condition=constants.STATUS_BOUND, timeout=60, sleep=20 ) logger.debug('Check that PVC status did not changed') assert not pvc_status_changed pvc_status = pvc.status logger.info(f"Status of PVC {pvc_name} after 60 seconds: {pvc_status}") assert_msg = ( f"PVC {pvc_name} hasn't reached status " f"{constants.STATUS_PENDING}" ) assert pvc_status == constants.STATUS_PENDING, assert_msg logger.info(f"Deleting PVC {pvc_name}") pvc.delete()
def _check_aws_credentials(): try: s3_res = boto3.resource( 's3', verify=False, endpoint_url="https://s3.amazonaws.com", aws_access_key_id=aws_access_key_id, aws_secret_access_key=aws_access_key ) test_bucket = s3_res.create_bucket( Bucket=create_unique_resource_name('cred-verify', 's3-bucket') ) test_bucket.delete() return True except ClientError: logger.info('Credentials are still not active. Retrying...') return False
def _create_buckets(amount=1): """ Creates and deletes all buckets that were created as part of the test Args: amount (int): The amount of buckets to create Returns: list: A list of s3.Bucket objects, containing all the created buckets """ for i in range(amount): bucket_name = create_unique_resource_name( resource_description='bucket', resource_type='s3') logger.info(f'Creating bucket: {bucket_name}') created_bucket_names.append( mcg_obj.s3_create_bucket(bucketname=bucket_name)) return created_bucket_names
def test_reclaim_policy_delete(self): """ Test to validate storage class with reclaim policy "Delete" """ pvc_obj = helpers.create_pvc( sc_name=self.sc_obj_delete.name, pvc_name=helpers.create_unique_resource_name('delete', 'pvc')) pv_name = pvc_obj.get()['spec']['volumeName'] pv_namespace = pvc_obj.get()['metadata']['namespace'] pv_obj = ocp.OCP(kind='PersistentVolume', namespace=pv_namespace) assert pvc_obj.delete() pvc_obj.ocp.wait_for_delete(resource_name=pvc_obj.name) try: pv_obj.get(pv_name) except CommandFailed as ex: assert f'persistentvolumes "{pv_name}" not found' in str(ex),\ "pv exists" log.info("Underlying PV is deleted")
def test_reclaim_policy_delete(self): """ Test to validate storage class with reclaim policy "Delete" """ pvc_obj = helpers.create_pvc( sc_name=self.sc_obj_delete.name, pvc_name=helpers.create_unique_resource_name('delete', 'pvc') ) helpers.wait_for_resource_state(pvc_obj, constants.STATUS_BOUND) pvc_obj.reload() pv_name = pvc_obj.get()['spec']['volumeName'] pv_namespace = pvc_obj.get()['metadata']['namespace'] pv_obj = ocp.OCP(kind='PersistentVolume', namespace=pv_namespace) assert pvc_obj.delete() pvc_obj.ocp.wait_for_delete(resource_name=pvc_obj.name) assert pv_obj.wait_for_delete(pv_name, 60), ( f"PV {pv_name} is not deleted" )
def create_new_backingstore_aws_bucket(self, backingstore_info): """ Creates an S3 target bucket for NooBaa to use as a backing store Args: backingstore_info: A tuple containing the BS information to be used in its creation. """ if backingstore_info.get('name') is None: backingstore_info['name'] = create_unique_resource_name('backingstorebucket', 'awsbucket') if backingstore_info.get('region') is None: self.aws_s3_resource.create_bucket(Bucket=backingstore_info['name']) else: self.aws_s3_resource.create_bucket( Bucket=backingstore_info['name'], CreateBucketConfiguration={ 'LocationConstraint': backingstore_info['region'] } )