def create_resource(self, name, **kwargs):
group = self._get_resource_group(**kwargs)
template = 'az sql server create -l {} -g {} -n {} -u {} -p {}'
execute(
template.format(self.location, group, name, self.admin_user,
self.admin_password))
return {self.parameter_name: name}
def create_resource(self, _, **kwargs):
# Omit name here since there is no randomization required
endpoint = os.environ.get(self.env_variable_name, self.endpoint)
logger.debug("endpoint %s", endpoint)
template = "az sf cluster select --endpoint {}"
execute(template.format(endpoint))
return {self.parameter_name: endpoint}
def _enable_intelligence_pack(resource_group, workspace_name):
intelligence_pack_name = 'SQLVulnerabilityAssessment'
template = 'az monitor log-analytics workspace pack enable -n {} -g {} --workspace-name {}'
execute(
DummyCli(),
template.format(intelligence_pack_name, resource_group,
workspace_name))
def create_resource(self, name, **kwargs):
if not os.environ.get('AZURE_CLI_TEST_DEV_BACKUP_POLICY_NAME', None):
self.resource_group = self._get_resource_group(**kwargs)
self.vault = self._get_vault(**kwargs)
policy_json = execute(
self.cli_ctx, 'az backup policy show -g {} -v {} -n {}'.format(
self.resource_group, self.vault,
'DefaultPolicy')).get_output_in_json()
policy_json['name'] = name
if self.instant_rp_days:
policy_json['properties'][
'instantRpRetentionRangeInDays'] = self.instant_rp_days
policy_json['properties']['backupManagementType'] = "AzureStorage"
policy_json = json.dumps(policy_json)
command_string = 'az backup policy create -g {} -v {} --policy \'{}\' -n {} --backup-management-type {}'
command_string = command_string.format(self.resource_group,
self.vault, policy_json,
name, "AzureStorage")
execute(self.cli_ctx, command_string)
return {self.parameter_name: name}
return {
self.parameter_name:
os.environ.get('AZURE_CLI_TEST_DEV_BACKUP_POLICY_NAME', None)
}
def create_resource(self, name, **kwargs):
if not self.dev_setting_value:
self.resource_group = self._get_resource_group(**kwargs)
self.location = self._get_resource_group_location(**kwargs)
cmd = 'az vm create -n {} -g {} --image Win2012R2Datacenter --admin-password %j^VYw9Q3Z@Cu$*h'
execute(cmd.format(name, self.resource_group))
return {self.parameter_name: name}
return {self.parameter_name: self.dev_setting_value}
def create_resource(self, name, **kwargs):
if not self.dev_setting_value:
self.resource_group = self._get_resource_group(**kwargs)
self.location = self._get_resource_group_location(**kwargs)
cmd = 'az vm create -n {} -g {} --image Win2012R2Datacenter --admin-password %j^VYw9Q3Z@Cu$*h'
execute(self.cli_ctx, cmd.format(name, self.resource_group))
return {self.parameter_name: name}
return {self.parameter_name: self.dev_setting_value}
def create_resource(self, name, **kwargs):
if not self.dev_setting_value:
self.resource_group = self._get_resource_group(**kwargs)
cmd = 'az batch account create -n {} -g {} -l {}'.format(name, self.resource_group,
self.location)
execute(cmd)
return {self.parameter_name: name}
return {self.parameter_name: self.dev_setting_value}
def create_resource(self, name, **kwargs):
if not self.dev_setting_value:
self.resource_group = self._get_resource_group(**kwargs)
cmd = 'az batch account create -n {} -g {} -l {}'.format(
name, self.resource_group, self.location)
execute(cmd)
return {self.parameter_name: name}
return {self.parameter_name: self.dev_setting_value}
def create_resource(self, name, **kwargs):
group = self._get_resource_group(**kwargs)
template = 'az {} flexible-server create -l {} -g {} -n {}'
execute(self.cli_ctx, template.format(self.engine_type,
self.location,
group, name))
return {self.parameter_name: name,
self.engine_parameter_name: self.engine_type}
def create_resource(self, name, **kwargs):
if not self.dev_setting_value:
self.resource_group = self._get_resource_group(**kwargs)
self.location = self._get_resource_group_location(**kwargs)
cmd = 'az backup vault create -n {} -g {} --location {}'.format(name, self.resource_group, self.location)
execute(self.cli_ctx, cmd)
return {self.parameter_name: name}
return {self.parameter_name: self.dev_setting_value}
def create_resource(self, name, **kwargs):
if not self.dev_setting_value:
self.resource_group = self._get_resource_group(**kwargs)
self.location = self._get_resource_group_location(**kwargs)
cmd = 'az backup vault create -n {} -g {} --location {}'.format(name, self.resource_group, self.location)
execute(self.cli_ctx, cmd)
return {self.parameter_name: name}
return {self.parameter_name: self.dev_setting_value}
def create_resource(self, name, **kwargs):
group = self._get_resource_group(**kwargs)
dns_name = self.id_generator()
parameters = ('adminUsername=admin123 adminPassword=SecretPassword123 location=westus '
'domainName=domain.com dnsPrefix={}').format(dns_name)
template = 'az group deployment create --name {} -g {} --template-uri {} --parameters {}'
execute(DummyCli(), template.format('domaintemplate', group,
'https://raw.githubusercontent.com/Azure/azure-quickstart-templates/master/active-directory-new-domain/azuredeploy.json',
parameters))
return {self.parameter_name: name}
def _assert_error(cmd, error_reason):
error_indicated = False
try:
execute(DummyCli(), cmd)
except:
error_indicated = True
finally:
if (not error_indicated):
raise CliTestError('No error raised when expected. ' +
error_reason)
def _set_vm_registry(resource_group, sqlvm):
template = 'az vm run-command invoke --command-id {} --name {} -g {} --scripts \'New-Item -ItemType Directory -Force -Path C:\\Users\\admin123\\Desktop\\Va_Logs\' \
\'New-Item -ItemType Directory -Force -Path C:\\Users\\admin123\\Desktop\\Setup_Logs\' \
\'New-Item -Path HKLM:\\Software\\Microsoft\\AzureOperationalInsights\' \
\'Set-ItemProperty -Path HKLM:\\Software\\Microsoft\\AzureOperationalInsights -Name SqlVulnerabilityAssessment_LogDirectoryPath -Value C:\\Users\\admin123\\Desktop\\Va_Logs\' \
\'Set-ItemProperty -Path HKLM:\\Software\\Microsoft\\AzureOperationalInsights -Name SqlVulnerabilityAssessment_BypassHashCheck -Value true\' \
\'Set-ItemProperty -Path HKLM:\\Software\\Microsoft\\AzureOperationalInsights -Name SqlVulnerabilityAssessment_TestMachine -Value true\''
execute(DummyCli(),
template.format('RunPowerShellScript', sqlvm, resource_group))
def create_resource(self, name, **kwargs):
group = self._get_resource_group(**kwargs)
template = (
'az vm create -l {} -g {} -n {} --admin-username {} --admin-password {} --image MicrosoftSQLServer:SQL2017-WS2016:Enterprise:latest'
' --size Standard_DS2_v2')
execute(
DummyCli(),
template.format(self.location, group, name, self.vm_user,
self.vm_password))
return {self.parameter_name: name}
def create_resource(self, name, **kwargs):
group = self._get_resource_group(**kwargs)
template = 'az {} server create -l {} -g {} -n {} -u {} -p {}'
execute(template.format(self.engine_type,
self.location,
group, name,
self.admin_user,
self.admin_password))
return {self.parameter_name: name,
self.engine_parameter_name: self.engine_type}
def create_resource(self, name, **kwargs):
group = self._get_resource_group(**kwargs)
template = (
'az vm create -l {} -g {} -n {} --admin-username {} --admin-password {} --image {} --size {}'
)
execute(
DummyCli(),
template.format(self.location, group, name, self.vm_user,
self.vm_password, sql_server_image,
sql_server_vm_size))
return {self.parameter_name: name}
def create_resource(self, name, **kwargs):
if not self.dev_setting_value:
self.resource_group = self._get_resource_group(**kwargs)
vault = self._get_vault(**kwargs)
vm = self._get_vm(**kwargs)
params_format = '-g {} -v {} --vm {} -p DefaultPolicy'
param_string = params_format.format(self.resource_group, vault, vm)
execute(self.cli_ctx, 'az backup protection enable-for-vm {}'.format(param_string))
return {self.parameter_name: name}
return {self.parameter_name: self.dev_setting_value}
def create_resource(self, name, **kwargs):
if not self.dev_setting_value:
self.resource_group = self._get_resource_group(**kwargs)
vault = self._get_vault(**kwargs)
vm = self._get_vm(**kwargs)
params_format = '-g {} -v {} --vm {} -p DefaultPolicy'
param_string = params_format.format(self.resource_group, vault, vm)
execute(self.cli_ctx, 'az backup protection enable-for-vm {}'.format(param_string))
return {self.parameter_name: name}
return {self.parameter_name: self.dev_setting_value}
def create_resource(self, name, **kwargs):
group = self._get_resource_group(**kwargs)
template = 'az {} server create -l {} -g {} -n {} -u {} -p {} --sku-name {}'
execute(self.cli_ctx, template.format(self.engine_type,
self.location,
group, name,
self.admin_user,
self.admin_password,
self.sku_name))
return {self.parameter_name: name,
self.engine_parameter_name: self.engine_type}
def create_resource(self, name, **kwargs):
if not self.dev_setting_value:
self.resource_group = self._get_resource_group(**kwargs)
self.location = self._get_resource_group_location(**kwargs)
cmd = 'az backup vault create -n {} -g {} --location {}'.format(name, self.resource_group, self.location)
execute(self.cli_ctx, cmd)
if not self.soft_delete:
cmd = 'az backup vault backup-properties set -n {} -g {} --soft-delete-feature-state Disable'.format(name, self.resource_group)
execute(self.cli_ctx, cmd)
return {self.parameter_name: name}
return {self.parameter_name: self.dev_setting_value}
def create_resource(self, name, **kwargs):
if not self.dev_setting_value:
self.resource_group = self._get_resource_group(**kwargs)
self.location = self._get_resource_group_location(**kwargs)
param_format = '-n {} -g {} --image {} --admin-username {} --admin-password {}'
param_string = param_format.format(name, self.resource_group, 'Win2012R2Datacenter', name,
'%j^VYw9Q3Z@Cu$*h')
cmd = 'az vm create {}'.format(param_string)
execute(self.cli_ctx, cmd.format(name, self.resource_group, name))
return {self.parameter_name: name}
return {self.parameter_name: self.dev_setting_value}
def create_resource(self, name, **kwargs):
if not self.dev_setting_value:
self.resource_group = self._get_resource_group(**kwargs)
self.location = self._get_resource_group_location(**kwargs)
param_format = '-n {} -g {} --image {} --admin-username {} --admin-password {}'
param_string = param_format.format(name, self.resource_group, 'Win2012R2Datacenter', name,
'%j^VYw9Q3Z@Cu$*h')
cmd = 'az vm create {}'.format(param_string)
execute(self.cli_ctx, cmd.format(name, self.resource_group, name))
return {self.parameter_name: name}
return {self.parameter_name: self.dev_setting_value}
def create_resource(self, name, **kwargs):
if not self.dev_setting_value:
self.resource_group = self._get_resource_group(**kwargs)
self.location = self._get_resource_group_location(**kwargs)
param_format = '-n {} -g {} --image {} --admin-username {} --admin-password {} --tags {} --nsg-rule None'
param_tags = 'MabUsed=Yes Owner=sisi Purpose=CLITest DeleteBy=12-2099 AutoShutdown=No'
param_string = param_format.format(name, self.resource_group, 'Win2012R2Datacenter', name,
'%j^VYw9Q3Z@Cu$*h', param_tags)
cmd = 'az vm create {}'.format(param_string)
execute(self.cli_ctx, cmd)
return {self.parameter_name: name}
return {self.parameter_name: self.dev_setting_value}
def create_resource(self, name, **kwargs):
if not self.dev_setting_value:
self.resource_group = self._get_resource_group(**kwargs)
vault = self._get_vault(**kwargs)
vm = self._get_vm(**kwargs)
retain_date = datetime.utcnow() + timedelta(days=30)
command_string = 'az backup protection backup-now -g {} -v {} -c {} -i {} --retain-until {} --query name'
command_string = command_string.format(self.resource_group, vault, vm, vm,
retain_date.strftime('%d-%m-%Y'))
backup_job = execute(self.cli_ctx, command_string).get_output_in_json()
execute(self.cli_ctx, 'az backup job wait -g {} -v {} -n {}'.format(self.resource_group, vault, backup_job))
return {self.parameter_name: name}
return {self.parameter_name: self.dev_setting_value}
def create_resource(self, name, **kwargs):
if not os.environ.get('AZURE_CLI_TEST_DEV_BACKUP_ITEM_NAME', None):
resource_group = self._get_resource_group(**kwargs)
storage_account = self._get_storage_account(**kwargs)
vault = self._get_vault(**kwargs)
afs = self._get_file_share(**kwargs)
policy = self._get_policy(**kwargs)
command_string = 'az backup protection enable-for-azurefileshare'
command_string += ' -g {} -v {} --azure-file-share {} --storage-account {} -p {}'
command_string = command_string.format(resource_group, vault, afs, storage_account, policy)
execute(self.cli_ctx, command_string)
return {self.parameter_name: name}
return {self.parameter_name: os.environ.get('AZURE_CLI_TEST_DEV_BACKUP_ITEM_NAME', None)}
def create_resource(self, name, **kwargs):
if not self.dev_setting_value:
self.resource_group = self._get_resource_group(**kwargs)
vault = self._get_vault(**kwargs)
vm = self._get_vm(**kwargs)
retain_date = datetime.utcnow() + timedelta(days=30)
command_string = 'az backup protection backup-now --backup-management-type AzureIaasVM --workload-type VM -g {} -v {} -c {} -i {} --retain-until {} --query name'
command_string = command_string.format(self.resource_group, vault, vm, vm,
retain_date.strftime('%d-%m-%Y'))
backup_job = execute(self.cli_ctx, command_string).get_output_in_json()
execute(self.cli_ctx, 'az backup job wait -g {} -v {} -n {}'.format(self.resource_group, vault, backup_job))
return {self.parameter_name: name}
return {self.parameter_name: self.dev_setting_value}
def create_resource(self, name, **kwargs):
if not self.dev_setting_value:
self.resource_group = self._get_resource_group(**kwargs)
self.vault = self._get_vault(**kwargs)
policy_json = execute(self.cli_ctx, 'az backup policy show -g {} -v {} -n {}'
.format(self.resource_group, self.vault, 'DefaultPolicy')).get_output_in_json()
policy_json['name'] = name
policy_json = json.dumps(policy_json)
execute(self.cli_ctx, 'az backup policy set -g {} -v {} --policy \'{}\''.format(self.resource_group,
self.vault,
policy_json))
return {self.parameter_name: name}
return {self.parameter_name: self.dev_setting_value}
def create_resource(self, name, **kwargs):
if not self.dev_setting_value:
self.resource_group = self._get_resource_group(**kwargs)
self.vault = self._get_vault(**kwargs)
policy_json = execute(self.cli_ctx, 'az backup policy show -g {} -v {} -n {}'
.format(self.resource_group, self.vault, 'DefaultPolicy')).get_output_in_json()
policy_json['name'] = name
policy_json = json.dumps(policy_json)
execute(self.cli_ctx, 'az backup policy set -g {} -v {} --policy \'{}\''.format(self.resource_group,
self.vault,
policy_json))
return {self.parameter_name: name}
return {self.parameter_name: self.dev_setting_value}
def create_resource(self, name, **kwargs):
if not os.environ.get('AZURE_CLI_TEST_DEV_BACKUP_RP_NAME', None):
self.resource_group = self._get_resource_group(**kwargs)
storage_account = self._get_storage_account(**kwargs)
vault = self._get_vault(**kwargs)
afs = self._get_file_share(**kwargs)
retain_date = datetime.utcnow() + timedelta(days=30)
retain_date = retain_date.strftime('%d-%m-%Y')
command_string = 'az backup protection backup-now'
command_string += ' -g {} -v {} -i {} -c {} --backup-management-type AzureStorage --retain-until {} --query name'
command_string = command_string.format(self.resource_group, vault, afs, storage_account, retain_date)
backup_job = execute(self.cli_ctx, command_string).get_output_in_json()
execute(self.cli_ctx, 'az backup job wait -g {} -v {} -n {}'.format(self.resource_group, vault, backup_job))
return {self.parameter_name: name}
return {self.parameter_name: os.environ.get('AZURE_CLI_TEST_DEV_BACKUP_RP_NAME', None)}
def create_resource(self, name, **kwargs):
if not os.environ.get('AZURE_CLI_TEST_DEV_BACKUP_POLICY_NAME', None):
self.resource_group = self._get_resource_group(**kwargs)
self.vault = self._get_vault(**kwargs)
policy_json = execute(self.cli_ctx, 'az backup policy show -g {} -v {} -n {}'
.format(self.resource_group, self.vault, 'DefaultPolicy')).get_output_in_json()
policy_json['name'] = name
if self.instant_rp_days:
policy_json['properties']['instantRpRetentionRangeInDays'] = self.instant_rp_days
policy_json = json.dumps(policy_json)
execute(self.cli_ctx, 'az backup policy set -g {} -v {} --policy \'{}\''.format(self.resource_group,
self.vault,
policy_json))
return {self.parameter_name: name}
return {self.parameter_name: os.environ.get('AZURE_CLI_TEST_DEV_BACKUP_POLICY_NAME', None)}
def _cleanup(self, vault_name, resource_group):
containers = execute(
self.cli_ctx,
'az backup container list --backup-management-type AzureIaasVM -v {} -g {} --query [].properties.friendlyName'
.format(vault_name, resource_group)).get_output_in_json()
for container in containers:
items = execute(
self.cli_ctx,
'az backup item list --backup-management-type AzureIaasVM --workload-type VM -g {} -v {} -c {} --query [].properties.friendlyName'
.format(resource_group, vault_name,
container)).get_output_in_json()
for item in items:
execute(
self.cli_ctx,
'az backup protection disable --backup-management-type AzureIaasVM --workload-type VM -g {} -v {} -c {} -i {} --delete-backup-data true --yes'
.format(resource_group, vault_name, container, item))
from azure.core.exceptions import HttpResponseError
try:
execute(
self.cli_ctx,
'az backup vault delete -n {} -g {} --yes'.format(
vault_name, resource_group))
except HttpResponseError as ex:
if "Operation returned an invalid status 'Bad Request'" not in str(
ex):
raise ex
def create_resource(self, name, **kwargs):
if not os.environ.get('AZURE_CLI_TEST_DEV_BACKUP_POLICY_NAME', None):
self.resource_group = self._get_resource_group(**kwargs)
storage_account = self._get_storage_account(**kwargs)
storage_keys_command = 'az storage account keys list --resource-group {} --account-name {} --query [0].value'
storage_keys_command = storage_keys_command.format(
self.resource_group, storage_account)
if self.file_upload:
storage_key = execute(
self.cli_ctx, storage_keys_command).get_output_in_json()
connection_string_command = 'az storage account show-connection-string -n {} -g {}'
connection_string_command = connection_string_command.format(
storage_account, self.resource_group)
connection_string = execute(
self.cli_ctx, connection_string_command).get_output_in_json()
connection_string = connection_string['connectionString']
command_string = 'az storage share create --name {} --quota 1 --connection-string {}'
command_string = command_string.format(name, connection_string)
execute(self.cli_ctx, command_string)
file_upload_command_format = 'az storage file upload --account-name {} --account-key {} --share-name {} --source {}'
if self.file_upload:
file_param_names = self.file_parameter_name
for file_param_name in file_param_names:
self.file_parameter_name = file_param_name
file = self._get_file(**kwargs)
file_upload_command = file_upload_command_format.format(
storage_account, storage_key, name, file)
execute(self.cli_ctx, file_upload_command)
return {self.parameter_name: name}
return {
self.parameter_name:
os.environ.get('AZURE_CLI_TEST_DEV_BACKUP_POLICY_NAME', None)
}
def _run_cmd(self, command, checks=None, expect_failure=False):
cli_ctx = get_dummy_cli()
cli_ctx.logging.command_log_dir = self.temp_command_log_dir
result = execute(cli_ctx, command, expect_failure=expect_failure).assert_with_checks(checks)
# manually handle error logging as azure.cli.core.util's handle_exception function is mocked out in testsdk / patches
# this logged error tests that we can properly parse errors from command log file.
with CommandLoggerContext(logger):
if result.exit_code != 0:
logger.error("There was an error during execution.")
cli_ctx.logging.end_cmd_metadata_logging(result.exit_code)
return result
def _cleanup(self, vault_name, resource_group):
containers = execute(self.cli_ctx, 'az backup container list -v {} -g {} --query [].properties.friendlyName'
.format(vault_name, resource_group)).get_output_in_json()
for container in containers:
items = execute(self.cli_ctx, 'az backup item list -g {} -v {} -c {} --query [].properties.friendlyName'
.format(resource_group, vault_name, container)).get_output_in_json()
for item in items:
execute(self.cli_ctx,
'az backup protection disable -g {} -v {} -c {} -i {} --delete-backup-data true --yes'
.format(resource_group, vault_name, container, item))
execute(self.cli_ctx, 'az backup vault delete -n {} -g {} --yes'.format(vault_name, resource_group))
def _cleanup(self, vault_name, resource_group):
containers = execute(self.cli_ctx, 'az backup container list -v {} -g {} --query [].properties.friendlyName'
.format(vault_name, resource_group)).get_output_in_json()
for container in containers:
items = execute(self.cli_ctx, 'az backup item list -g {} -v {} -c {} --query [].properties.friendlyName'
.format(resource_group, vault_name, container)).get_output_in_json()
for item in items:
execute(self.cli_ctx,
'az backup protection disable -g {} -v {} -c {} -i {} --delete-backup-data true --yes'
.format(resource_group, vault_name, container, item))
execute(self.cli_ctx, 'az backup vault delete -n {} -g {} --yes'.format(vault_name, resource_group))
def _run_cmd(self, command, checks=None, expect_failure=False):
cli_ctx = get_dummy_cli()
cli_ctx.logging.command_log_dir = self.temp_command_log_dir
# azure.cli.core.util.handle_exception is mocked by azure.cli.testsdk.patches.patch_main_exception_handler
# Patch it again so that errors are properly written to command log file.
from azure.cli.core.util import handle_exception
original_handle_exception = handle_exception
def _handle_exception_with_log(ex, *args, **kwargs):
with CommandLoggerContext(logger):
logger.error(ex)
original_handle_exception(*args, **kwargs)
with mock.patch('azure.cli.core.util.handle_exception',
_handle_exception_with_log):
result = execute(
cli_ctx, command,
expect_failure=expect_failure).assert_with_checks(checks)
return result
def _cleanup(self, vault_name, resource_group):
containers = execute(self.cli_ctx, 'az backup container list --backup-management-type AzureIaasVM -v {} -g {} --query [].properties.friendlyName'
.format(vault_name, resource_group)).get_output_in_json()
for container in containers:
items = execute(self.cli_ctx, 'az backup item list --backup-management-type AzureIaasVM --workload-type VM -g {} -v {} -c {} --query [].properties.friendlyName'
.format(resource_group, vault_name, container)).get_output_in_json()
for item in items:
execute(self.cli_ctx,
'az backup protection disable --backup-management-type AzureIaasVM --workload-type VM -g {} -v {} -c {} -i {} --delete-backup-data true --yes'
.format(resource_group, vault_name, container, item))
from msrestazure.azure_exceptions import CloudError
try:
execute(self.cli_ctx, 'az backup vault delete -n {} -g {} --yes'.format(vault_name, resource_group))
except CloudError as ex:
if 'Recovery Services vault cannot be deleted as there are backup items in soft deleted state in the vault' not in str(ex):
raise ex
def _run_cmd(self, command, checks=None, expect_failure=False):
cli_ctx = get_dummy_cli()
cli_ctx.logging.command_log_dir = self.temp_command_log_dir
# hotfix here for untouch feedback's code to avoid introducing possible break change.
# unregister the event for auto closing CLI's file logging after execute() is done
cli_ctx.unregister_event(EVENT_CLI_POST_EXECUTE,
cli_ctx.logging.deinit_cmd_metadata_logging)
# manually handle error logging as azure.cli.core.util's handle_exception function is mocked out in testsdk / patches
# this logged error tests that we can properly parse errors from command log file.
with CommandLoggerContext(logger):
result = execute(
cli_ctx, command,
expect_failure=expect_failure).assert_with_checks(checks)
if result.exit_code != 0:
logger.error("There was an error during execution.")
# close it manually because we unregister the deinit_cmd_metadata_logging
# callback from EVENT_CLI_POST_EXECUTE event
cli_ctx.logging.end_cmd_metadata_logging(result.exit_code)
return result
def _test_vnet_firewall_mgmt(self, resource_group, server, database_engine):
vnet_firewall_rule_1 = 'vnet_rule1'
vnet_firewall_rule_2 = 'vnet_rule2'
location = 'brazilsouth'
vnet_name = 'clitestvnet'
ignore_missing_endpoint = 'true'
address_prefix = '10.0.0.0/16'
subnet_name_1 = 'clitestsubnet1'
subnet_prefix_1 = '10.0.0.0/24'
subnet_name_2 = 'clitestsubnet2'
subnet_prefix_2 = '10.0.1.0/24'
# pre create the dependent resources here
# create vnet and subnet
execute(self.cli_ctx, 'az network vnet create -n {} -g {} -l {} '
'--address-prefix {} --subnet-name {} --subnet-prefix {}'.format(vnet_name, resource_group, location, address_prefix, subnet_name_1,
subnet_prefix_1))
# add one more subnet
execute(self.cli_ctx, 'az network vnet subnet create --vnet-name {} -g {} '
'--address-prefix {} -n {}'.format(vnet_name, resource_group, subnet_prefix_2, subnet_name_2))
# test vnet-rule create
self.cmd('{} server vnet-rule create -n {} -g {} -s {} '
'--vnet-name {} --subnet {} --ignore-missing-endpoint {}'
.format(database_engine, vnet_firewall_rule_1, resource_group, server,
vnet_name, subnet_name_1, ignore_missing_endpoint),
checks=[
JMESPathCheck('name', vnet_firewall_rule_1),
JMESPathCheck('resourceGroup', resource_group),
JMESPathCheck('state', 'Ready')])
# test vnet-rule show
self.cmd('{} server vnet-rule show -n {} -g {} -s {}'
.format(database_engine, vnet_firewall_rule_1, resource_group, server),
checks=[
JMESPathCheck('name', vnet_firewall_rule_1),
JMESPathCheck('resourceGroup', resource_group),
JMESPathCheck('state', 'Ready')])
# test create one more vnet rule .
self.cmd('{} server vnet-rule create -n {} -g {} -s {} '
'--vnet-name {} --subnet {} --ignore-missing-endpoint {}'
.format(database_engine, vnet_firewall_rule_2, resource_group, server,
vnet_name, subnet_name_2, ignore_missing_endpoint),
checks=[
JMESPathCheck('name', vnet_firewall_rule_2),
JMESPathCheck('resourceGroup', resource_group),
JMESPathCheck('state', 'Ready')])
# test vnet-rule list
self.cmd('{} server vnet-rule list -g {} -s {}'
.format(database_engine, resource_group, server),
checks=[JMESPathCheck('length(@)', 2)])
self.cmd('{} server vnet-rule delete --name {} -g {} --server {} --yes'
.format(database_engine, vnet_firewall_rule_1, resource_group, server), checks=NoneCheck())
self.cmd('{} server vnet-rule list -g {} --server {}'
.format(database_engine, resource_group, server), checks=[JMESPathCheck('length(@)', 1)])
self.cmd('{} server vnet-rule delete -n {} -g {} -s {} --yes'
.format(database_engine, vnet_firewall_rule_2, resource_group, server), checks=NoneCheck())
self.cmd('{} server vnet-rule list -g {} --server {}'
.format(database_engine, resource_group, server), checks=[NoneCheck()])
def remove_resource(self, name, **kwargs):
if not self.skip_delete:
group = self._get_resource_group(**kwargs)
execute(self.cli_ctx, 'az {} server delete -g {} -n {} --yes'.format(self.engine_type, group, name))
def remove_resource(self, name, **kwargs):
if not self.skip_delete:
group = self._get_resource_group(**kwargs)
execute(DummyCli(), 'az group delete -g {}'.format(group))
def create_resource(self, name, **kwargs):
group = self._get_resource_group(**kwargs)
template = ('az vm create -l {} -g {} -n {} --admin-username {} --admin-password {} --image MicrosoftSQLServer:SQL2017-WS2016:Enterprise:latest'
' --size Standard_DS2_v2')
execute(DummyCli(), template.format(self.location, group, name, self.vm_user, self.vm_password))
return {self.parameter_name: name}
def remove_resource(self, name, **kwargs):
if not self.skip_delete:
group = self._get_resource_group(**kwargs)
execute(DummyCli(), 'az vm delete -g {} -n {} --yes --no-wait'.format(group, name))
def remove_resource(self, name, **kwargs):
if not self.dev_setting_value and not self.skip_delete:
cmd = 'az batch account delete -n {} -g {} -y'.format(name, self.resource_group)
execute(cmd)
