Test.py

   1 #!/usr/bin/env ./Shell.py
   2 #
   3 # Test script example
   4 #
   5 # Mark Huang <mlhuang@cs.princeton.edu>
   6 # Copyright (C) 2006 The Trustees of Princeton University
   7 #
   8 # $Id: Shell.py,v 1.2 2006/09/06 19:17:25 mlhuang Exp $
   9 #
  10
  11 from pprint import pprint
  12 from string import letters, digits, punctuation
  13
  14 from random import Random
  15 random = Random()
  16
  17 import re
  18
  19 def randfloat(min = 0.0, max = 1.0):
  20     return float(min) + (random.random() * (float(max) - float(min)))
  21
  22 def randint(min = 0, max = 1):
  23     return int(randfloat(min, max + 1))
  24
  25 # See "2.2 Characters" in the XML specification:
  26 #
  27 # #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD]
  28 # avoiding
  29 # [#x7F-#x84], [#x86-#x9F], [#xFDD0-#xFDDF]
  30
  31 valid_xml_chars  = map(unichr, [0x9, 0xA, 0xD])
  32 valid_xml_chars += map(unichr, xrange(0x20, 0x7F - 1))
  33 valid_xml_chars += map(unichr, xrange(0x84 + 1, 0x86 - 1))
  34 valid_xml_chars += map(unichr, xrange(0x9F + 1, 0xD7FF))
  35 valid_xml_chars += map(unichr, xrange(0xE000, 0xFDD0 - 1))
  36 valid_xml_chars += map(unichr, xrange(0xFDDF + 1, 0xFFFD))
  37
  38 def randstr(length, pool = valid_xml_chars):
  39     sample = random.sample(pool, length)
  40     return u''.join(sample)
  41
  42 def randhostname():
  43     # 1. Each part begins and ends with a letter or number.
  44     # 2. Each part except the last can contain letters, numbers, or hyphens.
  45     # 3. Each part is between 1 and 64 characters, including the trailing dot.
  46     # 4. At least two parts.
  47     # 5. Last part can only contain between 2 and 6 letters.
  48     hostname = 'a' + randstr(61, letters + digits + '-') + '1.' + \
  49                'b' + randstr(61, letters + digits + '-') + '2.' + \
  50                'c' + randstr(5, letters)
  51     return hostname
  52
  53 def unicmp(a, b, encoding = "utf-8"):
  54     """
  55     When connected directly to the DB, values are returned as raw
  56     8-bit strings that may need to be decoded (as UTF-8 by default) in
  57     order to compare them against expected Python Unicode strings.
  58     """
  59
  60     is8bit = re.compile("[\x80-\xff]").search
  61     if isinstance(a, str) and is8bit(a):
  62         a = unicode(a, encoding)
  63     if isinstance(b, str) and is8bit(b):
  64         b = unicode(b, encoding)
  65     return a == b
  66
  67 admin = {'AuthMethod': "capability",
  68          'Username': config.PLC_API_MAINTENANCE_USER,
  69          'AuthString': config.PLC_API_MAINTENANCE_PASSWORD,
  70          'Role': "admin"}
  71
  72 user = {'AuthMethod': "password",
  73         'Role': "user"}
  74
  75 pi = {'AuthMethod': "password",
  76       'Role': "pi"}
  77
  78 tech = {'AuthMethod': "password",
  79         'Role': "tech"}
  80
  81 # Add sites
  82 site_ids = []
  83 for i in range(3):
  84     name = randstr(50)
  85     abbreviated_name = randstr(10)
  86     login_base = randstr(10, letters).lower()
  87     latitude = int(randfloat(-90.0, 90.0) * 1000) / 1000.0
  88     longitude = int(randfloat(-180.0, 180.0) * 1000) / 1000.0
  89
  90     # Add site
  91     print "AdmAddSite(%s)" % login_base,
  92     site_id = AdmAddSite(admin, name, abbreviated_name, login_base,
  93                          {'latitude': latitude, 'longitude': longitude})
  94
  95     # Should return a unique site_id
  96     assert site_id not in site_ids
  97     site_ids.append(site_id)
  98     print "=>", site_id
  99
 100     print "AdmGetSites(%d)" % site_id,
 101     site = AdmGetSites(admin, [site_id])[0]
 102     for key in 'name', 'abbreviated_name', 'login_base', 'latitude', 'longitude', 'site_id':
 103         assert unicmp(site[key], locals()[key])
 104     print "=> OK"
 105
 106 print "AdmGetSites",
 107 sites = AdmGetSites(admin, site_ids)
 108 assert set(site_ids) == set([site['site_id'] for site in sites])
 109 print "=>", site_ids
 110
 111 print "AdmGetAllRoles",
 112 role_ids = AdmGetAllRoles(admin)
 113 roles = dict(zip(role_ids.values(), map(int, role_ids.keys())))
 114 print "=>", role_ids
 115
 116 # Add users
 117 person_ids = []
 118 for auth in user, pi, tech:
 119     # XXX Figure out what the actual maximum is if high characters are
 120     # used.
 121     first_name = randstr(10)
 122     last_name = randstr(20)
 123     email = randstr(10, letters + digits) + "@" + randhostname()
 124     bio = randstr(50)
 125     # Accounts are disabled by default
 126     enabled = False
 127
 128     auth['Username'] = email
 129     # XXX md5crypt cannot handle Unicode strings for some reason
 130     auth['AuthString'] = str(randstr(16, letters))
 131
 132     print "AdmAddPerson(%s)" % email,
 133     person_id = AdmAddPerson(admin, first_name, last_name,
 134                              {'email': email, 'bio': bio,
 135                               'password': auth['AuthString']})
 136
 137     # Should return a unique person_id
 138     assert person_id not in person_ids
 139     person_ids.append(person_id)
 140     print "=>", person_id
 141
 142     # Check account
 143     print "AdmGetPersons(%d)" % person_id,
 144     person = AdmGetPersons(admin, [person_id])[0]
 145     for key in 'first_name', 'last_name', 'bio', 'person_id', 'enabled':
 146         assert unicmp(person[key], locals()[key])
 147     print "=> OK"
 148
 149     # Enable account
 150     print "AdmSetPersonEnabled(%d, True)" % person_id,
 151     AdmSetPersonEnabled(admin, person_id, True)
 152     person = AdmGetPersons(admin, [person_id])[0]
 153     assert person['enabled']
 154     print "=> OK"
 155
 156     # Add role
 157     role_id = roles[auth['Role']]
 158     print "AdmGrantRoleToPerson(%d, %d)" % (person_id, role_id),
 159     AdmGrantRoleToPerson(admin, person_id, role_id)
 160     print "=> OK"
 161
 162     print "AdmGetPersonRoles(%d)" % person_id,
 163     person_roles = AdmGetPersonRoles(admin, person_id)
 164     person_role_ids = map(int, person_roles.keys())
 165     assert [role_id] == person_role_ids
 166     person = AdmGetPersons(admin, [person_id])[0]
 167     assert [role_id] == person['role_ids']
 168     print "=>", person_role_ids
 169
 170     # Associate account with each site
 171     for site_id in site_ids:
 172         print "AdmAddPersonToSite(%d, %d)" % (person_id, site_id),
 173         AdmAddPersonToSite(admin, person_id, site_id)
 174         print "=> OK"
 175
 176     # Make sure it really did it
 177     print "AdmGetPersonSites(%d)" % person_id,
 178     person_site_ids = AdmGetPersonSites(auth, person_id)
 179     assert set(site_ids) == set(person_site_ids)
 180     person = AdmGetPersons(admin, [person_id])[0]
 181     assert set(site_ids) == set(person['site_ids'])
 182     print "=>", person_site_ids
 183
 184     # First site should be the primary site
 185     print "AdmSetPersonPrimarySite(%d, %d)" % (person_id, person_site_ids[1]),
 186     AdmSetPersonPrimarySite(auth, person_id, person_site_ids[1])
 187     assert AdmGetPersonSites(auth, person_id)[0] == person_site_ids[1]
 188     person = AdmGetPersons(admin, [person_id])[0]
 189     assert person['site_ids'][0] == person_site_ids[1]
 190     print "=> OK"
 191
 192 print "AdmGetPersons",
 193 persons = AdmGetPersons(admin, person_ids)
 194 assert set(person_ids) == set([person['person_id'] for person in persons])
 195 print "=>", person_ids
 196
 197 # Add nodes
 198 node_ids = []
 199 for site_id in site_ids:
 200     for i in range(3):
 201         hostname = randhostname()
 202         boot_state = 'inst'
 203         model = randstr(32)
 204
 205         # Add node
 206         print "AdmAddNode(%s)" % hostname,
 207         node_id = AdmAddNode(admin, site_id, hostname, boot_state,
 208                              {'model': model})
 209
 210         # Should return a unique node_id
 211         assert node_id not in node_ids
 212         node_ids.append(node_id)
 213         print "=>", node_id
 214
 215         # Check node
 216         print "AdmGetNodes(%d)" % node_id,
 217         node = AdmGetNodes(admin, [node_id])[0]
 218         for key in 'hostname', 'boot_state', 'model', 'node_id':
 219             assert unicmp(node[key], locals()[key])
 220         print "=> OK"
 221
 222     # XXX AdmGetSiteNodes
 223
 224 print "AdmGetNodes",
 225 nodes = AdmGetNodes(admin, node_ids)
 226 assert set(node_ids) == set([node['node_id'] for node in nodes])
 227 print "=>", node_ids
 228
 229 # Delete nodes
 230 for node_id in node_ids:
 231     print "AdmDeleteNode(%d)" % node_id,
 232     AdmDeleteNode(admin, node_id)
 233     assert not AdmGetNodes(admin, [node_id])
 234
 235     # Make sure it really deleted it
 236     nodes = AdmGetNodes(admin, node_ids)
 237     assert node_id not in [node['node_id'] for node in nodes]
 238     print "=> OK"
 239
 240 print "AdmGetNodes",
 241 assert not AdmGetNodes(admin, node_ids)
 242 print "=> []"
 243
 244 # Delete users
 245 for person_id in person_ids:
 246     # Remove from each site
 247     for site_id in site_ids:
 248         print "AdmRemovePersonFromSite(%d, %d)" % (person_id, site_id),
 249         AdmRemovePersonFromSite(admin, person_id, site_id)
 250         assert site_id not in AdmGetPersonSites(admin, person_id)
 251         person = AdmGetPersons(admin, [person_id])[0]
 252         assert site_id not in person['site_ids']
 253         print "=> OK"
 254
 255     assert not AdmGetPersonSites(admin, person_id)
 256
 257     # Revoke role
 258     person_roles = AdmGetPersonRoles(admin, person_id)
 259     role_id = int(person_roles.keys()[0])
 260     print "AdmRevokeRoleFromPerson(%d, %d)" % (person_id, role_id),
 261     AdmRevokeRoleFromPerson(admin, person_id, role_id)
 262     assert not AdmGetPersonRoles(admin, person_id)
 263     person = AdmGetPersons(admin, [person_id])[0]
 264     assert not person['role_ids']
 265     print "=> OK"
 266
 267     # Disable account
 268     print "AdmSetPersonEnabled(%d, False)" % person_id,
 269     AdmSetPersonEnabled(admin, person_id, False)
 270     person = AdmGetPersons(admin, [person_id])[0]
 271     assert not person['enabled']
 272     print "=> OK"
 273
 274     # Delete account
 275     print "AdmDeletePerson(%d)" % person_id,
 276     AdmDeletePerson(admin, person_id)
 277     assert not AdmGetPersons(admin, [person_id])
 278     print "=> OK"
 279
 280 print "AdmGetPersons",
 281 assert not AdmGetPersons(admin, person_ids)
 282 print "=> []"
 283
 284 # Delete sites
 285 for site_id in site_ids:
 286     print "AdmDeleteSite(%d)" % site_id,
 287     AdmDeleteSite(admin, site_id)
 288     assert not AdmGetSites(admin, [site_id])
 289     print "=> OK"
 290
 291 print "AdmGetSites",
 292 assert not AdmGetSites(admin, site_ids)
 293 print "=> []"