qaapi/qa/tests/api_unit_test.py

   1 #!/usr/bin/env /usr/share/plc_api/plcsh
   2 #
   3 # Test script example
   4 #
   5 # Copyright (C) 2006 The Trustees of Princeton University
   6 #
   7 #
   8
   9 from pprint import pprint
  10 from string import letters, digits, punctuation
  11 import traceback
  12 from traceback import print_exc
  13 import base64
  14 import os, sys
  15 import socket
  16 import struct
  17 import xmlrpclib
  18 import time
  19
  20 from Test import Test
  21 from qa import utils
  22 from qa.Config import Config
  23 from qa.logger import Logfile, log, logfile
  24 from random import Random
  25
  26 random = Random()
  27
  28 config = Config()
  29 api = config.api
  30 auth = api.auth
  31
  32 try: boot_states = api.GetBootStates(auth)
  33 except: boot_states = [u'boot', u'dbg', u'inst', u'new', u'rcnf', u'rins']
  34
  35 try: roles = [role['role_id'] for role in api.GetRoles(auth)]
  36 except: roles = [10,20,30,40]
  37
  38 try: methods = api.GetNetworkMethods(auth)
  39 except: methods = [u'static', u'dhcp', u'proxy', u'tap', u'ipmi', u'unknown']
  40
  41 try: key_types = api.GetKeyTypes(auth)
  42 except: key_types = [u'ssh']
  43
  44 try:types = api.GetNetworkTypes(auth)
  45 except: types = [u'ipv4']
  46
  47 try:
  48     attribute_types = [a['attribute_type_id'] for a in api.GetSliceAttributeTypes(auth)]
  49     attribute_types = filter(lambda x: x['name'] != 'initscript', attribute_types)
  50
  51 except:
  52     attribute_types = range(6,20)
  53
  54 try:
  55     sites = api.GetSites(auth, None, ['login_base'])
  56     login_bases = [site['login_base'] for site in sites]
  57 except:
  58     login_bases = ['pl']
  59
  60
  61 def randfloat(min = 0.0, max = 1.0):
  62     return float(min) + (random.random() * (float(max) - float(min)))
  63
  64 def randint(min = 0, max = 1):
  65     return int(randfloat(min, max + 1))
  66
  67 def randbool():
  68     return random.sample([True, False], 1)[0]
  69 # See "2.2 Characters" in the XML specification:
  70 #
  71 # #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD]
  72 # avoiding
  73 # [#x7F-#x84], [#x86-#x9F], [#xFDD0-#xFDDF]
  74
  75 ascii_xml_chars = map(unichr, [0x9, 0xA, 0xD])
  76 ascii_xml_chars += map(unichr, xrange(0x20, 0x7F - 1))
  77 low_xml_chars = list(ascii_xml_chars)
  78 low_xml_chars += map(unichr, xrange(0x84 + 1, 0x86 - 1))
  79 low_xml_chars += map(unichr, xrange(0x9F + 1, 0xFF))
  80 valid_xml_chars = list(low_xml_chars)
  81 valid_xml_chars += map(unichr, xrange(0xFF + 1, 0xD7FF))
  82 valid_xml_chars += map(unichr, xrange(0xE000, 0xFDD0 - 1))
  83 valid_xml_chars += map(unichr, xrange(0xFDDF + 1, 0xFFFD))
  84
  85 def randstr(length, pool = valid_xml_chars, encoding = "utf-8"):
  86     sample = random.sample(pool, min(length, len(pool)))
  87     while True:
  88         s = u''.join(sample)
  89         bytes = len(s.encode(encoding))
  90         if bytes > length:
  91             sample.pop()
  92         elif bytes < length:
  93             sample += random.sample(pool, min(length - bytes, len(pool)))
  94             random.shuffle(sample)
  95         else:
  96             break
  97     return s
  98
  99 def randhostname():
 100     # 1. Each part begins and ends with a letter or number.
 101     # 2. Each part except the last can contain letters, numbers, or hyphens.
 102     # 3. Each part is between 1 and 64 characters, including the trailing dot.
 103     # 4. At least two parts.
 104     # 5. Last part can only contain between 2 and 6 letters.
 105     hostname = 'a' + randstr(61, letters + digits + '-') + '1.' + \
 106                'b' + randstr(61, letters + digits + '-') + '2.' + \
 107                'c' + randstr(5, letters)
 108     return hostname
 109
 110 def randpath(length):
 111     parts = []
 112     for i in range(randint(1, 10)):
 113         parts.append(randstr(randint(1, 30), ascii_xml_chars))
 114     return os.sep.join(parts)[0:length]
 115
 116 def randemail():
 117     return (randstr(100, letters + digits) + "@" + randhostname()).lower()
 118
 119 def randkey(bits = 2048):
 120     key_types = ["ssh-dss", "ssh-rsa"]
 121     key_type = random.sample(key_types, 1)[0]
 122     return ' '.join([key_type,
 123                      base64.b64encode(''.join(randstr(bits / 8).encode("utf-8"))),
 124                      randemail()])
 125
 126 def random_site():
 127     return {
 128         'name': randstr(254),
 129         'abbreviated_name': randstr(50),
 130         'login_base': randstr(20, letters).lower(),
 131         'latitude': int(randfloat(-90.0, 90.0) * 1000) / 1000.0,
 132         'longitude': int(randfloat(-180.0, 180.0) * 1000) / 1000.0,
 133         'max_slices': 10
 134         }
 135
 136 def random_peer():
 137     bits = 2048
 138     return {
 139         'peername': randstr(254),
 140         'peer_url': "https://" + randhostname() + "/",
 141         'key': base64.b64encode(''.join(randstr(bits / 8).encode("utf-8"))),
 142         'cacert': base64.b64encode(''.join(randstr(bits / 8).encode("utf-8")))
 143         }
 144 def random_address_type():
 145     return {
 146         'name': randstr(20),
 147         'description': randstr(254),
 148         }
 149
 150 def random_address():
 151     return {
 152         'line1': randstr(254),
 153         'line2': randstr(254),
 154         'line3': randstr(254),
 155         'city': randstr(254),
 156         'state': randstr(254),
 157         'postalcode': randstr(64),
 158         'country': randstr(128),
 159         }
 160
 161 def random_person():
 162     return {
 163         'first_name': randstr(128),
 164         'last_name': randstr(128),
 165         'email': randemail(),
 166         'bio': randstr(254),
 167         # Accounts are disabled by default
 168         'enabled': False,
 169         'password': randstr(254),
 170         }
 171
 172 def random_key():
 173     return {
 174         'key_type': random.sample(key_types, 1)[0],
 175         'key': randkey()
 176         }
 177
 178 def random_slice():
 179     return {
 180         'name': random.sample(login_bases, 1)[0] + "_" + randstr(11, letters).lower(),
 181         'url': "http://" + randhostname() + "/",
 182         'description': randstr(2048),
 183         }
 184
 185 def random_nodegroup():
 186     return {
 187         'name': randstr(50),
 188         'description': randstr(200),
 189         }
 190
 191 def random_node():
 192    return {
 193        'hostname': randhostname(),
 194        'boot_state': random.sample(boot_states, 1)[0],
 195        'model': randstr(255),
 196        'version': randstr(64),
 197        'session': randstr(20)
 198        }
 199
 200 def random_nodenetwork():
 201     nodenetwork_fields = {
 202         'method': random.sample(methods, 1)[0],
 203         'type': random.sample(types, 1)[0],
 204         'bwlimit': randint(500000, 10000000),
 205         }
 206
 207     if nodenetwork_fields['method'] != 'dhcp':
 208         ip = randint(0, 0xffffffff)
 209         netmask = (0xffffffff << randint(2, 31)) & 0xffffffff
 210         network = ip & netmask
 211         broadcast = ((ip & netmask) | ~netmask) & 0xffffffff
 212         gateway = randint(network + 1, broadcast - 1)
 213         dns1 = randint(0, 0xffffffff)
 214
 215         for field in 'ip', 'netmask', 'network', 'broadcast', 'gateway', 'dns1':
 216             nodenetwork_fields[field] = socket.inet_ntoa(struct.pack('>L', locals()[field]))
 217
 218     return nodenetwork_fields
 219
 220 def random_nodenetwork_setting():
 221     return {
 222         'value': randstr(20)
 223         }
 224
 225 def random_nodenetwork_setting_type():
 226     return {
 227         'name': randstr(20),
 228         'description': randstr(50),
 229         'category': randstr(20),
 230         'min_role_id': random.sample(roles, 1)[0]
 231         }
 232
 233 def random_pcu():
 234     return {
 235         'hostname': randhostname(),
 236         'ip': socket.inet_ntoa(struct.pack('>L', randint(0, 0xffffffff))),
 237         'protocol': randstr(16),
 238         'username': randstr(254),
 239         'password': randstr(254),
 240         'notes': randstr(254),
 241         'model': randstr(32),
 242         }
 243
 244 def random_conf_file():
 245     return {
 246         'enabled': bool(randint()),
 247         'source': randpath(255),
 248         'dest': randpath(255),
 249         'file_permissions': "%#o" % randint(0, 512),
 250         'file_owner': randstr(32, letters + '_' + digits),
 251         'file_group': randstr(32, letters + '_' + digits),
 252         'preinstall_cmd': randpath(100),
 253         'postinstall_cmd': randpath(100),
 254         'error_cmd': randpath(100),
 255         'ignore_cmd_errors': bool(randint()),
 256         'always_update': bool(randint()),
 257         }
 258
 259 def random_attribute_type():
 260     return {
 261         'name': randstr(100),
 262         'description': randstr(254),
 263         'min_role_id': int(random.sample(roles, 1)[0]),
 264         }
 265
 266 def random_pcu_type():
 267     return {
 268         'model': randstr(254),
 269         'name': randstr(254),
 270         }
 271
 272 def random_pcu_protocol_type():
 273     return {
 274         'port': randint(0, 65535),
 275         'protocol': randstr(254),
 276         'supported': randbool()
 277         }
 278
 279 def random_slice_instantiation():
 280     return {
 281         'instantiation': randstr(10)
 282         }
 283 def random_slice_attribute():
 284     return {
 285         'attribute_type_id': random.sample(attribute_types, 1)[0],
 286         'name': randstr(50),
 287         'value': randstr(20)
 288         }
 289
 290 def random_initscript():
 291     return {
 292         'name': randstr(20),
 293         'enabled': randbool(),
 294         'script': randstr(200)
 295         }
 296
 297 def random_role():
 298     return {
 299         'role_id': randint(1000),
 300         'name': randstr(50)
 301         }
 302
 303 def random_message():
 304     return {
 305         'message_id': randstr(10),
 306         'subject': randstr(100),
 307         'template': randstr(254),
 308         }
 309
 310 class api_unit_test(Test):
 311
 312     logfile = Logfile("api-unittest-summary.log")
 313
 314     def call(self,
 315              boot_states = 2,
 316              sites = 2,
 317              peers = 2,
 318              address_types = 3,
 319              addresses = 2,
 320              pcu_types = 2,
 321              pcu_protocol_types = 2,
 322              pcus = 2,
 323              network_methods = 2,
 324              network_types = 2,
 325              nodegroups = 3,
 326              nodes = 4,
 327              conf_files = 3,
 328              nodenetworks = 4,
 329              nodenetwork_setting_types = 2,
 330              nodenetwork_settings = 2,
 331              slice_attribute_types = 2,
 332              slice_instantiations = 2,
 333              slices = 4,
 334              slice_attributes = 4,
 335              initscripts = 4,
 336              roles = 2,
 337              persons = 4,
 338              key_types = 3,
 339              keys = 3,
 340              messages = 2
 341             ):
 342         # Filter out deprecated (Adm) and boot Methods
 343         current_methods = lambda method: not method.startswith('Adm') and \
 344                                          not method.startswith('Slice') and \
 345                                          not method.startswith('Boot') and \
 346                                          not method.startswith('Anon') and \
 347                                          not method.startswith('system')
 348         self.all_methods = set(filter(current_methods, api.system.listMethods()))
 349         self.methods_tested = set()
 350         self.methods_failed = set()
 351
 352         # Begin testing methods
 353         try:
 354             try:
 355                 if hasattr(self, 'BootStates'): self.boot_states = self.BootStates(boot_states)
 356                 if hasattr(self, 'Sites'): self.site_ids = self.Sites(sites)
 357                 if hasattr(self, 'Peers'): self.peer_ids = self.Peers(peers)
 358                 if hasattr(self, 'AddressTypes'): self.address_type_ids = self.AddressTypes(address_types)
 359                 if hasattr(self, 'Addresses'): self.address_ids = self.Addresses(addresses)
 360                 if hasattr(self, 'PCUTypes'): self.pcu_type_ids = self.PCUTypes(pcu_types)
 361                 if hasattr(self, 'PCUProtocolTypes'): self.pcu_protocol_type_ids = self.PCUProtocolTypes(pcu_protocol_types)
 362                 if hasattr(self, 'PCUs'): self.pcu_ids = self.PCUs(pcus)
 363                 if hasattr(self, 'NetworkMethods'): self.network_methods = self.NetworkMethods()
 364                 if hasattr(self, 'NetworkTypes'): self.network_types = self.NetworkTypes()
 365                 if hasattr(self, 'NodeGroups'): self.nodegroup_ids = self.NodeGroups()
 366                 if hasattr(self, 'Nodes'): self.node_ids = self.Nodes(nodes)
 367                 if hasattr(self, 'ConfFiles'): self.conf_file_ids = self.ConfFiles(conf_files)
 368                 if hasattr(self, 'NodeNetworks'): self.nodenetwork_ids = self.NodeNetworks(nodenetworks)
 369                 if hasattr(self, 'NodeNetworkSettingTypes'): self.nodenetwork_setting_type_ids = self.NodeNetworkSettingTypes(nodenetwork_setting_types)
 370                 if hasattr(self, 'NodeNetworkSettings'): self.nodenetwork_setting_ids = self.NodeNetworkSettings(nodenetwork_settings)
 371                 if hasattr(self, 'SliceAttributeTypes'): self.slice_attribute_type_ids = self.SliceAttributeTypes(slice_attribute_types)
 372                 if hasattr(self, 'SliceInstantiations'): self.slice_instantiations = self.SliceInstantiations(slice_instantiations)
 373                 if hasattr(self, 'Slices'): self.slice_ids = self.Slices(slices)
 374                 if hasattr(self, 'SliceAttributes'): self.slice_attribute_ids = self.SliceAttributes(slice_attributes)
 375                 if hasattr(self, 'InitScripts'): self.initscript_ids = self.InitScripts(initscripts)
 376                 if hasattr(self, 'Roles'): self.role_ids = self.Roles(roles)
 377                 if hasattr(self, 'Persons'): self.person_ids = self.Persons(persons)
 378                 if hasattr(self, 'KeyTypes'): self.key_types = self.KeyTypes(key_types)
 379                 if hasattr(self, 'Keys'): self.key_ids = self.Keys(keys)
 380                 if hasattr(self, 'Messages'):  self.message_ids = self.Messages(messages)
 381                 if hasattr(self, 'Sessions'): self.session_ids = self.Sessions()
 382
 383                 # Test misc Get calls
 384                 if hasattr(self, 'GenerateNodeConfFile'): self.GenerateNodeConfFile()
 385                 if hasattr(self, 'GetBootMedium'): self.GetBootMedium()
 386                 if hasattr(self, 'GetEventObjects'): self.event_object_ids = self.GetEventObjects()
 387                 if hasattr(self, 'GetEvents'): self.event_ids = self.GetEvents()
 388                 if hasattr(self, 'GetPeerData'): self.GetPeerData()
 389                 if hasattr(self, 'GetPeerName'): self.GetPeerName()
 390                 if hasattr(self, 'GetPlcRelease'): self.GetPlcRelease()
 391                 if hasattr(self, 'GetSliceKeys'): self.GetSliceKeys()
 392                 if hasattr(self, 'GetSliceTicket'): self.GetSliceTicket()
 393                 if hasattr(self, 'GetSlicesMD5'): self.GetSlicesMD5()
 394                 if hasattr(self, 'GetSlivers'): self.GetSlivers()
 395                 if hasattr(self, 'GetWhitelist'): self.GetWhitelist()
 396
 397                 # Test various administrative methods
 398                 if hasattr(self, 'NotifyPersons'): self.NotifyPersons()
 399                 if hasattr(self, 'NotifySupport'): self.NotifySupport()
 400                 if hasattr(self, 'RebootNode'): self.RebootNode()
 401                 if hasattr(self, 'RefrestPeer'): self.RefreshPeer()
 402                 if hasattr(self, 'ResetPassword'): self.ResetPassword()
 403                 if hasattr(self, 'SetPersonPrimarySite'): self.SetPersonPrimarySite()
 404                 if hasattr(self, 'VerifyPerson'): self.VerifyPerson()
 405
 406
 407
 408
 409             except:
 410                 print_exc()
 411         finally:
 412             try:
 413                 self.cleanup()
 414             finally:
 415                 utils.header("writing api-unittest-summary.log")
 416                 methods_ok = list(self.methods_tested.difference(self.methods_failed))
 417                 methods_failed = list(self.methods_failed)
 418                 methods_untested = list(self.all_methods.difference(self.methods_tested))
 419                 methods_ok.sort()
 420                 methods_failed.sort()
 421                 methods_untested.sort()
 422                 print >> self.logfile, "\n".join([m+": [OK]" for m in  methods_ok])
 423                 print >> self.logfile, "\n".join([m+": [FAILED]" for m in methods_failed])
 424                 print >> self.logfile, "\n".join([m+": [Not Tested]" for m in  methods_untested])
 425
 426     def isequal(self, object_fields, expected_fields, method_name):
 427         try:
 428             for field in expected_fields:
 429                 assert field in object_fields
 430                 assert object_fields[field] == expected_fields[field]
 431         except:
 432             self.methods_failed.update([method_name])
 433             return False
 434         return True
 435
 436     def islistequal(self, list1, list2, method_name):
 437         try: assert set(list1) == set(list2)
 438         except:
 439             self.methods_failed.update([method_name])
 440             return False
 441         return True
 442
 443     def isunique(self, id, id_list, method_name):
 444         try: assert id not in id_list
 445         except:
 446             self.methods_failed.update([method_name])
 447             return False
 448         return True
 449
 450     def isinlist(self, item, item_list, method_name):
 451         try: assert item in item_list
 452         except:
 453             self.methods_failed.update([method_name])
 454             return False
 455         return True
 456     def debug(self, method, method_name=None):
 457         if method_name is None:
 458              method_name = method.name
 459
 460         self.methods_tested.update([method_name])
 461         def wrapper(*args, **kwds):
 462             try:
 463                 return method(*args, **kwds)
 464             except:
 465                 self.methods_failed.update([method_name])
 466                 print >> logfile, "%s%s: %s\n" % (method_name, tuple(args[1:]), traceback.format_exc())
 467                 return None
 468
 469         return wrapper
 470
 471     def cleanup(self):
 472         if hasattr(self, 'session_ids'): self.DeleteSessions()
 473         if hasattr(self, 'message_ids'): self.DeleteMessages()
 474         if hasattr(self, 'key_types'): self.DeleteKeyTypes()
 475         if hasattr(self, 'key_ids'): self.DeleteKeys()
 476         if hasattr(self, 'person_ids'): self.DeletePersons()
 477         if hasattr(self, 'role_ids'): self.DeleteRoles()
 478         if hasattr(self, 'initscript_ids'): self.DeleteInitScripts()
 479         if hasattr(self, 'slice_attribute_ids'): self.DeleteSliceAttributes()
 480         if hasattr(self, 'slice_ids'): self.DeleteSlices()
 481         if hasattr(self, 'slice_instantiations'): self.DeleteSliceInstantiations()
 482         if hasattr(self, 'slice_attribute_type_ids'): self.DeleteSliceAttributeTypes()
 483         if hasattr(self, 'nodenetwork_setting_ids'): self.DeleteNodeNetworkSettings()
 484         if hasattr(self, 'nodenetwork_setting_type_ids'): self.DeleteNodeNetworkSettingTypes()
 485         if hasattr(self, 'nodenetwork_ids'): self.DeleteNodeNetworks()
 486         if hasattr(self, 'conf_file_ids'): self.DeleteConfFiles()
 487         if hasattr(self, 'node_ids'): self.DeleteNodes()
 488         if hasattr(self, 'nodegroup_ids'): self.DeleteNodeGroups()
 489         if hasattr(self, 'network_types'): self.DeleteNetworkTypes()
 490         if hasattr(self, 'network_methods'): self.DeleteNetworkMethods()
 491         if hasattr(self, 'pcu_ids'): self.DeletePCUs()
 492         if hasattr(self, 'pcu_protocol_type_ids'): self.DeletePCUProtocolTypes()
 493         if hasattr(self, 'pcu_type_ids'): self.DeletePCUTypes()
 494         if hasattr(self, 'address_ids'): self.DeleteAddresses()
 495         if hasattr(self, 'address_type_ids'): self.DeleteAddressTypes()
 496         if hasattr(self, 'peer_ids'): self.DeletePeers()
 497         if hasattr(self, 'site_ids'): self.DeleteSites()
 498         if hasattr(self, 'boot_states'): self.DeleteBootStates()
 499
 500
 501     def Sites(self, n=4):
 502         site_ids = []
 503         for i in range(n):
 504             # Add Site
 505             site_fields = random_site()
 506             AddSite = self.debug(api.AddSite)
 507             site_id = AddSite(auth, site_fields)
 508             if site_id is None: continue
 509
 510             # Should return a unique id
 511             self.isunique(site_id, site_ids, 'AddSite - isunique')
 512             site_ids.append(site_id)
 513             GetSites = self.debug(api.GetSites)
 514             sites = GetSites(auth, [site_id])
 515             if sites is None: continue
 516             site = sites[0]
 517             self.isequal(site, site_fields, 'AddSite - isequal')
 518
 519             # Update site
 520             site_fields = random_site()
 521             UpdateSite = self.debug(api.UpdateSite)
 522             result = UpdateSite(auth, site_id, site_fields)
 523
 524             # Check again
 525             sites = GetSites(auth, [site_id])
 526             if sites is None: continue
 527             site = sites[0]
 528             self.isequal(site, site_fields, 'UpdateSite - isequal')
 529
 530         sites = GetSites(auth, site_ids)
 531         if sites is not None:
 532             self.islistequal(site_ids, [site['site_id'] for site in sites], 'GetSites - isequal')
 533
 534         if self.config.verbose:
 535             utils.header("Added sites: %s" % site_ids)
 536
 537         return site_ids
 538
 539
 540     def DeleteSites(self):
 541         # Delete all sites
 542         DeleteSite = self.debug(api.DeleteSite)
 543         for site_id in self.site_ids:
 544             result = DeleteSite(auth, site_id)
 545
 546         # Check if sites are deleted
 547         GetSites = self.debug(api.GetSites)
 548         sites = GetSites(auth, self.site_ids)
 549         self.islistequal(sites, [], 'DeleteSite - check')
 550
 551         if self.config.verbose:
 552             utils.header("Deleted sites: %s" % self.site_ids)
 553
 554         self.site_ids = []
 555
 556     def NetworkMethods(self, n=2):
 557         methods = []
 558         AddNetworkMethod = self.debug(api.AddNetworkMethod)
 559         GetNetworkMethods = self.debug(api.GetNetworkMethods)
 560
 561         for i in range(n):
 562             # Add Network Method
 563             net_method = randstr(10)
 564             AddNetworkMethod(auth, net_method)
 565             if net_method is None: continue
 566
 567             # Should return a unique id
 568             self.isunique(net_method, methods, 'AddNetworkMethod - isunique')
 569             methods.append(net_method)
 570             net_methods = GetNetworkMethods(auth)
 571             if net_methods is None: continue
 572             net_methods = filter(lambda x: x in [net_method], net_methods)
 573             method = net_methods[0]
 574             self.isequal(method, net_method, 'AddNetworkMethod - isequal')
 575
 576
 577         net_methods = GetNetworkMethods(auth)
 578         if net_methods is not None:
 579             net_methods = filter(lambda x: x in methods, net_methods)
 580             self.islistequal(methods, net_methods, 'GetNetworkMethods - isequal')
 581
 582         if self.config.verbose:
 583             utils.header("Added network methods: %s" % methods)
 584
 585         return methods
 586
 587     def DeleteNetworkMethods(self):
 588         DeleteNetworkMethod = self.debug(api.DeleteNetworkMethod)
 589         GetNetworkMethods = self.debug(api.GetNetworkMethods)
 590         for method in self.network_methods:
 591             DeleteNetworkMethod(auth, method)
 592
 593         # check
 594         network_methods = GetNetworkMethods(auth)
 595         network_methods = filter(lambda x: x in self.network_methods, network_methods)
 596         self.islistequal(network_methods, [], 'DeleteNetworkMethods - check')
 597
 598         if self.config.verbose:
 599             utils.header("Deleted network methods: %s" % self.network_methods)
 600         self.network_methods = []
 601
 602     def NetworkTypes(self, n=2):
 603         net_types = []
 604         AddNetworkType = self.debug(api.AddNetworkType)
 605         GetNetworkTypes = self.debug(api.GetNetworkTypes)
 606
 607         for i in range(n):
 608             # Add Network Type
 609             type = randstr(10)
 610             AddNetworkType(auth, type)
 611
 612             # Should return a unique id
 613             self.isunique(type, net_types, 'AddNetworkType - isunique')
 614             net_types.append(type)
 615             types = GetNetworkTypes(auth)
 616             if types is None: continue
 617             types = filter(lambda x: x in [type], types)
 618             if types is None: continue
 619             net_type = types[0]
 620             self.isequal(net_type, type, 'AddNetworkType - isequal')
 621
 622         types = GetNetworkTypes(auth)
 623         if types is not None:
 624             types = filter(lambda x: x in net_types, types)
 625             self.islistequal(types, net_types, 'GetNetworkTypes - isequal')
 626
 627         if self.config.verbose:
 628             utils.header("Added network types: %s" % net_types)
 629
 630         return net_types
 631
 632     def DeleteNetworkTypes(self):
 633         DeleteNetworkType = self.debug(api.DeleteNetworkType)
 634         GetNetworkTypes = self.debug(api.GetNetworkTypes)
 635         for type in self.network_types:
 636             DeleteNetworkType(auth, type)
 637
 638         # check
 639         network_types = GetNetworkTypes(auth)
 640         network_types = filter(lambda x: x in self.network_types, network_types)
 641         self.islistequal(network_types, [], 'DeleteNetworkTypes - check')
 642
 643         if self.config.verbose:
 644             utils.header("Deleted network types: %s" % self.network_types)
 645         self.network_types = []
 646
 647
 648     def NodeGroups(self, n = 4):
 649         nodegroup_ids = []
 650         AddNodeGroup = self.debug(api.AddNodeGroup)
 651         UpdateNodeGroup = self.debug(api.UpdateNodeGroup)
 652         GetNodeGroups = self.debug(api.GetNodeGroups)
 653
 654         for i in range(n):
 655             # Add Nodegroups
 656             nodegroup_fields = random_nodegroup()
 657             nodegroup_id = AddNodeGroup(auth, nodegroup_fields)
 658             if nodegroup_id is None: continue
 659
 660             # Should return a unique id
 661             self.isunique(nodegroup_id, nodegroup_ids, 'AddNodeGroup - isunique')
 662             nodegroup_ids.append(nodegroup_id)
 663             nodegroups = GetNodeGroups(auth, [nodegroup_id])
 664             if nodegroups is None: continue
 665             nodegroup = nodegroups[0]
 666             self.isequal(nodegroup, nodegroup_fields, 'AddNodeGroup - isequal')
 667
 668             # Update NodeGroups
 669             nodegroup_fields = random_nodegroup()
 670             UpdateNodeGroup(auth, nodegroup_id, nodegroup_fields)
 671
 672             # Check again
 673             nodegroups = GetNodeGroups(auth, [nodegroup_id])
 674             if nodegroups is None: continue
 675             nodegroup = nodegroups[0]
 676             self.isequal(nodegroup, nodegroup_fields, 'UpdateNodeGroup - isequal')
 677
 678         nodegroups = GetNodeGroups(auth, nodegroup_ids)
 679         if nodegroups is not None:
 680             self.islistequal(nodegroup_ids, [n['nodegroup_id'] for n in nodegroups], 'GetNodeGroups - isequal')
 681         if self.config.verbose:
 682             utils.header("Added nodegroups: %s" % nodegroup_ids)
 683
 684         return nodegroup_ids
 685
 686     def DeleteNodeGroups(self):
 687         # Delete all NodeGroups
 688         GetNodeGroups = self.debug(api.GetNodeGroups)
 689         DeleteNodeGroup = self.debug(api.DeleteNodeGroup)
 690
 691         for nodegroup_id in self.nodegroup_ids:
 692             result = DeleteNodeGroup(auth, nodegroup_id)
 693
 694         # Check is nodegroups are deleted
 695         nodegroups = GetNodeGroups(auth, self.nodegroup_ids)
 696         self.islistequal(nodegroups, [], 'DeleteNodeGroup - check')
 697
 698         if self.config.verbose:
 699             utils.header("Deleted nodegroups: %s" % self.nodegroup_ids)
 700
 701         self.nodegroup_ids = []
 702
 703     def PCUTypes(self, n=2):
 704         pcu_type_ids = []
 705         AddPCUType = self.debug(api.AddPCUType)
 706         UpdatePCUType = self.debug(api.UpdatePCUType)
 707         GetPCUTypes = self.debug(api.GetPCUTypes)
 708
 709         for i in range(n):
 710             # Add PCUType
 711             pcu_type_fields = random_pcu_type()
 712             pcu_type_id = AddPCUType(auth, pcu_type_fields)
 713             if pcu_type_id is None: continue
 714             # Should return a unique id
 715             self.isunique(pcu_type_id, pcu_type_ids, 'AddPCUType - isunique')
 716             pcu_type_ids.append(pcu_type_id)
 717
 718             # Check pcu type
 719             pcu_types = GetPCUTypes(auth, [pcu_type_id])
 720             if pcu_types is None: continue
 721             pcu_type = pcu_types[0]
 722             self.isequal(pcu_type, pcu_type_fields, 'AddPCUType - isequal')
 723
 724             # Update PCUType
 725             pcu_type_fields = random_pcu_type()
 726             UpdatePCUType(auth, pcu_type_id, pcu_type_fields)
 727
 728             # Check again
 729             pcu_types = GetPCUTypes(auth, [pcu_type_id])
 730             if pcu_types is None: continue
 731             pcu_type = pcu_types[0]
 732             self.isequal(pcu_type, pcu_type_fields, 'UpdatePCUType - isequal')
 733
 734         pcu_types = GetPCUTypes(auth, pcu_type_ids)
 735         if pcu_types is not None:
 736             self.islistequal(pcu_type_ids, [p['pcu_type_id'] for p in pcu_types], 'GetPCUTypes - check')
 737
 738         if self.config.verbose:
 739             utils.header("Added pcu_types: %s " % pcu_type_ids)
 740         return pcu_type_ids
 741
 742     def DeletePCUTypes(self):
 743         GetPCUTypes = self.debug(api.GetPCUTypes)
 744         DeletePCUType = self.debug(api.DeletePCUType)
 745
 746         for pcu_type_id in self.pcu_type_ids:
 747             DeletePCUType(auth, pcu_type_id)
 748
 749         pcu_types = GetPCUTypes(auth, self.pcu_type_ids)
 750         self.islistequal(pcu_types, [], 'DeletePCUType - check')
 751
 752     def PCUProtocolTypes(self, n=2):
 753         protocol_type_ids = []
 754         AddPCUProtocolType = self.debug(api.AddPCUProtocolType)
 755         UpdatePCUProtocolType = self.debug(api.UpdatePCUProtocolType)
 756         GetPCUProtocolTypes = self.debug(api.GetPCUProtocolTypes)
 757
 758         for i in range(n):
 759             # Add PCUProtocolType
 760             protocol_type_fields = random_pcu_protocol_type()
 761             pcu_type_id = random.sample(self.pcu_type_ids, 1)[0]
 762             protocol_type_id = AddPCUProtocolType(auth, pcu_type_id, protocol_type_fields)
 763             if protocol_type_id is None: continue
 764
 765             # Should return a unique id
 766             self.isunique(protocol_type_id, protocol_type_ids, 'AddPCUProtocolType - isunique')
 767             protocol_type_ids.append(protocol_type_id)
 768
 769             # Check protocol type
 770             protocol_types = GetPCUProtocolTypes(auth, [protocol_type_id])
 771             if protocol_types is None: continue
 772             protocol_type = protocol_types[0]
 773             self.isequal(protocol_type, protocol_type_fields, 'AddPCUProtocolType - isequal')
 774
 775             # Update protocol type
 776             protocol_type_fields = random_pcu_protocol_type()
 777             UpdatePCUProtocolType(auth, protocol_type_id, protocol_type_fields)
 778
 779             # Check again
 780             protocol_types = GetPCUProtocolTypes(auth, [protocol_type_id])
 781             if protocol_types is None: continue
 782             protocol_type = protocol_types[0]
 783             self.isequal(protocol_type, protocol_type_fields, 'UpdatePCUProtocolType - isequal')
 784
 785         protocol_types = GetPCUProtocolTypes(auth, protocol_type_ids)
 786         if protocol_types is not None:
 787             pt_ids = [p['pcu_protocol_type_id'] for p in protocol_types]
 788             self.islistequal(protocol_type_ids, pt_ids, 'GetPCUProtocolTypes - isequal')
 789
 790         if self.config.verbose:
 791             utils.header('Added pcu_protocol_types: %s' % protocol_type_ids)
 792
 793         return protocol_type_ids
 794
 795     def DeletePCUProtocolTypes(self):
 796         GetPCUProtocolTypes = self.debug(api.GetPCUProtocolTypes)
 797         DeletePCUProtocolType = self.debug(api.DeletePCUProtocolType)
 798
 799         for protocol_type_id in self.pcu_protocol_type_ids:
 800             DeletePCUProtocolType(auth, protocol_type_id)
 801
 802         # check
 803         protocol_types = GetPCUProtocolTypes(auth, self.pcu_protocol_type_ids)
 804         self.islistequal(protocol_types, [], 'DeletePCUProtocolType - check')
 805
 806         if self.config.verbose:
 807             utils.header("Deleted pcu_protocol_types: %s" % self.pcu_protocol_type_ids)
 808         self.pcu_protocol_type_ids = []
 809
 810     def PCUs(self, n = 4):
 811         pcu_ids = []
 812         AddPCU = self.debug(api.AddPCU)
 813         UpdatePCU = self.debug(api.UpdatePCU)
 814         GetPCUs = self.debug(api.GetPCUs)
 815
 816         for site_id in self.site_ids:
 817             # Add PCU
 818             pcu_fields = random_pcu()
 819             pcu_id = AddPCU(auth, site_id, pcu_fields)
 820             if pcu_id is None: continue
 821
 822             # Should return a unique id
 823             self.isunique(pcu_id, pcu_ids, 'AddPCU - isunique')
 824             pcu_ids.append(pcu_id)
 825
 826             # check PCU
 827             pcus = GetPCUs(auth, [pcu_id])
 828             if pcus is None: continue
 829             pcu = pcus[0]
 830             self.isequal(pcu, pcu_fields, 'AddPCU - isequal')
 831
 832             # Update PCU
 833             pcu_fields = random_pcu()
 834             UpdatePCU(auth, pcu_id, pcu_fields)
 835
 836             # Check again
 837             pcus = GetPCUs(auth, [pcu_id])
 838             if pcus is None: continue
 839             pcu = pcus[0]
 840             self.isequal(pcu, pcu_fields, 'UpdatePCU - isequal')
 841
 842         pcus = GetPCUs(auth, pcu_ids)
 843         if pcus is not None:
 844             self.islistequal(pcu_ids, [p['pcu_id'] for p in pcus], 'GetPCUs - isequal')
 845
 846         if self.config.verbose:
 847             utils.header('Added pcus: %s' % pcu_ids)
 848
 849         return pcu_ids
 850
 851     def DeletePCUs(self):
 852         GetPCUs = self.debug(api.GetPCUs)
 853         DeletePCU = self.debug(api.DeletePCU)
 854
 855         for pcu_id in self.pcu_ids:
 856             DeletePCU(auth, pcu_id)
 857
 858         # check
 859         pcus = GetPCUs(auth, self.pcu_ids)
 860         self.islistequal(pcus, [], 'DeletePCU - check')
 861
 862         if self.config.verbose:
 863             utils.header("Deleted pcus: %s " % self.pcu_ids)
 864         self.pcu_ids = []
 865
 866     def Nodes(self, n=4):
 867         node_ids = []
 868         AddNode = self.debug(api.AddNode)
 869         GetNodes = self.debug(api.GetNodes)
 870         UpdateNode = self.debug(api.UpdateNode)
 871         for i in range(n):
 872             # Add Node
 873             node_fields = random_node()
 874             site_id = random.sample(self.site_ids, 1)[0]
 875             node_id = AddNode(auth, site_id, node_fields)
 876             if node_id is None: continue
 877
 878             # Should return a unique id
 879             self.isunique(node_id, node_ids, 'AddNode - isunique')
 880             node_ids.append(node_id)
 881
 882             # Check nodes
 883             nodes = GetNodes(auth, [node_id])
 884             if nodes is None: continue
 885             node = nodes[0]
 886             self.isequal(node, node_fields, 'AddNode - isequal')
 887
 888             # Update node
 889             node_fields = random_node()
 890             result = UpdateNode(auth, node_id, node_fields)
 891
 892             # Check again
 893             nodes = GetNodes(auth, [node_id])
 894             if nodes is None: continue
 895             node = nodes[0]
 896             self.isequal(node, node_fields, 'UpdateNode - isequal')
 897
 898             # Add node to nodegroup
 899             nodegroup_id = random.sample(self.nodegroup_ids, 1)[0]
 900             AddNodeToNodeGroup = self.debug(api.AddNodeToNodeGroup)
 901             AddNodeToNodeGroup(auth, node_id, nodegroup_id)
 902
 903             # Add node to PCU
 904             sites = api.GetSites(auth, [node['site_id']], ['pcu_ids'])
 905             if not sites: continue
 906             site = sites[0]
 907             pcu_id = random.sample(site['pcu_ids'], 1)[0]
 908             port = random.sample(range(65535), 1)[0]
 909             AddNodeToPCU = self.debug(api.AddNodeToPCU)
 910             AddNodeToPCU(auth, node_id, pcu_id, port)
 911
 912             # check nodegroup, pcu
 913             nodes = GetNodes(auth, [node_id], ['nodegroup_ids', 'pcu_ids'])
 914             if nodes is None or not nodes: continue
 915             node = nodes[0]
 916             self.islistequal([nodegroup_id], node['nodegroup_ids'], 'AddNodeToNodeGroup - check')
 917             self.islistequal([pcu_id], node['pcu_ids'], 'AddNodeToPCU - check')
 918
 919         nodes = GetNodes(auth, node_ids)
 920         if nodes is not None:
 921             self.islistequal(node_ids, [node['node_id'] for node in nodes], 'GetNodes - isequal')
 922
 923         if self.config.verbose:
 924             utils.header("Added nodes: %s" % node_ids)
 925
 926         return node_ids
 927
 928     def DeleteNodes(self):
 929
 930         # Delete attributes manually for first node
 931         GetNodes = self.debug(api.GetNodes)
 932         nodes = GetNodes(auth, self.node_ids)
 933         if nodes is None or not nodes: return 0
 934         node = nodes[0]
 935
 936         if node['nodegroup_ids']:
 937             # Delete NodeGroup
 938             nodegroup_id = random.sample(node['nodegroup_ids'], 1)[0]
 939             DeleteNodeFromNodeGroup = self.debug(api.DeleteNodeFromNodeGroup)
 940             DeleteNodeFromNodeGroup(auth, node['node_id'], nodegroup_id)
 941
 942         if node['pcu_ids']:
 943             # Delete PCU
 944             pcu_id = random.sample(node['pcu_ids'], 1)[0]
 945             DeleteNodeFromPCU = self.debug(api.DeleteNodeFromPCU)
 946             DeleteNodeFromPCU(auth, node['node_id'], pcu_id)
 947
 948         # check nodegroup, pcu
 949         nodes = GetNodes(auth, [node['node_id']])
 950         if nodes is None or not nodes: return 0
 951         self.islistequal([], node['nodegroup_ids'], 'DeleteNodeGromNodeGroup - check')
 952         self.islistequal([], node['pcu_ids'], 'DeleteNodeFromPCU - check')
 953
 954         # Delete rest of nodes
 955         DeleteNode = self.debug(api.DeleteNode)
 956         for node_id in self.node_ids:
 957             result = DeleteNode(auth, node_id)
 958
 959         # Check if nodes are deleted
 960         GetNodes = self.debug(api.GetNodes)
 961         nodes = GetNodes(auth, self.node_ids)
 962         self.islistequal(nodes, [], 'DeleteNode Check')
 963
 964         if self.config.verbose:
 965             utils.header("Deleted nodes: %s" % self.node_ids)
 966
 967         self.node_ids = []
 968
 969     def AddressTypes(self, n = 3):
 970         address_type_ids = []
 971         for i in range(n):
 972             address_type_fields = random_address_type()
 973             AddAddressType = self.debug(api.AddAddressType)
 974             address_type_id = AddAddressType(auth, address_type_fields)
 975             if address_type_id is None: continue
 976
 977             # Should return a unique address_type_id
 978             self.isunique(address_type_id, address_type_ids, 'AddAddressType - isunique')
 979             address_type_ids.append(address_type_id)
 980
 981             # Check address type
 982             GetAddressTypes = self.debug(api.GetAddressTypes)
 983             address_types = GetAddressTypes(auth, [address_type_id])
 984             if address_types is None: continue
 985             address_type = address_types[0]
 986             self.isequal(address_type, address_type_fields, 'AddAddressType - isequal')
 987
 988             # Update address type
 989             address_type_fields = random_address_type()
 990             UpdateAddressType = self.debug(api.UpdateAddressType)
 991             result = UpdateAddressType(auth, address_type_id, address_type_fields)
 992             if result is None: continue
 993
 994             # Check address type again
 995             address_types = GetAddressTypes(auth, [address_type_id])
 996             if address_types is None: continue
 997             address_type = address_types[0]
 998             self.isequal(address_type, address_type_fields, 'UpdateAddressType - isequal')
 999
