dinislage/web2py
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

upgraded fpdf, better tests, passes travis.ci tests, thanks Niphlod

Browse Source
This commit is contained in:
Massimo
2013-03-18 16:52:47 -05:00
parent 8857e3d521
commit a8d1d5cfcf
4 changed files with 330 additions and 297 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.travis.yml
+1 -1
View File
@@ -1,7 +1,7 @@
language: python language: python
python: python:
#Temporarily disable 2.5 tests - '2.5' - '2.5'
- '2.6' - '2.6'
- '2.7' - '2.7'
env: env:
VERSION
+1 -1
View File
@@ -1 +1 @@
Version 2.4.4-stable+timestamp.2013.03.17.18.52.33 Version 2.4.4-stable+timestamp.2013.03.18.16.52.04
gluon/contrib/fpdf/fpdf.py
+33
View File
@@ -373,6 +373,21 @@ class FPDF(object):
"Draw a line" "Draw a line"
self._out(sprintf('%.2f %.2f m %.2f %.2f l S',x1*self.k,(self.h-y1)*self.k,x2*self.k,(self.h-y2)*self.k)) self._out(sprintf('%.2f %.2f m %.2f %.2f l S',x1*self.k,(self.h-y1)*self.k,x2*self.k,(self.h-y2)*self.k))
def _set_dash(self, dash_length=False, space_length=False):
if(dash_length and space_length):
s = sprintf('[%.3f %.3f] 0 d', dash_length*self.k, space_length*self.k)
else:
s = '[] 0 d'
self._out(s)
def dashed_line(self, x1,y1,x2,y2, dash_length=1, space_length=1):
"""Draw a dashed line. Same interface as line() except:
- dash_length: Length of the dash
- space_length: Length of the space between dashes"""
self._set_dash(dash_length, space_length)
self.line(x1, y1, x2, y2)
self._set_dash()
def rect(self, x,y,w,h,style=''): def rect(self, x,y,w,h,style=''):
"Draw a rectangle" "Draw a rectangle"
if(style=='F'): if(style=='F'):
@@ -900,6 +915,24 @@ class FPDF(object):
info=self._parsepng(name) info=self._parsepng(name)
else: else:
#Allow for additional formats #Allow for additional formats
#maybe the image is not showing the correct extension,
#but the header is OK,
succeed_parsing = False
#try all the parsing functions
parsing_functions = [self._parsejpg,self._parsepng,self._parsegif]
for pf in parsing_functions:
try:
info = pf(name)
succeed_parsing = True
break;
except:
pass
#last resource
if not succeed_parsing:
mtd='_parse'+type
if not hasattr(self,mtd):
self.error('Unsupported image type: '+type)
info=getattr(self, mtd)(name)
mtd='_parse'+type mtd='_parse'+type
if not hasattr(self,mtd): if not hasattr(self,mtd):
self.error('Unsupported image type: '+type) self.error('Unsupported image type: '+type)
gluon/tests/test_dal.py
+267 -267
View File
@@ -105,35 +105,35 @@ class TestFields(unittest.TestCase):
isinstance(f.formatter(datetime.datetime.now()), str) isinstance(f.formatter(datetime.datetime.now()), str)
def testRun(self): def testRun(self):
db = DAL(DEFAULT_URI) db = DAL(DEFAULT_URI, check_reserved=['all'])
for ft in ['string', 'text', 'password', 'upload', 'blob']: for ft in ['string', 'text', 'password', 'upload', 'blob']:
db.define_table('t', Field('a', ft, default='')) db.define_table('tt', Field('aa', ft, default=''))
self.assertEqual(db.t.insert(a='x'), 1) self.assertEqual(db.tt.insert(aa='x'), 1)
self.assertEqual(db().select(db.t.a)[0].a, 'x') self.assertEqual(db().select(db.tt.aa)[0].aa, 'x')
db.t.drop() db.tt.drop()
db.define_table('t', Field('a', 'integer', default=1)) db.define_table('tt', Field('aa', 'integer', default=1))
self.assertEqual(db.t.insert(a=3), 1) self.assertEqual(db.tt.insert(aa=3), 1)
self.assertEqual(db().select(db.t.a)[0].a, 3) self.assertEqual(db().select(db.tt.aa)[0].aa, 3)
db.t.drop() db.tt.drop()
db.define_table('t', Field('a', 'double', default=1)) db.define_table('tt', Field('aa', 'double', default=1))
self.assertEqual(db.t.insert(a=3.1), 1) self.assertEqual(db.tt.insert(aa=3.1), 1)
self.assertEqual(db().select(db.t.a)[0].a, 3.1) self.assertEqual(db().select(db.tt.aa)[0].aa, 3.1)
db.t.drop() db.tt.drop()
db.define_table('t', Field('a', 'boolean', default=True)) db.define_table('tt', Field('aa', 'boolean', default=True))
self.assertEqual(db.t.insert(a=True), 1) self.assertEqual(db.tt.insert(aa=True), 1)
self.assertEqual(db().select(db.t.a)[0].a, True) self.assertEqual(db().select(db.tt.aa)[0].aa, True)
db.t.drop() db.tt.drop()
db.define_table('t', Field('a', 'json', default={})) db.define_table('tt', Field('aa', 'json', default={}))
self.assertEqual(db.t.insert(a={}), 1) self.assertEqual(db.tt.insert(aa={}), 1)
self.assertEqual(db().select(db.t.a)[0].a, {}) self.assertEqual(db().select(db.tt.aa)[0].aa, {})
db.t.drop() db.tt.drop()
db.define_table('t', Field('a', 'date', db.define_table('tt', Field('aa', 'date',
default=datetime.date.today())) default=datetime.date.today()))
t0 = datetime.date.today() t0 = datetime.date.today()
self.assertEqual(db.t.insert(a=t0), 1) self.assertEqual(db.tt.insert(aa=t0), 1)
self.assertEqual(db().select(db.t.a)[0].a, t0) self.assertEqual(db().select(db.tt.aa)[0].aa, t0)
db.t.drop() db.tt.drop()
db.define_table('t', Field('a', 'datetime', db.define_table('tt', Field('aa', 'datetime',
default=datetime.datetime.today())) default=datetime.datetime.today()))
t0 = datetime.datetime( t0 = datetime.datetime(
1971, 1971,
@@ -144,34 +144,34 @@ class TestFields(unittest.TestCase):
55, 55,
0, 0,
) )
self.assertEqual(db.t.insert(a=t0), 1) self.assertEqual(db.tt.insert(aa=t0), 1)
self.assertEqual(db().select(db.t.a)[0].a, t0) self.assertEqual(db().select(db.tt.aa)[0].aa, t0)
## Row APIs ## Row APIs
row = db().select(db.t.a)[0] row = db().select(db.tt.aa)[0]
self.assertEqual(db.t[1].a,t0) self.assertEqual(db.tt[1].aa,t0)
self.assertEqual(db.t['a'],db.t.a) self.assertEqual(db.tt['aa'],db.tt.aa)
self.assertEqual(db.t(1).a,t0) self.assertEqual(db.tt(1).aa,t0)
self.assertTrue(db.t(1,a=None)==None) self.assertTrue(db.tt(1,aa=None)==None)
self.assertFalse(db.t(1,a=t0)==None) self.assertFalse(db.tt(1,aa=t0)==None)
self.assertEqual(row.a,t0) self.assertEqual(row.aa,t0)
self.assertEqual(row['a'],t0) self.assertEqual(row['aa'],t0)
self.assertEqual(row['t.a'],t0) self.assertEqual(row['tt.aa'],t0)
self.assertEqual(row('t.a'),t0) self.assertEqual(row('tt.aa'),t0)
## Lazy and Virtual fields ## Lazy and Virtual fields
db.t.b = Field.Virtual(lambda row: row.t.a) db.tt.b = Field.Virtual(lambda row: row.tt.aa)
db.t.c = Field.Lazy(lambda row: row.t.a) db.tt.c = Field.Lazy(lambda row: row.tt.aa)
row = db().select(db.t.a)[0] row = db().select(db.tt.aa)[0]
self.assertEqual(row.b,t0) self.assertEqual(row.b,t0)
self.assertEqual(row.c(),t0) self.assertEqual(row.c(),t0)
db.t.drop() db.tt.drop()
db.define_table('t', Field('a', 'time', default='11:30')) db.define_table('tt', Field('aa', 'time', default='11:30'))
t0 = datetime.time(10, 30, 55) t0 = datetime.time(10, 30, 55)
self.assertEqual(db.t.insert(a=t0), 1) self.assertEqual(db.tt.insert(aa=t0), 1)
self.assertEqual(db().select(db.t.a)[0].a, t0) self.assertEqual(db().select(db.tt.aa)[0].aa, t0)
db.t.drop() db.tt.drop()
class TestAll(unittest.TestCase): class TestAll(unittest.TestCase):
@@ -207,7 +207,7 @@ class TestTable(unittest.TestCase):
in str(persons.ALL)) in str(persons.ALL))
def testTableAlias(self): def testTableAlias(self):
db = DAL(DEFAULT_URI) db = DAL(DEFAULT_URI, check_reserved=['all'])
persons = Table(db, 'persons', Field('firstname', persons = Table(db, 'persons', Field('firstname',
'string'), Field('lastname', 'string')) 'string'), Field('lastname', 'string'))
aliens = persons.with_alias('aliens') aliens = persons.with_alias('aliens')
@@ -230,200 +230,200 @@ class TestTable(unittest.TestCase):
class TestInsert(unittest.TestCase): class TestInsert(unittest.TestCase):
def testRun(self): def testRun(self):
db = DAL(DEFAULT_URI) db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('t', Field('a')) db.define_table('tt', Field('aa'))
self.assertEqual(db.t.insert(a='1'), 1) self.assertEqual(db.tt.insert(aa='1'), 1)
self.assertEqual(db.t.insert(a='1'), 2) self.assertEqual(db.tt.insert(aa='1'), 2)
self.assertEqual(db.t.insert(a='1'), 3) self.assertEqual(db.tt.insert(aa='1'), 3)
self.assertEqual(db(db.t.a == '1').count(), 3) self.assertEqual(db(db.tt.aa == '1').count(), 3)
self.assertEqual(db(db.t.a == '1').update(a='2'), 3) self.assertEqual(db(db.tt.aa == '1').update(aa='2'), 3)
self.assertEqual(db(db.t.a == '2').count(), 3) self.assertEqual(db(db.tt.aa == '2').count(), 3)
self.assertEqual(db(db.t.a == '2').delete(), 3) self.assertEqual(db(db.tt.aa == '2').delete(), 3)
db.t.drop() db.tt.drop()
class TestSelect(unittest.TestCase): class TestSelect(unittest.TestCase):
def testRun(self): def testRun(self):
db = DAL(DEFAULT_URI) db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('t', Field('a')) db.define_table('tt', Field('aa'))
self.assertEqual(db.t.insert(a='1'), 1) self.assertEqual(db.tt.insert(aa='1'), 1)
self.assertEqual(db.t.insert(a='2'), 2) self.assertEqual(db.tt.insert(aa='2'), 2)
self.assertEqual(db.t.insert(a='3'), 3) self.assertEqual(db.tt.insert(aa='3'), 3)
self.assertEqual(len(db(db.t.id > 0).select()), 3) self.assertEqual(len(db(db.tt.id > 0).select()), 3)
self.assertEqual(db(db.t.id > 0).select(orderby=~db.t.a self.assertEqual(db(db.tt.id > 0).select(orderby=~db.tt.aa
| db.t.id)[0].a, '3') | db.tt.id)[0].aa, '3')
self.assertEqual(len(db(db.t.id > 0).select(limitby=(1, 2))), 1) self.assertEqual(len(db(db.tt.id > 0).select(limitby=(1, 2))), 1)
self.assertEqual(db(db.t.id > 0).select(limitby=(1, 2))[0].a, self.assertEqual(db(db.tt.id > 0).select(limitby=(1, 2))[0].aa,
'2') '2')
self.assertEqual(len(db().select(db.t.ALL)), 3) self.assertEqual(len(db().select(db.tt.ALL)), 3)
self.assertEqual(len(db(db.t.a == None).select()), 0) self.assertEqual(len(db(db.tt.aa == None).select()), 0)
self.assertEqual(len(db(db.t.a != None).select()), 3) self.assertEqual(len(db(db.tt.aa != None).select()), 3)
self.assertEqual(len(db(db.t.a > '1').select()), 2) self.assertEqual(len(db(db.tt.aa > '1').select()), 2)
self.assertEqual(len(db(db.t.a >= '1').select()), 3) self.assertEqual(len(db(db.tt.aa >= '1').select()), 3)
self.assertEqual(len(db(db.t.a == '1').select()), 1) self.assertEqual(len(db(db.tt.aa == '1').select()), 1)
self.assertEqual(len(db(db.t.a != '1').select()), 2) self.assertEqual(len(db(db.tt.aa != '1').select()), 2)
self.assertEqual(len(db(db.t.a < '3').select()), 2) self.assertEqual(len(db(db.tt.aa < '3').select()), 2)
self.assertEqual(len(db(db.t.a <= '3').select()), 3) self.assertEqual(len(db(db.tt.aa <= '3').select()), 3)
self.assertEqual(len(db(db.t.a > '1')(db.t.a < '3').select()), 1) self.assertEqual(len(db(db.tt.aa > '1')(db.tt.aa < '3').select()), 1)
self.assertEqual(len(db((db.t.a > '1') & (db.t.a < '3')).select()), 1) self.assertEqual(len(db((db.tt.aa > '1') & (db.tt.aa < '3')).select()), 1)
self.assertEqual(len(db((db.t.a > '1') | (db.t.a < '3')).select()), 3) self.assertEqual(len(db((db.tt.aa > '1') | (db.tt.aa < '3')).select()), 3)
self.assertEqual(len(db((db.t.a > '1') & ~(db.t.a > '2')).select()), 1) self.assertEqual(len(db((db.tt.aa > '1') & ~(db.tt.aa > '2')).select()), 1)
self.assertEqual(len(db(~(db.t.a > '1') & (db.t.a > '2')).select()), 0) self.assertEqual(len(db(~(db.tt.aa > '1') & (db.tt.aa > '2')).select()), 0)
db.t.drop() db.tt.drop()
class TestBelongs(unittest.TestCase): class TestBelongs(unittest.TestCase):
def testRun(self): def testRun(self):
db = DAL(DEFAULT_URI) db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('t', Field('a')) db.define_table('tt', Field('aa'))
self.assertEqual(db.t.insert(a='1'), 1) self.assertEqual(db.tt.insert(aa='1'), 1)
self.assertEqual(db.t.insert(a='2'), 2) self.assertEqual(db.tt.insert(aa='2'), 2)
self.assertEqual(db.t.insert(a='3'), 3) self.assertEqual(db.tt.insert(aa='3'), 3)
self.assertEqual(len(db(db.t.a.belongs(('1', '3'))).select()), self.assertEqual(len(db(db.tt.aa.belongs(('1', '3'))).select()),
2) 2)
self.assertEqual(len(db(db.t.a.belongs(db(db.t.id self.assertEqual(len(db(db.tt.aa.belongs(db(db.tt.id
> 2)._select(db.t.a))).select()), 1) > 2)._select(db.tt.aa))).select()), 1)
self.assertEqual(len(db(db.t.a.belongs(db(db.t.a.belongs(('1', self.assertEqual(len(db(db.tt.aa.belongs(db(db.tt.aa.belongs(('1',
'3')))._select(db.t.a))).select()), 2) '3')))._select(db.tt.aa))).select()), 2)
self.assertEqual(len(db(db.t.a.belongs(db(db.t.a.belongs(db self.assertEqual(len(db(db.tt.aa.belongs(db(db.tt.aa.belongs(db
(db.t.a.belongs(('1', '3')))._select(db.t.a)))._select( (db.tt.aa.belongs(('1', '3')))._select(db.tt.aa)))._select(
db.t.a))).select()), db.tt.aa))).select()),
2) 2)
db.t.drop() db.tt.drop()
class TestContains(unittest.TestCase): class TestContains(unittest.TestCase):
def testRun(self): def testRun(self):
db = DAL(DEFAULT_URI) db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('t', Field('a', 'list:string')) db.define_table('tt', Field('aa', 'list:string'))
self.assertEqual(db.t.insert(a=['aaa','bbb']), 1) self.assertEqual(db.tt.insert(aa=['aaa','bbb']), 1)
self.assertEqual(db.t.insert(a=['bbb','ddd']), 2) self.assertEqual(db.tt.insert(aa=['bbb','ddd']), 2)
self.assertEqual(db.t.insert(a=['eee','aaa']), 3) self.assertEqual(db.tt.insert(aa=['eee','aaa']), 3)
self.assertEqual(len(db(db.t.a.contains('aaa')).select()), self.assertEqual(len(db(db.tt.aa.contains('aaa')).select()),
2) 2)
self.assertEqual(len(db(db.t.a.contains('bbb')).select()), self.assertEqual(len(db(db.tt.aa.contains('bbb')).select()),
2) 2)
self.assertEqual(len(db(db.t.a.contains('aa')).select()), self.assertEqual(len(db(db.tt.aa.contains('aa')).select()),
0) 0)
db.t.drop() db.tt.drop()
class TestLike(unittest.TestCase): class TestLike(unittest.TestCase):
def testRun(self): def testRun(self):
db = DAL(DEFAULT_URI) db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('t', Field('a')) db.define_table('tt', Field('aa'))
self.assertEqual(db.t.insert(a='abc'), 1) self.assertEqual(db.tt.insert(aa='abc'), 1)
self.assertEqual(len(db(db.t.a.like('a%')).select()), 1) self.assertEqual(len(db(db.tt.aa.like('a%')).select()), 1)
self.assertEqual(len(db(db.t.a.like('%b%')).select()), 1) self.assertEqual(len(db(db.tt.aa.like('%b%')).select()), 1)
self.assertEqual(len(db(db.t.a.like('%c')).select()), 1) self.assertEqual(len(db(db.tt.aa.like('%c')).select()), 1)
self.assertEqual(len(db(db.t.a.like('%d%')).select()), 0) self.assertEqual(len(db(db.tt.aa.like('%d%')).select()), 0)
self.assertEqual(len(db(db.t.a.lower().like('A%')).select()), 1) self.assertEqual(len(db(db.tt.aa.lower().like('A%')).select()), 1)
self.assertEqual(len(db(db.t.a.lower().like('%B%')).select()), self.assertEqual(len(db(db.tt.aa.lower().like('%B%')).select()),
1) 1)
self.assertEqual(len(db(db.t.a.lower().like('%C')).select()), 1) self.assertEqual(len(db(db.tt.aa.lower().like('%C')).select()), 1)
self.assertEqual(len(db(db.t.a.upper().like('A%')).select()), 1) self.assertEqual(len(db(db.tt.aa.upper().like('A%')).select()), 1)
self.assertEqual(len(db(db.t.a.upper().like('%B%')).select()), self.assertEqual(len(db(db.tt.aa.upper().like('%B%')).select()),
1) 1)
self.assertEqual(len(db(db.t.a.upper().like('%C')).select()), 1) self.assertEqual(len(db(db.tt.aa.upper().like('%C')).select()), 1)
db.t.drop() db.tt.drop()
db.define_table('t', Field('a', 'integer')) db.define_table('tt', Field('aa', 'integer'))
self.assertEqual(db.t.insert(a=1111111111), 1) self.assertEqual(db.tt.insert(aa=1111111111), 1)
self.assertEqual(len(db(db.t.a.like('1%')).select()), 1) self.assertEqual(len(db(db.tt.aa.like('1%')).select()), 1)
self.assertEqual(len(db(db.t.a.like('2%')).select()), 0) self.assertEqual(len(db(db.tt.aa.like('2%')).select()), 0)
db.t.drop() db.tt.drop()
class TestDatetime(unittest.TestCase): class TestDatetime(unittest.TestCase):
def testRun(self): def testRun(self):
db = DAL(DEFAULT_URI) db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('t', Field('a', 'datetime')) db.define_table('tt', Field('aa', 'datetime'))
self.assertEqual(db.t.insert(a=datetime.datetime(1971, 12, 21, self.assertEqual(db.tt.insert(aa=datetime.datetime(1971, 12, 21,
11, 30)), 1) 11, 30)), 1)
self.assertEqual(db.t.insert(a=datetime.datetime(1971, 11, 21, self.assertEqual(db.tt.insert(aa=datetime.datetime(1971, 11, 21,
10, 30)), 2) 10, 30)), 2)
self.assertEqual(db.t.insert(a=datetime.datetime(1970, 12, 21, self.assertEqual(db.tt.insert(aa=datetime.datetime(1970, 12, 21,
9, 30)), 3) 9, 30)), 3)
self.assertEqual(len(db(db.t.a == datetime.datetime(1971, 12, self.assertEqual(len(db(db.tt.aa == datetime.datetime(1971, 12,
21, 11, 30)).select()), 1) 21, 11, 30)).select()), 1)
self.assertEqual(db(db.t.a.year() == 1971).count(), 2) self.assertEqual(db(db.tt.aa.year() == 1971).count(), 2)
self.assertEqual(db(db.t.a.month() == 12).count(), 2) self.assertEqual(db(db.tt.aa.month() == 12).count(), 2)
self.assertEqual(db(db.t.a.day() == 21).count(), 3) self.assertEqual(db(db.tt.aa.day() == 21).count(), 3)
self.assertEqual(db(db.t.a.hour() == 11).count(), 1) self.assertEqual(db(db.tt.aa.hour() == 11).count(), 1)
self.assertEqual(db(db.t.a.minutes() == 30).count(), 3) self.assertEqual(db(db.tt.aa.minutes() == 30).count(), 3)
self.assertEqual(db(db.t.a.seconds() == 0).count(), 3) self.assertEqual(db(db.tt.aa.seconds() == 0).count(), 3)
self.assertEqual(db(db.t.a.epoch()<365*24*3600).count(),1) self.assertEqual(db(db.tt.aa.epoch()<365*24*3600).count(),1)
db.t.drop() db.tt.drop()
class TestExpressions(unittest.TestCase): class TestExpressions(unittest.TestCase):
def testRun(self): def testRun(self):
db = DAL(DEFAULT_URI) db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('t', Field('a', 'integer')) db.define_table('tt', Field('aa', 'integer'))
self.assertEqual(db.t.insert(a=1), 1) self.assertEqual(db.tt.insert(aa=1), 1)
self.assertEqual(db.t.insert(a=2), 2) self.assertEqual(db.tt.insert(aa=2), 2)
self.assertEqual(db.t.insert(a=3), 3) self.assertEqual(db.tt.insert(aa=3), 3)
self.assertEqual(db(db.t.a == 3).update(a=db.t.a + 1), 1) self.assertEqual(db(db.tt.aa == 3).update(aa=db.tt.aa + 1), 1)
self.assertEqual(db(db.t.a == 4).count(), 1) self.assertEqual(db(db.tt.aa == 4).count(), 1)
db.t.drop() db.tt.drop()
class TestJoin(unittest.TestCase): class TestJoin(unittest.TestCase):
def testRun(self): def testRun(self):
db = DAL(DEFAULT_URI) db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('t1', Field('a')) db.define_table('t1', Field('aa'))
db.define_table('t2', Field('a'), Field('b', db.t1)) db.define_table('t2', Field('aa'), Field('b', db.t1))
i1 = db.t1.insert(a='1') i1 = db.t1.insert(aa='1')
i2 = db.t1.insert(a='2') i2 = db.t1.insert(aa='2')
i3 = db.t1.insert(a='3') i3 = db.t1.insert(aa='3')
db.t2.insert(a='4', b=i1) db.t2.insert(aa='4', b=i1)
db.t2.insert(a='5', b=i2) db.t2.insert(aa='5', b=i2)
db.t2.insert(a='6', b=i2) db.t2.insert(aa='6', b=i2)
self.assertEqual(len(db(db.t1.id self.assertEqual(len(db(db.t1.id
== db.t2.b).select(orderby=db.t1.a == db.t2.b).select(orderby=db.t1.aa
| db.t2.a)), 3) | db.t2.aa)), 3)
self.assertEqual(db(db.t1.id == db.t2.b).select(orderby=db.t1.a self.assertEqual(db(db.t1.id == db.t2.b).select(orderby=db.t1.aa
| db.t2.a)[2].t1.a, '2') | db.t2.aa)[2].t1.aa, '2')
self.assertEqual(db(db.t1.id == db.t2.b).select(orderby=db.t1.a self.assertEqual(db(db.t1.id == db.t2.b).select(orderby=db.t1.aa
| db.t2.a)[2].t2.a, '6') | db.t2.aa)[2].t2.aa, '6')
self.assertEqual(len(db().select(db.t1.ALL, db.t2.ALL, self.assertEqual(len(db().select(db.t1.ALL, db.t2.ALL,
left=db.t2.on(db.t1.id == db.t2.b), left=db.t2.on(db.t1.id == db.t2.b),
orderby=db.t1.a | db.t2.a)), 4) orderby=db.t1.aa | db.t2.aa)), 4)
self.assertEqual(db().select(db.t1.ALL, db.t2.ALL, self.assertEqual(db().select(db.t1.ALL, db.t2.ALL,
left=db.t2.on(db.t1.id == db.t2.b), left=db.t2.on(db.t1.id == db.t2.b),
orderby=db.t1.a | db.t2.a)[2].t1.a, '2') orderby=db.t1.aa | db.t2.aa)[2].t1.aa, '2')
self.assertEqual(db().select(db.t1.ALL, db.t2.ALL, self.assertEqual(db().select(db.t1.ALL, db.t2.ALL,
left=db.t2.on(db.t1.id == db.t2.b), left=db.t2.on(db.t1.id == db.t2.b),
orderby=db.t1.a | db.t2.a)[2].t2.a, '6') orderby=db.t1.aa | db.t2.aa)[2].t2.aa, '6')
self.assertEqual(db().select(db.t1.ALL, db.t2.ALL, self.assertEqual(db().select(db.t1.ALL, db.t2.ALL,
left=db.t2.on(db.t1.id == db.t2.b), left=db.t2.on(db.t1.id == db.t2.b),
orderby=db.t1.a | db.t2.a)[3].t1.a, '3') orderby=db.t1.aa | db.t2.aa)[3].t1.aa, '3')
self.assertEqual(db().select(db.t1.ALL, db.t2.ALL, self.assertEqual(db().select(db.t1.ALL, db.t2.ALL,
left=db.t2.on(db.t1.id == db.t2.b), left=db.t2.on(db.t1.id == db.t2.b),
orderby=db.t1.a | db.t2.a)[3].t2.a, None) orderby=db.t1.aa | db.t2.aa)[3].t2.aa, None)
self.assertEqual(len(db().select(db.t1.a, db.t2.id.count(), self.assertEqual(len(db().select(db.t1.aa, db.t2.id.count(),
left=db.t2.on(db.t1.id == db.t2.b), left=db.t2.on(db.t1.id == db.t2.b),
orderby=db.t1.a, groupby=db.t1.a)), orderby=db.t1.aa, groupby=db.t1.aa)),
3) 3)
self.assertEqual(db().select(db.t1.a, db.t2.id.count(), self.assertEqual(db().select(db.t1.aa, db.t2.id.count(),
left=db.t2.on(db.t1.id == db.t2.b), left=db.t2.on(db.t1.id == db.t2.b),
orderby=db.t1.a, orderby=db.t1.aa,
groupby=db.t1.a)[0]._extra[db.t2.id.count()], groupby=db.t1.aa)[0]._extra[db.t2.id.count()],
1) 1)
self.assertEqual(db().select(db.t1.a, db.t2.id.count(), self.assertEqual(db().select(db.t1.aa, db.t2.id.count(),
left=db.t2.on(db.t1.id == db.t2.b), left=db.t2.on(db.t1.id == db.t2.b),
orderby=db.t1.a, orderby=db.t1.aa,
groupby=db.t1.a)[1]._extra[db.t2.id.count()], groupby=db.t1.aa)[1]._extra[db.t2.id.count()],
2) 2)
self.assertEqual(db().select(db.t1.a, db.t2.id.count(), self.assertEqual(db().select(db.t1.aa, db.t2.id.count(),
left=db.t2.on(db.t1.id == db.t2.b), left=db.t2.on(db.t1.id == db.t2.b),
orderby=db.t1.a, orderby=db.t1.aa,
groupby=db.t1.a)[2]._extra[db.t2.id.count()], groupby=db.t1.aa)[2]._extra[db.t2.id.count()],
0) 0)
db.t2.drop() db.t2.drop()
db.t1.drop() db.t1.drop()
@@ -431,75 +431,77 @@ class TestJoin(unittest.TestCase):
db.define_table('person',Field('name')) db.define_table('person',Field('name'))
id = db.person.insert(name="max") id = db.person.insert(name="max")
self.assertEqual(id.name,'max') self.assertEqual(id.name,'max')
db.define_table('dog',Field('name'),Field('owner','reference person')) db.define_table('dog',Field('name'),Field('ownerperson','reference person'))
db.dog.insert(name='skipper',owner=1) db.dog.insert(name='skipper',ownerperson=1)
row = db(db.person.id==db.dog.owner).select().first() row = db(db.person.id==db.dog.ownerperson).select().first()
self.assertEqual(row[db.person.name],'max') self.assertEqual(row[db.person.name],'max')
self.assertEqual(row['person.name'],'max') self.assertEqual(row['person.name'],'max')
db.dog.drop() db.dog.drop()
self.assertEqual(len(db.person._referenced_by),0) self.assertEqual(len(db.person._referenced_by),0)
db.person.drop() db.person.drop()
class TestMinMaxSum(unittest.TestCase): class TestMinMaxSumAvg(unittest.TestCase):
def testRun(self): def testRun(self):
db = DAL(DEFAULT_URI) db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('t', Field('a', 'integer')) db.define_table('tt', Field('aa', 'integer'))
self.assertEqual(db.t.insert(a=1), 1) self.assertEqual(db.tt.insert(aa=1), 1)
self.assertEqual(db.t.insert(a=2), 2) self.assertEqual(db.tt.insert(aa=2), 2)
self.assertEqual(db.t.insert(a=3), 3) self.assertEqual(db.tt.insert(aa=3), 3)
s = db.t.a.min() s = db.tt.aa.min()
self.assertEqual(db(db.t.id > 0).select(s)[0]._extra[s], 1) self.assertEqual(db(db.tt.id > 0).select(s)[0]._extra[s], 1)
self.assertEqual(db(db.t.id > 0).select(s).first()[s], 1) self.assertEqual(db(db.tt.id > 0).select(s).first()[s], 1)
self.assertEqual(db().select(s).first()[s], 1) self.assertEqual(db().select(s).first()[s], 1)
s = db.t.a.max() s = db.tt.aa.max()
self.assertEqual(db().select(s).first()[s], 3) self.assertEqual(db().select(s).first()[s], 3)
s = db.t.a.sum() s = db.tt.aa.sum()
self.assertEqual(db().select(s).first()[s], 6) self.assertEqual(db().select(s).first()[s], 6)
s = db.t.a.count() s = db.tt.aa.count()
self.assertEqual(db().select(s).first()[s], 3) self.assertEqual(db().select(s).first()[s], 3)
db.t.drop() s = db.tt.aa.avg()
self.assertEqual(db().select(s).first()[s], 2)
db.tt.drop()
class TestCache(unittest.TestCase): class TestCache(unittest.TestCase):
def testRun(self): def testRun(self):
from cache import CacheInRam from cache import CacheInRam
cache = CacheInRam() cache = CacheInRam()
db = DAL(DEFAULT_URI) db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('t', Field('a')) db.define_table('tt', Field('aa'))
db.t.insert(a='1') db.tt.insert(aa='1')
r0 = db().select(db.t.ALL) r0 = db().select(db.tt.ALL)
r1 = db().select(db.t.ALL, cache=(cache, 1000)) r1 = db().select(db.tt.ALL, cache=(cache, 1000))
self.assertEqual(len(r0),len(r1)) self.assertEqual(len(r0),len(r1))
r2 = db().select(db.t.ALL, cache=(cache, 1000)) r2 = db().select(db.tt.ALL, cache=(cache, 1000))
self.assertEqual(len(r0),len(r2)) self.assertEqual(len(r0),len(r2))
r3 = db().select(db.t.ALL, cache=(cache, 1000), cacheable=True) r3 = db().select(db.tt.ALL, cache=(cache, 1000), cacheable=True)
self.assertEqual(len(r0),len(r3)) self.assertEqual(len(r0),len(r3))
r4 = db().select(db.t.ALL, cache=(cache, 1000), cacheable=True) r4 = db().select(db.tt.ALL, cache=(cache, 1000), cacheable=True)
self.assertEqual(len(r0),len(r4)) self.assertEqual(len(r0),len(r4))
db.t.drop() db.tt.drop()
class TestMigrations(unittest.TestCase): class TestMigrations(unittest.TestCase):
def testRun(self): def testRun(self):
db = DAL(DEFAULT_URI) db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('t', Field('a'), migrate='.storage.table') db.define_table('tt', Field('aa'), migrate='.storage.table')
db.commit() db.commit()
db.close() db.close()
db = DAL(DEFAULT_URI) db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('t', Field('a'), Field('b'), db.define_table('tt', Field('aa'), Field('b'),
migrate='.storage.table') migrate='.storage.table')
db.commit() db.commit()
db.close() db.close()
db = DAL(DEFAULT_URI) db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('t', Field('a'), Field('b', 'text'), db.define_table('tt', Field('aa'), Field('b', 'text'),
migrate='.storage.table') migrate='.storage.table')
db.commit() db.commit()
db.close() db.close()
db = DAL(DEFAULT_URI) db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('t', Field('a'), migrate='.storage.table') db.define_table('tt', Field('aa'), migrate='.storage.table')
db.t.drop() db.tt.drop()
db.commit() db.commit()
db.close() db.close()
@@ -512,78 +514,78 @@ class TestMigrations(unittest.TestCase):
class TestReference(unittest.TestCase): class TestReference(unittest.TestCase):
def testRun(self): def testRun(self):
db = DAL(DEFAULT_URI) db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('t', Field('name'), Field('a','reference t')) db.define_table('tt', Field('name'), Field('aa','reference tt'))
db.commit() db.commit()
x = db.t.insert(name='max') x = db.tt.insert(name='max')
assert x.id == 1 assert x.id == 1
assert x['id'] == 1 assert x['id'] == 1
x.a = x x.aa = x
assert x.a == 1 assert x.aa == 1
x.update_record() x.update_record()
y = db.t[1] y = db.tt[1]
assert y.a == 1 assert y.aa == 1
assert y.a.a.a.a.a.a.name == 'max' assert y.aa.aa.aa.aa.aa.aa.name == 'max'
z=db.t.insert(name='xxx', a = y) z=db.tt.insert(name='xxx', aa = y)
assert z.a == y.id assert z.aa == y.id
db.t.drop() db.tt.drop()
db.commit() db.commit()
class TestClientLevelOps(unittest.TestCase): class TestClientLevelOps(unittest.TestCase):
def testRun(self): def testRun(self):
db = DAL(DEFAULT_URI) db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('t', Field('a')) db.define_table('tt', Field('aa'))
db.commit() db.commit()
db.t.insert(a="test") db.tt.insert(aa="test")
rows1 = db(db.t.id>0).select() rows1 = db(db.tt.id>0).select()
rows2 = db(db.t.id>0).select() rows2 = db(db.tt.id>0).select()
rows3 = rows1 & rows2 rows3 = rows1 & rows2
assert len(rows3) == 2 assert len(rows3) == 2
rows4 = rows1 | rows2 rows4 = rows1 | rows2
assert len(rows4) == 1 assert len(rows4) == 1
rows5 = rows1.find(lambda row: row.a=="test") rows5 = rows1.find(lambda row: row.aa=="test")
assert len(rows5) == 1 assert len(rows5) == 1
rows6 = rows2.exclude(lambda row: row.a=="test") rows6 = rows2.exclude(lambda row: row.aa=="test")
assert len(rows6) == 1 assert len(rows6) == 1
rows7 = rows5.sort(lambda row: row.a) rows7 = rows5.sort(lambda row: row.aa)
assert len(rows7) == 1 assert len(rows7) == 1
db.t.drop() db.tt.drop()
db.commit() db.commit()
class TestVirtualFields(unittest.TestCase): class TestVirtualFields(unittest.TestCase):
def testRun(self): def testRun(self):
db = DAL(DEFAULT_URI) db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('t', Field('a')) db.define_table('tt', Field('aa'))
db.commit() db.commit()
db.t.insert(a="test") db.tt.insert(aa="test")
class Compute: class Compute:
def a_upper(row): return row.t.a.upper() def a_upper(row): return row.tt.aa.upper()
db.t.virtualfields.append(Compute()) db.tt.virtualfields.append(Compute())
assert db(db.t.id>0).select().first().a_upper == 'TEST' assert db(db.tt.id>0).select().first().a_upper == 'TEST'
db.t.drop() db.tt.drop()
db.commit() db.commit()
class TestComputedFields(unittest.TestCase): class TestComputedFields(unittest.TestCase):
def testRun(self): def testRun(self):
db = DAL(DEFAULT_URI) db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('t', db.define_table('tt',
Field('a'), Field('aa'),
Field('b',default='x'), Field('bb',default='x'),
Field('c',compute=lambda r: r.a+r.b)) Field('cc',compute=lambda r: r.aa+r.bb))
db.commit() db.commit()
id = db.t.insert(a="z") id = db.tt.insert(aa="z")
self.assertEqual(db.t[id].c,'zx') self.assertEqual(db.tt[id].cc,'zx')
db.t.drop() db.tt.drop()
db.commit() db.commit()
class TestImportExportFields(unittest.TestCase): class TestImportExportFields(unittest.TestCase):
def testRun(self): def testRun(self):
db = DAL(DEFAULT_URI) db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('person', Field('name')) db.define_table('person', Field('name'))
db.define_table('pet',Field('friend',db.person),Field('name')) db.define_table('pet',Field('friend',db.person),Field('name'))
for n in range(2): for n in range(2):
@@ -607,7 +609,7 @@ class TestImportExportFields(unittest.TestCase):
class TestImportExportUuidFields(unittest.TestCase): class TestImportExportUuidFields(unittest.TestCase):
def testRun(self): def testRun(self):
db = DAL(DEFAULT_URI) db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('person', Field('name'),Field('uuid')) db.define_table('person', Field('name'),Field('uuid'))
db.define_table('pet',Field('friend',db.person),Field('name')) db.define_table('pet',Field('friend',db.person),Field('name'))
for n in range(2): for n in range(2):
@@ -631,7 +633,7 @@ class TestImportExportUuidFields(unittest.TestCase):
class TestDALDictImportExport(unittest.TestCase): class TestDALDictImportExport(unittest.TestCase):
def testRun(self): def testRun(self):
db = DAL(DEFAULT_URI) db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('person', Field('name', default="Michael"),Field('uuid')) db.define_table('person', Field('name', default="Michael"),Field('uuid'))
db.define_table('pet',Field('friend',db.person),Field('name')) db.define_table('pet',Field('friend',db.person),Field('name'))
dbdict = db.as_dict(flat=True, sanitize=False) dbdict = db.as_dict(flat=True, sanitize=False)
@@ -644,9 +646,7 @@ class TestDALDictImportExport(unittest.TestCase):
assert dbdict["items"]["person"]["items"]["name"]["default"] == db.person.name.default assert dbdict["items"]["person"]["items"]["name"]["default"] == db.person.name.default
assert dbdict assert dbdict
db2 = DAL(dbdict, check_reserved=['all'])
db2 = DAL(dbdict)
assert len(db.tables) == len(db2.tables) assert len(db.tables) == len(db2.tables)
assert hasattr(db2, "pet") and isinstance(db2.pet, Table) assert hasattr(db2, "pet") and isinstance(db2.pet, Table)
assert hasattr(db2.pet, "friend") and isinstance(db2.pet.friend, Field) assert hasattr(db2.pet, "friend") and isinstance(db2.pet.friend, Field)
@@ -679,51 +679,51 @@ class TestDALDictImportExport(unittest.TestCase):
{"default":"Michael"}, {"default":"Michael"},
"food": "food":
{"default":"Spam"}, {"default":"Spam"},
"show": "tvshow":
{"type": "reference show"} {"type": "reference tvshow"}
}}, }},
"show":{"items": {"name": "tvshow":{"items": {"name":
{"default":mpfc}, {"default":mpfc},
"rating": "rating":
{"type":"double"}}}}} {"type":"double"}}}}}
db4 = DAL(dbdict4) db4 = DAL(dbdict4, check_reserved=['all'])
assert "staff" in db4.tables assert "staff" in db4.tables
assert "name" in db4.staff assert "name" in db4.staff
assert db4.show.rating.type == "double" assert db4.tvshow.rating.type == "double"
assert (db4.show.insert(), db4.show.insert(name="Loriot"), assert (db4.tvshow.insert(), db4.tvshow.insert(name="Loriot"),
db4.show.insert(name="Il Mattatore")) == (1, 2, 3) db4.tvshow.insert(name="Il Mattatore")) == (1, 2, 3)
assert db4(db4.show).select().first().id == 1 assert db4(db4.tvshow).select().first().id == 1
assert db4(db4.show).select().first().name == mpfc assert db4(db4.tvshow).select().first().name == mpfc
db4.staff.drop() db4.staff.drop()
db4.show.drop() db4.tvshow.drop()
db4.commit() db4.commit()
dbdict5 = {"uri": DEFAULT_URI} dbdict5 = {"uri": DEFAULT_URI}
db5 = DAL(dbdict5) db5 = DAL(dbdict5, check_reserved=['all'])
assert db5.tables in ([], None) assert db5.tables in ([], None)
assert not (str(db5) in ("", None)) assert not (str(db5) in ("", None))
dbdict6 = {"uri": DEFAULT_URI, dbdict6 = {"uri": DEFAULT_URI,
"items":{"staff":{}, "items":{"staff":{},
"show":{"items": {"name": {}, "tvshow":{"items": {"name": {},
"rating": "rating":
{"type":"double"} {"type":"double"}
} }
} }
} }
} }
db6 = DAL(dbdict6) db6 = DAL(dbdict6, check_reserved=['all'])
assert len(db6["staff"].fields) == 1 assert len(db6["staff"].fields) == 1
assert "name" in db6["show"].fields assert "name" in db6["tvshow"].fields
assert db6.staff.insert() is not None assert db6.staff.insert() is not None
assert db6(db6.staff).select().first().id == 1 assert db6(db6.staff).select().first().id == 1
db6.staff.drop() db6.staff.drop()
db6.show.drop() db6.tvshow.drop()
db6.commit() db6.commit()