def test_conflict_availability_set(self):
ctx = self.mock_ctx('testconflictavailabilityset')
current_ctx.set(ctx=ctx)
ctx.logger.info("BEGIN conflict availability_set test")
ctx.logger.info("create availability_set")
self.assertEqual(200, availability_set.create(ctx=ctx))
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "availability_set",constants.SUCCEEDED, 600)
ctx.logger.info("create conflict availability_set")
self.assertEqual(200, availability_set.create(ctx=ctx))
ctx.logger.info("delete availability_set")
self.assertEqual(200, availability_set.delete(ctx=ctx))
try:
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "availability_set","deleting", 600)
except utils.WindowsAzureError:
pass
ctx.logger.info("delete conflict availability_set")
self.assertEqual(204, availability_set.delete(ctx=ctx))
ctx.logger.info("END conflict availability_set test")
def test_fail_create_datadisk(self):
# Disks are limited to a maximum of 1TB
disk = [{'name': 'disk_fail_1',
'size': 5000,
'deletable': True,
'caching': 'None'
}]
test_name = 'test-fail-create-datadisk'
ctx = self.mock_ctx(test_name, disk)
current_ctx.set(ctx=ctx)
ctx.logger.info("BEGIN create VM test: {}".format(test_name))
instance.create(ctx=ctx)
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, 'instance',timeout=900)
current_ctx.set(ctx=ctx)
self.assertRaises(utils.WindowsAzureError,
datadisks.create,
ctx=ctx
)
current_ctx.set(ctx=ctx)
ctx.logger.info("BEGIN delete VM test: {}".format(test_name))
instance.delete(ctx=ctx)
try:
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, 'instance',
constants.DELETING, timeout=900)
except utils.WindowsAzureError:
pass
def test_conflict_public_ip(self):
ctx = self.mock_ctx('testconflictip')
current_ctx.set(ctx=ctx)
ctx.logger.info("BEGIN conflict public_ip test")
ctx.logger.info("create public_ip")
status_code = public_ip.create(ctx=ctx)
ctx.logger.debug("status_code =" + str(status_code) )
self.assertTrue(bool((status_code == 200) or (status_code == 201)))
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "public_ip",constants.SUCCEEDED, timeout=600)
status_code = public_ip.create(ctx=ctx)
ctx.logger.debug("status_code =" + str(status_code) )
self.assertTrue(bool((status_code == 200) or (status_code == 201)))
ctx.logger.info("delete public_ip")
self.assertEqual(202, public_ip.delete(ctx=ctx))
try:
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "public_ip","waiting for exception", timeout=600)
except utils.WindowsAzureError:
pass
ctx.logger.info("delete conflict public_ip")
self.assertEqual(204, public_ip.delete(ctx=ctx))
ctx.logger.info("END conflict public_ip test")
def test_conflict_storage(self):
ctx = self.mock_ctx('testconflictstorage')
current_ctx.set(ctx=ctx)
ctx.logger.info("BEGIN test conflict storage")
status_code = storage.create(ctx=ctx)
ctx.logger.info("status_code : " + str(status_code))
self.assertTrue(bool((status_code == 200) | (status_code == 202)))
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "storage", constants.SUCCEEDED, timeout=600)
ctx.logger.info("Storage Account Created")
ctx.logger.info("Conflict Creating Storage Account")
self.assertEqual(409, storage.create(ctx=ctx))
self.assertEqual(200, storage.delete(ctx=ctx))
ctx.logger.info("Check is Storage Account is release")
current_ctx.set(ctx=ctx)
self.assertRaises(utils.WindowsAzureError,
storage.get_provisioning_state,
ctx=ctx
)
ctx.logger.info("Storage Account Deleted")
ctx.logger.info("END test conflict storage")
def delete(**_):
"""Delete an instance.
:param ctx: The Cloudify ctx context.
:return: The status code of the REST request.
:rtype: int
"""
utils.validate_node_property(constants.COMPUTE_KEY, ctx.node.properties)
azure_config = utils.get_azure_config(ctx)
subscription_id = azure_config[constants.SUBSCRIPTION_KEY]
resource_group_name = azure_config[constants.RESOURCE_GROUP_KEY]
api_version = constants.AZURE_API_VERSION_06
vm_name = ctx.node.properties[constants.COMPUTE_KEY]
ctx.logger.info('Deleting vm {}.'.format(vm_name))
response = connection.AzureConnectionClient().azure_delete(
ctx,
("subscriptions/{}/resourceGroups/{}/providers/Microsoft.Compute" +
"/virtualMachines/{}?api-version={}").format(subscription_id,
resource_group_name,
vm_name, api_version
)
)
# wait vm deletion
try:
utils.wait_status(ctx, 'instance', 'waiting for exception')
except utils.WindowsAzureError:
pass
return response.status_code
def test_delete_public_ip(self):
ctx = self.mock_ctx('testdeleteip')
current_ctx.set(ctx=ctx)
ctx.logger.info("BEGIN public_ip delete test")
ctx.logger.info("create public ip with deletable propertie set to False")
ctx.node.properties[constants.DELETABLE_KEY] = False
status_code = public_ip.create(ctx=ctx)
ctx.logger.debug("status_code =" + str(status_code) )
self.assertTrue(bool((status_code == 200) or (status_code == 201)))
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "public_ip",constants.SUCCEEDED, timeout=600)
ctx.logger.info("not delete public ip")
self.assertEqual(0, public_ip.delete(ctx=ctx))
ctx.logger.info("Set deletable propertie to True")
ctx.node.properties[constants.DELETABLE_KEY] = True
ctx.logger.info("delete public ip")
self.assertEqual(202, public_ip.delete(ctx=ctx))
try:
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "public_ip","waiting for exception", timeout=600)
except utils.WindowsAzureError:
pass
ctx.logger.info("END public_ip delete test")
def test_delete_subnet(self):
ctx = self.mock_ctx("testdeletesubnet", cdir="10.0.3.0/24")
ctx.logger.info("BEGIN test_delete_subnet")
current_ctx.set(ctx=ctx)
status_code = subnet.create(ctx=ctx)
ctx.logger.debug("status_code =" + str(status_code))
self.assertTrue(bool((status_code == 200) or (status_code == 201)))
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "subnet", constants.SUCCEEDED, timeout=600)
current_ctx.set(ctx=ctx)
ctx.logger.info("create subnet with deletable propertie set to False")
ctx.node.properties[constants.DELETABLE_KEY] = False
ctx.logger.info("not delete subnet")
self.assertEqual(0, subnet.delete(ctx=ctx))
current_ctx.set(ctx=ctx)
ctx.logger.info("Set deletable propertie to True")
ctx.node.properties[constants.DELETABLE_KEY] = True
status_code = subnet.delete(ctx=ctx)
ctx.logger.debug("status_code =" + str(status_code))
self.assertTrue(bool((status_code == 202) or (status_code == 204)))
try:
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "subnet", "waiting for exception", timeout=600)
except utils.WindowsAzureError:
pass
ctx.logger.info("END test_delete_subnet")
def test_create_storage(self):
ctx = self.mock_ctx('testcreatestorage')
current_ctx.set(ctx=ctx)
ctx.logger.info("BEGIN test create storage")
status_code = storage.create(ctx=ctx)
ctx.logger.info("status_code : " + str(status_code))
self.assertTrue(bool((status_code == 200) | (status_code == 202)))
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "storage",constants.SUCCEEDED, timeout=600)
ctx.logger.info("Storage Account Created")
keys = storage.get_storage_keys(ctx)
self.assertIsNotNone(keys)
self.assertEqual(len(keys), 2)
ctx.logger.info("Key 1: {}, key 2: {}".format(keys[0], keys[1]))
self.assertEqual(200, storage.delete(ctx=ctx))
ctx.logger.info("Checking Storage Account deleted")
current_ctx.set(ctx=ctx)
self.assertRaises(utils.WindowsAzureError,
storage.get_provisioning_state,
ctx=ctx
)
ctx.logger.info("Storage Account Deleted")
ctx.logger.info("END test create storage")
def test_delete(self):
ctx = self.mock_ctx('testdeletenic')
current_ctx.set(ctx=ctx)
ctx.logger.info("BEGIN delete NIC test")
ctx.logger.info("create NIC")
status_code = nic.create(ctx=ctx)
ctx.logger.debug("status_code = " + str(status_code) )
self.assertTrue(bool((status_code == 200) or (status_code == 201)))
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "nic",constants.SUCCEEDED, 600)
ctx.logger.info("trying to delete an non-deletable nic")
ctx.node.properties[constants.DELETABLE_KEY] = False
current_ctx.set(ctx=ctx)
self.assertEqual(0, nic.delete(ctx=ctx))
ctx.logger.info("delete NIC")
ctx.node.properties[constants.DELETABLE_KEY] = True
current_ctx.set(ctx=ctx)
self.assertEqual(202, nic.delete(ctx=ctx))
ctx.logger.info("check is nic is release")
try:
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "nic","deleting", 600)
except utils.WindowsAzureError:
pass
ctx.logger.info("END delete NIC test")
def test_delete_storage(self):
ctx = self.mock_ctx('testdeletestorage')
current_ctx.set(ctx=ctx)
ctx.logger.info("BEGIN test delete storage")
status_code = storage.create(ctx=ctx)
ctx.logger.info("status_code : " + str(status_code))
self.assertTrue(bool((status_code == 200) | (status_code == 202)))
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "storage",constants.SUCCEEDED, timeout=600)
ctx.logger.info("create storage with deletable propertie set to False")
ctx.node.properties[constants.DELETABLE_KEY] = False
ctx.logger.info("not delete storage")
self.assertEqual(0, storage.delete(ctx=ctx))
ctx.logger.info("Set deletable propertie to True")
ctx.node.properties[constants.DELETABLE_KEY] = True
ctx.logger.info("Delete storage")
self.assertEqual(200, storage.delete(ctx=ctx))
ctx.logger.info("Checking Storage Account deleted")
current_ctx.set(ctx=ctx)
self.assertRaises(utils.WindowsAzureError,
storage.get_provisioning_state,
ctx=ctx
)
ctx.logger.info("Storage Account Deleted")
ctx.logger.info("END test delete storage")
def test_create_windows_instance(self):
ctx = self.mock_ctx('testwin')
ctx.node.properties[constants.IMAGE_KEY
][constants.PUBLISHER_KEY] = \
'MicrosoftWindowsServer'
ctx.node.properties[constants.IMAGE_KEY
][constants.OFFER_KEY] = 'WindowsServer'
ctx.node.properties[constants.IMAGE_KEY
][constants.SKU_KEY] = '2012-R2-Datacenter'
ctx.node.properties[constants.WINDOWS_AUTOMATIC_UPDATES_KEY] = True
current_ctx.set(ctx=ctx)
ctx.logger.info("BEGIN create windows VM test")
ctx.logger.info("Creating VM...")
instance.create(ctx=ctx)
current_ctx.set(ctx=ctx)
jsonVM = instance.get_json_from_azure(ctx=ctx)
self.assertIsNotNone(jsonVM['properties']['osProfile'][
'windowsConfiguration'])
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "instance",constants.SUCCEEDED, 600)
ctx.logger.info("delete windows VM")
self.assertEqual(202, instance.delete(ctx=ctx))
ctx.logger.info("END create windows VM test")
def test_conflict(self):
ctx = self.mock_ctx('testconflictnic')
current_ctx.set(ctx=ctx)
ctx.logger.info("BEGIN conflict NIC test")
ctx.logger.info("create NIC")
status_code = nic.create(ctx=ctx)
ctx.logger.debug("status_code = " + str(status_code) )
self.assertTrue(bool((status_code == 200) or (status_code == 201)))
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "nic",constants.SUCCEEDED, 600)
ctx.logger.info("create NIC conflict")
status_code = nic.create(ctx=ctx)
ctx.logger.debug("status_code =" + str(status_code) )
self.assertTrue(bool((status_code == 200) or (status_code == 201)))
ctx.logger.info("delete NIC")
self.assertEqual(202, nic.delete(ctx=ctx))
ctx.logger.info("check is NIC is release")
try:
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "nic","deleting", 600)
except utils.WindowsAzureError:
pass
ctx.logger.info("delete conflict NIC")
self.assertEqual(204, nic.delete(ctx=ctx))
ctx.logger.info("END conflict NIC test")
def test_nicInUse_instance(self):
ctx1 = self.mock_ctx('testnicinuse')
ctx2 = self.mock_ctx('testnicinuse2')
ctx1.logger.info("BEGIN nicInUse test")
current_ctx.set(ctx=ctx1)
ctx1.logger.info("create VM")
instance.create(ctx=ctx1)
current_ctx.set(ctx=ctx1)
utils.wait_status(ctx1, "instance",constants.SUCCEEDED, 600)
ctx1.logger.info("VM creation conflict nicInUse")
self.assertRaises(utils.WindowsAzureError,
instance.create,
ctx=ctx2
)
ctx1.logger.info("delete VM")
self.assertEqual(202, instance.delete(ctx=ctx1))
current_ctx.set(ctx=ctx1)
ctx1.logger.info("check vm provisionning state in a deleted machine")
self.assertRaises(
utils.WindowsAzureError,
instance.get_provisioning_state,
ctx=ctx1
)
ctx1.logger.info("END conflict VM test")
time.sleep(TIME_DELAY)
def test_delete_security_group(self):
ctx = self.mock_ctx('testdeletesecuritygroup')
current_ctx.set(ctx=ctx)
ctx.logger.info("BEGIN delete security_group test")
ctx.logger.info("create security_group")
self.assertEqual(201, security_group.create(ctx=ctx))
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "security_group",constants.SUCCEEDED, 600)
ctx.logger.info("trying to delete an non-deletable security_group")
ctx.node.properties[constants.DELETABLE_KEY] = False
current_ctx.set(ctx=ctx)
self.assertEqual(0, security_group.delete(ctx=ctx))
ctx.logger.info("delete security_group")
ctx.node.properties[constants.DELETABLE_KEY] = True
current_ctx.set(ctx=ctx)
self.assertEqual(202, security_group.delete(ctx=ctx))
try:
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "security_group","deleting", 600)
except utils.WindowsAzureError:
pass
ctx.logger.info("END delete security_group test")
def test_conflict_security_group(self):
ctx = self.mock_ctx('testconflictsecuritygroup')
current_ctx.set(ctx=ctx)
ctx.logger.info("BEGIN conflict security_group test")
ctx.logger.info("create security_group")
self.assertEqual(201, security_group.create(ctx=ctx))
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "security_group",constants.SUCCEEDED, 600)
ctx.logger.info("create conflict security_group")
self.assertEqual(200, security_group.create(ctx=ctx))
ctx.logger.info("delete security_group")
self.assertEqual(202, security_group.delete(ctx=ctx))
try:
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "security_group","deleting", 600)
except utils.WindowsAzureError:
pass
ctx.logger.info("delete conflict security_group")
self.assertEqual(204, security_group.delete(ctx=ctx))
ctx.logger.info("END conflict security_group test")
def test_conflict_resource_group(self):
ctx = self.mock_ctx('conflictgroup')
current_ctx.set(ctx=ctx)
ctx.logger.info("BEGIN resource_group conflict test")
ctx.logger.info("create resource group")
status_code = resource_group.create(ctx=ctx)
ctx.logger.debug("status_code = " + str(status_code) )
self.assertTrue(bool((status_code == 200) or (status_code == 201)))
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "resource_group",constants.SUCCEEDED, timeout=600)
ctx.logger.info("conflict create resource group")
status_code = resource_group.create(ctx=ctx)
ctx.logger.debug("status_code = " + str(status_code) )
self.assertTrue(bool((status_code == 200) or (status_code == 201)))
ctx.logger.info("delete resource_group")
current_ctx.set(ctx=ctx)
self.assertEqual(202, resource_group.delete(ctx=ctx))
try:
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "resource_group","waiting for exception", timeout=600)
except utils.WindowsAzureError:
pass
ctx.logger.info("END resource_group conflict test")
def create(**_):
"""Create a resource group.
:param ctx: The Cloudify ctx context.
:return: The status code of the REST request.
:rtype: int
"""
utils.validate_node_property(constants.RESOURCE_GROUP_KEY, ctx.node.properties)
azure_config = utils.get_azure_config(ctx)
subscription_id = azure_config[constants.SUBSCRIPTION_KEY]
location = azure_config[constants.LOCATION_KEY]
api_version = constants.AZURE_API_VERSION_04_PREVIEW
resource_group_name = ctx.node.properties[constants.RESOURCE_GROUP_KEY]
json ={"location": str(location)}
ctx.logger.info('Beginning resource_group creation')
cntn = connection.AzureConnectionClient()
response = cntn.azure_put(ctx,
("subscriptions/{}/resourcegroups/{}" +
"?api-version={}").format(
subscription_id,
resource_group_name,
api_version
),
json=json
)
utils.wait_status(ctx, 'resource_group')
return response.status_code
def test_create_too_much_datadisks(self):
disks = [{'name': 'much_disks_1',
'size': 100,
'deletable': False,
'caching': 'None'
},{'name': 'much_disks_2',
'size': 200,
'deletable': False,
'caching': 'ReadWrite'
},{'name': 'much_disks_3',
'size': 200,
'deletable': False,
'caching': 'ReadOnly'
}]
test_name = 'test-create-too-much-datadisks'
ctx = self.mock_ctx(test_name , disks)
current_ctx.set(ctx=ctx)
ctx.logger.info("BEGIN create VM test: {}".format(test_name))
instance.create(ctx=ctx)
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, 'instance', timeout=900)
current_ctx.set(ctx=ctx)
datadisks.create(ctx=ctx)
current_ctx.set(ctx=ctx)
json_VM = instance.get_json_from_azure(ctx=ctx)
self.assertIsNotNone(json_VM['properties'][
'storageProfile']['dataDisks'])
disks_vm = json_VM['properties']['storageProfile']['dataDisks']
ctx.logger.debug(disks_vm)
self.assertNotEqual(len(disks), len(disks_vm))
self.assertEqual(disks[0]['name'], disks_vm[0]['name'])
self.assertEqual(disks[0]['size'], disks_vm[0]['diskSizeGB'])
self.assertEqual(disks[0]['caching'], disks_vm[0]['caching'])
self.assertEqual(disks[1]['name'], disks_vm[1]['name'])
self.assertEqual(disks[1]['size'], disks_vm[1]['diskSizeGB'])
self.assertEqual(disks[1]['caching'], disks_vm[1]['caching'])
current_ctx.set(ctx=ctx)
ctx.logger.info("BEGIN delete VM test: {}".format(test_name))
instance.delete(ctx=ctx)
try:
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, 'instance',
constants.DELETING, timeout=900)
except utils.WindowsAzureError:
pass
def test_delete_datadisk(self):
disk = [{'name': 'delete_disk',
'size': 100,
constants.DELETABLE_KEY: True,
'caching': 'None'
},{'name': 'delete_disk_2',
'size': 100,
constants.DELETABLE_KEY: False,
'caching': 'None'
}]
test_name = 'test-delete-datadisk'
ctx = self.mock_ctx(test_name, disk)
current_ctx.set(ctx=ctx)
ctx.logger.info("BEGIN create VM test: {}".format(test_name))
instance.create(ctx=ctx)
current_ctx.set(ctx=ctx)
datadisks.create(ctx=ctx)
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, 'instance',timeout=900)
current_ctx.set(ctx=ctx)
ctx.logger.info("BEGIN delete VM test: {}".format(test_name))
instance.delete(ctx=ctx)
try:
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, 'instance',
constants.DELETING, timeout=900)
except utils.WindowsAzureError:
pass
ctx.logger.info("BEGIN delete datadisk test: {}".format(
disk[0]['name']
)
)
current_ctx.set(ctx=ctx)
datadisks.delete(ctx=ctx)
list = datadisks._get_datadisks_from_storage(ctx)
self.assertFalse(datadisks._is_datadisk_exists(
list,
disk[0]['name']
)
)
ctx.logger.info("Disk {} has been deleted.".format(disk[0]['name']))
self.assertTrue(datadisks._is_datadisk_exists(
list,
disk[1]['name']
)
)
ctx.logger.info("Datadisk {} still exists.".format(disk[1]['name']))
def create(**_):
"""
Create the availability set.
:return: The int of the status code of the request (200 OK; 404 Not Found).
:rtype: int
"""
utils.validate_node_property(constants.AVAILABILITY_SET_KEY, ctx.node.properties)
azure_config = utils.get_azure_config(ctx)
subscription_id = azure_config[constants.SUBSCRIPTION_KEY]
resource_group_name = azure_config[constants.RESOURCE_GROUP_KEY]
location = azure_config[constants.LOCATION_KEY]
api_version = constants.AZURE_API_VERSION_05_preview
availability_set_name = ctx.node.properties[constants.AVAILABILITY_SET_KEY]
# Place the availability_set name in runtime_properties for relationships
ctx.instance.runtime_properties[constants.AVAILABILITY_SET_KEY] = \
availability_set_name
json ={
"name": str(availability_set_name),
"type": "Microsoft.Compute/availabilitySets",
"location": str(location),
"properties": {
"platformUpdateDomainCount": 5,
"platformFaultDomainCount": 3
}
}
response = connection.AzureConnectionClient().azure_put(ctx,
("subscriptions/{}" +
"/resourceGroups/{}" +
"/providers/Microsoft.Compute" +
"/availabilitySets/{}" +
"?api-version={}").format(
subscription_id,
resource_group_name,
availability_set_name,
api_version
),
json=json
)
# Place the availability_set id in runtime_properties for relationships
ctx.instance.runtime_properties[constants.AVAILABILITY_ID_KEY] = \
response.json()['id']
utils.wait_status(ctx, 'availability_set')
return response.status_code
def test_add_public_ip(self):
ctx = self.mock_ctx('testaddpublicip')
ctx.logger.info("BEGIN attach public_ip to NIC test")
ctx.logger.info("create NIC")
current_ctx.set(ctx=ctx)
nic.create(ctx=ctx)
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "nic", constants.SUCCEEDED, 600)
ctx.logger.info("attach public_ip to NIC: {}".format(ctx.instance.runtime_properties['subnet_id']))
ctx_rel = self.mock_relationship_ctx('testaddpublicip', ctx.instance.runtime_properties['subnet_id'])
current_ctx.set(ctx=ctx_rel)
nic.add_public_ip(ctx=ctx_rel)
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "nic", constants.SUCCEEDED, 600)
ctx.logger.info('Checking if Public IP is correctly set')
current_ctx.set(ctx=ctx_rel)
response = (connection.AzureConnectionClient().azure_get(
ctx,
("subscriptions/{}" +
"/resourceGroups/{}/providers/" +
"microsoft.network/networkInterfaces/{}"
"?api-version={}"
).format(test_utils.SUBSCRIPTION_ID,
'nic_resource_group_test' + self.__random_id,
ctx.node.properties[constants.NETWORK_INTERFACE_KEY],
constants.AZURE_API_VERSION_06
)
)
).json()
public_ip_id = nic.get_public_ip_id(ctx=ctx_rel)
self.assertEqual(response['properties']['ipConfigurations'][
0]['properties']['publicIPAddress']['id'], public_ip_id)
ctx.logger.info("DELETING NIC")
current_ctx.set(ctx=ctx)
self.assertEqual(202, nic.delete(ctx=ctx))
ctx.logger.info("Check if NIC is released.")
current_ctx.set(ctx=ctx)
self.assertRaises(utils.WindowsAzureError,
nic.get_provisioning_state,
ctx=ctx
)
ctx.logger.info("END add public ip NIC test")
def test_delete_instance(self):
ctx = self.mock_ctx('testdeleteinstance')
current_ctx.set(ctx=ctx)
ctx.logger.info("BEGIN delete VM test")
ctx.logger.info("create VM")
instance.create(ctx=ctx)
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "instance",constants.SUCCEEDED, 600)
ctx.logger.info("delete VM")
self.assertEqual(202, instance.delete(ctx=ctx))
ctx.logger.info("END delete VM test")
def create(**_):
"""Create a public ip.
:param ctx: The Cloudify ctx context.
:return: The status code of the REST request.
:rtype: int
"""
utils.validate_node_property(constants.PUBLIC_IP_KEY, ctx.node.properties)
azure_config = utils.get_azure_config(ctx)
subscription_id = azure_config[constants.SUBSCRIPTION_KEY]
resource_group_name = azure_config[constants.RESOURCE_GROUP_KEY]
location = azure_config[constants.LOCATION_KEY]
api_version = constants.AZURE_API_VERSION_06
public_ip_name = ctx.node.properties[constants.PUBLIC_IP_KEY]
public_ip_allocation_method = "Dynamic"
# Place the public_ip name in runtime_properties for relationships
ctx.instance.runtime_properties[constants.PUBLIC_IP_KEY] = \
public_ip_name
json ={
"location": str(location),
"properties": {
"publicIPAllocationMethod": str(public_ip_allocation_method)
}
}
cntn = connection.AzureConnectionClient()
response = cntn.azure_put(ctx,
("subscriptions/{}/resourcegroups/{}/" +
"providers/microsoft.network" +
"/publicIPAddresses/{}" +
"?api-version={}").format(
subscription_id,
resource_group_name,
public_ip_name,
api_version
),
json=json
)
utils.wait_status(ctx, 'public_ip')
return response.status_code
def test_create_instance_from_vhd(self):
'''To run this test, you need all the required resource to start a machine
(resource group, storage account, nic). You then have to upload a valid
bootable VHD on the storage account. Note the vhd's endpoint and replace
MY_URI_VHD by this value.
Then, you can run the test.
Note the resource group will not be deleted by the class teardown.
'''
ctx = self.mock_ctx('testinstancevhd')
ctx.node.properties[constants.AZURE_CONFIG_KEY
][constants.RESOURCE_GROUP_KEY] = MY_RESOURCE_GROUP
ctx.node.properties[constants.AZURE_CONFIG_KEY
][constants.STORAGE_ACCOUNT_KEY] = MY_STORAGE_ACCOUNT
ctx.node.properties[constants.NETWORK_INTERFACE_KEY] = MY_NIC
ctx.node.properties[constants.IMAGE_KEY] = {}
ctx.node.properties[constants.IMAGE_KEY
][constants.OS_URI_KEY] = MY_URI_VHD
ctx.node.properties[constants.IMAGE_KEY
][constants.OS_TYPE_KEY] = 'Linux'
current_ctx.set(ctx=ctx)
ctx.logger.info("BEGIN create VM test: {}".format(ctx.instance.id))
ctx.logger.info("create VM")
instance.create(ctx=ctx)
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "instance",constants.SUCCEEDED, 600)
current_ctx.set(ctx=ctx)
jsonVM = instance.get_json_from_azure(ctx=ctx)
self.assertEqual(jsonVM['properties']['storageProfile'
]['osDisk']['osType'],
ctx.node.properties[constants.IMAGE_KEY
][constants.OS_TYPE_KEY]
)
self.assertEqual(jsonVM['properties']['storageProfile'
]['osDisk']['image']['uri'],
ctx.node.properties[constants.IMAGE_KEY
][constants.OS_URI_KEY]
)
ctx.logger.info("delete VM")
self.assertEqual(202, instance.delete(ctx=ctx))
ctx.logger.info("END create VM test")
def test_create_datadisk(self):
disk = [{'name': 'disk_1',
'size': 100,
'deletable': False,
'caching': 'None'
}]
test_name = 'test-create-datadisk'
ctx = self.mock_ctx(test_name, disk)
current_ctx.set(ctx=ctx)
ctx.logger.info("BEGIN create VM test: {}".format(test_name))
instance.create(ctx=ctx)
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, 'instance', constants.SUCCEEDED, timeout=900)
current_ctx.set(ctx=ctx)
datadisks.create(ctx=ctx)
current_ctx.set(ctx=ctx)
json_VM = instance.get_json_from_azure(ctx=ctx)
ctx.logger.debug(json_VM)
self.assertIsNotNone(json_VM['properties'][
'storageProfile']['dataDisks'])
disks_vm = json_VM['properties']['storageProfile']['dataDisks']
ctx.logger.debug(disks_vm)
self.assertEqual(disk[0]['name'], disks_vm[0]['name'])
self.assertEqual(disk[0]['caching'], disks_vm[0]['caching'])
self.assertEqual(disk[0]['size'], disks_vm[0]['diskSizeGB'])
current_ctx.set(ctx=ctx)
ctx.logger.info("BEGIN delete VM test: {}".format(test_name))
instance.delete(ctx=ctx)
try:
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, 'instance',
constants.DELETING, timeout=900)
except utils.WindowsAzureError:
pass
def setUpClass(self):
ctx = self.mock_ctx('init','')
ctx.logger.info("BEGIN test datadisk number "\
+ self.__random_id)
current_ctx.set(ctx=ctx)
ctx.logger.info("CREATE ressource_group")
resource_group.create(ctx=ctx)
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "resource_group",
constants.SUCCEEDED, timeout=600)
current_ctx.set(ctx=ctx)
ctx.logger.info("CREATE storage account")
ctx.node.properties[constants.ACCOUNT_TYPE_KEY] = "Standard_LRS"
storage.create(ctx=ctx)
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "storage",constants.SUCCEEDED, timeout=600)
ctx.logger.info("CREATE network")
current_ctx.set(ctx=ctx)
ctx.node.properties[constants.VIRTUAL_NETWORK_ADDRESS_KEY] = \
"10.0.0.0/16"
network.create(ctx=ctx)
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "network",constants.SUCCEEDED, timeout=600)
ctx.logger.info("CREATE subnet")
current_ctx.set(ctx=ctx)
ctx.node.properties[constants.SUBNET_ADDRESS_KEY] = "10.0.1.0/24"
ctx.instance.runtime_properties[constants.VIRTUAL_NETWORK_KEY] =\
"diskvirtualnetwork_test" + self.__random_id
subnet.create(ctx=ctx)
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "subnet",constants.SUCCEEDED, timeout=600)
ctx.logger.info("CREATE NIC")
current_ctx.set(ctx=ctx)
nic.create(ctx=ctx)
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "nic",constants.SUCCEEDED, timeout=600)
def test_add_availability_set_instance(self):
ctx = self.mock_ctx('testaddavailabilityinstance')
current_ctx.set(ctx=ctx)
ctx.logger.info("BEGIN add availability set VM test: {}".format(ctx.instance.id))
ctx.logger.info("create availability_set")
self.assertEqual(200, availability_set.create(ctx=ctx))
ctx.logger.debug("availability_set_id = {}".format(
ctx.instance.runtime_properties[constants.AVAILABILITY_ID_KEY]))
ctx.instance.relationships.append(test_mockcontext.MockRelationshipContext(node_id='test',
runtime_properties={
constants.AVAILABILITY_ID_KEY:\
ctx.instance.runtime_properties[constants.AVAILABILITY_ID_KEY]
},
type=constants.INSTANCE_CONTAINED_IN_AVAILABILITY_SET)
)
ctx.logger.info("create VM")
instance.create(ctx=ctx)
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "instance",constants.SUCCEEDED, 600)
ctx.logger.info("test instance is in availability_set")
current_ctx.set(ctx=ctx)
json = instance.get_json_from_azure(ctx=ctx)
self.assertIsNotNone(json['properties']['availabilitySet'])
self.assertEqual(str(json['properties']['availabilitySet']['id']).lower(),
str(ctx.instance.runtime_properties[constants.AVAILABILITY_ID_KEY]).lower()
)
ctx.logger.info("delete VM")
self.assertEqual(202, instance.delete(ctx=ctx))
ctx.logger.info("delete availability_set")
self.assertEqual(200, availability_set.delete(ctx=ctx))
ctx.logger.info("END create VM test")
def test_storage_relationship_instance(self):
ctx = self.mock_ctx('teststorelainstance')
current_ctx.set(ctx=ctx)
ctx.logger.info("BEGIN storage relationship VM test: {}".format(ctx.instance.id))
ctx.instance.relationships.append(test_mockcontext.MockRelationshipContext(node_id='test',
runtime_properties={
constants.STORAGE_ACCOUNT_KEY:\
ctx.node.properties[constants.STORAGE_ACCOUNT_KEY]
},
type=constants.INSTANCE_CONNECTED_TO_STORAGE_ACCOUNT)
)
ctx.logger.info("create VM")
instance.create(ctx=ctx)
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "instance",constants.SUCCEEDED, 600)
ctx.logger.info("delete VM")
self.assertEqual(202, instance.delete(ctx=ctx))
ctx.logger.info("END create VM test")
def test_create_subnet(self):
ctx = self.mock_ctx("testcreatesubnet", cdir="10.0.2.0/24")
ctx.logger.info("BEGIN test_create_subnet")
current_ctx.set(ctx=ctx)
status_code = subnet.create(ctx=ctx)
ctx.logger.debug("status_code = " + str(status_code))
self.assertTrue(bool((status_code == 200) or (status_code == 201)))
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "subnet", constants.SUCCEEDED, timeout=600)
current_ctx.set(ctx=ctx)
status_code = subnet.delete(ctx=ctx)
ctx.logger.debug("status_code = " + str(status_code))
self.assertTrue(bool((status_code == 202) or (status_code == 204)))
try:
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "subnet", "waiting for exception", timeout=600)
except utils.WindowsAzureError:
pass
ctx.logger.info("END test_create_subnet")
def test_connect_security_group_subnet(self):
ctx = self.mock_ctx("testaddsecugroupsubnet", cdir="10.0.5.0/24")
ctx.logger.info("BEGIN test_connect_security_group_subnet")
ctx.logger.info("create security_group")
self.assertEqual(201, security_group.create(ctx=ctx))
ctx.logger.debug(
"security_group_id = {}".format(ctx.instance.runtime_properties[constants.SECURITY_GROUP_ID_KEY])
)
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "security_group", constants.SUCCEEDED, timeout=900)
ctx.instance.relationships.append(
test_mockcontext.MockRelationshipContext(
node_id="test",
runtime_properties={
constants.SECURITY_GROUP_ID_KEY: ctx.instance.runtime_properties[constants.SECURITY_GROUP_ID_KEY]
},
type=constants.SUBNET_CONNECTED_TO_SECURITY_GROUP,
)
)
current_ctx.set(ctx=ctx)
status_code = subnet.create(ctx=ctx)
ctx.logger.debug("status_code = " + str(status_code))
self.assertTrue(bool((status_code == 200) or (status_code == 201)))
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "subnet", constants.SUCCEEDED, timeout=600)
ctx.logger.info("test subnet is connected to a security_group")
current_ctx.set(ctx=ctx)
json = subnet.get_json_from_azure(ctx=ctx)
self.assertIsNotNone(json["properties"]["networkSecurityGroup"])
self.assertEqual(
str(json["properties"]["networkSecurityGroup"]["id"]).lower(),
str(ctx.instance.runtime_properties[constants.SECURITY_GROUP_ID_KEY]).lower(),
)
current_ctx.set(ctx=ctx)
status_code = subnet.delete(ctx=ctx)
ctx.logger.debug("status_code = " + str(status_code))
self.assertTrue(bool((status_code == 202) or (status_code == 204)))
try:
current_ctx.set(ctx=ctx)
utils.wait_status(ctx, "subnet", "waiting for exception", timeout=600)
except utils.WindowsAzureError:
pass
ctx.logger.info("delete security_group")
self.assertEqual(202, security_group.delete(ctx=ctx))
ctx.logger.info("END test_connect_security_group_subnet")
