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