def test_03_project_vmlifecycle_delete_instance(self):
# Validate the following
# 1. Assign account to projects and verify the resource updates
# 2. Deploy VM with the accounts added to the project
# 3. Destroy VM of an accounts added to the project
# 4. Resource count should list as 0 after destroying the instance
self.debug("Checking memory resource count for project: %s" % self.project.name)
project_list = Project.list(self.apiclient, id=self.project.id, listall=True)
self.debug(project_list)
self.assertIsInstance(project_list, list, "List Projects should return a valid response")
resource_count = project_list[0].memorytotal
self.debug(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"])
self.debug("Checking memory resource count for project: %s" % self.project.name)
project_list = Project.list(self.apiclient, id=self.project.id, listall=True)
self.assertIsInstance(project_list, list, "List Projects should return a valid response")
resource_count_after_delete = project_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_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.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_project_counts_delete_instance(self):
# Validate the following
# 1. Assign account to projects and verify the resource updates
# 2. Deploy VM with the accounts added to the project
# 3. Destroy VM of an accounts added to the project to a new host
# 4. Resource count should list properly.
project_list = Project.list(self.apiclient, id=self.project.id, listall=True)
self.assertIsInstance(project_list, list, "List Projects should return a valid response")
resource_count = project_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)
project_list = Project.list(self.apiclient, id=self.project.id, listall=True)
self.assertIsInstance(project_list, list, "List Projects should return a valid response")
resource_count_after_delete = project_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_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_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.getUserApiClient(
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 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.getUserApiClient(
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_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.getUserApiClient(
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_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.getUserApiClient(
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_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.getUserApiClient(
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_03_project_vmlifecycle_delete_instance(self):
# Validate the following
# 1. Assign account to projects and verify the resource updates
# 2. Deploy VM with the accounts added to the project
# 3. Destroy VM of an accounts added to the project
# 4. Resource count should list as 0 after destroying the instance
self.debug("Checking memory resource count for project: %s" %
self.project.name)
project_list = Project.list(self.apiclient,
id=self.project.id,
listall=True)
self.debug(project_list)
self.assertIsInstance(project_list, list,
"List Projects should return a valid response")
resource_count = project_list[0].memorytotal
self.debug(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"])
self.debug("Checking memory resource count for project: %s" %
self.project.name)
project_list = Project.list(self.apiclient,
id=self.project.id,
listall=True)
self.assertIsInstance(project_list, list,
"List Projects should return a valid response")
resource_count_after_delete = project_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_03_project_counts_delete_instance(self):
# Validate the following
# 1. Assign account to projects and verify the resource updates
# 2. Deploy VM with the accounts added to the project
# 3. Destroy VM of an accounts added to the project to a new host
# 4. Resource count should list properly.
project_list = Project.list(self.apiclient,
id=self.project.id,
listall=True)
self.assertIsInstance(project_list, list,
"List Projects should return a valid response")
resource_count = project_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)
project_list = Project.list(self.apiclient,
id=self.project.id,
listall=True)
self.assertIsInstance(project_list, list,
"List Projects should return a valid response")
resource_count_after_delete = project_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_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_01_multiple_child_domains(self):
"""Test memory limits with multiple child domains"""
# Validate the following
# 1. Create Domain1 with 4 GB RAM and 2 child domains with 2 GB
# each.
# 2. Deploy VM's by Domain1 admin1/user1/ Domain2 user1/Admin1 account
# and verify the resource updates
# 3. Deploy VM by admin account after reaching max parent domain limit
# 4. Deploy VM with child account after reaching max child domain limit
# 5. Delete user account and verify the resource updates
# 6. Destroy user/admin account VM's and verify the child & Parent
# domain resource updates
self.debug("Creating service offering with 2 GB RAM")
self.services["service_offering"]["memory"] = 2048
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("Setting up account and domain hierarchy")
self.setupAccounts()
api_client_cadmin_1 = self.testClient.getUserApiClient(
UserName=self.cadmin_1.name, DomainName=self.cadmin_1.domain)
api_client_cadmin_2 = self.testClient.getUserApiClient(
UserName=self.cadmin_2.name, DomainName=self.cadmin_2.domain)
self.debug("Creating an instance with service offering: %s" %
self.service_offering.name)
vm_1 = self.createInstance(account=self.cadmin_1,
service_off=self.service_offering,
api_client=api_client_cadmin_1)
vm_2 = self.createInstance(account=self.cadmin_2,
service_off=self.service_offering,
api_client=api_client_cadmin_2)
account_list = Account.list(self.apiclient, id=self.cadmin_1.id)
self.assertIsInstance(account_list, list,
"List Accounts should return a valid response")
resource_count_cadmin_1 = account_list[0].memorytotal
self.debug(resource_count_cadmin_1)
account_list = Account.list(self.apiclient, id=self.cadmin_2.id)
self.assertIsInstance(account_list, list,
"List Accounts should return a valid response")
resource_count_cadmin_2 = account_list[0].memorytotal
self.debug(resource_count_cadmin_2)
self.debug(
"Creating instance when Memory limit is fully used in parent domain"
)
with self.assertRaises(Exception):
self.createInstance(account=self.cadmin_1,
service_off=self.service_offering,
api_client=api_client_cadmin_1)
self.debug(
"Creating instance when Memory limit is fully used in child domain"
)
with self.assertRaises(Exception):
self.createInstance(account=self.cadmin_2,
service_off=self.service_offering,
api_client=api_client_cadmin_2)
self.debug("Destroying instances: %s, %s" % (vm_1.name, vm_2.name))
try:
vm_1.delete(self.apiclient)
vm_2.delete(self.apiclient)
except Exception as e:
self.fail("Failed to delete instance: %s" % e)
self.debug("Checking resource count for account: %s" %
self.cadmin_1.name)
account_list = Account.list(self.apiclient, id=self.cadmin_1.id)
self.assertIsInstance(account_list, list,
"List Accounts should return a valid response")
resource_count_cadmin_1 = account_list[0].memorytotal
self.assertEqual(resource_count_cadmin_1, 0,
"Resource count for %s should be 0" %
get_resource_type(resource_id=9)) #RAM
self.debug("Checking resource count for account: %s" %
self.cadmin_2.name)
account_list = Account.list(self.apiclient, id=self.cadmin_1.id)
self.assertIsInstance(account_list, list,
"List Accounts should return a valid response")
resource_count_cadmin_2 = account_list[0].memorytotal
self.assertEqual(resource_count_cadmin_2, 0,
"Resource count for %s should be 0" %
get_resource_type(resource_id=9)) #RAM
return
def test_01_multiple_child_domains(self):
"""Test CPU limits with multiple child domains"""
# Validate the following
# 1. Create Domain1 with 10 core CPU and 2 child domains with 4 core
# each.Assign 2 cores for Domain1 admin1 & Domain1 User1 .Assign 2
# cores for Domain2 admin1 & Domain2 User1
# 2. Deploy VM's by Domain1 admin1/user1/ Domain2 user1/Admin1 account
# and verify the resource updates
# 3. Deploy VM by admin account after reaching max parent domain limit
# 4. Deploy VM with child account after reaching max child domain limit
# 5. Destroy user/admin account VM's and verify the child & Parent
# domain resource updates
self.debug("Creating service offering with 2 CPU cores")
self.services["service_offering"]["cpunumber"] = 2
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("Setting up account and domain hierarchy")
self.setupAccounts()
api_client_cadmin_1 = self.testClient.getUserApiClient(
UserName=self.cadmin_1.name,
DomainName=self.cadmin_1.domain)
api_client_cadmin_2 = self.testClient.getUserApiClient(
UserName=self.cadmin_2.name,
DomainName=self.cadmin_2.domain)
self.debug("Creating an instance with service offering: %s" %
self.service_offering.name)
vm_1 = self.createInstance(account=self.cadmin_1,
service_off=self.service_offering, api_client=api_client_cadmin_1)
vm_2 = self.createInstance(account=self.cadmin_2,
service_off=self.service_offering, api_client=api_client_cadmin_2)
self.debug("Checking resource count for account: %s" % self.cadmin_1.name)
account_list = Account.list(self.apiclient, id=self.cadmin_1.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count_cadmin_1 = account_list[0].cputotal
self.debug(resource_count_cadmin_1)
self.debug("Checking resource count for account: %s" % self.cadmin_2.name)
account_list = Account.list(self.apiclient, id=self.cadmin_2.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count_cadmin_2 = account_list[0].cputotal
self.debug(resource_count_cadmin_2)
self.debug(
"Creating instance when CPU limit is fully used in child domain 1")
with self.assertRaises(Exception):
self.createInstance(account=self.cadmin_1,
service_off=self.service_offering, api_client=api_client_cadmin_1)
self.debug(
"Creating instance when CPU limit is fully used in child domain 2")
with self.assertRaises(Exception):
self.createInstance(account=self.cadmin_2,
service_off=self.service_offering, api_client=api_client_cadmin_2)
self.debug("Destroying instances: %s, %s" % (vm_1.name, vm_2.name))
try:
vm_1.delete(self.apiclient)
vm_2.delete(self.apiclient)
except Exception as e:
self.fail("Failed to delete instance: %s" % e)
self.debug("Checking resource count for account: %s" % self.cadmin_1.name)
account_list = Account.list(self.apiclient, id=self.cadmin_1.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count_cadmin_1 = account_list[0].cputotal
self.debug(resource_count_cadmin_1)
self.assertEqual(resource_count_cadmin_1, 0, "Resource count for %s should be 0" % get_resource_type(resource_id=8))#CPU
self.debug("Checking resource count for account: %s" % self.cadmin_2.name)
account_list = Account.list(self.apiclient, id=self.cadmin_2.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count_cadmin_2 = account_list[0].cputotal
self.debug(resource_count_cadmin_2)
self.assertEqual(resource_count_cadmin_2, 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 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.getUserApiClient(
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
