def network_resources():
with test_config_container.create_vcr(
cassette_library_dir=CASSETTE_LIBRARY_DIR).use_cassette(
'boot_volume_network_resources_fixture.yml'):
vcn_name = util.random_name('cli_test_boot_vol')
cidr_block = "10.0.0.0/16"
vcn_dns_label = util.random_name('vcn', insert_underscore=False)
result = invoke([
'network', 'vcn', 'create', '--compartment-id',
util.COMPARTMENT_ID, '--display-name', vcn_name, '--cidr-block',
cidr_block, '--dns-label', vcn_dns_label, '--wait-for-state',
'AVAILABLE', '--wait-interval-seconds', util.WAIT_INTERVAL_SECONDS
])
util.validate_response(result, json_response_expected=False)
vcn_ocid = util.get_json_from_mixed_string(result.output)['data']['id']
subnet_name = util.random_name('cli_test_boot_vol')
subnet_dns_label = util.random_name('subnet', insert_underscore=False)
result = invoke([
'network', 'subnet', 'create', '--compartment-id',
util.COMPARTMENT_ID, '--availability-domain',
util.availability_domain(), '--display-name', subnet_name,
'--vcn-id', vcn_ocid, '--cidr-block', cidr_block, '--dns-label',
subnet_dns_label, '--wait-for-state', 'AVAILABLE',
'--wait-interval-seconds', util.WAIT_INTERVAL_SECONDS
])
util.validate_response(result,
expect_etag=True,
json_response_expected=False)
subnet_ocid = util.get_json_from_mixed_string(
result.output)['data']['id']
yield (vcn_ocid, subnet_ocid)
result = invoke([
'network', 'subnet', 'delete', '--subnet-id', subnet_ocid,
'--force', '--wait-for-state', 'TERMINATED',
'--wait-interval-seconds', util.WAIT_INTERVAL_SECONDS
])
util.validate_response(result, json_response_expected=False)
result = util.invoke_command([
'network', 'vcn', 'delete', '--vcn-id', vcn_ocid, '--force',
'--wait-for-state', 'TERMINATED', '--wait-interval-seconds',
util.WAIT_INTERVAL_SECONDS
])
util.validate_response(result, json_response_expected=False)
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 subtest_volume_attachment_operations(self):
va_name = util.random_name('cli_test_va')
result = self.invoke([
'compute', 'volume-attachment', 'attach', '--display-name',
va_name, '--type', 'iscsi', '--instance-id', self.instance_ocid,
'--volume-id', self.volume_ocid
])
self.va_ocid = util.find_id_in_response(result.output)
util.validate_response(result, expect_etag=True)
util.wait_until([
'compute', 'volume-attachment', 'get', '--volume-attachment-id',
self.va_ocid
],
'ATTACHED',
max_wait_seconds=300)
result = self.invoke([
'compute', 'volume-attachment', 'list', '--compartment-id',
util.COMPARTMENT_ID, '--instance-id', self.instance_ocid
])
util.validate_response(result)
result = self.invoke([
'compute', 'volume-attachment', 'get', '--volume-attachment-id',
self.va_ocid
])
util.validate_response(result, expect_etag=True)
result = self.invoke([
'compute', 'volume-attachment', 'detach', '--volume-attachment-id',
self.va_ocid, '--force'
])
util.validate_response(result)
util.wait_until([
'compute', 'volume-attachment', 'get', '--volume-attachment-id',
self.va_ocid
],
'DETACHED',
max_wait_seconds=300)
result = self.invoke([
'compute', 'volume-attachment', 'attach', '--display-name',
va_name, '--type', 'iscsi', '--instance-id', self.instance_ocid,
'--volume-id', self.volume_ocid, '--wait-for-state', 'ATTACHED',
'--wait-interval-seconds', util.WAIT_INTERVAL_SECONDS
])
util.validate_response(result,
expect_etag=True,
json_response_expected=False)
self.va_ocid = util.get_json_from_mixed_string(
result.output)['data']['id']
result = self.invoke([
'compute', 'volume-attachment', 'detach', '--volume-attachment-id',
self.va_ocid, '--force', '--wait-for-state', 'DETACHED',
'--wait-interval-seconds', util.WAIT_INTERVAL_SECONDS
])
util.validate_response(result, json_response_expected=False)
def subtest_create_compartment(self):
result = self.invoke([
'compartment', 'create', '--name', 'PythonCLITest124',
'--description',
'Create Compartment for CLI testing using wait for state ACTIVE',
'--compartment-id', util.COMPARTMENT_ID, '--wait-for-state',
'ACTIVE'
])
self.validate_response(result, json_response_expected=False)
assert 'NotAuthorizedOrNotFound' not in result.output
created_compartment = util.get_json_from_mixed_string(result.output)
assert created_compartment['data'][
'compartment-id'] == util.COMPARTMENT_ID
assert created_compartment['data']['lifecycle-state'] == 'ACTIVE'
result = self.invoke([
'compartment', 'delete', '--compartment-id',
created_compartment['data']['id'], '--force'
])
assert result.exit_code == 0
def test_load_balancer_operations_with_waiters(runner, config_file,
config_profile, vcn_and_subnets,
key_pair_files):
with test_config_container.create_vcr(
cassette_library_dir=CASSETTE_LIBRARY_DIR).use_cassette(
'test_load_balancer_ops_with_waiters.yml'):
subnet_ocid_1 = vcn_and_subnets[1]
subnet_ocid_2 = vcn_and_subnets[2]
lb_name = util.random_name('cli_lb')
params = [
'load-balancer', 'create', '-c', util.COMPARTMENT_ID,
'--display-name', lb_name, '--shape-name', '100Mbps',
'--subnet-ids', '["{}","{}"]'.format(subnet_ocid_1, subnet_ocid_2),
'--wait-for-state', 'SUCCEEDED'
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result, json_response_expected=False)
load_balancer = util.get_json_from_mixed_string(result.output)
assert load_balancer['data']['lifecycle-state'] == 'ACTIVE'
assert 'loadbalancer' in load_balancer['data']['id']
assert load_balancer['data']['display-name'] == lb_name
assert load_balancer['data']['shape-name'] == '100Mbps'
assert len(load_balancer['data']['subnet-ids']) == 2
assert subnet_ocid_1 in load_balancer['data']['subnet-ids']
assert subnet_ocid_2 in load_balancer['data']['subnet-ids']
_do_backend_and_backend_set_waiters(runner,
load_balancer['data']['id'],
config_file, config_profile)
_do_certificate_waiters(runner, load_balancer['data']['id'],
config_file, config_profile, key_pair_files)
params = [
'load-balancer', 'delete', '--load-balancer-id',
load_balancer['data']['id'], '--force', '--wait-for-state',
'SUCCEEDED'
]
result = invoke(runner, config_file, config_profile, params)
_validate_work_request_result(result, load_balancer['data']['id'])
def test_boot_volume_clone_backup(network_resources):
with test_config_container.create_vcr(cassette_library_dir=CASSETTE_LIBRARY_DIR).use_cassette('boot_volume_test_boot_volume_clone_backup.yml'):
boot_volume_id = None
instance_ocid = None
backup_boot_volume_id = None
cloned_boot_volume_id = None
backup_id = None
try:
instance_name = util.random_name('boot_vol_instance')
image_id = util.oracle_linux_image()
shape = 'VM.Standard1.1'
hostname_label = util.random_name('bootvolinst', insert_underscore=False)
boot_volume_size_in_gbs = '51'
result = invoke([
'compute', 'instance', 'launch',
'--compartment-id', util.COMPARTMENT_ID,
'--availability-domain', util.availability_domain(),
'--display-name', instance_name,
'--subnet-id', network_resources[1],
'--image-id', image_id,
'--shape', shape,
'--hostname-label', hostname_label,
'--boot-volume-size-in-gbs', boot_volume_size_in_gbs,
'--wait-for-state', 'RUNNING',
'--wait-interval-seconds', util.WAIT_INTERVAL_SECONDS
])
util.validate_response(result, json_response_expected=False)
instance_data = util.get_json_from_mixed_string(result.output)['data']
instance_ocid = instance_data['id']
assert 'image' == instance_data['source-details']['source-type']
assert image_id == instance_data['source-details']['image-id']
result = invoke([
'compute', 'boot-volume-attachment', 'list',
'-c', util.COMPARTMENT_ID,
'--availability-domain', util.availability_domain(),
'--instance-id', instance_data['id']
])
util.validate_response(result)
parsed_result = json.loads(result.output)
assert len(parsed_result['data']) == 1
boot_volume_id = parsed_result['data'][0]['boot-volume-id']
result = invoke([
'bv', 'boot-volume', 'get',
'--boot-volume-id', boot_volume_id
])
util.validate_response(result)
parsed_result = json.loads(result.output)
boot_volume_size_in_gbs = parsed_result['data']['size-in-gbs']
assert boot_volume_size_in_gbs == int(boot_volume_size_in_gbs)
result = invoke([
'compute', 'instance', 'terminate',
'--instance-id', instance_ocid,
'--wait-for-state', 'TERMINATED',
'--preserve-boot-volume', 'true',
'--force'
])
util.validate_response(result, json_response_expected=False)
instance_ocid = None
# Since we preserved the volume it should still be available
result = invoke(['bv', 'boot-volume', 'get', '--boot-volume-id', boot_volume_id])
util.validate_response(result)
parsed_result = json.loads(result.output)
assert util.availability_domain() == parsed_result['data']['availability-domain']
assert 'AVAILABLE' == parsed_result['data']['lifecycle-state']
assert image_id == parsed_result['data']['image-id']
size_in_gbs = int(parsed_result['data']['size-in-gbs'])
new_size_in_gbs = size_in_gbs + 10
# Resize boot volume to new_size_in_gbs
result = invoke(['bv', 'boot-volume', 'update', '--boot-volume-id', boot_volume_id,
'--size-in-gbs', str(new_size_in_gbs),
'--wait-for-state', 'AVAILABLE',
'--wait-interval-seconds', util.WAIT_INTERVAL_SECONDS])
util.validate_response(result, json_response_expected=False)
# Since we preserved the volume it should still be available
result = invoke(['bv', 'boot-volume', 'get', '--boot-volume-id', boot_volume_id])
util.validate_response(result)
parsed_result = json.loads(result.output)
assert 'AVAILABLE' == parsed_result['data']['lifecycle-state']
assert new_size_in_gbs == int(parsed_result['data']['size-in-gbs'])
# Take a backup
result = invoke(['bv', 'boot-volume-backup', 'create', '--boot-volume-id', boot_volume_id,
'--wait-for-state', 'AVAILABLE',
'--wait-interval-seconds', util.WAIT_INTERVAL_SECONDS])
util.validate_response(result, json_response_expected=False)
parsed_result = util.get_json_from_mixed_string(result.output)
assert boot_volume_id == parsed_result['data']['boot-volume-id']
assert image_id == parsed_result['data']['image-id']
assert 'AVAILABLE' == parsed_result['data']['lifecycle-state']
backup_id = parsed_result['data']['id']
# Boot Volume Create Error cases
# Error 1: No option specified
result = invoke(['bv', 'boot-volume', 'create',
'--wait-for-state', 'AVAILABLE',
'--wait-interval-seconds', util.WAIT_INTERVAL_SECONDS])
assert "An empty boot volume cannot be created. Please specify either --boot-volume-backup-id, --source-boot-volume-id or --source-volume-replica-id" in result.output
# Error 2: Both options specified
result = invoke(['bv', 'boot-volume', 'create',
'--source-boot-volume-id', boot_volume_id[0],
'--boot-volume-backup-id', boot_volume_id[0],
'--wait-for-state', 'AVAILABLE',
'--wait-interval-seconds', util.WAIT_INTERVAL_SECONDS])
assert "You can only specify one of either --source-boot-volume-id, --boot-volume-backup-id or --source-volume-replica-id option" in result.output
# Clone the boot volume (Error 1: Invalid Boot Volume ID)
result = invoke(['bv', 'boot-volume', 'create',
'--source-boot-volume-id', boot_volume_id[0],
'--wait-for-state', 'AVAILABLE',
'--wait-interval-seconds', util.WAIT_INTERVAL_SECONDS])
util.validate_service_error(result, error_message="InvalidParameter")
backup_policy_ids = get_backup_policy_ids()
create_new_size_in_gbs = new_size_in_gbs + 10
# Clone the boot volume with bronze backup policy and larger size
result = invoke(['bv', 'boot-volume', 'create',
'--source-boot-volume-id', boot_volume_id,
'--backup-policy-id', backup_policy_ids["bronze"],
'--wait-for-state', 'AVAILABLE',
'--size-in-gbs', str(create_new_size_in_gbs),
'--wait-interval-seconds', util.WAIT_INTERVAL_SECONDS])
util.validate_response(result, json_response_expected=False)
parsed_result = util.get_json_from_mixed_string(result.output)
assert util.availability_domain() == parsed_result['data']['availability-domain']
assert 'AVAILABLE' == parsed_result['data']['lifecycle-state']
assert image_id == parsed_result['data']['image-id']
assert create_new_size_in_gbs == int(parsed_result['data']['size-in-gbs'])
cloned_boot_volume_id = parsed_result['data']['id']
# Verify the backup policy
result = invoke(['bv', 'volume-backup-policy-assignment',
'get-volume-backup-policy-asset-assignment',
'--asset-id', cloned_boot_volume_id])
util.validate_response(result)
parsed_result = json.loads(result.output)
backup_policy_assignment_id = parsed_result["data"][0]["id"]
assert parsed_result["data"][0]["policy-id"] == backup_policy_ids["bronze"]
# Remove backup policy
result = invoke(['bv', 'volume-backup-policy-assignment',
'delete', '--policy-assignment-id', backup_policy_assignment_id, '--force'])
util.validate_response(result)
# Change backup policy to silver
result = invoke(['bv', 'volume-backup-policy-assignment', 'create',
'--asset-id', cloned_boot_volume_id,
'--policy-id', backup_policy_ids['silver']])
util.validate_response(result)
parsed_result = json.loads(result.output)
backup_policy_assignment_id = parsed_result["data"]["id"]
assert parsed_result["data"]["policy-id"] == backup_policy_ids["silver"]
# Remove the backup policy
result = invoke(['bv', 'volume-backup-policy-assignment',
'delete', '--policy-assignment-id', backup_policy_assignment_id, '--force'])
util.validate_response(result)
# We can now launch an instance using that boot volume
result = invoke([
'compute', 'instance', 'launch',
'--compartment-id', util.COMPARTMENT_ID,
'--availability-domain', util.availability_domain(),
'--display-name', instance_name,
'--subnet-id', network_resources[1],
'--shape', shape,
'--hostname-label', hostname_label,
'--source-boot-volume-id', cloned_boot_volume_id,
'--wait-for-state', 'RUNNING',
'--wait-interval-seconds', util.WAIT_INTERVAL_SECONDS
])
util.validate_response(result, json_response_expected=False)
instance_data = util.get_json_from_mixed_string(result.output)['data']
instance_ocid = instance_data['id']
assert 'bootVolume' == instance_data['source-details']['source-type']
assert cloned_boot_volume_id == instance_data['source-details']['boot-volume-id']
clean_up_instances(instance_ocid)
cloned_boot_volume_id = None
instance_ocid = None
# Delete existing boot volume
clean_up_boot_volume(boot_volume_id)
boot_volume_id = None
# Create boot volume from backup (Error 1: Invalid Backup Volume ID)
result = invoke(['bv', 'boot-volume', 'create',
'--boot-volume-backup-id', backup_id[0],
'--availability-domain', util.availability_domain(),
'--wait-for-state', 'AVAILABLE',
'--wait-interval-seconds', util.WAIT_INTERVAL_SECONDS])
util.validate_service_error(result, error_message="InvalidParameter")
# Create boot volume from backup (Error 2: Availability domain not specified)
result = invoke(['bv', 'boot-volume', 'create',
'--boot-volume-backup-id', backup_id,
'--wait-for-state', 'AVAILABLE',
'--wait-interval-seconds', util.WAIT_INTERVAL_SECONDS])
assert "An availability domain must be specified when restoring a boot volume from backup" in result.output
# Create boot volume from backup
result = invoke(['bv', 'boot-volume', 'create',
'--boot-volume-backup-id', backup_id,
'--availability-domain', util.availability_domain(),
'--wait-for-state', 'AVAILABLE',
'--wait-interval-seconds', util.WAIT_INTERVAL_SECONDS])
util.validate_response(result, json_response_expected=False)
parsed_result = util.get_json_from_mixed_string(result.output)
assert util.availability_domain() == parsed_result['data']['availability-domain']
assert 'AVAILABLE' == parsed_result['data']['lifecycle-state']
assert image_id == parsed_result['data']['image-id']
backup_boot_volume_id = parsed_result['data']['id']
# We can now launch an instance using that boot volume
result = invoke([
'compute', 'instance', 'launch',
'--compartment-id', util.COMPARTMENT_ID,
'--availability-domain', util.availability_domain(),
'--display-name', instance_name,
'--subnet-id', network_resources[1],
'--shape', shape,
'--hostname-label', hostname_label,
'--source-boot-volume-id', backup_boot_volume_id,
'--wait-for-state', 'RUNNING',
'--wait-interval-seconds', util.WAIT_INTERVAL_SECONDS
])
util.validate_response(result, json_response_expected=False)
instance_data = util.get_json_from_mixed_string(result.output)['data']
instance_ocid = instance_data['id']
assert 'bootVolume' == instance_data['source-details']['source-type']
assert backup_boot_volume_id == instance_data['source-details']['boot-volume-id']
clean_up_instances(instance_ocid)
backup_boot_volume_id = None
instance_ocid = None
finally:
clean_up_instances(instance_ocid)
clean_up_boot_volume(boot_volume_id)
clean_up_boot_volume(cloned_boot_volume_id)
clean_up_boot_volume(backup_boot_volume_id)
clean_up_boot_volume_backup(backup_id)
def invoke_command(command, response_expected=True, **kwargs):
response = util.invoke_command(command, **kwargs)
assert (response.exit_code == 0)
data = util.get_json_from_mixed_string(
response.output)['data'] if response_expected else None
return data
def test_load_balancer_tagging(runner, config_file, config_profile,
vcn_and_subnets, key_pair_files):
with test_config_container.create_vcr(
cassette_library_dir=CASSETTE_LIBRARY_DIR).use_cassette(
'test_load_balancer_tagging.yml'):
subnet_ocid_1 = vcn_and_subnets[1]
subnet_ocid_2 = vcn_and_subnets[2]
# Setup the tag inputs
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_lb.json'),
tag_data_container.tag_namespace, tag_names_to_values)
# Create the LB with tags
lb_name = util.random_name('cli_lb')
params = [
'load-balancer', 'create', '-c', util.COMPARTMENT_ID,
'--display-name', lb_name, '--shape-name', '100Mbps',
'--subnet-ids', '["{}","{}"]'.format(subnet_ocid_1, subnet_ocid_2),
'--freeform-tags',
'file://tests/resources/tagging/freeform_tags_2.json',
'--defined-tags', 'file://tests/temp/defined_tags_lb.json',
'--wait-for-state', 'SUCCEEDED', '--wait-interval-seconds',
util.WAIT_INTERVAL_SECONDS
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result, json_response_expected=False)
load_balancer = util.get_json_from_mixed_string(result.output)
id = load_balancer['data']['id']
try:
# Make sure the tags are in the results
assert "tagOne" in load_balancer['data']['freeform-tags']
assert "value three" == load_balancer['data']['freeform-tags'][
"tagOne"]
assert "cli_tag_ns_320683" in load_balancer['data']['defined-tags']
assert "cli_tag_320683" in load_balancer['data']['defined-tags'][
'cli_tag_ns_320683']
assert "cli_tag_320683" in load_balancer['data']['defined-tags'][
'cli_tag_ns_320683']
assert "somevalue cli_tag_320683" == load_balancer['data'][
'defined-tags']['cli_tag_ns_320683']['cli_tag_320683']
# Get the LB and make sure the tags are in the results
params = ['load-balancer', 'get', '--load-balancer-id', id]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result, json_response_expected=False)
load_balancer = util.get_json_from_mixed_string(result.output)
id = load_balancer['data']['id']
assert "tagOne" in load_balancer['data']['freeform-tags']
assert "value three" == load_balancer['data']['freeform-tags'][
"tagOne"]
assert "cli_tag_ns_320683" in load_balancer['data']['defined-tags']
assert "cli_tag_320683" in load_balancer['data']['defined-tags'][
'cli_tag_ns_320683']
assert "cli_tag_320683" in load_balancer['data']['defined-tags'][
'cli_tag_ns_320683']
assert "somevalue cli_tag_320683" == load_balancer['data'][
'defined-tags']['cli_tag_ns_320683']['cli_tag_320683']
# List the LB and check that the tags are in the result
params = ['load-balancer', 'list', '-c', util.COMPARTMENT_ID]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result, json_response_expected=False)
list_result = util.get_json_from_mixed_string(result.output)
if len(list_result['data']) == 1:
load_balancer = list_result['data'][0]
assert "tagOne" in load_balancer['freeform-tags']
assert "value three" == load_balancer['freeform-tags'][
"tagOne"]
assert "cli_tag_ns_320683" in load_balancer['defined-tags']
assert "cli_tag_320683" in load_balancer['defined-tags'][
'cli_tag_ns_320683']
assert "cli_tag_320683" in load_balancer['defined-tags'][
'cli_tag_ns_320683']
assert "somevalue cli_tag_320683" == load_balancer[
'defined-tags']['cli_tag_ns_320683']['cli_tag_320683']
# Update the display name for the lb.
params = [
'load-balancer', 'update', '--load-balancer-id', id,
'--display-name', 'new' + lb_name, '--wait-for-state',
'SUCCEEDED'
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result, json_response_expected=False)
params = ['load-balancer', 'get', '--load-balancer-id', id]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result, json_response_expected=False)
load_balancer = util.get_json_from_mixed_string(result.output)
assert "new" + lb_name == load_balancer['data']['display-name']
# Setup the tag inputs
tag_names_to_values = {}
for t in tag_data_container.tags:
tag_names_to_values[t.name] = 'newvalue {}'.format(t.name)
tag_data_container.write_defined_tags_to_file(
os.path.join('tests', 'temp', 'defined_tags_lb.json'),
tag_data_container.tag_namespace, tag_names_to_values)
# Update the tags for the lb.
params = [
'load-balancer', 'update', '--load-balancer-id', id,
'--freeform-tags',
'file://tests/resources/tagging/freeform_tags_1.json',
'--defined-tags', 'file://tests/temp/defined_tags_lb.json',
'--wait-for-state', 'SUCCEEDED', '--force'
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result, json_response_expected=False)
params = ['load-balancer', 'get', '--load-balancer-id', id]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result, json_response_expected=False)
load_balancer = util.get_json_from_mixed_string(result.output)
assert "tagOne" in load_balancer['data']['freeform-tags']
assert "tag_Two" in load_balancer['data']['freeform-tags']
assert "value1" == load_balancer['data']['freeform-tags']["tagOne"]
assert "value two" == load_balancer['data']['freeform-tags'][
"tag_Two"]
assert "cli_tag_ns_320683" in load_balancer['data']['defined-tags']
assert "cli_tag_320683" in load_balancer['data']['defined-tags'][
'cli_tag_ns_320683']
assert "newvalue cli_tag_320683" == load_balancer['data'][
'defined-tags']['cli_tag_ns_320683']['cli_tag_320683']
finally:
# Delete the LB
params = [
'load-balancer', 'delete', '--load-balancer-id', id, '--force',
'--wait-for-state', 'SUCCEEDED', '--wait-interval-seconds',
util.WAIT_INTERVAL_SECONDS
]
result = invoke(runner, config_file, config_profile, params)
_validate_work_request_result(result, id)
def cross_connect(runner, config_file, config_profile, cross_connect_group):
# Set-up of cross-connect resource
cc_id = None
with test_config_container.create_vcr(
cassette_library_dir=CASSETTE_LIBRARY_DIR).use_cassette(
'test_fastconnect_fixture_crossconnect.yml'):
# Find cross-connect locations
params = [
'network', 'cross-connect-location', 'list', '--compartment-id',
util.COMPARTMENT_ID
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
fc_location_name = json.loads(result.output)['data'][0]['name']
# Get cross-connect port speeds
params = [
'network', 'cross-connect-port-speed-shape', 'list',
'--compartment-id', util.COMPARTMENT_ID
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
fc_port_speed = json.loads(result.output)['data'][0]['name']
# Create cross-connect
cc_name = util.random_name('cli_test_network_cc')
params = [
'network', 'cross-connect', 'create', '--display-name', cc_name,
'--location-name', fc_location_name, '--port-speed-shape-name',
fc_port_speed, '--cross-connect-group-id', cross_connect_group,
'--compartment-id', util.COMPARTMENT_ID
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
cc_id = json.loads(result.output)['data']['id']
# Get cross-connect status by cross-connect OCID
params = [
'network', 'cross-connect-status', 'get', '--cross-connect-id',
cc_id
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
# Get cross-connect by cross-connect OCID
params = [
'network', 'cross-connect', 'get', '--cross-connect-id', cc_id
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
# List cross-connects in a given compartment
params = [
'network', 'cross-connect', '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.
# Make sure the cross-connect is activated; Virtual circuit can ONLY be created in a cross-connect group
# which has cross-connect in it.
cc_name = util.random_name('cli_test_network_crossconnect')
params = [
'network', 'cross-connect', 'update', '--cross-connect-id', cc_id,
'--display-name', cc_name, '--is-active', 'true',
'--wait-for-state', 'PROVISIONED'
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result, json_response_expected=False)
assert util.get_json_from_mixed_string(
result.output)['data']['lifecycle-state'] == 'PROVISIONED'
yield cc_id
# Teardown of cross-connect resource.
with test_config_container.create_vcr(
cassette_library_dir=CASSETTE_LIBRARY_DIR).use_cassette(
'test_fastconnect_fixture_crossconnect_delete.yml'):
if cc_id:
# Delete cross-connect
params = [
'network', 'cross-connect', 'delete', '--cross-connect-id',
cc_id, '--wait-for-state', 'TERMINATED', '--force'
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result, json_response_expected=False)
def test_virtual_circuit_crud_operations(runner, config_file, config_profile,
cross_connect_group, cross_connect):
# Set up of virtual circuit
vc_id = None
with test_config_container.create_vcr(
cassette_library_dir=CASSETTE_LIBRARY_DIR).use_cassette(
'test_fastconnect_fixture_virtualcircuit.yml'):
# Create Dynamic Routing Gateway
drg_name = util.random_name('cli_test_network_drg')
params = [
'network', 'drg', 'create', '--display-name', drg_name,
'--compartment-id', util.COMPARTMENT_ID, '--wait-for-state',
'AVAILABLE'
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result, json_response_expected=False)
assert util.get_json_from_mixed_string(
result.output)['data']['lifecycle-state'] == 'AVAILABLE'
drg_id = util.get_json_from_mixed_string(result.output)['data']['id']
# Get fast connect service provider OCID
params = [
'network', 'fast-connect-provider-service', 'list',
'--compartment-id', util.COMPARTMENT_ID
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
fcps_id = json.loads(result.output)['data'][0]['id']
# Get virtual circuit bandwidth shapes for a particular fast connect service provider
params = [
'network', 'fast-connect-provider-service',
'virtual-circuit-bandwidth-shape', 'list', '--provider-service-id',
fcps_id
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
vc_bandwidth = json.loads(result.output)['data'][0]['name']
# Create virtual circuit
vc_name = util.random_name('cli_test_network_vc')
bgpMd5AuthKey = 'null'
customerBgpPeeringIp = '10.0.0.17/31'
oracleBgpPeeringIp = '10.0.0.16/31'
vlan = 131
cc_mappings = '[{{"bgpMd5AuthKey":{},"crossConnectOrCrossConnectGroupId":"{}",' \
'"customerBgpPeeringIp":"{}","oracleBgpPeeringIp":"{}","vlan":{}}}]'\
.format(bgpMd5AuthKey, cross_connect_group, customerBgpPeeringIp, oracleBgpPeeringIp, vlan)
params = [
'network', 'virtual-circuit', 'create', '--display-name', vc_name,
'--type', 'PRIVATE', '--bandwidth-shape-name', vc_bandwidth,
'--cross-connect-mappings', cc_mappings, '--customer-bgp-asn',
'12345', '--gateway-id', drg_id, '--wait-for-state', 'PROVISIONED',
'--compartment-id', util.COMPARTMENT_ID
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result, json_response_expected=False)
assert util.get_json_from_mixed_string(
result.output)['data']['lifecycle-state'] == 'PROVISIONED'
vc_id = util.get_json_from_mixed_string(result.output)['data']['id']
# Get virtual-circuit by virtual-circuit OCID
params = [
'network', 'virtual-circuit', 'get', '--virtual-circuit-id', vc_id
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
# List virtual-circuits in a given compartment
params = [
'network', 'virtual-circuit', '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 virtual-circuit
vc_name = util.random_name('cli_test_network_virtualcircuit')
params = [
'network', 'virtual-circuit', 'update', '--virtual-circuit-id',
vc_id, '--display-name', vc_name
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result)
# Teardown of virtual-circuit
with test_config_container.create_vcr(
cassette_library_dir=CASSETTE_LIBRARY_DIR).use_cassette(
'test_fastconnect_fixture_virtualcircuit_delete.yml'):
if vc_id:
# Delete virtual-circuit
params = [
'network', 'virtual-circuit', 'delete', '--virtual-circuit-id',
vc_id, '--wait-for-state', 'TERMINATED', '--force'
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result, json_response_expected=False)
# Delete the dynamic gateway
params = [
'network', 'drg', 'delete', '--drg-id', drg_id,
'--wait-for-state', 'TERMINATED', '--force'
]
result = invoke(runner, config_file, config_profile, params)
util.validate_response(result, json_response_expected=False)
