cloudstack-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sangeet...@apache.org
Subject [1/2] CLOUDSTACK-7034 - [Automation] - Automate ACL test cases relating to listVirtualMachines()
Date Mon, 08 Sep 2014 18:31:45 GMT
Repository: cloudstack
Updated Branches:
  refs/heads/master e1354878c -> 5049dd0bf


http://git-wip-us.apache.org/repos/asf/cloudstack/blob/5049dd0b/test/integration/component/test_acl_listvm.py
----------------------------------------------------------------------
diff --git a/test/integration/component/test_acl_listvm.py b/test/integration/component/test_acl_listvm.py
new file mode 100644
index 0000000..398f98a
--- /dev/null
+++ b/test/integration/component/test_acl_listvm.py
@@ -0,0 +1,2830 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+# 
+#   http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+""" 
+Test cases relating to listVirtualMachine() relating to parameters - id,listall,isrecursive,account and domainid
+"""
+#Import Local Modules
+import marvin
+from marvin.cloudstackTestCase import *
+from marvin.cloudstackAPI import *
+from marvin.lib.utils import *
+from marvin.lib.base import *
+from marvin.lib.common import *
+from nose.plugins.attrib import attr
+#Import System modules
+import time
+
+_multiprocess_shared_ = True
+
+class TestVMList(cloudstackTestCase):
+    @classmethod
+    def setUpClass(cls):
+	""" 
+	Create the following domain tree and accounts that are reqiured for executing listVirtualMachine test cases:
+	Under ROOT - create 2 domaind D1 and D2
+        Under D1 - Create 2 subdomain D11 and D12
+        Under D11 - Create subdimain D111
+
+        Under each of the domain create 1 admin user and couple of regular users.
+
+        As each of these users , deploy Virtual machines.
+
+	"""
+       	cls.testclient = super(TestVMList, cls).getClsTestClient()
+        cls.apiclient = cls.testclient.getApiClient()
+	cls.testdata = cls.testClient.getParsedTestDataConfig()
+        cls.acldata = cls.testdata["acl"]
+
+        cls.domain_1 = None
+        cls.domain_2 = None
+        cls.cleanup = []
+
+	try:
+		
+        	# backup default apikey and secretkey
+        	cls.default_apikey = cls.apiclient.connection.apiKey
+        	cls.default_secretkey = cls.apiclient.connection.securityKey
+	
+        	# Create domains 
+       		cls.domain_1 = Domain.create(
+                                   cls.apiclient,
+                                   cls.acldata["domain1"]
+                                   )
+        	cls.domain_11 = Domain.create(
+                                   cls.apiclient,
+                                   cls.acldata["domain11"],
+				   parentdomainid=cls.domain_1.id
+                                   )
+        	cls.domain_111 = Domain.create(
+                                   cls.apiclient,
+                                   cls.acldata["domain111"],
+				   parentdomainid=cls.domain_11.id,
+                                   )
+        	cls.domain_12 = Domain.create(
+                                   cls.apiclient,
+                                   cls.acldata["domain12"],
+				   parentdomainid=cls.domain_1.id
+                                   )
+        	cls.domain_2 = Domain.create(
+                                   cls.apiclient,
+                                   cls.acldata["domain2"]
+                                   )
+        	# Create  1 admin account and 2 user accounts for doamin_1
+        	cls.account_d1 = Account.create(
+                            cls.apiclient,
+                            cls.acldata["accountD1"],
+                            admin=True,
+                            domainid=cls.domain_1.id
+                            )
+
+    		user = cls.generateKeysForUser(cls.apiclient,cls.account_d1)
+            	cls.user_d1_apikey = user.apikey
+            	cls.user_d1_secretkey = user.secretkey
+            
+            	cls.account_d1a = Account.create(
+                                cls.apiclient,
+                                cls.acldata["accountD1A"],
+                                admin=False,
+                                domainid=cls.domain_1.id
+                                )        
+    		user = cls.generateKeysForUser(cls.apiclient,cls.account_d1a)
+            	cls.user_d1a_apikey = user.apikey
+            	cls.user_d1a_secretkey = user.secretkey
+            
+    
+            	cls.account_d1b = Account.create(
+                                cls.apiclient,
+                                cls.acldata["accountD1B"],
+                                admin=False,
+                                domainid=cls.domain_1.id
+                                )
+    
+    		user = cls.generateKeysForUser(cls.apiclient,cls.account_d1b)
+                cls.user_d1b_apikey = user.apikey
+           	cls.user_d1b_secretkey = user.secretkey
+      
+            	# Create  1 admin and 2 user accounts for doamin_11
+            	cls.account_d11 = Account.create(
+                                cls.apiclient,
+                                cls.acldata["accountD11"],
+                                admin=True,
+                                domainid=cls.domain_11.id
+                                )        
+    		user = cls.generateKeysForUser(cls.apiclient,cls.account_d11)
+            	cls.user_d11_apikey = user.apikey
+            	cls.user_d11_secretkey = user.secretkey
+    
+            	cls.account_d11a = Account.create(
+                                cls.apiclient,
+                                cls.acldata["accountD11A"],
+                                admin=False,
+                                domainid=cls.domain_11.id
+                                )        
+    		user = cls.generateKeysForUser(cls.apiclient,cls.account_d11a)
+            	cls.user_d11a_apikey = user.apikey
+            	cls.user_d11a_secretkey = user.secretkey
+    
+            	cls.account_d11b = Account.create(
+                                cls.apiclient,
+                                cls.acldata["accountD11B"],
+                                admin=False,
+                                domainid=cls.domain_11.id
+                                )  
+    		user = cls.generateKeysForUser(cls.apiclient,cls.account_d11b)
+            	cls.user_d11b_apikey = user.apikey
+            	cls.user_d11b_secretkey = user.secretkey
+    
+            	# Create  1 user account for doamin_111
+    
+            	cls.account_d111a = Account.create(
+                                cls.apiclient,
+                                cls.acldata["accountD111A"],
+                                admin=False,
+                                domainid=cls.domain_111.id
+                                )        
+    		user = cls.generateKeysForUser(cls.apiclient,cls.account_d111a)
+            	cls.user_d111a_apikey = user.apikey
+            	cls.user_d111a_secretkey = user.secretkey
+          
+            	# Create  2 user accounts for doamin_12
+            	cls.account_d12a = Account.create(
+                                cls.apiclient,
+                                cls.acldata["accountD12A"],
+                                admin=False,
+                                domainid=cls.domain_12.id
+                                )        
+    		user = cls.generateKeysForUser(cls.apiclient,cls.account_d12a)
+            	cls.user_d12a_apikey = user.apikey
+            	cls.user_d12a_secretkey = user.secretkey
+    
+            	cls.account_d12b = Account.create(
+                                cls.apiclient,
+                                cls.acldata["accountD12B"],
+                                admin=False,
+                                domainid=cls.domain_12.id
+                                )  
+          
+    		user = cls.generateKeysForUser(cls.apiclient,cls.account_d12b)
+            	cls.user_d12b_apikey = user.apikey
+            	cls.user_d12b_secretkey = user.secretkey
+          
+            	# Create 1 user account for domain_2
+    
+            	cls.account_d2a = Account.create(
+                                cls.apiclient,
+                                cls.acldata["accountD2"],
+                                admin=False,
+                                domainid=cls.domain_2.id
+                                )
+            
+    		user = cls.generateKeysForUser(cls.apiclient,cls.account_d2a)
+            	cls.user_d2a_apikey = user.apikey
+            	cls.user_d2a_secretkey = user.secretkey
+                             
+                    
+            	# Create admin user account 
+    
+            	cls.account_a = Account.create(
+                                cls.apiclient,
+                                cls.acldata["accountROOTA"],
+                                admin=True,
+                                )
+            
+    		user = cls.generateKeysForUser(cls.apiclient,cls.account_a)
+            	cls.user_a_apikey = user.apikey
+            	cls.user_a_secretkey = user.secretkey
+            	# create service offering
+            	cls.service_offering = ServiceOffering.create(
+                                    cls.apiclient,
+                                    cls.acldata["service_offering"]["small"]
+                                    )
+            
+            	cls.zone = get_zone(cls.apiclient,cls.testclient.getZoneForTests())
+            	cls.acldata['mode'] = cls.zone.networktype
+            	cls.template = get_template(cls.apiclient, cls.zone.id, cls.acldata["ostype"])
+    
+            	# deploy VM
+    
+        	cls.apiclient.connection.apiKey = cls.user_d1_apikey
+                cls.apiclient.connection.securityKey = cls.user_d1_secretkey
+                cls.vm_d1 = VirtualMachine.create(
+                    cls.apiclient,
+                    cls.acldata["vmD1"],
+                    zoneid=cls.zone.id,
+                    serviceofferingid=cls.service_offering.id,
+                    templateid=cls.template.id
+                )
+          
+        	cls.apiclient.connection.apiKey = cls.user_d1a_apikey
+                cls.apiclient.connection.securityKey = cls.user_d1a_secretkey
+                cls.vm_d1a = VirtualMachine.create(
+                    cls.apiclient,
+                    cls.acldata["vmD1A"],
+                    zoneid=cls.zone.id,
+                    serviceofferingid=cls.service_offering.id,
+                    templateid=cls.template.id
+                )
+          
+        	cls.apiclient.connection.apiKey = cls.user_d1b_apikey
+                cls.apiclient.connection.securityKey = cls.user_d1b_secretkey
+                cls.vm_d1b = VirtualMachine.create(
+                    cls.apiclient,
+                    cls.acldata["vmD1B"],
+                    zoneid=cls.zone.id,
+                    serviceofferingid=cls.service_offering.id,
+                    templateid=cls.template.id
+                )  
+        
+        	cls.apiclient.connection.apiKey = cls.user_d11_apikey
+                cls.apiclient.connection.securityKey = cls.user_d11_secretkey
+                cls.vm_d11 = VirtualMachine.create(
+                    cls.apiclient,
+                    cls.acldata["vmD11"],
+                    zoneid=cls.zone.id,
+                    serviceofferingid=cls.service_offering.id,
+        	            templateid=cls.template.id
+                )  
+                
+        	cls.apiclient.connection.apiKey = cls.user_d11a_apikey
+                cls.apiclient.connection.securityKey = cls.user_d11a_secretkey
+                cls.vm_d11a = VirtualMachine.create(
+                    cls.apiclient,
+                    cls.acldata["vmD11A"],
+                    zoneid=cls.zone.id,
+                    serviceofferingid=cls.service_offering.id,
+                    templateid=cls.template.id
+                )  
+                
+        	cls.apiclient.connection.apiKey = cls.user_d11b_apikey
+                cls.apiclient.connection.securityKey = cls.user_d11b_secretkey
+                cls.vm_d11b = VirtualMachine.create(
+                    cls.apiclient,
+                    cls.acldata["vmD11B"],
+                    zoneid=cls.zone.id,
+                    serviceofferingid=cls.service_offering.id,
+                    templateid=cls.template.id
+                )
+          
+        	cls.apiclient.connection.apiKey = cls.user_d111a_apikey
+                cls.apiclient.connection.securityKey = cls.user_d111a_secretkey
+                cls.vm_d111a = VirtualMachine.create(
+                    cls.apiclient,
+                    cls.acldata["vmD111A"],
+                    zoneid=cls.zone.id,
+                    serviceofferingid=cls.service_offering.id,
+                    templateid=cls.template.id
+                )  
+                
+        	cls.apiclient.connection.apiKey = cls.user_d12a_apikey
+                cls.apiclient.connection.securityKey = cls.user_d12a_secretkey
+                cls.vm_d12a = VirtualMachine.create(
+                    cls.apiclient,
+                    cls.acldata["vmD12A"],
+                    zoneid=cls.zone.id,
+                    serviceofferingid=cls.service_offering.id,
+                    templateid=cls.template.id
+                )  
+                
+        	cls.apiclient.connection.apiKey = cls.user_d12b_apikey
+                cls.apiclient.connection.securityKey = cls.user_d12b_secretkey
+                cls.vm_d12b = VirtualMachine.create(
+                    cls.apiclient,
+                    cls.acldata["vmD12B"],
+                    zoneid=cls.zone.id,
+                    serviceofferingid=cls.service_offering.id,
+                    templateid=cls.template.id
+                )
+          
+        	cls.apiclient.connection.apiKey = cls.user_d2a_apikey
+                cls.apiclient.connection.securityKey = cls.user_d2a_secretkey
+                cls.vm_d2 = VirtualMachine.create(
+                    cls.apiclient,
+                    cls.acldata["vmD2A"],
+                    zoneid=cls.zone.id,
+                    serviceofferingid=cls.service_offering.id,
+                    templateid=cls.template.id
+                )
+        
+        	cls.apiclient.connection.apiKey = cls.user_a_apikey
+                cls.apiclient.connection.securityKey = cls.user_a_secretkey
+                cls.vm_a = VirtualMachine.create(
+                    cls.apiclient,
+                    cls.acldata["vmROOTA"],
+                    zoneid=cls.zone.id,
+                    serviceofferingid=cls.service_offering.id,
+                    templateid=cls.template.id
+                )
+                cls.cleanup = [
+                            cls.account_a,
+                            cls.service_offering,
+                            ]
+    	except Exception as e:
+        	cls.domain_1.delete(cls.apiclient,cleanup="true")
+        	cls.domain_2.delete(cls.apiclient,cleanup="true")
+        	cleanup_resources(cls.apiclient, cls.cleanup)
+		raise Exception("Failed to create the setup required to execute the test cases: %s" % e)
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.apiclient = super(TestVMList, cls).getClsTestClient().getApiClient()
+        cls.apiclient.connection.apiKey = cls.default_apikey
+        cls.apiclient.connection.securityKey = cls.default_secretkey
+        cls.domain_1.delete(cls.apiclient,cleanup="true")
+        cls.domain_2.delete(cls.apiclient,cleanup="true")
+        cleanup_resources(cls.apiclient, cls.cleanup)
+        return
+
+    def setUp(cls):
+        cls.apiclient = cls.testClient.getApiClient()
+        cls.dbclient = cls.testClient.getDbConnection()
+
+    def tearDown(cls):
+        # restore back default apikey and secretkey
+        cls.apiclient.connection.apiKey = cls.default_apikey
+        cls.apiclient.connection.securityKey = cls.default_secretkey
+        return
+
+## Domain Admin - Test cases  with listall =true 
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_domainadmin_listall_true(self):
+	"""
+	# Test listing of Vms by passing listall="true" parameter as domain admin
+	# Validate that it returns all the Vms that is owned by accounts in this domain and all its subdomain
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1_apikey
+        self.apiclient.connection.securityKey = self.user_d1_secretkey
+	vmList = VirtualMachine.list(self.apiclient,listall="true")
+	self.debug ("List as Domain Admin - listall=true -  %s" % vmList)
+
+	self.assertEqual(len(vmList) == 9,
+			True,
+			"Number of items in list response check failed!!")
+
+	if (self.checkForExistenceOfValue(vmList,self.vm_d1.id), 
+	   self.checkForExistenceOfValue(vmList,self.vm_d1a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d1b.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11b.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d12a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d12b.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d111a.id)):
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_domainadmin_listall_true_rec_true(self):
+	"""
+	# Test listing of Vms by passing listall="true"i and isrecusriv="true" parameter as domain admin
+	# Validate that it returns all the Vms that is owned by accounts in this domain and all its subdomain
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1_apikey
+        self.apiclient.connection.securityKey = self.user_d1_secretkey
+	vmList = VirtualMachine.list(self.apiclient,listall="true",isrecursive="true")
+	self.debug ("List as Domain Admin  - listall=true,isrecursive=true %s" %vmList)
+
+	self.assertEqual(len(vmList) == 9,
+			True,
+			"Number of items in list response check failed!!")
+
+	if (self.checkForExistenceOfValue(vmList,self.vm_d1.id), 
+	   self.checkForExistenceOfValue(vmList,self.vm_d1a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d1b.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11b.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d12a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d12b.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d111a.id)):
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_domainadmin_listall_true_rec_false(self):
+	"""
+	# Test listing of Vms by passing listall="true" and isrecusriv="false" parameter as domain admin
+	# Validate that it returns all the Vms that is owned by accounts in this domain and all its subdomain
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1_apikey
+        self.apiclient.connection.securityKey = self.user_d1_secretkey
+	vmList = VirtualMachine.list(self.apiclient,listall="true",isrecursive="false")
+	self.debug ("List as Domain Admin  - listall=true,isrecursive=false %s" %vmList)
+
+	self.assertEqual(len(vmList) == 9,
+			True,
+			"Number of items in list response check failed!!")
+
+	if (self.checkForExistenceOfValue(vmList,self.vm_d1.id), 
+	   self.checkForExistenceOfValue(vmList,self.vm_d1a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d1b.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11b.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d12a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d12b.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d111a.id)):
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+## Domain Admin - Test cases  with listall=false
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_domainadmin_listall_false(self):
+	"""
+	# Test listing of Vms by passing listall="false" parameter as domain admin
+	# Validate that it returns all the Vms that is owned by the domain admin
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1_apikey
+        self.apiclient.connection.securityKey = self.user_d1_secretkey
+	vmList = VirtualMachine.list(self.apiclient,listall="false")
+	self.debug ("List as Domain Admin - listall=false -  %s" % vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if (self.checkForExistenceOfValue(vmList,self.vm_d1.id)): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_domainadmin_listall_false_rec_true(self):
+	"""
+	# Test listing of Vms by passing listall="false" and isrecusrive="true" parameter as domain admin
+	# Validate that it returns all the Vms that is owned by the domain admin
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1_apikey
+        self.apiclient.connection.securityKey = self.user_d1_secretkey
+	vmList = VirtualMachine.list(self.apiclient,listall="false",isrecursive="true")
+	self.debug ("List as Domain Admin  - listall=false,isrecursive=true %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if (self.checkForExistenceOfValue(vmList,self.vm_d1.id)): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_domainadmin_listall_false_rec_false(self):
+	"""
+	# Test listing of Vms by passing listall="false" and isrecusrive="false" parameter as domain admin
+	# Validate that it returns all the Vms that is owned by the domain admin
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1_apikey
+        self.apiclient.connection.securityKey = self.user_d1_secretkey
+	vmList = VirtualMachine.list(self.apiclient,listall="false",isrecursive="false")
+	self.debug ("List as Domain Admin  - listall=false,isrecursive=false %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+	if (self.checkForExistenceOfValue(vmList,self.vm_d1.id)): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+## Domain Admin - Test cases  without passing listall paramter 
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_domainadmin(self):
+	"""
+	# Test listing of Vms by passing no parameter as domain admin
+	# Validate that it returns all the Vms that is owned by the domain admin
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1_apikey
+        self.apiclient.connection.securityKey = self.user_d1_secretkey
+	vmList = VirtualMachine.list(self.apiclient)
+	self.debug ("List as Domain Admin - %s" % vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if (self.checkForExistenceOfValue(vmList,self.vm_d1.id)): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_domainadmin_rec_true(self):
+	"""
+	# Test listing of Vms by passing isrecusrive="true" parameter as domain admin
+	# Validate that it returns all the Vms that is owned by the domain admin
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1_apikey
+        self.apiclient.connection.securityKey = self.user_d1_secretkey
+	vmList = VirtualMachine.list(self.apiclient,isrecursive="true")
+	self.debug ("List as Domain Admin  - isrecursive=true %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if (self.checkForExistenceOfValue(vmList,self.vm_d1.id)): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_domainadmin_true_rec_false(self):
+	"""
+	# Test listing of Vms by passing isrecusrive="false" parameter as domain admin
+	# Validate that it returns all the Vms that is owned by the domain admin
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1_apikey
+        self.apiclient.connection.securityKey = self.user_d1_secretkey
+	vmList = VirtualMachine.list(self.apiclient,isrecursive="false")
+	self.debug ("List as Domain Admin  - isrecursive=false %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if (self.checkForExistenceOfValue(vmList,self.vm_d1.id)): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+## Domain Admin - Test cases when domainId is passed with listall =true 
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_domainadmin_domainid_listall_true(self):
+	"""
+	# Test listing of Vms by passing domainId and listall="true" parameter as domain admin
+	# Validate that it returns all the Vms in the domain passed
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1_apikey
+        self.apiclient.connection.securityKey = self.user_d1_secretkey
+	vmList = VirtualMachine.list(self.apiclient,domainid=self.domain_11.id,listall="true")
+	self.debug ("List as Domain Admin passing domainId  - listall=true %s" %vmList)
+
+	self.assertEqual(len(vmList) == 3,
+			True,
+			"Number of items in list response check failed!!")
+
+	if ( self.checkForExistenceOfValue(vmList,self.vm_d11.id) and 
+	   self.checkForExistenceOfValue(vmList,self.vm_d11a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11b.id) ): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_domainadmin_domainid_listall_true_rec_true(self):
+	"""
+	# Test listing of Vms by passing domainId ,listall="true" and isrecursive="true" parameter as domain admin
+	# Validate that it returns all the Vms in the subdomain and the domain passed
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1_apikey
+        self.apiclient.connection.securityKey = self.user_d1_secretkey
+	vmList = VirtualMachine.list(self.apiclient,domainid=self.domain_11.id,listall="true",isrecursive="true")
+	self.debug ("List as Domain Admin passing domainId  - listall=true,isrecursive=true %s" %vmList)
+
+	self.assertEqual(len(vmList) == 4,
+			True,
+			"Number of items in list response check failed!!")
+
+	if ( self.checkForExistenceOfValue(vmList,self.vm_d11.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11b.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d111a.id) ): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_domainadmin_domainid_listall_true_rec_false(self):
+	"""
+	# Test listing of Vms by passing domainId ,listall="true" and isrecursive="false" parameter as domain admin
+	# Validate that it returns all the Vms in the domain passed
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1_apikey
+        self.apiclient.connection.securityKey = self.user_d1_secretkey
+	vmList = VirtualMachine.list(self.apiclient,domainid=self.domain_11.id,listall="true",isrecursive="false")
+	self.debug ("List as Domain Admin passing domainId  - listall=true,isrecursive=false %s" %vmList)
+
+	self.assertEqual(len(vmList) == 3,
+			True,
+			"Number of items in list response check failed!!")
+
+	if ( self.checkForExistenceOfValue(vmList,self.vm_d11.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11b.id) ): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+
+## Domain Admin - Test cases  when domainId is passed with listall=false
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_domainadmin_domainid_listall_false(self):
+	"""
+	# Test listing of Vms by passing domainId ,listall="false" parameter as domain admin
+	# Validate that it returns all the Vms in the domain passed
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1_apikey
+        self.apiclient.connection.securityKey = self.user_d1_secretkey
+	vmList = VirtualMachine.list(self.apiclient,domainid=self.domain_11.id,listall="false")
+	self.debug ("List as Domain Admin passing domainId  - listall=false %s" %vmList)
+
+	self.assertEqual(len(vmList) == 3,
+			True,
+			"Number of items in list response check failed!!")
+
+	if ( self.checkForExistenceOfValue(vmList,self.vm_d11.id) and 
+	   self.checkForExistenceOfValue(vmList,self.vm_d11a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11b.id) ): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_domainadmin_domainid_listall_false_rec_true(self):
+	"""
+	# Test listing of Vms by passing domainId ,listall="false" and isrecursive="true" parameter as domain admin
+	# Validate that it returns all the Vms in the subdomain and the domain passed
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1_apikey
+        self.apiclient.connection.securityKey = self.user_d1_secretkey
+	vmList = VirtualMachine.list(self.apiclient,domainid=self.domain_11.id,listall="false",isrecursive="true")
+	self.debug ("List as Domain Admin passing domainId  - listall=false,isrecursive=true %s" %vmList)
+
+	self.assertEqual(len(vmList) == 4,
+			True,
+			"Number of items in list response check failed!!")
+
+	if ( self.checkForExistenceOfValue(vmList,self.vm_d11.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11b.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d111a.id) ): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_domainadmin_domainid_listall_false_rec_false(self):
+	"""
+	# Test listing of Vms by passing domainId ,listall="false" and isrecursive="false" parameter as domain admin
+	# Validate that it returns all the Vms in the domain passed
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1_apikey
+        self.apiclient.connection.securityKey = self.user_d1_secretkey
+	vmList = VirtualMachine.list(self.apiclient,domainid=self.domain_11.id,listall="false",isrecursive="false")
+	self.debug ("List as Domain Admin passing domainId  - listall=false,isrecursive=false %s" %vmList)
+
+	self.assertEqual(len(vmList) == 3,
+			True,
+			"Number of items in list response check failed!!")
+
+	if ( self.checkForExistenceOfValue(vmList,self.vm_d11.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11b.id) ): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+ 
+
+## Domain Admin - Test cases  when domainId is passed with no listall parameter
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_domainadmin_domainid(self):
+	"""
+	# Test listing of Vms by passing domainId parameter as domain admin
+	# Validate that it returns all the Vms in the domain passed
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1_apikey
+        self.apiclient.connection.securityKey = self.user_d1_secretkey
+	vmList = VirtualMachine.list(self.apiclient,domainid=self.domain_11.id)
+	self.debug ("List as Domain Admin passing domainId  - %s" %vmList)
+
+	self.assertEqual(len(vmList) == 3,
+			True,
+			"Number of items in list response check failed!!")
+
+	if ( self.checkForExistenceOfValue(vmList,self.vm_d11.id) and 
+	   self.checkForExistenceOfValue(vmList,self.vm_d11a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11b.id) ): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_domainadmin_domainid_rec_true(self):
+	"""
+	# Test listing of Vms by passing domainId and isrecursive="true" parameter as domain admin
+	# Validate that it returns all the Vms in the subdomain and domain passed
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1_apikey
+        self.apiclient.connection.securityKey = self.user_d1_secretkey
+	vmList = VirtualMachine.list(self.apiclient,domainid=self.domain_11.id,isrecursive="true")
+	self.debug ("List as Domain Admin passing domainId  - isrecursive=true %s" %vmList)
+
+	self.assertEqual(len(vmList) == 4,
+			True,
+			"Number of items in list response check failed!!")
+
+	if ( self.checkForExistenceOfValue(vmList,self.vm_d11.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11b.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d111a.id) ): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_domainadmin_domainid_rec_false(self):
+	"""
+	# Test listing of Vms by passing domainId and isrecursive="false" parameter as domain admin
+	# Validate that it returns all the Vms in the subdomain and domain passed
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1_apikey
+        self.apiclient.connection.securityKey = self.user_d1_secretkey
+	vmList = VirtualMachine.list(self.apiclient,domainid=self.domain_11.id,isrecursive="false")
+	self.debug ("List as Domain Admin passing domainId  - isrecursive=false %s" %vmList)
+
+	self.assertEqual(len(vmList) == 3,
+			True,
+			"Number of items in list response check failed!!")
+
+	if ( self.checkForExistenceOfValue(vmList,self.vm_d11.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11b.id) ): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+
+## Domain Admin - Test cases  when account and domainId is passed with listall =true 
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_domainadmin_domainid_accountid_listall_true(self):
+	"""
+	# Test listing of Vms by passing account ,domainId and listall="true" parameter as domain admin
+	# Validate that it returns all the Vms owned by the account passed in account parameter
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1_apikey
+        self.apiclient.connection.securityKey = self.user_d1_secretkey
+	vmList = VirtualMachine.list(self.apiclient,account=self.account_d11.user[0].username,domainid=self.domain_11.id,listall="true")
+	self.debug ("List as Domain Admin passing domainId and accountId - listall=true %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_d11.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_domainadmin_domainid_accountid_listall_true_rec_true(self):
+	"""
+	# Test listing of Vms by passing account ,domainId and listall="true" and isrecursive="true" parameter as domain admin
+	# Validate that it returns all the Vms owned by the account passed in account parameter
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1_apikey
+        self.apiclient.connection.securityKey = self.user_d1_secretkey
+	vmList = VirtualMachine.list(self.apiclient,account=self.account_d11.user[0].username,domainid=self.domain_11.id,listall="true",isrecursive="true")
+	self.debug ("List as Domain Admin passing domainId and accountId - listall=true,isrecursive=true %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_d11.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_domainadmin_domainid_accountid_listall_true_rec_false(self):
+	"""
+	# Test listing of Vms by passing account ,domainId , listall="true" and isrecursive="false" parameter as domain admin
+	# Validate that it returns all the Vms owned by the account passed in account parameter
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1_apikey
+        self.apiclient.connection.securityKey = self.user_d1_secretkey
+	vmList = VirtualMachine.list(self.apiclient,account=self.account_d11.user[0].username,domainid=self.domain_11.id,listall="true",isrecursive="false")
+	self.debug ("List as Domain Admin passing domainId and accountId - listall=true,isrecursive=false %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_d11.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+
+## Domain Admin - Test cases  when account and domainId is passed with listall=false
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_domainadmin_domainid_accountid_listall_false(self):
+	"""
+	# Test listing of Vms by passing account ,domainId and listall="false" parameter as domain admin
+	# Validate that it returns all the Vms owned by the account passed in account parameter
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1_apikey
+        self.apiclient.connection.securityKey = self.user_d1_secretkey
+	vmList = VirtualMachine.list(self.apiclient,account=self.account_d11.user[0].username,domainid=self.domain_11.id,listall="false")
+	self.debug ("List as Domain Admin passing domainId and accountId - listall=false %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_d11.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_domainadmin_domainid_accountid_listall_false_rec_true(self):
+	"""
+	# Test listing of Vms by passing account ,domainId and listall="false" and isrecursive="true" parameter as domain admin
+	# Validate that it returns all the Vms owned by the account passed in account parameter
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1_apikey
+        self.apiclient.connection.securityKey = self.user_d1_secretkey
+	vmList = VirtualMachine.list(self.apiclient,account=self.account_d11.user[0].username,domainid=self.domain_11.id,listall="false",isrecursive="true")
+	self.debug ("List as Domain Admin passing domainId and accountId - listall=false,isrecursive=true %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_d11.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_domainadmin_domainid_accountid_listall_false_rec_false(self):
+	"""
+	# Test listing of Vms by passing account ,domainId , listall="false" and isrecursive="false" parameter as domain admin
+	# Validate that it returns all the Vms owned by the account passed in account parameter
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1_apikey
+        self.apiclient.connection.securityKey = self.user_d1_secretkey
+	vmList = VirtualMachine.list(self.apiclient,account=self.account_d11.user[0].username,domainid=self.domain_11.id,listall="false",isrecursive="false")
+	self.debug ("List as Domain Admin passing domainId and accountId - listall=false,isrecursive=false %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_d11.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+## Domain Admin - Test cases  when account and domainId is passed with listall not passed
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_domainadmin_domainid_accountid(self):
+	"""
+	# Test listing of Vms by passing account ,domainId parameter as domain admin
+	# Validate that it returns all the Vms owned by the account passed in account parameter
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1_apikey
+        self.apiclient.connection.securityKey = self.user_d1_secretkey
+	vmList = VirtualMachine.list(self.apiclient,account=self.account_d11.user[0].username,domainid=self.domain_11.id)
+	self.debug ("List as Domain Admin passing domainId and accountId - %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_d11.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_domainadmin_domainid_accountid_rec_true(self):
+	"""
+	# Test listing of Vms by passing account ,domainId and isrecursive="true" parameter as domain admin
+	# Validate that it returns all the Vms owned by the account passed in account parameter
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1_apikey
+        self.apiclient.connection.securityKey = self.user_d1_secretkey
+	vmList = VirtualMachine.list(self.apiclient,account=self.account_d11.user[0].username,domainid=self.domain_11.id,isrecursive="true")
+	self.debug ("List as Domain Admin passing domainId and accountId - isrecursive=true %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_d11.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_domainadmin_domainid_accountid_rec_false(self):
+	"""
+	# Test listing of Vms by passing account ,domainId and isrecursive="false" parameter as domain admin
+	# Validate that it returns all the Vms owned by the account passed in account parameter
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1_apikey
+        self.apiclient.connection.securityKey = self.user_d1_secretkey
+	vmList = VirtualMachine.list(self.apiclient,account=self.account_d11.user[0].username,domainid=self.domain_11.id,isrecursive="false")
+	self.debug ("List as Domain Admin passing domainId and accountId - isrecursive=false %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_d11.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+## ROOT Admin - Test cases  with listall =true 
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_rootadmin_listall_true(self):
+	"""
+	# Test listing of Vms by passing listall="true" parameter as admin
+	# Validate that it returns all the Vms
+	"""
+
+        self.apiclient.connection.apiKey = self.user_a_apikey
+        self.apiclient.connection.securityKey = self.user_a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,listall="true")
+	self.debug ("List as ROOT Admin - listall=true %s" %vmList)
+
+	self.assertEqual(len(vmList) >= 11,
+			True,
+			"Number of items in list response check failed!!")
+
+	if (self.checkForExistenceOfValue(vmList,self.vm_d1.id), 
+	   self.checkForExistenceOfValue(vmList,self.vm_d1a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d1b.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11b.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d12a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d12b.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d111a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d2.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_a.id)):
+	   	
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_rootadmin_listall_true_rec_true(self):
+	"""
+	# Test listing of Vms by passing listall="true" and isrecusrive="true" parameter as admin
+	# Validate that it returns all the Vms
+	"""
+
+        self.apiclient.connection.apiKey = self.user_a_apikey
+        self.apiclient.connection.securityKey = self.user_a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,listall="true",isrecursive="true")
+	self.debug ("List as ROOT Admin  - listall=true,isrecursive=true %s" %vmList)
+
+	self.assertEqual(len(vmList) >= 11,
+			True,
+			"Number of items in list response check failed!!")
+
+	if (self.checkForExistenceOfValue(vmList,self.vm_d1.id), 
+	   self.checkForExistenceOfValue(vmList,self.vm_d1a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d1b.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11b.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d12a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d12b.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d111a.id) and
+ 	   self.checkForExistenceOfValue(vmList,self.vm_d2.id) and
+           self.checkForExistenceOfValue(vmList,self.vm_a.id)):
+
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_rootadmin_listall_true_rec_false(self):
+	"""
+	# Test listing of Vms by passing listall="true" and isrecusrive="false" parameter as admin
+	# Validate that it returns all the Vms
+	"""
+
+        self.apiclient.connection.apiKey = self.user_a_apikey
+        self.apiclient.connection.securityKey = self.user_a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,listall="true",isrecursive="false")
+	self.debug ("List as ROOT Admin  - listall=true,isrecursive=false %s" %vmList)
+
+	self.assertEqual(len(vmList) >= 11,
+			True,
+			"Number of items in list response check failed!!")
+
+	if (self.checkForExistenceOfValue(vmList,self.vm_d1.id), 
+	   self.checkForExistenceOfValue(vmList,self.vm_d1a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d1b.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11b.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d12a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d12b.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d111a.id) and
+ 	   self.checkForExistenceOfValue(vmList,self.vm_d2.id) and
+           self.checkForExistenceOfValue(vmList,self.vm_a.id)):
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+## ROOT Admin - Test cases  with listall=false
+ 
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_rootadmin_listall_false(self):
+	"""
+	# Test listing of Vms by passing listall="false" parameter as admin
+	# Validate that it returns all the Vms owned by admin
+	"""
+
+        self.apiclient.connection.apiKey = self.user_a_apikey
+        self.apiclient.connection.securityKey = self.user_a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,listall="false")
+	self.debug ("List as ROOT Admin - listall=false %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_a.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_rootadmin_listall_false_rec_true(self):
+	"""
+	# Test listing of Vms by passing listall="false" and isrecusrive="true" parameter as admin
+	# Validate that it returns all the Vms owned by admin
+	"""
+
+        self.apiclient.connection.apiKey = self.user_a_apikey
+        self.apiclient.connection.securityKey = self.user_a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,listall="false",isrecursive="true")
+	self.debug ("List as ROOT Admin  - listall=false,isrecursive=true %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_a.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_rootadmin_listall_false_rec_false(self):
+	"""
+	# Test listing of Vms by passing listall="false" and isrecusrive="false" parameter as admin
+	# Validate that it returns all the Vms owned by admin
+	"""
+
+        self.apiclient.connection.apiKey = self.user_a_apikey
+        self.apiclient.connection.securityKey = self.user_a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,listall="false",isrecursive="false")
+	self.debug ("List as ROOT Admin  - listall=false,isrecursive=false %s" %vmList)
+
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_a.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+
+## ROOT Admin - Test cases  without passing listall paramter 
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_rootadmin(self):
+	"""
+	# Test listing of Vms by passing no parameter as admin
+	# Validate that it returns all the Vms owned by admin
+	"""
+
+        self.apiclient.connection.apiKey = self.user_a_apikey
+        self.apiclient.connection.securityKey = self.user_a_secretkey
+	vmList = VirtualMachine.list(self.apiclient)
+	self.debug ("List as ROOT Admin  %s" %vmList)
+
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_a.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_rootadmin_rec_true(self):
+	"""
+	# Test listing of Vms by passing isrecusrive="true" parameter as admin
+	# Validate that it returns all the Vms owned by admin
+	"""
+
+        self.apiclient.connection.apiKey = self.user_a_apikey
+        self.apiclient.connection.securityKey = self.user_a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,isrecursive="true")
+	self.debug ("List as ROOT Admin - isrecursive=true %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_a.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_rootadmin_rec_false(self):
+	"""
+	# Test listing of Vms by passing isrecusrive="false" parameter as admin
+	# Validate that it returns all the Vms owned by admin
+	"""
+
+        self.apiclient.connection.apiKey = self.user_a_apikey
+        self.apiclient.connection.securityKey = self.user_a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,isrecursive="false")
+	self.debug ("List as ROOT Admin passing domainId - isrecursive=false %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_a.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+## ROOT Admin - Test cases when domainId is passed with listall =true 
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_rootadmin_domainid_listall_true(self):
+	"""
+	# Test listing of Vms by passing domainid and listall="true" parameter as admin
+	# Validate that it returns all the Vms in the domain passed 
+	"""
+
+        self.apiclient.connection.apiKey = self.user_a_apikey
+        self.apiclient.connection.securityKey = self.user_a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,domainid=self.domain_11.id,listall="true")
+	self.debug ("List as ROOT Admin passing domainId  - listall=true %s" %vmList)
+
+	self.assertEqual(len(vmList) == 3,
+			True,
+			"Number of items in list response check failed!!")
+
+	if ( self.checkForExistenceOfValue(vmList,self.vm_d11.id) and 
+	   self.checkForExistenceOfValue(vmList,self.vm_d11a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11b.id) ): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_rootadmin_domainid_listall_true_rec_true(self):
+	"""
+	# Test listing of Vms by passing domainid , listall="true" and isrecusrive="true" parameter as admin
+	# Validate that it returns all the Vms in the subdomain and the domain passed
+	"""
+
+        self.apiclient.connection.apiKey = self.user_a_apikey
+        self.apiclient.connection.securityKey = self.user_a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,domainid=self.domain_11.id,listall="true",isrecursive="true")
+	self.debug ("List as ROOT Admin passing domainId  - listall=true,isrecursive=true %s" %vmList)
+
+	self.assertEqual(len(vmList) == 4,
+			True,
+			"Number of items in list response check failed!!")
+
+	if ( self.checkForExistenceOfValue(vmList,self.vm_d11.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11b.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d111a.id) ): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_rootadmin_domainid_listall_true_rec_false(self):
+	"""
+	# Test listing of Vms by passing domainid, listall="true" and isrecusrive="false" parameter as admin
+	# Validate that it returns all the Vms in the domain passed
+	"""
+
+        self.apiclient.connection.apiKey = self.user_a_apikey
+        self.apiclient.connection.securityKey = self.user_a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,domainid=self.domain_11.id,listall="true",isrecursive="false")
+	self.debug ("List as ROOT Admin passing domainId  - listall=true,isrecursive=false %s" %vmList)
+
+	self.assertEqual(len(vmList) == 3,
+			True,
+			"Number of items in list response check failed!!")
+
+	if ( self.checkForExistenceOfValue(vmList,self.vm_d11.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11b.id) ): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+
+## ROOT Admin - Test cases  when domainId is passed with listall=false
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_rootadmin_domainid_listall_false(self):
+	"""
+	# Test listing of Vms by passing domainid, listall="false" parameter as admin
+	# Validate that it returns all the Vms in the domain passed
+	"""
+
+        self.apiclient.connection.apiKey = self.user_a_apikey
+        self.apiclient.connection.securityKey = self.user_a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,domainid=self.domain_11.id,listall="false")
+	self.debug ("List as ROOT Admin passing domainId  - listall=false %s" %vmList)
+
+	self.assertEqual(len(vmList) == 3,
+			True,
+			"Number of items in list response check failed!!")
+
+	if ( self.checkForExistenceOfValue(vmList,self.vm_d11.id) and 
+	   self.checkForExistenceOfValue(vmList,self.vm_d11a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11b.id) ): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_rootadmin_domainid_listall_false_rec_true(self):
+	"""
+	# Test listing of Vms by passing domainid, listall="false" and isrecusrive="true" parameter as admin
+	# Validate that it returns all the Vms in the subdoamin and domain passed
+	"""
+
+        self.apiclient.connection.apiKey = self.user_a_apikey
+        self.apiclient.connection.securityKey = self.user_a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,domainid=self.domain_11.id,listall="false",isrecursive="true")
+	self.debug ("List as ROOT Admin passing domainId  - listall=false,isrecursive=true %s" %vmList)
+
+	self.assertEqual(len(vmList) == 4,
+			True,
+			"Number of items in list response check failed!!")
+
+	if ( self.checkForExistenceOfValue(vmList,self.vm_d11.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11b.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d111a.id) ): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_rootadmin_domainid_listall_false_rec_false(self):
+
+	"""
+	# Test listing of Vms by passing domainid, listall="false" and isrecusrive="false" parameter as admin
+	# Validate that it returns all the Vms in the domain passed
+	"""
+
+        self.apiclient.connection.apiKey = self.user_a_apikey
+        self.apiclient.connection.securityKey = self.user_a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,domainid=self.domain_11.id,listall="false",isrecursive="false")
+	self.debug ("List as ROOT Admin passing domainId  - listall=false,isrecursive=false %s" %vmList)
+
+	self.assertEqual(len(vmList) == 3,
+			True,
+			"Number of items in list response check failed!!")
+
+	if ( self.checkForExistenceOfValue(vmList,self.vm_d11.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11b.id) ): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+ 
+
+## ROOT Admin - Test cases  when domainId is passed with no listall parameter
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_rootadmin_domainid(self):
+	"""
+	# Test listing of Vms by passing domainid parameter as admin
+	# Validate that it returns all the Vms in the domain passed
+	"""
+
+        self.apiclient.connection.apiKey = self.user_a_apikey
+        self.apiclient.connection.securityKey = self.user_a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,domainid=self.domain_11.id)
+	self.debug ("List as ROOT Admin passing domainId  - %s" %vmList)
+
+	self.assertEqual(len(vmList) == 3,
+			True,
+			"Number of items in list response check failed!!")
+
+	if ( self.checkForExistenceOfValue(vmList,self.vm_d11.id) and 
+	   self.checkForExistenceOfValue(vmList,self.vm_d11a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11b.id) ): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_rootadmin_domainid_rec_true(self):
+	"""
+	# Test listing of Vms by passing domainid and isrecusrive="true" parameter as admin
+	# Validate that it returns all the Vms in the subdmain and domain passed
+	"""
+
+        self.apiclient.connection.apiKey = self.user_a_apikey
+        self.apiclient.connection.securityKey = self.user_a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,domainid=self.domain_11.id,isrecursive="true")
+	self.debug ("List as ROOT Admin passing domainId  - isrecursive=true %s" %vmList)
+
+	self.assertEqual(len(vmList) == 4,
+			True,
+			"Number of items in list response check failed!!")
+
+	if ( self.checkForExistenceOfValue(vmList,self.vm_d11.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11b.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d111a.id) ): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_rootadmin_domainid_rec_false(self):
+	"""
+	# Test listing of Vms by passing domainid and isrecusrive="false" parameter as admin
+	# Validate that it returns all the Vms in the domain passed
+	"""
+
+        self.apiclient.connection.apiKey = self.user_a_apikey
+        self.apiclient.connection.securityKey = self.user_a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,domainid=self.domain_11.id,isrecursive="false")
+	self.debug ("List as ROOT Admin passing domainId  - isrecursive=false %s" %vmList)
+
+	self.assertEqual(len(vmList) == 3,
+			True,
+			"Number of items in list response check failed!!")
+
+	if ( self.checkForExistenceOfValue(vmList,self.vm_d11.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11a.id) and
+	   self.checkForExistenceOfValue(vmList,self.vm_d11b.id) ): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+
+## ROOT Admin - Test cases  when account and domainId is passed with listall =true 
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_rootadmin_domainid_accountid_listall_true(self):
+	"""
+	# Test listing of Vms by passing domainid,account ,listall = "true" parameter as admin
+	# Validate that it returns all the Vms of account that is passed
+	"""
+
+        self.apiclient.connection.apiKey = self.user_a_apikey
+        self.apiclient.connection.securityKey = self.user_a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,account=self.account_d11.user[0].username,domainid=self.domain_11.id,listall="true")
+	self.debug ("List as ROOT Admin passing domainId and accountId - listall=true %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_d11.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_rootadmin_domainid_accountid_listall_true_rec_true(self):
+	"""
+	# Test listing of Vms by passing domainid,account ,listall = "true" and isrecusrive="true" parameter as admin
+	# Validate that it returns all the Vms of the account that is passed
+	"""
+
+        self.apiclient.connection.apiKey = self.user_a_apikey
+        self.apiclient.connection.securityKey = self.user_a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,account=self.account_d11.user[0].username,domainid=self.domain_11.id,listall="true",isrecursive="true")
+	self.debug ("List as ROOT Admin passing domainId and accountId - listall=true,isrecursive=true %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_d11.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_rootadmin_domainid_accountid_listall_true_rec_false(self):
+	"""
+	# Test listing of Vms by passing domainid,account ,listall = "true" and isrecusrive="false" parameter as admin
+	# Validate that it returns all the Vms of the account that is passed
+	"""
+
+        self.apiclient.connection.apiKey = self.user_a_apikey
+        self.apiclient.connection.securityKey = self.user_a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,account=self.account_d11.user[0].username,domainid=self.domain_11.id,listall="true",isrecursive="false")
+	self.debug ("List as ROOT Admin passing domainId and accountId - listall=true,isrecursive=false %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_d11.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+
+## ROOT Admin - Test cases  when account and domainId is passed with listall=false
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_rootadmin_domainid_accountid_listall_false(self):
+	"""
+	# Test listing of Vms by passing domainid,account ,listall = "false" parameter as admin
+	# Validate that it returns all the Vms of the account that is passed
+	"""
+
+        self.apiclient.connection.apiKey = self.user_a_apikey
+        self.apiclient.connection.securityKey = self.user_a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,account=self.account_d11.user[0].username,domainid=self.domain_11.id,listall="false")
+	self.debug ("List as ROOT Admin passing domainId and accountId - listall=false %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_d11.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_rootadmin_domainid_accountid_listall_false_rec_true(self):
+	"""
+	# Test listing of Vms by passing domainid,account ,listall = "false" and isrecusrive="false" parameter as admin
+	# Validate that it returns all the Vms of the account that is passed
+	"""
+
+        self.apiclient.connection.apiKey = self.user_a_apikey
+        self.apiclient.connection.securityKey = self.user_a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,account=self.account_d11.user[0].username,domainid=self.domain_11.id,listall="false",isrecursive="true")
+	self.debug ("List as ROOT Admin passing domainId and accountId - listall=false,isrecursive=true %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_d11.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_rootadmin_domainid_accountid_listall_false_rec_false(self):
+	"""
+	# Test listing of Vms by passing domainid,account ,listall = "false" and isrecusrive="false" parameter as admin
+	# Validate that it returns all the Vms of the account that is passed
+	"""
+
+        self.apiclient.connection.apiKey = self.user_a_apikey
+        self.apiclient.connection.securityKey = self.user_a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,account=self.account_d11.user[0].username,domainid=self.domain_11.id,listall="false",isrecursive="false")
+	self.debug ("List as ROOT Admin passing domainId and accountId - listall=false,isrecursive=false %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_d11.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+ 
+
+## ROOT Admin - Test cases  when account and domainId is passed with listall not passed
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_rootadmin_domainid_accountid(self):
+	"""
+	# Test listing of Vms by passing domainid,account parameter as admin
+	# Validate that it returns all the Vms of the account that is passed
+	"""
+
+        self.apiclient.connection.apiKey = self.user_a_apikey
+        self.apiclient.connection.securityKey = self.user_a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,account=self.account_d11.user[0].username,domainid=self.domain_11.id)
+	self.debug ("List as ROOT Admin passing domainId and accountId -  %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_d11.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_rootadmin_domainid_accountid_rec_true(self):
+	"""
+	# Test listing of Vms by passing domainid,account and isrecusrive="true" parameter as admin
+	# Validate that it returns all the Vms of the account that is passed
+	"""
+
+        self.apiclient.connection.apiKey = self.user_a_apikey
+        self.apiclient.connection.securityKey = self.user_a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,account=self.account_d11.user[0].username,domainid=self.domain_11.id,isrecursive="true")
+	self.debug ("List as ROOT Admin passing domainId and accountId - isrecursive=true %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_d11.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_rootadmin_domainid_accountid_rec_false(self):
+	"""
+	# Test listing of Vms by passing domainid,account and isrecusrive="false" parameter as admin
+	# Validate that it returns all the Vms of the account that is passed
+	"""
+
+        self.apiclient.connection.apiKey = self.user_a_apikey
+        self.apiclient.connection.securityKey = self.user_a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,account=self.account_d11.user[0].username,domainid=self.domain_11.id,isrecursive="false")
+	self.debug ("List as ROOT Admin passing domainId and accountId - isrecursive=false %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_d11.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+
+## Regular User - Test cases  with listall =true 
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_regularuser_listall_true(self):
+	"""
+	# Test listing of Vms by passing listall="true"  parameter as regular user
+	# Validate that it returns all the Vms of the account the user belongs to 
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1a_apikey
+        self.apiclient.connection.securityKey = self.user_d1a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,listall="true")
+	self.debug ("List as Regular User - listall=true %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_d1a.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_regularuser_listall_true_rec_true(self):
+	"""
+	# Test listing of Vms by passing listall="true" and isrecusrive="true" parameter as regular user
+	# Validate that it returns all the Vms of the account the user belongs to 
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1a_apikey
+        self.apiclient.connection.securityKey = self.user_d1a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,listall="true",isrecursive="true")
+	self.debug ("List as Regular User  - listall=true,isrecursive=true %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_d1a.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_regularuser_listall_true_rec_false(self):
+	"""
+	# Test listing of Vms by passing listall="true" and isrecusrive="false" parameter as regular user
+	# Validate that it returns all the Vms of the account the user belongs to 
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1a_apikey
+        self.apiclient.connection.securityKey = self.user_d1a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,listall="true",isrecursive="false")
+	self.debug ("List as Regular User  - listall=true,isrecursive=false %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_d1a.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+##  Regular User  - Test cases  with listall=false
+ 
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_regularuser_listall_false(self):
+	"""
+	# Test listing of Vms by passing domainid,account,listall="false" parameter as regular user
+	# Validate that it returns all the Vms of the account the user belongs to 
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1a_apikey
+        self.apiclient.connection.securityKey = self.user_d1a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,listall="false")
+	self.debug ("List as Regular User - listall=false %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_d1a.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_regularuser_listall_false_rec_true(self):
+	"""
+	# Test listing of Vms by passing listall="false" and isrecusrive="true" parameter as regular user
+	# Validate that it returns all the Vms of the account the user belongs to 
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1a_apikey
+        self.apiclient.connection.securityKey = self.user_d1a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,listall="false",isrecursive="true")
+	self.debug ("List as Regular User  - listall=false,isrecursive=true %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_d1a.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_regularuser_listall_false_rec_false(self):
+	"""
+	# Test listing of Vms by passing listall="false" and isrecusrive="false" parameter as regular user
+	# Validate that it returns all the Vms of the account the user belongs to 
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1a_apikey
+        self.apiclient.connection.securityKey = self.user_d1a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,listall="false",isrecursive="false")
+	self.debug ("List as Regular User  - listall=false,isrecursive=false %s" %vmList)
+
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_d1a.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+
+##  Regular User  - Test cases  without passing listall paramter 
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_regularuser(self):
+	"""
+	# Test listing of Vms by passing no parameter as regular user
+	# Validate that it returns all the Vms of the account the user belongs to 
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1a_apikey
+        self.apiclient.connection.securityKey = self.user_d1a_secretkey
+	vmList = VirtualMachine.list(self.apiclient)
+	self.debug ("List as Regular User  %s" %vmList)
+
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_d1a.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_regularuser_rec_true(self):
+	"""
+	# Test listing of Vms by passing isrecusrive="true" parameter as regular user
+	# Validate that it returns all the Vms of the account the user belongs to 
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1a_apikey
+        self.apiclient.connection.securityKey = self.user_d1a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,isrecursive="true")
+	self.debug ("List as Regular User - isrecursive=true %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_d1a.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_regularuser_rec_false(self):
+	"""
+	# Test listing of Vms by passing isrecusrive="false" parameter as regular user
+	# Validate that it returns all the Vms of the account the user belongs to 
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1a_apikey
+        self.apiclient.connection.securityKey = self.user_d1a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,isrecursive="false")
+	self.debug ("List as Regular User passing domainId - isrecursive=false %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_d1a.id): 
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+##  Regular User  - Test cases when domainId is passed with listall =true 
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_regularuser_domainid_listall_true(self):
+	"""
+	# Test listing of Vms by passing domainid,listall="true" parameter as regular user
+	# Validate that it returns all the Vms of the account the user belongs to 
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1a_apikey
+        self.apiclient.connection.securityKey = self.user_d1a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,domainid=self.domain_1.id,listall="true")
+	self.debug ("List as Regular User passing domainId  - listall=true %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if  self.checkForExistenceOfValue(vmList,self.vm_d1a.id):
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_regularuser_domainid_listall_true_rec_true(self):
+	"""
+	# Test listing of Vms by passing domainid,listall="true" and isrecusrive="true" parameter as regular user
+	# Validate that it returns all the Vms of the account the user belongs to 
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1a_apikey
+        self.apiclient.connection.securityKey = self.user_d1a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,domainid=self.domain_1.id,listall="true",isrecursive="true")
+	self.debug ("List as Regular User passing domainId  - listall=true,isrecursive=true %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_d1a.id):
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_regularuser_domainid_listall_true_rec_false(self):
+	"""
+	# Test listing of Vms by passing domainid,listall="true" and isrecusrive="false" parameter as regular user
+	# Validate that it returns all the Vms of the account the user belongs to 
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1a_apikey
+        self.apiclient.connection.securityKey = self.user_d1a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,domainid=self.domain_1.id,listall="true",isrecursive="false")
+	self.debug ("List as Regular User passing domainId  - listall=true,isrecursive=false %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_d1a.id):
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+
+##  Regular User  - Test cases  when domainId is passed with listall=false
+ 
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_regularuser_domainid_listall_false(self):
+	"""
+	# Test listing of Vms by passing domainid,listall="false" parameter as regular user
+	# Validate that it returns all the Vms of the account the user belongs to 
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1a_apikey
+        self.apiclient.connection.securityKey = self.user_d1a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,domainid=self.domain_1.id,listall="false")
+	self.debug ("List as Regular User passing domainId  - listall=false %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_d1a.id):
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_regularuser_domainid_listall_false_rec_true(self):
+	"""
+	# Test listing of Vms by passing domainid,listall="false" and isrecusrive="true" parameter as regular user
+	# Validate that it returns all the Vms of the account the user belongs to 
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1a_apikey
+        self.apiclient.connection.securityKey = self.user_d1a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,domainid=self.domain_1.id,listall="false",isrecursive="true")
+	self.debug ("List as Regular User passing domainId  - listall=false,isrecursive=true %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_d1a.id):
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_regularuser_domainid_listall_false_rec_false(self):
+	"""
+	# Test listing of Vms by passing domainid,listall="false" and isrecusrive="false" parameter as regular user
+	# Validate that it returns all the Vms of the account the user belongs to 
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1a_apikey
+        self.apiclient.connection.securityKey = self.user_d1a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,domainid=self.domain_1.id,listall="false",isrecursive="false")
+	self.debug ("List as Regular User passing domainId  - listall=false,isrecursive=false %s" %vmList)
+
+	self.assertEqual(len(vmList) == 1,
+			True,
+			"Number of items in list response check failed!!")
+
+	if self.checkForExistenceOfValue(vmList,self.vm_d1a.id):
+	    accountAccess = True
+	else:
+	    accountAccess = False
+		
+	self.assertEqual(accountAccess,
+			True,
+			"Account access check failed!!")
+
+
+##  Regular User  - Test cases  when domainId is passed with no listall parameter
+
+    @attr(tags=["advanced"],required_hardware="false")
+    def test_listVM_as_regularuser_domainid(self):
+	"""
+	# Test listing of Vms by passing domainid parameter as regular user
+	# Validate that it returns all the Vms of the account the user belongs to 
+	"""
+
+        self.apiclient.connection.apiKey = self.user_d1a_apikey
+        self.apiclient.connection.securityKey = self.user_d1a_secretkey
+	vmList = VirtualMachine.list(self.apiclient,domainid=self.domain_

<TRUNCATED>

Mime
View raw message