def grant(privilege, role, db):
'grant a privilege to a role'
r = RoleHasPrivilege()
r.privilege = privilege
r.role = role
db.insertRow(r)
return
def join(member, group, db):
'make the give role (member) as a member of the given group'
r = RoleHasRole()
r.group = group
r.member = member
db.insertRow(r)
return
def test1(self):
'dsaw.db.Psycopg2: double type'
db = self.dbManager()
# declare tables
from dsaw.db.WithID import WithID
class DoubleTest(WithID):
name = 'doubletest'
import dsaw.db
d = dsaw.db.double(name='d')
r = dsaw.db.real(name='r')
db.registerTable(DoubleTest)
db.createAllTables()
t1 = DoubleTest()
t1.id = 't1'
import math
t1.r = t1.d = math.pi
db.insertRow(t1)
print t1.r, t1.d
self.assertAlmostEqual(t1.r, math.pi, 5)
self.assertNotAlmostEqual(t1.r, math.pi, 10)
self.assertAlmostEqual(t1.d, math.pi, 10)
t1.d = math.e
db.updateRecord(t1)
db.destroyAllTables()
return
def assign(role, user, db):
'assign a role to a user'
r = UserHasRole()
r.user = user
r.role = role
db.insertRow(r)
return
def test5(self):
'dsaw.db: make sure globalpointer is left blank when a record is created'
db = self.dbManager()
# declare tables
from dsaw.db.WithID import WithID
from dsaw.db.GloballyReferrable import GloballyReferrable
class User(WithID, GloballyReferrable):
name = 'users'
import dsaw.db
username = dsaw.db.varchar(name='username', length=100)
# register and initialize
tables = [User]
for table in tables: db.registerTable(table)
db.createAllTables()
# insert a record
bob = User()
bob.id = bob.username = '******'
db.insertRow(bob)
# read
bob1 = db.query(User).filter_by(id=bob.id).one()
self.assertEqual(bob1.globalpointer, None)
# destroy
db.destroyAllTables()
return
def test1(self):
'dsaw.db.Psycopg2: integer array type'
db = self.dbManager()
# declare tables
from dsaw.db.WithID import WithID
class IntegerArrayTest(WithID):
name = 'integerarraytest'
import dsaw.db
arr = dsaw.db.integerArray(name='arr')
db.registerTable(IntegerArrayTest)
db.createAllTables()
t1 = IntegerArrayTest()
t1.id = 't1'
t1.arr = [1, 2]
db.insertRow(t1)
t1.arr = [3, 4]
db.updateRecord(t1)
db.destroyAllTables()
return
def test2(self):
'dsaw.db.Psycopg2: normal table'
db = self.dbManager()
# init system tables
db.createSystemTables()
from dsaw.db.WithID import WithID
class Table1(WithID):
name = 'table1'
import dsaw.db
greeting = dsaw.db.varchar(name='greeting', length=100)
db.createTable(Table1)
# insert record
row = Table1()
row.greeting = 'hello'
row.id = 'first'
db.insertRow(row)
# fetch it
rows = db.fetchall(Table1, where="id='%s'" % row.id)
self.assertEqual(len(rows), 1)
row1 = rows[0]
self.assertEqual(row1.greeting, row.greeting)
db.dropTable(Table1)
# remove system tables
db.destroySystemTables()
return
def test1(self):
'dsaw.db.ReferenceSet: '
# create table
from dsaw.db.WithID import WithID
class Test(WithID):
name = "test"
import dsaw.db
# add more columns
import dsaw.db
address = dsaw.db.varchar(name='address', length=16)
Test.addColumn(address)
#
db = self.db
# create table
db.registerTable(Test)
db.createAllTables()
# create new record
t = Test()
t.id = '111'
t.address = 'abc'
db.insertRow(t)
# load from db and compare
t1 = db.query(Test).filter_by(id=t.id).one()
self.assertEqual(t.address, t1.address)
return
def test4(self):
'dsaw.db: DBManager.getUniqueIdentifierStr and DBManager.fetchRecordUsingUniqueIdentifierStr'
db = self.dbManager()
# declare tables
from dsaw.db.WithID import WithID
class User(WithID):
name = 'users'
import dsaw.db
username = dsaw.db.varchar(name='username', length=100)
# register and initialize
tables = [User]
for table in tables: db.registerTable(table)
db.createAllTables()
# insert a record
bob = User()
bob.id = bob.username = '******'
db.insertRow(bob)
#
uidstr = db.getUniqueIdentifierStr(bob)
bob1 = db.fetchRecordUsingUniqueIdentifierStr(uidstr)
assert bob1.id == bob.id
assert bob1.username == bob.username
# destroy
db.destroyAllTables()
return
def test1(self):
'add, delete users'
db = self.db
# insert records
userbob = User()
userbob.id = userbob.username = '******'
db.insertRow(userbob)
group = Group()
group.id = 'group1'
db.insertRow(group)
refset = group.users
users = refset.dereference( db )
self.assertEqual(len(users), 0)
print '> add one user'
refset.add( userbob, db, name='1' )
users = refset.dereference( db )
self.assertEqual(len(users), 1)
print '> delete one user'
refset.delete( userbob, db )
users = refset.dereference( db )
self.assertEqual(len(users), 0)
return
def grant(privilege, role, db):
'grant a privilege to a role'
r = RoleHasPrivilege()
r.privilege = privilege
r.role = role
db.insertRow(r)
return
def test1(self):
'dsaw.db.pickler: basic table'
self.removeDB()
user1 = User()
user1.id = 1
user1.username = '******'
db = self.dbManager()
db.createTable(User)
db.insertRow(user1)
db.commit()
from dsaw.db.Pickler import Pickler
outdir = 'pickle-test1-out'
if os.path.exists(outdir):
shutil.rmtree(outdir)
pickler = Pickler(db, outdir)
pickler.dump(User)
import pickle
pkl = os.path.join(outdir, User.getTableName())
tablename, fields, records = pickle.load(open(pkl))
self.assertEqual(tablename, User.getTableName())
self.assertEqual(fields, tuple(user1.getColumnNames()))
self.assertEqual(records[0][0],
user1.getColumnValue(user1.getColumnNames()[0]))
# resolve order
resolve_order = open(
os.path.join(outdir, Pickler.resolve_order_filename)).read()
resolve_order = resolve_order.splitlines()
self.assertEqual(resolve_order, ['users'])
return
def assign(role, user, db):
'assign a role to a user'
r = UserHasRole()
r.user = user
r.role = role
db.insertRow(r)
return
def test1(self):
'dsaw.db.Psycopg2: varchar array type'
db = self.dbManager()
# declare tables
from dsaw.db.WithID import WithID
class VarCharArrayTest(WithID):
name = 'varchararraytest'
import dsaw.db
arr = dsaw.db.varcharArray(name='arr', length=10)
db.registerTable(VarCharArrayTest)
db.createAllTables()
t1 = VarCharArrayTest()
t1.id = 't1'
t1.arr = ['a', 'b', 'c']
db.insertRow(t1)
t1.arr = ['hello', 'world']
db.updateRecord(t1)
db.destroyAllTables()
return
def test3(self):
'dsaw.db.pickler: table with a column being versatile reference'
self.removeDB()
# create tables and insert rows
tables = [global_pointer, Cylinder, Sample]
cyl1 = Cylinder()
cyl1.id = 3
sample1 = Sample()
sample1.shape = cyl1
sample1.id = 5
records = [
cyl1,
sample1,
]
db = self.dbManager()
for t in tables:
db.createTable(t)
for r in records:
db.insertRow(r)
db.commit()
# pickle
from dsaw.db.Pickler import Pickler
outdir = 'pickle-test3-out'
if os.path.exists(outdir):
shutil.rmtree(outdir)
pickler = Pickler(db, outdir)
pickler.dump(tables=tables)
# load and compare
import pickle
# Cylinder
pkl = os.path.join(outdir, Cylinder.getTableName())
tablename, fields, records = pickle.load(open(pkl))
self.assertEqual(tablename, Cylinder.getTableName())
self.assertEqual(fields, tuple(cyl1.getColumnNames()))
self.assertEqual(records[0][0], cyl1.globalpointer.id)
# Sample
pkl = os.path.join(outdir, Sample.getTableName())
tablename, fields, records = pickle.load(open(pkl))
self.assertEqual(tablename, Sample.getTableName())
self.assertEqual(fields, tuple(sample1.getColumnNames()))
self.assertEqual(records[0][1], sample1.id)
self.assertEqual(records[0][0], cyl1.globalpointer.id)
# resolve order
resolve_order = open(
os.path.join(outdir, Pickler.resolve_order_filename)).read()
resolve_order = resolve_order.splitlines()
self.assertEqual(resolve_order,
['global_pointers', 'cylinders', 'samples'])
return
def test2(self):
'dsaw.db.pickler: table with a column being reference'
self.removeDB()
tables = [User, Simulation]
user1 = User()
user1.id = 1
user1.username = '******'
sim1 = Simulation()
sim1.creator = user1
sim1.id = 5
records = [
user1,
sim1,
]
db = self.dbManager()
for t in tables:
db.createTable(t)
for r in records:
db.insertRow(r)
db.commit()
from dsaw.db.Pickler import Pickler
outdir = 'pickle-test2-out'
if os.path.exists(outdir):
shutil.rmtree(outdir)
pickler = Pickler(db, outdir)
pickler.dump(Simulation)
# load and compare
import pickle
# User
pkl = os.path.join(outdir, User.getTableName())
tablename, fields, records = pickle.load(open(pkl))
self.assertEqual(tablename, User.getTableName())
self.assertEqual(fields, tuple(user1.getColumnNames()))
self.assertEqual(records[0][0],
user1.getColumnValue(user1.getColumnNames()[0]))
# Simulation
pkl = os.path.join(outdir, Simulation.getTableName())
tablename, fields, records = pickle.load(open(pkl))
self.assertEqual(tablename, Simulation.getTableName())
self.assertEqual(fields, tuple(sim1.getColumnNames()))
self.assertEqual(records[0][0], sim1.id)
self.assertEqual(records[0][1], user1.id)
# resolve order
resolve_order = open(
os.path.join(outdir, Pickler.resolve_order_filename)).read()
resolve_order = resolve_order.splitlines()
self.assertEqual(resolve_order, ['users', 'simulations'])
return
def markResultFileStatusAndErrorMessage(self, filename, db, status, message=None):
message_len = _ComputationResultRetrievals.message.length
gp = self.globalpointer
gp = gp and gp.id
if not gp:
# no global address yet, means need new entry
neednewentry = True
else:
# look for the entries
where = "computation=%s and filename='%s'" % (gp, filename)
rs = db.query(_ComputationResultRetrievals).filter(where).all()
db.commit()
if len(rs) == 0:
# no entry, need one
neednewentry = True
elif len(rs) > 1:
# more than one entries, error
raise RuntimeError, \
"multiple entries in table %s for computation %s(%s), filename %s" % (
_ComputationResultRetrievals.getTableName(),
self.getTableName(), self.id,
filename)
else:
# found one entry
neednewentry = False
r = rs[0]
if neednewentry:
# create a new entry
r = _ComputationResultRetrievals()
r.computation = self
#db.insertRow(r)
r.status = status
#db.updateRecord(r)
r.filename = filename
#db.updateRecord(r)
if message is not None:
r.message = message[:message_len]
#db.updateRecord(r)
db.insertRow(r)
return
# update entry
r.status = status
if message is not None:
r.message = message[:message_len]
db.updateRecord(r)
return
def test3b(self):
'dsaw.db.Psycopg2: table with reference. catch dangling reference'
db = self.dbManager()
# declare tables
from dsaw.db.WithID import WithID
class User(WithID):
name = 'users'
import dsaw.db
username = dsaw.db.varchar(name='username', length=100)
class Greeting(WithID):
name = 'greetings'
import dsaw.db
greeting = dsaw.db.varchar(name='greeting', length=100)
who = dsaw.db.reference(name='who', table=User)
tables = [User, Greeting]
# init system tables
db.createSystemTables()
#
for table in tables:
db.createTable(table)
# create a user
user = User()
user.id = user.username = '******'
db.insertRow(user)
# create a greeting
greeting = Greeting()
greeting.who = user
greeting.greeting = 'hello'
greeting.id = 'greeting1'
db.insertRow(greeting)
# delete user would leave a dangling reference
self.assertRaises(db.RecordStillReferred, db.deleteRecord, user)
#
tables.reverse()
for table in tables:
db.dropTable(table)
#
db.destroySystemTables()
return
def inittable(db):
def new( id, samplecomponent):
r = SampleComponentExample()
r.id = id
r.samplecomponent = samplecomponent
return r
records = [
new('vanadiumplate-000001: samplecomp example 1',
'vanadiumplates###vanadiumplate-000001'),
]
for r in records: db.insertRow( r )
return
def inittable(db):
def new(id, samplecomponent):
r = SampleComponentExample()
r.id = id
r.samplecomponent = samplecomponent
return r
records = [
new('vanadiumplate-000001: samplecomp example 1',
'vanadiumplates###vanadiumplate-000001'),
]
for r in records:
db.insertRow(r)
return
def test3(self):
'dsaw.db.Psycopg2: table with reference'
db = self.dbManager()
from dsaw.db.WithID import WithID
class User(WithID):
name = 'users'
import dsaw.db
username = dsaw.db.varchar(name='username', length=100)
class Greeting(WithID):
name = 'greetings'
import dsaw.db
greeting = dsaw.db.varchar(name='greeting', length=100)
who = dsaw.db.reference(name='who', table=User)
tables = [User, Greeting]
# init system tables
db.createSystemTables()
#
for table in tables: db.createTable(table)
# create a user
user = User()
user.username = '******'
user.id = 'bob1'
db.insertRow(user)
# create a greeting
greeting = Greeting()
greeting.who = user
greeting.greeting = 'hello'
greeting.id = 'greeting1'
db.insertRow(greeting)
#
tables.reverse()
for table in tables: db.dropTable(table)
#
db.destroySystemTables()
return
def _test2(self):
'dsaw.db.GloballyReferrable: establish global pointer automatically'
import dsaw.db
db = dsaw.db.connect(db='postgres:///test')
db.autocommit(True)
print 'declare tables'
from dsaw.db.WithID import WithID
from dsaw.db.GloballyReferrable import GloballyReferrable
class Cylinder(WithID, GloballyReferrable):
name = 'cylinders'
radius = dsaw.db.real(name='radius')
height = dsaw.db.real(name='height')
tables = [
Cylinder,
]
for table in tables:
db.registerTable(table)
db.createAllTables()
print 'insert records'
cylinder1 = Cylinder()
cylinder1.id = 'cylinder1'
cylinder1.radius = 5
cylinder1.height = 10
rows = [
cylinder1,
]
for row in rows:
db.insertRow(row)
self.assert_(cylinder1.globalpointer and cylinder1.globalpointer.id)
print 'remove tables'
db.destroyAllTables()
return
def test5(self):
'insert'
db = self.db
# insert records
userbob = User()
userbob.id = userbob.username = '******'
db.insertRow(userbob)
useralice = User()
useralice.id = useralice.username = '******'
db.insertRow(useralice)
group = Group()
group.id = 'group5'
db.insertRow(group)
db.commit()
refset = group.users
# bob
refset.add(userbob, db=db)
# alice, bob
refset.insert(useralice, before=userbob, db=db)
#
self.assertEqual(refset.getElement(index=0, db=db).id, useralice.id)
self.assertEqual(refset.getElement(index=1, db=db).id, userbob.id)
return
def test2(self):
'add, delete two users'
db = self.db
# insert records
userbob = User()
userbob.id = userbob.username = '******'
db.insertRow(userbob)
useralice = User()
useralice.id = useralice.username = '******'
db.insertRow(useralice)
group = Group()
group.id = 'group2'
db.insertRow(group)
db.commit()
refset = group.users
refset.add(userbob, db)
refset.add(useralice, db)
users = refset.dereference(db)
self.assertEqual(len(users), 2)
refset.delete(useralice, db)
refset.delete(userbob, db)
return
def test1(self):
'dsaw.db.Psycopg2: double array type'
db = self.dbManager()
# declare tables
from dsaw.db.WithID import WithID
class DoubleArrayTest(WithID):
name = 'doublearraytest'
import dsaw.db
arr = dsaw.db.doubleArray(name='arr')
m = dsaw.db.doubleArray(name='m', shape=(2, 3))
db.registerTable(DoubleArrayTest)
db.createAllTables()
t1 = DoubleArrayTest()
t1.id = 't1'
t1.arr = [1., 2.]
db.insertRow(t1)
t1.arr = [3., 4.]
db.updateRecord(t1)
t1.arr = [5., 6.]
t1.m = [[0, 1, 2], [3, 4, 5]]
self.assertEqual(t1.m.shape, (2, 3))
t1.m = [[0, 1. / 3, 2], [3, 4, 5]]
db.updateRecord(t1)
self.assert_(abs(t1.m[0, 1] - 1. / 3) < 1e-12)
t1a = db.query(DoubleArrayTest).filter_by(id='t1').one()
self.assert_(abs(t1a.m[0, 1] - 1. / 3) < 1e-12)
db.destroyAllTables()
return
def test3c(self):
'dsaw.db.Psycopg2: table with reference. updateRecord'
db = self.dbManager()
# declare tables
from dsaw.db.WithID import WithID
class User(WithID):
name = 'users'
import dsaw.db
username = dsaw.db.varchar(name='username', length=100)
class Greeting(WithID):
name = 'greetings'
import dsaw.db
greeting = dsaw.db.varchar(name='greeting', length=100)
who = dsaw.db.reference(name='who', table=User)
db._tablemap.registerTable(User)
db._tablemap.TableToObject(User)
tables = [User, Greeting]
for table in tables:
db.registerTable(table)
db.createAllTables()
# create two users
userbob = User()
userbob.id = userbob.username = '******'
db.insertRow(userbob)
useralice = User()
useralice.id = useralice.username = '******'
db.insertRow(useralice)
# create a greeting
greeting = Greeting()
greeting.who = userbob
greeting.greeting = 'hello'
greeting.id = 'greeting1'
db.insertRow(greeting)
# update
greeting.who = useralice
greeting.greeting = 'aloha'
db.updateRecord(greeting)
# fetch it
greeting1 = db.query(Greeting).filter_by(id=greeting.id).one()
self.assertEqual(greeting1.greeting, 'aloha')
self.assertEqual(greeting1.who.id, useralice.id)
db.destroyAllTables()
return
def test4(self):
'get, set, delete by index'
db = self.db
# insert records
userbob = User()
userbob.id = userbob.username = '******'
db.insertRow(userbob)
useralice = User()
useralice.id = useralice.username = '******'
db.insertRow(useralice)
group = Group()
group.id = 'group4'
db.insertRow(group)
db.commit()
refset = group.users
# bob, alice
refset.add(userbob, db=db)
refset.add(useralice, db=db)
user0 = refset.getElement(db=db, index=0)
self.assertEqual(user0.id, userbob.id)
# alice, alice
refset.setElement(element=useralice, index=0, db=db)
user0 = refset.getElement(db=db, index=0)
self.assertEqual(user0.id, useralice.id)
# alice, bob
refset.setElement(element=userbob, index=1, db=db)
user0 = refset.getElement(db=db, index=0)
self.assertEqual(user0.id, useralice.id)
user1 = refset.getElement(db=db, index=1)
self.assertEqual(user1.id, userbob.id)
# bob
refset.delElement(index=0, db=db)
user0 = refset.getElement(db=db, index=0)
self.assertEqual(user0.id, userbob.id)
return
def test3(self):
'get, set, delete by key'
db = self.db
# insert records
userbob = User()
userbob.id = userbob.username = '******'
db.insertRow(userbob)
useralice = User()
useralice.id = useralice.username = '******'
db.insertRow(useralice)
group = Group()
group.id = 'group3'
db.insertRow(group)
db.commit()
refset = group.users
refset.setElement(element=userbob, db=db, key='key1')
refset.setElement(element=useralice, db=db, key='key2')
user1 = refset.getElement(db=db, key='key1')
self.assertEqual(user1.id, userbob.id)
user2 = refset.getElement(db=db, key='key2')
self.assertEqual(user2.id, useralice.id)
refset.delElement(db=db, key='key1')
self.assertEqual(len(refset.dereference(db)), 1)
user2 = refset.getElement(db=db, key='key2')
self.assertEqual(user2.id, useralice.id)
user0 = refset.getElement(db=db, index=0)
self.assertEqual(user0.id, useralice.id)
refset.setElement(db=db, key='key1', element=userbob)
user1 = refset.getElement(db=db, index=1)
self.assertEqual(user1.id, userbob.id)
return
sphere1.radius = 10.
cylinder1 = Cylinder()
cylinder1.id = 'cylinder1'
cylinder1.radius = 5
cylinder1.height = 10
scatterer1 = Scatterer()
scatterer1.id = 'scatterer1'
scatterer1.shape = sphere1
rows = [
sphere1, cylinder1,
scatterer1,
]
for row in rows: db.insertRow(row)
def assertEqual(first, second):
"""Fail if the two objects are unequal as determined by the '=='
operator.
"""
if not first == second:
raise Exception, ('%r != %r' % (first, second))
print 'dereference'
shape1 = scatterer1.shape.dereference(db)
assertEqual( shape1.__class__, sphere1.__class__)
assertEqual(shape1.id, sphere1.id)
print 'fetch from db'
rows = db.fetchall(Scatterer, where="id='%s'" % scatterer1.id)
def test1(self):
'dsaw.db.VersatileReference: '
import dsaw.db
db = dsaw.db.connect(db='postgres:///test')
db.autocommit(True)
print 'declare tables'
from dsaw.db.WithID import WithID
from dsaw.db.GloballyReferrable import GloballyReferrable
class Cylinder(WithID, GloballyReferrable):
name = 'cylinders'
radius = dsaw.db.real(name='radius')
height = dsaw.db.real(name='height')
class Sphere(WithID, GloballyReferrable):
name = 'spheres'
radius = dsaw.db.real(name='radius')
class Scatterer(WithID):
name = 'scatterers'
shape = dsaw.db.versatileReference(name='shape')
tables = [
Sphere,
Cylinder,
Scatterer,
]
for table in tables:
db.registerTable(table)
db.createAllTables()
print 'insert records'
sphere1 = Sphere()
sphere1.id = 'sphere1'
sphere1.radius = 10.
cylinder1 = Cylinder()
cylinder1.id = 'cylinder1'
cylinder1.radius = 5
cylinder1.height = 10
scatterer1 = Scatterer()
scatterer1.id = 'scatterer1'
scatterer1.shape = sphere1
rows = [
sphere1,
cylinder1,
scatterer1,
]
for row in rows:
db.insertRow(row)
print 'dereference'
shape1 = scatterer1.shape.dereference(db)
self.assertEqual(shape1.__class__, sphere1.__class__)
self.assertEqual(shape1.id, sphere1.id)
print 'fetch from db'
rows = db.fetchall(Scatterer, where="id='%s'" % scatterer1.id)
self.assertEqual(len(rows), 1)
scatterer1r = rows[0]
self.assertEqual(scatterer1r.shape.id, sphere1.globalpointer.id)
print "make sure we don't create dangling reference"
self.assertRaises(db.RecordStillReferred, db.deleteRecord, sphere1)
print 'updateRecord: switch to a different type of shape'
scatterer1.shape = cylinder1
db.updateRecord(scatterer1)
shape1 = scatterer1.shape.dereference(db)
self.assertEqual(shape1.__class__, cylinder1.__class__)
self.assertEqual(shape1.id, cylinder1.id)
print 'updateRecord 2: switch to a different type of shape by using a string'
scatterer1.shape = 'spheres###sphere1'
db.updateRecord(scatterer1)
shape1 = scatterer1.shape.dereference(db)
self.assertEqual(shape1.__class__, sphere1.__class__)
self.assertEqual(shape1.id, sphere1.id)
print 'updateRecord 3: switch to None'
scatterer1.shape = None
db.updateRecord(scatterer1)
shape1 = scatterer1.shape.dereference(db)
self.assertEqual(shape1, None)
print 'remove tables'
db.destroyAllTables()
return
def setUp(self):
import dsaw.db
db = dsaw.db.connect(db='sqlite://')
tables = [
User, Role, Privilege,
UserHasRole, RoleHasRole, RoleHasPrivilege,
]
map(db.registerTable, tables)
db.createAllTables()
# users
linjiao = User(); linjiao.id = linjiao.username = '******'
db.insertRow(linjiao)
demo = User(); demo.id = demo.username = '******'
db.insertRow(demo)
# roles
vnfadmin = Role(); vnfadmin.rolename='admin'; vnfadmin.context='vnf'
db.insertRow(vnfadmin)
#
vnfuser = Role(); vnfuser.rolename='user'; vnfuser.context='vnf'
db.insertRow(vnfuser)
#
vnfguest = Role(); vnfguest.rolename='guest'; vnfguest.context='vnf'
db.insertRow(vnfguest)
# privileges
writesample = Privilege(); writesample.name='write'; writesample.target='sample'
db.insertRow(writesample)
# linjiao is a vnf admin
linjiao.assignRole(vnfadmin, db)
# vnf admin can be vnf user
vnfadmin.becomeMember(vnfuser, db)
# demo is a guest
demo.assignRole(vnfguest, db)
# vnf user can write samples
grant(writesample, vnfuser, db)
self.db = db
return
def test1(self):
'dsaw.db.Reference: '
import dsaw.db
db = dsaw.db.connect(db='postgres:///test')
db.autocommit(True)
print 'declare tables'
from dsaw.db.WithID import WithID
class Cylinder(WithID):
name = 'cylinders'
radius = dsaw.db.real(name='radius')
height = dsaw.db.real(name='height')
class Scatterer(WithID):
name = 'scatterers'
shape = dsaw.db.reference(name='shape', table=Cylinder)
tables = [
Cylinder,
Scatterer,
]
for table in tables:
db.registerTable(table)
db.createAllTables()
print 'insert records'
cylinder1 = Cylinder()
cylinder1.id = 'cylinder1'
cylinder1.radius = 5
cylinder1.height = 10
scatterer1 = Scatterer()
scatterer1.id = 'scatterer1'
scatterer1.shape = cylinder1
rows = [
cylinder1,
scatterer1,
]
for row in rows:
db.insertRow(row)
print 'dereference'
shape1 = scatterer1.shape.dereference(db)
self.assertEqual(shape1.__class__, Cylinder)
self.assertEqual(shape1.id, cylinder1.id)
print "make sure we don't create dangling reference"
self.assertRaises(db.RecordStillReferred, db.deleteRecord, cylinder1)
print 'updateRecord 3: switch to None'
scatterer1.shape = None
db.updateRecord(scatterer1)
shape1 = scatterer1.shape
self.assertEqual(shape1, None)
print 'remove tables'
db.destroyAllTables()
return
def setUp(self):
import dsaw.db
db = dsaw.db.connect(db='sqlite://')
tables = [
User,
Role,
Privilege,
UserHasRole,
RoleHasRole,
RoleHasPrivilege,
]
map(db.registerTable, tables)
db.createAllTables()
# users
linjiao = User()
linjiao.id = linjiao.username = '******'
db.insertRow(linjiao)
demo = User()
demo.id = demo.username = '******'
db.insertRow(demo)
# roles
vnfadmin = Role()
vnfadmin.rolename = 'admin'
vnfadmin.context = 'vnf'
db.insertRow(vnfadmin)
#
vnfuser = Role()
vnfuser.rolename = 'user'
vnfuser.context = 'vnf'
db.insertRow(vnfuser)
#
vnfguest = Role()
vnfguest.rolename = 'guest'
vnfguest.context = 'vnf'
db.insertRow(vnfguest)
# privileges
writesample = Privilege()
writesample.name = 'write'
writesample.target = 'sample'
db.insertRow(writesample)
# linjiao is a vnf admin
linjiao.assignRole(vnfadmin, db)
# vnf admin can be vnf user
vnfadmin.becomeMember(vnfuser, db)
# demo is a guest
demo.assignRole(vnfguest, db)
# vnf user can write samples
grant(writesample, vnfuser, db)
self.db = db
return
def testMixed(self):
'dsaw.db.ReferenceSet: mixed'
db = self.db
# insert records
userbob = User()
userbob.id = userbob.username = '******'
db.insertRow(userbob)
useralice = User()
useralice.id = useralice.username = '******'
db.insertRow(useralice)
db.commit()
group = Group()
group.id = 'groupMixed'
db.insertRow(group)
db.commit()
refset = group.users
print 'referenceset instance: %s' % refset
users = refset.dereference(db)
self.assertEqual(len(users), 0)
print 'users: %s' % (users, )
print '> add one user'
refset.add(userbob, db, name='1')
users = refset.dereference(db)
self.assertEqual(len(users), 1)
print '> delete one user'
refset.delete(userbob, db)
users = refset.dereference(db)
self.assertEqual(len(users), 0)
print '> add two users'
refset.add(userbob, db)
refset.add(useralice, db)
users = refset.dereference(db)
self.assertEqual(len(users), 2)
ids = [row.id for label, row in users]
self.assert_('bobMixed' in ids)
self.assert_('aliceMixed' in ids)
print '> remove all users'
refset.clear(db)
users = refset.dereference(db)
self.assertEqual(len(users), 0)
print '> getElement and setElement'
refset.setElement('1', userbob, db)
refset.setElement('2', useralice, db)
self.assertEqual(refset.getElement('1', db).id, userbob.id)
users = refset.dereference(db)
self.assertEqual(len(users), 2)
ids = [row.id for label, row in users]
self.assert_('bobMixed' in ids)
self.assert_('aliceMixed' in ids)
refset.setElement('2', userbob, db)
users = refset.dereference(db)
self.assertEqual(len(users), 2)
ids = [row.id for label, row in users]
self.assert_('bobMixed' in ids)
self.assert_('aliceMixed' not in ids)
print '> delElement'
deleted = refset.delElement('1', db)
self.assertEqual(deleted.id, 'bobMixed')
self.assertEqual(len(refset.dereference(db)), 1)
self.assertRaises(KeyError, refset.delElement, '1', db)
print '> remove all users'
refset.clear(db)
users = refset.dereference(db)
self.assertEqual(len(users), 0)
return
