def subtest_instance_action_operations(self):
result = self.invoke(['compute', 'instance', 'action', '--instance-id', self.instance_ocid, '--action', 'RESET'])
util.validate_response(result)
util.vcr_mode_aware_sleep(10)
util.wait_until(['compute', 'instance', 'get', '--instance-id', self.instance_ocid], 'RUNNING',
max_wait_seconds=300)
util.vcr_mode_aware_sleep(5)
def subtest_instance_console_connections_tagging(self):
tag_names_to_values = {}
for t in tag_data_container.tags:
tag_names_to_values[t.name] = 'somevalue {}'.format(t.name)
tag_data_container.write_defined_tags_to_file(
os.path.join('tests', 'temp', 'defined_tags_compute.json'),
tag_data_container.tag_namespace,
tag_names_to_values
)
result = self.invoke([
'compute', 'instance-console-connection', 'create',
'--instance-id', self.instance_ocid,
'--ssh-public-key-file', util.SSH_AUTHORIZED_KEYS_FILE,
'--freeform-tags', 'file://tests/resources/tagging/freeform_tags_1.json',
'--defined-tags', 'file://tests/temp/defined_tags_compute.json'
])
util.validate_response(result)
instance_console_connection_details = json.loads(result.output)
expected_freeform = {'tagOne': 'value1', 'tag_Two': 'value two'}
expected_defined = {tag_data_container.tag_namespace.name: tag_names_to_values}
self.assertEquals(expected_freeform, instance_console_connection_details['data']['freeform-tags'])
self.assertEquals(expected_defined, instance_console_connection_details['data']['defined-tags'])
self.invoke(['compute', 'instance-console-connection', 'delete', '--instance-console-connection-id', instance_console_connection_details['data']['id'], '--force'])
result = self.invoke(['compute', 'instance-console-connection', 'get', '--instance-console-connection-id', instance_console_connection_details['data']['id']])
parsed_result = json.loads(result.output)
if 'DELET' not in parsed_result['data']['lifecycle-state']:
print("parsed_result=" + str(parsed_result) + ", lifecycle-state=" + str(parsed_result['data']['lifecycle-state']))
util.vcr_mode_aware_sleep(60)
result = self.invoke(['compute', 'instance-console-connection', 'get', '--instance-console-connection-id', instance_console_connection_details['data']['id']])
parsed_result = json.loads(result.output)
self.assertTrue(parsed_result['data']['lifecycle-state'] == 'DELETED' or parsed_result['data']['lifecycle-state'] == 'DELETING')
def zone(dns_client, runner, config_file, config_profile):
# Since zone names are global, if the name is used in another tenancy or even another instance
# of this test, it would make this test fail. So by varying the zone name, we have less
# chances of name collision.
zone_name = 'clitest-dnszone-' + str(random.randint(0, 1000000)) + '.test'
params = [
'zone', 'create', '--name', zone_name, '--compartment-id',
util.COMPARTMENT_ID, '--zone-type', 'PRIMARY'
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
oci.wait_until(
dns_client,
dns_client.get_zone(zone_name),
evaluate_response=lambda r: r.data.lifecycle_state == 'ACTIVE',
max_wait_seconds=360)
# The zone name from a cassette response will not match the zone name randomly generated.
zone_name = json.loads(result.output)['data']['name']
zone_id = dns_client.get_zone(zone_name).data.id
print("created zone_id=" + str(zone_id) + ", zone_name=" + str(zone_name))
yield zone_id, zone_name
with test_config_container.create_vcr(
cassette_library_dir=CASSETTE_LIBRARY_DIR).use_cassette(
'dns_test_cleanup.yml'):
params = ['zone', 'delete', '--zone-name-or-id', zone_id, '--force']
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
print("deleted zone_id=" + str(zone_id) + ", zone_name=" +
str(zone_name))
def subtest_delete(self):
error_count = 0
if len(self.instance_ocids) > 0:
for ocid in self.instance_ocids:
try:
print("checking TERMINATED for " + ocid)
util.wait_until(['compute', 'instance', 'get', '--instance-id', ocid], 'TERMINATED', max_wait_seconds=1200, succeed_if_not_found=True)
except Exception as error:
util.print_latest_exception(error)
error_count = error_count + 1
if hasattr(self, 'subnet_ocid'):
try:
print("Deleting subnet")
result = util.invoke_command(['network', 'subnet', 'delete', '--subnet-id', self.subnet_ocid, '--force'])
util.validate_response(result)
util.wait_until(['network', 'subnet', 'get', '--subnet-id', self.subnet_ocid], 'TERMINATED',
max_wait_seconds=600, succeed_if_not_found=True)
except Exception as error:
util.print_latest_exception(error)
error_count = error_count + 1
if hasattr(self, 'vcn_ocid'):
try:
print("Deleting vcn")
result = util.invoke_command(['network', 'vcn', 'delete', '--vcn-id', self.vcn_ocid, '--force'])
util.validate_response(result)
util.wait_until(['network', 'vcn', 'get', '--vcn-id', self.vcn_ocid], 'TERMINATED',
max_wait_seconds=600, succeed_if_not_found=True)
except Exception as error:
util.print_latest_exception(error)
error_count = error_count + 1
self.assertEquals(0, error_count)
def test_create_kubeconfig_6(runner, config_file, config_profile, oce_cluster,
request):
with test_config_container.create_vcr(
cassette_library_dir=CASSETTE_LIBRARY_DIR).use_cassette(
'test_oce_create_kubeconfig_test6.yml'):
config_file_path = os.path.expandvars(
os.path.expanduser(USER_KUBECONFIG_LOCATION + "_" +
request.function.__name__))
# There should be no file at user provided location for this test.
if os.path.isfile(config_file_path):
os.remove(config_file_path)
cluster_id, _, _, _ = oce_cluster
params = [
'ce', 'cluster', 'create-kubeconfig', '--cluster-id', cluster_id,
'--file', config_file_path, '--overwrite'
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result, json_response_expected=False)
# Check that a file got created at default kubeconfig location
assert (os.path.isfile(config_file_path))
# Check if it is a valid yaml. yaml load will raise an exception in case of invalid yaml
with open(config_file_path, 'r') as f:
kubeconfig = yaml.safe_load(f)
# Check there is only ONE cluster, user and context in the downloaded kubeconfig for this test.
assert (len(kubeconfig['clusters']) == 1)
assert (len(kubeconfig['contexts']) == 1)
assert (len(kubeconfig['users']) == 1)
def file_system(filestorage_client, runner, config_file, config_profile):
with test_config_container.create_vcr(
cassette_library_dir=CASSETTE_LIBRARY_DIR).use_cassette(
'filestorage_file_system_fixture.yml'):
params = [
'file-system', 'create', '--compartment-id', util.COMPARTMENT_ID,
'--availability-domain',
util.availability_domain()
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
file_system_id = json.loads(result.output)['data']['id']
util.wait_until(
['fs', 'file-system', 'get', '--file-system-id', file_system_id],
'ACTIVE',
max_wait_seconds=300)
yield file_system_id
with test_config_container.create_vcr(
cassette_library_dir=CASSETTE_LIBRARY_DIR).use_cassette(
'filestorage_file_system_fixture_cleanup.yml'):
params = [
'file-system', 'delete', '--file-system-id', file_system_id,
'--force'
]
invoke(runner, config_file, config_profile, params)
util.wait_until(
['fs', 'file-system', 'get', '--file-system-id', file_system_id],
'DELETED',
max_wait_seconds=300)
def exa_db_system_cleanup(runner, config_file, config_profile, db_system_id_1):
if SKIP_CLEAN_UP_RESOURCES:
print("Skipping clean up of DB systems and dependent resources.")
return
success_terminating_db_systems = True
try:
# terminate db system 1
params = [
'system', 'terminate', '--db-system-id', db_system_id_1, '--force'
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
# validate that it goes into terminating state
params = ['system', 'get', '--db-system-id', db_system_id_1]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
state = json.loads(result.output)['data']['lifecycle-state']
assert "TERMINAT" in state
util.wait_until(
['db', 'system', 'get', '--db-system-id', db_system_id_1],
'TERMINATED',
max_wait_seconds=DB_SYSTEM_PROVISIONING_TIME_SEC,
succeed_if_not_found=True)
except Exception as error:
util.print_latest_exception(error)
success_terminating_db_systems = False
assert success_terminating_db_systems
def subtest_launch_instance_merges_user_data_file_param_with_metadata(
self):
instance_name = util.random_name('cli_test_instance_options')
image_id = util.oracle_linux_image()
shape = 'VM.Standard1.2'
hostname_label = util.random_name('bminstance',
insert_underscore=False)
launch_instance_result = util.invoke_command([
'compute', 'instance', 'launch', '--compartment-id',
util.COMPARTMENT_ID, '--availability-domain',
util.availability_domain(), '--display-name', instance_name,
'--subnet-id', self.subnet_ocid, '--image-id', image_id, '--shape',
shape, '--hostname-label', hostname_label + "4",
'--user-data-file', USER_DATA_FILE, '--metadata',
util.remove_outer_quotes(oci_cli_compute.compute_cli_extended.
compute_instance_launch_metadata_example)
])
util.validate_response(launch_instance_result, expect_etag=True)
temp_instance_ocid = util.find_id_in_response(
launch_instance_result.output)
self.instance_ocids.append(temp_instance_ocid)
response = json.loads(launch_instance_result.output)
instance_metadata = response['data']['metadata']
assert instance_metadata['user_data']
assert instance_metadata['ssh_authorized_keys']
self.delete_instance(temp_instance_ocid)
def subtest_setup(self):
# Create a VCN
vcn_name = util.random_name('cli_test_compute_vcn')
cidr_block = "10.0.0.0/16"
vcn_dns_label = util.random_name('vcn', insert_underscore=False)
result = util.invoke_command([
'network', 'vcn', 'create', '--compartment-id',
util.COMPARTMENT_ID, '--display-name', vcn_name, '--cidr-block',
cidr_block, '--dns-label', vcn_dns_label
])
self.vcn_ocid = util.find_id_in_response(result.output)
util.validate_response(result, expect_etag=True)
util.wait_until(['network', 'vcn', 'get', '--vcn-id', self.vcn_ocid],
'AVAILABLE',
max_wait_seconds=300)
# Create a subnet
subnet_name = util.random_name('cli_test_compute_subnet')
subnet_dns_label = util.random_name('subnet', insert_underscore=False)
result = util.invoke_command([
'network', 'subnet', 'create', '--compartment-id',
util.COMPARTMENT_ID, '--availability-domain',
util.availability_domain(), '--display-name', subnet_name,
'--vcn-id', self.vcn_ocid, '--cidr-block', cidr_block,
'--dns-label', subnet_dns_label
])
self.subnet_ocid = util.find_id_in_response(result.output)
util.validate_response(result, expect_etag=True)
util.wait_until(
['network', 'subnet', 'get', '--subnet-id', self.subnet_ocid],
'AVAILABLE',
max_wait_seconds=300)
def subtest_volume_group_backup_operations(self):
# create a volume group backup, perform get & list, update it & restore from it
backup_name = util.random_name('cli_test_volume_group_backup')
result = self.invoke([
'volume-group-backup', 'create', '--volume-group-id',
self.volume_group, '--display-name', backup_name
])
util.validate_response(result)
self.volume_group_backup_id = util.find_id_in_response(result.output)
util.wait_until([
'bv', 'volume-group-backup', 'get', '--volume-group-backup-id',
self.volume_group_backup_id
],
'AVAILABLE',
max_wait_seconds=600)
result = self.invoke([
'volume-group-backup', 'get', '--volume-group-backup-id',
self.volume_group_backup_id
])
util.validate_response(result)
parsed_result = json.loads(result.output)
assert parsed_result['data']['size-in-mbs'] is not None
assert parsed_result['data']['unique-size-in-mbs'] is not None
result = self.invoke([
'volume-group-backup', 'list', '--compartment-id',
util.COMPARTMENT_ID
])
util.validate_response(result)
result = self.invoke([
'volume-group-backup', 'list', '--compartment-id',
util.COMPARTMENT_ID, '--volume-group-id', self.volume_group
])
util.validate_response(result)
self.assertEquals(1, len(json.loads(result.output)['data']))
backup_name = backup_name + "_UPDATED"
result = self.invoke([
'volume-group-backup', 'update', '--volume-group-backup-id',
self.volume_group_backup_id, '--display-name', backup_name
])
util.validate_response(result)
volume_group_name = util.random_name('cli_test_volume_group_restore')
source_details = {
'type': 'volumeGroupBackupId',
'volumeGroupBackupId': self.volume_group_backup_id
}
params = [
'volume-group', 'create', '--availability-domain',
util.availability_domain(), '--compartment-id',
util.COMPARTMENT_ID, '--display-name', volume_group_name,
'--source-details',
json.dumps(source_details)
]
self.volume_group_restored, self.restored_volumes = self.volume_group_operations_internal(
volume_group_name, params)
def subtest_config_get(self):
util.set_admin_pass_phrase()
result = util.invoke_command_as_admin(['audit', 'config', 'get', '--compartment-id', util.TENANT_ID])
util.unset_admin_pass_phrase()
util.validate_response(result)
response = json.loads(result.output)
assert response["data"]["retention-period-days"] is not None
def test_create_kubeconfig_4(runner, config_file, config_profile, oce_cluster,
request):
with test_config_container.create_vcr(
cassette_library_dir=CASSETTE_LIBRARY_DIR).use_cassette(
'test_oce_create_kubeconfig_test4.yml'):
# There should be an EMPTY kubeconfig file at user provided location for this test.
config_file_path = os.path.expandvars(
os.path.expanduser(USER_KUBECONFIG_LOCATION + "_" +
request.function.__name__))
# Remove any previous file from user provided location USER_KUBECONFIG_LOCATION
if os.path.isfile(config_file_path):
os.remove(config_file_path)
# Create the directory path for the file based on user provided file location USER_KUBECONFIG_LOCATION
if os.path.dirname(config_file_path) and not os.path.exists(
os.path.dirname(config_file_path)):
os.makedirs(os.path.dirname(config_file_path))
# Create an empty file at the user provided location
open(config_file_path, 'w').close()
cluster_id, _, _, _ = oce_cluster
params = [
'ce', 'cluster', 'create-kubeconfig', '--cluster-id', cluster_id,
'--file', config_file_path
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result, json_response_expected=False)
# Check if it is a valid yaml. yaml load will raise an exception in case of invalid yaml
with open(config_file_path, 'r') as f:
kubeconfig = yaml.safe_load(f)
# Check there is only ONE cluster, user and context in the downloaded kubeconfig for this test.
assert (len(kubeconfig['clusters']) == 1)
assert (len(kubeconfig['contexts']) == 1)
assert (len(kubeconfig['users']) == 1)
def subtest_clone_operations(self):
volume_name = util.random_name('cli_test_clone_vol')
params = [
'volume', 'create', '--source-volume-id', self.volume_id,
'--display-name', volume_name, '--size-in-gbs', '60'
]
result = self.invoke(params)
util.validate_response(result)
parsed_result = json.loads(result.output)
source_details = {'id': self.volume_id, 'type': 'volume'}
assert source_details == parsed_result['data']['source-details']
assert util.availability_domain(
) == parsed_result['data']['availability-domain']
assert 60 == int(
parsed_result['data']['size-in-gbs']
) # We initially created a 50GB volume, now increasing to 60
volume_id = util.find_id_in_response(result.output)
util.wait_until(['bv', 'volume', 'get', '--volume-id', volume_id],
'AVAILABLE',
max_wait_seconds=180)
util.wait_until(['bv', 'volume', 'get', '--volume-id', volume_id],
True,
max_wait_seconds=360,
state_property_name="is-hydrated")
result = self.invoke(
['volume', 'delete', '--volume-id', volume_id, '--force'])
util.validate_response(result)
def _validate_work_request_result(result, load_balancer_id):
util.validate_response(result, json_response_expected=False)
assert 'Action completed. Waiting until the work request has entered state:' in result.output
work_request = util.get_json_from_mixed_string(result.output)
assert work_request['data']['load-balancer-id'] == load_balancer_id
assert work_request['data']['lifecycle-state'] == 'SUCCEEDED'
def test_erratum(managed_instance_id_fixture, runner, config_file, config_profile):
managed_instance_id = managed_instance_id_fixture
# get list available updates
params = [
'os-management', 'managed-instance', 'list-available-updates',
'--managed-instance-id', managed_instance_id,
'--limit', '5'
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
availableUpdates = json.loads(result.output)['data']
erratumId = None
for availableUpdate in availableUpdates:
errata = availableUpdate['errata']
if len(errata) > 0:
for erratum in errata:
erratumId = erratum['id']
if erratumId is not None:
params = [
'os-management', 'erratum', 'get',
'--erratum-id', erratumId
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
def test_010_compute_pic_listing_list(self):
# A policy is required so we don't have to run as ADMIN:
# Allow group PythonCLITestGroup to manage app-catalog-listing in tenancy
result = self.invoke(['compute', 'pic', 'listing', 'list'])
util.validate_response(result)
json_result = json.loads(result.output)
TestComputePic.listing_id = json_result['data'][0]['listing-id']
def test_managed_instance_software_source(managed_instance_id_fixture, runner,
config_file, config_profile):
managed_instance_id = managed_instance_id_fixture
# get the managed instance
params = [
'os-management', 'managed-instance', 'get', '--managed-instance-id',
managed_instance_id
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
managed_instance = json.loads(result.output)['data']
child_software_sources = managed_instance['child-software-sources']
parent_software_source_id = managed_instance['parent-software-source'][
'id']
# test detach of child software source
child_software_source_id = child_software_sources[0]['id']
params = [
'os-management', 'managed-instance', 'detach-child',
'--managed-instance-id', managed_instance_id, '--software-source-id',
child_software_source_id
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
# test detach of parent software source
params = [
'os-management', 'managed-instance', 'detach-parent',
'--managed-instance-id', managed_instance_id, '--software-source-id',
parent_software_source_id
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
# test attach of parent software source
params = [
'os-management', 'managed-instance', 'attach-parent',
'--managed-instance-id', managed_instance_id, '--software-source-id',
parent_software_source_id
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
# test attach of child software sources
for child_software_source in child_software_sources:
child_software_source_id = child_software_source['id']
params = [
'os-management', 'managed-instance', 'attach-child',
'--managed-instance-id', managed_instance_id,
'--software-source-id', child_software_source_id
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
def get_and_list_operations(identity_client, tag_namespace_id, tag_name):
result = invoke([
'iam', 'tag-namespace', 'get', '--tag-namespace-id', tag_namespace_id
])
util.validate_response(result)
parsed_result = json.loads(result.output)
assert 'updated description' == parsed_result['data']['description']
assert parsed_result['data']['is-retired']
result = oci_cli.cli_util.list_call_get_all_results(
identity_client.list_tag_namespaces,
compartment_id=util.COMPARTMENT_ID)
filtered_results = list(
filter(lambda d: d.id == tag_namespace_id, result.data))
assert len(filtered_results) == 1
assert 'updated description' == filtered_results[0].description
assert filtered_results[0].is_retired
result = invoke(
['iam', 'tag-namespace', 'list', '-c', util.COMPARTMENT_ID, '--all'])
parsed_result = json.loads(result.output)
found_namespace = False
for pr in parsed_result['data']:
if pr['id'] == tag_namespace_id:
assert 'updated description' == pr['description']
assert pr['is-retired']
found_namespace = True
break
assert found_namespace
result = invoke([
'iam', 'tag', 'get', '--tag-namespace-id', tag_namespace_id,
'--tag-name', tag_name
])
util.validate_response(result)
parsed_result = json.loads(result.output)
assert 'updated tag desc' == parsed_result['data']['description']
assert parsed_result['data']['is-retired']
result = oci_cli.cli_util.list_call_get_all_results(
identity_client.list_tags, tag_namespace_id=tag_namespace_id)
filtered_results = list(filter(lambda d: d.name == tag_name, result.data))
assert len(filtered_results) == 1
assert 'updated tag desc' == filtered_results[0].description
assert filtered_results[0].is_retired
result = invoke([
'iam', 'tag', 'list', '--tag-namespace-id', tag_namespace_id, '--all'
])
parsed_result = json.loads(result.output)
found_tag = False
for pr in parsed_result['data']:
assert pr[
'is-retired'] # since the namespace is retired, all tags under it should be retired
if pr['name'] == tag_name:
assert 'updated tag desc' == pr['description']
found_tag = True
break
assert found_tag
def clean_up_boot_volume_backup(backup_boot_volume_id):
if backup_boot_volume_id:
result = invoke([
'bv', 'boot-volume-backup', 'delete', '--boot-volume-backup-id',
backup_boot_volume_id, '--force', '--wait-for-state', 'TERMINATED',
'--wait-interval-seconds', util.WAIT_INTERVAL_SECONDS
])
util.validate_response(result, json_response_expected=False)
def clean_up_instances(instance_ocid):
if instance_ocid:
result = invoke([
'compute', 'instance', 'terminate', '--instance-id', instance_ocid,
'--wait-for-state', 'TERMINATED', '--wait-interval-seconds',
util.WAIT_INTERVAL_SECONDS, '--force'
])
util.validate_response(result, json_response_expected=False)
def get_backup_policy_ids():
result = invoke('bv volume-backup-policy list --profile ADMIN'.split())
util.validate_response(result)
parsed_result = json.loads(result.output)
backup_policy_ids = {}
for policy in parsed_result["data"]:
backup_policy_ids[policy["display-name"]] = policy["id"]
return backup_policy_ids
def test_list_lb_policy(runner, config_file, config_profile):
with test_config_container.create_vcr(
cassette_library_dir=CASSETTE_LIBRARY_DIR).use_cassette(
'test_load_balancer_lb_policy.yml'):
params = ['policy', 'list', '-c', util.COMPARTMENT_ID]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
def test_list_dns_zones(runner, config_file, config_profile):
params = [
'zone', 'list',
'--compartment-id', util.COMPARTMENT_ID
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
def test_gitlab_trigger_get(project_and_pipeline, gitlab_trigger, runner,
config_file, config_profile):
trigger_id = gitlab_trigger
params = ['devops', 'trigger', 'get', '--trigger-id', trigger_id]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
assert trigger_id == json.loads(result.output)['data']['id'], \
"Get API should return correct trigger id"
def test_gitlab_connection_get(project_and_pipeline, gitlab_connection, runner,
config_file, config_profile):
connection_id = gitlab_connection
params = ['devops', 'connection', 'get', '--connection-id', connection_id]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
assert connection_id == json.loads(result.output)['data']['id'], \
"Get API should return correct connection id"
def subtest_config_get(self):
result = self.invoke([
'audit', 'config', 'get', '--compartment-id', util.COMPARTMENT_ID
])
util.validate_response(result)
response = json.loads(result.output)
assert response["data"]["retention-period-days"] is not None
def test_gitlab_trigger_list(project_and_pipeline, gitlab_trigger, runner,
config_file, config_profile):
params = [
'devops', 'trigger', 'list', '--compartment-id', util.COMPARTMENT_ID
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
triggers = json.loads(result.output)['data']['items']
assert len(triggers) > 0, "List API should return at least one trigger"
def test_build_run_list(project_and_pipeline, build_run, runner, config_file,
config_profile):
params = [
'devops', 'build-run', 'list', '--compartment-id', util.COMPARTMENT_ID
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
build_runs = json.loads(result.output)['data']['items']
assert len(build_runs) > 0, "List API should return at least one build run"
def cross_connect_group(runner, config_file, config_profile):
# Set-up of cross-connect group
ccg_id = None
with test_config_container.create_vcr(
cassette_library_dir=CASSETTE_LIBRARY_DIR).use_cassette(
'test_fastconnect_fixture_crossconnectgroup.yml'):
# Create cross connect group
ccg_name = util.random_name('cli_test_network_ccg')
params = [
'network', 'cross-connect-group', 'create', '--display-name',
ccg_name, '--compartment-id', util.COMPARTMENT_ID
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
ccg_id = json.loads(result.output)['data']['id']
# Get cross connect group
params = [
'network', 'cross-connect-group', 'get',
'--cross-connect-group-id', ccg_id
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
# List cross connect group
params = [
'network', 'cross-connect-group', 'list', '--compartment-id',
util.COMPARTMENT_ID
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
assert len(json.loads(result.output)['data']) > 0
# Update cross connect group
ccg_name = util.random_name('cli_test_network_crossconnect_grp')
params = [
'network', 'cross-connect-group', 'update',
'--cross-connect-group-id', ccg_id, '--display-name', ccg_name
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
yield ccg_id
# Teardown of cross-connect group
with test_config_container.create_vcr(
cassette_library_dir=CASSETTE_LIBRARY_DIR).use_cassette(
'test_fastconnect_fixture_crossconnectgroup_delete.yml'):
if ccg_id:
# Delete cross connect group
params = [
'network', 'cross-connect-group', 'delete',
'--cross-connect-group-id', ccg_id, '--wait-for-state',
'TERMINATED', '--force'
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result, json_response_expected=False)
def test_list_file_systems(file_system, runner, config_file, config_profile):
params = [
'file-system', 'list', '--compartment-id', util.COMPARTMENT_ID,
'--availability-domain',
util.availability_domain()
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)