1 #!/usr/bin/env /usr/share/plc_api/plcsh
5 # Copyright (C) 2006 The Trustees of Princeton University
9 from pprint import pprint
10 from string import letters, digits, punctuation
12 from traceback import print_exc
22 from qa.Config import Config
23 from qa.logger import Logfile, log
24 from random import Random
27 boot_states = [u'boot', u'dbg', u'inst', u'new', u'rcnf', u'rins']
29 methods = [u'static', u'dhcp', u'proxy', u'tap', u'ipmi', u'unknown']
32 attribute_types = range(6,20)
36 def randfloat(min = 0.0, max = 1.0):
37 return float(min) + (random.random() * (float(max) - float(min)))
39 def randint(min = 0, max = 1):
40 return int(randfloat(min, max + 1))
43 return random.sample([True, False], 1)[0]
44 # See "2.2 Characters" in the XML specification:
46 # #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD]
48 # [#x7F-#x84], [#x86-#x9F], [#xFDD0-#xFDDF]
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))
60 def randstr(length, pool = valid_xml_chars, encoding = "utf-8"):
61 sample = random.sample(pool, min(length, len(pool)))
64 bytes = len(s.encode(encoding))
68 sample += random.sample(pool, min(length - bytes, len(pool)))
69 random.shuffle(sample)
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)
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]
92 return (randstr(100, letters + digits) + "@" + randhostname()).lower()
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"))),
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,
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")))
119 def random_address_type():
122 'description': randstr(254),
125 def random_address():
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),
138 'first_name': randstr(128),
139 'last_name': randstr(128),
140 'email': randemail(),
142 # Accounts are disabled by default
144 'password': randstr(254),
149 'key_type': random.sample(key_types, 1)[0],
155 'name': random.sample(login_bases, 1)[0] + "_" + randstr(11, letters).lower(),
156 'url': "http://" + randhostname() + "/",
157 'description': randstr(2048),
160 def random_nodegroup():
163 'description': randstr(200),
168 'hostname': randhostname(),
169 'boot_state': random.sample(boot_states, 1)[0],
170 'model': randstr(255),
171 'version': randstr(64),
172 'session': randstr(20)
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),
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)
190 for field in 'ip', 'netmask', 'network', 'broadcast', 'gateway', 'dns1':
191 nodenetwork_fields[field] = socket.inet_ntoa(struct.pack('>L', locals()[field]))
193 return nodenetwork_fields
195 def random_nodenetwork_setting():
200 def random_nodenetwork_setting_type():
203 'description': randstr(50),
204 'category': randstr(20),
205 'min_role_id': random.sample(roles, 1)[0]
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),
219 def random_conf_file():
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()),
234 def random_attribute_type():
236 'name': randstr(100),
237 'description': randstr(254),
238 'min_role_id': int(random.sample(roles, 1)[0]),
241 def random_pcu_type():
243 'model': randstr(254),
244 'name': randstr(254),
247 def random_pcu_protocol_type():
249 'port': randint(0, 65535),
250 'protocol': randstr(254),
251 'supported': randbool()
254 def random_slice_instantiation():
256 'instantiation': randstr(10)
258 def random_slice_attribute():
260 'attribute_type_id': random.sample(attribute_types, 1)[0],
265 def random_initscript():
268 'enabled': randbool(),
269 'script': randstr(200)
274 'role_id': randint(1000),
278 def random_message():
280 'message_id': randstr(10),
281 'subject': randstr(100),
282 'template': randstr(254),
285 class api_unit_test(Test):
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)
300 pcu_protocol_types = 2,
308 nodenetwork_setting_types = 2,
309 nodenetwork_settings = 2,
310 slice_attribute_types = 2,
311 slice_instantiations = 2,
313 slice_attributes = 4,
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')
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()
336 # Begin testing methods
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()
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()
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()
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))
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])
407 def isequal(self, object_fields, expected_fields, method_name):
409 for field in expected_fields:
410 assert field in object_fields
411 assert object_fields[field] == expected_fields[field]
413 self.methods_failed.update([method_name])
417 def islistequal(self, list1, list2, method_name):
418 try: assert set(list1) == set(list2)
420 self.methods_failed.update([method_name])
424 def isunique(self, id, id_list, method_name):
425 try: assert id not in id_list
427 self.methods_failed.update([method_name])
431 def isinlist(self, item, item_list, method_name):
432 try: assert item in item_list
434 self.methods_failed.update([method_name])
438 def debug(self, method, method_name=None):
439 if method_name is None:
441 method_name = method.name
442 self.methods_tested.update([method_name])
444 method_name = method._Method__name
445 self.methods_tested.update([method_name])
447 def wrapper(*args, **kwds):
449 return method(*args, **kwds)
451 self.methods_failed.update([method_name])
452 print >> self.logfile, "%s%s: %s\n" % (method_name, tuple(args[1:]), traceback.format_exc())
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()
487 def Sites(self, n=4):
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
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
503 self.isequal(site, site_fields, 'AddSite - isequal')
506 site_fields = random_site()
507 UpdateSite = self.debug(self.api.UpdateSite)
508 result = UpdateSite(self.auth, site_id, site_fields)
512 sites = GetSites(self.auth, [site_id])
513 if sites is None: continue
515 self.isequal(site, site_fields, 'UpdateSite - isequal')
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')
521 if self.config.verbose:
522 utils.header("Added sites: %s" % site_ids)
527 def DeleteSites(self):
529 DeleteSite = self.debug(self.api.DeleteSite)
530 for site_id in self.site_ids:
531 result = DeleteSite(self.auth, site_id)
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')
538 if self.config.verbose:
539 utils.header("Deleted sites: %s" % self.site_ids)
543 def NetworkMethods(self, n=2):
545 AddNetworkMethod = self.debug(self.api.AddNetworkMethod)
546 GetNetworkMethods = self.debug(self.api.GetNetworkMethods)
550 net_method = randstr(10)
551 AddNetworkMethod(self.auth, net_method)
552 if net_method is None: continue
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')
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')
569 if self.config.verbose:
570 utils.header("Added network methods: %s" % methods)
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)
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')
585 if self.config.verbose:
586 utils.header("Deleted network methods: %s" % self.network_methods)
587 self.network_methods = []
589 def NetworkTypes(self, n=2):
591 AddNetworkType = self.debug(self.api.AddNetworkType)
592 GetNetworkTypes = self.debug(self.api.GetNetworkTypes)
597 AddNetworkType(self.auth, type)
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
607 self.isequal(net_type, type, 'AddNetworkType - isequal')
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')
614 if self.config.verbose:
615 utils.header("Added network types: %s" % net_types)
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)
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')
630 if self.config.verbose:
631 utils.header("Deleted network types: %s" % self.network_types)
632 self.network_types = []
635 def NodeGroups(self, n = 4):
637 AddNodeGroup = self.debug(self.api.AddNodeGroup)
638 UpdateNodeGroup = self.debug(self.api.UpdateNodeGroup)
639 GetNodeGroups = self.debug(self.api.GetNodeGroups)
643 nodegroup_fields = random_nodegroup()
644 nodegroup_id = AddNodeGroup(self.auth, nodegroup_fields)
645 if nodegroup_id is None: continue
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')
656 nodegroup_fields = random_nodegroup()
657 UpdateNodeGroup(self.auth, nodegroup_id, nodegroup_fields)
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')
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)
673 def DeleteNodeGroups(self):
674 # Delete all NodeGroups
675 GetNodeGroups = self.debug(self.api.GetNodeGroups)
676 DeleteNodeGroup = self.debug(self.api.DeleteNodeGroup)
678 for nodegroup_id in self.nodegroup_ids:
679 result = DeleteNodeGroup(self.auth, nodegroup_id)
681 # Check is nodegroups are deleted
682 nodegroups = GetNodeGroups(self.auth, self.nodegroup_ids)
683 self.islistequal(nodegroups, [], 'DeleteNodeGroup - check')
685 if self.config.verbose:
686 utils.header("Deleted nodegroups: %s" % self.nodegroup_ids)
688 self.nodegroup_ids = []
690 def PCUTypes(self, n=2):
692 AddPCUType = self.debug(self.api.AddPCUType)
693 UpdatePCUType = self.debug(self.api.UpdatePCUType)
694 GetPCUTypes = self.debug(self.api.GetPCUTypes)
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)
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')
712 pcu_type_fields = random_pcu_type()
713 UpdatePCUType(self.auth, pcu_type_id, pcu_type_fields)
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')
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')
725 if self.config.verbose:
726 utils.header("Added pcu_types: %s " % pcu_type_ids)
729 def DeletePCUTypes(self):
730 GetPCUTypes = self.debug(self.api.GetPCUTypes)
731 DeletePCUType = self.debug(self.api.DeletePCUType)
733 for pcu_type_id in self.pcu_type_ids:
734 DeletePCUType(self.auth, pcu_type_id)
736 pcu_types = GetPCUTypes(self.auth, self.pcu_type_ids)
737 self.islistequal(pcu_types, [], 'DeletePCUType - check')
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)
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
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)
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')
762 # Update protocol type
763 protocol_type_fields = random_pcu_protocol_type()
764 UpdatePCUProtocolType(self.auth, protocol_type_id, protocol_type_fields)
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')
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')
777 if self.config.verbose:
778 utils.header('Added pcu_protocol_types: %s' % protocol_type_ids)
780 return protocol_type_ids
782 def DeletePCUProtocolTypes(self):
783 GetPCUProtocolTypes = self.debug(self.api.GetPCUProtocolTypes)
784 DeletePCUProtocolType = self.debug(self.api.DeletePCUProtocolType)
786 for protocol_type_id in self.pcu_protocol_type_ids:
787 DeletePCUProtocolType(self.auth, protocol_type_id)
790 protocol_types = GetPCUProtocolTypes(self.auth, self.pcu_protocol_type_ids)
791 self.islistequal(protocol_types, [], 'DeletePCUProtocolType - check')
793 if self.config.verbose:
794 utils.header("Deleted pcu_protocol_types: %s" % self.pcu_protocol_type_ids)
795 self.pcu_protocol_type_ids = []
797 def PCUs(self, n = 4):
799 AddPCU = self.debug(self.api.AddPCU)
800 UpdatePCU = self.debug(self.api.UpdatePCU)
801 GetPCUs = self.debug(self.api.GetPCUs)
803 for site_id in self.site_ids:
805 pcu_fields = random_pcu()
806 pcu_id = AddPCU(self.auth, site_id, pcu_fields)
807 if pcu_id is None: continue
809 # Should return a unique id
810 self.isunique(pcu_id, pcu_ids, 'AddPCU - isunique')
811 pcu_ids.append(pcu_id)
814 pcus = GetPCUs(self.auth, [pcu_id])
815 if pcus is None: continue
817 self.isequal(pcu, pcu_fields, 'AddPCU - isequal')
820 pcu_fields = random_pcu()
821 UpdatePCU(self.auth, pcu_id, pcu_fields)
824 pcus = GetPCUs(self.auth, [pcu_id])
825 if pcus is None: continue
827 self.isequal(pcu, pcu_fields, 'UpdatePCU - isequal')
829 pcus = GetPCUs(self.auth, pcu_ids)
831 self.islistequal(pcu_ids, [p['pcu_id'] for p in pcus], 'GetPCUs - isequal')
833 if self.config.verbose:
834 utils.header('Added pcus: %s' % pcu_ids)
838 def DeletePCUs(self):
839 GetPCUs = self.debug(self.api.GetPCUs)
840 DeletePCU = self.debug(self.api.DeletePCU)
842 for pcu_id in self.pcu_ids:
843 DeletePCU(self.auth, pcu_id)
846 pcus = GetPCUs(self.auth, self.pcu_ids)
847 self.islistequal(pcus, [], 'DeletePCU - check')
849 if self.config.verbose:
850 utils.header("Deleted pcus: %s " % self.pcu_ids)
853 def Nodes(self, n=4):
855 AddNode = self.debug(self.api.AddNode)
856 GetNodes = self.debug(self.api.GetNodes)
857 UpdateNode = self.debug(self.api.UpdateNode)
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
865 # Should return a unique id
866 self.isunique(node_id, node_ids, 'AddNode - isunique')
867 node_ids.append(node_id)
870 nodes = GetNodes(self.auth, [node_id])
871 if nodes is None: continue
873 self.isequal(node, node_fields, 'AddNode - isequal')
876 node_fields = random_node()
877 result = UpdateNode(self.auth, node_id, node_fields)
880 nodes = GetNodes(self.auth, [node_id])
881 if nodes is None: continue
883 self.isequal(node, node_fields, 'UpdateNode - isequal')
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)
891 sites = self.api.GetSites(self.auth, [node['site_id']], ['pcu_ids'])
892 if not sites: continue
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)
899 # check nodegroup, pcu
900 nodes = GetNodes(self.auth, [node_id], ['nodegroup_ids', 'pcu_ids'])
901 if nodes is None or not nodes: continue
903 self.islistequal([nodegroup_id], node['nodegroup_ids'], 'AddNodeToNodeGroup - check')
904 self.islistequal([pcu_id], node['pcu_ids'], 'AddNodeToPCU - check')
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')
910 if self.config.verbose:
911 utils.header("Added nodes: %s" % node_ids)
915 def DeleteNodes(self):
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
923 if node['nodegroup_ids']:
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)
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)
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')
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)
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')
951 if self.config.verbose:
952 utils.header("Deleted nodes: %s" % self.node_ids)
956 def AddressTypes(self, n = 3):
957 address_type_ids = []
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
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)
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')
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
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')
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')
992 if self.config.verbose:
993 utils.header("Added address types: %s " % address_type_ids)
995 return address_type_ids
997 def DeleteAddressTypes(self):
999 DeleteAddressType = self.debug(self.api.DeleteAddressType)
1000 for address_type_id in self.address_type_ids:
1001 DeleteAddressType(self.auth, address_type_id)
1003 GetAddressTypes = self.debug(self.api.GetAddressTypes)
1004 address_types = GetAddressTypes(self.auth, self.address_type_ids)
1005 self.islistequal(address_types, [], 'DeleteAddressType - check')
1007 if self.config.verbose:
1008 utils.header("Deleted address types: %s" % self.address_type_ids)
1010 self.address_type_ids = []
1012 def Addresses(self, n = 3):
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)
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
1024 # Should return a unique address_id
1025 self.isunique(address_id, address_ids, 'AddSiteAddress - isunique')
1026 address_ids.append(address_id)
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')
1035 address_fields = random_address()
1036 result = UpdateAddress(self.auth, address_id, address_fields)
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')
1045 address_type_id = random.sample(self.address_type_ids, 1)[0]
1046 AddAddressTypeToAddress(self.auth, address_type_id, address_id)
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')
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')
1058 if self.config.verbose:
1059 utils.header("Added addresses: %s" % address_ids)
1063 def DeleteAddresses(self):
1065 DeleteAddress = self.debug(self.api.DeleteAddress)
1066 DeleteAddressTypeFromAddress = self.debug(self.api.DeleteAddressTypeFromAddress)
1067 GetAddresses = self.debug(self.api.GetAddresses)
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]
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'])
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')
1084 # Delete site addresses
1085 for address_id in self.address_ids:
1086 result = DeleteAddress(self.auth, address_id)
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)
1094 self.address_ids = []
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)
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
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)
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')
1117 # Update slice_attribute_type
1118 attribute_type_fields = random_attribute_type()
1119 result = UpdateSliceAttributeType(self.auth, attribute_type_id, attribute_type_fields)
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')
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')
1132 if self.config.verbose:
1133 utils.header("Added slice_attribute_types: %s" % attribute_type_ids)
1135 return attribute_type_ids
1137 def DeleteSliceAttributeTypes(self):
1138 DeleteSliceAttributeType = self.debug(self.api.DeleteSliceAttributeType)
1139 GetSliceAttributeTypes = self.debug(self.api.GetSliceAttributeTypes)
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)
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)
1151 self.slice_attribute_type_ids = []
1153 def SliceInstantiations(self, n = 2):
1155 AddSliceInstantiation= self.debug(self.api.AddSliceInstantiation)
1156 GetSliceInstantiations = self.debug(self.api.GetSliceInstantiations)
1160 result = AddSliceInstantiation(self.auth, inst)
1161 if result is None: continue
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')
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')
1177 if self.config.verbose:
1178 utils.header("Added slice instantiations: %s" % insts)
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)
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)
1196 self.slice_instantiations = []
1198 def Slices(self, n = 3):
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)
1206 slice_fields = random_slice()
1207 slice_id = AddSlice(self.auth, slice_fields)
1208 if slice_id is None: continue
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
1216 self.isequal(slice, slice_fields, 'AddSlice - isequal')
1219 slice_fields = random_slice()
1220 result = UpdateSlice(self.auth, slice_id, slice_fields)
1223 slices = GetSlices(self.auth, [slice_id])
1224 if slices is None: continue
1226 self.isequal(slice, slice_fields, 'UpdateSlice - isequal')
1229 node_id = random.sample(self.node_ids, 1)[0]
1230 AddSliceToNodes(self.auth, slice_id, [node_id])
1233 slices = GetSlices(self.auth, [slice_id], ['node_ids'])
1234 if slices is None or not slices: continue
1236 self.islistequal([node_id], slice['node_ids'], 'AddSliceToNode - check')
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')
1242 if self.config.verbose:
1243 utils.header("Added slices: %s" % slice_ids)
1247 def DeleteSlices(self):
1249 GetSlices = self.debug(self.api.GetSlices)
1250 DeleteSlice = self.debug(self.api.DeleteSlice)
1251 DeleteSliceFromNodes = self.debug(self.api.DeleteSliceFromNodes)
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
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])
1264 slices = GetSlices(self.auth, [slice['slice_id']], ['node_ids'])
1265 if slices is None or not slices: return 0
1267 self.islistequal([], slice['node_ids'], 'DeleteSliceFromNode - check')
1269 # Have DeleteSlice automatically delete attriubtes for the rest
1270 for slice_id in self.slice_ids:
1272 DeleteSlice(self.auth, slice_id)
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')
1279 if self.config.verbose:
1280 utils.header("Deleted slices: %s" % self.slice_ids)
1284 def SliceAttributes(self, n = 4):
1286 AddSliceAttribute = self.debug(self.api.AddSliceAttribute)
1287 GetSliceAttributes = self.debug(self.api.GetSliceAttributes)
1288 UpdateSliceAttribute = self.debug(self.api.UpdateSliceAttribute)
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
1299 # Should return a unique id
1300 self.isunique(attribute_id, attribute_ids, 'AddSliceAttribute - isunique')
1301 attribute_ids.append(attribute_id)
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')
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)
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')
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)
1328 return attribute_ids
1330 def DeleteSliceAttributes(self):
1331 DeleteSliceAttribute = self.debug(self.api.DeleteSliceAttribute)
1332 GetSliceAttributes = self.debug(self.api.GetSliceAttributes)
1334 for attribute_id in self.slice_attribute_ids:
1335 DeleteSliceAttribute(self.auth, attribute_id)
1337 attributes = GetSliceAttributes(self.auth, self.slice_attribute_ids)
1338 self.islistequal(attributes, [], 'DeleteSliceAttribute - check')
1340 if self.config.verbose:
1341 utils.header("Deleted slice attributes: %s" % self.slice_attribute_ids)
1343 self.slice_attribute_ids = []
1345 def InitScripts(self, n = 2):
1347 AddInitScript = self.debug(self.api.AddInitScript)
1348 GetInitScripts = self.debug(self.api.GetInitScripts)
1349 UpdateInitScript = self.debug(self.api.UpdateInitScript)
1352 initscript_fields = random_initscript()
1353 initscript_id = AddInitScript(self.auth, initscript_fields)
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')
1364 initscript_fields = random_initscript()
1365 result = UpdateInitScript(self.auth, initscript_id, initscript_fields)
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')
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')
1377 if self.config.verbose:
1378 utils.header("Added initscripts: %s" % initscript_ids)
1380 return initscript_ids
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)
1389 # Check if peers are deleted
1390 initscripts = GetInitScripts(self.auth, self.initscript_ids)
1391 self.islistequal(initscripts, [], 'DeletInitScript - check')
1393 if self.config.verbose:
1394 utils.header("Deleted initscripts: %s" % self.initscript_ids)
1395 self.initscript_ids =[]
1397 def Roles(self, n = 2):
1399 AddRole = self.debug(self.api.AddRole)
1400 GetRoles = self.debug(self.api.GetRoles)
1403 role_fields = random_role()
1404 role_id = role_fields['role_id']
1405 name = role_fields['name']
1406 AddRole(self.auth, role_id, name)
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)
1415 self.isequal(role, role_fields, 'AddRole - isequal')
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')
1422 if self.config.verbose:
1423 utils.header("Added roles: %s" % role_ids)
1427 def DeleteRoles(self):
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)
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)
1439 if self.config.verbose:
1440 utils.header("Deleted roles: %s" % self.role_ids)
1443 def Persons(self, n = 3):
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
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
1461 self.isequal(person, person_fields, 'AddPerson - isequal')
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)
1470 AddRoleToPerson = self.debug(self.api.AddRoleToPerson)
1471 role = random.sample(roles, 1)[0]
1472 result = AddRoleToPerson(self.auth, role, person_id)
1476 key_id = AddPersonKey = self.debug(self.api.AddPersonKey)
1477 AddPersonKey(self.auth, person_id, key)
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)
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)
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
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')
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')
1502 if self.config.verbose:
1503 utils.header("Added users: %s" % person_ids)
1507 def DeletePersons(self):
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
1517 role = random.sample(person['roles'], 1)[0]
1518 DeleteRoleFromPerson = self.debug(self.api.DeleteRoleFromPerson)
1519 DeleteRoleFromPerson(self.auth, role, person['person_id'])
1521 if person['key_ids']:
1523 key_id = random.sample(person['key_ids'], 1)[0]
1524 DeleteKey = self.debug(self.api.DeleteKey)
1525 DeleteKey(self.auth, key_id)
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)
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)
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
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')
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:
1552 DeletePerson(self.auth, person_id)
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')
1559 if self.config.verbose:
1560 utils.header("Deleted users: %s" % self.person_ids)
1562 self.person_ids = []
1564 def KeyTypes(self, n = 2):
1566 AddKeyType = self.debug(self.api.AddKeyType)
1567 GetKeyTypes = self.debug(self.api.GetKeyTypes)
1570 keytype = randstr(10)
1571 result = AddKeyType(self.auth, keytype)
1572 if result is None: continue
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')
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')
1588 if self.config.verbose:
1589 utils.header("Added key types: %s" % key_types)
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)
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')
1604 if self.config.verbose:
1605 utils.header("Deleted key types %s" % self.key_types)
1609 def Keys(self, n = 3):
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
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
1626 self.isequal(key, key_fields, 'AddPersonKey - isequal')
1629 key_fields = random_key()
1630 UpdateKey = self.debug(self.api.UpdateKey)
1631 result = UpdateKey(self.auth, key_id, key_fields)
1633 keys = GetKeys(self.auth, [key_id])
1634 if keys is None or not keys: continue
1636 self.isequal(key, key_fields, 'UpdatePersonKey - isequal')
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')
1642 if self.config.verbose:
1643 utils.header("Added keys: %s" % key_ids)
1647 def DeleteKeys(self):
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)
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')
1659 if self.config.verbose:
1660 utils.header("Blacklisted key: %s" % key_id)
1662 for key_id in self.key_ids:
1663 DeleteKey(self.auth, key_id)
1665 keys = GetKeys(self.auth, self.key_ids)
1666 self.islistequal(keys, [], 'DeleteKey - check')
1668 if self.config.verbose:
1669 utils.header("Deleted keys: %s" % self.key_ids)
1673 def BootStates(self, n = 3):
1675 AddBootState = self.debug(self.api.AddBootState)
1676 GetBootStates = self.debug(self.api.GetBootStates)
1679 bootstate_fields = randstr(10)
1680 result = AddBootState(self.auth, bootstate_fields)
1681 if result is None: continue
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')
1693 bs = GetBootStates(self.auth)
1695 bs = filter(lambda x: x in [boot_states], bs)
1696 self.islistequal(boot_states, bs, 'GetBootStates - isequal')
1698 if self.config.verbose:
1699 utils.header("Added boot_states: %s" % boot_states)
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)
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')
1714 if self.config.verbose:
1715 utils.header("Deleted boot_states: %s" % self.boot_states)
1717 self.boot_states = []
1720 def Peers(self, n = 2):
1722 AddPeer = self.debug(self.api.AddPeer)
1723 GetPeers = self.debug(self.api.GetPeers)
1724 UpdatePeer = self.debug(self.api.UpdatePeer)
1727 peer_fields = random_peer()
1728 peer_id = AddPeer(self.auth, peer_fields)
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
1736 self.isequal(peer, peer_fields, 'AddPeer - isequal')
1739 peer_fields = random_peer()
1740 result = UpdatePeer(self.auth, peer_id, peer_fields)
1743 peers = GetPeers(self.auth, [peer_id])
1744 if peers is None: continue
1746 self.isequal(peer, peer_fields, 'UpdatePeer - isequal')
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')
1752 if self.config.verbose:
1753 utils.header("Added peers: %s" % peer_ids)
1758 def DeletePeers(self):
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)
1765 # Check if peers are deleted
1766 peers = GetPeers(self.auth, self.peer_ids)
1767 self.islistequal(peers, [], 'DeletePeer - check' % self.peer_ids)
1769 if self.config.verbose:
1770 utils.header("Deleted peers: %s" % self.peer_ids)
1773 def ConfFiles(self, n = 2):
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
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)
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')
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)
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')
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)
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)
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')
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)
1830 return conf_file_ids
1832 def DeleteConfFiles(self):
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)
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)
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')
1856 for conf_file_id in self.conf_file_ids:
1857 DeleteConfFile(self.auth, conf_file_id)
1860 conf_files = GetConfFiles(self.auth, self.conf_file_ids)
1861 self.islistequal(conf_files, [], 'DeleteConfFile - check')
1863 if self.config.verbose:
1864 utils.header("Deleted conf_files: %s" % self.conf_file_ids)
1866 self.conf_file_ids = []
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)
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
1881 # Should return a unique id
1882 self.isunique(nodenetwork_ids, nodenetwork_ids, 'AddNodeNetwork - isunique')
1883 nodenetwork_ids.append(nodenetwork_id)
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')
1891 # Update NodeNetwork
1892 nodenetwork_fields = random_nodenetwork()
1893 UpdateNodeNetwork(self.auth, nodenetwork_id, nodenetwork_fields)
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')
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')
1905 if self.config.verbose:
1906 utils.header('Added nodenetworks: %s' % nodenetwork_ids)
1908 return nodenetwork_ids
1910 def DeleteNodeNetworks(self):
1911 GetNodeNetworks = self.debug(self.api.GetNodeNetworks)
1912 DeleteNodeNetwork = self.debug(self.api.DeleteNodeNetwork)
1914 for nodenetwork_id in self.nodenetwork_ids:
1915 DeleteNodeNetwork(self.auth, nodenetwork_id)
1918 nodenetworks = GetNodeNetworks(self.auth, self.nodenetwork_ids)
1919 self.islistequal(nodenetworks, [], 'DeleteNodeNetwork - check')
1921 if self.config.verbose:
1922 utils.header("Deleted nodenetworks: %s " % self.nodenetwork_ids)
1923 self.nodenetwork_ids = []
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)
1931 for nodenetwork_id in self.nodenetwork_ids:
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
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)
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')
1950 # Update NodeNetworkSetting
1951 nodenetwork_setting_fields = random_nodenetwork_setting()
1952 value = nodenetwork_setting_fields['value']
1953 UpdateNodeNetworkSetting(self.auth, nodenetwork_setting_id, value)
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')
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')
1965 if self.config.verbose:
1966 utils.header('Added nodenetwork_settings: %s' % nodenetwork_setting_ids)
1968 return nodenetwork_setting_ids
1970 def DeleteNodeNetworkSettings(self):
1971 GetNodeNetworkSettings = self.debug(self.api.GetNodeNetworkSettings)
1972 DeleteNodeNetworkSetting = self.debug(self.api.DeleteNodeNetworkSetting)
1974 for nodenetwork_setting_id in self.nodenetwork_setting_ids:
1975 DeleteNodeNetworkSetting(self.auth, nodenetwork_setting_id)
1978 nodenetwork_settings = GetNodeNetworkSettings(self.auth, self.nodenetwork_setting_ids)
1979 self.islistequal(nodenetwork_settings, [], 'DeleteNodeNetworkSetting - check')
1981 if self.config.verbose:
1982 utils.header("Deleted nodenetwork settings: %s " % self.nodenetwork_setting_ids)
1983 self.nodenetwork_setting_ids = []
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)
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
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)
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')
2007 # Update NodeNetworkSetting
2008 nodenetwork_setting_type_fields = random_nodenetwork_setting_type()
2009 UpdateNodeNetworkSettingType(self.auth, nodenetwork_setting_type_id, nodenetwork_setting_type_fields)
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')
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')
2021 if self.config.verbose:
2022 utils.header('Added nodenetwork_setting_types: %s' % nodenetwork_setting_type_ids)
2024 return nodenetwork_setting_type_ids
2026 def DeleteNodeNetworkSettingTypes(self):
2027 GetNodeNetworkSettingTypes = self.debug(self.api.GetNodeNetworkSettingTypes)
2028 DeleteNodeNetworkSettingType = self.debug(self.api.DeleteNodeNetworkSettingType)
2030 for nodenetwork_setting_type_id in self.nodenetwork_setting_type_ids:
2031 DeleteNodeNetworkSettingType(self.auth, nodenetwork_setting_type_id)
2034 nodenetwork_setting_types = GetNodeNetworkSettingTypes(self.auth, self.nodenetwork_setting_type_ids)
2035 self.islistequal(nodenetwork_setting_types, [], 'DeleteNodeNetworkSettingType - check')
2037 if self.config.verbose:
2038 utils.header("Deleted nodenetwork setting types: %s " % self.nodenetwork_setting_type_ids)
2039 self.nodenetwork_setting_type_ids = []
2041 def Messages(self, n = 2):
2043 AddMessage = self.debug(self.api.AddMessage)
2044 GetMessages = self.debug(self.api.GetMessages)
2045 UpdateMessage = self.debug(self.api.UpdateMessage)
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
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')
2062 message_fields = random_message()
2063 result = UpdateMessage(self.auth, message_id, message_fields)
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')
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')
2075 if self.config.verbose:
2076 utils.header("Added messages: %s" % message_ids)
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)
2087 # Check if messages are deleted
2088 messages = GetMessages(self.auth, self.message_ids)
2089 self.islistequal(messages, [], 'DeleteMessage - check')
2091 if self.config.verbose:
2092 utils.header("Deleted messages: %s" % self.message_ids)
2094 self.message_ids = []
2096 def Sessions(self, n = 2):
2098 AddSession = self.debug(self.api.AddSession)
2099 GetSession = self.debug(self.api.GetSession)
2100 GetSessions = self.debug(self.api.GetSessions)
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)
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')
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)
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')
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')
2133 if self.config.verbose:
2134 utils.header("Added sessions: %s" % session_ids)
2138 def DeleteSessions(self):
2139 DeleteSession = self.debug(self.api.DeleteSession)
2140 GetSessions = self.debug(self.api.GetSessions)
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]
2148 'session': session['session_id'],
2149 'AuthMethod': 'session'
2152 DeleteSession(tmpauth)
2154 # Check if sessions are deleted
2155 sessions = GetSessions(self.auth, self.session_ids)
2156 self.islistequal(sessions, [], 'DeleteBootState check')
2158 if self.config.verbose:
2159 utils.header("Deleted sessions: %s" % self.session_ids)
2161 self.session_ids = []
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)
2168 nodes = GetNodes(self.auth, self.node_ids)
2169 nodes = filter(lambda n: n['nodenetwork_ids'], nodes)
2170 if not nodes: return 0
2172 nodenetworks = GetNodeNetworks(self.auth, node['nodenetwork_ids'])
2173 nodenetwork = nodenetworks[0]
2174 parts = node['hostname'].split(".", 1)
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'],
2189 'DOMAIN_NAME': domain
2191 node_config_file = GenerateNodeConfFile(self.auth, node['node_id'])
2192 self.isequal(node_config_file, node_config, 'GenerateNodeConfFile - isequal')
2194 if self.config.verbose:
2195 utils.header("GenerateNodeConfFile")
2197 def GetBootMedium(self):
2201 def GetEventObjects(self):
2202 GetEventObjects = self.debug(self.api.GetEventObjects)
2203 GetEventObjects(self.auth)
2205 if self.config.verbose:
2206 utils.header("GetEventObjects")
2208 def GetEvents(self):
2209 GetEvents = self.debug(self.api.GetEvents)
2210 GetEvents(self.auth)
2212 if self.config.verbose:
2213 utils.header("GetEvents")
2215 def GetPeerData(self):
2216 GetPeers = self.debug(self.api.GetPeers)
2217 GetPeerData = self.debug(self.api.GetPeerData)
2219 peers = GetPeers(self.auth)
2220 if peers is None or not peers: return 0
2222 peer_data = GetPeerData(self.auth)
2224 # Manuall construt peer data
2226 if self.config.verbose:
2227 utils.header("GetPeerData")
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')
2235 if self.config.verbose:
2236 utils.header("GetPeerName")
2238 def GetPlcRelease(self):
2239 GetPlcRelease = self.debug(self.api.GetPlcRelease)
2240 plc_release = GetPlcRelease(self.auth)
2242 if self.config.verbose:
2243 utils.header("GetPlcRelease")
2245 def GetSliceKeys(self):
2246 GetSliceKeys = self.debug(self.api.GetSliceKeys)
2247 GetSlices = self.debug(self.api.GetSlices)
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
2255 slice_keys = GetSliceKeys(self.auth, [slice['slice_id']])
2256 # XX Manually construct slice_keys for this slice and compare
2258 if self.config.verbose:
2259 utils.header("GetSliceKeys(%s)" % [slice['slice_id']])
2261 def GetSliceTicket(self):
2262 GetSliceTicket = self.debug(self.api.GetSliceTicket)
2264 slice_id = random.sample(self.slice_ids, 1)[0]
2265 slice_ticket = GetSliceTicket(self.auth, slice_id)
2267 if self.config.verbose:
2268 utils.header("GetSliceTicket(%s)" % slice_id)
2270 def GetSlicesMD5(self):
2271 GetSlicesMD5 = self.debug(self.api.GetSlicesMD5)
2273 slices_md5 = GetSlicesMD5(self.auth)
2275 if self.config.verbose:
2276 utils.header("GetSlicesMD5")
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
2287 slivers = GetSlivers(self.auth, node['node_id'])
2289 # XX manually create slivers object and compare
2291 if self.config.verbose:
2292 utils.header("GetSlivers(%s)" % node['node_id'])
2294 def GetWhitelist(self):
2295 GetWhitelist = self.debug(self.api.GetWhitelist)
2296 GetNodes = self.debug(self.api.GetNodes)
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')
2304 if self.config.verbose:
2305 utils.header("GetWhitelist")
2307 def NotifyPersons(self):
2308 NotifyPersons = self.debug(self.api.NotifyPersons)
2309 person_id = random.sample(self.person_ids, 1)[0]
2311 NotifyPersons(self.auth, [person_id], 'QA Test', 'Welcome')
2313 if self.config.verbose:
2314 utils.header('NotifyPersons(%s)' % [person_id])
2316 def NotifySupport(self):
2317 NotifySupport = self.debug(self.api.NotifySupport)
2318 NotifySupport(self.auth, 'QA Test', 'Support Request')
2320 if self.config.verbose:
2321 utils.header('NotifSupport')
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)
2328 if self.config.verbose:
2329 utils.header('RebootNode(%s)' % node_id)
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)
2336 if self.config.verbose:
2337 utils.header('ResetPassword(%s)' % person_id)
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
2346 site_id = random.sample(person['site_ids'], 1)[0]
2347 SetPersonPrimarySite(self.auth, person_id, site_id)
2349 if self.config.verbose:
2350 utils.header('SetPersonPrimarySite(%s, %s)' % (person_id, site_id))
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)
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
2362 UpdatePerson(self.auth, person['person_id'], {'enabled': False})
2363 VerifyPerson(self.auth, person['person_id'])
2365 if self.config.verbose:
2366 utils.header('VerifyPerson(%s)' % person_id)
2368 if __name__ == '__main__':
2369 args = tuple(sys.argv[1:])
2370 api_unit_test()(*args)