def test_keyvault_secret(self, resource_group):
self.resource_group = resource_group
self.keyvault_name = self.create_random_name('cli-test-kevault-', 24)
self.location = 'westus'
_create_keyvault(self, self.keyvault_name, self.resource_group, self.location)
kv = self.keyvault_name
# create a secret
secret = self.cmd('keyvault secret set --vault-name {} -n secret1 --value ABC123'.format(kv),
checks=JMESPathCheck('value', 'ABC123')).get_output_in_json()
first_kid = secret['id']
first_version = first_kid.rsplit('/', 1)[1]
# list secrets
self.cmd('keyvault secret list --vault-name {}'.format(kv), checks=JMESPathCheck('length(@)', 1))
# create a new secret version
secret = self.cmd('keyvault secret set --vault-name {} -n secret1 --value DEF456 --tags test=foo --description "test type"'.format(kv), checks=[
JMESPathCheck('value', 'DEF456'),
JMESPathCheck('tags', {'file-encoding': 'utf-8', 'test': 'foo'}),
JMESPathCheck('contentType', 'test type')
]).get_output_in_json()
second_kid = secret['id']
# list secret versions
self.cmd('keyvault secret list-versions --vault-name {} -n secret1'.format(kv),
checks=JMESPathCheck('length(@)', 2))
# show secret (latest)
self.cmd('keyvault secret show --vault-name {} -n secret1'.format(kv),
checks=JMESPathCheck('id', second_kid))
# show secret (specific version)
self.cmd('keyvault secret show --vault-name {} -n secret1 -v {}'.format(kv, first_version),
checks=JMESPathCheck('id', first_kid))
# set secret attributes
self.cmd('keyvault secret set-attributes --vault-name {} -n secret1 --enabled false'.format(kv), checks=[
JMESPathCheck('id', second_kid),
JMESPathCheck('attributes.enabled', False)
])
# backup and then delete secret
bak_file = 'backup.secret'
self.cmd('keyvault secret backup --vault-name {} -n secret1 --file {}'.format(kv, bak_file))
self.cmd('keyvault secret delete --vault-name {} -n secret1'.format(kv))
self.cmd('keyvault secret list --vault-name {}'.format(kv), checks=NoneCheck())
# restore key from backup
self.cmd('keyvault secret restore --vault-name {} --file {}'.format(kv, bak_file))
self.cmd('keyvault secret list-versions --vault-name {} -n secret1'.format(kv),
checks=JMESPathCheck('length(@)', 2))
if os.path.isfile(bak_file):
os.remove(bak_file)
# delete secret
self.cmd('keyvault secret delete --vault-name {} -n secret1'.format(kv))
self.cmd('keyvault secret list --vault-name {}'.format(kv),
checks=NoneCheck())
self._test_download_secret()
def test_sqlvm_create_and_delete(self, resource_group,
resource_group_location, sqlvm1, sqlvm2,
sqlvm3, storage_account):
# test create sqlvm1 with minimal required parameters
self.cmd('sql vm create -n {} -g {} -l {} --license-type {}'.format(
sqlvm1, resource_group, resource_group_location, 'PAYG'),
checks=[
JMESPathCheck('name', sqlvm1),
JMESPathCheck('location', resource_group_location),
JMESPathCheck('provisioningState', "Succeeded"),
JMESPathCheck('sqlServerLicenseType', 'PAYG')
])
# test create sqlvm2 with AHUB changes inmediately
self.cmd('sql vm create -n {} -g {} -l {} --license-type {}'.format(
sqlvm2, resource_group, resource_group_location, 'AHUB'),
checks=[
JMESPathCheck('name', sqlvm2),
JMESPathCheck('location', resource_group_location),
JMESPathCheck('provisioningState', "Succeeded"),
JMESPathCheck('sqlServerLicenseType', 'AHUB')
])
# test create sqlvm with sql connectivity settings
self.cmd(
'sql vm create -n {} -g {} -l {} --license-type {} --sql-mgmt-type {} --connectivity-type {} --port {} --sql-auth-update-username {} --sql-auth-update-pwd {}'
.format(sqlvm3, resource_group, resource_group_location, 'PAYG',
'Full', 'PUBLIC', 1433, 'sqladmin123',
'SecretPassword123'),
checks=[
JMESPathCheck('name', sqlvm3),
JMESPathCheck('location', resource_group_location),
JMESPathCheck('provisioningState', "Succeeded"),
JMESPathCheck('sqlServerLicenseType', 'PAYG'),
JMESPathCheck('sqlManagement', 'Full')
])
# For allocation purposes, will delete the vms and re create them with different settings.
# delete sqlvm1
self.cmd('sql vm delete -n {} -g {} --yes'.format(
sqlvm1, resource_group),
checks=NoneCheck())
# delete sqlvm2
self.cmd('sql vm delete -n {} -g {} --yes'.format(
sqlvm2, resource_group),
checks=NoneCheck())
# delete sqlvm3
self.cmd('sql vm delete -n {} -g {} --yes'.format(
sqlvm3, resource_group),
checks=NoneCheck())
# test create sqlvm1 with auto patching
self.cmd(
'sql vm create -n {} -g {} -l {} --license-type {} --sql-mgmt-type {} --day-of-week {} --maintenance-window-duration {} --maintenance-window-start-hour {}'
.format(sqlvm1, resource_group, resource_group_location, 'PAYG',
'Full', 'Monday', 60, 22),
checks=[
JMESPathCheck('name', sqlvm1),
JMESPathCheck('location', resource_group_location),
JMESPathCheck('provisioningState', "Succeeded"),
JMESPathCheck('sqlServerLicenseType', 'PAYG'),
JMESPathCheck('sqlManagement', 'Full')
])
# test create sqlvm1 with auto backup
self.cmd(
'storage account update -n {} -g {} --set kind=StorageV2'.format(
storage_account, resource_group))
sa = self.cmd('storage account show -n {} -g {}'.format(
storage_account, resource_group)).get_output_in_json()
key = self.cmd('storage account keys list -n {} -g {}'.format(
storage_account, resource_group)).get_output_in_json()
self.cmd(
'sql vm create -n {} -g {} -l {} --license-type {} --backup-schedule-type {} --full-backup-frequency {} --full-backup-start-hour {} --full-backup-duration {} '
'--sa-key {} --storage-account {} --retention-period {} --log-backup-frequency {} --sql-mgmt-type {}'
.format(sqlvm2, resource_group, resource_group_location, 'PAYG',
'Manual', 'Weekly', 2, 2, key[0]['value'],
sa['primaryEndpoints']['blob'], 30, 60, 'Full'),
checks=[
JMESPathCheck('name', sqlvm2),
JMESPathCheck('location', resource_group_location),
JMESPathCheck('provisioningState', "Succeeded"),
JMESPathCheck('sqlServerLicenseType', 'PAYG'),
JMESPathCheck('sqlManagement', 'Full')
])
# test create sqlvm1 with R services on
self.cmd(
'sql vm create -n {} -g {} -l {} --license-type {} --enable-r-services {} --sql-mgmt-type {}'
.format(sqlvm3, resource_group, resource_group_location, 'PAYG',
True, 'Full'),
checks=[
JMESPathCheck('name', sqlvm3),
JMESPathCheck('location', resource_group_location),
JMESPathCheck('provisioningState', "Succeeded"),
JMESPathCheck('sqlServerLicenseType', 'PAYG'),
JMESPathCheck('sqlManagement', 'Full')
])
def test_storage_blob_container_operations(self, resource_group, storage_account):
account_info = self.get_account_info(resource_group, storage_account)
c = self.create_container(account_info)
proposed_lease_id = 'abcdabcd-abcd-abcd-abcd-abcdabcdabcd'
new_lease_id = 'dcbadcba-dcba-dcba-dcba-dcbadcbadcba'
date = '2016-04-01t12:00z'
self.storage_cmd('storage container exists -n {}', account_info, c) \
.assert_with_checks(JMESPathCheck('exists', True))
self.storage_cmd('storage container set-permission -n {} --public-access blob',
account_info, c)
self.storage_cmd('storage container show-permission -n {}', account_info, c) \
.assert_with_checks(JMESPathCheck('publicAccess', 'blob'))
self.storage_cmd('storage container set-permission -n {} --public-access off', account_info,
c)
self.storage_cmd('storage container show-permission -n {}', account_info, c) \
.assert_with_checks(JMESPathCheck('publicAccess', 'off'))
self.storage_cmd('storage container show -n {}', account_info, c) \
.assert_with_checks(JMESPathCheck('name', c))
self.assertIn(c, self.storage_cmd('storage container list --query "[].name"',
account_info).get_output_in_json())
self.storage_cmd('storage container metadata update -n {} --metadata foo=bar moo=bak',
account_info, c)
self.storage_cmd('storage container metadata show -n {}', account_info, c) \
.assert_with_checks(JMESPathCheck('foo', 'bar'), JMESPathCheck('moo', 'bak'))
self.storage_cmd('storage container metadata update -n {}', account_info, c)
self.storage_cmd('storage container metadata show -n {}', account_info, c) \
.assert_with_checks(NoneCheck())
# test lease operations
self.storage_cmd('storage container lease acquire --lease-duration 60 -c {} '
'--if-modified-since {} --proposed-lease-id {}', account_info, c, date,
proposed_lease_id)
self.storage_cmd('storage container show --name {}', account_info, c) \
.assert_with_checks(JMESPathCheck('properties.lease.duration', 'fixed'),
JMESPathCheck('properties.lease.state', 'leased'),
JMESPathCheck('properties.lease.status', 'locked'))
self.storage_cmd('storage container lease change -c {} --lease-id {} '
'--proposed-lease-id {}', account_info, c, proposed_lease_id, new_lease_id)
self.storage_cmd('storage container lease renew -c {} --lease-id {}',
account_info, c, new_lease_id)
self.storage_cmd('storage container show -n {}', account_info, c) \
.assert_with_checks(JMESPathCheck('properties.lease.duration', 'fixed'),
JMESPathCheck('properties.lease.state', 'leased'),
JMESPathCheck('properties.lease.status', 'locked'))
self.storage_cmd('storage container lease break -c {} --lease-break-period 30',
account_info, c)
self.storage_cmd('storage container show --name {}', account_info, c) \
.assert_with_checks(JMESPathCheck('properties.lease.duration', None),
JMESPathCheck('properties.lease.state', 'breaking'),
JMESPathCheck('properties.lease.status', 'locked'))
self.storage_cmd('storage container lease release -c {} --lease-id {}', account_info, c,
new_lease_id)
self.storage_cmd('storage container show --name {}', account_info, c) \
.assert_with_checks(JMESPathCheck('properties.lease.duration', None),
JMESPathCheck('properties.lease.state', 'available'),
JMESPathCheck('properties.lease.status', 'unlocked'))
self.assertIn('sig=', self.storage_cmd('storage container generate-sas -n {}', account_info,
c).output)
# verify delete operation
self.storage_cmd('storage container delete --name {} --fail-not-exist', account_info, c) \
.assert_with_checks(JMESPathCheck('deleted', True))
self.storage_cmd('storage container exists -n {}', account_info, c) \
.assert_with_checks(JMESPathCheck('exists', False))
def _test_firewall_rule_mgmt(self, database_engine, resource_group):
server_name = self.create_random_name(SERVER_NAME_PREFIX,
SERVER_NAME_MAX_LENGTH)
storage_size = 32
if database_engine == 'postgres':
version = '12'
location = self.postgres_location
elif database_engine == 'mysql':
version = '5.7'
location = self.mysql_location
self.cmd(
'{} flexible-server create -g {} --name {} -l {} --storage-size {} --version {}'
.format(database_engine, resource_group, server_name, location,
storage_size, version))
firewall_rule_name = 'firewall_test_rule'
start_ip_address = '10.10.10.10'
end_ip_address = '12.12.12.12'
firewall_rule_checks = [
JMESPathCheck('name', firewall_rule_name),
JMESPathCheck('endIpAddress', end_ip_address),
JMESPathCheck('startIpAddress', start_ip_address)
]
# firewall-rule create
self.cmd(
'{} flexible-server firewall-rule create -g {} -s {} --name {} '
'--start-ip-address {} --end-ip-address {} '.format(
database_engine, resource_group, server_name,
firewall_rule_name, start_ip_address, end_ip_address),
checks=firewall_rule_checks)
# firewall-rule show
self.cmd(
'{} flexible-server firewall-rule show -g {} -s {} --name {} '.
format(database_engine, resource_group, server_name,
firewall_rule_name),
checks=firewall_rule_checks)
# firewall-rule update
new_start_ip_address = '9.9.9.9'
self.cmd(
'{} flexible-server firewall-rule update -g {} -s {} --name {} --start-ip-address {}'
.format(database_engine, resource_group, server_name,
firewall_rule_name, new_start_ip_address),
checks=[JMESPathCheck('startIpAddress', new_start_ip_address)])
new_end_ip_address = '13.13.13.13'
self.cmd(
'{} flexible-server firewall-rule update -g {} -s {} --name {} --end-ip-address {}'
.format(database_engine, resource_group, server_name,
firewall_rule_name, new_end_ip_address))
# Add second firewall-rule
new_firewall_rule_name = 'firewall_test_rule2'
firewall_rule_checks = [
JMESPathCheck('name', new_firewall_rule_name),
JMESPathCheck('endIpAddress', end_ip_address),
JMESPathCheck('startIpAddress', start_ip_address)
]
self.cmd(
'{} flexible-server firewall-rule create -g {} -s {} --name {} '
'--start-ip-address {} --end-ip-address {} '.format(
database_engine, resource_group, server_name,
new_firewall_rule_name, start_ip_address, end_ip_address),
checks=firewall_rule_checks)
# firewall-rule list
self.cmd('{} flexible-server firewall-rule list -g {} -s {}'.format(
database_engine, resource_group, server_name),
checks=[JMESPathCheck('length(@)', 2)])
# firewall-rule delete
self.cmd(
'{} flexible-server firewall-rule delete --name {} -g {} --server {} --prompt no'
.format(database_engine, firewall_rule_name, resource_group,
server_name),
checks=NoneCheck())
self.cmd(
'{} flexible-server firewall-rule list -g {} --server {}'.format(
database_engine, resource_group, server_name),
checks=[JMESPathCheck('length(@)', 1)])
self.cmd(
'{} flexible-server firewall-rule delete -g {} -s {} --name {} --prompt no'
.format(database_engine, resource_group, server_name,
new_firewall_rule_name))
self.cmd('{} flexible-server firewall-rule list -g {} -s {}'.format(
database_engine, resource_group, server_name),
checks=NoneCheck())
def _test_flexible_server_vnet_mgmt_supplied_subnet_id_in_different_rg(
self, database_engine, resource_group_1, resource_group_2):
# flexible-server create
if self.cli_ctx.local_context.is_on:
self.cmd('local-context off')
if database_engine == 'postgres':
location = self.postgres_location
elif database_engine == 'mysql':
location = self.mysql_location
vnet_name = 'clitestvnet7'
subnet_name = 'clitestsubnet7'
address_prefix = '10.0.0.0/16'
subnet_prefix_1 = '10.0.0.0/24'
vnet_name_2 = 'clitestvnet8'
subnet_name_2 = 'clitestsubnet8'
# flexible-servers
servers = [
'testvnetserver7' + database_engine,
'testvnetserver8' + database_engine
]
# Case 1 : Provision a server with supplied subnetid that exists in a different RG
# create vnet and subnet.
vnet_result = self.cmd(
'network vnet create -n {} -g {} -l {} --address-prefix {} --subnet-name {} --subnet-prefix {}'
.format(vnet_name, resource_group_1, location, address_prefix,
subnet_name, subnet_prefix_1)).get_output_in_json()
# create server - Delegation should be added.
self.cmd('{} flexible-server create -g {} -n {} --subnet {}'.format(
database_engine, resource_group_2, servers[0],
vnet_result['newVNet']['subnets'][0]['id']))
# Case 2 : Provision a server with supplied subnetid that has a different RG in the ID but does not exist. The vnet and subnet is then created in the RG of the server
self.cmd('{} flexible-server create -g {} -n {} --subnet {}'.format(
database_engine, resource_group_2, servers[1],
'/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/virtualNetworks/{}/subnets/{}'
.format(self.get_subscription_id(), resource_group_1, vnet_name_2,
subnet_name_2)))
# flexible-server show to validate delegation is added to both the created server
show_result_1 = self.cmd('{} flexible-server show -g {} -n {}'.format(
database_engine, resource_group_2,
servers[0])).get_output_in_json()
show_result_2 = self.cmd('{} flexible-server show -g {} -n {}'.format(
database_engine, resource_group_2,
servers[1])).get_output_in_json()
self.assertEqual(
show_result_1['delegatedSubnetArguments']['subnetArmResourceId'],
'/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/virtualNetworks/{}/subnets/{}'
.format(self.get_subscription_id(), resource_group_1, vnet_name,
subnet_name))
self.assertEqual(
show_result_2['delegatedSubnetArguments']['subnetArmResourceId'],
'/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/virtualNetworks/{}/subnets/{}'
.format(self.get_subscription_id(), resource_group_2, vnet_name_2,
'Subnet' + servers[1][6:]))
# delete all servers
self.cmd('{} flexible-server delete -g {} -n {} --yes'.format(
database_engine, resource_group_2, servers[0]),
checks=NoneCheck())
self.cmd('{} flexible-server delete -g {} -n {} --yes'.format(
database_engine, resource_group_2, servers[1]),
checks=NoneCheck())
time.sleep(15 * 60)
# remove delegations from all vnets
self.cmd(
'network vnet subnet update -g {} --name {} --vnet-name {} --remove delegations'
.format(resource_group_1, subnet_name, vnet_name))
self.cmd(
'network vnet subnet update -g {} --name {} --vnet-name {} --remove delegations'
.format(resource_group_2, 'Subnet' + servers[1][6:], vnet_name_2))
# remove all vnets
self.cmd('network vnet delete -g {} -n {}'.format(
resource_group_1, vnet_name))
self.cmd('network vnet delete -g {} -n {}'.format(
resource_group_2, vnet_name_2))
def _test_flexible_server_replica_mgmt(self, database_engine, resource_group):
location = self.mysql_location
master_server = self.create_random_name(SERVER_NAME_PREFIX, 32)
replicas = [self.create_random_name('azuredbclirep1', SERVER_NAME_MAX_LENGTH),
self.create_random_name('azuredbclirep2', SERVER_NAME_MAX_LENGTH)]
# create a server
self.cmd('{} flexible-server create -g {} --name {} -l {} --storage-size {}'
.format(database_engine, resource_group, master_server, location, 256))
result = self.cmd('{} flexible-server show -g {} --name {} '
.format(database_engine, resource_group, master_server),
checks=[JMESPathCheck('replicationRole', 'None')]).get_output_in_json()
# test replica create
self.cmd('{} flexible-server replica create -g {} --replica-name {} --source-server {}'
.format(database_engine, resource_group, replicas[0], result['id']),
checks=[
JMESPathCheck('name', replicas[0]),
JMESPathCheck('resourceGroup', resource_group),
JMESPathCheck('sku.tier', result['sku']['tier']),
JMESPathCheck('sku.name', result['sku']['name']),
JMESPathCheck('replicationRole', 'Replica'),
JMESPathCheck('sourceServerId', result['id']),
JMESPathCheck('replicaCapacity', '0')])
# test replica list
self.cmd('{} flexible-server replica list -g {} --name {}'
.format(database_engine, resource_group, master_server),
checks=[JMESPathCheck('length(@)', 1)])
# test replica stop
self.cmd('{} flexible-server replica stop-replication -g {} --name {} --yes'
.format(database_engine, resource_group, replicas[0]),
checks=[
JMESPathCheck('name', replicas[0]),
JMESPathCheck('resourceGroup', resource_group),
JMESPathCheck('replicationRole', 'None'),
JMESPathCheck('sourceServerId', ''),
JMESPathCheck('replicaCapacity', result['replicaCapacity'])])
# test show server with replication info, master becomes normal server
self.cmd('{} flexible-server show -g {} --name {}'
.format(database_engine, resource_group, master_server),
checks=[
JMESPathCheck('replicationRole', 'None'),
JMESPathCheck('sourceServerId', ''),
JMESPathCheck('replicaCapacity', result['replicaCapacity'])])
# test delete master server
self.cmd('{} flexible-server replica create -g {} --replica-name {} --source-server {}'
.format(database_engine, resource_group, replicas[1], result['id']),
checks=[
JMESPathCheck('name', replicas[1]),
JMESPathCheck('resourceGroup', resource_group),
JMESPathCheck('sku.name', result['sku']['name']),
JMESPathCheck('replicationRole', 'Replica'),
JMESPathCheck('sourceServerId', result['id']),
JMESPathCheck('replicaCapacity', '0')])
self.cmd('{} flexible-server delete -g {} --name {} --yes'
.format(database_engine, resource_group, master_server), checks=NoneCheck())
# test show server with replication info, replica was auto stopped after master server deleted
self.cmd('{} flexible-server show -g {} --name {}'
.format(database_engine, resource_group, replicas[1]),
checks=[
JMESPathCheck('replicationRole', 'None'),
JMESPathCheck('sourceServerId', ''),
JMESPathCheck('replicaCapacity', result['replicaCapacity'])])
# clean up servers
self.cmd('{} flexible-server delete -g {} --name {} --yes'
.format(database_engine, resource_group, replicas[0]), checks=NoneCheck())
self.cmd('{} flexible-server delete -g {} --name {} --yes'
.format(database_engine, resource_group, replicas[1]), checks=NoneCheck())
def _test_server_mgmt(self, database_engine, resource_group_1,
resource_group_2):
servers = [
self.create_random_name(SERVER_NAME_PREFIX,
SERVER_NAME_MAX_LENGTH),
self.create_random_name('azuredbclirestore',
SERVER_NAME_MAX_LENGTH),
self.create_random_name('azuredbcligeorestore',
SERVER_NAME_MAX_LENGTH)
]
admin_login = '******'
admin_passwords = ['SecretPassword123', 'SecretPassword456']
edition = 'GeneralPurpose'
backupRetention = 10
geoRedundantBackup = 'Enabled'
old_cu = 2
new_cu = 4
family = 'Gen5'
skuname = '{}_{}_{}'.format("GP", family, old_cu)
loc = 'koreasouth'
geoGeoRedundantBackup = 'Disabled'
geoBackupRetention = 20
geoloc = 'koreasouth'
# test create server
self.cmd('{} server create -g {} --name {} -l {} '
'--admin-user {} --admin-password {} '
'--sku-name {} --tags key=1 --geo-redundant-backup {} '
'--backup-retention {}'.format(database_engine,
resource_group_1, servers[0],
loc, admin_login,
admin_passwords[0], skuname,
geoRedundantBackup,
backupRetention),
checks=[
JMESPathCheck('name', servers[0]),
JMESPathCheck('resourceGroup', resource_group_1),
JMESPathCheck('administratorLogin', admin_login),
JMESPathCheck('sslEnforcement', 'Enabled'),
JMESPathCheck('tags.key', '1'),
JMESPathCheck('sku.capacity', old_cu),
JMESPathCheck('sku.tier', edition),
JMESPathCheck('storageProfile.backupRetentionDays',
backupRetention),
JMESPathCheck('storageProfile.geoRedundantBackup',
geoRedundantBackup)
])
# test show server
result = self.cmd('{} server show -g {} --name {}'
.format(database_engine, resource_group_1, servers[0]),
checks=[
JMESPathCheck('name', servers[0]),
JMESPathCheck('resourceGroup', resource_group_1),
JMESPathCheck('administratorLogin', admin_login),
JMESPathCheck('sslEnforcement', 'Enabled'),
JMESPathCheck('tags.key', '1'),
JMESPathCheck('sku.capacity', old_cu),
JMESPathCheck('sku.tier', edition),
JMESPathCheck('storageProfile.backupRetentionDays', backupRetention),
JMESPathCheck('storageProfile.geoRedundantBackup', geoRedundantBackup)]).get_output_in_json() # pylint: disable=line-too-long
# test update server
self.cmd('{} server update -g {} --name {} --admin-password {} '
'--ssl-enforcement Disabled --tags key=2'.format(
database_engine, resource_group_1, servers[0],
admin_passwords[1]),
checks=[
JMESPathCheck('name', servers[0]),
JMESPathCheck('resourceGroup', resource_group_1),
JMESPathCheck('sslEnforcement', 'Disabled'),
JMESPathCheck('sku.tier', edition),
JMESPathCheck('tags.key', '2'),
JMESPathCheck('administratorLogin', admin_login)
])
self.cmd('{} server update -g {} --name {} --vcore {}'.format(
database_engine, resource_group_1, servers[0], new_cu),
checks=[
JMESPathCheck('name', servers[0]),
JMESPathCheck('resourceGroup', resource_group_1),
JMESPathCheck('sku.tier', edition),
JMESPathCheck('sku.capacity', new_cu),
JMESPathCheck('administratorLogin', admin_login)
])
# test show server
self.cmd('{} server show -g {} --name {}'.format(
database_engine, resource_group_1, servers[0]),
checks=[
JMESPathCheck('name', servers[0]),
JMESPathCheck('resourceGroup', resource_group_1),
JMESPathCheck('sslEnforcement', 'Disabled'),
JMESPathCheck('sku.tier', edition),
JMESPathCheck('sku.capacity', new_cu),
JMESPathCheck('tags.key', '2'),
JMESPathCheck('administratorLogin', admin_login)
])
# test update server per property
self.cmd('{} server update -g {} --name {} --vcore {}'.format(
database_engine, resource_group_1, servers[0], old_cu),
checks=[
JMESPathCheck('name', servers[0]),
JMESPathCheck('resourceGroup', resource_group_1),
JMESPathCheck('sku.tier', edition),
JMESPathCheck('sku.capacity', old_cu),
JMESPathCheck('administratorLogin', admin_login)
])
self.cmd('{} server update -g {} --name {} --ssl-enforcement Enabled'.
format(database_engine, resource_group_1, servers[0]),
checks=[
JMESPathCheck('name', servers[0]),
JMESPathCheck('resourceGroup', resource_group_1),
JMESPathCheck('sslEnforcement', 'Enabled'),
JMESPathCheck('sku.tier', edition),
JMESPathCheck('administratorLogin', admin_login)
])
self.cmd('{} server update -g {} --name {} --tags key=3'.format(
database_engine, resource_group_1, servers[0]),
checks=[
JMESPathCheck('name', servers[0]),
JMESPathCheck('resourceGroup', resource_group_1),
JMESPathCheck('sslEnforcement', 'Enabled'),
JMESPathCheck('tags.key', '3'),
JMESPathCheck('sku.tier', edition),
JMESPathCheck('administratorLogin', admin_login)
])
# test restore to a new server, make sure wait at least 5 min after server created.
from time import sleep
sleep(300)
self.cmd('{} server restore -g {} --name {} '
'--source-server {} '
'--restore-point-in-time {}'.format(
database_engine, resource_group_2, servers[1],
result['id'],
datetime.utcnow().replace(tzinfo=tzutc()).isoformat()),
checks=[
JMESPathCheck('name', servers[1]),
JMESPathCheck('resourceGroup', resource_group_2),
JMESPathCheck('sku.tier', edition),
JMESPathCheck('administratorLogin', admin_login)
])
# test georestore server
with self.assertRaises(CLIError) as exception:
self.cmd(
'{} server georestore -g {} --name {} --source-server {} -l {} '
'--geo-redundant-backup {} --backup-retention {}'.format(
database_engine, resource_group_2, servers[2],
result['id'], geoloc, geoGeoRedundantBackup,
geoBackupRetention),
checks=[
JMESPathCheck('name', servers[2]),
JMESPathCheck('resourceGroup', resource_group_2),
JMESPathCheck('sku.tier', edition),
JMESPathCheck('administratorLogin', admin_login),
JMESPathCheck('location', geoloc),
JMESPathCheck('storageProfile.backupRetentionDays',
geoBackupRetention),
JMESPathCheck('storageProfile.geoRedundantBackup',
geoGeoRedundantBackup)
])
self.assertTrue(
' does not have the server ' in '{}'.format(exception.exception))
# test list servers
self.cmd('{} server list -g {}'.format(database_engine,
resource_group_2),
checks=[JMESPathCheck('type(@)', 'array')])
# test list servers without resource group
self.cmd('{} server list'.format(database_engine),
checks=[JMESPathCheck('type(@)', 'array')])
# test delete server
self.cmd('{} server delete -g {} --name {} --yes'.format(
database_engine, resource_group_1, servers[0]),
checks=NoneCheck())
self.cmd('{} server delete -g {} -n {} --yes'.format(
database_engine, resource_group_2, servers[1]),
checks=NoneCheck())
# test list server should be 0
self.cmd('{} server list -g {}'.format(database_engine,
resource_group_1),
checks=[NoneCheck()])
self.cmd('{} server list -g {}'.format(database_engine,
resource_group_2),
checks=[NoneCheck()])
def _test_firewall_rule_mgmt(self, database_engine, resource_group,
server):
firewall_rule_name = 'firewall_test_rule'
start_ip_address = '10.10.10.10'
end_ip_address = '12.12.12.12'
firewall_rule_checks = [
JMESPathCheck('name', firewall_rule_name),
JMESPathCheck('endIpAddress', end_ip_address),
JMESPathCheck('startIpAddress', start_ip_address)
]
self.cmd(
'{} flexible-server firewall-rule create -g {} --name {} --rule-name {} '
'--start-ip-address {} --end-ip-address {} '.format(
database_engine, resource_group, server, firewall_rule_name,
start_ip_address, end_ip_address),
checks=firewall_rule_checks)
self.cmd(
'{} flexible-server firewall-rule show -g {} --name {} --rule-name {} '
.format(database_engine, resource_group, server,
firewall_rule_name),
checks=firewall_rule_checks)
new_start_ip_address = '9.9.9.9'
self.cmd(
'{} flexible-server firewall-rule update -g {} --name {} --rule-name {} --start-ip-address {}'
.format(database_engine, resource_group, server,
firewall_rule_name, new_start_ip_address),
checks=[JMESPathCheck('startIpAddress', new_start_ip_address)])
new_end_ip_address = '13.13.13.13'
self.cmd(
'{} flexible-server firewall-rule update -g {} --name {} --rule-name {} --end-ip-address {}'
.format(database_engine, resource_group, server,
firewall_rule_name, new_end_ip_address))
new_firewall_rule_name = 'firewall_test_rule2'
firewall_rule_checks = [
JMESPathCheck('name', new_firewall_rule_name),
JMESPathCheck('endIpAddress', end_ip_address),
JMESPathCheck('startIpAddress', start_ip_address)
]
self.cmd(
'{} flexible-server firewall-rule create -g {} -n {} --rule-name {} '
'--start-ip-address {} --end-ip-address {} '.format(
database_engine, resource_group, server,
new_firewall_rule_name, start_ip_address, end_ip_address),
checks=firewall_rule_checks)
self.cmd('{} flexible-server firewall-rule list -g {} -n {}'.format(
database_engine, resource_group, server),
checks=[JMESPathCheck('length(@)', 2)])
self.cmd(
'{} flexible-server firewall-rule delete --rule-name {} -g {} --name {} --yes'
.format(database_engine, firewall_rule_name, resource_group,
server),
checks=NoneCheck())
self.cmd(
'{} flexible-server firewall-rule list -g {} --name {}'.format(
database_engine, resource_group, server),
checks=[JMESPathCheck('length(@)', 1)])
self.cmd(
'{} flexible-server firewall-rule delete -g {} -n {} --rule-name {} --yes'
.format(database_engine, resource_group, server,
new_firewall_rule_name))
self.cmd('{} flexible-server firewall-rule list -g {} -n {}'.format(
database_engine, resource_group, server),
checks=NoneCheck())
def _test_flexible_server_mgmt(self, database_engine, resource_group):
from knack.util import CLIError
# flexible-server create
# flexible-server create auto-generate, no local context
if self.cli_ctx.local_context.is_on:
self.cmd('local-context off')
location = self.location
if database_engine == 'postgres':
version = '12'
elif database_engine == 'mysql':
version = '5.7'
# flexible-server create with user input
server_name = self.create_random_name(SERVER_NAME_PREFIX, SERVER_NAME_MAX_LENGTH)
admin_user = '******'
sku_name = 'Standard_D4s_v3'
tier = 'GeneralPurpose'
high_availability = 'Disabled'
tag_key1 = 'key1'
tag_value1 = 'val1'
tags = tag_key1 + '=' + tag_value1
storage_size = 64
storage_size_mb = storage_size * 1024
backup_retention = 10
list_checks = [JMESPathCheck('name', server_name),
JMESPathCheck('resourceGroup', resource_group),
JMESPathCheck('sku.name', sku_name),
JMESPathCheck('sku.tier', tier),
JMESPathCheck('version', version),
JMESPathCheck('storageProfile.storageMb', storage_size_mb),
JMESPathCheck('storageProfile.backupRetentionDays', backup_retention),
JMESPathCheck('tags.' + tag_key1, tag_value1),
JMESPathCheck('administratorLogin', admin_user)]
self.cmd('{} flexible-server create -g {} -n {} -l {} --admin-user {} --sku-name {} '
'--version {} --storage-size {} --backup-retention {} --tier {} --high-availability {} --tags {} '
.format(database_engine, resource_group, server_name, location, admin_user, sku_name,
version, storage_size, backup_retention, tier, high_availability, tags))
# flexible-server show
self.cmd('{} flexible-server show -g {} -n {}'.format(database_engine, resource_group, server_name), checks=list_checks)
# flexible-server update
# update storage profile
storage_size = 128
storage_size_mb = storage_size * 1024
updated_list_checks = [JMESPathCheck('storageProfile.storageMb', storage_size_mb)]
self.cmd('{} flexible-server update -g {} -n {} --storage-size {}'
.format(database_engine, resource_group, server_name, storage_size),
checks=updated_list_checks)
# flexible-server restart
self.cmd('{} flexible-server restart -g {} -n {}'
.format(database_engine, resource_group, server_name), checks=NoneCheck())
# flexible-server stop
self.cmd('{} flexible-server stop -g {} -n {}'
.format(database_engine, resource_group, server_name), checks=NoneCheck())
# flexible-server start
self.cmd('{} flexible-server start -g {} -n {}'
.format(database_engine, resource_group, server_name), checks=NoneCheck())
# flexible-server list servers
self.cmd('{} flexible-server list -g {}'.format(database_engine, resource_group),
checks=[JMESPathCheck('type(@)', 'array')])
# test delete server
self.cmd('{} flexible-server delete -g {} -n {} --force'.format(database_engine, resource_group, server_name), checks=NoneCheck())
def test_sqlvm_mgmt(self, resource_group, resource_group_location, sqlvm,
storage_account):
loc = 'westus'
sa = self.cmd('storage account show -n {} -g {}'.format(
storage_account, resource_group)).get_output_in_json()
key = self.cmd('storage account keys list -n {} -g {}'.format(
storage_account, resource_group)).get_output_in_json()
# test create sqlvm with minimal required parameters
sqlvm_1 = self.cmd(
'sql vm create -n {} -g {} -l {} --license-type {}'.format(
sqlvm, resource_group, loc, 'PAYG'),
checks=[
JMESPathCheck('name', sqlvm),
JMESPathCheck('location', loc),
JMESPathCheck('sqlServerLicenseType', 'PAYG')
]).get_output_in_json()
# test list sqlvm should be 1
self.cmd('sql vm list -g {}'.format(resource_group),
checks=[JMESPathCheck('length(@)', 1)])
# test show of vm
self.cmd('sql vm show -n {} -g {}'.format(sqlvm, resource_group),
checks=[
JMESPathCheck('name', sqlvm),
JMESPathCheck('location', loc),
JMESPathCheck('provisioningState', "Succeeded"),
JMESPathCheck('id', sqlvm_1['id'])
])
# Check the id of the vm is correct in show
self.cmd('sql vm show -n {} -g {}'.format(sqlvm, resource_group),
checks=[
JMESPathCheck('name', sqlvm),
JMESPathCheck('id', sqlvm_1['id'])
])
# test license change
self.cmd('sql vm update -n {} -g {} --license-type {}'.format(
sqlvm, resource_group, 'AHUB'),
checks=[
JMESPathCheck('name', sqlvm),
JMESPathCheck('location', loc),
JMESPathCheck('provisioningState', "Succeeded"),
JMESPathCheck('id', sqlvm_1['id']),
JMESPathCheck('sqlServerLicenseType', 'AHUB')
])
# test enabling R services
self.cmd('sql vm update -n {} -g {} --enable-r-services {}'.format(
sqlvm, resource_group, True),
checks=[
JMESPathCheck('name', sqlvm),
JMESPathCheck('location', loc),
JMESPathCheck('provisioningState', "Succeeded"),
JMESPathCheck('id', sqlvm_1['id'])
])
# test autopatching enabling succeeds
self.cmd(
'sql vm update -n {} -g {} --day-of-week {} --maintenance-window-duration {} --maintenance-window-start-hour {}'
.format(sqlvm, resource_group, 'Monday', 60, 22),
checks=[
JMESPathCheck('name', sqlvm),
JMESPathCheck('location', loc),
JMESPathCheck('provisioningState', "Succeeded"),
JMESPathCheck('id', sqlvm_1['id'])
])
# test autopatching disabling succeeds
self.cmd('sql vm update -n {} -g {} --enable-auto-patching {}'.format(
sqlvm, resource_group, False),
checks=[
JMESPathCheck('name', sqlvm),
JMESPathCheck('location', loc),
JMESPathCheck('provisioningState', "Succeeded"),
JMESPathCheck('id', sqlvm_1['id'])
])
# test backup enabling works
self.cmd(
'sql vm update -n {} -g {} --backup-schedule-type {} --full-backup-frequency {} --full-backup-start-hour {} --full-backup-duration {} '
'--sa-key {} --storage-account {} --retention-period {} --log-backup-frequency {}'
.format(sqlvm, resource_group, 'Manual', 'Weekly', 2, 2,
key[0]['value'], sa['primaryEndpoints']['blob'], 30, 60),
checks=[
JMESPathCheck('name', sqlvm),
JMESPathCheck('location', loc),
JMESPathCheck('provisioningState', "Succeeded"),
JMESPathCheck('id', sqlvm_1['id'])
])
# test delete vm
self.cmd('sql vm delete -n {} -g {} --yes'.format(
sqlvm, resource_group),
checks=NoneCheck())
# test list sql vm should be empty
self.cmd('sql vm list -g {}'.format(resource_group),
checks=[NoneCheck()])
def test_keyvault_mgmt(self, resource_group):
self.keyvault_names = [
self.create_random_name('cli-keyvault-', 24),
self.create_random_name('cli-keyvault-', 24),
self.create_random_name('cli-keyvault-', 24),
self.create_random_name('cli-keyvault-', 24)
]
rg = resource_group
kv = self.keyvault_names[0]
loc = 'westus'
# test create keyvault with default access policy set
keyvault = self.cmd('keyvault create -g {} -n {} -l {}'.format(rg, kv, loc), checks=[
JMESPathCheck('name', kv),
JMESPathCheck('location', loc),
JMESPathCheck('resourceGroup', rg),
JMESPathCheck('type(properties.accessPolicies)', 'array'),
JMESPathCheck('length(properties.accessPolicies)', 1),
JMESPathCheck('properties.sku.name', 'standard')
]).get_output_in_json()
policy_id = keyvault['properties']['accessPolicies'][0]['objectId']
self.cmd('keyvault show -n {}'.format(kv), checks=[
JMESPathCheck('name', kv),
JMESPathCheck('location', loc),
JMESPathCheck('resourceGroup', rg),
JMESPathCheck('type(properties.accessPolicies)', 'array'),
JMESPathCheck('length(properties.accessPolicies)', 1),
])
self.cmd('keyvault list -g {}'.format(rg), checks=[
JMESPathCheck('type(@)', 'array'),
JMESPathCheck('length(@)', 1),
JMESPathCheck('[0].name', kv),
JMESPathCheck('[0].location', loc),
JMESPathCheck('[0].resourceGroup', rg),
])
# test updating keyvault sku name
self.cmd('keyvault update -g {} -n {} --set properties.sku.name=premium'.format(rg, kv), checks=[
JMESPathCheck('name', kv),
JMESPathCheck('properties.sku.name', 'premium'),
])
# test policy set/delete
self.cmd('keyvault set-policy -g {} -n {} --object-id {} --certificate-permissions get list'.format(rg, kv, policy_id),
checks=JMESPathCheck('length(properties.accessPolicies[0].permissions.certificates)', 2))
self.cmd('keyvault delete-policy -g {} -n {} --object-id {}'.format(rg, kv, policy_id), checks=[
JMESPathCheck('type(properties.accessPolicies)', 'array'),
JMESPathCheck('length(properties.accessPolicies)', 0)
])
# test keyvault delete
self.cmd('keyvault delete -n {}'.format(kv))
self.cmd('keyvault list -g {}'.format(rg), checks=NoneCheck())
# test create keyvault further
self.cmd('keyvault create -g {} -n {} -l {} --no-self-perms'.format(rg, self.keyvault_names[1], loc), checks=[
JMESPathCheck('type(properties.accessPolicies)', 'array'),
JMESPathCheck('length(properties.accessPolicies)', 0)
])
self.cmd('keyvault create -g {} -n {} -l {} --enabled-for-deployment true --enabled-for-disk-encryption true --enabled-for-template-deployment true'.format(rg, self.keyvault_names[2], loc), checks=[
JMESPathCheck('properties.enabledForDeployment', True),
JMESPathCheck('properties.enabledForDiskEncryption', True),
JMESPathCheck('properties.enabledForTemplateDeployment', True)
])
self.cmd('keyvault create -g {} -n {} -l {} --sku premium'.format(rg, self.keyvault_names[3], loc), checks=[
JMESPathCheck('properties.sku.name', 'premium')
])
def test_keyvault_certificate(self, resource_group):
self.resource_group = resource_group
self.keyvault_name = self.create_random_name('cli-test-keyvault-', 24)
self.location = 'westus'
self._test_keyvault_certificate_get_default_policy()
_create_keyvault(self, self.keyvault_name, self.resource_group, self.location)
kv = self.keyvault_name
self._test_certificate_download()
policy_path = os.path.join(TEST_DIR, 'policy.json')
policy2_path = os.path.join(TEST_DIR, 'policy2.json')
# create a certificate
self.cmd('keyvault certificate create --vault-name {} -n cert1 -p @"{}"'.format(kv, policy_path),
checks=JMESPathCheck('status', 'completed'))
# list certificates
self.cmd('keyvault certificate list --vault-name {}'.format(kv),
checks=JMESPathCheck('length(@)', 1))
# create a new certificate version
self.cmd('keyvault certificate create --vault-name {} -n cert1 -p @"{}"'.format(kv, policy2_path), checks=[
JMESPathCheck('status', 'completed'),
])
# list certificate versions
ver_list = self.cmd('keyvault certificate list-versions --vault-name {} -n cert1'.format(kv),
checks=JMESPathCheck('length(@)', 2)).get_output_in_json()
ver_list = sorted(ver_list, key=lambda x: x['attributes']['created'])
versions = [x['id'] for x in ver_list]
# show certificate (latest)
self.cmd('keyvault certificate show --vault-name {} -n cert1'.format(kv), checks=[
JMESPathCheck('id', versions[1]),
JMESPathCheck('policy.x509CertificateProperties.validityInMonths', 50)
])
# show certificate (specific version)
cert_version = versions[0].rsplit('/', 1)[1]
self.cmd('keyvault certificate show --vault-name {} -n cert1 -v {}'.format(kv, cert_version),
checks=JMESPathCheck('id', versions[0]))
# update certificate attributes
self.cmd('keyvault certificate set-attributes --vault-name {} -n cert1 --enabled false -p @"{}"'.format(kv, policy_path), checks=[
JMESPathCheck('id', versions[1]),
JMESPathCheck('attributes.enabled', False),
JMESPathCheck('policy.x509CertificateProperties.validityInMonths', 60)
])
self._test_keyvault_certificate_contacts()
self._test_keyvault_certificate_issuers()
self._test_keyvault_pending_certificate()
# delete certificate
self.cmd('keyvault certificate delete --vault-name {} -n cert1'.format(kv))
self.cmd('keyvault certificate list --vault-name {}'.format(kv),
checks=NoneCheck())
# test certificate import
pem_encrypted_file = os.path.join(TEST_DIR, 'import_pem_encrypted_pwd_1234.pem')
pem_encrypted_password = '******'
pem_plain_file = os.path.join(TEST_DIR, 'import_pem_plain.pem')
pem_policy_path = os.path.join(TEST_DIR, 'policy_import_pem.json')
self.cmd('keyvault certificate import --vault-name {} -n pem-cert1 --file "{}" -p @"{}"'.format(kv, pem_plain_file, pem_policy_path))
self.cmd('keyvault certificate import --vault-name {} -n pem-cert2 --file "{}" --password {} -p @"{}"'.format(kv, pem_encrypted_file, pem_encrypted_password, pem_policy_path))
pfx_plain_file = os.path.join(TEST_DIR, 'import_pfx.pfx')
pfx_policy_path = os.path.join(TEST_DIR, 'policy_import_pfx.json')
self.cmd('keyvault certificate import --vault-name {} -n pfx-cert --file "{}" -p @"{}"'.format(kv, pfx_plain_file, pfx_policy_path))
def _test_keyvault_certificate_issuers(self):
kv = self.keyvault_name
self.cmd('keyvault certificate issuer create --vault-name {} --issuer-name issuer1 --provider Test'.format(kv), checks=[
JMESPathCheck('provider', 'Test'),
JMESPathCheck('attributes.enabled', True)
])
self.cmd('keyvault certificate issuer show --vault-name {} --issuer-name issuer1'.format(kv), checks=[
JMESPathCheck('provider', 'Test'),
JMESPathCheck('attributes.enabled', True)
])
self.cmd('keyvault certificate issuer update --vault-name {} --issuer-name issuer1 --organization-id TestOrg --account-id test_account'.format(kv), checks=[
JMESPathCheck('provider', 'Test'),
JMESPathCheck('attributes.enabled', True),
JMESPathCheck('organizationDetails.id', 'TestOrg'),
JMESPathCheck('credentials.accountId', 'test_account')
])
with self.assertRaises(CLIError):
self.cmd('keyvault certificate issuer update --vault-name {} --issuer-name notexist --organization-id TestOrg --account-id test_account'.format(kv))
self.cmd('keyvault certificate issuer update --vault-name {} --issuer-name issuer1 --account-id ""'.format(kv), checks=[
JMESPathCheck('provider', 'Test'),
JMESPathCheck('attributes.enabled', True),
JMESPathCheck('organizationDetails.id', 'TestOrg'),
JMESPathCheck('credentials.accountId', None)
])
self.cmd('keyvault certificate issuer list --vault-name {}'.format(kv),
checks=JMESPathCheck('length(@)', 1))
# test admin commands
self.cmd('keyvault certificate issuer admin add --vault-name {} --issuer-name issuer1 --email [email protected] --first-name Test --last-name Admin --phone 123-456-7890'.format(kv), checks=[
JMESPathCheck('emailAddress', '*****@*****.**'),
JMESPathCheck('firstName', 'Test'),
JMESPathCheck('lastName', 'Admin'),
JMESPathCheck('phone', '123-456-7890'),
])
with self.assertRaises(CLIError):
self.cmd(
'keyvault certificate issuer admin add --vault-name {} --issuer-name issuer1 --email [email protected]'.format(kv))
self.cmd('keyvault certificate issuer admin add --vault-name {} --issuer-name issuer1 --email [email protected]'.format(kv), checks=[
JMESPathCheck('emailAddress', '*****@*****.**'),
JMESPathCheck('firstName', None),
JMESPathCheck('lastName', None),
JMESPathCheck('phone', None),
])
self.cmd('keyvault certificate issuer admin list --vault-name {} --issuer-name issuer1'.format(kv),
checks=JMESPathCheck('length(@)', 2))
self.cmd('keyvault certificate issuer admin delete --vault-name {} --issuer-name issuer1 --email [email protected]'.format(kv))
self.cmd('keyvault certificate issuer admin list --vault-name {} --issuer-name issuer1'.format(kv),
checks=JMESPathCheck('length(@)', 1))
self.cmd('keyvault certificate issuer delete --vault-name {} --issuer-name issuer1'.format(kv))
self.cmd('keyvault certificate issuer list --vault-name {}'.format(kv), checks=NoneCheck())
def test_sqlvm_update_license_and_sku(self, resource_group,
resource_group_location, sqlvm1):
# test create sqlvm with sql license type and sku type.
self.cmd(
'sql vm create -n {} -g {} -l {} --image-sku {} --license-type {}'.
format(sqlvm1, resource_group, resource_group_location,
'Enterprise', 'AHUB'),
checks=[
JMESPathCheck('name', sqlvm1),
JMESPathCheck('location', resource_group_location),
JMESPathCheck('provisioningState', "Succeeded"),
JMESPathCheck('sqlServerLicenseType', 'AHUB'),
JMESPathCheck('sqlImageSku', 'Enterprise'),
])
# test sku change with license change.
self.cmd('sql vm update -n {} -g {} --image-sku {} --license-type {}'.
format(sqlvm1, resource_group, 'Enterprise', 'PAYG'),
checks=[
JMESPathCheck('name', sqlvm1),
JMESPathCheck('location', resource_group_location),
JMESPathCheck('provisioningState', "Succeeded"),
JMESPathCheck('sqlImageSku', 'Enterprise'),
JMESPathCheck('sqlServerLicenseType', 'PAYG')
])
# delete sqlvm
self.cmd('sql vm delete -n {} -g {} --yes'.format(
sqlvm1, resource_group),
checks=NoneCheck())
# test create sqlvm with sql license type PAYG and sku type.
self.cmd(
'sql vm create -n {} -g {} -l {} --image-sku {} --license-type {}'.
format(sqlvm1, resource_group, resource_group_location,
'Enterprise', 'PAYG'),
checks=[
JMESPathCheck('name', sqlvm1),
JMESPathCheck('location', resource_group_location),
JMESPathCheck('provisioningState', "Succeeded"),
JMESPathCheck('sqlServerLicenseType', 'PAYG'),
JMESPathCheck('sqlImageSku', 'Enterprise'),
])
# test sku change without license change.
self.cmd('sql vm update -n {} -g {} --image-sku {}'.format(
sqlvm1, resource_group, 'Enterprise'),
checks=[
JMESPathCheck('name', sqlvm1),
JMESPathCheck('location', resource_group_location),
JMESPathCheck('provisioningState', "Succeeded"),
JMESPathCheck('sqlImageSku', 'Enterprise'),
JMESPathCheck('sqlServerLicenseType', 'PAYG')
])
# test sku change with license change.
self.cmd('sql vm update -n {} -g {} --image-sku {} --license-type {}'.
format(sqlvm1, resource_group, 'Enterprise', 'AHUB'),
checks=[
JMESPathCheck('name', sqlvm1),
JMESPathCheck('location', resource_group_location),
JMESPathCheck('provisioningState', "Succeeded"),
JMESPathCheck('sqlImageSku', 'Enterprise'),
JMESPathCheck('sqlServerLicenseType', 'AHUB')
])
# test license change for DR only.
self.cmd('sql vm update -n {} -g {} --license-type {}'.format(
sqlvm1, resource_group, 'DR'),
checks=[
JMESPathCheck('name', sqlvm1),
JMESPathCheck('location', resource_group_location),
JMESPathCheck('provisioningState', "Succeeded"),
JMESPathCheck('sqlImageSku', 'Enterprise'),
JMESPathCheck('sqlServerLicenseType', 'DR')
])
# delete sqlvm
self.cmd('sql vm delete -n {} -g {} --yes'.format(
sqlvm1, resource_group),
checks=NoneCheck())
# test create sqlvm with sql license type DR.
self.cmd('sql vm create -n {} -g {} -l {} --license-type {}'.format(
sqlvm1, resource_group, resource_group_location, 'DR'),
checks=[
JMESPathCheck('name', sqlvm1),
JMESPathCheck('location', resource_group_location),
JMESPathCheck('provisioningState', "Succeeded"),
JMESPathCheck('sqlServerLicenseType', 'DR'),
])
def _test_firewall_mgmt(self, resource_group, server, database_engine):
rg = resource_group
firewall_rule_1 = 'rule1'
start_ip_address_1 = '0.0.0.0'
end_ip_address_1 = '255.255.255.255'
firewall_rule_2 = 'rule2'
start_ip_address_2 = '123.123.123.123'
end_ip_address_2 = '123.123.123.124'
# test firewall-rule create
self.cmd('{} server firewall-rule create -n {} -g {} -s {} '
'--start-ip-address {} --end-ip-address {}'.format(
database_engine, firewall_rule_1, rg, server,
start_ip_address_1, end_ip_address_1),
checks=[
JMESPathCheck('name', firewall_rule_1),
JMESPathCheck('resourceGroup', rg),
JMESPathCheck('startIpAddress', start_ip_address_1),
JMESPathCheck('endIpAddress', end_ip_address_1)
])
# test firewall-rule show
self.cmd(
'{} server firewall-rule show --name {} -g {} --server {}'.format(
database_engine, firewall_rule_1, rg, server),
checks=[
JMESPathCheck('name', firewall_rule_1),
JMESPathCheck('resourceGroup', rg),
JMESPathCheck('startIpAddress', start_ip_address_1),
JMESPathCheck('endIpAddress', end_ip_address_1)
])
# test firewall-rule update
self.cmd('{} server firewall-rule update -n {} -g {} -s {} '
'--start-ip-address {} --end-ip-address {}'.format(
database_engine, firewall_rule_1, rg, server,
start_ip_address_2, end_ip_address_2),
checks=[
JMESPathCheck('name', firewall_rule_1),
JMESPathCheck('resourceGroup', rg),
JMESPathCheck('startIpAddress', start_ip_address_2),
JMESPathCheck('endIpAddress', end_ip_address_2)
])
self.cmd('{} server firewall-rule update --name {} -g {} --server {} '
'--start-ip-address {}'.format(database_engine,
firewall_rule_1, rg, server,
start_ip_address_1),
checks=[
JMESPathCheck('name', firewall_rule_1),
JMESPathCheck('resourceGroup', rg),
JMESPathCheck('startIpAddress', start_ip_address_1),
JMESPathCheck('endIpAddress', end_ip_address_2)
])
self.cmd('{} server firewall-rule update -n {} -g {} -s {} '
'--end-ip-address {}'.format(database_engine, firewall_rule_1,
rg, server, end_ip_address_1),
checks=[
JMESPathCheck('name', firewall_rule_1),
JMESPathCheck('resourceGroup', rg),
JMESPathCheck('startIpAddress', start_ip_address_1),
JMESPathCheck('endIpAddress', end_ip_address_1)
])
# test firewall-rule create another rule
self.cmd('{} server firewall-rule create --name {} -g {} --server {} '
'--start-ip-address {} --end-ip-address {}'.format(
database_engine, firewall_rule_2, rg, server,
start_ip_address_2, end_ip_address_2),
checks=[
JMESPathCheck('name', firewall_rule_2),
JMESPathCheck('resourceGroup', rg),
JMESPathCheck('startIpAddress', start_ip_address_2),
JMESPathCheck('endIpAddress', end_ip_address_2)
])
# test firewall-rule list
self.cmd('{} server firewall-rule list -g {} -s {}'.format(
database_engine, rg, server),
checks=[JMESPathCheck('length(@)', 2)])
self.cmd(
'{} server firewall-rule delete --name {} -g {} --server {} --yes'.
format(database_engine, firewall_rule_1, rg, server),
checks=NoneCheck())
self.cmd('{} server firewall-rule list -g {} --server {}'.format(
database_engine, rg, server),
checks=[JMESPathCheck('length(@)', 1)])
self.cmd(
'{} server firewall-rule delete -n {} -g {} -s {} --yes'.format(
database_engine, firewall_rule_2, rg, server),
checks=NoneCheck())
self.cmd('{} server firewall-rule list -g {} --server {}'.format(
database_engine, rg, server),
checks=[NoneCheck()])
def test_sqlvm_group_mgmt(self, resource_group, resource_group_location,
storage_account1, storage_account2):
name = 'sqlvmgroup'
image_offer = 'SQL2017-WS2016'
image_sku = 'Enterprise'
domain = 'domain.com'
operator_acc = 'myvmadmin'
sql_service_acc = 'sqlservice'
sa_1 = self.cmd('storage account show -n {} -g {}'.format(
storage_account1, resource_group)).get_output_in_json()
key_1 = self.cmd('storage account keys list -n {} -g {}'.format(
storage_account1, resource_group)).get_output_in_json()
sa_2 = self.cmd('storage account show -n {} -g {}'.format(
storage_account2, resource_group)).get_output_in_json()
key_2 = self.cmd('storage account keys list -n {} -g {}'.format(
storage_account2, resource_group)).get_output_in_json()
# create sql vm group
sqlvmgroup = self.cmd(
'sql vm group create -n {} -g {} -l {} -i {} -s {} -f {} -p {} -k {} -e {} -u {}'
.format(name, resource_group, resource_group_location, image_offer,
image_sku, domain, operator_acc, key_1[0]['value'],
sql_service_acc, sa_1['primaryEndpoints']['blob']),
checks=[
JMESPathCheck('name', name),
JMESPathCheck('location', resource_group_location),
JMESPathCheck('provisioningState', "Succeeded")
]).get_output_in_json()
# test list sqlvm should be 1
self.cmd('sql vm group list -g {}'.format(resource_group),
checks=[JMESPathCheck('length(@)', 1)])
# test show of the group
self.cmd('sql vm group show -n {} -g {}'.format(name, resource_group),
checks=[
JMESPathCheck('name', name),
JMESPathCheck('location', resource_group_location),
JMESPathCheck('provisioningState', "Succeeded"),
JMESPathCheck('sqlImageOffer', image_offer),
JMESPathCheck('sqlImageSku', image_sku),
JMESPathCheck('id', sqlvmgroup['id'])
])
# Change the storage account url and key
self.cmd('sql vm group update -n {} -g {} -u {} -k {}'.format(
name, resource_group, sa_2['primaryEndpoints']['blob'],
key_2[0]['value']),
checks=[
JMESPathCheck('name', name),
JMESPathCheck('location', resource_group_location),
JMESPathCheck('wsfcDomainProfile.storageAccountUrl',
sa_2['primaryEndpoints']['blob'])
])
# change the domain
self.cmd('sql vm group update -n {} -g {} -f {} -k {}'.format(
name, resource_group, 'my' + domain, key_2[0]['value']),
checks=[
JMESPathCheck('name', name),
JMESPathCheck('location', resource_group_location),
JMESPathCheck('wsfcDomainProfile.domainFqdn',
'my' + domain)
])
# change the operator account
self.cmd('sql vm group update -n {} -g {} -p {} -k {}'.format(
name, resource_group, 'my' + operator_acc, key_2[0]['value']),
checks=[
JMESPathCheck('name', name),
JMESPathCheck('location', resource_group_location),
JMESPathCheck('wsfcDomainProfile.clusterOperatorAccount',
'my' + operator_acc)
])
# test delete vm
self.cmd('sql vm group delete -n {} -g {} --yes'.format(
name, resource_group),
checks=NoneCheck())
# test list sql vm should be empty
self.cmd('sql vm group list -g {}'.format(resource_group),
checks=[NoneCheck()])
def _test_server_mgmt(self, database_engine, resource_group_1,
resource_group_2):
servers = [
self.create_random_name(SERVER_NAME_PREFIX,
SERVER_NAME_MAX_LENGTH),
self.create_random_name('azuredbclirestore',
SERVER_NAME_MAX_LENGTH)
]
admin_login = '******'
admin_passwords = ['SecretPassword123', 'SecretPassword456']
edition = 'Basic'
old_cu = 100
new_cu = 50
rg = resource_group_1
loc = 'westeurope'
# test create server
self.cmd(
'{} server create -g {} --name {} -l {} '
'--admin-user {} --admin-password {} '
'--performance-tier {} --compute-units {} --tags key=1'.format(
database_engine, rg, servers[0], loc, admin_login,
admin_passwords[0], edition, old_cu),
checks=[
JMESPathCheck('name', servers[0]),
JMESPathCheck('resourceGroup', rg),
JMESPathCheck('administratorLogin', admin_login),
JMESPathCheck('sslEnforcement', 'Enabled'),
JMESPathCheck('tags.key', '1'),
JMESPathCheck('sku.capacity', old_cu),
JMESPathCheck('sku.tier', edition)
])
# test show server
result = self.cmd('{} server show -g {} --name {}'.format(
database_engine, rg, servers[0]),
checks=[
JMESPathCheck('name', servers[0]),
JMESPathCheck('administratorLogin', admin_login),
JMESPathCheck('sku.capacity', 100),
JMESPathCheck('resourceGroup', rg)
]).get_output_in_json()
# test update server
self.cmd('{} server update -g {} --name {} --admin-password {} '
'--ssl-enforcement Disabled --tags key=2'.format(
database_engine, rg, servers[0], admin_passwords[1]),
checks=[
JMESPathCheck('name', servers[0]),
JMESPathCheck('resourceGroup', rg),
JMESPathCheck('sslEnforcement', 'Disabled'),
JMESPathCheck('sku.tier', edition),
JMESPathCheck('tags.key', '2'),
JMESPathCheck('administratorLogin', admin_login)
])
self.cmd('{} server update -g {} --name {} --compute-units {}'.format(
database_engine, rg, servers[0], new_cu),
checks=[
JMESPathCheck('name', servers[0]),
JMESPathCheck('resourceGroup', rg),
JMESPathCheck('sku.tier', edition),
JMESPathCheck('sku.capacity', new_cu),
JMESPathCheck('administratorLogin', admin_login)
])
# test show server
self.cmd('{} server show -g {} --name {}'.format(
database_engine, rg, servers[0]),
checks=[
JMESPathCheck('name', servers[0]),
JMESPathCheck('resourceGroup', rg),
JMESPathCheck('sslEnforcement', 'Disabled'),
JMESPathCheck('sku.tier', edition),
JMESPathCheck('sku.capacity', new_cu),
JMESPathCheck('tags.key', '2'),
JMESPathCheck('administratorLogin', admin_login)
])
# test update server per property
self.cmd('{} server update -g {} --name {} --compute-units {}'.format(
database_engine, rg, servers[0], old_cu),
checks=[
JMESPathCheck('name', servers[0]),
JMESPathCheck('resourceGroup', rg),
JMESPathCheck('sku.tier', edition),
JMESPathCheck('sku.capacity', old_cu),
JMESPathCheck('administratorLogin', admin_login)
])
self.cmd('{} server update -g {} --name {} --ssl-enforcement Enabled'.
format(database_engine, rg, servers[0]),
checks=[
JMESPathCheck('name', servers[0]),
JMESPathCheck('resourceGroup', rg),
JMESPathCheck('sslEnforcement', 'Enabled'),
JMESPathCheck('sku.tier', edition),
JMESPathCheck('administratorLogin', admin_login)
])
self.cmd('{} server update -g {} --name {} --tags key=3'.format(
database_engine, rg, servers[0]),
checks=[
JMESPathCheck('name', servers[0]),
JMESPathCheck('resourceGroup', rg),
JMESPathCheck('sslEnforcement', 'Enabled'),
JMESPathCheck('tags.key', '3'),
JMESPathCheck('sku.tier', edition),
JMESPathCheck('administratorLogin', admin_login)
])
# test restore to a new server, make sure wait at least 5 min after server created.
from time import sleep
sleep(300)
self.cmd('{} server restore -g {} --name {} '
'--source-server {} '
'--restore-point-in-time {}'.format(
database_engine, resource_group_2, servers[1],
result['id'],
datetime.utcnow().replace(tzinfo=tzutc()).isoformat()),
checks=[
JMESPathCheck('name', servers[1]),
JMESPathCheck('resourceGroup', resource_group_2),
JMESPathCheck('sku.tier', edition),
JMESPathCheck('administratorLogin', admin_login)
])
# test list servers
self.cmd('{} server list -g {}'.format(database_engine,
resource_group_2),
checks=[JMESPathCheck('type(@)', 'array')])
# test list servers without resource group
self.cmd('{} server list'.format(database_engine),
checks=[JMESPathCheck('type(@)', 'array')])
# test delete server
self.cmd('{} server delete -g {} --name {} --yes'.format(
database_engine, rg, servers[0]),
checks=NoneCheck())
self.cmd('{} server delete -g {} -n {} --yes'.format(
database_engine, resource_group_2, servers[1]),
checks=NoneCheck())
# test list server should be 0
self.cmd('{} server list -g {}'.format(database_engine, rg),
checks=[NoneCheck()])
def _test_flexible_server_vnet_mgmt_supplied_vname_and_subnetname(
self, database_engine, resource_group, virtual_network):
# flexible-server create
if self.cli_ctx.local_context.is_on:
self.cmd('local-context off')
vnet_name_2 = 'clitestvnet6'
# flexible-servers
servers = [
'testvnetserver5' + database_engine,
'testvnetserver6' + database_engine
]
# Case 1 : Provision a server with supplied Vname and subnet name that exists.
# create vnet and subnet. When vnet name is supplied, the subnet created will be given the default name.
subnet_id = self.cmd(
'network vnet subnet show -g {rg} -n default --vnet-name {vnet}'
).get_output_in_json()['id']
# create server - Delegation should be added.
self.cmd(
'{} flexible-server create -g {} -n {} --vnet {} --subnet default'.
format(database_engine, resource_group, servers[0],
virtual_network))
# Case 2 : Provision a server with a supplied Vname and subnet name that does not exist.
self.cmd('{} flexible-server create -g {} -n {} --vnet {}'.format(
database_engine, resource_group, servers[1], vnet_name_2))
# flexible-server show to validate delegation is added to both the created server
show_result_1 = self.cmd('{} flexible-server show -g {} -n {}'.format(
database_engine, resource_group, servers[0])).get_output_in_json()
show_result_2 = self.cmd('{} flexible-server show -g {} -n {}'.format(
database_engine, resource_group, servers[1])).get_output_in_json()
self.assertEqual(
show_result_1['delegatedSubnetArguments']['subnetArmResourceId'],
subnet_id)
self.assertEqual(
show_result_2['delegatedSubnetArguments']['subnetArmResourceId'],
'/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/virtualNetworks/{}/subnets/{}'
.format(self.get_subscription_id(), resource_group, vnet_name_2,
'Subnet' + servers[1][6:]))
# delete all servers
self.cmd('{} flexible-server delete -g {} -n {} --yes'.format(
database_engine, resource_group, servers[0]),
checks=NoneCheck())
self.cmd('{} flexible-server delete -g {} -n {} --yes'.format(
database_engine, resource_group, servers[1]),
checks=NoneCheck())
time.sleep(15 * 60)
self.cmd(
'network vnet subnet update -g {} --name {} --vnet-name {} --remove delegations'
.format(resource_group, 'Subnet' + servers[1][6:], vnet_name_2))
# remove all vnets
self.cmd('network vnet delete -g {} -n {}'.format(
resource_group, vnet_name_2))
def validate_file_scenario(self, account_info, share):
source_file = self.create_temp_file(128, full_random=False)
dest_file = self.create_temp_file(1)
filename = "sample_file.bin"
self.storage_cmd(
'storage file upload --share-name {} --source "{}" -p {}',
account_info, share, source_file, filename)
self.storage_cmd('storage file exists -s {} -p {}', account_info, share, filename) \
.assert_with_checks(JMESPathCheck('exists', True))
if os.path.isfile(dest_file):
os.remove(dest_file)
self.storage_cmd(
'storage file download --share-name {} -p "{}" --dest "{}"',
account_info, share, filename, dest_file)
self.assertTrue(os.path.isfile(dest_file))
self.assertEqual(os.stat(dest_file).st_size, 128 * 1024)
# test resize command
self.storage_cmd(
'storage file resize --share-name {} -p "{}" --size 1234',
account_info, share, filename)
self.storage_cmd('storage file show -s {} -p "{}"', account_info, share, filename) \
.assert_with_checks(JMESPathCheck('properties.contentLength', 1234))
# test ability to set and reset metadata
self.storage_cmd(
'storage file metadata update --share-name {} -p "{}" --metadata a=b c=d',
account_info, share, filename)
self.storage_cmd('storage file metadata show -s {} -p "{}"', account_info, share,
filename) \
.assert_with_checks(JMESPathCheck('a', 'b'), JMESPathCheck('c', 'd'))
self.storage_cmd(
'storage file metadata update --share-name {} -p "{}"',
account_info, share, filename)
self.storage_cmd('storage file metadata show -s {} -p "{}"', account_info, share,
filename) \
.assert_with_checks(NoneCheck())
file_url = 'https://{}.file.core.windows.net/{}/{}'.format(
account_info[0], share, filename)
self.storage_cmd('storage file url -s {} -p "{}"', account_info, share, filename) \
.assert_with_checks(StringCheck(file_url))
self.assertIn(
filename,
self.storage_cmd('storage file list -s {} --query "[].name"',
account_info, share).get_output_in_json())
self.storage_cmd('storage file generate-sas -s {} -p {}', account_info, share, filename) \
.assert_with_checks(StringContainCheck('sig='))
self.storage_cmd(
'storage file update -s {} -p {} --content-type "test/type"',
account_info, share, filename)
self.storage_cmd('storage file show -s {} -p {}', account_info, share,
filename) \
.assert_with_checks(JMESPathCheck('properties.contentSettings.contentType',
'test/type'))
self.storage_cmd('storage file delete --share-name {} -p "{}"',
account_info, share, filename)
self.storage_cmd('storage file exists --share-name {} -p "{}"',
account_info, share, filename) \
.assert_with_checks(JMESPathCheck('exists', False))
def test_storage_queue_general_scenario(self, resource_group,
storage_account):
account_key = self.get_account_key(resource_group, storage_account)
self.set_env('AZURE_STORAGE_ACCOUNT', storage_account)
self.set_env('AZURE_STORAGE_KEY', account_key)
queue = self.create_random_name('queue', 24)
self.cmd(
'storage queue create -n {} --fail-on-exist --metadata a=b c=d'.
format(queue),
checks=JMESPathCheck('created', True))
self.cmd('storage queue exists -n {}'.format(queue),
checks=JMESPathCheck('exists', True))
res = self.cmd('storage queue list').get_output_in_json()
self.assertIn(queue, [x['name'] for x in res],
'The newly created queue is not listed.')
sas = self.cmd(
'storage queue generate-sas -n {} --permissions r'.format(
queue)).output
self.assertIn('sig', sas,
'The sig segment is not in the sas {}'.format(sas))
self.cmd('storage queue metadata show -n {}'.format(queue),
checks=[JMESPathCheck('a', 'b'),
JMESPathCheck('c', 'd')])
self.cmd(
'storage queue metadata update -n {} --metadata e=f g=h'.format(
queue))
self.cmd('storage queue metadata show -n {}'.format(queue),
checks=[JMESPathCheck('e', 'f'),
JMESPathCheck('g', 'h')])
# Queue message operation
self.cmd(
'storage message put -q {} --content "test message"'.format(queue))
self.cmd('storage message peek -q {}'.format(queue),
checks=JMESPathCheck('[0].content', 'test message'))
first_message = self.cmd('storage message get -q {}'.format(queue),
checks=JMESPathCheck(
'length(@)', 1)).get_output_in_json()[0]
self.cmd(
'storage message update -q {} --id {} --pop-receipt {} --visibility-timeout 1 '
'--content "new message!"'.format(queue, first_message['id'],
first_message['popReceipt']))
time.sleep(2) # ensures message should be back in queue
self.cmd('storage message peek -q {}'.format(queue),
checks=JMESPathCheck('[0].content', 'new message!'))
self.cmd('storage message put -q {} --content "second message"'.format(
queue))
self.cmd('storage message put -q {} --content "third message"'.format(
queue))
self.cmd('storage message peek -q {} --num-messages 32'.format(queue),
checks=JMESPathCheck('length(@)', 3))
third_message = self.cmd(
'storage message get -q {}'.format(queue)).get_output_in_json()[0]
self.cmd(
'storage message delete -q {} --id {} --pop-receipt {}'.format(
queue, third_message['id'], third_message['popReceipt']))
self.cmd('storage message peek -q {} --num-messages 32'.format(queue),
checks=JMESPathCheck('length(@)', 2))
self.cmd('storage message clear -q {}'.format(queue))
self.cmd('storage message peek -q {} --num-messages 32'.format(queue),
checks=NoneCheck())
# verify delete operation
self.cmd('storage queue delete -n {} --fail-not-exist'.format(queue),
checks=JMESPathCheck('deleted', True))
self.cmd('storage queue exists -n {}'.format(queue),
checks=JMESPathCheck('exists', False))
# check status of the queue
queue_status = self.cmd('storage queue stats').get_output_in_json()
self.assertIn(queue_status['geoReplication']['status'],
('live', 'unavailable'))
def test_storage_queue_general_scenario(self, resource_group,
storage_account):
account_key = self.get_account_key(resource_group, storage_account)
self.set_env('AZURE_STORAGE_ACCOUNT', storage_account)
self.set_env('AZURE_STORAGE_KEY', account_key)
queue = self.create_random_name('queue', 24)
self.cmd(
'storage queue create -n {} --fail-on-exist --metadata a=b c=d'.
format(queue),
checks=JMESPathCheck('created', True))
self.cmd('storage queue exists -n {}'.format(queue),
checks=JMESPathCheck('exists', True))
res = self.cmd('storage queue list').get_output_in_json()
self.assertIn(queue, [x['name'] for x in res],
'The newly created queue is not listed.')
sas = self.cmd(
'storage queue generate-sas -n {} --permissions r'.format(
queue)).output
self.assertIn('sig', sas,
'The sig segment is not in the sas {}'.format(sas))
self.cmd('storage queue metadata show -n {}'.format(queue),
checks=[JMESPathCheck('a', 'b'),
JMESPathCheck('c', 'd')])
self.cmd(
'storage queue metadata update -n {} --metadata e=f g=h'.format(
queue))
self.cmd('storage queue metadata show -n {}'.format(queue),
checks=[JMESPathCheck('e', 'f'),
JMESPathCheck('g', 'h')])
# Queue ACL policy
self.cmd('storage queue policy list -q {}'.format(queue),
checks=NoneCheck())
start_time = '2016-01-01T00:00Z'
expiry = '2016-05-01T00:00Z'
policy = self.create_random_name('policy', 16)
self.cmd(
'storage queue policy create -q {} -n {} --permission raup --start {} --expiry {}'
.format(queue, policy, start_time, expiry))
acl = self.cmd('storage queue policy list -q {}'.format(
queue)).get_output_in_json()
self.assertIn(policy, acl)
self.assertEqual(1, len(acl))
self.cmd('storage queue policy show -q {} -n {}'.format(queue, policy),
checks=[
JMESPathCheck('start', '2016-01-01T00:00:00+00:00'),
JMESPathCheck('expiry', '2016-05-01T00:00:00+00:00'),
JMESPathCheck('permission', 'rpau')
])
self.cmd(
'storage queue policy update -q {} -n {} --permission ra'.format(
queue, policy))
self.cmd('storage queue policy show -q {} -n {}'.format(queue, policy),
checks=JMESPathCheck('permission', 'ra'))
self.cmd('storage queue policy delete -q {} -n {}'.format(
queue, policy))
self.cmd('storage queue policy list -q {}'.format(queue),
checks=NoneCheck())
# Queue message operation
self.cmd(
'storage message put -q {} --content "test message"'.format(queue))
self.cmd('storage message peek -q {}'.format(queue),
checks=JMESPathCheck('[0].content', 'test message'))
first_message = self.cmd('storage message get -q {}'.format(queue),
checks=JMESPathCheck(
'length(@)', 1)).get_output_in_json()[0]
self.cmd(
'storage message update -q {} --id {} --pop-receipt {} --visibility-timeout 1 '
'--content "new message!"'.format(queue, first_message['id'],
first_message['popReceipt']))
time.sleep(2) # ensures message should be back in queue
self.cmd('storage message peek -q {}'.format(queue),
checks=JMESPathCheck('[0].content', 'new message!'))
self.cmd('storage message put -q {} --content "second message"'.format(
queue))
self.cmd('storage message put -q {} --content "third message"'.format(
queue))
self.cmd('storage message peek -q {} --num-messages 32'.format(queue),
checks=JMESPathCheck('length(@)', 3))
third_message = self.cmd(
'storage message get -q {}'.format(queue)).get_output_in_json()[0]
self.cmd(
'storage message delete -q {} --id {} --pop-receipt {}'.format(
queue, third_message['id'], third_message['popReceipt']))
self.cmd('storage message peek -q {} --num-messages 32'.format(queue),
checks=JMESPathCheck('length(@)', 2))
self.cmd('storage message clear -q {}'.format(queue))
self.cmd('storage message peek -q {} --num-messages 32'.format(queue),
checks=NoneCheck())
# verify delete operation
self.cmd('storage queue delete -n {} --fail-not-exist'.format(queue),
checks=JMESPathCheck('deleted', True))
self.cmd('storage queue exists -n {}'.format(queue),
checks=JMESPathCheck('exists', False))
def _test_flexible_server_mgmt(self, database_engine, resource_group):
if self.cli_ctx.local_context.is_on:
self.cmd('local-context off')
if database_engine == 'postgres':
tier = 'GeneralPurpose'
sku_name = 'Standard_D2s_v3'
version = '12'
storage_size = 128
location = self.postgres_location
elif database_engine == 'mysql':
tier = 'Burstable'
sku_name = 'Standard_B1ms'
storage_size = 10
version = '5.7'
location = self.mysql_location
# flexible-server create with user input
server_name = self.create_random_name(SERVER_NAME_PREFIX, SERVER_NAME_MAX_LENGTH)
storage_size_mb = storage_size * 1024
backup_retention = 7
list_checks = [JMESPathCheck('name', server_name),
JMESPathCheck('resourceGroup', resource_group),
JMESPathCheck('sku.name', sku_name),
JMESPathCheck('sku.tier', tier),
JMESPathCheck('version', version),
JMESPathCheck('storageProfile.storageMb', storage_size_mb),
JMESPathCheck('storageProfile.backupRetentionDays', backup_retention)]
self.cmd('{} flexible-server create -g {} -n {} -l {}'
.format(database_engine, resource_group, server_name, location))
current_time = datetime.utcnow()
if database_engine == 'postgres':
self.cmd('postgres flexible-server create -g {} -l {} --tier Burstable --sku-name Standard_B1ms'
.format(resource_group, location))
self.cmd('postgres flexible-server create -g {} -l {} --tier MemoryOptimized --sku-name Standard_E2s_v3'
.format(resource_group, location))
elif database_engine == 'mysql':
self.cmd('mysql flexible-server create -g {} -l {} --tier GeneralPurpose --sku-name Standard_D2ds_v4'
.format(resource_group, location))
self.cmd('mysql flexible-server create -g {} -l {} --tier MemoryOptimized --sku-name Standard_E2ds_v4'
.format(resource_group, location))
self.cmd('{} flexible-server show -g {} -n {}'
.format(database_engine, resource_group, server_name), checks=list_checks).get_output_in_json()
self.cmd('{} flexible-server update -g {} -n {} --storage-size 256'
.format(database_engine, resource_group, server_name),
checks=[JMESPathCheck('storageProfile.storageMb', 256 * 1024)])
self.cmd('{} flexible-server update -g {} -n {} --backup-retention {}'
.format(database_engine, resource_group, server_name, backup_retention + 10),
checks=[JMESPathCheck('storageProfile.backupRetentionDays', backup_retention + 10)])
if database_engine == 'postgres':
tier = 'Burstable'
sku_name = 'Standard_B1ms'
elif database_engine == 'mysql':
tier = 'GeneralPurpose'
sku_name = 'Standard_D2ds_v4'
self.cmd('{} flexible-server update -g {} -n {} --tier {} --sku-name {}'
.format(database_engine, resource_group, server_name, tier, sku_name),
checks=[JMESPathCheck('sku.tier', tier),
JMESPathCheck('sku.name', sku_name)])
if database_engine == 'postgres':
self.cmd('{} flexible-server update -g {} -n {} --maintenance-window Mon:1:30'
.format(database_engine, resource_group, server_name),
checks=[JMESPathCheck('maintenanceWindow.dayOfWeek', 1),
JMESPathCheck('maintenanceWindow.startHour', 1),
JMESPathCheck('maintenanceWindow.startMinute', 30)])
self.cmd('{} flexible-server update -g {} -n {} --tags key=3'
.format(database_engine, resource_group, server_name),
checks=[JMESPathCheck('tags.key', '3')])
restore_server_name = 'restore-' + server_name
restore_time = (current_time + timedelta(minutes=10)).replace(tzinfo=tzutc()).isoformat()
self.cmd('{} flexible-server restore -g {} --name {} --source-server {} --restore-time {}'
.format(database_engine, resource_group, restore_server_name, server_name, restore_time),
checks=[JMESPathCheck('name', restore_server_name),
JMESPathCheck('resourceGroup', resource_group)])
self.cmd('{} flexible-server restart -g {} -n {}'
.format(database_engine, resource_group, server_name), checks=NoneCheck())
self.cmd('{} flexible-server stop -g {} -n {}'
.format(database_engine, resource_group, server_name), checks=NoneCheck())
self.cmd('{} flexible-server start -g {} -n {}'
.format(database_engine, resource_group, server_name), checks=NoneCheck())
self.cmd('{} flexible-server list -g {}'.format(database_engine, resource_group),
checks=[JMESPathCheck('type(@)', 'array')])
connection_string = self.cmd('{} flexible-server show-connection-string -s {}'
.format(database_engine, server_name)).get_output_in_json()
self.assertIn('jdbc', connection_string['connectionStrings'])
self.assertIn('node.js', connection_string['connectionStrings'])
self.assertIn('php', connection_string['connectionStrings'])
self.assertIn('python', connection_string['connectionStrings'])
self.cmd('{} flexible-server list-skus -l {}'.format(database_engine, location),
checks=[JMESPathCheck('type(@)', 'array')])
self.cmd('{} flexible-server delete -g {} -n {} --yes'.format(database_engine, resource_group, server_name), checks=NoneCheck())
def test_portal(self, resource_group):
self.kwargs.update({
'testDashboard':
self.create_random_name(prefix='cli_test_dashboards'[:9],
length=24)
})
self.cmd(
'az portal dashboard create '
'--location "eastus" '
'--input- "src/portal/azext_portal/tests/latest/properties.json" '
'--tags aKey=aValue anotherKey=anotherValue '
'--name "{testDashboard}" '
'--resource-group "{rg}"',
checks=[
JMESPathCheck('name', self.kwargs.get('testDashboard', ''))
])
self.cmd(
'az portal dashboard show '
'--name "{testDashboard}" '
'--resource-group "{rg}"',
checks=[
JMESPathCheck('name', self.kwargs.get('testDashboard', '')),
JMESPathCheck('resourceGroup', self.kwargs.get('rg', '')),
JMESPathCheck(
'tags',
'{\'aKey\': \'aValue\', \'anotherKey\': \'anotherValue\'}'
),
JMESPathCheck(
'lenses',
'{\'0\': {\'metadata\': None, \'order\': 0, \'parts\': '
'{\'0\': {\'metadata\': {\'inputs\': [], \'settings\': {}, \'type\': '
'\'Extension/HubsExtension/PartType/ClockPart\'}, \'position\': {\'colSpan\': 2, '
'\'metadata\': None, \'rowSpan\': 2, \'x\': 6, \'y\': 2}}}}}'
),
JMESPathCheck(
'metadata', '{\'model\': {\'timeRange\': {\'type\': '
'\'MsPortalFx.Composition.Configuration.ValueTypes.TimeRange\', \'value\': '
'{\'relative\': {\'duration\': 24, \'timeUnit\': 1}}}}}')
])
self.cmd(
'az portal dashboard list '
'--resource-group "{rg}"',
checks=[
JMESPathCheckExists('[?name==\'{}\']'.format(
self.kwargs.get('testDashboard', '')))
])
self.cmd(
'az portal dashboard list '
'--resource-group=',
checks=[
JMESPathCheckExists('[?name==\'{}\']'.format(
self.kwargs.get('testDashboard', '')))
])
self.cmd(
'az portal dashboard update '
'--input-path "src/portal/azext_portal/tests/latest/properties-update.json" '
'--name "{testDashboard}" '
'--resource-group "{rg}"',
checks=[
JMESPathCheck('name', self.kwargs.get('testDashboard', '')),
JMESPathCheck('resourceGroup', self.kwargs.get('rg', '')),
JMESPathCheck(
'tags',
'{\'aKey\': \'aValue\', \'anotherKey\': \'anotherValue\'}'
),
JMESPathCheck(
'lenses',
'{\'0\': {\'metadata\': None, \'order\': 0, \'parts\': '
'{\'0\': {\'metadata\': {\'inputs\': [], \'settings\': {}, \'type\': '
'\'Extension/HubsExtension/PartType/ClockPart\'}, \'position\': {\'colSpan\': 2, '
'\'metadata\': None, \'rowSpan\': 2, \'x\': 6, \'y\': 2}}}}}'
),
JMESPathCheck(
'metadata', '{\'model\': {\'timeRange\': {\'type\': '
'\'MsPortalFx.Composition.Configuration.ValueTypes.TimeRange\', \'value\': '
'{\'relative\': {\'duration\': 12, \'timeUnit\': 1}}}}}')
])
self.cmd(
'az portal dashboard delete '
'--name "{testDashboard}" '
'--resource-group "{rg}" '
'--y',
checks=[])
self.cmd('az portal dashboard list '
'--resource-group "{rg}"',
checks=[NoneCheck()])
self.cmd(
'az portal dashboard import '
'--input-path "src/portal/azext_portal/tests/latest/dashboard.json" '
'--name "{testDashboard}" '
'--resource-group "{rg}"',
checks=[
JMESPathCheck('name', '7c0464ec-b1cd-4a98-a4a5-1ebe2d980260'),
JMESPathCheck('resourceGroup', self.kwargs.get('rg', '')),
JMESPathCheck('location', 'eastus'),
JMESPathCheck('type', 'Microsoft.Portal/dashboards'),
JMESPathCheck('tags',
'{\'hidden-title\': \'test dashboard\'}'),
JMESPathCheck(
'lenses',
'{\'0\': {\'metadata\': None, \'order\': 0, \'parts\': '
'{\'0\': {\'metadata\': {\'inputs\': [{\'isOptional\': True, \'name\': '
'\'resourceType\', \'value\': \'Microsoft.Resources/subscriptions/resourcegroups\'},'
' {\'isOptional\': True, \'name\': \'filter\'}, {\'isOptional\': True, \'name\':'
' \'scope\'}, {\'isOptional\': True, \'name\': \'kind\'}], \'type\': '
'\'Extension/HubsExtension/PartType/BrowseResourceGroupPinnedPart\'}, \'position\': '
'{\'colSpan\': 6, \'metadata\': None, \'rowSpan\': 4, \'x\': 0, \'y\': 0}}}}}'
),
JMESPathCheck(
'metadata', '{\'model\': {\'timeRange\': {\'type\': '
'\'MsPortalFx.Composition.Configuration.ValueTypes.TimeRange\', \'value\': '
'{\'relative\': {\'duration\': 24, \'timeUnit\': 1}}}}}')
])
def _verify_access_control_list(self, account_info, service_type,
container_name):
container_id_parameter = '--{}-name {}'.format(service_type,
container_name)
self.storage_cmd(
'storage {} policy list {}', account_info, service_type,
container_id_parameter).assert_with_checks(NoneCheck())
self.storage_cmd('storage {} policy create {} -n test1 --permission l',
account_info, service_type, container_id_parameter)
self.storage_cmd(
'storage {} policy create {} -n test2 --start 2016-01-01T00:00Z',
account_info, service_type, container_id_parameter)
self.storage_cmd(
'storage {} policy create {} -n test3 --expiry 2018-01-01T00:00Z',
account_info, service_type, container_id_parameter)
self.storage_cmd(
'storage {} policy create {} -n test4 --permission rwdl '
'--start 2016-01-01T00:00Z --expiry 2016-05-01T00:00Z',
account_info, service_type, container_id_parameter)
acl = self.storage_cmd(
'storage {} policy list {}', account_info, service_type,
container_id_parameter).get_output_in_json().keys()
self.assertSetEqual(set(acl), set(['test1', 'test2', 'test3',
'test4']))
self.storage_cmd('storage {} policy show {} -n test1', account_info,
service_type,
container_id_parameter).assert_with_checks(
JMESPathCheck('permission', 'l'))
self.storage_cmd('storage {} policy show {} -n test2', account_info,
service_type,
container_id_parameter).assert_with_checks(
JMESPathCheck('start',
'2016-01-01T00:00:00+00:00'))
self.storage_cmd('storage {} policy show {} -n test3', account_info,
service_type,
container_id_parameter).assert_with_checks(
JMESPathCheck('expiry',
'2018-01-01T00:00:00+00:00'))
self.storage_cmd('storage {} policy show {} -n test4', account_info,
service_type,
container_id_parameter).assert_with_checks(
JMESPathCheck('start',
'2016-01-01T00:00:00+00:00'),
JMESPathCheck('expiry',
'2016-05-01T00:00:00+00:00'),
JMESPathCheck('permission', 'rwdl'))
self.storage_cmd('storage {} policy update {} -n test1 --permission r',
account_info, service_type, container_id_parameter)
self.storage_cmd('storage {} policy show {} -n test1', account_info,
service_type,
container_id_parameter).assert_with_checks(
JMESPathCheck('permission', 'r'))
self.storage_cmd('storage {} policy delete {} -n test1', account_info,
service_type, container_id_parameter)
acl = self.storage_cmd(
'storage {} policy list {}', account_info, service_type,
container_id_parameter).get_output_in_json().keys()
self.assertSequenceEqual(set(acl), set(['test2', 'test3', 'test4']))
def test_sqlvm_mgmt(self, resource_group, resource_group_location, sqlvm,
storage_account):
loc = 'westus'
self.cmd(
'storage account update -n {} -g {} --set kind=StorageV2'.format(
storage_account, resource_group))
sa = self.cmd('storage account show -n {} -g {}'.format(
storage_account, resource_group)).get_output_in_json()
key = self.cmd('storage account keys list -n {} -g {}'.format(
storage_account, resource_group)).get_output_in_json()
# Assert customer cannot create a SQL vm with no agent and do not provide offer and sku
with self.assertRaisesRegexp(
CLIError,
"usage error: --sql-mgmt-type NoAgent --image-sku NAME --image-offer NAME"
):
self.cmd(
'sql vm create -n {} -g {} -l {} --license-type {} --sql-mgmt-type {}'
.format(sqlvm, resource_group, loc, 'PAYG', 'NoAgent'))
# test create sqlvm with minimal required parameters
sqlvm_1 = self.cmd(
'sql vm create -n {} -g {} -l {} --license-type {}'.format(
sqlvm, resource_group, loc, 'PAYG'),
checks=[
JMESPathCheck('name', sqlvm),
JMESPathCheck('location', loc),
JMESPathCheck('sqlServerLicenseType', 'PAYG'),
JMESPathCheck('sqlManagement', 'LightWeight')
]).get_output_in_json()
# test list sqlvm should be 1
self.cmd('sql vm list -g {}'.format(resource_group),
checks=[JMESPathCheck('length(@)', 1)])
# test show of vm
self.cmd('sql vm show -n {} -g {}'.format(sqlvm, resource_group),
checks=[
JMESPathCheck('name', sqlvm),
JMESPathCheck('location', loc),
JMESPathCheck('provisioningState', "Succeeded"),
JMESPathCheck('id', sqlvm_1['id'])
])
# Check the id of the vm is correct in show
self.cmd('sql vm show -n {} -g {}'.format(sqlvm, resource_group),
checks=[
JMESPathCheck('name', sqlvm),
JMESPathCheck('id', sqlvm_1['id'])
])
# test update sqlvm with management mode to make sure it updates to full.
self.cmd('sql vm update -n {} -g {} --sql-mgmt-type {} --yes'.format(
sqlvm, resource_group, 'Full'),
checks=[
JMESPathCheck('name', sqlvm),
JMESPathCheck('location', loc),
JMESPathCheck('sqlManagement', 'Full')
]).get_output_in_json()
# test expand parameter: * - all settings exist
expand_all = self.cmd('sql vm show -n {} -g {} --expand {}'.format(
sqlvm, resource_group, '*')).get_output_in_json()
assert 'autoBackupSettings' in expand_all
assert 'autoPatchingSettings' in expand_all
assert 'keyVaultCredentialSettings' in expand_all
assert 'serverConfigurationsManagementSettings' in expand_all
# test expand parameter: single value - only specified setting exists
expand_one = self.cmd('sql vm show -n {} -g {} --expand {}'.format(
sqlvm, resource_group, 'AutoBackupSettings')).get_output_in_json()
assert 'autoBackupSettings' in expand_one
assert 'autoPatchingSettings' not in expand_one
assert 'keyVaultCredentialSettings' not in expand_one
assert 'serverConfigurationsManagementSettings' not in expand_one
# test expand parameter: comma-separated values - all specificed settings exist
expand_comma = self.cmd('sql vm show -n {} -g {} --expand {}'.format(
sqlvm, resource_group,
'AutoPatchingSettings AutoBackupSettings')).get_output_in_json()
assert 'autoBackupSettings' in expand_comma
assert 'autoPatchingSettings' in expand_comma
assert 'keyVaultCredentialSettings' not in expand_comma
assert 'serverConfigurationsManagementSettings' not in expand_comma
# test expand parameter: comma-separated values with * - all settings exist
expand_comma_all = self.cmd(
'sql vm show -n {} -g {} --expand {}'.format(
sqlvm, resource_group,
'AutoPatchingSettings * AutoBackupSettings')
).get_output_in_json()
assert 'autoBackupSettings' in expand_comma_all
assert 'autoPatchingSettings' in expand_comma_all
assert 'keyVaultCredentialSettings' in expand_comma_all
assert 'serverConfigurationsManagementSettings' in expand_comma_all
# test license change
self.cmd('sql vm update -n {} -g {} --license-type {}'.format(
sqlvm, resource_group, 'AHUB'),
checks=[
JMESPathCheck('name', sqlvm),
JMESPathCheck('location', loc),
JMESPathCheck('provisioningState', "Succeeded"),
JMESPathCheck('id', sqlvm_1['id']),
JMESPathCheck('sqlServerLicenseType', 'AHUB')
])
# test enabling R services
self.cmd('sql vm update -n {} -g {} --enable-r-services {}'.format(
sqlvm, resource_group, True),
checks=[
JMESPathCheck('name', sqlvm),
JMESPathCheck('location', loc),
JMESPathCheck('provisioningState', "Succeeded"),
JMESPathCheck('id', sqlvm_1['id'])
])
# test autopatching enabling succeeds
self.cmd(
'sql vm update -n {} -g {} --day-of-week {} --maintenance-window-duration {} --maintenance-window-start-hour {}'
.format(sqlvm, resource_group, 'Monday', 60, 22),
checks=[
JMESPathCheck('name', sqlvm),
JMESPathCheck('location', loc),
JMESPathCheck('provisioningState', "Succeeded"),
JMESPathCheck('id', sqlvm_1['id'])
])
# test autopatching disabling succeeds
self.cmd('sql vm update -n {} -g {} --enable-auto-patching {}'.format(
sqlvm, resource_group, False),
checks=[
JMESPathCheck('name', sqlvm),
JMESPathCheck('location', loc),
JMESPathCheck('provisioningState', "Succeeded"),
JMESPathCheck('id', sqlvm_1['id'])
])
# test backup enabling works
self.cmd(
'sql vm update -n {} -g {} --backup-schedule-type {} --full-backup-frequency {} --full-backup-start-hour {} --full-backup-duration {} '
'--sa-key {} --storage-account {} --retention-period {} --log-backup-frequency {}'
.format(sqlvm, resource_group, 'Manual', 'Weekly', 2, 2,
key[0]['value'], sa['primaryEndpoints']['blob'], 30, 60),
checks=[
JMESPathCheck('name', sqlvm),
JMESPathCheck('location', loc),
JMESPathCheck('provisioningState', "Succeeded"),
JMESPathCheck('id', sqlvm_1['id'])
])
# test delete vm
self.cmd('sql vm delete -n {} -g {} --yes'.format(
sqlvm, resource_group),
checks=NoneCheck())
# test list sql vm should be empty
self.cmd('sql vm list -g {}'.format(resource_group),
checks=[NoneCheck()])
def _test_mgmt_validator(self, database_engine, resource_group):
RANDOM_VARIABLE_MAX_LENGTH = 30
if database_engine == 'postgres':
location = self.postgres_location
elif database_engine == 'mysql':
location = self.mysql_location
invalid_version = self.create_random_name('version',
RANDOM_VARIABLE_MAX_LENGTH)
invalid_sku_name = self.create_random_name('sku_name',
RANDOM_VARIABLE_MAX_LENGTH)
invalid_tier = self.create_random_name('tier',
RANDOM_VARIABLE_MAX_LENGTH)
valid_tier = 'GeneralPurpose'
invalid_backup_retention = 1
# Create
self.cmd('{} flexible-server create -g {} -l {} --tier {}'.format(
database_engine, resource_group, location, invalid_tier),
expect_failure=True)
self.cmd('{} flexible-server create -g {} -l {} --version {}'.format(
database_engine, resource_group, location, invalid_version),
expect_failure=True)
self.cmd(
'{} flexible-server create -g {} -l {} --tier {} --sku-name {}'.
format(database_engine, resource_group, location, valid_tier,
invalid_sku_name),
expect_failure=True)
self.cmd('{} flexible-server create -g {} -l {} --backup-retention {}'.
format(database_engine, resource_group, location,
invalid_backup_retention),
expect_failure=True)
if database_engine == 'postgres':
invalid_storage_size = 60
elif database_engine == 'mysql':
invalid_storage_size = 999999
self.cmd(
'{} flexible-server create -g {} -l {} --storage-size {}'.format(
database_engine, resource_group, location,
invalid_storage_size),
expect_failure=True)
server_name = self.create_random_name(SERVER_NAME_PREFIX,
RANDOM_VARIABLE_MAX_LENGTH)
if database_engine == 'postgres':
tier = 'MemoryOptimized'
version = 12
sku_name = 'Standard_E2s_v3'
storage_size = 64
elif database_engine == 'mysql':
tier = 'GeneralPurpose'
version = 5.7
sku_name = 'Standard_D2ds_v4'
storage_size = 20
storage_size_mb = storage_size * 1024
backup_retention = 10
list_checks = [
JMESPathCheck('name', server_name),
JMESPathCheck('resourceGroup', resource_group),
JMESPathCheck('sku.name', sku_name),
JMESPathCheck('sku.tier', tier),
JMESPathCheck('version', version),
JMESPathCheck('storageProfile.storageMb', storage_size_mb),
JMESPathCheck('storageProfile.backupRetentionDays',
backup_retention)
]
self.cmd(
'{} flexible-server create -g {} -n {} -l {} --tier {} --version {} --sku-name {} --storage-size {} --backup-retention {}'
.format(database_engine, resource_group, server_name, location,
tier, version, sku_name, storage_size, backup_retention))
self.cmd('{} flexible-server show -g {} -n {}'.format(
database_engine, resource_group, server_name),
checks=list_checks)
# Update
invalid_storage_size_small = storage_size - 1
self.cmd('{} flexible-server update -g {} -n {} --tier {}'.format(
database_engine, resource_group, server_name, invalid_tier),
expect_failure=True)
self.cmd(
'{} flexible-server update -g {} -n {} --tier {} --sku-name {}'.
format(database_engine, resource_group, server_name, valid_tier,
invalid_sku_name),
expect_failure=True)
self.cmd(
'{} flexible-server update -g {} -n {} --storage-size {}'.format(
database_engine, resource_group, server_name,
invalid_storage_size_small),
expect_failure=True)
self.cmd('{} flexible-server update -g {} -n {} --backup-retention {}'.
format(database_engine, resource_group, server_name,
invalid_backup_retention),
expect_failure=True)
self.cmd('{} flexible-server delete -g {} -n {} --force'.format(
database_engine, resource_group, server_name),
checks=NoneCheck())
def test_keyvault_key(self, resource_group):
self.resource_group = resource_group
kv = self.create_random_name('cli-test-keyvault-', 24)
self.location = 'westus'
_create_keyvault(self, kv, self.resource_group, self.location)
# create a key
key = self.cmd('keyvault key create --vault-name {} -n key1 -p software'.format(kv),
checks=JMESPathCheck('attributes.enabled', True)).get_output_in_json()
first_kid = key['key']['kid']
first_version = first_kid.rsplit('/', 1)[1]
# list keys
self.cmd('keyvault key list --vault-name {}'.format(kv),
checks=JMESPathCheck('length(@)', 1))
# create a new key version
key = self.cmd('keyvault key create --vault-name {} -n key1 -p software --disabled --ops encrypt decrypt --tags test=foo'.format(kv), checks=[
JMESPathCheck('attributes.enabled', False),
JMESPathCheck('length(key.keyOps)', 2),
JMESPathCheck('tags', {'test': 'foo'})
]).get_output_in_json()
second_kid = key['key']['kid']
# list key versions
self.cmd('keyvault key list-versions --vault-name {} -n key1'.format(kv),
checks=JMESPathCheck('length(@)', 2))
# show key (latest)
self.cmd('keyvault key show --vault-name {} -n key1'.format(kv),
checks=JMESPathCheck('key.kid', second_kid))
# show key (specific version)
self.cmd('keyvault key show --vault-name {} -n key1 -v {}'.format(kv, first_version),
checks=JMESPathCheck('key.kid', first_kid))
# set key attributes
self.cmd('keyvault key set-attributes --vault-name {} -n key1 --enabled true'.format(kv), checks=[
JMESPathCheck('key.kid', second_kid),
JMESPathCheck('attributes.enabled', True)
])
# backup and then delete key
key_file = 'backup.key'
self.cmd('keyvault key backup --vault-name {} -n key1 --file {}'.format(kv, key_file))
self.cmd('keyvault key delete --vault-name {} -n key1'.format(kv))
self.cmd('keyvault key list --vault-name {}'.format(kv),
checks=NoneCheck())
# restore key from backup
self.cmd('keyvault key restore --vault-name {} --file {}'.format(kv, key_file))
self.cmd('keyvault key list-versions --vault-name {} -n key1'.format(kv),
checks=JMESPathCheck('length(@)', 2))
if os.path.isfile(key_file):
os.remove(key_file)
# import PEM
key_enc_file = os.path.join(TEST_DIR, 'mydomain.test.encrypted.pem')
key_enc_password = '******'
key_plain_file = os.path.join(TEST_DIR, 'mydomain.test.pem')
self.cmd('keyvault key import --vault-name {} -n import-key-plain --pem-file "{}" -p software'.format(kv, key_plain_file))
self.cmd('keyvault key import --vault-name {} -n import-key-encrypted --pem-file "{}" --pem-password {} -p hsm'.format(kv, key_enc_file, key_enc_password))
