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