def test_mgmt_batch_byos_account(self, resource_group, location, keyvault):
if self.is_live:
keyvault = keyvault.result()
batch_account = models.BatchAccountCreateParameters(
location=location,
pool_allocation_mode=models.PoolAllocationMode.user_subscription)
with self.assertRaises(Exception): # TODO: What exception
creating = self.mgmt_batch_client.batch_account.create(
resource_group.name,
self._get_account_name(),
batch_account)
creating.result()
keyvault_id = "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.KeyVault/vaults/{}".format(
self.settings.SUBSCRIPTION_ID, resource_group.name, keyvault.name)
keyvault_url = "https://{}.vault.azure.net/".format(keyvault.name)
batch_account = models.BatchAccountCreateParameters(
location=location,
pool_allocation_mode=models.PoolAllocationMode.user_subscription,
key_vault_reference={'id': keyvault_id, 'url': keyvault_url})
creating = self.mgmt_batch_client.batch_account.create(
resource_group.name,
self._get_account_name(),
batch_account)
creating.result()
def create_resource(self, name, **kwargs):
if self.is_live:
self.client = self.create_mgmt_client(
azure.mgmt.batch.BatchManagementClient)
group = self._get_resource_group(**kwargs)
batch_account = models.BatchAccountCreateParameters(
location=self.location, )
storage = self._get_storage_account(**kwargs)
if storage:
storage_resource = '/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Storage/storageAccounts/{}'.format(
self.test_class_instance.settings.SUBSCRIPTION_ID,
group.name, storage.name)
batch_account.auto_storage = models.AutoStorageBaseProperties(
storage_account_id=storage_resource)
account_setup = self.client.batch_account.create(
group.name, name, batch_account)
self.resource = account_setup.result()
keys = self.client.batch_account.get_keys(group.name, name)
credentials = SharedKeyCredentials(keys.account_name, keys.primary)
if storage:
self._add_app_package(group.name, name)
self.test_class_instance.scrubber.register_name_pair(
name, self.resource_moniker)
else:
self.resource = FakeAccount(
name=name,
account_endpoint="https://{}.{}.batch.azure.com".format(
name, self.location))
credentials = SharedKeyCredentials(name,
'ZmFrZV9hY29jdW50X2tleQ==')
return {
self.parameter_name: self.resource,
self.creds_parameter: credentials
}
def test_mgmt_batch_byos_account(self, resource_group, location):
# if self.is_live:
# keyvault = keyvault.result()
batch_account = models.BatchAccountCreateParameters(
location=location,
pool_allocation_mode=models.PoolAllocationMode.user_subscription)
with pytest.raises(Exception): # TODO: What exception
creating = self.mgmt_batch_client.batch_account.begin_create(
resource_group.name, self._get_account_name(), batch_account)
creating.result()
def test_mgmt_batch_account(self, resource_group, location):
batch_account = models.BatchAccountCreateParameters(
location=location, )
account_name = self._get_account_name()
account_setup = self.mgmt_batch_client.batch_account.begin_create(
resource_group.name, account_name, batch_account)
account_setup.result()
# Test Get Account
account = self.mgmt_batch_client.batch_account.get(
resource_group.name, account_name)
self.assertEqual(account.dedicated_core_quota,
EXPECTED_DEDICATED_CORE_QUOTA)
self.assertEqual(account.low_priority_core_quota,
EXPECTED_LOW_PRIO_CORE_QUOTA)
self.assertEqual(account.pool_quota, EXPECTED_POOL_QUOTA)
self.assertEqual(account.pool_allocation_mode, 'BatchService')
# Test List Accounts by Resource Group
accounts = self.mgmt_batch_client.batch_account.list_by_resource_group(
resource_group.name)
self.assertEqual(len(list(accounts)), 1)
# Test List Account Keys
keys = self.mgmt_batch_client.batch_account.get_keys(
resource_group.name, account_name)
self.assertIsInstance(keys, models.BatchAccountKeys)
self.assertEqual(keys.account_name, account_name)
secondary = keys.secondary
# Test Regenerate Account Key
keys = self.mgmt_batch_client.batch_account.regenerate_key(
resource_group.name, account_name, {"key_name": 'Secondary'})
self.assertIsInstance(keys, models.BatchAccountKeys)
self.assertFalse(keys.secondary == secondary)
# Test Update Account
update_tags = {'Name': 'tagName', 'Value': 'tagValue'}
updated = self.mgmt_batch_client.batch_account.update(
resource_group.name, account_name,
models.BatchAccountUpdateParameters(tags=update_tags))
self.assertIsInstance(updated, models.BatchAccount)
self.assertEqual(updated.tags['Name'], 'tagName')
self.assertEqual(updated.tags['Value'], 'tagValue')
# Test Delete Account
response = self.mgmt_batch_client.batch_account.begin_delete(
resource_group.name, account_name)
self.assertIsNone(response.result())
def test_mgmt_batch_account_advanced(self, resource_group, location):
batch_account_name = self.get_resource_name('batchpendpoint')
vnet_name = self.get_resource_name('vnet')
subnet_name = self.get_resource_name('subnet')
subnet_id = "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/virtualNetworks/{}/subnets/{}".format(
self.get_settings_value("SUBSCRIPTION_ID"), resource_group.name,
vnet_name, subnet_name)
private_endpoint_name = self.get_resource_name('pe')
private_connection_name = self.get_resource_name('pec')
private_link_service_id = '/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Batch/batchAccounts/{}'.format(
self.get_settings_value("SUBSCRIPTION_ID"), resource_group.name,
batch_account_name)
batch_account = models.BatchAccountCreateParameters(
location=location,
public_network_access='Disabled',
identity=models.BatchAccountIdentity(type='SystemAssigned'))
self.mgmt_batch_client.batch_account.begin_create(
resource_group_name=resource_group.name,
account_name=batch_account_name,
parameters=batch_account).result()
if self.is_live:
self.mgmt_network.virtual_networks.begin_create_or_update(
resource_group_name=resource_group.name,
virtual_network_name=vnet_name,
parameters=self.mgmt_network.models().VirtualNetwork(
address_space=self.mgmt_network.models().AddressSpace(
address_prefixes=['10.0.0.0/16']),
location=location,
subnets=[
self.mgmt_network.models().Subnet(
address_prefix='10.0.0.0/24',
name=subnet_name,
private_endpoint_network_policies='Disabled')
])).result()
self.mgmt_network.private_endpoints.begin_create_or_update(
resource_group_name=resource_group.name,
private_endpoint_name=private_endpoint_name,
parameters=self.mgmt_network.models().PrivateEndpoint(
location=location,
subnet=self.mgmt_network.models().Subnet(id=subnet_id),
manual_private_link_service_connections=[
self.mgmt_network.models().
PrivateLinkServiceConnection(
private_link_service_id=private_link_service_id,
group_ids=['batchAccount'],
name=private_connection_name)
])).result()
private_links = self.mgmt_batch_client.private_link_resource.list_by_batch_account(
resource_group_name=resource_group.name,
account_name=batch_account_name)
private_link = private_links.__next__()
self.mgmt_batch_client.private_link_resource.get(
resource_group_name=resource_group.name,
account_name=batch_account_name,
private_link_resource_name=private_link.name)
private_endpoints = self.mgmt_batch_client.private_endpoint_connection.list_by_batch_account(
resource_group_name=resource_group.name,
account_name=batch_account_name)
private_endpoint = private_endpoints.__next__()
self.mgmt_batch_client.private_endpoint_connection.get(
resource_group_name=resource_group.name,
account_name=batch_account_name,
private_endpoint_connection_name=private_endpoint.name)
self.mgmt_batch_client.private_endpoint_connection.begin_update(
resource_group_name=resource_group.name,
account_name=batch_account_name,
private_endpoint_connection_name=private_endpoint.name,
parameters={
"private_link_service_connection_state": {
"status": "Approved",
"description": "Approved for test"
}
}).result()
def test_mgmt_batch_applications(self, resource_group, location,
storage_account, storage_account_key):
# Test Create Account with Auto-Storage
storage_resource = '/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Storage/storageAccounts/{}'.format(
self.get_settings_value("SUBSCRIPTION_ID"), resource_group.name,
storage_account.name)
batch_account = models.BatchAccountCreateParameters(
location=location,
auto_storage=models.AutoStorageBaseProperties(
storage_account_id=storage_resource))
# account_name = self._get_account_name()
account_name = "batch11"
account_setup = self.mgmt_batch_client.batch_account.begin_create(
resource_group.name, account_name, batch_account)
account_setup.result()
# Test Sync AutoStorage Keys
response = self.mgmt_batch_client.batch_account.synchronize_auto_storage_keys(
resource_group.name, account_name)
assert response is None
# Test Add Application
application_id = 'my_application_id'
application_name = 'my_application_name'
application_ver = 'v1.0'
application_properties = models.Application(
display_name=application_name, allow_updates=True)
application = self.mgmt_batch_client.application.create(
resource_group.name,
account_name,
application_id,
parameters=application_properties)
assert isinstance(application, models.Application)
assert application_id in application.id
assert application_name in application.display_name
assert application.allow_updates
# Test Mgmt Get Application
application = self.mgmt_batch_client.application.get(
resource_group.name, account_name, application_id)
assert isinstance(application, models.Application)
assert application_id in application.id
assert application_name in application.display_name
assert application.allow_updates
# Test Mgmt List Applications
applications = self.mgmt_batch_client.application.list(
resource_group.name, account_name)
assert len(list(applications)) > 0
# Test Add Application Package
package_ref = self.mgmt_batch_client.application_package.create(
resource_group.name, account_name, application_id, application_ver)
assert isinstance(package_ref, models.ApplicationPackage)
with io.BytesIO(b'Hello World') as f:
headers = {'x-ms-blob-type': 'BlockBlob'}
upload = requests.put(package_ref.storage_url,
headers=headers,
data=f.read())
if not upload:
raise ValueError('Upload failed: {!r}'.format(upload))
# Test Activate Application Package
response = self.mgmt_batch_client.application_package.activate(
resource_group.name, account_name, application_id, application_ver,
{"format": 'zip'})
assert response.state == models.PackageState.active
# Test Update Application
params = models.Application(allow_updates=False,
display_name='my_updated_name',
default_version=application_ver)
response = self.mgmt_batch_client.application.update(
resource_group.name, account_name, application_id, params)
assert application_ver in response.default_version
assert 'my_updated_name' in response.display_name
assert not response.allow_updates
# Test Get Application Package
package_ref = self.mgmt_batch_client.application_package.get(
resource_group.name, account_name, application_id, application_ver)
assert isinstance(package_ref, models.ApplicationPackage)
assert application_id in package_ref.id
assert package_ref.format == 'zip'
assert package_ref.state == models.PackageState.active
# Test Delete Application Package
response = self.mgmt_batch_client.application_package.delete(
resource_group.name, account_name, application_id, application_ver)
assert response is None
# Test Delete Application
response = self.mgmt_batch_client.application.delete(
resource_group.name, account_name, application_id)
assert response is None
# Test Delete Account
response = self.mgmt_batch_client.batch_account.begin_delete(
resource_group.name, account_name)
assert response.result() is None
