def test_03_multiplecore_delete_instance(self):
"""Test Deploy VM with multiple core CPU & verify the usage"""
# Validate the following
# 1. Deploy VM with multiple core CPU & verify the usage
# 2. Destroy VM & verify update resource count of Root Admin Account
# 3. Resource count should list properly.
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count = account_list[0].cputotal
expected_resource_count = int(self.services["service_offering"]["cpunumber"])
self.assertEqual(resource_count, expected_resource_count,
"Resource count should match with the expected resource count")
self.debug("Destroying instance: %s" % self.vm.name)
try:
self.vm.delete(self.apiclient)
except Exception as e:
self.fail("Failed to delete instance: %s" % e)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count = account_list[0].cputotal
self.assertEqual(resource_count, 0 , "Resource count for %s should be 0" % get_resource_type(resource_id=8))#CPU
return
def test_03_multiplecore_delete_instance(self):
"""Test Deploy VM with multiple core CPU & verify the usage"""
# Validate the following
# 1. Deploy VM with multiple core CPU & verify the usage
# 2. Destroy VM & verify update resource count of Root Admin Account
# 3. Resource count should list properly.
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list, list,
"List Accounts should return a valid response")
resource_count = account_list[0].cputotal
expected_resource_count = int(
self.services["service_offering"]["cpunumber"])
self.assertEqual(
resource_count, expected_resource_count,
"Resource count should match with the expected resource count")
self.debug("Destroying instance: %s" % self.vm.name)
try:
self.vm.delete(self.apiclient)
except Exception as e:
self.fail("Failed to delete instance: %s" % e)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list, list,
"List Accounts should return a valid response")
resource_count = account_list[0].cputotal
self.assertEqual(resource_count, 0,
"Resource count for %s should be 0" %
get_resource_type(resource_id=8)) #CPU
return
def setupAccounts(self):
self.debug("Creating a sub-domain under: %s" % self.domain.name)
self.child_domain_1 = Domain.create(
self.apiclient,
services=self.services["domain"],
parentdomainid=self.domain.id)
self.child_do_admin_1 = Account.create(
self.apiclient,
self.services["account"],
admin=True,
domainid=self.child_domain_1.id)
# Cleanup the resources created at end of test
self.cleanup.append(self.child_do_admin_1)
self.cleanup.append(self.child_domain_1)
self.child_domain_2 = Domain.create(
self.apiclient,
services=self.services["domain"],
parentdomainid=self.domain.id)
self.child_do_admin_2 = Account.create(
self.apiclient,
self.services["account"],
admin=True,
domainid=self.child_domain_2.id)
# Cleanup the resources created at end of test
self.cleanup.append(self.child_do_admin_2)
self.cleanup.append(self.child_domain_2)
return
def setupAccounts(self):
self.debug("Creating a sub-domain under: %s" % self.domain.name)
self.child_domain_1 = Domain.create(self.apiclient,
services=self.services["domain"],
parentdomainid=self.domain.id)
self.child_do_admin_1 = Account.create(self.apiclient,
self.services["account"],
admin=True,
domainid=self.child_domain_1.id)
# Cleanup the resources created at end of test
self.cleanup.append(self.child_do_admin_1)
self.cleanup.append(self.child_domain_1)
self.child_domain_2 = Domain.create(self.apiclient,
services=self.services["domain"],
parentdomainid=self.domain.id)
self.child_do_admin_2 = Account.create(self.apiclient,
self.services["account"],
admin=True,
domainid=self.child_domain_2.id)
# Cleanup the resources created at end of test
self.cleanup.append(self.child_do_admin_2)
self.cleanup.append(self.child_domain_2)
return
def test_02_multiple_core_vm_migrate_instance(self):
"""Test Deploy VM with 4 core CPU & verify the usage"""
# Validate the following
# 1. Create two domains and set specific resource (cpu) limit for them
# 2. Create compute offering with 4 core CPU & deploy vm
# 3. Update Resource count for the domains
# 4. Migrate instance to new host and check resource count
# 5. Resource count should list properly.
self.debug("Setting up account and domain hierarchy")
self.setupAccounts()
users = {self.domain: self.admin,
self.child_domain: self.child_do_admin
}
for domain, admin in users.items():
self.account = admin
self.domain = domain
api_client = self.testClient.createUserApiClient(
UserName=self.account.name,
DomainName=self.account.domain)
self.debug("Creating an instance with service offering: %s" %
self.service_offering.name)
vm = self.createInstance(service_off=self.service_offering, api_client=api_client)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count = account_list[0].cputotal
expected_resource_count = int(self.services["service_offering"]["cpunumber"])
self.assertEqual(resource_count, expected_resource_count,
"Initial resource count should match with the expected resource count")
host = findSuitableHostForMigration(self.apiclient, vm.id)
if host is None:
self.skipTest(ERROR_NO_HOST_FOR_MIGRATION)
self.debug("Migrating instance: %s to host: %s" %
(vm.name, host.name))
try:
vm.migrate(self.apiclient, host.id)
except Exception as e:
self.fail("Failed to migrate instance: %s" % e)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count_after_migrate = account_list[0].cputotal
self.assertEqual(resource_count, resource_count_after_migrate,
"Resource count should be same as before, after migrating the instance")
return
def test_02_migrate_vm(self):
"""Test Deploy VM with specified RAM & verify the usage"""
# Validate the following
# 1. Create compute offering with specified RAM & Deploy VM in the created domain
# 2. List Resource count for the root admin Memory usage
# 3. Migrate vm to another host, resource count should list properly.
#Resetting memory count in service offering
self.services["service_offering"]["memory"] = 2048
self.debug("Setting up account and domain hierarchy")
self.setupAccounts()
users = { self.child_domain_1: self.child_do_admin_1,
self.child_domain_2: self.child_do_admin_2
}
for domain, admin in users.items():
self.account = admin
self.domain = domain
self.debug("Creating an instance with service offering: %s" %
self.service_offering.name)
api_client = self.testClient.createUserApiClient(
UserName=self.account.name,
DomainName=self.account.domain)
vm = self.createInstance(service_off=self.service_offering, api_client=api_client)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count = account_list[0].memorytotal
expected_resource_count = int(self.services["service_offering"]["memory"])
self.assertEqual(resource_count, expected_resource_count,
"Resource count should match with the expected resource count")
host = findSuitableHostForMigration(self.apiclient, vm.id)
if host is None:
self.skipTest(ERROR_NO_HOST_FOR_MIGRATION)
self.debug("Migrating instance: %s to host: %s" %
(vm.name, host.name))
try:
vm.migrate(self.apiclient, host.id)
except Exception as e:
self.fail("Failed to migrate instance: %s" % e)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count_after_migrate = account_list[0].memorytotal
self.assertTrue(resource_count_after_migrate == resource_count,
"Resource count should be same after migrating the instance")
return
def test_02_migrate_vm(self):
"""Test Deploy VM with specified RAM & verify the usage"""
# Validate the following
# 1. Create compute offering with specified RAM & Deploy VM in the created domain
# 2. List Resource count for the root admin Memory usage
# 3. Migrate vm to another host, resource count should list properly.
#Resetting memory count in service offering
self.services["service_offering"]["memory"] = 2048
self.debug("Setting up account and domain hierarchy")
self.setupAccounts()
users = {
self.child_domain_1: self.child_do_admin_1,
self.child_domain_2: self.child_do_admin_2
}
for domain, admin in users.items():
self.account = admin
self.domain = domain
self.debug("Creating an instance with service offering: %s" %
self.service_offering.name)
api_client = self.testClient.createUserApiClient(
UserName=self.account.name, DomainName=self.account.domain)
vm = self.createInstance(service_off=self.service_offering,
api_client=api_client)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(
account_list, list,
"List Accounts should return a valid response")
resource_count = account_list[0].memorytotal
expected_resource_count = int(
self.services["service_offering"]["memory"])
self.assertEqual(
resource_count, expected_resource_count,
"Resource count should match with the expected resource count")
host = find_suitable_host(self.apiclient, vm)
self.debug("Migrating instance: %s to host: %s" %
(vm.name, host.name))
try:
vm.migrate(self.apiclient, host.id)
except Exception as e:
self.fail("Failed to migrate instance: %s" % e)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(
account_list, list,
"List Accounts should return a valid response")
resource_count_after_migrate = account_list[0].memorytotal
self.assertTrue(
resource_count_after_migrate == resource_count,
"Resource count should be same after migrating the instance")
return
def test_03_multiple_core_vm_delete_instance(self):
"""Test Deploy VM with 4 core CPU & verify the usage"""
# Validate the following
# 1. Create two domains and set specific resource (cpu) limit for them
# 2. Create compute offering with 4 core CPU & deploy vm
# 3. Update Resource count for the domains
# 4. delete instance and check resource count
# 5. Resource count should list properly.
self.debug("Setting up account and domain hierarchy")
self.setupAccounts()
users = {
self.domain: self.admin,
self.child_domain: self.child_do_admin
}
for domain, admin in users.items():
self.account = admin
self.domain = domain
api_client = self.testClient.createUserApiClient(
UserName=self.account.name, DomainName=self.account.domain)
self.debug("Creating an instance with service offering: %s" %
self.service_offering.name)
vm = self.createInstance(service_off=self.service_offering,
api_client=api_client)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(
account_list, list,
"List Accounts should return a valid response")
resource_count = account_list[0].cputotal
expected_resource_count = int(
self.services["service_offering"]["cpunumber"])
self.assertEqual(
resource_count, expected_resource_count,
"Initial resource count should with the expected resource count"
)
self.debug("Destroying instance: %s" % vm.name)
try:
vm.delete(self.apiclient)
except Exception as e:
self.fail("Failed to delete instance: %s" % e)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(
account_list, list,
"List Accounts should return a valid response")
resource_count_after_delete = account_list[0].cputotal
self.assertEqual(resource_count_after_delete, 0,
"Resource count for %s should be 0" %
get_resource_type(resource_id=8)) #CPU
return
def test_03_delete_vm(self):
"""Test Deploy VM with 5 GB RAM & verify the usage"""
# Validate the following
# 1. Create compute offering with 5 GB RAM & Deploy VM in the created domain
# 2. List Resource count for the root admin Memory usage
# 3. Delete vm, resource count should list as 0 after delete operation.
self.debug("Setting up account and domain hierarchy")
self.setupAccounts()
users = {
self.domain: self.admin,
self.child_domain: self.child_do_admin
}
for domain, admin in users.items():
self.account = admin
self.domain = domain
self.debug("Creating an instance with service offering: %s" %
self.service_offering.name)
api_client = self.testClient.createUserApiClient(
UserName=self.account.name, DomainName=self.account.domain)
vm = self.createInstance(service_off=self.service_offering,
api_client=api_client)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(
account_list, list,
"List Accounts should return a valid response")
resource_count = account_list[0].memorytotal
expected_resource_count = int(
self.services["service_offering"]["memory"])
self.assertEqual(
resource_count, expected_resource_count,
"Resource count should match with the expected resource count")
self.debug("Destroying instance: %s" % vm.name)
try:
vm.delete(self.apiclient)
except Exception as e:
self.fail("Failed to delete instance: %s" % e)
# Wait for expunge interval to cleanup Memory
wait_for_cleanup(self.apiclient,
["expunge.delay", "expunge.interval"])
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(
account_list, list,
"List Accounts should return a valid response")
resource_count_after_delete = account_list[0].memorytotal
self.assertEqual(resource_count_after_delete, 0,
"Resource count for %s should be 0" %
get_resource_type(resource_id=9)) #RAM
return
def setupAccounts(self):
self.debug("Creating a domain under: %s" % self.domain.name)
self.parent_domain = Domain.create(
self.apiclient, services=self.services["domain"], parentdomainid=self.domain.id
)
self.parentd_admin = Account.create(
self.apiclient, self.services["account"], admin=True, domainid=self.domain.id
)
self.debug("Updating the Memory resource count for domain: %s" % self.domain.name)
Resources.updateLimit(
self.apiclient,
resourcetype=9,
max=4096,
account=self.parentd_admin.name,
domainid=self.parentd_admin.domainid,
)
self.debug("Creating a sub-domain under: %s" % self.parent_domain.name)
self.cdomain_1 = Domain.create(
self.apiclient, services=self.services["domain"], parentdomainid=self.parent_domain.id
)
self.debug("Creating a sub-domain under: %s" % self.parent_domain.name)
self.cdomain_2 = Domain.create(
self.apiclient, services=self.services["domain"], parentdomainid=self.parent_domain.id
)
self.cadmin_1 = Account.create(self.apiclient, self.services["account"], admin=True, domainid=self.cdomain_1.id)
self.debug("Updating the Memory resource count for domain: %s" % self.cdomain_1.name)
Resources.updateLimit(self.apiclient, resourcetype=9, max=2048, domainid=self.cadmin_1.domainid)
self.debug("Updating the Memory resource count for account: %s" % self.cadmin_1.name)
Resources.updateLimit(
self.apiclient, resourcetype=9, max=2048, account=self.cadmin_1.name, domainid=self.cadmin_1.domainid
)
self.cadmin_2 = Account.create(self.apiclient, self.services["account"], admin=True, domainid=self.cdomain_2.id)
self.debug("Updating the Memory resource count for domain: %s" % self.cdomain_2.name)
Resources.updateLimit(self.apiclient, resourcetype=9, max=2048, domainid=self.cadmin_2.domainid)
self.debug("Updating the Memory resource count for domain: %s" % self.cadmin_2.name)
Resources.updateLimit(
self.apiclient, resourcetype=9, max=2048, account=self.cadmin_2.name, domainid=self.cadmin_2.domainid
)
# Cleanup the resources created at end of test
self.cleanup.append(self.cadmin_1)
self.cleanup.append(self.cadmin_2)
self.cleanup.append(self.cdomain_1)
self.cleanup.append(self.cdomain_2)
self.cleanup.append(self.parentd_admin)
self.cleanup.append(self.parent_domain)
users = {self.parent_domain: self.parentd_admin, self.cdomain_1: self.cadmin_1, self.cdomain_2: self.cadmin_2}
return users
def test_03_delete_vm(self):
"""Test Deploy VM with specified RAM & verify the usage"""
# Validate the following
# 1. Create compute offering with specified RAM & Deploy VM in the created domain
# 2. List Resource count for the root admin Memory usage
# 3. Delete vm, resource count should list as 0 after delete operation.
# Resetting the memory count of service offering
self.services["service_offering"]["memory"] = 2048
self.debug("Setting up account and domain hierarchy")
self.setupAccounts()
users = { self.child_domain_1: self.child_do_admin_1,
self.child_domain_2: self.child_do_admin_2
}
for domain, admin in users.items():
self.account = admin
self.domain = domain
self.debug("Creating an instance with service offering: %s" %
self.service_offering.name)
api_client = self.testClient.createUserApiClient(
UserName=self.account.name,
DomainName=self.account.domain)
vm = self.createInstance(service_off=self.service_offering, api_client=api_client)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count = account_list[0].memorytotal
expected_resource_count = int(self.services["service_offering"]["memory"])
self.assertEqual(resource_count, expected_resource_count,
"Resource count should match with the expected resource count")
self.debug("Destroying instance: %s" % vm.name)
try:
vm.delete(self.apiclient)
except Exception as e:
self.fail("Failed to delete instance: %s" % e)
# Wait for expunge interval to cleanup Memory
wait_for_cleanup(self.apiclient, ["expunge.delay", "expunge.interval"])
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count_after_delete = account_list[0].memorytotal
self.assertEqual(resource_count_after_delete, 0 , "Resource count for %s should be 0" % get_resource_type(resource_id=9))#RAM
return
def test_04_deploy_multiple_vm(self):
"""Test Deploy multiple VM with specified RAM & verify the usage"""
# Validate the following
# 1. Create compute offering with specified RAM
# 2. Deploy multiple VMs with this service offering
# 3. List Resource count for the root admin Memory usage
# 4. Memory usage should list properly
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count = account_list[0].memorytotal
expected_resource_count = int(self.services["service_offering"]["memory"])
self.assertEqual(resource_count, expected_resource_count,
"Resource count should match with the expected resource count")
self.debug("Creating two instances with service offering: %s" %
self.service_offering.name)
vm_1 = self.createInstance(service_off=self.service_offering)
self.createInstance(service_off=self.service_offering)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count_new = account_list[0].memorytotal
expected_resource_count = int(self.services["service_offering"]["memory"]) * 3 #Total 3 VMs
self.assertEqual(resource_count_new, expected_resource_count,
"Resource count should match with the expected resource count")
self.debug("Destroying instance: %s" % vm_1.name)
try:
vm_1.delete(self.apiclient)
except Exception as e:
self.fail("Failed to delete instance: %s" % e)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count_after_delete = account_list[0].memorytotal
expected_resource_count -= int(self.services["service_offering"]["memory"])
self.assertEqual(resource_count_after_delete, expected_resource_count,
"Resource count should match with the expected resource count")
return
def test_03_delete_instance(self):
"""Test Deploy VM with specified RAM & verify the usage"""
# Validate the following
# 1. Create compute offering with specified RAM in child domains of root domain & Deploy VM
# 2. List Resource count for the Memory usage
# 3. Delete instance
# 4. Resource count should list as 0
self.debug("Setting up account and domain hierarchy")
self.setupAccounts()
users = {
self.child_domain_1: self.child_do_admin_1,
self.child_domain_2: self.child_do_admin_2
}
for domain, admin in users.items():
self.account = admin
self.domain = domain
api_client = self.testClient.createUserApiClient(
UserName=self.account.name, DomainName=self.account.domain)
self.debug("Creating an instance with service offering: %s" %
self.service_offering.name)
vm = self.createInstance(service_off=self.service_offering,
api_client=api_client)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(
account_list, list,
"List Accounts should return a valid response")
resource_count = account_list[0].memorytotal
expected_resource_count = int(
self.services["service_offering"]["memory"])
self.assertEqual(
resource_count, expected_resource_count,
"Initial resource count should match with the expected resource count"
)
self.debug("Destroying instance: %s" % vm.name)
try:
vm.delete(self.apiclient)
except Exception as e:
self.fail("Failed to delete instance: %s" % e)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(
account_list, list,
"List Accounts should return a valid response")
resource_count = account_list[0].memorytotal
self.assertEqual(resource_count, 0,
"Resource count for %s should be 0" %
get_resource_type(resource_id=9)) #RAM
return
def test_04_deploy_multiple_vm(self):
"""Test Deploy multiple VM with specified RAM & verify the usage"""
# Validate the following
# 1. Create compute offering with specified RAM
# 2. Deploy multiple VMs with this service offering
# 3. List Resource count for the root admin Memory usage
# 4. Memory usage should list properly
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list, list,
"List Accounts should return a valid response")
resource_count = account_list[0].memorytotal
expected_resource_count = int(
self.services["service_offering"]["memory"])
self.assertEqual(
resource_count, expected_resource_count,
"Resource count should match with the expected resource count")
self.debug("Creating two instances with service offering: %s" %
self.service_offering.name)
vm_1 = self.createInstance(service_off=self.service_offering)
self.createInstance(service_off=self.service_offering)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list, list,
"List Accounts should return a valid response")
resource_count_new = account_list[0].memorytotal
expected_resource_count = int(
self.services["service_offering"]["memory"]) * 3 #Total 3 VMs
self.assertEqual(
resource_count_new, expected_resource_count,
"Resource count should match with the expected resource count")
self.debug("Destroying instance: %s" % vm_1.name)
try:
vm_1.delete(self.apiclient)
except Exception as e:
self.fail("Failed to delete instance: %s" % e)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list, list,
"List Accounts should return a valid response")
resource_count_after_delete = account_list[0].memorytotal
expected_resource_count -= int(
self.services["service_offering"]["memory"])
self.assertEqual(
resource_count_after_delete, expected_resource_count,
"Resource count should match with the expected resource count")
return
def test_02_migrate_instance(self):
"""Test Deploy VM with 4 core CPU & verify the usage"""
# Validate the following
# 1. Create compute offering with 4 core CPU & Deploy VM
# 2. List Resource count
# 3. Migrate instance to another host
# 4. Resource count should list properly.
self.debug("Setting up account and domain hierarchy")
self.setupAccounts()
users = {self.child_domain_1: self.child_do_admin_1,
self.child_domain_2: self.child_do_admin_2
}
for domain, admin in users.items():
self.account = admin
self.domain = domain
api_client = self.testClient.createUserApiClient(
UserName=self.account.name,
DomainName=self.account.domain)
self.debug("Creating an instance with service offering: %s" %
self.service_offering.name)
vm = self.createInstance(service_off=self.service_offering, api_client=api_client)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count = account_list[0].cputotal
expected_resource_count = int(self.services["service_offering"]["cpunumber"])
self.assertEqual(resource_count, expected_resource_count,
"Initial resource count should with the expected resource count")
host = find_suitable_host(self.apiclient, vm)
self.debug("Migrating instance: %s to host: %s" %
(vm.name, host.name))
try:
vm.migrate(self.apiclient, host.id)
except Exception as e:
self.fail("Failed to migrate instance: %s" % e)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count_after_migrate = account_list[0].cputotal
self.assertEqual(resource_count, resource_count_after_migrate,
"Resource count should be same after starting the instance")
return
def test_03_multiple_core_vm_delete_instance(self):
"""Test Deploy VM with 4 core CPU & verify the usage"""
# Validate the following
# 1. Create two domains and set specific resource (cpu) limit for them
# 2. Create compute offering with 4 core CPU & deploy vm
# 3. Update Resource count for the domains
# 4. delete instance and check resource count
# 5. Resource count should list properly.
self.debug("Setting up account and domain hierarchy")
self.setupAccounts()
users = {self.domain: self.admin,
self.child_domain: self.child_do_admin
}
for domain, admin in users.items():
self.account = admin
self.domain = domain
api_client = self.testClient.createUserApiClient(
UserName=self.account.name,
DomainName=self.account.domain)
self.debug("Creating an instance with service offering: %s" %
self.service_offering.name)
vm = self.createInstance(service_off=self.service_offering, api_client=api_client)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count = account_list[0].cputotal
expected_resource_count = int(self.services["service_offering"]["cpunumber"])
self.assertEqual(resource_count, expected_resource_count,
"Initial resource count should with the expected resource count")
self.debug("Destroying instance: %s" % vm.name)
try:
vm.delete(self.apiclient)
except Exception as e:
self.fail("Failed to delete instance: %s" % e)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count_after_delete = account_list[0].cputotal
self.assertEqual(resource_count_after_delete, 0,
"Resource count for %s should be 0" % get_resource_type(resource_id=8))#CPU
return
def test_02_migrate_instance(self):
"""Test Deploy VM with 4 core CPU & verify the usage"""
# Validate the following
# 1. Create compute offering with 4 core CPU & Deploy VM
# 2. List Resource count
# 3. Migrate instance to another host
# 4. Resource count should list properly.
self.debug("Setting up account and domain hierarchy")
self.setupAccounts()
users = {
self.child_domain_1: self.child_do_admin_1,
self.child_domain_2: self.child_do_admin_2
}
for domain, admin in users.items():
self.account = admin
self.domain = domain
api_client = self.testClient.createUserApiClient(
UserName=self.account.name, DomainName=self.account.domain)
self.debug("Creating an instance with service offering: %s" %
self.service_offering.name)
vm = self.createInstance(service_off=self.service_offering,
api_client=api_client)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list, list,
"List Accounts should return a valid response")
resource_count = account_list[0].cputotal
expected_resource_count = int(
self.services["service_offering"]["cpunumber"])
self.assertEqual(
resource_count, expected_resource_count,
"Initial resource count should with the expected resource count")
host = find_suitable_host(self.apiclient, vm)
self.debug("Migrating instance: %s to host: %s" % (vm.name, host.name))
try:
vm.migrate(self.apiclient, host.id)
except Exception as e:
self.fail("Failed to migrate instance: %s" % e)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list, list,
"List Accounts should return a valid response")
resource_count_after_migrate = account_list[0].cputotal
self.assertEqual(
resource_count, resource_count_after_migrate,
"Resource count should be same after starting the instance")
return
def test_01_multiplecore_start_stop_instance(self):
"""Test Deploy VM with multiple core CPU & verify the usage"""
# Validate the following
# 1. Deploy VM with multiple core CPU & verify the usage
# 2. Stop VM & verify the update resource count of Root Admin Account
# 3. Start VM & verify the update resource count of Root Admin Account
# 4. Resource count should list properly.
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count = account_list[0].cputotal
expected_resource_count = int(self.services["service_offering"]["cpunumber"])
self.assertEqual(resource_count, expected_resource_count,
"Resource count should match with the expected resource count")
self.debug("Stopping instance: %s" % self.vm.name)
try:
self.vm.stop(self.apiclient)
except Exception as e:
self.fail("Failed to stop instance: %s" % e)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count_after_stop = account_list[0].cputotal
self.assertEqual(resource_count, resource_count_after_stop,
"Resource count should be same after stopping the instance")
self.debug("Starting instance: %s" % self.vm.name)
try:
self.vm.start(self.apiclient)
except Exception as e:
self.fail("Failed to start instance: %s" % e)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count_after_start = account_list[0].cputotal
self.assertEqual(resource_count, resource_count_after_start,
"Resource count should be same after stopping the instance")
return
def test_03_delete_instance(self):
"""Test Deploy VM with 4 core CPU & verify the usage"""
# Validate the following
# 1. Create compute offering with 4 core CPU & Deploy VM
# 2. List Resource count for the CPU usage
# 3. Delete instance
# 4. Resource count should list as 0
self.debug("Setting up account and domain hierarchy")
self.setupAccounts()
users = {
self.child_domain_1: self.child_do_admin_1,
self.child_domain_2: self.child_do_admin_2
}
for domain, admin in users.items():
self.account = admin
self.domain = domain
api_client = self.testClient.createUserApiClient(
UserName=self.account.name, DomainName=self.account.domain)
self.debug("Creating an instance with service offering: %s" %
self.service_offering.name)
vm = self.createInstance(
service_off=self.service_offering, api_client=api_client)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list, list,
"List Accounts should return a valid response")
resource_count = account_list[0].cputotal
expected_resource_count = int(
self.services["service_offering"]["cpunumber"])
self.assertEqual(
resource_count, expected_resource_count,
"Initial resource count should match with the expected resource count"
)
self.debug("Destroying instance: %s" % vm.name)
try:
vm.delete(self.apiclient)
except Exception as e:
self.fail("Failed to delete instance: %s" % e)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list, list,
"List Accounts should return a valid response")
resource_count = account_list[0].cputotal
self.assertEqual(resource_count, 0, "Resource count for %s should be 0"
% get_resource_type(resource_id=8)) #CPU
return
def setupAccounts(self):
self.debug("Creating a sub-domain under: %s" % self.domain.name)
self.child_domain = Domain.create(
self.apiclient,
services=self.services["domain"],
parentdomainid=self.domain.id
)
self.child_do_admin = Account.create(
self.apiclient,
self.services["account"],
admin=True,
domainid=self.child_domain.id
)
# Cleanup the resources created at end of test
self.cleanup.append(self.child_do_admin)
self.cleanup.append(self.child_domain)
Resources.updateLimit(
self.apiclient,
resourcetype=8,
max=16,
account=self.child_do_admin.name,
domainid=self.child_do_admin.domainid
)
self.domain = Domain.create(
self.apiclient,
services=self.services["domain"],
parentdomainid=self.domain.id
)
self.admin = Account.create(
self.apiclient,
self.services["account"],
admin=True,
domainid=self.domain.id
)
# Cleanup the resources created at end of test
self.cleanup.append(self.admin)
self.cleanup.append(self.domain)
Resources.updateLimit(
self.apiclient,
resourcetype=8,
max=16,
account=self.admin.name,
domainid=self.admin.domainid
)
return
def setupAccounts(self):
self.debug("Creating a sub-domain under: %s" % self.domain.name)
self.child_domain = Domain.create(
self.apiclient,
services=self.services["domain"],
parentdomainid=self.domain.id
)
self.child_do_admin = Account.create(
self.apiclient,
self.services["account"],
admin=True,
domainid=self.child_domain.id
)
# Cleanup the resources created at end of test
self.cleanup.append(self.child_do_admin)
self.cleanup.append(self.child_domain)
Resources.updateLimit(
self.apiclient,
resourcetype=8,
max=16,
account=self.child_do_admin.name,
domainid=self.child_do_admin.domainid
)
self.domain = Domain.create(
self.apiclient,
services=self.services["domain"],
parentdomainid=self.domain.id
)
self.admin = Account.create(
self.apiclient,
self.services["account"],
admin=True,
domainid=self.domain.id
)
# Cleanup the resources created at end of test
self.cleanup.append(self.admin)
self.cleanup.append(self.domain)
Resources.updateLimit(
self.apiclient,
resourcetype=8,
max=16,
account=self.admin.name,
domainid=self.admin.domainid
)
return
def test_01_multiplecore_start_stop_instance(self):
"""Test Deploy VM with multiple core CPU & verify the usage"""
# Validate the following
# 1. Deploy VM with multiple core CPU & verify the usage
# 2. Stop VM & verify the update resource count of Root Admin Account
# 3. Start VM & verify the update resource count of Root Admin Account
# 4. Resource count should list properly.
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list, list,
"List Accounts should return a valid response")
resource_count = account_list[0].cputotal
expected_resource_count = int(
self.services["service_offering"]["cpunumber"])
self.assertEqual(
resource_count, expected_resource_count,
"Resource count should match with the expected resource count")
self.debug("Stopping instance: %s" % self.vm.name)
try:
self.vm.stop(self.apiclient)
except Exception as e:
self.fail("Failed to stop instance: %s" % e)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list, list,
"List Accounts should return a valid response")
resource_count_after_stop = account_list[0].cputotal
self.assertEqual(
resource_count, resource_count_after_stop,
"Resource count should be same after stopping the instance")
self.debug("Starting instance: %s" % self.vm.name)
try:
self.vm.start(self.apiclient)
except Exception as e:
self.fail("Failed to start instance: %s" % e)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list, list,
"List Accounts should return a valid response")
resource_count_after_start = account_list[0].cputotal
self.assertEqual(
resource_count, resource_count_after_start,
"Resource count should be same after stopping the instance")
return
def test_01_stop_start_instance(self):
"""Test Deploy VM with specified RAM & verify the usage"""
# Validate the following
# 1. Create compute offering with specified RAM & Deploy VM as root admin
# 2 .List Resource count for the root admin Memory usage
# 3. Stop and start instance, resource count should list properly.
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count = account_list[0].memorytotal
expected_resource_count = int(self.services["service_offering"]["memory"])
self.assertEqual(resource_count, expected_resource_count,
"Resource count should match with the expected resource count")
self.debug("Stopping instance: %s" % self.vm.name)
try:
self.vm.stop(self.apiclient)
except Exception as e:
self.fail("Failed to stop instance: %s" % e)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count_after_stop = account_list[0].memorytotal
self.assertEqual(resource_count, resource_count_after_stop,
"Resource count should be same after stopping the instance")
self.debug("Starting instance: %s" % self.vm.name)
try:
self.vm.start(self.apiclient)
except Exception as e:
self.fail("Failed to start instance: %s" % e)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count_after_start = account_list[0].memorytotal
self.assertEqual(resource_count, resource_count_after_start,
"Resource count should be same after stopping the instance")
return
def test_01_stop_start_instance(self):
"""Test Deploy VM with specified RAM & verify the usage"""
# Validate the following
# 1. Create compute offering with specified RAM & Deploy VM as root admin
# 2 .List Resource count for the root admin Memory usage
# 3. Stop and start instance, resource count should list properly.
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list, list,
"List Accounts should return a valid response")
resource_count = account_list[0].memorytotal
expected_resource_count = int(
self.services["service_offering"]["memory"])
self.assertEqual(
resource_count, expected_resource_count,
"Resource count should match with the expected resource count")
self.debug("Stopping instance: %s" % self.vm.name)
try:
self.vm.stop(self.apiclient)
except Exception as e:
self.fail("Failed to stop instance: %s" % e)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list, list,
"List Accounts should return a valid response")
resource_count_after_stop = account_list[0].memorytotal
self.assertEqual(
resource_count, resource_count_after_stop,
"Resource count should be same after stopping the instance")
self.debug("Starting instance: %s" % self.vm.name)
try:
self.vm.start(self.apiclient)
except Exception as e:
self.fail("Failed to start instance: %s" % e)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list, list,
"List Accounts should return a valid response")
resource_count_after_start = account_list[0].memorytotal
self.assertEqual(
resource_count, resource_count_after_start,
"Resource count should be same after stopping the instance")
return
def setUpClass(cls):
cls.apiClient = super(TestDeployVmWithUserData, cls).getClsTestClient().getApiClient()
cls.services = Services().services
cls.zone = get_zone(cls.apiClient, cls.services)
if cls.zone.localstorageenabled:
#For devcloud since localstroage is enabled
cls.services["service_offering"]["storagetype"] = "local"
cls.service_offering = ServiceOffering.create(
cls.apiClient,
cls.services["service_offering"]
)
cls.account = Account.create(cls.apiClient, services=cls.services["account"])
cls.cleanup = [cls.account]
cls.template = get_template(
cls.apiClient,
cls.zone.id,
cls.services["ostype"]
)
cls.debug("Successfully created account: %s, id: \
%s" % (cls.account.name,\
cls.account.id))
# Generate userdata of 2500 bytes. This is larger than the 2048 bytes limit.
# CS however allows for upto 4K bytes in the code. So this must succeed.
# Overall, the query length must not exceed 4K, for then the json decoder
# will fail this operation at the marvin client side itcls.
user_data = ''.join(random.choice(string.ascii_uppercase + string.digits) for x in range(2500))
cls.services["virtual_machine"]["userdata"] = user_data
def setUpClass(cls):
cls.api_client = super(TestSnapshotOnRootVolume,
cls).getClsTestClient().getApiClient()
cls.services = Services().services
cls.domain = get_domain(cls.api_client, cls.services)
cls.zone = get_zone(cls.api_client, cls.services)
cls.template = get_template(
cls.api_client,
cls.zone.id,
cls.services["ostype"])
cls.account = Account.create(cls.api_client,
cls.services["account"],
domainid=cls.domain.id)
# pdb.set_trace()
cls.service_offering = ServiceOffering.create(
cls.api_client,
cls.services["service_offering"])
cls.disk_offering = DiskOffering.create(
cls.api_client,
cls.services["disk_offering"],
domainid=cls.domain.id)
cls.service_offering2 = ServiceOffering.create(
cls.api_client,
cls.services["service_offering2"])
cls.disk_offering2 = DiskOffering.create(
cls.api_client,
cls.services["disk_offering2"],
domainid=cls.domain.id)
cls._cleanup = [cls.account,
cls.service_offering,
cls.disk_offering,
cls.service_offering2,
cls.disk_offering2]
def test_05_remove_used_range(self):
"""
Test removing used vlan range
"""
# 1. Use a vlan id from existing range by deploying an instance which
# will create a network with vlan id from this range
# 4. Now try to remove this vlan range
# 5. Vlan range should not get removed, should throw error
account = Account.create(self.apiclient,self.services["account"],
domainid=self.domain.id)
self.debug("Deploying instance in the account: %s" % account.name)
try:
self.virtual_machine = VirtualMachine.create(self.apiclient,self.services["virtual_machine"],
accountid=account.name,domainid=account.domainid,
serviceofferingid=self.service_offering.id,
mode=self.zone.networktype)
self.debug("Deployed instance in account: %s" % account.name)
self.debug("Trying to remove vlan range : %s , This should fail" % self.vlan["partial_range"][0])
with self.assertRaises(Exception) as e:
self.physicalnetwork.update(self.apiClient, id = self.physicalnetworkid, vlan = self.vlan["partial_range"][0])
self.debug("operation failed with exception: %s" % e.exception)
account.delete(self.apiclient)
except Exception as e:
self.fail("Exception in test case: %s" % e)
return
def setUp(self):
try:
self.apiclient = self.testClient.getApiClient()
self.dbclient = self.testClient.getDbConnection()
self.account = Account.create(self.apiclient,
self.services["account"],
domainid=self.domain.id)
self.cleanup = [
self.account,
]
self.virtual_machine = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id)
self.public_ip = PublicIPAddress.create(
self.apiclient,
accountid=self.virtual_machine.account,
zoneid=self.virtual_machine.zoneid,
domainid=self.virtual_machine.domainid,
services=self.services["virtual_machine"])
return
except cloudstackAPIException as e:
self.tearDown()
raise e
def setupProjectAccounts(self):
self.debug("Creating a domain under: %s" % self.domain.name)
self.domain = Domain.create(self.apiclient,
services=self.services["domain"],
parentdomainid=self.domain.id)
self.admin = Account.create(self.apiclient,
self.services["account"],
admin=True,
domainid=self.domain.id)
# Create project as a domain admin
self.project = Project.create(self.apiclient,
self.services["project"],
account=self.admin.name,
domainid=self.admin.domainid)
# Cleanup created project at end of test
self.cleanup.append(self.project)
self.cleanup.append(self.admin)
self.cleanup.append(self.domain)
self.debug("Created project with domain admin with name: %s" %
self.project.name)
projects = Project.list(self.apiclient,
id=self.project.id,
listall=True)
self.assertEqual(isinstance(projects, list), True,
"Check for a valid list projects response")
project = projects[0]
self.assertEqual(project.name, self.project.name,
"Check project name from list response")
return
def setUp(self):
self.testdata = TestData().testdata
self.apiclient = self.testClient.getApiClient()
# Get Zone, Domain and Default Built-in template
self.domain = get_domain(self.apiclient, self.testdata)
self.zone = get_zone(self.apiclient, self.testdata)
self.testdata["mode"] = self.zone.networktype
self.template = get_template(self.apiclient, self.zone.id, self.testdata["ostype"])
# for testing with specific template
# self.template = get_template(self.apiclient, self.zone.id, self.testdata["ostype"], templatetype='USER', services = {"template":'31f52a4d-5681-43f7-8651-ad4aaf823618'})
#create a user account
self.account = Account.create(
self.apiclient,
self.testdata["account"],
domainid=self.domain.id
)
#create a service offering
self.service_offering = ServiceOffering.create(
self.apiclient,
self.testdata["service_offering"]["small"]
)
#build cleanup list
self.cleanup = [
self.service_offering,
self.account
]
def setupAccounts(self, account_limit=2, domain_limit=2, project_limit=2):
self.debug("Creating a domain under: %s" % self.domain.name)
self.child_domain = Domain.create(self.apiclient,
services=self.services["domain"],
parentdomainid=self.domain.id)
self.debug("domain crated with domain id %s" % self.child_domain.id)
self.child_do_admin = Account.create(self.apiclient,
self.services["account"],
admin=True,
domainid=self.child_domain.id)
self.debug("domain admin created for domain id %s" %
self.child_do_admin.domainid)
# Create project as a domain admin
self.project = Project.create(self.apiclient,
self.services["project"],
account=self.child_do_admin.name,
domainid=self.child_do_admin.domainid)
# Cleanup created project at end of test
self.cleanup.append(self.project)
# Cleanup accounts created
self.cleanup.append(self.child_do_admin)
self.cleanup.append(self.child_domain)
self.debug("Updating the CPU resource count for domain: %s" %
self.child_domain.name)
# Update resource limits for account 1
responses = Resources.updateLimit(self.apiclient,
resourcetype=8,
max=account_limit,
account=self.child_do_admin.name,
domainid=self.child_do_admin.domainid)
self.debug("CPU Resource count for child domain admin account is now: %s" %
responses.max)
self.debug("Updating the CPU limit for project")
responses = Resources.updateLimit(self.apiclient,
resourcetype=8,
max=project_limit,
projectid=self.project.id)
self.debug("CPU Resource count for project is now")
self.debug(responses.max)
self.debug("Updating the CPU limit for domain only")
responses = Resources.updateLimit(self.apiclient,
resourcetype=8,
max=domain_limit,
domainid=self.child_domain.id)
self.debug("CPU Resource count for domain %s with id %s is now %s" %
(responses.domain, responses.domainid, responses.max))
return
def setUpClass(cls):
cls.api_client = super(TestSnapshotOnRootVolume,
cls).getClsTestClient().getApiClient()
cls.services = Services().services
cls.domain = get_domain(cls.api_client, cls.services)
cls.zone = get_zone(cls.api_client, cls.services)
cls.template = get_template(cls.api_client, cls.zone.id,
cls.services["ostype"])
cls.account = Account.create(cls.api_client,
cls.services["account"],
domainid=cls.domain.id)
# pdb.set_trace()
cls.service_offering = ServiceOffering.create(
cls.api_client, cls.services["service_offering"])
cls.disk_offering = DiskOffering.create(cls.api_client,
cls.services["disk_offering"],
domainid=cls.domain.id)
cls.service_offering2 = ServiceOffering.create(
cls.api_client, cls.services["service_offering2"])
cls.disk_offering2 = DiskOffering.create(
cls.api_client,
cls.services["disk_offering2"],
domainid=cls.domain.id)
cls._cleanup = [
cls.account, cls.service_offering, cls.disk_offering,
cls.service_offering2, cls.disk_offering2
]
def test_04_deploy_multiple_vm_with_multiple_cpus(self):
"""Test Deploy multiple VM with 4 core CPU & verify the usage"""
# Validate the following
# 1. Create compute offering with 4 core CPU
# 2. Deploy multiple VMs with this service offering
# 3. List Resource count for the root admin CPU usage
# 4. CPU usage should list properly
# 5. Destroy one VM among multiple VM's and verify the resource count
# 6. Migrate VM from & verify resource updates
# 7. List resource count for Root Admin
# 8. Failed to deploy VM and verify the resource usage
self.debug("Creating service offering with 4 CPU cores")
self.service_offering = ServiceOffering.create(
self.apiclient, self.services["service_offering"])
# Adding to cleanup list after execution
self.cleanup.append(self.service_offering)
self.debug("Creating an instance with service offering: %s" %
self.service_offering.name)
vm_1 = self.createInstance(service_off=self.service_offering)
vm_2 = self.createInstance(service_off=self.service_offering)
self.createInstance(service_off=self.service_offering)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list, list,
"List Accounts should return a valid response")
resource_count = account_list[0].cputotal
expected_resource_count = int(
self.services["service_offering"]["cpunumber"]) * 4 #Total 4 Vms
self.assertTrue(resource_count == expected_resource_count,
"Resource count does not match the expected vavlue")
return
def setUp(self):
self.apiclient = self.testClient.getApiClient()
self.dbclient = self.testClient.getDbConnection()
self.account = Account.create(self.apiclient,
self.services["account"],
domainid=self.domain.id)
self.virtual_machine = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id)
self.virtual_machine_2 = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id)
self.public_ip = PublicIPAddress.create(
self.apiclient, self.virtual_machine.account,
self.virtual_machine.zoneid, self.virtual_machine.domainid,
self.services["virtual_machine"])
NATRule.create(self.apiclient,
self.virtual_machine,
self.services["natrule"],
ipaddressid=self.public_ip.ipaddress.id)
self.cleanup = [
self.account,
]
return
def setUp(self):
try:
self.apiclient = self.testClient.getApiClient()
self.dbclient = self.testClient.getDbConnection()
self.account = Account.create(
self.apiclient,
self.services["account"],
domainid=self.domain.id
)
self.cleanup = [
self.account,
]
self.virtual_machine = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id
)
self.public_ip = PublicIPAddress.create(
self.apiclient,
accountid=self.virtual_machine.account,
zoneid=self.virtual_machine.zoneid,
domainid=self.virtual_machine.domainid,
services=self.services["virtual_machine"]
)
return
except cloudstackAPIException as e:
self.tearDown()
raise e
def setUp(self):
self.apiclient = self.testClient.getApiClient()
self.dbclient = self.testClient.getDbConnection()
self.account = Account.create(
self.apiclient,
self.services["account"],
domainid=self.domain.id
)
self.virtual_machine = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id
)
self.public_ip = PublicIPAddress.create(
self.apiclient,
self.virtual_machine.account,
self.virtual_machine.zoneid,
self.virtual_machine.domainid,
self.services["virtual_machine"]
)
self.cleanup = [
self.account,
]
return
def setUp(self):
self.apiclient = self.testClient.getApiClient()
self.account = Account.create(
self.apiclient,
self.services["account"],
admin=True,
domainid=self.domain.id
)
self.cleanup = [self.account]
self.debug("Creating a VPC offering..")
self.vpc_off = VpcOffering.create(
self.apiclient,
self.services["vpc_offering"]
)
self.debug("Enabling the VPC offering created")
self.vpc_off.update(self.apiclient, state='Enabled')
self.debug("Creating a VPC network in the account: %s" % self.account.name)
self.services["vpc"]["cidr"] = '10.1.1.1/16'
self.vpc = VPC.create(
self.apiclient,
self.services["vpc"],
vpcofferingid=self.vpc_off.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid
)
return
def setUpClass(cls):
cls._cleanup = []
cls.api_client = super(TestEgressFWRules,
cls).getClsTestClient().getApiClient()
cls.services = Services().services
# Get Zone Domain and create Domains and sub Domains.
cls.domain = get_domain(cls.api_client, cls.services)
cls.zone = get_zone(cls.api_client, cls.services)
cls.services['mode'] = cls.zone.networktype
# Get and set template id for VM creation.
cls.template = get_template(cls.api_client,
cls.zone.id,
cls.services["ostype"])
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = cls.template.id
parentDomain = None
cls.domain = Domain.create(cls.api_client,
cls.services["domain"],
parentdomainid=parentDomain.id if parentDomain else None)
cls._cleanup.append(cls.domain)
# Create an Account associated with domain
cls.account = Account.create(cls.api_client,
cls.services["account"],
domainid=cls.domain.id)
cls._cleanup.append(cls.account)
# Create service offerings.
cls.service_offering = ServiceOffering.create(cls.api_client,
cls.services["service_offering"])
# Cleanup
cls._cleanup.append(cls.service_offering)
def setUpClass(cls):
cls.apiclient = super(TestDeployVmWithVariedPlanners, cls).getClsTestClient().getApiClient()
cls.services = Services().services
# Get Zone, Domain and templates
cls.domain = get_domain(cls.apiclient, cls.services)
cls.zone = get_zone(cls.apiclient, cls.services)
cls.template = get_template(
cls.apiclient,
cls.zone.id,
cls.services["ostype"]
)
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["template"] = cls.template.id
cls.services["zoneid"] = cls.zone.id
cls.account = Account.create(
cls.apiclient,
cls.services["account"],
domainid=cls.domain.id
)
cls.services["account"] = cls.account.name
cls.hosts = Host.list(cls.apiclient, type='Routing')
cls.clusters = Cluster.list(cls.apiclient)
cls.cleanup = [
cls.account
]
def setupProjectAccounts(self):
self.debug("Creating a domain under: %s" % self.domain.name)
self.domain = Domain.create(self.apiclient,
services=self.services["domain"],
parentdomainid=self.domain.id)
self.admin = Account.create(
self.apiclient,
self.services["account"],
admin=True,
domainid=self.domain.id
)
# Create project as a domain admin
self.project = Project.create(self.apiclient,
self.services["project"],
account=self.admin.name,
domainid=self.admin.domainid)
# Cleanup created project at end of test
self.cleanup.append(self.project)
self.cleanup.append(self.admin)
self.cleanup.append(self.domain)
self.debug("Created project with domain admin with name: %s" %
self.project.name)
projects = Project.list(self.apiclient, id=self.project.id,
listall=True)
self.assertEqual(isinstance(projects, list), True,
"Check for a valid list projects response")
project = projects[0]
self.assertEqual(project.name, self.project.name,
"Check project name from list response")
return
def create_domain_account_user(parentDomain=None):
domain = Domain.create(cls.api_client,
cls.services["domain"],
parentdomainid=parentDomain.id if parentDomain else None)
cls._cleanup.append(domain)
# Create an Account associated with domain
account = Account.create(cls.api_client,
cls.services["account"],
domainid=domain.id)
cls._cleanup.append(account)
# Create an User, Project, Volume associated with account
user = User.create(cls.api_client,
cls.services["user"],
account=account.name,
domainid=account.domainid)
cls._cleanup.append(user)
project = Project.create(cls.api_client,
cls.services["project"],
account=account.name,
domainid=account.domainid)
cls._cleanup.append(project)
volume = Volume.create(cls.api_client,
cls.services["volume"],
zoneid=cls.zone.id,
account=account.name,
domainid=account.domainid,
diskofferingid=cls.disk_offering.id)
cls._cleanup.append(volume)
return {'domain':domain, 'account':account, 'user':user, 'project':project, 'volume':volume}
def setUp(self):
self.apiclient = self.testClient.getApiClient()
self.account = Account.create(self.apiclient,
self.services["account"],
admin=True,
domainid=self.domain.id)
self.cleanup = [self.account]
self.debug("Creating a VPC offering..")
self.vpc_off = VpcOffering.create(self.apiclient,
self.services["vpc_offering"])
self.cleanup.append(self.vpc_off)
self.debug("Enabling the VPC offering created")
self.vpc_off.update(self.apiclient, state='Enabled')
self.debug("Creating a VPC network in the account: %s" %
self.account.name)
self.services["vpc"]["cidr"] = '10.1.1.1/16'
self.vpc = VPC.create(self.apiclient,
self.services["vpc"],
vpcofferingid=self.vpc_off.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid)
return
def setUp(self):
self.testdata = TestData().testdata
self.apiclient = self.testClient.getApiClient()
# Get Zone, Domain and Default Built-in template
self.domain = get_domain(self.apiclient, self.testdata)
self.zone = get_zone(self.apiclient, self.testdata)
self.testdata["mode"] = self.zone.networktype
self.template = get_template(self.apiclient, self.zone.id, self.testdata["ostype"])
#create a user account
self.account = Account.create(
self.apiclient,
self.testdata["account"],
domainid=self.domain.id
)
#create a service offering
self.service_offering = ServiceOffering.create(
self.apiclient,
self.testdata["service_offering"]["small"]
)
#build cleanup list
self.cleanup = [
self.service_offering,
self.account
]
def setUpClass(cls):
cls.apiClient = super(TestDeployVmWithUserData,
cls).getClsTestClient().getApiClient()
cls.services = Services().services
cls.zone = get_zone(cls.apiClient, cls.services)
if cls.zone.localstorageenabled:
#For devcloud since localstroage is enabled
cls.services["service_offering"]["storagetype"] = "local"
cls.service_offering = ServiceOffering.create(
cls.apiClient, cls.services["service_offering"])
cls.account = Account.create(cls.apiClient,
services=cls.services["account"])
cls.cleanup = [cls.account]
cls.template = get_template(cls.apiClient, cls.zone.id,
cls.services["ostype"])
cls.debug("Successfully created account: %s, id: \
%s" % (cls.account.name,\
cls.account.id))
# Generate userdata of 2500 bytes. This is larger than the 2048 bytes limit.
# CS however allows for upto 4K bytes in the code. So this must succeed.
# Overall, the query length must not exceed 4K, for then the json decoder
# will fail this operation at the marvin client side itcls.
user_data = ''.join(
random.choice(string.ascii_uppercase + string.digits)
for x in range(2500))
cls.services["virtual_machine"]["userdata"] = user_data
def setUp(self):
self.services = Services().services
self.apiclient = self.testClient.getApiClient()
# Get Zone, Domain and Default Built-in template
self.domain = get_domain(self.apiclient, self.services)
self.zone = get_zone(self.apiclient, self.services)
self.services["mode"] = self.zone.networktype
# Before running this test, register a windows template with ostype as 'Windows 7 (32-bit)'
self.template = get_template(self.apiclient, self.zone.id, self.services["ostype"], templatetype='USER')
#create a user account
self.account = Account.create(
self.apiclient,
self.services["account"],
domainid=self.domain.id
)
self.services["vgpu260q"]["zoneid"] = self.zone.id
self.services["vgpu260q"]["template"] = self.template.id
self.services["vgpu140q"]["zoneid"] = self.zone.id
self.services["vgpu140q"]["template"] = self.template.id
#create a service offering
self.service_offering = ServiceOffering.create(
self.apiclient,
self.services["service_offerings"]["vgpu260qwin"],
serviceofferingdetails={'pciDevice': 'VGPU'}
)
#build cleanup list
self.cleanup = [
self.service_offering,
self.account
]
def test_04_deploy_multiple_vm_with_multiple_cpus(self):
"""Test Deploy multiple VM with 4 core CPU & verify the usage"""
# Validate the following
# 1. Create compute offering with 4 core CPU
# 2. Deploy multiple VMs with this service offering
# 3. List Resource count for the root admin CPU usage
# 4. CPU usage should list properly
# 5. Destroy one VM among multiple VM's and verify the resource count
# 6. Migrate VM from & verify resource updates
# 7. List resource count for Root Admin
# 8. Failed to deploy VM and verify the resource usage
self.debug("Creating service offering with 4 CPU cores")
self.service_offering = ServiceOffering.create(
self.apiclient, self.services["service_offering"])
# Adding to cleanup list after execution
self.cleanup.append(self.service_offering)
self.debug("Creating an instance with service offering: %s" %
self.service_offering.name)
vm_1 = self.createInstance(service_off=self.service_offering)
vm_2 = self.createInstance(service_off=self.service_offering)
self.createInstance(service_off=self.service_offering)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list, list,
"List Accounts should return a valid response")
resource_count = account_list[0].cputotal
expected_resource_count = int(
self.services["service_offering"]["cpunumber"]) * 4 #Total 4 Vms
self.assertTrue(resource_count == expected_resource_count,
"Resource count does not match the expected vavlue")
return
def test_operations_non_root_admin_api_client(self, value):
"""Test basic operations using non root admin apii client"""
# Steps:
# 1. Create Domain and Account in it
# 2. Create network in it (isoalted/ shared/ vpc)
# 3. Create User API client of this account
# 4. Deploy a VM in this network and account
# 5. Add secondary IP to the default nic of VM using non root admin api client
# 6. List secondary IPs using non root admin api client
# 7. Remove secondary IP using non root admin api client
# Validations:
# 1. All the operations should be successful
child_domain = Domain.create(self.apiclient,services=self.services["domain"],
parentdomainid=self.domain.id)
self.account = Account.create(self.apiclient,self.services["account"],domainid=child_domain.id)
self.cleanup.append(self.account)
self.cleanup.append(child_domain)
apiclient = self.testClient.createUserApiClient(UserName=self.account.name, DomainName=self.account.domain)
if(shouldTestBeSkipped(networkType=value, zoneType=self.mode)):
self.skipTest("Skipping test as %s network is not supported in basic zone" % value)
network = createNetwork(self, value)
try:
virtual_machine = VirtualMachine.create(self.apiclient,self.services["virtual_machine"],
networkids=[network.id],serviceofferingid=self.service_offering.id,
accountid=self.account.name,domainid=self.account.domainid)
except Exception as e:
self.fail("vm creation failed: %s" % e)
try:
ipaddress_1 = NIC.addIp(apiclient, id=virtual_machine.nic[0].id)
except Exception as e:
self.fail("Failed while adding secondary IP to NIC of vm %s" % virtual_machine.id)
try:
NIC.list(apiclient, virtualmachineid=virtual_machine.id)
except Exception as e:
self.fail("Listing NICs for virtual machine %s failed with Exception %s" % (virtual_machine.id, e))
try:
NIC.list(apiclient, virtualmachineid=virtual_machine.id, nicid=virtual_machine.nic[0].id)
except Exception as e:
self.fail("Listing NICs for virtual machine %s and nic id %s failed with Exception %s" %
(virtual_machine.id, virtual_machine.nic[0].id, e))
try:
NIC.removeIp(apiclient, ipaddressid=ipaddress_1.id)
except Exception as e:
self.fail("Removing seondary IP %s from NIC failed as expected with Exception %s" % (ipaddress_1.id,e))
return
def test_add_static_nat_rule(self, value):
""" Add secondary IP to NIC of a VM"""
# Steps:
# 1. Create Account and create network in it (isoalted/ shared/ vpc)
# 2. Deploy a VM in this network and account
# 3. Add 2 secondary IPs to the default nic of VM
# 4. Acquire public IP, open firewall for it, and
# create static NAT rule for this public IP to the 1st secondary IP
# 5. Repeat step 4 for another public IP
# 6. Repeat step 4 for 2nd secondary IP
# 7. Repeat step 4 for invalid secondary IP
# 8. Try to remove 1st secondary IP (with active static nat rule)
# Validations:
# 1. Step 4 should succeed
# 2. Step 5 should succeed
# 3. Step 6 should succeed
# 4. Step 7 should fail
# 5. Step 8 should succeed
self.account = Account.create(self.apiclient,self.services["account"],domainid=self.domain.id)
self.cleanup.append(self.account)
network = createNetwork(self, value)
try:
virtual_machine = VirtualMachine.create(self.apiclient,self.services["virtual_machine"],
networkids=[network.id],serviceofferingid=self.service_offering.id,
accountid=self.account.name,domainid=self.account.domainid)
except Exception as e:
self.fail("vm creation failed: %s" % e)
try:
ipaddress_1 = NIC.addIp(self.apiclient, id=virtual_machine.nic[0].id)
except Exception as e:
self.fail("Failed while adding secondary IP to NIC of vm %s" % virtual_machine.id)
try:
ipaddress_2 = NIC.addIp(self.apiclient, id=virtual_machine.nic[0].id)
except Exception as e:
self.fail("Failed while adding secondary IP to NIC of vm %s" % virtual_machine.id)
self.assertEqual(createNetworkRules(self, virtual_machine, network, ipaddress_1.ipaddress, value, ruletype="staticnat"),
PASS, "Failure in creating NAT rule")
self.assertEqual(createNetworkRules(self, virtual_machine, network, ipaddress_1.ipaddress, value, ruletype="staticnat"),
FAIL, "Failure in creating NAT rule")
self.assertEqual(createNetworkRules(self, virtual_machine, network, ipaddress_2.ipaddress, value, ruletype="staticnat"),
PASS, "Failure in creating NAT rule")
self.assertEqual(createNetworkRules(self, virtual_machine, network, "255.255.255.300", value, ruletype="staticnat"),
FAIL, "Failure in NAT rule creation")
try:
NIC.removeIp(self.apiclient, ipaddress_1.id)
self.fail("Ip address should not get removed when active static NAT rule is defined for it")
except Exception as e:
self.debug("Exception while removing secondary ip address as expected because static nat rule is present for it")
return
def setUp(self):
self.apiclient = self.testClient.getApiClient()
self.dbclient = self.testClient.getDbConnection()
self.account = Account.create(self.apiclient,
self.services["account"],
admin=True,
domainid=self.domain.id)
self.cleanup = [self.account]
return
def test_disable_static_nat(self, value):
""" Add secondary IP to NIC of a VM"""
# Steps:
# 1. Create Account and create network in it (isoalted/ shared/ vpc)
# 2. Deploy a VM in this network and account
# 3. Add 2 secondary IPs to the default nic of VM
# 4. Acquire public IP, open firewall for it, and
# enable static NAT rule for this public IP to the 1st secondary IP
# 5. Disable the static nat rule and enable it again
# Validations:
# 1. Verify step 5 by listing seconday IP and checking the appropriate flag
self.account = Account.create(self.apiclient,self.services["account"],domainid=self.domain.id)
self.cleanup.append(self.account)
network = createNetwork(self, value)
try:
virtual_machine = VirtualMachine.create(self.apiclient,self.services["virtual_machine"],
networkids=[network.id],serviceofferingid=self.service_offering.id,
accountid=self.account.name,domainid=self.account.domainid)
except Exception as e:
self.fail("vm creation failed: %s" % e)
try:
ipaddress_1 = NIC.addIp(self.apiclient, id=virtual_machine.nic[0].id)
except Exception as e:
self.fail("Failed while adding secondary IP to NIC of vm %s" % virtual_machine.id)
public_ip = PublicIPAddress.create(self.api_client,accountid=self.account.name,
zoneid=self.zone.id,domainid=self.account.domainid,
networkid=network.id, vpcid = network.vpcid if value == VPC_NETWORK else None)
if value != VPC_NETWORK:
FireWallRule.create(self.apiclient,ipaddressid=public_ip.ipaddress.id,
protocol='TCP', cidrlist=[self.services["fwrule"]["cidr"]],
startport=self.services["fwrule"]["startport"],endport=self.services["fwrule"]["endport"])
StaticNATRule.enable(self.apiclient, public_ip.ipaddress.id, virtual_machine.id,
network.id, vmguestip=ipaddress_1.ipaddress)
self.VerifyStaticNatForPublicIp(public_ip.ipaddress.id, True)
# Disabling static NAT
StaticNATRule.disable(self.apiclient, public_ip.ipaddress.id)
self.VerifyStaticNatForPublicIp(public_ip.ipaddress.id, False)
StaticNATRule.enable(self.apiclient, public_ip.ipaddress.id, virtual_machine.id,
network.id, vmguestip=ipaddress_1.ipaddress)
self.VerifyStaticNatForPublicIp(public_ip.ipaddress.id, True)
public_ip.delete(self.apiclient)
return
def test_add_ip_to_nic(self, value):
""" Add secondary IP to NIC of a VM"""
# Steps:
# 1. Create Account and create network in it (isoalted/ shared/ vpc)
# 2. Deploy a VM in this network and account
# 3. Add secondary IP to the default nic of VM
# 4. Try to add the same IP again
# 5. Try to add secondary IP providing wrong virtual machine id
# 6. Try to add secondary IP with correct virtual machine id but wrong IP address
# Validations:
# 1. Step 3 should succeed
# 2. Step 4 should fail
# 3. Step 5 should should fail
# 4. Step 6 should fail
self.account = Account.create(self.apiclient,self.services["account"],domainid=self.domain.id)
self.cleanup.append(self.account)
if(shouldTestBeSkipped(networkType=value, zoneType=self.mode)):
self.skipTest("Skipping test as %s network is not supported in basic zone" % value)
network = createNetwork(self, value)
try:
virtual_machine = VirtualMachine.create(self.apiclient,self.services["virtual_machine"],
networkids=[network.id],serviceofferingid=self.service_offering.id,
accountid=self.account.name,domainid=self.account.domainid)
except Exception as e:
self.fail("vm creation failed: %s" % e)
try:
ipaddress_1 = NIC.addIp(self.apiclient, id=virtual_machine.nic[0].id)
except Exception as e:
self.fail("Failed while adding secondary IP to NIC of vm %s" % virtual_machine.id)
try:
NIC.addIp(self.apiclient, id=virtual_machine.nic[0].id, ipaddress=ipaddress_1.ipaddress)
self.debug("Adding already added secondary IP %s to NIC of vm %s succeeded, should have failed" %
(ipaddress_1.ipaddress, virtual_machine.id))
except Exception as e:
self.debug("Failed while adding already added secondary IP to NIC of vm %s" % virtual_machine.id)
try:
NIC.addIp(self.apiclient, id=(virtual_machine.nic[0].id + random_gen()))
self.fail("Adding secondary IP with wrong NIC id succeded, it shoud have failed")
except Exception as e:
self.debug("Failed while adding secondary IP to wrong NIC")
try:
NIC.addIp(self.apiclient, id=virtual_machine.nic[0].id, ipaddress = "255.255.255.300")
self.fail("Adding secondary IP with wrong ipaddress succeded, it should have failed")
except Exception as e:
self.debug("Failed while adding wrong secondary IP to NIC of VM %s" % virtual_machine.id)
return
def test_04_deploy_multiple_vm(self):
"""Test Deploy multiple VM with specified RAM & verify the usage"""
# Validate the following
# 1. Create compute offering with specified RAM
# 2. Deploy multiple VMs with this service offering
# 3. List Resource count for the root admin Memory usage
# 4. Memory usage should list properly
# Resetting the memory count of service offering
self.services["service_offering"]["memory"] = 2048
self.debug("Setting up account and domain hierarchy")
self.setupAccounts()
users = {
self.child_domain_1: self.child_do_admin_1,
self.child_domain_2: self.child_do_admin_2
}
for domain, admin in users.items():
self.account = admin
self.domain = domain
self.debug("Creating an instance with service offering: %s" %
self.service_offering.name)
api_client = self.testClient.createUserApiClient(
UserName=self.account.name, DomainName=self.account.domain)
vm_1 = self.createInstance(service_off=self.service_offering,
api_client=api_client)
vm_2 = self.createInstance(service_off=self.service_offering,
api_client=api_client)
vm_3 = self.createInstance(service_off=self.service_offering,
api_client=api_client)
self.debug(
"Deploying instance - Memory capacity is fully utilized")
with self.assertRaises(Exception):
self.createInstance(service_off=self.service_offering,
api_client=api_client)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(
account_list, list,
"List Accounts should return a valid response")
resource_count = account_list[0].memorytotal
expected_resource_count = int(
self.services["service_offering"]["memory"]) * 3 #Total 3 VMs
self.assertEqual(
resource_count, expected_resource_count,
"Resource count should match with the expected resource count")
vm_2.delete(self.apiclient)
vm_3.delete(self.apiclient)
return
def setUp(self):
self.testdata = TestData().testdata
self.apiclient = self.testClient.getApiClient()
# Get Zone, Domain and Default Built-in template
self.domain = get_domain(self.apiclient, self.testdata)
self.zone = get_zone(self.apiclient, self.testdata)
self.testdata["mode"] = self.zone.networktype
self.template = get_template(self.apiclient, self.zone.id,
self.testdata["ostype"])
#create a user account
self.account = Account.create(self.apiclient,
self.testdata["account"],
domainid=self.domain.id)
#create a service offering
self.service_offering = ServiceOffering.create(
self.apiclient, self.testdata["service_offering"]["small"])
#build cleanup list
self.cleanup = [self.service_offering, self.account]
# Validate the following:
# 1. Virtual Machine is accessible via SSH
# 2. listVirtualMachines returns accurate information
self.virtual_machine = VirtualMachine.create(
self.apiclient,
self.testdata["virtual_machine"],
accountid=self.account.name,
zoneid=self.zone.id,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
templateid=self.template.id)
list_vms = VirtualMachine.list(self.apiclient,
id=self.virtual_machine.id)
self.debug(
"Verify listVirtualMachines response for virtual machine: %s"\
% self.virtual_machine.id
)
self.assertEqual(isinstance(list_vms, list), True,
"List VM response was not a valid list")
self.assertNotEqual(len(list_vms), 0, "List VM response was empty")
vm = list_vms[0]
self.assertEqual(vm.id, self.virtual_machine.id,
"Virtual Machine ids do not match")
self.assertEqual(vm.name, self.virtual_machine.name,
"Virtual Machine names do not match")
self.assertEqual(vm.state, "Running", msg="VM is not in Running state")
def setUp(self):
self.apiclient = self.testClient.getApiClient()
self.dbclient = self.testClient.getDbConnection()
self.account = Account.create(self.apiclient,
self.services["account"],
admin=True)
self.debug("Creating service offering with 5 GB RAM")
self.cleanup = [
self.account,
]
return
def test_03_delete_instance(self):
"""Test Deploy VM with specified GB RAM & verify the usage"""
# Validate the following
# 1. Create compute offering with specified RAM & Deploy VM as root admin
# 2. List Resource count for the root admin Memory usage
# 3. Delete instance, resource count should be 0 after delete operation.
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list, list,
"List Accounts should return a valid response")
resource_count = account_list[0].memorytotal
expected_resource_count = int(
self.services["service_offering"]["memory"])
self.assertEqual(
resource_count, expected_resource_count,
"Resource count should match with the expected resource count")
self.debug("Destroying instance: %s" % self.vm.name)
try:
self.vm.delete(self.apiclient)
except Exception as e:
self.fail("Failed to delete instance: %s" % e)
# Wait for expunge interval to cleanup Memory
wait_for_cleanup(self.apiclient,
["expunge.delay", "expunge.interval"])
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list, list,
"List Accounts should return a valid response")
resource_count_after_delete = account_list[0].memorytotal
self.assertEqual(resource_count_after_delete, 0,
"Resource count for %s should be 0" %
get_resource_type(resource_id=9)) #RAM
return
def test_disassociate_ip_mapped_to_secondary_ip_through_PF_rule(self, value):
""" Add secondary IP to NIC of a VM"""
## Steps:
# 1. Create Account and create network in it (isoalted/ shared/ vpc)
# 2. Deploy a VM in this network and account
# 3. Add secondary IP to the default nic of VM
# 4. Acquire public IP, open firewall for it, and
# create NAT rule for this public IP to the 1st secondary IP
# 5. Try to delete the public IP used for NAT rule
# Validations:
# 1. Step 5 should succeed
self.account = Account.create(self.apiclient,self.services["account"],domainid=self.domain.id)
self.cleanup.append(self.account)
network = createNetwork(self, value)
try:
virtual_machine = VirtualMachine.create(self.apiclient,self.services["virtual_machine"],
networkids=[network.id],serviceofferingid=self.service_offering.id,
accountid=self.account.name,domainid=self.account.domainid)
except Exception as e:
self.fail("vm creation failed: %s" % e)
try:
ipaddress_1 = NIC.addIp(self.apiclient, id=virtual_machine.nic[0].id)
except Exception as e:
self.fail("Failed while adding secondary IP to NIC of vm %s" % virtual_machine.id)
public_ip = PublicIPAddress.create(self.api_client,accountid=self.account.name,
zoneid=self.zone.id,domainid=self.account.domainid,
networkid=network.id, vpcid = network.vpcid if value == VPC_NETWORK else None)
if value != VPC_NETWORK:
FireWallRule.create(self.apiclient,ipaddressid=public_ip.ipaddress.id,
protocol='TCP', cidrlist=[self.services["fwrule"]["cidr"]],
startport=self.services["fwrule"]["startport"],endport=self.services["fwrule"]["endport"])
# Create NAT rule
natrule = NATRule.create(self.api_client, virtual_machine,
self.services["natrule"],ipaddressid=public_ip.ipaddress.id,
networkid=network.id, vmguestip = ipaddress_1.ipaddress)
try:
public_ip.delete(self.apiclient)
except Exception as e:
self.fail("Exception while deleting nat rule %s: %s" % (natrule.id, e))
return
