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