1000         # Check get all address types
1001         address_types = GetAddressTypes(auth, address_type_ids)
1002         if address_types is not None:
1003             self.islistequal(address_type_ids, [address_type['address_type_id'] for address_type in address_types], 'GetAddressTypes - isequal')
1004
1005         if self.config.verbose:
1006             utils.header("Added address types: %s " % address_type_ids)
1007
1008         return address_type_ids
1009
1010     def DeleteAddressTypes(self):
1011
1012         DeleteAddressType = self.debug(api.DeleteAddressType)
1013         for address_type_id in self.address_type_ids:
1014             DeleteAddressType(auth, address_type_id)
1015
1016         GetAddressTypes = self.debug(api.GetAddressTypes)
1017         address_types = GetAddressTypes(auth, self.address_type_ids)
1018         self.islistequal(address_types, [], 'DeleteAddressType - check')
1019
1020         if self.config.verbose:
1021             utils.header("Deleted address types: %s" % self.address_type_ids)
1022
1023         self.address_type_ids = []
1024
1025     def Addresses(self, n = 3):
1026         address_ids = []
1027         AddSiteAddress = self.debug(api.AddSiteAddress)
1028         GetAddresses = self.debug(api.GetAddresses)
1029         UpdateAddress = self.debug(api.UpdateAddress)
1030         AddAddressTypeToAddress = self.debug(api.AddAddressTypeToAddress)
1031         for i in range(n):
1032             address_fields = random_address()
1033             site_id = random.sample(self.site_ids, 1)[0]
1034             address_id = AddSiteAddress(auth, site_id, address_fields)
1035             if address_id is None: continue
1036
1037             # Should return a unique address_id
1038             self.isunique(address_id, address_ids, 'AddSiteAddress - isunique')
1039             address_ids.append(address_id)
1040
1041             # Check address
1042             addresses = GetAddresses(auth, [address_id])
1043             if addresses is None: continue
1044             address = addresses[0]
1045             self.isequal(address, address_fields, 'AddSiteAddress - isequal')
1046
1047             # Update address
1048             address_fields = random_address()
1049             result = UpdateAddress(auth, address_id, address_fields)
1050
1051             # Check again
1052             addresses = GetAddresses(auth, [address_id])
1053             if addresses is None: continue
1054             address = addresses[0]
1055             self.isequal(address, address_fields, 'UpdateAddress - isequal')
1056
1057             # Add Address Type
1058             address_type_id = random.sample(self.address_type_ids, 1)[0]
1059             AddAddressTypeToAddress(auth, address_type_id, address_id)
1060
1061             # check adress type
1062             addresses = GetAddresses(auth, [address_id], ['address_type_ids'])
1063             if addresses is None or not addresses: continue
1064             address = addresses[0]
1065             self.islistequal([address_type_id], address['address_type_ids'], 'AddAddressTypeToAddress - check')
1066
1067         addresses = GetAddresses(auth, address_ids)
1068         if addresses is not None:
1069             self.islistequal(address_ids, [ad['address_id'] for ad in addresses], 'GetAddresses - isequal')
1070
1071         if self.config.verbose:
1072             utils.header("Added addresses: %s" % address_ids)
1073
1074         return address_ids
1075
1076     def DeleteAddresses(self):
1077
1078         DeleteAddress = self.debug(api.DeleteAddress)
1079         DeleteAddressTypeFromAddress = self.debug(api.DeleteAddressTypeFromAddress)
1080         GetAddresses = self.debug(api.GetAddresses)
1081
1082         # Delete attributes mananually first
1083         addresses = GetAddresses(auth, self.address_ids, ['address_id', 'address_type_ids'])
1084         if addresses is None or not addresses: return 0
1085         address = addresses[0]
1086
1087         if address['address_type_ids']:
1088             address_type_id = random.sample(address['address_type_ids'], 1)[0]
1089             DeleteAddressTypeFromAddress(auth, address_type_id, address['address_id'])
1090
1091         # check address_type_ids
1092         addresses = GetAddresses(auth, [address['address_id']], ['address_type_ids'])
1093         if addresses is None or not addresses: return 0
1094         address = addresses[0]
1095         self.islistequal([], address['address_type_ids'], 'DeleteAddressTypeFromAddress - check')
1096
1097         # Delete site addresses
1098         for address_id in self.address_ids:
1099             result = DeleteAddress(auth, address_id)
1100
1101         # Check
1102         addresses = GetAddresses(auth, self.address_ids)
1103         self.islistequal(addresses, [], 'DeleteAddress - check')
1104         if self.config.verbose:
1105             utils.header("Deleted addresses: %s" % self.address_ids)
1106
1107         self.address_ids = []
1108
1109     def SliceAttributeTypes(self, n = 2):
1110         attribute_type_ids = []
1111         AddSliceAttributeType = self.debug(api.AddSliceAttributeType)
1112         GetSliceAttributeTypes = self.debug(api.GetSliceAttributeTypes)
1113         UpdateSliceAttributeType = self.debug(api.UpdateSliceAttributeType)
1114
1115         for i in range(n):
1116             attribute_type_fields = random_attribute_type()
1117             attribute_type_id = AddSliceAttributeType(auth, attribute_type_fields)
1118             if attribute_type_id is None: continue
1119
1120             # Should return a unique slice_attribute_type_id
1121             self.isunique(attribute_type_id, attribute_type_ids, 'AddSliceAttributeType - isunique')
1122             attribute_type_ids.append(attribute_type_id)
1123
1124             # Check slice_attribute_type
1125             attribute_types = GetSliceAttributeTypes(auth, [attribute_type_id])
1126             if attribute_types is None: continue
1127             attribute_type = attribute_types[0]
1128             self.isequal(attribute_type, attribute_type_fields, 'AddSliceAttributeType - isequal')
1129
1130             # Update slice_attribute_type
1131             attribute_type_fields = random_attribute_type()
1132             result = UpdateSliceAttributeType(auth, attribute_type_id, attribute_type_fields)
1133
1134             # Check again
1135             attribute_types = GetSliceAttributeTypes(auth, [attribute_type_id])
1136             if attribute_types is None: continue
1137             attribute_type = attribute_types[0]
1138             self.isequal(attribute_type, attribute_type_fields, 'UpdateSliceAttributeType - isequal')
1139
1140         attribute_types = GetSliceAttributeTypes(auth, attribute_type_ids)
1141         if attribute_types is not None:
1142             at_ids = [at['attribute_type_id'] for at in attribute_types]
1143             self.islistequal(attribute_type_ids, at_ids, 'GetSliceAttributeTypes - isequal')
1144
1145         if self.config.verbose:
1146             utils.header("Added slice_attribute_types: %s" % attribute_type_ids)
1147
1148         return attribute_type_ids
1149
1150     def DeleteSliceAttributeTypes(self):
1151         DeleteSliceAttributeType = self.debug(api.DeleteSliceAttributeType)
1152         GetSliceAttributeTypes = self.debug(api.GetSliceAttributeTypes)
1153
1154         # Delete slice_attribute_type
1155         for slice_attribute_type_id in self.slice_attribute_type_ids:
1156             result = DeleteSliceAttributeType(auth, slice_attribute_type_id)
1157
1158         # Check
1159         slice_attribute_types = GetSliceAttributeTypes(auth, self.slice_attribute_type_ids)
1160         self.islistequal(slice_attribute_types, [], 'DeleteSliceAttributeTypes - check')
1161         if self.config.verbose:
1162             utils.header("Deleted slice_attributes: %s" % self.slice_attribute_type_ids)
1163
1164         self.slice_attribute_type_ids = []
1165
1166     def SliceInstantiations(self, n = 2):
1167         insts = []
1168         AddSliceInstantiation= self.debug(api.AddSliceInstantiation)
1169         GetSliceInstantiations = self.debug(api.GetSliceInstantiations)
1170
1171         for i in range(n):
1172             inst = randstr(10)
1173             result = AddSliceInstantiation(auth, inst)
1174             if result is None: continue
1175             insts.append(inst)
1176
1177             # Check slice instantiaton
1178             instantiations = GetSliceInstantiations(auth)
1179             if instantiations is None: continue
1180             instantiations = filter(lambda x: x in [inst], instantiations)
1181             instantiation = instantiations[0]
1182             self.isequal(instantiation, inst, 'AddSliceInstantiation - isequal')
1183
1184
1185         instantiations = GetSliceInstantiations(auth)
1186         if instantiations is not None:
1187             instantiations = filter(lambda x: x in insts, instantiations)
1188             self.islistequal(insts, instantiations, 'GetSliceInstantiations - isequal')
1189
1190         if self.config.verbose:
1191             utils.header("Added slice instantiations: %s" % insts)
1192
1193         return insts
1194
1195     def DeleteSliceInstantiations(self):
1196         DeleteSliceInstantiation = self.debug(api.DeleteSliceInstantiation)
1197         GetSliceInstantiations = self.debug(api.GetSliceInstantiations)
1198         # Delete slice instantiation
1199         for instantiation  in self.slice_instantiations:
1200             result = DeleteSliceInstantiation(auth, instantiation)
1201
1202         # Check
1203         instantiations = GetSliceInstantiations(auth)
1204         instantiations = filter(lambda x: x in self.slice_instantiations, instantiations)
1205         self.islistequal(instantiations, [], 'DeleteSliceInstantiation - check')
1206         if self.config.verbose:
1207             utils.header("Deleted slice instantiations: %s" % self.slice_instantiations)
1208
1209         self.slice_instantiations = []
1210
1211     def Slices(self, n = 3):
1212         slice_ids = []
1213         AddSlice = self.debug(api.AddSlice)
1214         GetSlices = self.debug(api.GetSlices)
1215         UpdateSlice = self.debug(api.UpdateSlice)
1216         AddSliceToNodes = self.debug(api.AddSliceToNodes)
1217         for i in range(n):
1218             # Add Site
1219             slice_fields = random_slice()
1220             slice_id = AddSlice(auth, slice_fields)
1221             if slice_id is None: continue
1222
1223             # Should return a unique id
1224             self.isunique(slice_id, slice_ids, 'AddSlicel - isunique')
1225             slice_ids.append(slice_id)
1226             slices = GetSlices(auth, [slice_id])
1227             if slices is None: continue
1228             slice = slices[0]
1229             self.isequal(slice, slice_fields, 'AddSlice - isequal')
1230
1231             # Update slice
1232             slice_fields = random_slice()
1233             result = UpdateSlice(auth, slice_id, slice_fields)
1234
1235             # Check again
1236             slices = GetSlices(auth, [slice_id])
1237             if slices is None: continue
1238             slice = slices[0]
1239             self.isequal(slice, slice_fields, 'UpdateSlice - isequal')
1240
1241             # Add node
1242             node_id = random.sample(self.node_ids, 1)[0]
1243             AddSliceToNodes(auth, slice_id, [node_id])
1244
1245             # check node
1246             slices = GetSlices(auth, [slice_id], ['node_ids'])
1247             if slices is None or not slices: continue
1248             slice = slices[0]
1249             self.islistequal([node_id], slice['node_ids'], 'AddSliceToNode - check')
1250
1251         slices = GetSlices(auth, slice_ids)
1252         if slices is not None:
1253             self.islistequal(slice_ids, [slice['slice_id'] for slice in slices], 'GetSlices - isequal')
1254
1255         if self.config.verbose:
1256             utils.header("Added slices: %s" % slice_ids)
1257
1258         return slice_ids
1259
1260     def DeleteSlices(self):
1261
1262         GetSlices = self.debug(api.GetSlices)
1263         DeleteSlice = self.debug(api.DeleteSlice)
1264         DeleteSliceFromNodes = self.debug(api.DeleteSliceFromNodes)
1265
1266         # manually delete attributes for first slice
1267         slices = GetSlices(auth, self.slice_ids, ['slice_id', 'node_ids'])
1268         if slices is None or not slices: return 0
1269         slice = slices[0]
1270
1271         if slice['node_ids']:
1272             # Delete node from slice
1273             node_id = random.sample(slice['node_ids'], 1)[0]
1274             DeleteSliceFromNodes(slice['slice_id'], [node_id])
1275
1276         # Check node_ids
1277         slices = GetSlices(auth, [slice['slice_id']], ['node_ids'])
1278         if slices is None or not slices: return 0
1279         slice = slices[0]
1280         self.islistequal([], slice['node_ids'], 'DeleteSliceFromNode - check')
1281
1282         # Have DeleteSlice automatically delete attriubtes for the rest
1283         for slice_id in self.slice_ids:
1284             # Delete account
1285             DeleteSlice(auth, slice_id)
1286
1287         # Check if slices are deleted
1288         GetSlices = self.debug(api.GetSlices)
1289         slices = GetSlices(auth, self.slice_ids)
1290         self.islistequal(slices, [], 'DeleteSlice - check')
1291
1292         if self.config.verbose:
1293             utils.header("Deleted slices: %s" % self.slice_ids)
1294
1295         self.slice_ids = []
1296
1297     def SliceAttributes(self, n = 4):
1298         attribute_ids = []
1299         AddSliceAttribute = self.debug(api.AddSliceAttribute)
1300         GetSliceAttributes = self.debug(api.GetSliceAttributes)
1301         UpdateSliceAttribute = self.debug(api.UpdateSliceAttribute)
1302
1303         for i in range(n):
1304             # Add slice attribute
1305             attribute_fields = random_slice_attribute()
1306             slice_id = random.sample(self.slice_ids, 1)[0]
1307             type = attribute_fields['attribute_type_id']
1308             value = attribute_fields['value']
1309             attribute_id = AddSliceAttribute(auth, slice_id, type, value)
1310             if attribute_id is None: continue
1311
1312             # Should return a unique id
1313             self.isunique(attribute_id, attribute_ids, 'AddSliceAttribute - isunique')
1314             attribute_ids.append(attribute_id)
1315
1316             # Check attribute
1317             attributes = GetSliceAttributes(auth, [attribute_id])
1318             if attributes is None: continue
1319             attribute = attributes[0]
1320             self.isequal(attribute, attribute_fields, 'AddSliceAttribute - isequal')
1321
1322             # Update attribute
1323             attribute_fields = random_slice_attribute()
1324             type = attribute_fields['attribute_type_id']
1325             value = attribute_fields['value']
1326             result = UpdateSliceAttribute(auth, attribute_id, value)
1327
1328             # Check again
1329             attributes = GetSliceAttributes(auth, [attribute_id])
1330             if attributes is None: continue
1331             attribute = attributes[0]
1332             self.isequal(attribute, attribute_fields, 'UpdateSliceAttribute - isequal')
1333
1334         attributes = GetSliceAttributes(auth, attribute_ids)
1335         if attributes is not None:
1336             attr_ids = [a['slice_attribute_id'] for a in attributes]
1337             self.islistequal(attribute_ids, attr_ids, 'GetSliceAttributes - isequal')
1338         if self.config.verbose:
1339             utils.header("Added slice attributes: %s" % attribute_ids)
1340
1341         return attribute_ids
1342
1343     def DeleteSliceAttributes(self):
1344         DeleteSliceAttribute = self.debug(api.DeleteSliceAttribute)
1345         GetSliceAttributes = self.debug(api.GetSliceAttributes)
1346
1347         for attribute_id in self.slice_attribute_ids:
1348             DeleteSliceAttribute(auth, attribute_id)
1349
1350         attributes = GetSliceAttributes(auth, self.slice_attribute_ids)
1351         self.islistequal(attributes, [], 'DeleteSliceAttribute - check')
1352
1353         if self.config.verbose:
1354             utils.header("Deleted slice attributes: %s" % self.slice_attribute_ids)
1355
1356         self.slice_attribute_ids = []
1357
1358     def InitScripts(self, n = 2):
1359         initscript_ids = []
1360         AddInitScript = self.debug(api.AddInitScript)
1361         GetInitScripts = self.debug(api.GetInitScripts)
1362         UpdateInitScript = self.debug(api.UpdateInitScript)
1363         for i in range(n):
1364             # Add Peer
1365             initscript_fields = random_initscript()
1366             initscript_id = AddInitScript(auth, initscript_fields)
1367
1368             # Should return a unique id
1369             self.isunique(initscript_id, initscript_ids, 'AddInitScript - isunique')
1370             initscript_ids.append(initscript_id)
1371             initscripts = GetInitScripts(auth, [initscript_id])
1372             if initscripts is None: continue
1373             initscript = initscripts[0]
1374             self.isequal(initscript, initscript_fields, 'AddInitScript - isequal')
1375
1376             # Update Peer
1377             initscript_fields = random_initscript()
1378             result = UpdateInitScript(auth, initscript_id, initscript_fields)
1379
1380             # Check again
1381             initscripts = GetInitScripts(auth, [initscript_id])
1382             if initscripts is None: continue
1383             initscript = initscripts[0]
1384             self.isequal(initscript, initscript_fields, 'UpdateInitScript - isequal')
1385
1386         initscripts = GetInitScripts(auth, initscript_ids)
1387         if initscripts is not None:
1388             self.islistequal(initscript_ids, [i['initscript_id'] for i in initscripts], 'GetInitScripts -isequal')
1389
1390         if self.config.verbose:
1391             utils.header("Added initscripts: %s" % initscript_ids)
1392
1393         return initscript_ids
1394
1395     def DeleteInitScripts(self):
1396         # Delete all initscripts
1397         DeleteInitScript = self.debug(api.DeleteInitScript)
1398         GetInitScripts = self.debug(api.GetInitScripts)
1399         for initscript_id in self.initscript_ids:
1400             result = DeleteInitScript(auth, initscript_id)
1401
1402         # Check if peers are deleted
1403         initscripts = GetInitScripts(auth, self.initscript_ids)
1404         self.islistequal(initscripts, [], 'DeletInitScript - check')
1405
1406         if self.config.verbose:
1407             utils.header("Deleted initscripts: %s" % self.initscript_ids)
1408         self.initscript_ids =[]
1409
1410     def Roles(self, n = 2):
1411         role_ids = []
1412         AddRole = self.debug(api.AddRole)
1413         GetRoles = self.debug(api.GetRoles)
1414         for i in range(n):
1415             # Add Role
1416             role_fields = random_role()
1417             role_id = role_fields['role_id']
1418             name = role_fields['name']
1419             AddRole(auth, role_id, name)
1420
1421             # Should return a unique id
1422             self.isunique(role_id, role_ids, 'AddRole - isunique')
1423             role_ids.append(role_id)
1424             roles = GetRoles(auth)
1425             if roles is None: continue
1426             roles = filter(lambda x: x['role_id'] in [role_id], roles)
1427             role = roles[0]
1428             self.isequal(role, role_fields, 'AddRole - isequal')
1429
1430         roles = GetRoles(auth)
1431         if roles is not None:
1432             roles = filter(lambda x: x['role_id'] in role_ids, roles)
1433             self.islistequal(role_ids, [r['role_id'] for r in roles], 'GetRoles - isequal')
1434
1435         if self.config.verbose:
1436             utils.header("Added roles: %s" % role_ids)
1437
1438         return role_ids
1439
1440     def DeleteRoles(self):
1441         # Delete all roles
1442         DeleteRole = self.debug(api.DeleteRole)
1443         GetRoles = self.debug(api.GetRoles)
1444         for role_id in self.role_ids:
1445             result = DeleteRole(auth, role_id)
1446
1447         # Check if peers are deleted
1448         roles = GetRoles(auth)
1449         roles = filter(lambda x: x['role_id'] in self.role_ids, roles)
1450         self.islistequal(roles, [], 'DeleteRole - check' % self.role_ids)
1451
1452         if self.config.verbose:
1453             utils.header("Deleted roles: %s" % self.role_ids)
1454         self.role_ids =[]
1455
1456     def Persons(self, n = 3):
1457
1458         person_ids = []
1459         for i in range(n):
1460
1461             # Add account
1462             person_fields = random_person()
1463             AddPerson = self.debug(api.AddPerson)
1464             person_id = AddPerson(auth, person_fields)
1465             if person_id is None: continue
1466
1467             # Should return a unique person_id
1468             self.isunique(person_id, person_ids, 'AddPerson - isunique')
1469             person_ids.append(person_id)
1470             GetPersons = self.debug(api.GetPersons)
1471             persons = GetPersons(auth, [person_id])
1472             if persons is None: continue
1473             person = persons[0]
1474             self.isequal(person, person_fields, 'AddPerson - isequal')
1475
1476             # Update account
1477             person_fields = random_person()
1478             person_fields['enabled'] = True
1479             UpdatePerson = self.debug(api.UpdatePerson)
1480             result = UpdatePerson(auth, person_id, person_fields)
1481
1482             # Add random role
1483             AddRoleToPerson = self.debug(api.AddRoleToPerson)
1484             role = random.sample(roles, 1)[0]
1485             result = AddRoleToPerson(auth, role, person_id)
1486
1487             # Add key to person
1488             key = random_key()
1489             key_id = AddPersonKey = self.debug(api.AddPersonKey)
1490             AddPersonKey(auth, person_id, key)
1491
1492             # Add person to site
1493             site_id = random.sample(self.site_ids, 1)[0]
1494             AddPersonToSite = self.debug(api.AddPersonToSite)
1495             AddPersonToSite(auth, person_id, site_id)
1496
1497             # Add person to slice
1498             slice_id = random.sample(self.slice_ids, 1)[0]
1499             AddPersonToSlice = self.debug(api.AddPersonToSlice)
1500             AddPersonToSlice(auth, person_id, slice_id)
1501
1502             # check role, key, site, slice
1503             persons = GetPersons(auth, [person_id], ['roles', 'key_ids', 'site_ids', 'slice_ids'])
1504             if persons is None or not persons: continue
1505             person = persons[0]
1506             self.islistequal([role], person['roles'], 'AddRoleToPerson - check')
1507             self.islistequal([key_id], person['key_ids'], 'AddPersonKey - check')
1508             self.islistequal([site_id], person['site_ids'], 'AddPersonToSite - check')
1509             self.islistequal([slice_id], person['slice_ids'], 'AddPersonToSlice - check')
1510
1511         persons = GetPersons(auth, person_ids)
1512         if persons is not None:
1513             self.islistequal(person_ids, [p['person_id'] for p in persons], 'GetPersons - isequal')
1514
1515         if self.config.verbose:
1516             utils.header("Added users: %s" % person_ids)
1517
1518         return person_ids
1519
1520     def DeletePersons(self):
1521
1522         # Delete attributes manually for first person
1523         GetPersons = self.debug(api.GetPersons)
1524         persons = GetPersons(auth, self.person_ids, ['person_id' , 'key_ids', 'site_ids', 'slice_ids', 'roles'])
1525         if persons is None or not persons: return 0
1526         person = persons[0]
1527
1528         if person['roles']:
1529             # Delete role
1530             role = random.sample(person['roles'], 1)[0]
1531             DeleteRoleFromPerson = self.debug(api.DeleteRoleFromPerson)
1532             DeleteRoleFromPerson(auth, role, person['person_id'])
1533
1534         if person['key_ids']:
1535             # Delete key
1536             key_id = random.sample(person['key_ids'], 1)[0]
1537             DeleteKey = self.debug(api.DeleteKey)
1538             DeleteKey(auth, key_id)
1539
1540         if person['site_ids']:
1541             # Remove person from site
1542             site_id = random.sample(person['site_ids'], 1)[0]
1543             DeletePersonFromSite = self.debug(api.DeletePersonFromSite)
1544             DeletePersonFromSite(auth, person['person_id'], site_id)
1545
1546         if person['slice_ids']:
1547             # Remove person from slice
1548             slice_id = random.sample(person['slice_ids'], 1)[0]
1549             DeletePersonFromSlice = self.debug(api.DeletePersonFromSlice)
1550             DeletePersonFromSlice(auth, person['person_id'], slice_id)
1551
1552         # check role, key, site, slice
1553         persons = GetPersons(auth, [person['person_id']], ['roles', 'key_ids', 'site_ids', 'slice_ids'])
1554         if persons is None or not persons: return 0
1555         person = persons[0]
1556         self.islistequal([], person['roles'], 'DeleteRoleFromPerson - check')
1557         self.islistequal([], person['key_ids'], 'DeleteKey - check')
1558         self.islistequal([], person['site_ids'], 'DeletePersonFromSite - check')
1559         self.islistequal([], person['slice_ids'], 'DeletePersonFromSlice - check')
1560
1561         DeletePerson = self.debug(api.DeletePerson)
1562         # Have DeletePeson automatically delete attriubtes for all other persons
1563         for person_id in self.person_ids:
1564             # Delete account
1565             DeletePerson(auth, person_id)
1566
1567         # Check if persons are deleted
1568         GetPersons = self.debug(api.GetPersons)
1569         persons = GetPersons(auth, self.person_ids)
1570         self.islistequal(persons, [], 'DeletePerson - check')
1571
1572         if self.config.verbose:
1573             utils.header("Deleted users: %s" % self.person_ids)
1574
1575         self.person_ids = []
1576
1577     def KeyTypes(self, n = 2):
1578         key_types = []
1579         AddKeyType = self.debug(api.AddKeyType)
1580         GetKeyTypes = self.debug(api.GetKeyTypes)
1581         for i in range(n):
1582             # Add key type
1583             keytype = randstr(10)
1584             result = AddKeyType(auth, keytype)
1585             if result is None: continue
1586
1587             # Check key types
1588             key_types.append(keytype)
1589             keytypes  = GetKeyTypes(auth)
1590             if not keytypes: continue
1591             keytypes = filter(lambda x: x in [keytype], keytypes)
1592             if not keytypes: continue
1593             self.isequal(keytype, keytypes[0], 'AddKeyType - isequal')
1594
1595         # Check all
1596         keytypes = GetKeyTypes(auth)
1597         if keytypes is not None:
1598             keytypes = filter(lambda x: x in key_types, keytypes)
1599             self.islistequal(key_types, keytypes, 'GetKeyTypes - isequal')
1600
1601         if self.config.verbose:
1602             utils.header("Added key types: %s" % key_types)
1603
1604         return key_types
1605
1606     def DeleteKeyTypes(self):
1607         DeleteKeyType = self.debug(api.DeleteKeyType)
1608         GetKeyTypes = self.debug(api.GetKeyTypes)
1609         for key_type in self.key_types:
1610             result = DeleteKeyType(auth, key_type)
1611
1612         # Check if key types are deleted
1613         key_types = GetKeyTypes(auth)
1614         key_types = filter(lambda x: x in self.key_types, key_types)
1615         self.islistequal(key_types, [], 'DeleteKeyType - check')
1616
1617         if self.config.verbose:
1618             utils.header("Deleted key types %s" % self.key_types)
1619
1620         self.key_types = []
1621
1622     def Keys(self, n = 3):
1623         key_ids = []
1624         for i in range(n):
1625             # Add a key to an account
1626             key_fields = random_key()
1627             person_id = random.sample(self.person_ids, 1)[0]
1628             AddPersonKey = self.debug(api.AddPersonKey)
1629             key_id = AddPersonKey(auth, person_id, key_fields)
1630             if key_id is None: continue
1631
1632             # Should return a unique key_id
1633             self.isunique(key_id, key_ids, 'AddPersonKey - isunique')
1634             key_ids.append(key_id)
1635             GetKeys = self.debug(api.GetKeys)
1636             keys = GetKeys(auth, [key_id])
1637             if keys is None: continue
1638             key = keys[0]
1639             self.isequal(key, key_fields, 'AddPersonKey - isequal')
1640
1641             # Update Key
1642             key_fields = random_key()
1643             UpdateKey = self.debug(api.UpdateKey)
1644             result = UpdateKey(auth, key_id, key_fields)
1645
1646             keys = GetKeys(auth, [key_id])
1647             if keys is None or not keys: continue
1648             key = keys[0]
1649             self.isequal(key, key_fields, 'UpdatePersonKey - isequal')
1650
1651         keys = GetKeys(auth, key_ids)
1652         if keys is not None:
1653             self.islistequal(key_ids, [key['key_id'] for key in keys], 'GetKeys - isequal')
1654
1655         if self.config.verbose:
1656             utils.header("Added keys: %s" % key_ids)
1657         return key_ids
1658
1659
1660     def DeleteKeys(self):
1661
1662         # Blacklist first key, Delete rest
1663         GetKeys = self.debug(api.GetKeys)
1664         DeleteKey = self.debug(api.DeleteKey)
1665         BlacklistKey = self.debug(api.BlacklistKey)
1666
1667         key_id = self.key_ids.pop()
1668         BlacklistKey(auth, key_id)
1669         keys = GetKeys(auth, [key_id])
1670         self.islistequal(keys, [], 'BlacklistKey - check')
1671
1672         if self.config.verbose:
1673             utils.header("Blacklisted key: %s" % key_id)
1674
1675         for key_id in self.key_ids:
1676             DeleteKey(auth, key_id)
1677
1678         keys = GetKeys(auth, self.key_ids)
1679         self.islistequal(keys, [], 'DeleteKey - check')
1680
1681         if self.config.verbose:
1682             utils.header("Deleted keys: %s" % self.key_ids)
1683
1684         self.key_ids = []
1685
1686     def BootStates(self, n = 3):
1687         boot_states = []
1688         AddBootState = self.debug(api.AddBootState)
1689         GetBootStates = self.debug(api.GetBootStates)
1690         for i in range(n):
1691             # Add boot state
1692             bootstate_fields = randstr(10)
1693             result = AddBootState(auth, bootstate_fields)
1694             if result is None: continue
1695
1696             # Check boot states
1697             boot_states.append(bootstate_fields)
1698             bootstates = GetBootStates(auth)
1699             if not bootstates: continue
1700             bootstates = filter(lambda x: x in [bootstate_fields], bootstates)
1701             if not bootstates: continue
1702             bootstate = bootstates[0]
1703             self.isequal(bootstate, bootstate_fields, 'AddBootState - isequal')
1704
1705         # Check all
1706         bs = GetBootStates(auth)
1707         if bs is not None:
1708             bs = filter(lambda x: x in [boot_states], bs)
1709             self.islistequal(boot_states, bs, 'GetBootStates - isequal')
1710
1711         if self.config.verbose:
1712             utils.header("Added boot_states: %s" % boot_states)
1713
1714         return boot_states
1715
1716     def DeleteBootStates(self):
1717         DeleteBootState = self.debug(api.DeleteBootState)
1718         GetBootStates = self.debug(api.GetBootStates)
1719         for boot_state in self.boot_states:
1720             result = DeleteBootState(auth, boot_state)
1721
1722         # Check if bootsates are deleted
1723         boot_states = GetBootStates(auth)
1724         boot_states = filter(lambda x: x in self.boot_states, boot_states)
1725         self.islistequal(boot_states, [], 'DeleteBootState check')
1726
1727         if self.config.verbose:
1728             utils.header("Deleted boot_states: %s" % self.boot_states)
1729
1730         self.boot_states = []
1731
1732
1733     def Peers(self, n = 2):
1734         peer_ids = []
1735         AddPeer = self.debug(api.AddPeer)
1736         GetPeers = self.debug(api.GetPeers)
1737         UpdatePeer = self.debug(api.UpdatePeer)
1738         for i in range(n):
1739             # Add Peer
1740             peer_fields = random_peer()
1741             peer_id = AddPeer(auth, peer_fields)
1742
1743             # Should return a unique id
1744             self.isunique(peer_id, peer_ids, 'AddPeer - isunique')
1745             peer_ids.append(peer_id)
1746             peers = GetPeers(auth, [peer_id])
1747             if peers is None: continue
1748             peer = peers[0]
1749             self.isequal(peer, peer_fields, 'AddPeer - isequal')
1750
1751             # Update Peer
1752             peer_fields = random_peer()
1753             result = UpdatePeer(auth, peer_id, peer_fields)
1754
1755             # Check again
1756             peers = GetPeers(auth, [peer_id])
1757             if peers is None: continue
1758             peer = peers[0]
1759             self.isequal(peer, peer_fields, 'UpdatePeer - isequal')
1760
1761         peers = GetPeers(auth, peer_ids)
1762         if peers is not None:
1763             self.islistequal(peer_ids, [peer['peer_id'] for peer in peers], 'GetPeers -isequal')
1764
1765         if self.config.verbose:
1766             utils.header("Added peers: %s" % peer_ids)
1767
1768         return peer_ids
1769
1770
1771     def DeletePeers(self):
1772         # Delete all peers
1773         DeletePeer = self.debug(api.DeletePeer)
1774         GetPeers = self.debug(api.GetPeers)
1775         for peer_id in self.peer_ids:
1776             result = DeletePeer(auth, peer_id)
1777
1778         # Check if peers are deleted
1779         peers = GetPeers(auth, self.peer_ids)
1780         self.islistequal(peers, [], 'DeletePeer - check' % self.peer_ids)
1781
1782         if self.config.verbose:
1783             utils.header("Deleted peers: %s" % self.peer_ids)
1784         self.peer_ids =[]
1785
1786     def ConfFiles(self, n = 2):
1787         conf_file_ids = []
1788         for i in range(n):
1789             # Add ConfFile
1790             conf_file_fields = random_conf_file()
1791             AddConfFile = self.debug(api.AddConfFile)
1792             conf_file_id = AddConfFile(auth, conf_file_fields)
1793             if conf_file_id is None: continue
1794
1795             # Should return a unique id
1796             self.isunique(conf_file_id, conf_file_ids, 'AddConfFile - isunique')
1797             conf_file_ids.append(conf_file_id)
1798
1799             # Get ConfFiles
1800             GetConfFiles = self.debug(api.GetConfFiles)
1801             conf_files = GetConfFiles(auth, [conf_file_id])
1802             if conf_files is None: continue
1803             conf_file = conf_files[0]
1804             self.isequal(conf_file, conf_file_fields, 'AddConfFile - isunique')
1805
1806             # Update ConfFile
1807             conf_file_fields = random_conf_file()
1808             UpdateConfFile = self.debug(api.UpdateConfFile)
1809             result = UpdateConfFile(auth, conf_file_id, conf_file_fields)
1810
1811             # Check again
1812             conf_files = GetConfFiles(auth, [conf_file_id])
1813             if conf_files is None: continue
1814             conf_file = conf_files[0]
1815             self.isequal(conf_file, conf_file_fields, 'UpdateConfFile - isunique')
1816
1817
1818             # Add this conf file to a random node
1819             node_id = random.sample(self.node_ids, 1)[0]
1820             AddConfFileToNode = self.debug(api.AddConfFileToNode)
1821             AddConfFileToNode(auth, conf_file_id, node_id)
1822
1823             # Add this conf file to a random node group
1824             nodegroup_id = random.sample(self.nodegroup_ids, 1)[0]
1825             AddConfFileToNodeGroup = self.debug(api.AddConfFileToNodeGroup)
1826             AddConfFileToNodeGroup(auth, conf_file_id, nodegroup_id)
1827
1828             # Check node, nodegroup
1829             conf_files = GetConfFiles(auth, [conf_file_id], ['node_ids', 'nodegroup_ids'])
1830             if conf_files is None or not conf_files: continue
1831             conf_file = conf_files[0]
1832             self.islistequal([node_id], conf_file['node_ids'], 'AddConfFileToNode - check')
1833             self.islistequal([nodegroup_id], conf_file['nodegroup_ids'], 'AddConfFileToNodeGroup - check')
1834
1835
1836
1837         conf_files = GetConfFiles(auth, conf_file_ids)
1838         if conf_files is not None:
1839             self.islistequal(conf_file_ids, [c['conf_file_id'] for c in conf_files], 'GetConfFiles - isequal')
1840         if self.config.verbose:
1841             utils.header("Added conf_files: %s" % conf_file_ids)
1842
1843         return conf_file_ids
1844
1845     def DeleteConfFiles(self):
1846
1847             GetConfFiles = self.debug(api.GetConfFiles)
1848             DeleteConfFile = self.debug(api.DeleteConfFile)
1849             DeleteConfFileFromNode = self.debug(api.DeleteConfFileFromNode)
1850             DeleteConfFileFromNodeGroup = self.debug(api.DeleteConfFileFromNodeGroup)
1851
1852             conf_files = GetConfFiles(auth, self.conf_file_ids)
1853             if conf_files is None or not conf_files: return 0
1854             conf_file = conf_files[0]
1855             if conf_file['node_ids']:
1856                 node_id = random.sample(conf_file['node_ids'], 1)[0]
1857                 DeleteConfFileFromNode(auth, conf_file['conf_file_id'], node_id)
1858             if conf_file['nodegroup_ids']:
1859                 nodegroup_id = random.sample(conf_file['nodegroup_ids'], 1)[0]
1860                 DeleteConfFileFromNodeGroup(auth, conf_file['conf_file_id'], nodegroup_id)
1861
1862             # check
1863             conf_files = GetConfFiles(auth, [conf_file['conf_file_id']], ['node_ids', 'nodegroup_ids'])
1864             if conf_files is None or not conf_files: return 0
1865             conf_file = conf_files[0]
1866             self.islistequal([], conf_file['node_ids'], 'AddConfFileToNode - check')
1867             self.islistequal([], conf_file['nodegroup_ids'], 'AddConfFileToNodeGroup - check')
1868
1869             for conf_file_id in self.conf_file_ids:
1870                 DeleteConfFile(auth, conf_file_id)
1871
1872             # check
1873             conf_files = GetConfFiles(auth, self.conf_file_ids)
1874             self.islistequal(conf_files, [], 'DeleteConfFile - check')
1875
1876             if self.config.verbose:
1877                 utils.header("Deleted conf_files: %s" % self.conf_file_ids)
1878
1879             self.conf_file_ids = []
1880
1881     def NodeNetworks(self, n = 4):
1882         nodenetwork_ids = []
1883         AddNodeNetwork = self.debug(api.AddNodeNetwork)
1884         UpdateNodeNetwork = self.debug(api.UpdateNodeNetwork)
1885         GetNodeNetworks = self.debug(api.GetNodeNetworks)
1886
1887         for i in range(n):
1888             # Add Node Network
1889             nodenetwork_fields = random_nodenetwork()
1890             node_id = random.sample(self.node_ids, 1)[0]
1891             nodenetwork_id = AddNodeNetwork(auth, node_id, nodenetwork_fields)
1892             if nodenetwork_id is None: continue
1893
1894             # Should return a unique id
1895             self.isunique(nodenetwork_ids, nodenetwork_ids, 'AddNodeNetwork - isunique')
1896             nodenetwork_ids.append(nodenetwork_id)
1897
1898             # check Node Network
1899             nodenetworks = GetNodeNetworks(auth, [nodenetwork_id])
1900             if nodenetworks is None: continue
1901             nodenetwork = nodenetworks[0]
1902             self.isequal(nodenetwork, nodenetwork_fields, 'AddNodeNetwork - isequal')
1903
1904             # Update NodeNetwork
1905             nodenetwork_fields = random_nodenetwork()
1906             UpdateNodeNetwork(auth, nodenetwork_id, nodenetwork_fields)
1907
1908             # Check again
1909             nodenetworks = GetNodeNetworks(auth, [nodenetwork_id])
1910             if nodenetworks is None: continue
1911             nodenetwork = nodenetworks[0]
1912             self.isequal(nodenetwork,  nodenetwork_fields, 'UpdateNodeNetwork - isequal')
1913
1914         nodenetworks = GetNodeNetworks(auth, nodenetwork_ids)
1915         if nodenetworks is not None:
1916             self.islistequal(nodenetwork_ids, [n['nodenetwork_id'] for n in nodenetworks], 'GetNodeNetworks - isequal')
1917
1918         if self.config.verbose:
1919             utils.header('Added nodenetworks: %s' % nodenetwork_ids)
1920
1921         return nodenetwork_ids
1922
1923     def DeleteNodeNetworks(self):
1924         GetNodeNetworks = self.debug(api.GetNodeNetworks)
1925         DeleteNodeNetwork = self.debug(api.DeleteNodeNetwork)
1926
1927         for nodenetwork_id in self.nodenetwork_ids:
1928             DeleteNodeNetwork(auth, nodenetwork_id)
1929
1930         # check
1931         nodenetworks = GetNodeNetworks(auth, self.nodenetwork_ids)
1932         self.islistequal(nodenetworks, [], 'DeleteNodeNetwork - check')
1933
1934         if self.config.verbose:
1935             utils.header("Deleted nodenetworks: %s " % self.nodenetwork_ids)
1936         self.nodenetwork_ids = []
1937
1938     def NodeNetworkSettings(self, n=2):
1939         nodenetwork_setting_ids = []
1940         AddNodeNetworkSetting = self.debug(api.AddNodeNetworkSetting)
1941         UpdateNodeNetworkSetting = self.debug(api.UpdateNodeNetworkSetting)
1942         GetNodeNetworkSettings = self.debug(api.GetNodeNetworkSettings)
1943
1944         for nodenetwork_id in self.nodenetwork_ids:
1945             # Add Node Network
1946             nodenetwork_setting_fields = random_nodenetwork_setting()
1947             #nodenetwork_id = random.sample(self.nodenetwork_ids, 1)[0]
1948             nodenetwork_setting_type_id = random.sample(self.nodenetwork_setting_type_ids, 1)[0]
1949             value = nodenetwork_setting_fields['value']
1950             nodenetwork_setting_id = AddNodeNetworkSetting(auth, nodenetwork_id, nodenetwork_setting_type_id, value)
1951             if nodenetwork_setting_id is None: continue
1952
1953             # Should return a unique id
1954             self.isunique(nodenetwork_setting_ids, nodenetwork_setting_ids, 'AddNodeNetworkSetting - isunique')
1955             nodenetwork_setting_ids.append(nodenetwork_setting_id)
1956
1957             # check Node Network
1958             nodenetwork_settings = GetNodeNetworkSettings(auth, [nodenetwork_setting_id])
1959             if nodenetwork_settings is None: continue
1960             nodenetwork_setting = nodenetwork_settings[0]
1961             self.isequal(nodenetwork_setting, nodenetwork_setting_fields, 'AddNodeNetworkSetting - isequal')
1962
1963             # Update NodeNetworkSetting
1964             nodenetwork_setting_fields = random_nodenetwork_setting()
1965             value = nodenetwork_setting_fields['value']
1966             UpdateNodeNetworkSetting(auth, nodenetwork_setting_id, value)
1967
1968             # Check again
1969             nodenetwork_settings = GetNodeNetworkSettings(auth, [nodenetwork_setting_id])
1970             if nodenetwork_settings is None: continue
1971             nodenetwork_setting = nodenetwork_settings[0]
1972             self.isequal(nodenetwork_setting,  nodenetwork_setting_fields, 'UpdateNodeNetworkSetting - isequal')
1973
1974         nodenetwork_settings = GetNodeNetworkSettings(auth, nodenetwork_setting_ids)
1975         if nodenetwork_settings is not None:
1976             self.islistequal(nodenetwork_setting_ids, [n['nodenetwork_setting_id'] for n in nodenetwork_settings], 'GetNodeNetworkSettings - isequal')
1977
1978         if self.config.verbose:
1979             utils.header('Added nodenetwork_settings: %s' % nodenetwork_setting_ids)
1980
1981         return nodenetwork_setting_ids
1982
1983     def DeleteNodeNetworkSettings(self):
1984         GetNodeNetworkSettings = self.debug(api.GetNodeNetworkSettings)
1985         DeleteNodeNetworkSetting = self.debug(api.DeleteNodeNetworkSetting)
1986
1987         for nodenetwork_setting_id in self.nodenetwork_setting_ids:
1988             DeleteNodeNetworkSetting(auth, nodenetwork_setting_id)
1989
1990         # check
1991         nodenetwork_settings = GetNodeNetworkSettings(auth, self.nodenetwork_setting_ids)
1992         self.islistequal(nodenetwork_settings, [], 'DeleteNodeNetworkSetting - check')
1993
1994         if self.config.verbose:
1995             utils.header("Deleted nodenetwork settings: %s " % self.nodenetwork_setting_ids)
1996         self.nodenetwork_setting_ids = []
1997
1998     def NodeNetworkSettingTypes(self, n = 2):
1999         nodenetwork_setting_type_ids = []
2000         AddNodeNetworkSettingType = self.debug(api.AddNodeNetworkSettingType)
2001         UpdateNodeNetworkSettingType = self.debug(api.UpdateNodeNetworkSettingType)
2002         GetNodeNetworkSettingTypes = self.debug(api.GetNodeNetworkSettingTypes)
2003
2004         for i in range(n):
2005             # Add Node Network Settings Type
2006             nodenetwork_setting_type_fields = random_nodenetwork_setting_type()
2007             nodenetwork_setting_type_id = AddNodeNetworkSettingType(auth, nodenetwork_setting_type_fields)
2008             if nodenetwork_setting_type_id is None: continue
2009
2010             # Should return a unique id
2011             self.isunique(nodenetwork_setting_type_ids, nodenetwork_setting_type_ids, 'AddNodeNetworkSettingType - isunique')
2012             nodenetwork_setting_type_ids.append(nodenetwork_setting_type_id)
2013
2014             # check Node Network Settings Type
2015             nodenetwork_setting_types = GetNodeNetworkSettingTypes(auth, [nodenetwork_setting_type_id])
2016             if nodenetwork_setting_types is None: continue
2017             nodenetwork_setting_type = nodenetwork_setting_types[0]
2018             self.isequal(nodenetwork_setting_type, nodenetwork_setting_type_fields, 'AddNodeNetworkSettingType - isequal')
2019
2020             # Update NodeNetworkSetting
2021             nodenetwork_setting_type_fields = random_nodenetwork_setting_type()
2022             UpdateNodeNetworkSettingType(auth, nodenetwork_setting_type_id, nodenetwork_setting_type_fields)
2023
2024             # Check again
2025             nodenetwork_setting_types = GetNodeNetworkSettingTypes(auth, [nodenetwork_setting_type_id])
2026             if nodenetwork_setting_types is None: continue
2027             nodenetwork_setting_type = nodenetwork_setting_types[0]
2028             self.isequal(nodenetwork_setting_type,  nodenetwork_setting_type_fields, 'UpdateNodeNetworkSettingType - isequal')
2029
2030         nodenetwork_setting_types = GetNodeNetworkSettingTypes(auth, nodenetwork_setting_type_ids)
2031         if nodenetwork_setting_types is not None:
2032             self.islistequal(nodenetwork_setting_type_ids, [n['nodenetwork_setting_type_id'] for n in nodenetwork_setting_types], 'GetNodeNetworkSettingTypes - isequal')
2033
2034         if self.config.verbose:
2035             utils.header('Added nodenetwork_setting_types: %s' % nodenetwork_setting_type_ids)
2036
2037         return nodenetwork_setting_type_ids
2038
2039     def DeleteNodeNetworkSettingTypes(self):
2040         GetNodeNetworkSettingTypes = self.debug(api.GetNodeNetworkSettingTypes)
2041         DeleteNodeNetworkSettingType = self.debug(api.DeleteNodeNetworkSettingType)
2042
2043         for nodenetwork_setting_type_id in self.nodenetwork_setting_type_ids:
2044             DeleteNodeNetworkSettingType(auth, nodenetwork_setting_type_id)
2045
2046         # check
2047         nodenetwork_setting_types = GetNodeNetworkSettingTypes(auth, self.nodenetwork_setting_type_ids)
2048         self.islistequal(nodenetwork_setting_types, [], 'DeleteNodeNetworkSettingType - check')
2049
2050         if self.config.verbose:
2051             utils.header("Deleted nodenetwork setting types: %s " % self.nodenetwork_setting_type_ids)
2052         self.nodenetwork_setting_type_ids = []
2053
2054     def Messages(self, n = 2):
2055         message_ids = []
2056         AddMessage = self.debug(api.AddMessage)
2057         GetMessages = self.debug(api.GetMessages)
2058         UpdateMessage = self.debug(api.UpdateMessage)
2059         for i in range(n):
2060             # Add Message
2061             message_fields = random_message()
2062             message_id = message_fields['message_id']
2063             AddMessage(auth, message_fields)
2064             if message_id is None: continue
2065
2066             # Should return a unique id
2067             self.isunique(message_id, message_ids, 'AddMessage - isunique')
2068             message_ids.append(message_id)
2069             messages = GetMessages(auth, [message_id])
2070             if messages is None: continue
2071             message = messages[0]
2072             self.isequal(message, message_fields, 'AddMessage - isequal')
2073
2074             # Update message
2075             message_fields = random_message()
2076             result = UpdateMessage(auth, message_id, message_fields)
2077
2078             # Check again
2079             messages = GetMessages(auth, [message_id])
2080             if messages is None: continue
2081             message = messages[0]
2082             self.isequal(message, message_fields, 'UpdateMessage - isequal')
2083
2084         messages = GetMessages(auth, message_ids)
2085         if messages is not None:
2086             self.islistequal(message_ids, [m['message_id'] for m in messages], 'GetMessages - isequal')
2087
2088         if self.config.verbose:
2089             utils.header("Added messages: %s" % message_ids)
2090
2091         return message_ids
2092
2093     def DeleteMessages(self):
2094         # Delete all messages
2095         DeleteMessage = self.debug(api.DeleteMessage)
2096         GetMessages = self.debug(api.GetMessages)
2097         for message_id in self.message_ids:
2098             result = DeleteMessage(auth, message_id)
2099
2100         # Check if messages are deleted
2101         messages = GetMessages(auth, self.message_ids)
2102         self.islistequal(messages, [], 'DeleteMessage - check')
2103
2104         if self.config.verbose:
2105             utils.header("Deleted messages: %s" % self.message_ids)
2106
2107         self.message_ids = []
2108
2109     def Sessions(self, n = 2):
2110         session_ids = []
2111         AddSession = self.debug(api.AddSession)
2112         GetSession = self.debug(api.GetSession)
2113         GetSessions = self.debug(api.GetSessions)
2114         for i in range(n):
2115             # Add session
2116             person_id = random.sample(self.person_ids, 1)[0]
2117             session_id = AddSession(auth, person_id)
2118             if session_id is None: continue
2119             session_ids.append(session_id)
2120
2121             # Check session
2122             sessions = GetSessions(auth, [person_id])
2123             if not sessions: continue
2124             session = sessions[0]
2125             sess_id = session['session_id']
2126             self.islistequal([sess_id], [session_id], 'AddSession - isequal')
2127
2128             # GetSession creates session_id based on auth, so we must use the current auth
2129             session_id = GetSession(auth)
2130             if session_id is None: continue
2131             session_ids.append(session_id)
2132
2133             # Check session
2134             sessions = GetSessions(auth, [auth['Username']])
2135             if not sessions: continue
2136             session = sessions[0]
2137             sess_id = session['session_id']
2138             self.islistequal([sess_id], [session_id], 'GetSession - isequal')
2139
2140         # Check all
2141         sessions = GetSessions(auth, session_ids)
2142         if sessions is not None:
2143             sess_ids = [s['session_id'] for s in sessions]
2144             self.islistequal(sess_ids, session_ids, 'GetSessions - isequal')
2145
2146         if self.config.verbose:
2147             utils.header("Added sessions: %s" % session_ids)
2148
2149         return session_ids
2150
2151     def DeleteSessions(self):
2152         DeleteSession = self.debug(api.DeleteSession)
2153         GetSessions = self.debug(api.GetSessions)
2154
2155         # DeleteSession deletes based on auth, so we must create auths for the sessions we delete
2156         for session_id  in self.session_ids:
2157             sessions = GetSessions(auth, [session_id])
2158             if not sessions: continue
2159             session = sessions[0]
2160             tmpauth = {
2161                 'session': session['session_id'],
2162                 'AuthMethod': 'session'
2163                 }
2164
2165             DeleteSession(tmpauth)
2166
2167         # Check if sessions are deleted
2168         sessions = GetSessions(auth, self.session_ids)
2169         self.islistequal(sessions, [], 'DeleteBootState check')
2170
2171         if self.config.verbose:
2172             utils.header("Deleted sessions: %s" % self.session_ids)
2173
2174         self.session_ids = []
2175
2176     def GenerateNodeConfFile(self):
2177         GetNodes = self.debug(api.GetNodes)
2178         GetNodeNetworks = self.debug(api.GetNodeNetworks)
2179         GenerateNodeConfFile = self.debug(api.GenerateNodeConfFile)
2180
2181         nodes = GetNodes(auth, self.node_ids)
2182         nodes = filter(lambda n: n['nodenetwork_ids'], nodes)
2183         if not nodes: return 0
2184         node = nodes[0]
2185         nodenetworks = GetNodeNetworks(auth, node['nodenetwork_ids'])
2186         nodenetwork = nodenetworks[0]
2187         parts = node['hostname'].split(".", 1)
2188         host = parts[0]
2189         domain = parts[1]
2190         node_config = {
2191                 'NODE_ID': node['node_id'],
2192                 'NODE_KEY': node['key'],
2193                 'IP_METHOD': nodenetwork['method'],
2194                 'IP_ADDRESS': nodenetwork['ip'],
2195                 'IP_GATEWAY': nodenetwork['gateway'],
2196                 'IP_NETMASK': nodenetwork['netmask'],
2197                 'IP_NETADDR': nodenetwork['network'],
2198                 'IP_BROADCASTADDR': nodenetwork['broadcast'],
2199                 'IP_DNS1': nodenetwork['dns1'],
2200                 'IP_DNS2': nodenetwork['dns2'],
2201                 'HOSTNAME': host,
2202                 'DOMAIN_NAME': domain
2203                 }
2204         node_config_file = GenerateNodeConfFile(auth, node['node_id'])
2205         self.isequal(node_config_file, node_config, 'GenerateNodeConfFile - isequal')
2206
2207         if self.config.verbose:
2208             utils.header("GenerateNodeConfFile")
2209
2210     def GetBootMedium(self):
2211         pass
2212
2213
2214     def GetEventObjects(self):
2215         GetEventObjects = self.debug(api.GetEventObjects)
2216         GetEventObjects(auth)
2217
2218         if self.config.verbose:
2219             utils.header("GetEventObjects")
2220
2221     def GetEvents(self):
2222         GetEvents = self.debug(api.GetEvents)
2223         GetEvents(auth)
2224
2225         if self.config.verbose:
2226             utils.header("GetEvents")
2227
2228     def GetPeerData(self):
2229         GetPeers = self.debug(api.GetPeers)
2230         GetPeerData = self.debug(api.GetPeerData)
2231
2232         peers = GetPeers(auth)
2233         if peers is None or not peers: return 0
2234         peer = peers[0]
2235         peer_data = GetPeerData(auth)
2236
2237         # Manuall construt peer data
2238
2239         if self.config.verbose:
2240             utils.header("GetPeerData")
2241
2242     def GetPeerName(self):
2243         # GetPeerName should return the same as api.config.PLC_NAME
2244         GetPeerName = self.debug(api.GetPeerName)
2245         peer_name = GetPeerName(auth)
2246         self.islistequal([peer_name], [api.config.PLC_NAME], 'GetPeerName - isequal')
2247
2248         if self.config.verbose:
2249             utils.header("GetPeerName")
2250
2251     def GetPlcRelease(self):
2252         GetPlcRelease = self.debug(api.GetPlcRelease)
2253         plc_release = GetPlcRelease(auth)
2254
2255         if self.config.verbose:
2256             utils.header("GetPlcRelease")
2257
2258     def GetSliceKeys(self):
2259         GetSliceKeys = self.debug(api.GetSliceKeys)
2260         GetSlices = self.debug(api.GetSlices)
2261
2262         slices = GetSlices(auth, self.slice_ids)
2263         if not slices: return 0
2264         slices = filter(lambda s: s['person_ids'], slices)
2265         if not slices: return 0
2266         slice = slices[0]
2267
2268         slice_keys = GetSliceKeys(auth, [slice['slice_id']])
2269         # XX Manually construct slice_keys for this slice and compare
2270
2271         if self.config.verbose:
2272             utils.header("GetSliceKeys(%s)" % [slice['slice_id']])
2273
2274     def GetSliceTicket(self):
2275         GetSliceTicket = self.debug(api.GetSliceTicket)
2276
2277         slice_id = random.sample(self.slice_ids, 1)[0]
2278         slice_ticket = GetSliceTicket(auth, slice_id)
2279
2280         if self.config.verbose:
2281             utils.header("GetSliceTicket(%s)" % slice_id)
2282
2283     def GetSlicesMD5(self):
2284         GetSlicesMD5 = self.debug(api.GetSlicesMD5)
2285
2286         slices_md5 = GetSlicesMD5(auth)
2287
2288         if self.config.verbose:
2289             utils.header("GetSlicesMD5")
2290
2291     def GetSlivers(self):
2292         GetSlivers = self.debug(api.GetSlivers)
2293         GetNodes = self.debug(api.GetNodes)
2294         nodes = GetNodes(auth, self.node_ids)
2295         if nodes is None or not nodes: return 0
2296         nodes = filter(lambda n: n['slice_ids'], nodes)
2297         if not nodes: return 0
2298         node = nodes[0]
2299
2300         slivers = GetSlivers(auth, node['node_id'])
2301
2302         # XX manually create slivers object and compare
2303
2304         if self.config.verbose:
2305             utils.header("GetSlivers(%s)" % node['node_id'])
2306
2307     def GetWhitelist(self):
2308         GetWhitelist = self.debug(api.GetWhitelist)
2309         GetNodes = self.debug(api.GetNodes)
2310
2311         whitelists = GetWhitelist(auth, self.node_ids)
2312         nodes = GetNodes(auth, self.node_ids)
2313         if nodes is None or not nodes: return 0
2314         nodes = filter(lambda n: n['slice_ids_whitelist'], nodes)
2315         self.islistequal(whitelists, nodes, 'GetWhitelist - isequal')
2316
2317         if self.config.verbose:
2318             utils.header("GetWhitelist")
2319
2320     def NotifyPersons(self):
2321         NotifyPersons = self.debug(api.NotifyPersons)
2322         person_id = random.sample(self.person_ids, 1)[0]
2323
2324         NotifyPersons(auth, [person_id], 'QA Test', 'Welcome')
2325
2326         if self.config.verbose:
2327             utils.header('NotifyPersons(%s)' % [person_id])
2328
2329     def NotifySupport(self):
2330         NotifySupport = self.debug(api.NotifySupport)
2331         NotifySupport(auth, 'QA Test', 'Support Request')
2332
2333         if self.config.verbose:
2334             utils.header('NotifSupport')
2335
2336     def RebootNode(self):
2337         RebootNode = self.debug(api.RebootNode)
2338         node_id = random.sample(self.node_ids, 1)[0]
2339         RebootNode(auth, node_id)
2340
2341         if self.config.verbose:
2342             utils.header('RebootNode(%s)' % node_id)
2343
2344     def ResetPassword(self):
2345         ResetPassword = self.debug(api.ResetPassword)
2346         person_id = random.sample(self.person_ids, 1)[0]
2347         ResetPassword(auth, person_id)
2348
2349         if self.config.verbose:
2350             utils.header('ResetPassword(%s)' % person_id)
2351
2352     def SetPersonPrimarySite(self):
2353         SetPersonPrimarySite = self.debug(api.SetPersonPrimarySite)
2354         GetPersons = self.debug(api.GetPersons)
2355         person_id = random.sample(self.person_ids, 1)[0]
2356         persons = GetPersons(auth, person_id)
2357         if not persons: return 0
2358         person = persons[0]
2359         site_id = random.sample(person['site_ids'], 1)[0]
2360         SetPersonPrimarySite(auth, person_id, site_id)
2361
2362         if self.config.verbose:
2363             utils.header('SetPersonPrimarySite(%s, %s)' % (person_id, site_id))
2364
2365     def VerifyPerson(self):
2366         VerifyPerson = self.debug(api.VerifyPerson)
2367         UpdatePerson = self.debug(api.UpdatePerson)
2368         GetPersons = self.debug(api.GetPersons)
2369
2370         # can only verify new (disabled) accounts
2371         person_id = random.sample(self.person_ids, 1)[0]
2372         persons = GetPersons(auth, [person_id])
2373         if persons is None or not persons: return 0
2374         person = persons[0]
2375         UpdatePerson(auth, person['person_id'], {'enabled': False})
2376         VerifyPerson(auth, person['person_id'])
2377
2378         if self.config.verbose:
2379             utils.header('VerifyPerson(%s)' % person_id)
2380
2381 if __name__ == '__main__':
2382     args = tuple(sys.argv[1:])
2383     api_unit_test()(*args)