from Test import Test
from qa import utils
from qa.Config import Config
-from qa.logger import Logfile, log, logfile
+from qa.logger import Logfile, log
from random import Random
random = Random()
-
-config = Config()
-api = config.api
-auth = api.auth
-
-try: boot_states = api.GetBootStates(auth)
-except: boot_states = [u'boot', u'dbg', u'inst', u'new', u'rcnf', u'rins']
-
-try: roles = [role['role_id'] for role in api.GetRoles(auth)]
-except: roles = [10,20,30,40]
-
-try: methods = api.GetNetworkMethods(auth)
-except: methods = [u'static', u'dhcp', u'proxy', u'tap', u'ipmi', u'unknown']
-
-try: key_types = api.GetKeyTypes(auth)
-except: key_types = [u'ssh']
-
-try:types = api.GetNetworkTypes(auth)
-except: types = [u'ipv4']
-
-try:
- attribute_types = [a['attribute_type_id'] for a in api.GetSliceAttributeTypes(auth)]
- attribute_types = filter(lambda x: x['name'] != 'initscript', attribute_types)
-
-except:
- attribute_types = range(6,20)
-
-try:
- sites = api.GetSites(auth, None, ['login_base'])
- login_bases = [site['login_base'] for site in sites]
-except:
- login_bases = ['pl']
+boot_states = [u'boot', u'dbg', u'inst', u'new', u'rcnf', u'rins']
+roles = [10,20,30,40]
+methods = [u'static', u'dhcp', u'proxy', u'tap', u'ipmi', u'unknown']
+key_types = [u'ssh']
+types = [u'ipv4']
+attribute_types = range(6,20)
+login_bases = ['pl']
def randfloat(min = 0.0, max = 1.0):
class api_unit_test(Test):
- logfile = Logfile("api-unittest-summary.log")
-
def call(self,
+ plc_name = None,
boot_states = 2,
sites = 2,
peers = 2,
keys = 3,
messages = 2
):
+ plc = self.config.get_plc(plc_name)
+ self.api = plc.config.api
+ self.auth = plc.config.auth
+ self.logfile = Logfile(self.config.logfile.dir + 'api-unittest.log')
+
# Filter out deprecated (Adm) and boot Methods
current_methods = lambda method: not method.startswith('Adm') and \
not method.startswith('Slice') and \
not method.startswith('Boot') and \
not method.startswith('Anon') and \
not method.startswith('system')
- self.all_methods = set(filter(current_methods, api.system.listMethods()))
+ self.all_methods = set(filter(current_methods, self.api.system.listMethods()))
self.methods_tested = set()
self.methods_failed = set()
if hasattr(self, 'SetPersonPrimarySite'): self.SetPersonPrimarySite()
if hasattr(self, 'VerifyPerson'): self.VerifyPerson()
-
-
-
except:
print_exc()
finally:
except:
self.methods_failed.update([method_name])
return False
- return True
+ return True
+
def debug(self, method, method_name=None):
if method_name is None:
- method_name = method.name
-
- self.methods_tested.update([method_name])
+ try:
+ method_name = method.name
+ self.methods_tested.update([method_name])
+ except:
+ method_name = method._Method__name
+ self.methods_tested.update([method_name])
+
def wrapper(*args, **kwds):
try:
return method(*args, **kwds)
except:
self.methods_failed.update([method_name])
- print >> logfile, "%s%s: %s\n" % (method_name, tuple(args[1:]), traceback.format_exc())
+ print >> self.logfile, "%s%s: %s\n" % (method_name, tuple(args[1:]), traceback.format_exc())
return None
return wrapper
for i in range(n):
# Add Site
site_fields = random_site()
- AddSite = self.debug(api.AddSite)
- site_id = AddSite(auth, site_fields)
+ AddSite = self.debug(self.api.AddSite)
+ site_id = AddSite(self.auth, site_fields)
if site_id is None: continue
# Should return a unique id
self.isunique(site_id, site_ids, 'AddSite - isunique')
site_ids.append(site_id)
- GetSites = self.debug(api.GetSites)
- sites = GetSites(auth, [site_id])
+ GetSites = self.debug(self.api.GetSites)
+ sites = GetSites(self.auth, [site_id])
if sites is None: continue
site = sites[0]
self.isequal(site, site_fields, 'AddSite - isequal')
# Update site
site_fields = random_site()
- UpdateSite = self.debug(api.UpdateSite)
- result = UpdateSite(auth, site_id, site_fields)
+ UpdateSite = self.debug(self.api.UpdateSite)
+ result = UpdateSite(self.auth, site_id, site_fields)
+
# Check again
- sites = GetSites(auth, [site_id])
+ sites = GetSites(self.auth, [site_id])
if sites is None: continue
site = sites[0]
self.isequal(site, site_fields, 'UpdateSite - isequal')
- sites = GetSites(auth, site_ids)
+ sites = GetSites(self.auth, site_ids)
if sites is not None:
self.islistequal(site_ids, [site['site_id'] for site in sites], 'GetSites - isequal')
def DeleteSites(self):
# Delete all sites
- DeleteSite = self.debug(api.DeleteSite)
+ DeleteSite = self.debug(self.api.DeleteSite)
for site_id in self.site_ids:
- result = DeleteSite(auth, site_id)
+ result = DeleteSite(self.auth, site_id)
# Check if sites are deleted
- GetSites = self.debug(api.GetSites)
- sites = GetSites(auth, self.site_ids)
+ GetSites = self.debug(self.api.GetSites)
+ sites = GetSites(self.auth, self.site_ids)
self.islistequal(sites, [], 'DeleteSite - check')
if self.config.verbose:
def NetworkMethods(self, n=2):
methods = []
- AddNetworkMethod = self.debug(api.AddNetworkMethod)
- GetNetworkMethods = self.debug(api.GetNetworkMethods)
+ AddNetworkMethod = self.debug(self.api.AddNetworkMethod)
+ GetNetworkMethods = self.debug(self.api.GetNetworkMethods)
for i in range(n):
# Add Network Method
net_method = randstr(10)
- AddNetworkMethod(auth, net_method)
+ AddNetworkMethod(self.auth, net_method)
if net_method is None: continue
# Should return a unique id
self.isunique(net_method, methods, 'AddNetworkMethod - isunique')
methods.append(net_method)
- net_methods = GetNetworkMethods(auth)
+ net_methods = GetNetworkMethods(self.auth)
if net_methods is None: continue
net_methods = filter(lambda x: x in [net_method], net_methods)
method = net_methods[0]
self.isequal(method, net_method, 'AddNetworkMethod - isequal')
- net_methods = GetNetworkMethods(auth)
+ net_methods = GetNetworkMethods(self.auth)
if net_methods is not None:
net_methods = filter(lambda x: x in methods, net_methods)
self.islistequal(methods, net_methods, 'GetNetworkMethods - isequal')
return methods
def DeleteNetworkMethods(self):
- DeleteNetworkMethod = self.debug(api.DeleteNetworkMethod)
- GetNetworkMethods = self.debug(api.GetNetworkMethods)
+ DeleteNetworkMethod = self.debug(self.api.DeleteNetworkMethod)
+ GetNetworkMethods = self.debug(self.api.GetNetworkMethods)
for method in self.network_methods:
- DeleteNetworkMethod(auth, method)
+ DeleteNetworkMethod(self.auth, method)
# check
- network_methods = GetNetworkMethods(auth)
+ network_methods = GetNetworkMethods(self.auth)
network_methods = filter(lambda x: x in self.network_methods, network_methods)
self.islistequal(network_methods, [], 'DeleteNetworkMethods - check')
def NetworkTypes(self, n=2):
net_types = []
- AddNetworkType = self.debug(api.AddNetworkType)
- GetNetworkTypes = self.debug(api.GetNetworkTypes)
+ AddNetworkType = self.debug(self.api.AddNetworkType)
+ GetNetworkTypes = self.debug(self.api.GetNetworkTypes)
for i in range(n):
# Add Network Type
type = randstr(10)
- AddNetworkType(auth, type)
+ AddNetworkType(self.auth, type)
# Should return a unique id
self.isunique(type, net_types, 'AddNetworkType - isunique')
net_types.append(type)
- types = GetNetworkTypes(auth)
+ types = GetNetworkTypes(self.auth)
if types is None: continue
types = filter(lambda x: x in [type], types)
if types is None: continue
net_type = types[0]
self.isequal(net_type, type, 'AddNetworkType - isequal')
- types = GetNetworkTypes(auth)
+ types = GetNetworkTypes(self.auth)
if types is not None:
types = filter(lambda x: x in net_types, types)
self.islistequal(types, net_types, 'GetNetworkTypes - isequal')
return net_types
def DeleteNetworkTypes(self):
- DeleteNetworkType = self.debug(api.DeleteNetworkType)
- GetNetworkTypes = self.debug(api.GetNetworkTypes)
+ DeleteNetworkType = self.debug(self.api.DeleteNetworkType)
+ GetNetworkTypes = self.debug(self.api.GetNetworkTypes)
for type in self.network_types:
- DeleteNetworkType(auth, type)
+ DeleteNetworkType(self.auth, type)
# check
- network_types = GetNetworkTypes(auth)
+ network_types = GetNetworkTypes(self.auth)
network_types = filter(lambda x: x in self.network_types, network_types)
self.islistequal(network_types, [], 'DeleteNetworkTypes - check')
def NodeGroups(self, n = 4):
nodegroup_ids = []
- AddNodeGroup = self.debug(api.AddNodeGroup)
- UpdateNodeGroup = self.debug(api.UpdateNodeGroup)
- GetNodeGroups = self.debug(api.GetNodeGroups)
+ AddNodeGroup = self.debug(self.api.AddNodeGroup)
+ UpdateNodeGroup = self.debug(self.api.UpdateNodeGroup)
+ GetNodeGroups = self.debug(self.api.GetNodeGroups)
for i in range(n):
# Add Nodegroups
nodegroup_fields = random_nodegroup()
- nodegroup_id = AddNodeGroup(auth, nodegroup_fields)
+ nodegroup_id = AddNodeGroup(self.auth, nodegroup_fields)
if nodegroup_id is None: continue
# Should return a unique id
self.isunique(nodegroup_id, nodegroup_ids, 'AddNodeGroup - isunique')
nodegroup_ids.append(nodegroup_id)
- nodegroups = GetNodeGroups(auth, [nodegroup_id])
+ nodegroups = GetNodeGroups(self.auth, [nodegroup_id])
if nodegroups is None: continue
nodegroup = nodegroups[0]
self.isequal(nodegroup, nodegroup_fields, 'AddNodeGroup - isequal')
# Update NodeGroups
nodegroup_fields = random_nodegroup()
- UpdateNodeGroup(auth, nodegroup_id, nodegroup_fields)
+ UpdateNodeGroup(self.auth, nodegroup_id, nodegroup_fields)
# Check again
- nodegroups = GetNodeGroups(auth, [nodegroup_id])
+ nodegroups = GetNodeGroups(self.auth, [nodegroup_id])
if nodegroups is None: continue
nodegroup = nodegroups[0]
self.isequal(nodegroup, nodegroup_fields, 'UpdateNodeGroup - isequal')
- nodegroups = GetNodeGroups(auth, nodegroup_ids)
+ nodegroups = GetNodeGroups(self.auth, nodegroup_ids)
if nodegroups is not None:
self.islistequal(nodegroup_ids, [n['nodegroup_id'] for n in nodegroups], 'GetNodeGroups - isequal')
if self.config.verbose:
def DeleteNodeGroups(self):
# Delete all NodeGroups
- GetNodeGroups = self.debug(api.GetNodeGroups)
- DeleteNodeGroup = self.debug(api.DeleteNodeGroup)
+ GetNodeGroups = self.debug(self.api.GetNodeGroups)
+ DeleteNodeGroup = self.debug(self.api.DeleteNodeGroup)
for nodegroup_id in self.nodegroup_ids:
- result = DeleteNodeGroup(auth, nodegroup_id)
+ result = DeleteNodeGroup(self.auth, nodegroup_id)
# Check is nodegroups are deleted
- nodegroups = GetNodeGroups(auth, self.nodegroup_ids)
+ nodegroups = GetNodeGroups(self.auth, self.nodegroup_ids)
self.islistequal(nodegroups, [], 'DeleteNodeGroup - check')
if self.config.verbose:
def PCUTypes(self, n=2):
pcu_type_ids = []
- AddPCUType = self.debug(api.AddPCUType)
- UpdatePCUType = self.debug(api.UpdatePCUType)
- GetPCUTypes = self.debug(api.GetPCUTypes)
+ AddPCUType = self.debug(self.api.AddPCUType)
+ UpdatePCUType = self.debug(self.api.UpdatePCUType)
+ GetPCUTypes = self.debug(self.api.GetPCUTypes)
for i in range(n):
# Add PCUType
pcu_type_fields = random_pcu_type()
- pcu_type_id = AddPCUType(auth, pcu_type_fields)
+ pcu_type_id = AddPCUType(self.auth, pcu_type_fields)
if pcu_type_id is None: continue
# Should return a unique id
self.isunique(pcu_type_id, pcu_type_ids, 'AddPCUType - isunique')
pcu_type_ids.append(pcu_type_id)
# Check pcu type
- pcu_types = GetPCUTypes(auth, [pcu_type_id])
+ pcu_types = GetPCUTypes(self.auth, [pcu_type_id])
if pcu_types is None: continue
pcu_type = pcu_types[0]
self.isequal(pcu_type, pcu_type_fields, 'AddPCUType - isequal')
# Update PCUType
pcu_type_fields = random_pcu_type()
- UpdatePCUType(auth, pcu_type_id, pcu_type_fields)
+ UpdatePCUType(self.auth, pcu_type_id, pcu_type_fields)
# Check again
- pcu_types = GetPCUTypes(auth, [pcu_type_id])
+ pcu_types = GetPCUTypes(self.auth, [pcu_type_id])
if pcu_types is None: continue
pcu_type = pcu_types[0]
self.isequal(pcu_type, pcu_type_fields, 'UpdatePCUType - isequal')
- pcu_types = GetPCUTypes(auth, pcu_type_ids)
+ pcu_types = GetPCUTypes(self.auth, pcu_type_ids)
if pcu_types is not None:
self.islistequal(pcu_type_ids, [p['pcu_type_id'] for p in pcu_types], 'GetPCUTypes - check')
return pcu_type_ids
def DeletePCUTypes(self):
- GetPCUTypes = self.debug(api.GetPCUTypes)
- DeletePCUType = self.debug(api.DeletePCUType)
+ GetPCUTypes = self.debug(self.api.GetPCUTypes)
+ DeletePCUType = self.debug(self.api.DeletePCUType)
for pcu_type_id in self.pcu_type_ids:
- DeletePCUType(auth, pcu_type_id)
+ DeletePCUType(self.auth, pcu_type_id)
- pcu_types = GetPCUTypes(auth, self.pcu_type_ids)
+ pcu_types = GetPCUTypes(self.auth, self.pcu_type_ids)
self.islistequal(pcu_types, [], 'DeletePCUType - check')
def PCUProtocolTypes(self, n=2):
protocol_type_ids = []
- AddPCUProtocolType = self.debug(api.AddPCUProtocolType)
- UpdatePCUProtocolType = self.debug(api.UpdatePCUProtocolType)
- GetPCUProtocolTypes = self.debug(api.GetPCUProtocolTypes)
+ AddPCUProtocolType = self.debug(self.api.AddPCUProtocolType)
+ UpdatePCUProtocolType = self.debug(self.api.UpdatePCUProtocolType)
+ GetPCUProtocolTypes = self.debug(self.api.GetPCUProtocolTypes)
for i in range(n):
# Add PCUProtocolType
protocol_type_fields = random_pcu_protocol_type()
pcu_type_id = random.sample(self.pcu_type_ids, 1)[0]
- protocol_type_id = AddPCUProtocolType(auth, pcu_type_id, protocol_type_fields)
+ protocol_type_id = AddPCUProtocolType(self.auth, pcu_type_id, protocol_type_fields)
if protocol_type_id is None: continue
# Should return a unique id
protocol_type_ids.append(protocol_type_id)
# Check protocol type
- protocol_types = GetPCUProtocolTypes(auth, [protocol_type_id])
+ protocol_types = GetPCUProtocolTypes(self.auth, [protocol_type_id])
if protocol_types is None: continue
protocol_type = protocol_types[0]
self.isequal(protocol_type, protocol_type_fields, 'AddPCUProtocolType - isequal')
# Update protocol type
protocol_type_fields = random_pcu_protocol_type()
- UpdatePCUProtocolType(auth, protocol_type_id, protocol_type_fields)
+ UpdatePCUProtocolType(self.auth, protocol_type_id, protocol_type_fields)
# Check again
- protocol_types = GetPCUProtocolTypes(auth, [protocol_type_id])
+ protocol_types = GetPCUProtocolTypes(self.auth, [protocol_type_id])
if protocol_types is None: continue
protocol_type = protocol_types[0]
self.isequal(protocol_type, protocol_type_fields, 'UpdatePCUProtocolType - isequal')
- protocol_types = GetPCUProtocolTypes(auth, protocol_type_ids)
+ protocol_types = GetPCUProtocolTypes(self.auth, protocol_type_ids)
if protocol_types is not None:
pt_ids = [p['pcu_protocol_type_id'] for p in protocol_types]
self.islistequal(protocol_type_ids, pt_ids, 'GetPCUProtocolTypes - isequal')
return protocol_type_ids
def DeletePCUProtocolTypes(self):
- GetPCUProtocolTypes = self.debug(api.GetPCUProtocolTypes)
- DeletePCUProtocolType = self.debug(api.DeletePCUProtocolType)
+ GetPCUProtocolTypes = self.debug(self.api.GetPCUProtocolTypes)
+ DeletePCUProtocolType = self.debug(self.api.DeletePCUProtocolType)
for protocol_type_id in self.pcu_protocol_type_ids:
- DeletePCUProtocolType(auth, protocol_type_id)
+ DeletePCUProtocolType(self.auth, protocol_type_id)
# check
- protocol_types = GetPCUProtocolTypes(auth, self.pcu_protocol_type_ids)
+ protocol_types = GetPCUProtocolTypes(self.auth, self.pcu_protocol_type_ids)
self.islistequal(protocol_types, [], 'DeletePCUProtocolType - check')
if self.config.verbose:
def PCUs(self, n = 4):
pcu_ids = []
- AddPCU = self.debug(api.AddPCU)
- UpdatePCU = self.debug(api.UpdatePCU)
- GetPCUs = self.debug(api.GetPCUs)
+ AddPCU = self.debug(self.api.AddPCU)
+ UpdatePCU = self.debug(self.api.UpdatePCU)
+ GetPCUs = self.debug(self.api.GetPCUs)
for site_id in self.site_ids:
# Add PCU
pcu_fields = random_pcu()
- pcu_id = AddPCU(auth, site_id, pcu_fields)
+ pcu_id = AddPCU(self.auth, site_id, pcu_fields)
if pcu_id is None: continue
# Should return a unique id
pcu_ids.append(pcu_id)
# check PCU
- pcus = GetPCUs(auth, [pcu_id])
+ pcus = GetPCUs(self.auth, [pcu_id])
if pcus is None: continue
pcu = pcus[0]
self.isequal(pcu, pcu_fields, 'AddPCU - isequal')
# Update PCU
pcu_fields = random_pcu()
- UpdatePCU(auth, pcu_id, pcu_fields)
+ UpdatePCU(self.auth, pcu_id, pcu_fields)
# Check again
- pcus = GetPCUs(auth, [pcu_id])
+ pcus = GetPCUs(self.auth, [pcu_id])
if pcus is None: continue
pcu = pcus[0]
self.isequal(pcu, pcu_fields, 'UpdatePCU - isequal')
- pcus = GetPCUs(auth, pcu_ids)
+ pcus = GetPCUs(self.auth, pcu_ids)
if pcus is not None:
self.islistequal(pcu_ids, [p['pcu_id'] for p in pcus], 'GetPCUs - isequal')
return pcu_ids
def DeletePCUs(self):
- GetPCUs = self.debug(api.GetPCUs)
- DeletePCU = self.debug(api.DeletePCU)
+ GetPCUs = self.debug(self.api.GetPCUs)
+ DeletePCU = self.debug(self.api.DeletePCU)
for pcu_id in self.pcu_ids:
- DeletePCU(auth, pcu_id)
+ DeletePCU(self.auth, pcu_id)
# check
- pcus = GetPCUs(auth, self.pcu_ids)
+ pcus = GetPCUs(self.auth, self.pcu_ids)
self.islistequal(pcus, [], 'DeletePCU - check')
if self.config.verbose:
def Nodes(self, n=4):
node_ids = []
- AddNode = self.debug(api.AddNode)
- GetNodes = self.debug(api.GetNodes)
- UpdateNode = self.debug(api.UpdateNode)
+ AddNode = self.debug(self.api.AddNode)
+ GetNodes = self.debug(self.api.GetNodes)
+ UpdateNode = self.debug(self.api.UpdateNode)
for i in range(n):
# Add Node
node_fields = random_node()
site_id = random.sample(self.site_ids, 1)[0]
- node_id = AddNode(auth, site_id, node_fields)
+ node_id = AddNode(self.auth, site_id, node_fields)
if node_id is None: continue
# Should return a unique id
node_ids.append(node_id)
# Check nodes
- nodes = GetNodes(auth, [node_id])
+ nodes = GetNodes(self.auth, [node_id])
if nodes is None: continue
node = nodes[0]
self.isequal(node, node_fields, 'AddNode - isequal')
# Update node
node_fields = random_node()
- result = UpdateNode(auth, node_id, node_fields)
+ result = UpdateNode(self.auth, node_id, node_fields)
# Check again
- nodes = GetNodes(auth, [node_id])
+ nodes = GetNodes(self.auth, [node_id])
if nodes is None: continue
node = nodes[0]
self.isequal(node, node_fields, 'UpdateNode - isequal')
# Add node to nodegroup
nodegroup_id = random.sample(self.nodegroup_ids, 1)[0]
- AddNodeToNodeGroup = self.debug(api.AddNodeToNodeGroup)
- AddNodeToNodeGroup(auth, node_id, nodegroup_id)
+ AddNodeToNodeGroup = self.debug(self.api.AddNodeToNodeGroup)
+ AddNodeToNodeGroup(self.auth, node_id, nodegroup_id)
# Add node to PCU
- sites = api.GetSites(auth, [node['site_id']], ['pcu_ids'])
+ sites = self.api.GetSites(self.auth, [node['site_id']], ['pcu_ids'])
if not sites: continue
site = sites[0]
pcu_id = random.sample(site['pcu_ids'], 1)[0]
port = random.sample(range(65535), 1)[0]
- AddNodeToPCU = self.debug(api.AddNodeToPCU)
- AddNodeToPCU(auth, node_id, pcu_id, port)
+ AddNodeToPCU = self.debug(self.api.AddNodeToPCU)
+ AddNodeToPCU(self.auth, node_id, pcu_id, port)
# check nodegroup, pcu
- nodes = GetNodes(auth, [node_id], ['nodegroup_ids', 'pcu_ids'])
+ nodes = GetNodes(self.auth, [node_id], ['nodegroup_ids', 'pcu_ids'])
if nodes is None or not nodes: continue
node = nodes[0]
self.islistequal([nodegroup_id], node['nodegroup_ids'], 'AddNodeToNodeGroup - check')
self.islistequal([pcu_id], node['pcu_ids'], 'AddNodeToPCU - check')
- nodes = GetNodes(auth, node_ids)
+ nodes = GetNodes(self.auth, node_ids)
if nodes is not None:
self.islistequal(node_ids, [node['node_id'] for node in nodes], 'GetNodes - isequal')
def DeleteNodes(self):
# Delete attributes manually for first node
- GetNodes = self.debug(api.GetNodes)
- nodes = GetNodes(auth, self.node_ids)
+ GetNodes = self.debug(self.api.GetNodes)
+ nodes = GetNodes(self.auth, self.node_ids)
if nodes is None or not nodes: return 0
node = nodes[0]
if node['nodegroup_ids']:
# Delete NodeGroup
nodegroup_id = random.sample(node['nodegroup_ids'], 1)[0]
- DeleteNodeFromNodeGroup = self.debug(api.DeleteNodeFromNodeGroup)
- DeleteNodeFromNodeGroup(auth, node['node_id'], nodegroup_id)
+ DeleteNodeFromNodeGroup = self.debug(self.api.DeleteNodeFromNodeGroup)
+ DeleteNodeFromNodeGroup(self.auth, node['node_id'], nodegroup_id)
if node['pcu_ids']:
# Delete PCU
pcu_id = random.sample(node['pcu_ids'], 1)[0]
- DeleteNodeFromPCU = self.debug(api.DeleteNodeFromPCU)
- DeleteNodeFromPCU(auth, node['node_id'], pcu_id)
+ DeleteNodeFromPCU = self.debug(self.api.DeleteNodeFromPCU)
+ DeleteNodeFromPCU(self.auth, node['node_id'], pcu_id)
# check nodegroup, pcu
- nodes = GetNodes(auth, [node['node_id']])
+ nodes = GetNodes(self.auth, [node['node_id']])
if nodes is None or not nodes: return 0
self.islistequal([], node['nodegroup_ids'], 'DeleteNodeGromNodeGroup - check')
self.islistequal([], node['pcu_ids'], 'DeleteNodeFromPCU - check')
# Delete rest of nodes
- DeleteNode = self.debug(api.DeleteNode)
+ DeleteNode = self.debug(self.api.DeleteNode)
for node_id in self.node_ids:
- result = DeleteNode(auth, node_id)
+ result = DeleteNode(self.auth, node_id)
# Check if nodes are deleted
- GetNodes = self.debug(api.GetNodes)
- nodes = GetNodes(auth, self.node_ids)
+ GetNodes = self.debug(self.api.GetNodes)
+ nodes = GetNodes(self.auth, self.node_ids)
self.islistequal(nodes, [], 'DeleteNode Check')
if self.config.verbose:
address_type_ids = []
for i in range(n):
address_type_fields = random_address_type()
- AddAddressType = self.debug(api.AddAddressType)
- address_type_id = AddAddressType(auth, address_type_fields)
+ AddAddressType = self.debug(self.api.AddAddressType)
+ address_type_id = AddAddressType(self.auth, address_type_fields)
if address_type_id is None: continue
# Should return a unique address_type_id
address_type_ids.append(address_type_id)
# Check address type
- GetAddressTypes = self.debug(api.GetAddressTypes)
- address_types = GetAddressTypes(auth, [address_type_id])
+ GetAddressTypes = self.debug(self.api.GetAddressTypes)
+ address_types = GetAddressTypes(self.auth, [address_type_id])
if address_types is None: continue
address_type = address_types[0]
self.isequal(address_type, address_type_fields, 'AddAddressType - isequal')
# Update address type
address_type_fields = random_address_type()
- UpdateAddressType = self.debug(api.UpdateAddressType)
- result = UpdateAddressType(auth, address_type_id, address_type_fields)
+ UpdateAddressType = self.debug(self.api.UpdateAddressType)
+ result = UpdateAddressType(self.auth, address_type_id, address_type_fields)
if result is None: continue
# Check address type again
- address_types = GetAddressTypes(auth, [address_type_id])
+ address_types = GetAddressTypes(self.auth, [address_type_id])
if address_types is None: continue
address_type = address_types[0]
self.isequal(address_type, address_type_fields, 'UpdateAddressType - isequal')
# Check get all address types
- address_types = GetAddressTypes(auth, address_type_ids)
+ address_types = GetAddressTypes(self.auth, address_type_ids)
if address_types is not None:
self.islistequal(address_type_ids, [address_type['address_type_id'] for address_type in address_types], 'GetAddressTypes - isequal')
def DeleteAddressTypes(self):
- DeleteAddressType = self.debug(api.DeleteAddressType)
+ DeleteAddressType = self.debug(self.api.DeleteAddressType)
for address_type_id in self.address_type_ids:
- DeleteAddressType(auth, address_type_id)
+ DeleteAddressType(self.auth, address_type_id)
- GetAddressTypes = self.debug(api.GetAddressTypes)
- address_types = GetAddressTypes(auth, self.address_type_ids)
+ GetAddressTypes = self.debug(self.api.GetAddressTypes)
+ address_types = GetAddressTypes(self.auth, self.address_type_ids)
self.islistequal(address_types, [], 'DeleteAddressType - check')
if self.config.verbose:
def Addresses(self, n = 3):
address_ids = []
- AddSiteAddress = self.debug(api.AddSiteAddress)
- GetAddresses = self.debug(api.GetAddresses)
- UpdateAddress = self.debug(api.UpdateAddress)
- AddAddressTypeToAddress = self.debug(api.AddAddressTypeToAddress)
+ AddSiteAddress = self.debug(self.api.AddSiteAddress)
+ GetAddresses = self.debug(self.api.GetAddresses)
+ UpdateAddress = self.debug(self.api.UpdateAddress)
+ AddAddressTypeToAddress = self.debug(self.api.AddAddressTypeToAddress)
for i in range(n):
address_fields = random_address()
site_id = random.sample(self.site_ids, 1)[0]
- address_id = AddSiteAddress(auth, site_id, address_fields)
+ address_id = AddSiteAddress(self.auth, site_id, address_fields)
if address_id is None: continue
# Should return a unique address_id
address_ids.append(address_id)
# Check address
- addresses = GetAddresses(auth, [address_id])
+ addresses = GetAddresses(self.auth, [address_id])
if addresses is None: continue
address = addresses[0]
self.isequal(address, address_fields, 'AddSiteAddress - isequal')
# Update address
address_fields = random_address()
- result = UpdateAddress(auth, address_id, address_fields)
+ result = UpdateAddress(self.auth, address_id, address_fields)
# Check again
- addresses = GetAddresses(auth, [address_id])
+ addresses = GetAddresses(self.auth, [address_id])
if addresses is None: continue
address = addresses[0]
self.isequal(address, address_fields, 'UpdateAddress - isequal')
# Add Address Type
address_type_id = random.sample(self.address_type_ids, 1)[0]
- AddAddressTypeToAddress(auth, address_type_id, address_id)
+ AddAddressTypeToAddress(self.auth, address_type_id, address_id)
# check adress type
- addresses = GetAddresses(auth, [address_id], ['address_type_ids'])
+ addresses = GetAddresses(self.auth, [address_id], ['address_type_ids'])
if addresses is None or not addresses: continue
address = addresses[0]
self.islistequal([address_type_id], address['address_type_ids'], 'AddAddressTypeToAddress - check')
- addresses = GetAddresses(auth, address_ids)
+ addresses = GetAddresses(self.auth, address_ids)
if addresses is not None:
self.islistequal(address_ids, [ad['address_id'] for ad in addresses], 'GetAddresses - isequal')
def DeleteAddresses(self):
- DeleteAddress = self.debug(api.DeleteAddress)
- DeleteAddressTypeFromAddress = self.debug(api.DeleteAddressTypeFromAddress)
- GetAddresses = self.debug(api.GetAddresses)
+ DeleteAddress = self.debug(self.api.DeleteAddress)
+ DeleteAddressTypeFromAddress = self.debug(self.api.DeleteAddressTypeFromAddress)
+ GetAddresses = self.debug(self.api.GetAddresses)
# Delete attributes mananually first
- addresses = GetAddresses(auth, self.address_ids, ['address_id', 'address_type_ids'])
+ addresses = GetAddresses(self.auth, self.address_ids, ['address_id', 'address_type_ids'])
if addresses is None or not addresses: return 0
address = addresses[0]
if address['address_type_ids']:
address_type_id = random.sample(address['address_type_ids'], 1)[0]
- DeleteAddressTypeFromAddress(auth, address_type_id, address['address_id'])
+ DeleteAddressTypeFromAddress(self.auth, address_type_id, address['address_id'])
# check address_type_ids
- addresses = GetAddresses(auth, [address['address_id']], ['address_type_ids'])
+ addresses = GetAddresses(self.auth, [address['address_id']], ['address_type_ids'])
if addresses is None or not addresses: return 0
address = addresses[0]
self.islistequal([], address['address_type_ids'], 'DeleteAddressTypeFromAddress - check')
# Delete site addresses
for address_id in self.address_ids:
- result = DeleteAddress(auth, address_id)
+ result = DeleteAddress(self.auth, address_id)
# Check
- addresses = GetAddresses(auth, self.address_ids)
+ addresses = GetAddresses(self.auth, self.address_ids)
self.islistequal(addresses, [], 'DeleteAddress - check')
if self.config.verbose:
utils.header("Deleted addresses: %s" % self.address_ids)
def SliceAttributeTypes(self, n = 2):
attribute_type_ids = []
- AddSliceAttributeType = self.debug(api.AddSliceAttributeType)
- GetSliceAttributeTypes = self.debug(api.GetSliceAttributeTypes)
- UpdateSliceAttributeType = self.debug(api.UpdateSliceAttributeType)
+ AddSliceAttributeType = self.debug(self.api.AddSliceAttributeType)
+ GetSliceAttributeTypes = self.debug(self.api.GetSliceAttributeTypes)
+ UpdateSliceAttributeType = self.debug(self.api.UpdateSliceAttributeType)
for i in range(n):
attribute_type_fields = random_attribute_type()
- attribute_type_id = AddSliceAttributeType(auth, attribute_type_fields)
+ attribute_type_id = AddSliceAttributeType(self.auth, attribute_type_fields)
if attribute_type_id is None: continue
# Should return a unique slice_attribute_type_id
attribute_type_ids.append(attribute_type_id)
# Check slice_attribute_type
- attribute_types = GetSliceAttributeTypes(auth, [attribute_type_id])
+ attribute_types = GetSliceAttributeTypes(self.auth, [attribute_type_id])
if attribute_types is None: continue
attribute_type = attribute_types[0]
self.isequal(attribute_type, attribute_type_fields, 'AddSliceAttributeType - isequal')
# Update slice_attribute_type
attribute_type_fields = random_attribute_type()
- result = UpdateSliceAttributeType(auth, attribute_type_id, attribute_type_fields)
+ result = UpdateSliceAttributeType(self.auth, attribute_type_id, attribute_type_fields)
# Check again
- attribute_types = GetSliceAttributeTypes(auth, [attribute_type_id])
+ attribute_types = GetSliceAttributeTypes(self.auth, [attribute_type_id])
if attribute_types is None: continue
attribute_type = attribute_types[0]
self.isequal(attribute_type, attribute_type_fields, 'UpdateSliceAttributeType - isequal')
- attribute_types = GetSliceAttributeTypes(auth, attribute_type_ids)
+ attribute_types = GetSliceAttributeTypes(self.auth, attribute_type_ids)
if attribute_types is not None:
at_ids = [at['attribute_type_id'] for at in attribute_types]
self.islistequal(attribute_type_ids, at_ids, 'GetSliceAttributeTypes - isequal')
return attribute_type_ids
def DeleteSliceAttributeTypes(self):
- DeleteSliceAttributeType = self.debug(api.DeleteSliceAttributeType)
- GetSliceAttributeTypes = self.debug(api.GetSliceAttributeTypes)
+ DeleteSliceAttributeType = self.debug(self.api.DeleteSliceAttributeType)
+ GetSliceAttributeTypes = self.debug(self.api.GetSliceAttributeTypes)
# Delete slice_attribute_type
for slice_attribute_type_id in self.slice_attribute_type_ids:
- result = DeleteSliceAttributeType(auth, slice_attribute_type_id)
+ result = DeleteSliceAttributeType(self.auth, slice_attribute_type_id)
# Check
- slice_attribute_types = GetSliceAttributeTypes(auth, self.slice_attribute_type_ids)
+ slice_attribute_types = GetSliceAttributeTypes(self.auth, self.slice_attribute_type_ids)
self.islistequal(slice_attribute_types, [], 'DeleteSliceAttributeTypes - check')
if self.config.verbose:
utils.header("Deleted slice_attributes: %s" % self.slice_attribute_type_ids)
def SliceInstantiations(self, n = 2):
insts = []
- AddSliceInstantiation= self.debug(api.AddSliceInstantiation)
- GetSliceInstantiations = self.debug(api.GetSliceInstantiations)
+ AddSliceInstantiation= self.debug(self.api.AddSliceInstantiation)
+ GetSliceInstantiations = self.debug(self.api.GetSliceInstantiations)
for i in range(n):
inst = randstr(10)
- result = AddSliceInstantiation(auth, inst)
+ result = AddSliceInstantiation(self.auth, inst)
if result is None: continue
insts.append(inst)
# Check slice instantiaton
- instantiations = GetSliceInstantiations(auth)
+ instantiations = GetSliceInstantiations(self.auth)
if instantiations is None: continue
instantiations = filter(lambda x: x in [inst], instantiations)
instantiation = instantiations[0]
self.isequal(instantiation, inst, 'AddSliceInstantiation - isequal')
- instantiations = GetSliceInstantiations(auth)
+ instantiations = GetSliceInstantiations(self.auth)
if instantiations is not None:
instantiations = filter(lambda x: x in insts, instantiations)
self.islistequal(insts, instantiations, 'GetSliceInstantiations - isequal')
return insts
def DeleteSliceInstantiations(self):
- DeleteSliceInstantiation = self.debug(api.DeleteSliceInstantiation)
- GetSliceInstantiations = self.debug(api.GetSliceInstantiations)
+ DeleteSliceInstantiation = self.debug(self.api.DeleteSliceInstantiation)
+ GetSliceInstantiations = self.debug(self.api.GetSliceInstantiations)
# Delete slice instantiation
for instantiation in self.slice_instantiations:
- result = DeleteSliceInstantiation(auth, instantiation)
+ result = DeleteSliceInstantiation(self.auth, instantiation)
# Check
- instantiations = GetSliceInstantiations(auth)
+ instantiations = GetSliceInstantiations(self.auth)
instantiations = filter(lambda x: x in self.slice_instantiations, instantiations)
self.islistequal(instantiations, [], 'DeleteSliceInstantiation - check')
if self.config.verbose:
def Slices(self, n = 3):
slice_ids = []
- AddSlice = self.debug(api.AddSlice)
- GetSlices = self.debug(api.GetSlices)
- UpdateSlice = self.debug(api.UpdateSlice)
- AddSliceToNodes = self.debug(api.AddSliceToNodes)
+ AddSlice = self.debug(self.api.AddSlice)
+ GetSlices = self.debug(self.api.GetSlices)
+ UpdateSlice = self.debug(self.api.UpdateSlice)
+ AddSliceToNodes = self.debug(self.api.AddSliceToNodes)
for i in range(n):
# Add Site
slice_fields = random_slice()
- slice_id = AddSlice(auth, slice_fields)
+ slice_id = AddSlice(self.auth, slice_fields)
if slice_id is None: continue
# Should return a unique id
self.isunique(slice_id, slice_ids, 'AddSlicel - isunique')
slice_ids.append(slice_id)
- slices = GetSlices(auth, [slice_id])
+ slices = GetSlices(self.auth, [slice_id])
if slices is None: continue
slice = slices[0]
self.isequal(slice, slice_fields, 'AddSlice - isequal')
# Update slice
slice_fields = random_slice()
- result = UpdateSlice(auth, slice_id, slice_fields)
+ result = UpdateSlice(self.auth, slice_id, slice_fields)
# Check again
- slices = GetSlices(auth, [slice_id])
+ slices = GetSlices(self.auth, [slice_id])
if slices is None: continue
slice = slices[0]
self.isequal(slice, slice_fields, 'UpdateSlice - isequal')
# Add node
node_id = random.sample(self.node_ids, 1)[0]
- AddSliceToNodes(auth, slice_id, [node_id])
+ AddSliceToNodes(self.auth, slice_id, [node_id])
# check node
- slices = GetSlices(auth, [slice_id], ['node_ids'])
+ slices = GetSlices(self.auth, [slice_id], ['node_ids'])
if slices is None or not slices: continue
slice = slices[0]
self.islistequal([node_id], slice['node_ids'], 'AddSliceToNode - check')
- slices = GetSlices(auth, slice_ids)
+ slices = GetSlices(self.auth, slice_ids)
if slices is not None:
self.islistequal(slice_ids, [slice['slice_id'] for slice in slices], 'GetSlices - isequal')
def DeleteSlices(self):
- GetSlices = self.debug(api.GetSlices)
- DeleteSlice = self.debug(api.DeleteSlice)
- DeleteSliceFromNodes = self.debug(api.DeleteSliceFromNodes)
+ GetSlices = self.debug(self.api.GetSlices)
+ DeleteSlice = self.debug(self.api.DeleteSlice)
+ DeleteSliceFromNodes = self.debug(self.api.DeleteSliceFromNodes)
# manually delete attributes for first slice
- slices = GetSlices(auth, self.slice_ids, ['slice_id', 'node_ids'])
+ slices = GetSlices(self.auth, self.slice_ids, ['slice_id', 'node_ids'])
if slices is None or not slices: return 0
slice = slices[0]
if slice['node_ids']:
# Delete node from slice
node_id = random.sample(slice['node_ids'], 1)[0]
- DeleteSliceFromNodes(slice['slice_id'], [node_id])
+ DeleteSliceFromNodes(self.auth, slice['slice_id'], [node_id])
# Check node_ids
- slices = GetSlices(auth, [slice['slice_id']], ['node_ids'])
+ slices = GetSlices(self.auth, [slice['slice_id']], ['node_ids'])
if slices is None or not slices: return 0
slice = slices[0]
self.islistequal([], slice['node_ids'], 'DeleteSliceFromNode - check')
# Have DeleteSlice automatically delete attriubtes for the rest
for slice_id in self.slice_ids:
# Delete account
- DeleteSlice(auth, slice_id)
+ DeleteSlice(self.auth, slice_id)
# Check if slices are deleted
- GetSlices = self.debug(api.GetSlices)
- slices = GetSlices(auth, self.slice_ids)
+ GetSlices = self.debug(self.api.GetSlices)
+ slices = GetSlices(self.auth, self.slice_ids)
self.islistequal(slices, [], 'DeleteSlice - check')
if self.config.verbose:
def SliceAttributes(self, n = 4):
attribute_ids = []
- AddSliceAttribute = self.debug(api.AddSliceAttribute)
- GetSliceAttributes = self.debug(api.GetSliceAttributes)
- UpdateSliceAttribute = self.debug(api.UpdateSliceAttribute)
+ AddSliceAttribute = self.debug(self.api.AddSliceAttribute)
+ GetSliceAttributes = self.debug(self.api.GetSliceAttributes)
+ UpdateSliceAttribute = self.debug(self.api.UpdateSliceAttribute)
for i in range(n):
# Add slice attribute
slice_id = random.sample(self.slice_ids, 1)[0]
type = attribute_fields['attribute_type_id']
value = attribute_fields['value']
- attribute_id = AddSliceAttribute(auth, slice_id, type, value)
+ attribute_id = AddSliceAttribute(self.auth, slice_id, type, value)
if attribute_id is None: continue
# Should return a unique id
attribute_ids.append(attribute_id)
# Check attribute
- attributes = GetSliceAttributes(auth, [attribute_id])
+ attributes = GetSliceAttributes(self.auth, [attribute_id])
if attributes is None: continue
attribute = attributes[0]
self.isequal(attribute, attribute_fields, 'AddSliceAttribute - isequal')
attribute_fields = random_slice_attribute()
type = attribute_fields['attribute_type_id']
value = attribute_fields['value']
- result = UpdateSliceAttribute(auth, attribute_id, value)
+ result = UpdateSliceAttribute(self.auth, attribute_id, value)
# Check again
- attributes = GetSliceAttributes(auth, [attribute_id])
+ attributes = GetSliceAttributes(self.auth, [attribute_id])
if attributes is None: continue
attribute = attributes[0]
self.isequal(attribute, attribute_fields, 'UpdateSliceAttribute - isequal')
- attributes = GetSliceAttributes(auth, attribute_ids)
+ attributes = GetSliceAttributes(self.auth, attribute_ids)
if attributes is not None:
attr_ids = [a['slice_attribute_id'] for a in attributes]
self.islistequal(attribute_ids, attr_ids, 'GetSliceAttributes - isequal')
return attribute_ids
def DeleteSliceAttributes(self):
- DeleteSliceAttribute = self.debug(api.DeleteSliceAttribute)
- GetSliceAttributes = self.debug(api.GetSliceAttributes)
+ DeleteSliceAttribute = self.debug(self.api.DeleteSliceAttribute)
+ GetSliceAttributes = self.debug(self.api.GetSliceAttributes)
for attribute_id in self.slice_attribute_ids:
- DeleteSliceAttribute(auth, attribute_id)
+ DeleteSliceAttribute(self.auth, attribute_id)
- attributes = GetSliceAttributes(auth, self.slice_attribute_ids)
+ attributes = GetSliceAttributes(self.auth, self.slice_attribute_ids)
self.islistequal(attributes, [], 'DeleteSliceAttribute - check')
if self.config.verbose:
def InitScripts(self, n = 2):
initscript_ids = []
- AddInitScript = self.debug(api.AddInitScript)
- GetInitScripts = self.debug(api.GetInitScripts)
- UpdateInitScript = self.debug(api.UpdateInitScript)
+ AddInitScript = self.debug(self.api.AddInitScript)
+ GetInitScripts = self.debug(self.api.GetInitScripts)
+ UpdateInitScript = self.debug(self.api.UpdateInitScript)
for i in range(n):
# Add Peer
initscript_fields = random_initscript()
- initscript_id = AddInitScript(auth, initscript_fields)
+ initscript_id = AddInitScript(self.auth, initscript_fields)
# Should return a unique id
self.isunique(initscript_id, initscript_ids, 'AddInitScript - isunique')
initscript_ids.append(initscript_id)
- initscripts = GetInitScripts(auth, [initscript_id])
+ initscripts = GetInitScripts(self.auth, [initscript_id])
if initscripts is None: continue
initscript = initscripts[0]
self.isequal(initscript, initscript_fields, 'AddInitScript - isequal')
# Update Peer
initscript_fields = random_initscript()
- result = UpdateInitScript(auth, initscript_id, initscript_fields)
+ result = UpdateInitScript(self.auth, initscript_id, initscript_fields)
# Check again
- initscripts = GetInitScripts(auth, [initscript_id])
+ initscripts = GetInitScripts(self.auth, [initscript_id])
if initscripts is None: continue
initscript = initscripts[0]
self.isequal(initscript, initscript_fields, 'UpdateInitScript - isequal')
- initscripts = GetInitScripts(auth, initscript_ids)
+ initscripts = GetInitScripts(self.auth, initscript_ids)
if initscripts is not None:
self.islistequal(initscript_ids, [i['initscript_id'] for i in initscripts], 'GetInitScripts -isequal')
def DeleteInitScripts(self):
# Delete all initscripts
- DeleteInitScript = self.debug(api.DeleteInitScript)
- GetInitScripts = self.debug(api.GetInitScripts)
+ DeleteInitScript = self.debug(self.api.DeleteInitScript)
+ GetInitScripts = self.debug(self.api.GetInitScripts)
for initscript_id in self.initscript_ids:
- result = DeleteInitScript(auth, initscript_id)
+ result = DeleteInitScript(self.auth, initscript_id)
# Check if peers are deleted
- initscripts = GetInitScripts(auth, self.initscript_ids)
+ initscripts = GetInitScripts(self.auth, self.initscript_ids)
self.islistequal(initscripts, [], 'DeletInitScript - check')
if self.config.verbose:
def Roles(self, n = 2):
role_ids = []
- AddRole = self.debug(api.AddRole)
- GetRoles = self.debug(api.GetRoles)
+ AddRole = self.debug(self.api.AddRole)
+ GetRoles = self.debug(self.api.GetRoles)
for i in range(n):
# Add Role
role_fields = random_role()
role_id = role_fields['role_id']
name = role_fields['name']
- AddRole(auth, role_id, name)
+ AddRole(self.auth, role_id, name)
# Should return a unique id
self.isunique(role_id, role_ids, 'AddRole - isunique')
role_ids.append(role_id)
- roles = GetRoles(auth)
+ roles = GetRoles(self.auth)
if roles is None: continue
roles = filter(lambda x: x['role_id'] in [role_id], roles)
role = roles[0]
self.isequal(role, role_fields, 'AddRole - isequal')
- roles = GetRoles(auth)
+ roles = GetRoles(self.auth)
if roles is not None:
roles = filter(lambda x: x['role_id'] in role_ids, roles)
self.islistequal(role_ids, [r['role_id'] for r in roles], 'GetRoles - isequal')
def DeleteRoles(self):
# Delete all roles
- DeleteRole = self.debug(api.DeleteRole)
- GetRoles = self.debug(api.GetRoles)
+ DeleteRole = self.debug(self.api.DeleteRole)
+ GetRoles = self.debug(self.api.GetRoles)
for role_id in self.role_ids:
- result = DeleteRole(auth, role_id)
+ result = DeleteRole(self.auth, role_id)
# Check if peers are deleted
- roles = GetRoles(auth)
+ roles = GetRoles(self.auth)
roles = filter(lambda x: x['role_id'] in self.role_ids, roles)
self.islistequal(roles, [], 'DeleteRole - check' % self.role_ids)
# Add account
person_fields = random_person()
- AddPerson = self.debug(api.AddPerson)
- person_id = AddPerson(auth, person_fields)
+ AddPerson = self.debug(self.api.AddPerson)
+ person_id = AddPerson(self.auth, person_fields)
if person_id is None: continue
# Should return a unique person_id
self.isunique(person_id, person_ids, 'AddPerson - isunique')
person_ids.append(person_id)
- GetPersons = self.debug(api.GetPersons)
- persons = GetPersons(auth, [person_id])
+ GetPersons = self.debug(self.api.GetPersons)
+ persons = GetPersons(self.auth, [person_id])
if persons is None: continue
person = persons[0]
self.isequal(person, person_fields, 'AddPerson - isequal')
# Update account
person_fields = random_person()
person_fields['enabled'] = True
- UpdatePerson = self.debug(api.UpdatePerson)
- result = UpdatePerson(auth, person_id, person_fields)
+ UpdatePerson = self.debug(self.api.UpdatePerson)
+ result = UpdatePerson(self.auth, person_id, person_fields)
# Add random role
- AddRoleToPerson = self.debug(api.AddRoleToPerson)
+ AddRoleToPerson = self.debug(self.api.AddRoleToPerson)
role = random.sample(roles, 1)[0]
- result = AddRoleToPerson(auth, role, person_id)
+ result = AddRoleToPerson(self.auth, role, person_id)
# Add key to person
key = random_key()
- key_id = AddPersonKey = self.debug(api.AddPersonKey)
- AddPersonKey(auth, person_id, key)
+ key_id = AddPersonKey = self.debug(self.api.AddPersonKey)
+ AddPersonKey(self.auth, person_id, key)
# Add person to site
site_id = random.sample(self.site_ids, 1)[0]
- AddPersonToSite = self.debug(api.AddPersonToSite)
- AddPersonToSite(auth, person_id, site_id)
+ AddPersonToSite = self.debug(self.api.AddPersonToSite)
+ AddPersonToSite(self.auth, person_id, site_id)
# Add person to slice
slice_id = random.sample(self.slice_ids, 1)[0]
- AddPersonToSlice = self.debug(api.AddPersonToSlice)
- AddPersonToSlice(auth, person_id, slice_id)
+ AddPersonToSlice = self.debug(self.api.AddPersonToSlice)
+ AddPersonToSlice(self.auth, person_id, slice_id)
# check role, key, site, slice
- persons = GetPersons(auth, [person_id], ['roles', 'key_ids', 'site_ids', 'slice_ids'])
+ persons = GetPersons(self.auth, [person_id], ['roles', 'key_ids', 'site_ids', 'slice_ids'])
if persons is None or not persons: continue
person = persons[0]
self.islistequal([role], person['roles'], 'AddRoleToPerson - check')
self.islistequal([site_id], person['site_ids'], 'AddPersonToSite - check')
self.islistequal([slice_id], person['slice_ids'], 'AddPersonToSlice - check')
- persons = GetPersons(auth, person_ids)
+ persons = GetPersons(self.auth, person_ids)
if persons is not None:
self.islistequal(person_ids, [p['person_id'] for p in persons], 'GetPersons - isequal')
def DeletePersons(self):
# Delete attributes manually for first person
- GetPersons = self.debug(api.GetPersons)
- persons = GetPersons(auth, self.person_ids, ['person_id' , 'key_ids', 'site_ids', 'slice_ids', 'roles'])
+ GetPersons = self.debug(self.api.GetPersons)
+ persons = GetPersons(self.auth, self.person_ids, ['person_id' , 'key_ids', 'site_ids', 'slice_ids', 'roles'])
if persons is None or not persons: return 0
person = persons[0]
if person['roles']:
# Delete role
role = random.sample(person['roles'], 1)[0]
- DeleteRoleFromPerson = self.debug(api.DeleteRoleFromPerson)
- DeleteRoleFromPerson(auth, role, person['person_id'])
+ DeleteRoleFromPerson = self.debug(self.api.DeleteRoleFromPerson)
+ DeleteRoleFromPerson(self.auth, role, person['person_id'])
if person['key_ids']:
# Delete key
key_id = random.sample(person['key_ids'], 1)[0]
- DeleteKey = self.debug(api.DeleteKey)
- DeleteKey(auth, key_id)
+ DeleteKey = self.debug(self.api.DeleteKey)
+ DeleteKey(self.auth, key_id)
if person['site_ids']:
# Remove person from site
site_id = random.sample(person['site_ids'], 1)[0]
- DeletePersonFromSite = self.debug(api.DeletePersonFromSite)
- DeletePersonFromSite(auth, person['person_id'], site_id)
+ DeletePersonFromSite = self.debug(self.api.DeletePersonFromSite)
+ DeletePersonFromSite(self.auth, person['person_id'], site_id)
if person['slice_ids']:
# Remove person from slice
slice_id = random.sample(person['slice_ids'], 1)[0]
- DeletePersonFromSlice = self.debug(api.DeletePersonFromSlice)
- DeletePersonFromSlice(auth, person['person_id'], slice_id)
+ DeletePersonFromSlice = self.debug(self.api.DeletePersonFromSlice)
+ DeletePersonFromSlice(self.auth, person['person_id'], slice_id)
# check role, key, site, slice
- persons = GetPersons(auth, [person['person_id']], ['roles', 'key_ids', 'site_ids', 'slice_ids'])
+ persons = GetPersons(self.auth, [person['person_id']], ['roles', 'key_ids', 'site_ids', 'slice_ids'])
if persons is None or not persons: return 0
person = persons[0]
self.islistequal([], person['roles'], 'DeleteRoleFromPerson - check')
self.islistequal([], person['site_ids'], 'DeletePersonFromSite - check')
self.islistequal([], person['slice_ids'], 'DeletePersonFromSlice - check')
- DeletePerson = self.debug(api.DeletePerson)
+ DeletePerson = self.debug(self.api.DeletePerson)
# Have DeletePeson automatically delete attriubtes for all other persons
for person_id in self.person_ids:
# Delete account
- DeletePerson(auth, person_id)
+ DeletePerson(self.auth, person_id)
# Check if persons are deleted
- GetPersons = self.debug(api.GetPersons)
- persons = GetPersons(auth, self.person_ids)
+ GetPersons = self.debug(self.api.GetPersons)
+ persons = GetPersons(self.auth, self.person_ids)
self.islistequal(persons, [], 'DeletePerson - check')
if self.config.verbose:
def KeyTypes(self, n = 2):
key_types = []
- AddKeyType = self.debug(api.AddKeyType)
- GetKeyTypes = self.debug(api.GetKeyTypes)
+ AddKeyType = self.debug(self.api.AddKeyType)
+ GetKeyTypes = self.debug(self.api.GetKeyTypes)
for i in range(n):
# Add key type
keytype = randstr(10)
- result = AddKeyType(auth, keytype)
+ result = AddKeyType(self.auth, keytype)
if result is None: continue
# Check key types
key_types.append(keytype)
- keytypes = GetKeyTypes(auth)
+ keytypes = GetKeyTypes(self.auth)
if not keytypes: continue
keytypes = filter(lambda x: x in [keytype], keytypes)
if not keytypes: continue
self.isequal(keytype, keytypes[0], 'AddKeyType - isequal')
# Check all
- keytypes = GetKeyTypes(auth)
+ keytypes = GetKeyTypes(self.auth)
if keytypes is not None:
keytypes = filter(lambda x: x in key_types, keytypes)
self.islistequal(key_types, keytypes, 'GetKeyTypes - isequal')
return key_types
def DeleteKeyTypes(self):
- DeleteKeyType = self.debug(api.DeleteKeyType)
- GetKeyTypes = self.debug(api.GetKeyTypes)
+ DeleteKeyType = self.debug(self.api.DeleteKeyType)
+ GetKeyTypes = self.debug(self.api.GetKeyTypes)
for key_type in self.key_types:
- result = DeleteKeyType(auth, key_type)
+ result = DeleteKeyType(self.auth, key_type)
# Check if key types are deleted
- key_types = GetKeyTypes(auth)
+ key_types = GetKeyTypes(self.auth)
key_types = filter(lambda x: x in self.key_types, key_types)
self.islistequal(key_types, [], 'DeleteKeyType - check')
# Add a key to an account
key_fields = random_key()
person_id = random.sample(self.person_ids, 1)[0]
- AddPersonKey = self.debug(api.AddPersonKey)
- key_id = AddPersonKey(auth, person_id, key_fields)
+ AddPersonKey = self.debug(self.api.AddPersonKey)
+ key_id = AddPersonKey(self.auth, person_id, key_fields)
if key_id is None: continue
# Should return a unique key_id
self.isunique(key_id, key_ids, 'AddPersonKey - isunique')
key_ids.append(key_id)
- GetKeys = self.debug(api.GetKeys)
- keys = GetKeys(auth, [key_id])
+ GetKeys = self.debug(self.api.GetKeys)
+ keys = GetKeys(self.auth, [key_id])
if keys is None: continue
key = keys[0]
self.isequal(key, key_fields, 'AddPersonKey - isequal')
# Update Key
key_fields = random_key()
- UpdateKey = self.debug(api.UpdateKey)
- result = UpdateKey(auth, key_id, key_fields)
+ UpdateKey = self.debug(self.api.UpdateKey)
+ result = UpdateKey(self.auth, key_id, key_fields)
- keys = GetKeys(auth, [key_id])
+ keys = GetKeys(self.auth, [key_id])
if keys is None or not keys: continue
key = keys[0]
self.isequal(key, key_fields, 'UpdatePersonKey - isequal')
- keys = GetKeys(auth, key_ids)
+ keys = GetKeys(self.auth, key_ids)
if keys is not None:
self.islistequal(key_ids, [key['key_id'] for key in keys], 'GetKeys - isequal')
def DeleteKeys(self):
# Blacklist first key, Delete rest
- GetKeys = self.debug(api.GetKeys)
- DeleteKey = self.debug(api.DeleteKey)
- BlacklistKey = self.debug(api.BlacklistKey)
+ GetKeys = self.debug(self.api.GetKeys)
+ DeleteKey = self.debug(self.api.DeleteKey)
+ BlacklistKey = self.debug(self.api.BlacklistKey)
key_id = self.key_ids.pop()
- BlacklistKey(auth, key_id)
- keys = GetKeys(auth, [key_id])
+ BlacklistKey(self.auth, key_id)
+ keys = GetKeys(self.auth, [key_id])
self.islistequal(keys, [], 'BlacklistKey - check')
if self.config.verbose:
utils.header("Blacklisted key: %s" % key_id)
for key_id in self.key_ids:
- DeleteKey(auth, key_id)
+ DeleteKey(self.auth, key_id)
- keys = GetKeys(auth, self.key_ids)
+ keys = GetKeys(self.auth, self.key_ids)
self.islistequal(keys, [], 'DeleteKey - check')
if self.config.verbose:
def BootStates(self, n = 3):
boot_states = []
- AddBootState = self.debug(api.AddBootState)
- GetBootStates = self.debug(api.GetBootStates)
+ AddBootState = self.debug(self.api.AddBootState)
+ GetBootStates = self.debug(self.api.GetBootStates)
for i in range(n):
# Add boot state
bootstate_fields = randstr(10)
- result = AddBootState(auth, bootstate_fields)
+ result = AddBootState(self.auth, bootstate_fields)
if result is None: continue
# Check boot states
boot_states.append(bootstate_fields)
- bootstates = GetBootStates(auth)
+ bootstates = GetBootStates(self.auth)
if not bootstates: continue
bootstates = filter(lambda x: x in [bootstate_fields], bootstates)
if not bootstates: continue
self.isequal(bootstate, bootstate_fields, 'AddBootState - isequal')
# Check all
- bs = GetBootStates(auth)
+ bs = GetBootStates(self.auth)
if bs is not None:
bs = filter(lambda x: x in [boot_states], bs)
self.islistequal(boot_states, bs, 'GetBootStates - isequal')
return boot_states
def DeleteBootStates(self):
- DeleteBootState = self.debug(api.DeleteBootState)
- GetBootStates = self.debug(api.GetBootStates)
+ DeleteBootState = self.debug(self.api.DeleteBootState)
+ GetBootStates = self.debug(self.api.GetBootStates)
for boot_state in self.boot_states:
- result = DeleteBootState(auth, boot_state)
+ result = DeleteBootState(self.auth, boot_state)
# Check if bootsates are deleted
- boot_states = GetBootStates(auth)
+ boot_states = GetBootStates(self.auth)
boot_states = filter(lambda x: x in self.boot_states, boot_states)
self.islistequal(boot_states, [], 'DeleteBootState check')
def Peers(self, n = 2):
peer_ids = []
- AddPeer = self.debug(api.AddPeer)
- GetPeers = self.debug(api.GetPeers)
- UpdatePeer = self.debug(api.UpdatePeer)
+ AddPeer = self.debug(self.api.AddPeer)
+ GetPeers = self.debug(self.api.GetPeers)
+ UpdatePeer = self.debug(self.api.UpdatePeer)
for i in range(n):
# Add Peer
peer_fields = random_peer()
- peer_id = AddPeer(auth, peer_fields)
+ peer_id = AddPeer(self.auth, peer_fields)
# Should return a unique id
self.isunique(peer_id, peer_ids, 'AddPeer - isunique')
peer_ids.append(peer_id)
- peers = GetPeers(auth, [peer_id])
+ peers = GetPeers(self.auth, [peer_id])
if peers is None: continue
peer = peers[0]
self.isequal(peer, peer_fields, 'AddPeer - isequal')
# Update Peer
peer_fields = random_peer()
- result = UpdatePeer(auth, peer_id, peer_fields)
+ result = UpdatePeer(self.auth, peer_id, peer_fields)
# Check again
- peers = GetPeers(auth, [peer_id])
+ peers = GetPeers(self.auth, [peer_id])
if peers is None: continue
peer = peers[0]
self.isequal(peer, peer_fields, 'UpdatePeer - isequal')
- peers = GetPeers(auth, peer_ids)
+ peers = GetPeers(self.auth, peer_ids)
if peers is not None:
self.islistequal(peer_ids, [peer['peer_id'] for peer in peers], 'GetPeers -isequal')
def DeletePeers(self):
# Delete all peers
- DeletePeer = self.debug(api.DeletePeer)
- GetPeers = self.debug(api.GetPeers)
+ DeletePeer = self.debug(self.api.DeletePeer)
+ GetPeers = self.debug(self.api.GetPeers)
for peer_id in self.peer_ids:
- result = DeletePeer(auth, peer_id)
+ result = DeletePeer(self.auth, peer_id)
# Check if peers are deleted
- peers = GetPeers(auth, self.peer_ids)
+ peers = GetPeers(self.auth, self.peer_ids)
self.islistequal(peers, [], 'DeletePeer - check' % self.peer_ids)
if self.config.verbose:
for i in range(n):
# Add ConfFile
conf_file_fields = random_conf_file()
- AddConfFile = self.debug(api.AddConfFile)
- conf_file_id = AddConfFile(auth, conf_file_fields)
+ AddConfFile = self.debug(self.api.AddConfFile)
+ conf_file_id = AddConfFile(self.auth, conf_file_fields)
if conf_file_id is None: continue
# Should return a unique id
conf_file_ids.append(conf_file_id)
# Get ConfFiles
- GetConfFiles = self.debug(api.GetConfFiles)
- conf_files = GetConfFiles(auth, [conf_file_id])
+ GetConfFiles = self.debug(self.api.GetConfFiles)
+ conf_files = GetConfFiles(self.auth, [conf_file_id])
if conf_files is None: continue
conf_file = conf_files[0]
self.isequal(conf_file, conf_file_fields, 'AddConfFile - isunique')
# Update ConfFile
conf_file_fields = random_conf_file()
- UpdateConfFile = self.debug(api.UpdateConfFile)
- result = UpdateConfFile(auth, conf_file_id, conf_file_fields)
+ UpdateConfFile = self.debug(self.api.UpdateConfFile)
+ result = UpdateConfFile(self.auth, conf_file_id, conf_file_fields)
# Check again
- conf_files = GetConfFiles(auth, [conf_file_id])
+ conf_files = GetConfFiles(self.auth, [conf_file_id])
if conf_files is None: continue
conf_file = conf_files[0]
self.isequal(conf_file, conf_file_fields, 'UpdateConfFile - isunique')
# Add this conf file to a random node
node_id = random.sample(self.node_ids, 1)[0]
- AddConfFileToNode = self.debug(api.AddConfFileToNode)
- AddConfFileToNode(auth, conf_file_id, node_id)
+ AddConfFileToNode = self.debug(self.api.AddConfFileToNode)
+ AddConfFileToNode(self.auth, conf_file_id, node_id)
# Add this conf file to a random node group
nodegroup_id = random.sample(self.nodegroup_ids, 1)[0]
- AddConfFileToNodeGroup = self.debug(api.AddConfFileToNodeGroup)
- AddConfFileToNodeGroup(auth, conf_file_id, nodegroup_id)
+ AddConfFileToNodeGroup = self.debug(self.api.AddConfFileToNodeGroup)
+ AddConfFileToNodeGroup(self.auth, conf_file_id, nodegroup_id)
# Check node, nodegroup
- conf_files = GetConfFiles(auth, [conf_file_id], ['node_ids', 'nodegroup_ids'])
+ conf_files = GetConfFiles(self.auth, [conf_file_id], ['node_ids', 'nodegroup_ids'])
if conf_files is None or not conf_files: continue
conf_file = conf_files[0]
self.islistequal([node_id], conf_file['node_ids'], 'AddConfFileToNode - check')
- conf_files = GetConfFiles(auth, conf_file_ids)
+ conf_files = GetConfFiles(self.auth, conf_file_ids)
if conf_files is not None:
self.islistequal(conf_file_ids, [c['conf_file_id'] for c in conf_files], 'GetConfFiles - isequal')
if self.config.verbose:
def DeleteConfFiles(self):
- GetConfFiles = self.debug(api.GetConfFiles)
- DeleteConfFile = self.debug(api.DeleteConfFile)
- DeleteConfFileFromNode = self.debug(api.DeleteConfFileFromNode)
- DeleteConfFileFromNodeGroup = self.debug(api.DeleteConfFileFromNodeGroup)
+ GetConfFiles = self.debug(self.api.GetConfFiles)
+ DeleteConfFile = self.debug(self.api.DeleteConfFile)
+ DeleteConfFileFromNode = self.debug(self.api.DeleteConfFileFromNode)
+ DeleteConfFileFromNodeGroup = self.debug(self.api.DeleteConfFileFromNodeGroup)
- conf_files = GetConfFiles(auth, self.conf_file_ids)
+ conf_files = GetConfFiles(self.auth, self.conf_file_ids)
if conf_files is None or not conf_files: return 0
conf_file = conf_files[0]
if conf_file['node_ids']:
node_id = random.sample(conf_file['node_ids'], 1)[0]
- DeleteConfFileFromNode(auth, conf_file['conf_file_id'], node_id)
+ DeleteConfFileFromNode(self.auth, conf_file['conf_file_id'], node_id)
if conf_file['nodegroup_ids']:
nodegroup_id = random.sample(conf_file['nodegroup_ids'], 1)[0]
- DeleteConfFileFromNodeGroup(auth, conf_file['conf_file_id'], nodegroup_id)
+ DeleteConfFileFromNodeGroup(self.auth, conf_file['conf_file_id'], nodegroup_id)
# check
- conf_files = GetConfFiles(auth, [conf_file['conf_file_id']], ['node_ids', 'nodegroup_ids'])
+ conf_files = GetConfFiles(self.auth, [conf_file['conf_file_id']], ['node_ids', 'nodegroup_ids'])
if conf_files is None or not conf_files: return 0
conf_file = conf_files[0]
self.islistequal([], conf_file['node_ids'], 'AddConfFileToNode - check')
self.islistequal([], conf_file['nodegroup_ids'], 'AddConfFileToNodeGroup - check')
for conf_file_id in self.conf_file_ids:
- DeleteConfFile(auth, conf_file_id)
+ DeleteConfFile(self.auth, conf_file_id)
# check
- conf_files = GetConfFiles(auth, self.conf_file_ids)
+ conf_files = GetConfFiles(self.auth, self.conf_file_ids)
self.islistequal(conf_files, [], 'DeleteConfFile - check')
if self.config.verbose:
def NodeNetworks(self, n = 4):
nodenetwork_ids = []
- AddNodeNetwork = self.debug(api.AddNodeNetwork)
- UpdateNodeNetwork = self.debug(api.UpdateNodeNetwork)
- GetNodeNetworks = self.debug(api.GetNodeNetworks)
+ AddNodeNetwork = self.debug(self.api.AddNodeNetwork)
+ UpdateNodeNetwork = self.debug(self.api.UpdateNodeNetwork)
+ GetNodeNetworks = self.debug(self.api.GetNodeNetworks)
for i in range(n):
# Add Node Network
nodenetwork_fields = random_nodenetwork()
node_id = random.sample(self.node_ids, 1)[0]
- nodenetwork_id = AddNodeNetwork(auth, node_id, nodenetwork_fields)
+ nodenetwork_id = AddNodeNetwork(self.auth, node_id, nodenetwork_fields)
if nodenetwork_id is None: continue
# Should return a unique id
nodenetwork_ids.append(nodenetwork_id)
# check Node Network
- nodenetworks = GetNodeNetworks(auth, [nodenetwork_id])
+ nodenetworks = GetNodeNetworks(self.auth, [nodenetwork_id])
if nodenetworks is None: continue
nodenetwork = nodenetworks[0]
self.isequal(nodenetwork, nodenetwork_fields, 'AddNodeNetwork - isequal')
# Update NodeNetwork
nodenetwork_fields = random_nodenetwork()
- UpdateNodeNetwork(auth, nodenetwork_id, nodenetwork_fields)
+ UpdateNodeNetwork(self.auth, nodenetwork_id, nodenetwork_fields)
# Check again
- nodenetworks = GetNodeNetworks(auth, [nodenetwork_id])
+ nodenetworks = GetNodeNetworks(self.auth, [nodenetwork_id])
if nodenetworks is None: continue
nodenetwork = nodenetworks[0]
self.isequal(nodenetwork, nodenetwork_fields, 'UpdateNodeNetwork - isequal')
- nodenetworks = GetNodeNetworks(auth, nodenetwork_ids)
+ nodenetworks = GetNodeNetworks(self.auth, nodenetwork_ids)
if nodenetworks is not None:
self.islistequal(nodenetwork_ids, [n['nodenetwork_id'] for n in nodenetworks], 'GetNodeNetworks - isequal')
return nodenetwork_ids
def DeleteNodeNetworks(self):
- GetNodeNetworks = self.debug(api.GetNodeNetworks)
- DeleteNodeNetwork = self.debug(api.DeleteNodeNetwork)
+ GetNodeNetworks = self.debug(self.api.GetNodeNetworks)
+ DeleteNodeNetwork = self.debug(self.api.DeleteNodeNetwork)
for nodenetwork_id in self.nodenetwork_ids:
- DeleteNodeNetwork(auth, nodenetwork_id)
+ DeleteNodeNetwork(self.auth, nodenetwork_id)
# check
- nodenetworks = GetNodeNetworks(auth, self.nodenetwork_ids)
+ nodenetworks = GetNodeNetworks(self.auth, self.nodenetwork_ids)
self.islistequal(nodenetworks, [], 'DeleteNodeNetwork - check')
if self.config.verbose:
def NodeNetworkSettings(self, n=2):
nodenetwork_setting_ids = []
- AddNodeNetworkSetting = self.debug(api.AddNodeNetworkSetting)
- UpdateNodeNetworkSetting = self.debug(api.UpdateNodeNetworkSetting)
- GetNodeNetworkSettings = self.debug(api.GetNodeNetworkSettings)
+ AddNodeNetworkSetting = self.debug(self.api.AddNodeNetworkSetting)
+ UpdateNodeNetworkSetting = self.debug(self.api.UpdateNodeNetworkSetting)
+ GetNodeNetworkSettings = self.debug(self.api.GetNodeNetworkSettings)
for nodenetwork_id in self.nodenetwork_ids:
# Add Node Network
#nodenetwork_id = random.sample(self.nodenetwork_ids, 1)[0]
nodenetwork_setting_type_id = random.sample(self.nodenetwork_setting_type_ids, 1)[0]
value = nodenetwork_setting_fields['value']
- nodenetwork_setting_id = AddNodeNetworkSetting(auth, nodenetwork_id, nodenetwork_setting_type_id, value)
+ nodenetwork_setting_id = AddNodeNetworkSetting(self.auth, nodenetwork_id, nodenetwork_setting_type_id, value)
if nodenetwork_setting_id is None: continue
# Should return a unique id
nodenetwork_setting_ids.append(nodenetwork_setting_id)
# check Node Network
- nodenetwork_settings = GetNodeNetworkSettings(auth, [nodenetwork_setting_id])
+ nodenetwork_settings = GetNodeNetworkSettings(self.auth, [nodenetwork_setting_id])
if nodenetwork_settings is None: continue
nodenetwork_setting = nodenetwork_settings[0]
self.isequal(nodenetwork_setting, nodenetwork_setting_fields, 'AddNodeNetworkSetting - isequal')
# Update NodeNetworkSetting
nodenetwork_setting_fields = random_nodenetwork_setting()
value = nodenetwork_setting_fields['value']
- UpdateNodeNetworkSetting(auth, nodenetwork_setting_id, value)
+ UpdateNodeNetworkSetting(self.auth, nodenetwork_setting_id, value)
# Check again
- nodenetwork_settings = GetNodeNetworkSettings(auth, [nodenetwork_setting_id])
+ nodenetwork_settings = GetNodeNetworkSettings(self.auth, [nodenetwork_setting_id])
if nodenetwork_settings is None: continue
nodenetwork_setting = nodenetwork_settings[0]
self.isequal(nodenetwork_setting, nodenetwork_setting_fields, 'UpdateNodeNetworkSetting - isequal')
- nodenetwork_settings = GetNodeNetworkSettings(auth, nodenetwork_setting_ids)
+ nodenetwork_settings = GetNodeNetworkSettings(self.auth, nodenetwork_setting_ids)
if nodenetwork_settings is not None:
self.islistequal(nodenetwork_setting_ids, [n['nodenetwork_setting_id'] for n in nodenetwork_settings], 'GetNodeNetworkSettings - isequal')
return nodenetwork_setting_ids
def DeleteNodeNetworkSettings(self):
- GetNodeNetworkSettings = self.debug(api.GetNodeNetworkSettings)
- DeleteNodeNetworkSetting = self.debug(api.DeleteNodeNetworkSetting)
+ GetNodeNetworkSettings = self.debug(self.api.GetNodeNetworkSettings)
+ DeleteNodeNetworkSetting = self.debug(self.api.DeleteNodeNetworkSetting)
for nodenetwork_setting_id in self.nodenetwork_setting_ids:
- DeleteNodeNetworkSetting(auth, nodenetwork_setting_id)
+ DeleteNodeNetworkSetting(self.auth, nodenetwork_setting_id)
# check
- nodenetwork_settings = GetNodeNetworkSettings(auth, self.nodenetwork_setting_ids)
+ nodenetwork_settings = GetNodeNetworkSettings(self.auth, self.nodenetwork_setting_ids)
self.islistequal(nodenetwork_settings, [], 'DeleteNodeNetworkSetting - check')
if self.config.verbose:
def NodeNetworkSettingTypes(self, n = 2):
nodenetwork_setting_type_ids = []
- AddNodeNetworkSettingType = self.debug(api.AddNodeNetworkSettingType)
- UpdateNodeNetworkSettingType = self.debug(api.UpdateNodeNetworkSettingType)
- GetNodeNetworkSettingTypes = self.debug(api.GetNodeNetworkSettingTypes)
+ AddNodeNetworkSettingType = self.debug(self.api.AddNodeNetworkSettingType)
+ UpdateNodeNetworkSettingType = self.debug(self.api.UpdateNodeNetworkSettingType)
+ GetNodeNetworkSettingTypes = self.debug(self.api.GetNodeNetworkSettingTypes)
for i in range(n):
# Add Node Network Settings Type
nodenetwork_setting_type_fields = random_nodenetwork_setting_type()
- nodenetwork_setting_type_id = AddNodeNetworkSettingType(auth, nodenetwork_setting_type_fields)
+ nodenetwork_setting_type_id = AddNodeNetworkSettingType(self.auth, nodenetwork_setting_type_fields)
if nodenetwork_setting_type_id is None: continue
# Should return a unique id
nodenetwork_setting_type_ids.append(nodenetwork_setting_type_id)
# check Node Network Settings Type
- nodenetwork_setting_types = GetNodeNetworkSettingTypes(auth, [nodenetwork_setting_type_id])
+ nodenetwork_setting_types = GetNodeNetworkSettingTypes(self.auth, [nodenetwork_setting_type_id])
if nodenetwork_setting_types is None: continue
nodenetwork_setting_type = nodenetwork_setting_types[0]
self.isequal(nodenetwork_setting_type, nodenetwork_setting_type_fields, 'AddNodeNetworkSettingType - isequal')
# Update NodeNetworkSetting
nodenetwork_setting_type_fields = random_nodenetwork_setting_type()
- UpdateNodeNetworkSettingType(auth, nodenetwork_setting_type_id, nodenetwork_setting_type_fields)
+ UpdateNodeNetworkSettingType(self.auth, nodenetwork_setting_type_id, nodenetwork_setting_type_fields)
# Check again
- nodenetwork_setting_types = GetNodeNetworkSettingTypes(auth, [nodenetwork_setting_type_id])
+ nodenetwork_setting_types = GetNodeNetworkSettingTypes(self.auth, [nodenetwork_setting_type_id])
if nodenetwork_setting_types is None: continue
nodenetwork_setting_type = nodenetwork_setting_types[0]
self.isequal(nodenetwork_setting_type, nodenetwork_setting_type_fields, 'UpdateNodeNetworkSettingType - isequal')
- nodenetwork_setting_types = GetNodeNetworkSettingTypes(auth, nodenetwork_setting_type_ids)
+ nodenetwork_setting_types = GetNodeNetworkSettingTypes(self.auth, nodenetwork_setting_type_ids)
if nodenetwork_setting_types is not None:
self.islistequal(nodenetwork_setting_type_ids, [n['nodenetwork_setting_type_id'] for n in nodenetwork_setting_types], 'GetNodeNetworkSettingTypes - isequal')
return nodenetwork_setting_type_ids
def DeleteNodeNetworkSettingTypes(self):
- GetNodeNetworkSettingTypes = self.debug(api.GetNodeNetworkSettingTypes)
- DeleteNodeNetworkSettingType = self.debug(api.DeleteNodeNetworkSettingType)
+ GetNodeNetworkSettingTypes = self.debug(self.api.GetNodeNetworkSettingTypes)
+ DeleteNodeNetworkSettingType = self.debug(self.api.DeleteNodeNetworkSettingType)
for nodenetwork_setting_type_id in self.nodenetwork_setting_type_ids:
- DeleteNodeNetworkSettingType(auth, nodenetwork_setting_type_id)
+ DeleteNodeNetworkSettingType(self.auth, nodenetwork_setting_type_id)
# check
- nodenetwork_setting_types = GetNodeNetworkSettingTypes(auth, self.nodenetwork_setting_type_ids)
+ nodenetwork_setting_types = GetNodeNetworkSettingTypes(self.auth, self.nodenetwork_setting_type_ids)
self.islistequal(nodenetwork_setting_types, [], 'DeleteNodeNetworkSettingType - check')
if self.config.verbose:
def Messages(self, n = 2):
message_ids = []
- AddMessage = self.debug(api.AddMessage)
- GetMessages = self.debug(api.GetMessages)
- UpdateMessage = self.debug(api.UpdateMessage)
+ AddMessage = self.debug(self.api.AddMessage)
+ GetMessages = self.debug(self.api.GetMessages)
+ UpdateMessage = self.debug(self.api.UpdateMessage)
for i in range(n):
# Add Message
message_fields = random_message()
message_id = message_fields['message_id']
- AddMessage(auth, message_fields)
+ AddMessage(self.auth, message_fields)
if message_id is None: continue
# Should return a unique id
self.isunique(message_id, message_ids, 'AddMessage - isunique')
message_ids.append(message_id)
- messages = GetMessages(auth, [message_id])
+ messages = GetMessages(self.auth, [message_id])
if messages is None: continue
message = messages[0]
self.isequal(message, message_fields, 'AddMessage - isequal')
# Update message
message_fields = random_message()
- result = UpdateMessage(auth, message_id, message_fields)
+ result = UpdateMessage(self.auth, message_id, message_fields)
# Check again
- messages = GetMessages(auth, [message_id])
+ messages = GetMessages(self.auth, [message_id])
if messages is None: continue
message = messages[0]
self.isequal(message, message_fields, 'UpdateMessage - isequal')
- messages = GetMessages(auth, message_ids)
+ messages = GetMessages(self.auth, message_ids)
if messages is not None:
self.islistequal(message_ids, [m['message_id'] for m in messages], 'GetMessages - isequal')
def DeleteMessages(self):
# Delete all messages
- DeleteMessage = self.debug(api.DeleteMessage)
- GetMessages = self.debug(api.GetMessages)
+ DeleteMessage = self.debug(self.api.DeleteMessage)
+ GetMessages = self.debug(self.api.GetMessages)
for message_id in self.message_ids:
- result = DeleteMessage(auth, message_id)
+ result = DeleteMessage(self.auth, message_id)
# Check if messages are deleted
- messages = GetMessages(auth, self.message_ids)
+ messages = GetMessages(self.auth, self.message_ids)
self.islistequal(messages, [], 'DeleteMessage - check')
if self.config.verbose:
def Sessions(self, n = 2):
session_ids = []
- AddSession = self.debug(api.AddSession)
- GetSession = self.debug(api.GetSession)
- GetSessions = self.debug(api.GetSessions)
+ AddSession = self.debug(self.api.AddSession)
+ GetSession = self.debug(self.api.GetSession)
+ GetSessions = self.debug(self.api.GetSessions)
for i in range(n):
# Add session
person_id = random.sample(self.person_ids, 1)[0]
- session_id = AddSession(auth, person_id)
+ session_id = AddSession(self.auth, person_id)
if session_id is None: continue
session_ids.append(session_id)
# Check session
- sessions = GetSessions(auth, [person_id])
+ sessions = GetSessions(self.auth, [person_id])
if not sessions: continue
session = sessions[0]
sess_id = session['session_id']
self.islistequal([sess_id], [session_id], 'AddSession - isequal')
# GetSession creates session_id based on auth, so we must use the current auth
- session_id = GetSession(auth)
+ session_id = GetSession(self.auth)
if session_id is None: continue
session_ids.append(session_id)
# Check session
- sessions = GetSessions(auth, [auth['Username']])
+ sessions = GetSessions(self.auth, [self.auth['Username']])
if not sessions: continue
session = sessions[0]
sess_id = session['session_id']
self.islistequal([sess_id], [session_id], 'GetSession - isequal')
# Check all
- sessions = GetSessions(auth, session_ids)
+ sessions = GetSessions(self.auth, session_ids)
if sessions is not None:
sess_ids = [s['session_id'] for s in sessions]
self.islistequal(sess_ids, session_ids, 'GetSessions - isequal')
return session_ids
def DeleteSessions(self):
- DeleteSession = self.debug(api.DeleteSession)
- GetSessions = self.debug(api.GetSessions)
+ DeleteSession = self.debug(self.api.DeleteSession)
+ GetSessions = self.debug(self.api.GetSessions)
# DeleteSession deletes based on auth, so we must create auths for the sessions we delete
for session_id in self.session_ids:
- sessions = GetSessions(auth, [session_id])
+ sessions = GetSessions(self.auth, [session_id])
if not sessions: continue
session = sessions[0]
tmpauth = {
DeleteSession(tmpauth)
# Check if sessions are deleted
- sessions = GetSessions(auth, self.session_ids)
+ sessions = GetSessions(self.auth, self.session_ids)
self.islistequal(sessions, [], 'DeleteBootState check')
if self.config.verbose:
self.session_ids = []
def GenerateNodeConfFile(self):
- GetNodes = self.debug(api.GetNodes)
- GetNodeNetworks = self.debug(api.GetNodeNetworks)
- GenerateNodeConfFile = self.debug(api.GenerateNodeConfFile)
+ GetNodes = self.debug(self.api.GetNodes)
+ GetNodeNetworks = self.debug(self.api.GetNodeNetworks)
+ GenerateNodeConfFile = self.debug(self.api.GenerateNodeConfFile)
- nodes = GetNodes(auth, self.node_ids)
+ nodes = GetNodes(self.auth, self.node_ids)
nodes = filter(lambda n: n['nodenetwork_ids'], nodes)
if not nodes: return 0
node = nodes[0]
- nodenetworks = GetNodeNetworks(auth, node['nodenetwork_ids'])
+ nodenetworks = GetNodeNetworks(self.auth, node['nodenetwork_ids'])
nodenetwork = nodenetworks[0]
parts = node['hostname'].split(".", 1)
host = parts[0]
'HOSTNAME': host,
'DOMAIN_NAME': domain
}
- node_config_file = GenerateNodeConfFile(auth, node['node_id'])
+ node_config_file = GenerateNodeConfFile(self.auth, node['node_id'])
self.isequal(node_config_file, node_config, 'GenerateNodeConfFile - isequal')
if self.config.verbose:
def GetEventObjects(self):
- GetEventObjects = self.debug(api.GetEventObjects)
- GetEventObjects(auth)
+ GetEventObjects = self.debug(self.api.GetEventObjects)
+ GetEventObjects(self.auth)
if self.config.verbose:
utils.header("GetEventObjects")
def GetEvents(self):
- GetEvents = self.debug(api.GetEvents)
- GetEvents(auth)
+ GetEvents = self.debug(self.api.GetEvents)
+ GetEvents(self.auth)
if self.config.verbose:
utils.header("GetEvents")
def GetPeerData(self):
- GetPeers = self.debug(api.GetPeers)
- GetPeerData = self.debug(api.GetPeerData)
+ GetPeers = self.debug(self.api.GetPeers)
+ GetPeerData = self.debug(self.api.GetPeerData)
- peers = GetPeers(auth)
+ peers = GetPeers(self.auth)
if peers is None or not peers: return 0
peer = peers[0]
- peer_data = GetPeerData(auth)
+ peer_data = GetPeerData(self.auth)
# Manuall construt peer data
def GetPeerName(self):
# GetPeerName should return the same as api.config.PLC_NAME
- GetPeerName = self.debug(api.GetPeerName)
- peer_name = GetPeerName(auth)
- self.islistequal([peer_name], [api.config.PLC_NAME], 'GetPeerName - isequal')
+ GetPeerName = self.debug(self.api.GetPeerName)
+ peer_name = GetPeerName(self.auth)
+ self.islistequal([peer_name], [self.api.config.PLC_NAME], 'GetPeerName - isequal')
if self.config.verbose:
utils.header("GetPeerName")
def GetPlcRelease(self):
- GetPlcRelease = self.debug(api.GetPlcRelease)
- plc_release = GetPlcRelease(auth)
+ GetPlcRelease = self.debug(self.api.GetPlcRelease)
+ plc_release = GetPlcRelease(self.auth)
if self.config.verbose:
utils.header("GetPlcRelease")
def GetSliceKeys(self):
- GetSliceKeys = self.debug(api.GetSliceKeys)
- GetSlices = self.debug(api.GetSlices)
+ GetSliceKeys = self.debug(self.api.GetSliceKeys)
+ GetSlices = self.debug(self.api.GetSlices)
- slices = GetSlices(auth, self.slice_ids)
+ slices = GetSlices(self.auth, self.slice_ids)
if not slices: return 0
slices = filter(lambda s: s['person_ids'], slices)
if not slices: return 0
slice = slices[0]
- slice_keys = GetSliceKeys(auth, [slice['slice_id']])
+ slice_keys = GetSliceKeys(self.auth, [slice['slice_id']])
# XX Manually construct slice_keys for this slice and compare
if self.config.verbose:
utils.header("GetSliceKeys(%s)" % [slice['slice_id']])
def GetSliceTicket(self):
- GetSliceTicket = self.debug(api.GetSliceTicket)
+ GetSliceTicket = self.debug(self.api.GetSliceTicket)
slice_id = random.sample(self.slice_ids, 1)[0]
- slice_ticket = GetSliceTicket(auth, slice_id)
+ slice_ticket = GetSliceTicket(self.auth, slice_id)
if self.config.verbose:
utils.header("GetSliceTicket(%s)" % slice_id)
def GetSlicesMD5(self):
- GetSlicesMD5 = self.debug(api.GetSlicesMD5)
+ GetSlicesMD5 = self.debug(self.api.GetSlicesMD5)
- slices_md5 = GetSlicesMD5(auth)
+ slices_md5 = GetSlicesMD5(self.auth)
if self.config.verbose:
utils.header("GetSlicesMD5")
def GetSlivers(self):
- GetSlivers = self.debug(api.GetSlivers)
- GetNodes = self.debug(api.GetNodes)
- nodes = GetNodes(auth, self.node_ids)
+ GetSlivers = self.debug(self.api.GetSlivers)
+ GetNodes = self.debug(self.api.GetNodes)
+ nodes = GetNodes(self.auth, self.node_ids)
if nodes is None or not nodes: return 0
nodes = filter(lambda n: n['slice_ids'], nodes)
if not nodes: return 0
node = nodes[0]
- slivers = GetSlivers(auth, node['node_id'])
+ slivers = GetSlivers(self.auth, node['node_id'])
# XX manually create slivers object and compare
utils.header("GetSlivers(%s)" % node['node_id'])
def GetWhitelist(self):
- GetWhitelist = self.debug(api.GetWhitelist)
- GetNodes = self.debug(api.GetNodes)
+ GetWhitelist = self.debug(self.api.GetWhitelist)
+ GetNodes = self.debug(self.api.GetNodes)
- whitelists = GetWhitelist(auth, self.node_ids)
- nodes = GetNodes(auth, self.node_ids)
+ whitelists = GetWhitelist(self.auth, self.node_ids)
+ nodes = GetNodes(self.auth, self.node_ids)
if nodes is None or not nodes: return 0
nodes = filter(lambda n: n['slice_ids_whitelist'], nodes)
self.islistequal(whitelists, nodes, 'GetWhitelist - isequal')
utils.header("GetWhitelist")
def NotifyPersons(self):
- NotifyPersons = self.debug(api.NotifyPersons)
+ NotifyPersons = self.debug(self.api.NotifyPersons)
person_id = random.sample(self.person_ids, 1)[0]
- NotifyPersons(auth, [person_id], 'QA Test', 'Welcome')
+ NotifyPersons(self.auth, [person_id], 'QA Test', 'Welcome')
if self.config.verbose:
utils.header('NotifyPersons(%s)' % [person_id])
def NotifySupport(self):
- NotifySupport = self.debug(api.NotifySupport)
- NotifySupport(auth, 'QA Test', 'Support Request')
+ NotifySupport = self.debug(self.api.NotifySupport)
+ NotifySupport(self.auth, 'QA Test', 'Support Request')
if self.config.verbose:
utils.header('NotifSupport')
def RebootNode(self):
- RebootNode = self.debug(api.RebootNode)
+ RebootNode = self.debug(self.api.RebootNode)
node_id = random.sample(self.node_ids, 1)[0]
- RebootNode(auth, node_id)
+ RebootNode(self.auth, node_id)
if self.config.verbose:
utils.header('RebootNode(%s)' % node_id)
def ResetPassword(self):
- ResetPassword = self.debug(api.ResetPassword)
+ ResetPassword = self.debug(self.api.ResetPassword)
person_id = random.sample(self.person_ids, 1)[0]
- ResetPassword(auth, person_id)
+ ResetPassword(self.auth, person_id)
if self.config.verbose:
utils.header('ResetPassword(%s)' % person_id)
def SetPersonPrimarySite(self):
- SetPersonPrimarySite = self.debug(api.SetPersonPrimarySite)
- GetPersons = self.debug(api.GetPersons)
+ SetPersonPrimarySite = self.debug(self.api.SetPersonPrimarySite)
+ GetPersons = self.debug(self.api.GetPersons)
person_id = random.sample(self.person_ids, 1)[0]
- persons = GetPersons(auth, person_id)
+ persons = GetPersons(self.auth, person_id)
if not persons: return 0
person = persons[0]
site_id = random.sample(person['site_ids'], 1)[0]
- SetPersonPrimarySite(auth, person_id, site_id)
+ SetPersonPrimarySite(self.auth, person_id, site_id)
if self.config.verbose:
utils.header('SetPersonPrimarySite(%s, %s)' % (person_id, site_id))
def VerifyPerson(self):
- VerifyPerson = self.debug(api.VerifyPerson)
- UpdatePerson = self.debug(api.UpdatePerson)
- GetPersons = self.debug(api.GetPersons)
+ VerifyPerson = self.debug(self.api.VerifyPerson)
+ UpdatePerson = self.debug(self.api.UpdatePerson)
+ GetPersons = self.debug(self.api.GetPersons)
# can only verify new (disabled) accounts
person_id = random.sample(self.person_ids, 1)[0]
- persons = GetPersons(auth, [person_id])
+ persons = GetPersons(self.auth, [person_id])
if persons is None or not persons: return 0
person = persons[0]
- UpdatePerson(auth, person['person_id'], {'enabled': False})
- VerifyPerson(auth, person['person_id'])
+ UpdatePerson(self.auth, person['person_id'], {'enabled': False})
+ VerifyPerson(self.auth, person['person_id'])
if self.config.verbose:
utils.header('VerifyPerson(%s)' % person_id)
git://git.onelab.eu / tests.git / commitdiff