code-cc4667ef3f12/test/.cvsignore 0000644 0000000 0000000 00000000046 10030631223 014704 0 ustar 0000000 0000000 *.pyc
*.pyo
localconfig.py
db
*.cover
code-cc4667ef3f12/test/README.txt 0000644 0000000 0000000 00000001371 10030631223 014404 0 ustar 0000000 0000000 $Id: README.txt,v 1.2 2001-07-29 07:01:39 richard Exp $
Structure of the tests:
1 Test date classes
1.1 Date
1.2 Interval
2 Set up schema
3 Open with specific backend
3.1 anydbm
3.2 bsddb
4 Create database base set (stati, priority, etc)
5 Perform some actions
6 Perform mail import
6.1 text/plain
6.2 multipart/mixed (with one text/plain)
6.3 text/html
6.4 multipart/alternative (with one text/plain)
6.5 multipart/alternative (with no text/plain)
------
$Log: not supported by cvs2svn $
Revision 1.1 2001/07/27 07:16:21 richard
rename for consistency
Revision 1.1 2001/07/27 06:55:07 richard
moving tests -> test
Revision 1.2 2001/07/25 04:34:31 richard
Added id and log to tests files...
code-cc4667ef3f12/test/__init__.py 0000644 0000000 0000000 00000000032 10030631223 015010 0 ustar 0000000 0000000 # make this dir a package
code-cc4667ef3f12/test/benchmark.py 0000644 0000000 0000000 00000012024 10030631223 015207 0 ustar 0000000 0000000 import sys, os, time, shutil
from roundup.hyperdb import String, Password, Link, Multilink, Date, \
Interval, DatabaseError, Boolean, Number
from roundup import date, password
from roundup.indexer import Indexer
def setupSchema(db, module):
status = module.Class(db, "status", name=String())
status.setkey("name")
user = module.Class(db, "user", username=String(), password=Password(),
assignable=Boolean(), age=Number(), roles=String())
user.setkey("username")
file = module.FileClass(db, "file", name=String(), type=String(),
comment=String(indexme="yes"))
issue = module.IssueClass(db, "issue", title=String(indexme="yes"),
status=Link("status"), nosy=Multilink("user"), deadline=Date(),
foo=Interval(), files=Multilink("file"), assignedto=Link('user'))
session = module.Class(db, 'session', title=String())
session.disableJournalling()
db.post_init()
db.commit()
class config:
DATABASE='_benchmark'
GADFLY_DATABASE = ('test', DATABASE)
MAILHOST = 'localhost'
MAIL_DOMAIN = 'fill.me.in.'
TRACKER_NAME = 'Roundup issue tracker'
TRACKER_EMAIL = 'issue_tracker@%s'%MAIL_DOMAIN
TRACKER_WEB = 'http://some.useful.url/'
ADMIN_EMAIL = 'roundup-admin@%s'%MAIL_DOMAIN
FILTER_POSITION = 'bottom' # one of 'top', 'bottom', 'top and bottom'
ANONYMOUS_ACCESS = 'deny' # either 'deny' or 'allow'
ANONYMOUS_REGISTER = 'deny' # either 'deny' or 'allow'
MESSAGES_TO_AUTHOR = 'no' # either 'yes' or 'no'
EMAIL_SIGNATURE_POSITION = 'bottom'
def main(backendname, time=time.time, numissues=10):
try:
exec('from roundup.backends import %s as backend'%backendname)
except ImportError:
return
times = []
config.DATABASE = os.path.join('_benchmark', '%s-%s'%(backendname,
numissues))
if not os.path.exists(config.DATABASE):
db = backend.Database(config, 'admin')
setupSchema(db, backend)
# create a whole bunch of stuff
db.user.create(**{'username': 'admin'})
db.status.create(name="unread")
db.status.create(name="in-progress")
db.status.create(name="testing")
db.status.create(name="resolved")
pc = -1
for i in range(numissues):
db.user.create(**{'username': 'user %s'%i})
for j in range(10):
db.user.set(str(i+1), assignable=1)
db.user.set(str(i+1), assignable=0)
db.issue.create(**{'title': 'issue %s'%i})
for j in range(10):
db.issue.set(str(i+1), status='2', assignedto='2', nosy=[])
db.issue.set(str(i+1), status='1', assignedto='1',
nosy=['1','2'])
if (i*100/numissues) != pc:
pc = (i*100/numissues)
sys.stdout.write("%d%%\r"%pc)
sys.stdout.flush()
db.commit()
else:
db = backend.Database(config, 'admin')
setupSchema(db, backend)
sys.stdout.write('%7s: %-6d'%(backendname, numissues))
sys.stdout.flush()
times.append(('start', time()))
# fetch
db.clearCache()
for i in db.issue.list():
db.issue.get(i, 'title')
times.append(('fetch', time()))
# journals
db.clearCache()
for i in db.issue.list():
db.issue.history(i)
times.append(('journal', time()))
# "calculated" props
db.clearCache()
for i in db.issue.list():
db.issue.get(i, 'activity')
db.issue.get(i, 'creator')
db.issue.get(i, 'creation')
times.append(('jprops', time()))
# lookup
db.clearCache()
for i in range(numissues):
db.user.lookup('user %s'%i)
times.append(('lookup', time()))
# filter
db.clearCache()
for i in range(100):
db.issue.filter(None, {'assignedto': '1', 'title':'issue'},
('+', 'activity'), ('+', 'status'))
times.append(('filter', time()))
# filter with multilink
db.clearCache()
for i in range(100):
db.issue.filter(None, {'nosy': ['1'], 'assignedto': '1',
'title':'issue'}, ('+', 'activity'), ('+', 'status'))
times.append(('filtml', time()))
# results
last = None
for event, stamp in times:
if last is None:
first = stamp
else:
sys.stdout.write(' %-6.2f'%(stamp-last))
last = stamp
print ' %-6.2f'%(last-first)
sys.stdout.flush()
if __name__ == '__main__':
# 0 1 2 3 4 5 6
# 01234567890123456789012345678901234567890123456789012345678901234
print 'Test name fetch journl jprops lookup filter filtml TOTAL '
for name in 'anydbm bsddb bsddb3 metakit sqlite'.split():
main(name)
for name in 'anydbm bsddb bsddb3 metakit sqlite'.split():
main(name, numissues=20)
for name in 'anydbm bsddb bsddb3 metakit sqlite'.split():
main(name, numissues=100)
# don't even bother benchmarking the dbm backends > 100!
for name in 'metakit sqlite'.split():
main(name, numissues=1000)
code-cc4667ef3f12/test/db_test_base.py 0000644 0000000 0000000 00000143720 10030631223 015703 0 ustar 0000000 0000000 #
# Copyright (c) 2001 Bizar Software Pty Ltd (http://www.bizarsoftware.com.au/)
# This module is free software, and you may redistribute it and/or modify
# under the same terms as Python, so long as this copyright message and
# disclaimer are retained in their original form.
#
# IN NO EVENT SHALL BIZAR SOFTWARE PTY LTD BE LIABLE TO ANY PARTY FOR
# DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING
# OUT OF THE USE OF THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# BIZAR SOFTWARE PTY LTD SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
# BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE. THE CODE PROVIDED HEREUNDER IS ON AN "AS IS"
# BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
# SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
#
# $Id: db_test_base.py,v 1.20 2004-03-24 04:57:25 richard Exp $
import unittest, os, shutil, errno, imp, sys, time, pprint
from roundup.hyperdb import String, Password, Link, Multilink, Date, \
Interval, DatabaseError, Boolean, Number, Node
from roundup import date, password
from roundup import init
def setupSchema(db, create, module):
status = module.Class(db, "status", name=String())
status.setkey("name")
user = module.Class(db, "user", username=String(), password=Password(),
assignable=Boolean(), age=Number(), roles=String())
user.setkey("username")
file = module.FileClass(db, "file", name=String(), type=String(),
comment=String(indexme="yes"), fooz=Password())
issue = module.IssueClass(db, "issue", title=String(indexme="yes"),
status=Link("status"), nosy=Multilink("user"), deadline=Date(),
foo=Interval(), files=Multilink("file"), assignedto=Link('user'))
stuff = module.Class(db, "stuff", stuff=String())
session = module.Class(db, 'session', title=String())
session.disableJournalling()
db.post_init()
if create:
user.create(username="admin", roles='Admin',
password=password.Password('sekrit'))
user.create(username="fred", roles='User',
password=password.Password('sekrit'))
status.create(name="unread")
status.create(name="in-progress")
status.create(name="testing")
status.create(name="resolved")
db.commit()
class MyTestCase(unittest.TestCase):
def tearDown(self):
if hasattr(self, 'db'):
self.db.close()
if os.path.exists(config.DATABASE):
shutil.rmtree(config.DATABASE)
class config:
DATABASE='_test_dir'
MAILHOST = 'localhost'
MAIL_DOMAIN = 'fill.me.in.'
TRACKER_NAME = 'Roundup issue tracker'
TRACKER_EMAIL = 'issue_tracker@%s'%MAIL_DOMAIN
TRACKER_WEB = 'http://some.useful.url/'
ADMIN_EMAIL = 'roundup-admin@%s'%MAIL_DOMAIN
FILTER_POSITION = 'bottom' # one of 'top', 'bottom', 'top and bottom'
ANONYMOUS_ACCESS = 'deny' # either 'deny' or 'allow'
ANONYMOUS_REGISTER = 'deny' # either 'deny' or 'allow'
MESSAGES_TO_AUTHOR = 'no' # either 'yes' or 'no'
EMAIL_SIGNATURE_POSITION = 'bottom'
class DBTest(MyTestCase):
def setUp(self):
# remove previous test, ignore errors
if os.path.exists(config.DATABASE):
shutil.rmtree(config.DATABASE)
os.makedirs(config.DATABASE + '/files')
self.db = self.module.Database(config, 'admin')
setupSchema(self.db, 1, self.module)
def testRefresh(self):
self.db.refresh_database()
#
# automatic properties (well, the two easy ones anyway)
#
def testCreatorProperty(self):
i = self.db.issue
id1 = i.create(title='spam')
self.db.commit()
self.db.close()
self.db = self.module.Database(config, 'fred')
setupSchema(self.db, 0, self.module)
i = self.db.issue
id2 = i.create(title='spam')
self.assertNotEqual(id1, id2)
self.assertNotEqual(i.get(id1, 'creator'), i.get(id2, 'creator'))
def testActorProperty(self):
i = self.db.issue
id1 = i.create(title='spam')
self.db.commit()
self.db.close()
self.db = self.module.Database(config, 'fred')
setupSchema(self.db, 0, self.module)
i = self.db.issue
i.set(id1, title='asfasd')
self.assertNotEqual(i.get(id1, 'creator'), i.get(id1, 'actor'))
# ID number controls
def testIDGeneration(self):
id1 = self.db.issue.create(title="spam", status='1')
id2 = self.db.issue.create(title="eggs", status='2')
self.assertNotEqual(id1, id2)
def testIDSetting(self):
# XXX numeric ids
self.db.setid('issue', 10)
id2 = self.db.issue.create(title="eggs", status='2')
self.assertEqual('11', id2)
#
# basic operations
#
def testEmptySet(self):
id1 = self.db.issue.create(title="spam", status='1')
self.db.issue.set(id1)
# String
def testStringChange(self):
for commit in (0,1):
# test set & retrieve
nid = self.db.issue.create(title="spam", status='1')
self.assertEqual(self.db.issue.get(nid, 'title'), 'spam')
# change and make sure we retrieve the correct value
self.db.issue.set(nid, title='eggs')
if commit: self.db.commit()
self.assertEqual(self.db.issue.get(nid, 'title'), 'eggs')
def testStringUnset(self):
for commit in (0,1):
nid = self.db.issue.create(title="spam", status='1')
if commit: self.db.commit()
self.assertEqual(self.db.issue.get(nid, 'title'), 'spam')
# make sure we can unset
self.db.issue.set(nid, title=None)
if commit: self.db.commit()
self.assertEqual(self.db.issue.get(nid, "title"), None)
# FileClass "content" property (no unset test)
def testFileClassContentChange(self):
for commit in (0,1):
# test set & retrieve
nid = self.db.file.create(content="spam")
self.assertEqual(self.db.file.get(nid, 'content'), 'spam')
# change and make sure we retrieve the correct value
self.db.file.set(nid, content='eggs')
if commit: self.db.commit()
self.assertEqual(self.db.file.get(nid, 'content'), 'eggs')
# Link
def testLinkChange(self):
self.assertRaises(IndexError, self.db.issue.create, title="spam",
status='100')
for commit in (0,1):
nid = self.db.issue.create(title="spam", status='1')
if commit: self.db.commit()
self.assertEqual(self.db.issue.get(nid, "status"), '1')
self.db.issue.set(nid, status='2')
if commit: self.db.commit()
self.assertEqual(self.db.issue.get(nid, "status"), '2')
def testLinkUnset(self):
for commit in (0,1):
nid = self.db.issue.create(title="spam", status='1')
if commit: self.db.commit()
self.db.issue.set(nid, status=None)
if commit: self.db.commit()
self.assertEqual(self.db.issue.get(nid, "status"), None)
# Multilink
def testMultilinkChange(self):
for commit in (0,1):
self.assertRaises(IndexError, self.db.issue.create, title="spam",
nosy=['foo%s'%commit])
u1 = self.db.user.create(username='foo%s'%commit)
u2 = self.db.user.create(username='bar%s'%commit)
nid = self.db.issue.create(title="spam", nosy=[u1])
if commit: self.db.commit()
self.assertEqual(self.db.issue.get(nid, "nosy"), [u1])
self.db.issue.set(nid, nosy=[])
if commit: self.db.commit()
self.assertEqual(self.db.issue.get(nid, "nosy"), [])
self.db.issue.set(nid, nosy=[u1,u2])
if commit: self.db.commit()
l = [u1,u2]; l.sort()
m = self.db.issue.get(nid, "nosy"); m.sort()
self.assertEqual(l, m)
# Date
def testDateChange(self):
self.assertRaises(TypeError, self.db.issue.create,
title='spam', deadline=1)
for commit in (0,1):
nid = self.db.issue.create(title="spam", status='1')
self.assertRaises(TypeError, self.db.issue.set, nid, deadline=1)
a = self.db.issue.get(nid, "deadline")
if commit: self.db.commit()
self.db.issue.set(nid, deadline=date.Date())
b = self.db.issue.get(nid, "deadline")
if commit: self.db.commit()
self.assertNotEqual(a, b)
self.assertNotEqual(b, date.Date('1970-1-1 00:00:00'))
def testDateUnset(self):
for commit in (0,1):
nid = self.db.issue.create(title="spam", status='1')
self.db.issue.set(nid, deadline=date.Date())
if commit: self.db.commit()
self.assertNotEqual(self.db.issue.get(nid, "deadline"), None)
self.db.issue.set(nid, deadline=None)
if commit: self.db.commit()
self.assertEqual(self.db.issue.get(nid, "deadline"), None)
# Interval
def testIntervalChange(self):
self.assertRaises(TypeError, self.db.issue.create,
title='spam', foo=1)
for commit in (0,1):
nid = self.db.issue.create(title="spam", status='1')
self.assertRaises(TypeError, self.db.issue.set, nid, foo=1)
if commit: self.db.commit()
a = self.db.issue.get(nid, "foo")
i = date.Interval('-1d')
self.db.issue.set(nid, foo=i)
if commit: self.db.commit()
self.assertNotEqual(self.db.issue.get(nid, "foo"), a)
self.assertEqual(i, self.db.issue.get(nid, "foo"))
j = date.Interval('1y')
self.db.issue.set(nid, foo=j)
if commit: self.db.commit()
self.assertNotEqual(self.db.issue.get(nid, "foo"), i)
self.assertEqual(j, self.db.issue.get(nid, "foo"))
def testIntervalUnset(self):
for commit in (0,1):
nid = self.db.issue.create(title="spam", status='1')
self.db.issue.set(nid, foo=date.Interval('-1d'))
if commit: self.db.commit()
self.assertNotEqual(self.db.issue.get(nid, "foo"), None)
self.db.issue.set(nid, foo=None)
if commit: self.db.commit()
self.assertEqual(self.db.issue.get(nid, "foo"), None)
# Boolean
def testBooleanChange(self):
userid = self.db.user.create(username='foo', assignable=1)
self.assertEqual(1, self.db.user.get(userid, 'assignable'))
self.db.user.set(userid, assignable=0)
self.assertEqual(self.db.user.get(userid, 'assignable'), 0)
def testBooleanUnset(self):
nid = self.db.user.create(username='foo', assignable=1)
self.db.user.set(nid, assignable=None)
self.assertEqual(self.db.user.get(nid, "assignable"), None)
# Number
def testNumberChange(self):
nid = self.db.user.create(username='foo', age=1)
self.assertEqual(1, self.db.user.get(nid, 'age'))
self.db.user.set(nid, age=3)
self.assertNotEqual(self.db.user.get(nid, 'age'), 1)
self.db.user.set(nid, age=1.0)
self.assertEqual(self.db.user.get(nid, 'age'), 1)
self.db.user.set(nid, age=0)
self.assertEqual(self.db.user.get(nid, 'age'), 0)
nid = self.db.user.create(username='bar', age=0)
self.assertEqual(self.db.user.get(nid, 'age'), 0)
def testNumberUnset(self):
nid = self.db.user.create(username='foo', age=1)
self.db.user.set(nid, age=None)
self.assertEqual(self.db.user.get(nid, "age"), None)
# Password
def testPasswordChange(self):
x = password.Password('x')
userid = self.db.user.create(username='foo', password=x)
self.assertEqual(x, self.db.user.get(userid, 'password'))
self.assertEqual(self.db.user.get(userid, 'password'), 'x')
y = password.Password('y')
self.db.user.set(userid, password=y)
self.assertEqual(self.db.user.get(userid, 'password'), 'y')
self.assertRaises(TypeError, self.db.user.create, userid,
username='bar', password='x')
self.assertRaises(TypeError, self.db.user.set, userid, password='x')
def testPasswordUnset(self):
x = password.Password('x')
nid = self.db.user.create(username='foo', password=x)
self.db.user.set(nid, assignable=None)
self.assertEqual(self.db.user.get(nid, "assignable"), None)
# key value
def testKeyValue(self):
self.assertRaises(ValueError, self.db.user.create)
newid = self.db.user.create(username="spam")
self.assertEqual(self.db.user.lookup('spam'), newid)
self.db.commit()
self.assertEqual(self.db.user.lookup('spam'), newid)
self.db.user.retire(newid)
self.assertRaises(KeyError, self.db.user.lookup, 'spam')
# use the key again now that the old is retired
newid2 = self.db.user.create(username="spam")
self.assertNotEqual(newid, newid2)
# try to restore old node. this shouldn't succeed!
self.assertRaises(KeyError, self.db.user.restore, newid)
self.assertRaises(TypeError, self.db.issue.lookup, 'fubar')
# label property
def testLabelProp(self):
# key prop
self.assertEqual(self.db.status.labelprop(), 'name')
self.assertEqual(self.db.user.labelprop(), 'username')
# title
self.assertEqual(self.db.issue.labelprop(), 'title')
# name
self.assertEqual(self.db.file.labelprop(), 'name')
# id
self.assertEqual(self.db.stuff.labelprop(default_to_id=1), 'id')
# retirement
def testRetire(self):
self.db.issue.create(title="spam", status='1')
b = self.db.status.get('1', 'name')
a = self.db.status.list()
self.db.status.retire('1')
# make sure the list is different
self.assertNotEqual(a, self.db.status.list())
# can still access the node if necessary
self.assertEqual(self.db.status.get('1', 'name'), b)
self.assertRaises(IndexError, self.db.status.set, '1', name='hello')
self.db.commit()
self.assertEqual(self.db.status.get('1', 'name'), b)
self.assertNotEqual(a, self.db.status.list())
# try to restore retired node
self.db.status.restore('1')
def testCacheCreateSet(self):
self.db.issue.create(title="spam", status='1')
a = self.db.issue.get('1', 'title')
self.assertEqual(a, 'spam')
self.db.issue.set('1', title='ham')
b = self.db.issue.get('1', 'title')
self.assertEqual(b, 'ham')
def testSerialisation(self):
nid = self.db.issue.create(title="spam", status='1',
deadline=date.Date(), foo=date.Interval('-1d'))
self.db.commit()
assert isinstance(self.db.issue.get(nid, 'deadline'), date.Date)
assert isinstance(self.db.issue.get(nid, 'foo'), date.Interval)
uid = self.db.user.create(username="fozzy",
password=password.Password('t. bear'))
self.db.commit()
assert isinstance(self.db.user.get(uid, 'password'), password.Password)
def testTransactions(self):
# remember the number of items we started
num_issues = len(self.db.issue.list())
num_files = self.db.numfiles()
self.db.issue.create(title="don't commit me!", status='1')
self.assertNotEqual(num_issues, len(self.db.issue.list()))
self.db.rollback()
self.assertEqual(num_issues, len(self.db.issue.list()))
self.db.issue.create(title="please commit me!", status='1')
self.assertNotEqual(num_issues, len(self.db.issue.list()))
self.db.commit()
self.assertNotEqual(num_issues, len(self.db.issue.list()))
self.db.rollback()
self.assertNotEqual(num_issues, len(self.db.issue.list()))
self.db.file.create(name="test", type="text/plain", content="hi")
self.db.rollback()
self.assertEqual(num_files, self.db.numfiles())
for i in range(10):
self.db.file.create(name="test", type="text/plain",
content="hi %d"%(i))
self.db.commit()
num_files2 = self.db.numfiles()
self.assertNotEqual(num_files, num_files2)
self.db.file.create(name="test", type="text/plain", content="hi")
self.db.rollback()
self.assertNotEqual(num_files, self.db.numfiles())
self.assertEqual(num_files2, self.db.numfiles())
# rollback / cache interaction
name1 = self.db.user.get('1', 'username')
self.db.user.set('1', username = name1+name1)
# get the prop so the info's forced into the cache (if there is one)
self.db.user.get('1', 'username')
self.db.rollback()
name2 = self.db.user.get('1', 'username')
self.assertEqual(name1, name2)
def testDestroyNoJournalling(self):
self.innerTestDestroy(klass=self.db.session)
def testDestroyJournalling(self):
self.innerTestDestroy(klass=self.db.issue)
def innerTestDestroy(self, klass):
newid = klass.create(title='Mr Friendly')
n = len(klass.list())
self.assertEqual(klass.get(newid, 'title'), 'Mr Friendly')
count = klass.count()
klass.destroy(newid)
self.assertNotEqual(count, klass.count())
self.assertRaises(IndexError, klass.get, newid, 'title')
self.assertNotEqual(len(klass.list()), n)
if klass.do_journal:
self.assertRaises(IndexError, klass.history, newid)
# now with a commit
newid = klass.create(title='Mr Friendly')
n = len(klass.list())
self.assertEqual(klass.get(newid, 'title'), 'Mr Friendly')
self.db.commit()
count = klass.count()
klass.destroy(newid)
self.assertNotEqual(count, klass.count())
self.assertRaises(IndexError, klass.get, newid, 'title')
self.db.commit()
self.assertRaises(IndexError, klass.get, newid, 'title')
self.assertNotEqual(len(klass.list()), n)
if klass.do_journal:
self.assertRaises(IndexError, klass.history, newid)
# now with a rollback
newid = klass.create(title='Mr Friendly')
n = len(klass.list())
self.assertEqual(klass.get(newid, 'title'), 'Mr Friendly')
self.db.commit()
count = klass.count()
klass.destroy(newid)
self.assertNotEqual(len(klass.list()), n)
self.assertRaises(IndexError, klass.get, newid, 'title')
self.db.rollback()
self.assertEqual(count, klass.count())
self.assertEqual(klass.get(newid, 'title'), 'Mr Friendly')
self.assertEqual(len(klass.list()), n)
if klass.do_journal:
self.assertNotEqual(klass.history(newid), [])
def testExceptions(self):
# this tests the exceptions that should be raised
ar = self.assertRaises
ar(KeyError, self.db.getclass, 'fubar')
#
# class create
#
# string property
ar(TypeError, self.db.status.create, name=1)
# id, creation, creator and activity properties are reserved
ar(KeyError, self.db.status.create, id=1)
ar(KeyError, self.db.status.create, creation=1)
ar(KeyError, self.db.status.create, creator=1)
ar(KeyError, self.db.status.create, activity=1)
ar(KeyError, self.db.status.create, actor=1)
# invalid property name
ar(KeyError, self.db.status.create, foo='foo')
# key name clash
ar(ValueError, self.db.status.create, name='unread')
# invalid link index
ar(IndexError, self.db.issue.create, title='foo', status='bar')
# invalid link value
ar(ValueError, self.db.issue.create, title='foo', status=1)
# invalid multilink type
ar(TypeError, self.db.issue.create, title='foo', status='1',
nosy='hello')
# invalid multilink index type
ar(ValueError, self.db.issue.create, title='foo', status='1',
nosy=[1])
# invalid multilink index
ar(IndexError, self.db.issue.create, title='foo', status='1',
nosy=['10'])
#
# key property
#
# key must be a String
ar(TypeError, self.db.file.setkey, 'fooz')
# key must exist
ar(KeyError, self.db.file.setkey, 'fubar')
#
# class get
#
# invalid node id
ar(IndexError, self.db.issue.get, '99', 'title')
# invalid property name
ar(KeyError, self.db.status.get, '2', 'foo')
#
# class set
#
# invalid node id
ar(IndexError, self.db.issue.set, '99', title='foo')
# invalid property name
ar(KeyError, self.db.status.set, '1', foo='foo')
# string property
ar(TypeError, self.db.status.set, '1', name=1)
# key name clash
ar(ValueError, self.db.status.set, '2', name='unread')
# set up a valid issue for me to work on
id = self.db.issue.create(title="spam", status='1')
# invalid link index
ar(IndexError, self.db.issue.set, id, title='foo', status='bar')
# invalid link value
ar(ValueError, self.db.issue.set, id, title='foo', status=1)
# invalid multilink type
ar(TypeError, self.db.issue.set, id, title='foo', status='1',
nosy='hello')
# invalid multilink index type
ar(ValueError, self.db.issue.set, id, title='foo', status='1',
nosy=[1])
# invalid multilink index
ar(IndexError, self.db.issue.set, id, title='foo', status='1',
nosy=['10'])
# NOTE: the following increment the username to avoid problems
# within metakit's backend (it creates the node, and then sets the
# info, so the create (and by a fluke the username set) go through
# before the age/assignable/etc. set, which raises the exception)
# invalid number value
ar(TypeError, self.db.user.create, username='foo', age='a')
# invalid boolean value
ar(TypeError, self.db.user.create, username='foo2', assignable='true')
nid = self.db.user.create(username='foo3')
# invalid number value
ar(TypeError, self.db.user.set, nid, age='a')
# invalid boolean value
ar(TypeError, self.db.user.set, nid, assignable='true')
def testJournals(self):
self.db.user.create(username="mary")
self.db.user.create(username="pete")
self.db.issue.create(title="spam", status='1')
self.db.commit()
# journal entry for issue create
journal = self.db.getjournal('issue', '1')
self.assertEqual(1, len(journal))
(nodeid, date_stamp, journaltag, action, params) = journal[0]
self.assertEqual(nodeid, '1')
self.assertEqual(journaltag, self.db.user.lookup('admin'))
self.assertEqual(action, 'create')
keys = params.keys()
keys.sort()
self.assertEqual(keys, [])
# journal entry for link
journal = self.db.getjournal('user', '1')
self.assertEqual(1, len(journal))
self.db.issue.set('1', assignedto='1')
self.db.commit()
journal = self.db.getjournal('user', '1')
self.assertEqual(2, len(journal))
(nodeid, date_stamp, journaltag, action, params) = journal[1]
self.assertEqual('1', nodeid)
self.assertEqual('1', journaltag)
self.assertEqual('link', action)
self.assertEqual(('issue', '1', 'assignedto'), params)
# journal entry for unlink
self.db.issue.set('1', assignedto='2')
self.db.commit()
journal = self.db.getjournal('user', '1')
self.assertEqual(3, len(journal))
(nodeid, date_stamp, journaltag, action, params) = journal[2]
self.assertEqual('1', nodeid)
self.assertEqual('1', journaltag)
self.assertEqual('unlink', action)
self.assertEqual(('issue', '1', 'assignedto'), params)
# test disabling journalling
# ... get the last entry
jlen = len(self.db.getjournal('user', '1'))
self.db.issue.disableJournalling()
self.db.issue.set('1', title='hello world')
self.db.commit()
# see if the change was journalled when it shouldn't have been
self.assertEqual(jlen, len(self.db.getjournal('user', '1')))
jlen = len(self.db.getjournal('issue', '1'))
self.db.issue.enableJournalling()
self.db.issue.set('1', title='hello world 2')
self.db.commit()
# see if the change was journalled
self.assertNotEqual(jlen, len(self.db.getjournal('issue', '1')))
def testJournalPreCommit(self):
id = self.db.user.create(username="mary")
self.assertEqual(len(self.db.getjournal('user', id)), 1)
self.db.commit()
def testPack(self):
id = self.db.issue.create(title="spam", status='1')
self.db.commit()
self.db.issue.set(id, status='2')
self.db.commit()
# sleep for at least a second, then get a date to pack at
time.sleep(1)
pack_before = date.Date('.')
# wait another second and add one more entry
time.sleep(1)
self.db.issue.set(id, status='3')
self.db.commit()
jlen = len(self.db.getjournal('issue', id))
# pack
self.db.pack(pack_before)
# we should have the create and last set entries now
self.assertEqual(jlen-1, len(self.db.getjournal('issue', id)))
def testIndexerSearching(self):
f1 = self.db.file.create(content='hello', type="text/plain")
# content='world' has the wrong content-type and won't be indexed
f2 = self.db.file.create(content='world', type="text/frozz",
comment='blah blah')
i1 = self.db.issue.create(files=[f1, f2], title="flebble plop")
i2 = self.db.issue.create(title="flebble frooz")
self.db.commit()
self.assertEquals(self.db.indexer.search(['hello'], self.db.issue),
{i1: {'files': [f1]}})
self.assertEquals(self.db.indexer.search(['world'], self.db.issue), {})
self.assertEquals(self.db.indexer.search(['frooz'], self.db.issue),
{i2: {}})
self.assertEquals(self.db.indexer.search(['flebble'], self.db.issue),
{i1: {}, i2: {}})
def testReindexing(self):
search = self.db.indexer.search
issue = self.db.issue
i1 = issue.create(title="flebble plop")
i2 = issue.create(title="flebble frooz")
self.db.commit()
self.assertEquals(search(['plop'], issue), {i1: {}})
self.assertEquals(search(['flebble'], issue), {i1: {}, i2: {}})
# change i1's title
issue.set(i1, title="plop")
self.db.commit()
self.assertEquals(search(['plop'], issue), {i1: {}})
self.assertEquals(search(['flebble'], issue), {i2: {}})
# unset i1's title
issue.set(i1, title="")
self.db.commit()
self.assertEquals(search(['plop'], issue), {})
self.assertEquals(search(['flebble'], issue), {i2: {}})
def testFileClassReindexing(self):
f1 = self.db.file.create(content='hello')
f2 = self.db.file.create(content='hello, world')
i1 = self.db.issue.create(files=[f1, f2])
self.db.commit()
d = self.db.indexer.search(['hello'], self.db.issue)
d[i1]['files'].sort()
self.assertEquals(d, {i1: {'files': [f1, f2]}})
self.assertEquals(self.db.indexer.search(['world'], self.db.issue),
{i1: {'files': [f2]}})
self.db.file.set(f1, content="world")
self.db.commit()
d = self.db.indexer.search(['world'], self.db.issue)
d[i1]['files'].sort()
self.assertEquals(d, {i1: {'files': [f1, f2]}})
self.assertEquals(self.db.indexer.search(['hello'], self.db.issue),
{i1: {'files': [f2]}})
def testForcedReindexing(self):
self.db.issue.create(title="flebble frooz")
self.db.commit()
self.assertEquals(self.db.indexer.search(['flebble'], self.db.issue),
{'1': {}})
self.db.indexer.quiet = 1
self.db.indexer.force_reindex()
self.db.post_init()
self.db.indexer.quiet = 9
self.assertEquals(self.db.indexer.search(['flebble'], self.db.issue),
{'1': {}})
#
# searching tests follow
#
def testFindIncorrectProperty(self):
self.assertRaises(TypeError, self.db.issue.find, title='fubar')
def _find_test_setup(self):
self.db.file.create(content='')
self.db.file.create(content='')
self.db.user.create(username='')
one = self.db.issue.create(status="1", nosy=['1'])
two = self.db.issue.create(status="2", nosy=['2'], files=['1'],
assignedto='2')
three = self.db.issue.create(status="1", nosy=['1','2'])
four = self.db.issue.create(status="3", assignedto='1',
files=['1','2'])
return one, two, three, four
def testFindLink(self):
one, two, three, four = self._find_test_setup()
got = self.db.issue.find(status='1')
got.sort()
self.assertEqual(got, [one, three])
got = self.db.issue.find(status={'1':1})
got.sort()
self.assertEqual(got, [one, three])
def testFindLinkFail(self):
self._find_test_setup()
self.assertEqual(self.db.issue.find(status='4'), [])
self.assertEqual(self.db.issue.find(status={'4':1}), [])
def testFindLinkUnset(self):
one, two, three, four = self._find_test_setup()
got = self.db.issue.find(assignedto=None)
got.sort()
self.assertEqual(got, [one, three])
got = self.db.issue.find(assignedto={None:1})
got.sort()
self.assertEqual(got, [one, three])
def testFindMultilink(self):
one, two, three, four = self._find_test_setup()
got = self.db.issue.find(nosy='2')
got.sort()
self.assertEqual(got, [two, three])
got = self.db.issue.find(nosy={'2':1})
got.sort()
self.assertEqual(got, [two, three])
got = self.db.issue.find(nosy={'2':1}, files={})
got.sort()
self.assertEqual(got, [two, three])
def testFindMultiMultilink(self):
one, two, three, four = self._find_test_setup()
got = self.db.issue.find(nosy='2', files='1')
got.sort()
self.assertEqual(got, [two, three, four])
got = self.db.issue.find(nosy={'2':1}, files={'1':1})
got.sort()
self.assertEqual(got, [two, three, four])
def testFindMultilinkFail(self):
self._find_test_setup()
self.assertEqual(self.db.issue.find(nosy='3'), [])
self.assertEqual(self.db.issue.find(nosy={'3':1}), [])
def testFindMultilinkUnset(self):
self._find_test_setup()
self.assertEqual(self.db.issue.find(nosy={}), [])
def testFindLinkAndMultilink(self):
one, two, three, four = self._find_test_setup()
got = self.db.issue.find(status='1', nosy='2')
got.sort()
self.assertEqual(got, [one, two, three])
got = self.db.issue.find(status={'1':1}, nosy={'2':1})
got.sort()
self.assertEqual(got, [one, two, three])
def testFindRetired(self):
one, two, three, four = self._find_test_setup()
self.assertEqual(len(self.db.issue.find(status='1')), 2)
self.db.issue.retire(one)
self.assertEqual(len(self.db.issue.find(status='1')), 1)
def testStringFind(self):
self.assertRaises(TypeError, self.db.issue.stringFind, status='1')
ids = []
ids.append(self.db.issue.create(title="spam"))
self.db.issue.create(title="not spam")
ids.append(self.db.issue.create(title="spam"))
ids.sort()
got = self.db.issue.stringFind(title='spam')
got.sort()
self.assertEqual(got, ids)
self.assertEqual(self.db.issue.stringFind(title='fubar'), [])
# test retiring a node
self.db.issue.retire(ids[0])
self.assertEqual(len(self.db.issue.stringFind(title='spam')), 1)
def filteringSetup(self):
for user in (
{'username': 'bleep'},
{'username': 'blop'},
{'username': 'blorp'}):
self.db.user.create(**user)
iss = self.db.issue
for issue in (
{'title': 'issue one', 'status': '2', 'assignedto': '1',
'foo': date.Interval('1:10'),
'deadline': date.Date('2003-01-01.00:00')},
{'title': 'issue two', 'status': '1', 'assignedto': '2',
'foo': date.Interval('1d'),
'deadline': date.Date('2003-02-16.22:50')},
{'title': 'issue three', 'status': '1',
'nosy': ['1','2'], 'deadline': date.Date('2003-02-18')},
{'title': 'non four', 'status': '3',
'foo': date.Interval('0:10'),
'nosy': ['1'], 'deadline': date.Date('2004-03-08')}):
self.db.issue.create(**issue)
self.db.commit()
return self.assertEqual, self.db.issue.filter
def testFilteringID(self):
ae, filt = self.filteringSetup()
ae(filt(None, {'id': '1'}, ('+','id'), (None,None)), ['1'])
ae(filt(None, {'id': '2'}, ('+','id'), (None,None)), ['2'])
ae(filt(None, {'id': '10'}, ('+','id'), (None,None)), [])
def testFilteringString(self):
ae, filt = self.filteringSetup()
ae(filt(None, {'title': ['one']}, ('+','id'), (None,None)), ['1'])
ae(filt(None, {'title': ['issue']}, ('+','id'), (None,None)),
['1','2','3'])
ae(filt(None, {'title': ['one', 'two']}, ('+','id'), (None,None)),
['1', '2'])
def testFilteringLink(self):
ae, filt = self.filteringSetup()
ae(filt(None, {'status': '1'}, ('+','id'), (None,None)), ['2','3'])
ae(filt(None, {'assignedto': '-1'}, ('+','id'), (None,None)), ['3','4'])
def testFilteringRetired(self):
ae, filt = self.filteringSetup()
self.db.issue.retire('2')
ae(filt(None, {'status': '1'}, ('+','id'), (None,None)), ['3'])
def testFilteringMultilink(self):
ae, filt = self.filteringSetup()
ae(filt(None, {'nosy': '2'}, ('+','id'), (None,None)), ['3'])
ae(filt(None, {'nosy': '-1'}, ('+','id'), (None,None)), ['1', '2'])
def testFilteringMany(self):
ae, filt = self.filteringSetup()
ae(filt(None, {'nosy': '2', 'status': '1'}, ('+','id'), (None,None)),
['3'])
def testFilteringRange(self):
ae, filt = self.filteringSetup()
# Date ranges
ae(filt(None, {'deadline': 'from 2003-02-10 to 2003-02-23'}), ['2','3'])
ae(filt(None, {'deadline': '2003-02-10; 2003-02-23'}), ['2','3'])
ae(filt(None, {'deadline': '; 2003-02-16'}), ['1'])
# Lets assume people won't invent a time machine, otherwise this test
# may fail :)
ae(filt(None, {'deadline': 'from 2003-02-16'}), ['2', '3', '4'])
ae(filt(None, {'deadline': '2003-02-16;'}), ['2', '3', '4'])
# year and month granularity
ae(filt(None, {'deadline': '2002'}), [])
ae(filt(None, {'deadline': '2003'}), ['1', '2', '3'])
ae(filt(None, {'deadline': '2004'}), ['4'])
ae(filt(None, {'deadline': '2003-02'}), ['2', '3'])
ae(filt(None, {'deadline': '2003-03'}), [])
ae(filt(None, {'deadline': '2003-02-16'}), ['2'])
ae(filt(None, {'deadline': '2003-02-17'}), [])
# Interval ranges
ae(filt(None, {'foo': 'from 0:50 to 2:00'}), ['1'])
ae(filt(None, {'foo': 'from 0:50 to 1d 2:00'}), ['1', '2'])
ae(filt(None, {'foo': 'from 5:50'}), ['2'])
ae(filt(None, {'foo': 'to 0:05'}), [])
def testFilteringIntervalSort(self):
ae, filt = self.filteringSetup()
# ascending should sort None, 1:10, 1d
ae(filt(None, {}, ('+','foo'), (None,None)), ['3', '4', '1', '2'])
# descending should sort 1d, 1:10, None
ae(filt(None, {}, ('-','foo'), (None,None)), ['2', '1', '4', '3'])
# XXX add sorting tests for other types
# XXX test auditors and reactors
def testImportExport(self):
# use the filtering setup to create a bunch of items
ae, filt = self.filteringSetup()
self.db.user.retire('3')
self.db.issue.retire('2')
# grab snapshot of the current database
orig = {}
for cn,klass in self.db.classes.items():
cl = orig[cn] = {}
for id in klass.list():
it = cl[id] = {}
for name in klass.getprops().keys():
it[name] = klass.get(id, name)
# grab the export
export = {}
for cn,klass in self.db.classes.items():
names = klass.getprops().keys()
cl = export[cn] = [names+['is retired']]
for id in klass.getnodeids():
cl.append(klass.export_list(names, id))
# shut down this db and nuke it
self.db.close()
self.nuke_database()
# open a new, empty database
os.makedirs(config.DATABASE + '/files')
self.db = self.module.Database(config, 'admin')
setupSchema(self.db, 0, self.module)
# import
for cn, items in export.items():
klass = self.db.classes[cn]
names = items[0]
maxid = 1
for itemprops in items[1:]:
maxid = max(maxid, int(klass.import_list(names, itemprops)))
self.db.setid(cn, str(maxid+1))
# compare with snapshot of the database
for cn, items in orig.items():
klass = self.db.classes[cn]
propdefs = klass.getprops(1)
# ensure retired items are retired :)
l = items.keys(); l.sort()
m = klass.list(); m.sort()
ae(l, m)
for id, props in items.items():
for name, value in props.items():
l = klass.get(id, name)
if isinstance(value, type([])):
value.sort()
l.sort()
try:
ae(l, value)
except AssertionError:
if not isinstance(propdefs[name], Date):
raise
# don't get hung up on rounding errors
assert not l.__cmp__(value, int_seconds=1)
# make sure the retired items are actually imported
ae(self.db.user.get('4', 'username'), 'blop')
ae(self.db.issue.get('2', 'title'), 'issue two')
# make sure id counters are set correctly
maxid = max([int(id) for id in self.db.user.list()])
newid = self.db.user.create(username='testing')
assert newid > maxid
def testSafeGet(self):
# existent nodeid, existent property
self.assertEqual(self.db.user.safeget('1', 'username'), 'admin')
# nonexistent nodeid, existent property
self.assertEqual(self.db.user.safeget('999', 'username'), None)
# different default
self.assertEqual(self.db.issue.safeget('999', 'nosy', []), [])
def testAddProperty(self):
self.db.issue.create(title="spam", status='1')
self.db.commit()
self.db.issue.addprop(fixer=Link("user"))
# force any post-init stuff to happen
self.db.post_init()
props = self.db.issue.getprops()
keys = props.keys()
keys.sort()
self.assertEqual(keys, ['activity', 'actor', 'assignedto', 'creation',
'creator', 'deadline', 'files', 'fixer', 'foo', 'id', 'messages',
'nosy', 'status', 'superseder', 'title'])
self.assertEqual(self.db.issue.get('1', "fixer"), None)
def testRemoveProperty(self):
self.db.issue.create(title="spam", status='1')
self.db.commit()
del self.db.issue.properties['title']
self.db.post_init()
props = self.db.issue.getprops()
keys = props.keys()
keys.sort()
self.assertEqual(keys, ['activity', 'actor', 'assignedto', 'creation',
'creator', 'deadline', 'files', 'foo', 'id', 'messages',
'nosy', 'status', 'superseder'])
self.assertEqual(self.db.issue.list(), ['1'])
def testAddRemoveProperty(self):
self.db.issue.create(title="spam", status='1')
self.db.commit()
self.db.issue.addprop(fixer=Link("user"))
del self.db.issue.properties['title']
self.db.post_init()
props = self.db.issue.getprops()
keys = props.keys()
keys.sort()
self.assertEqual(keys, ['activity', 'actor', 'assignedto', 'creation',
'creator', 'deadline', 'files', 'fixer', 'foo', 'id', 'messages',
'nosy', 'status', 'superseder'])
self.assertEqual(self.db.issue.list(), ['1'])
class ROTest(MyTestCase):
def setUp(self):
# remove previous test, ignore errors
if os.path.exists(config.DATABASE):
shutil.rmtree(config.DATABASE)
os.makedirs(config.DATABASE + '/files')
self.db = self.module.Database(config, 'admin')
setupSchema(self.db, 1, self.module)
self.db.close()
self.db = self.module.Database(config)
setupSchema(self.db, 0, self.module)
def testExceptions(self):
# this tests the exceptions that should be raised
ar = self.assertRaises
# this tests the exceptions that should be raised
ar(DatabaseError, self.db.status.create, name="foo")
ar(DatabaseError, self.db.status.set, '1', name="foo")
ar(DatabaseError, self.db.status.retire, '1')
class SchemaTest(MyTestCase):
def setUp(self):
# remove previous test, ignore errors
if os.path.exists(config.DATABASE):
shutil.rmtree(config.DATABASE)
os.makedirs(config.DATABASE + '/files')
def test_reservedProperties(self):
self.db = self.module.Database(config, 'admin')
self.assertRaises(ValueError, self.module.Class, self.db, "a",
creation=String())
self.assertRaises(ValueError, self.module.Class, self.db, "a",
activity=String())
self.assertRaises(ValueError, self.module.Class, self.db, "a",
creator=String())
self.assertRaises(ValueError, self.module.Class, self.db, "a",
actor=String())
def init_a(self):
self.db = self.module.Database(config, 'admin')
a = self.module.Class(self.db, "a", name=String())
a.setkey("name")
self.db.post_init()
def init_ab(self):
self.db = self.module.Database(config, 'admin')
a = self.module.Class(self.db, "a", name=String())
a.setkey("name")
b = self.module.Class(self.db, "b", name=String())
b.setkey("name")
self.db.post_init()
def test_addNewClass(self):
self.init_a()
self.assertRaises(ValueError, self.module.Class, self.db, "a",
name=String())
aid = self.db.a.create(name='apple')
self.db.commit(); self.db.close()
# add a new class to the schema and check creation of new items
# (and existence of old ones)
self.init_ab()
bid = self.db.b.create(name='bear')
self.assertEqual(self.db.a.get(aid, 'name'), 'apple')
self.db.commit()
self.db.close()
# now check we can recall the added class' items
self.init_ab()
self.assertEqual(self.db.a.get(aid, 'name'), 'apple')
self.assertEqual(self.db.a.lookup('apple'), aid)
self.assertEqual(self.db.b.get(bid, 'name'), 'bear')
self.assertEqual(self.db.b.lookup('bear'), bid)
# confirm journal's ok
self.db.getjournal('a', aid)
self.db.getjournal('b', bid)
def init_amod(self):
self.db = self.module.Database(config, 'admin')
a = self.module.Class(self.db, "a", name=String(), fooz=String())
a.setkey("name")
b = self.module.Class(self.db, "b", name=String())
b.setkey("name")
self.db.post_init()
def test_modifyClass(self):
self.init_ab()
# add item to user and issue class
aid = self.db.a.create(name='apple')
bid = self.db.b.create(name='bear')
self.db.commit(); self.db.close()
# modify "a" schema
self.init_amod()
self.assertEqual(self.db.a.get(aid, 'name'), 'apple')
self.assertEqual(self.db.a.get(aid, 'fooz'), None)
self.assertEqual(self.db.b.get(aid, 'name'), 'bear')
aid2 = self.db.a.create(name='aardvark', fooz='booz')
self.db.commit(); self.db.close()
# test
self.init_amod()
self.assertEqual(self.db.a.get(aid, 'name'), 'apple')
self.assertEqual(self.db.a.get(aid, 'fooz'), None)
self.assertEqual(self.db.b.get(aid, 'name'), 'bear')
self.assertEqual(self.db.a.get(aid2, 'name'), 'aardvark')
self.assertEqual(self.db.a.get(aid2, 'fooz'), 'booz')
# confirm journal's ok
self.db.getjournal('a', aid)
self.db.getjournal('a', aid2)
def init_amodkey(self):
self.db = self.module.Database(config, 'admin')
a = self.module.Class(self.db, "a", name=String(), fooz=String())
a.setkey("fooz")
b = self.module.Class(self.db, "b", name=String())
b.setkey("name")
self.db.post_init()
def test_changeClassKey(self):
self.init_amod()
aid = self.db.a.create(name='apple')
self.assertEqual(self.db.a.lookup('apple'), aid)
self.db.commit(); self.db.close()
# change the key to fooz on a
self.init_amodkey()
self.assertEqual(self.db.a.get(aid, 'name'), 'apple')
self.assertEqual(self.db.a.get(aid, 'fooz'), None)
self.assertRaises(KeyError, self.db.a.lookup, 'apple')
aid2 = self.db.a.create(name='aardvark', fooz='booz')
self.db.commit(); self.db.close()
# check
self.init_amodkey()
self.assertEqual(self.db.a.lookup('booz'), aid2)
# confirm journal's ok
self.db.getjournal('a', aid)
def init_ml(self):
self.db = self.module.Database(config, 'admin')
a = self.module.Class(self.db, "a", name=String())
a.setkey('name')
b = self.module.Class(self.db, "b", name=String(),
fooz=Multilink('a'))
b.setkey("name")
self.db.post_init()
def test_makeNewMultilink(self):
self.init_a()
aid = self.db.a.create(name='apple')
self.assertEqual(self.db.a.lookup('apple'), aid)
self.db.commit(); self.db.close()
# add a multilink prop
self.init_ml()
bid = self.db.b.create(name='bear', fooz=[aid])
self.assertEqual(self.db.b.find(fooz=aid), [bid])
self.assertEqual(self.db.a.lookup('apple'), aid)
self.db.commit(); self.db.close()
# check
self.init_ml()
self.assertEqual(self.db.b.find(fooz=aid), [bid])
self.assertEqual(self.db.a.lookup('apple'), aid)
self.assertEqual(self.db.b.lookup('bear'), bid)
# confirm journal's ok
self.db.getjournal('a', aid)
self.db.getjournal('b', bid)
def test_removeMultilink(self):
# add a multilink prop
self.init_ml()
aid = self.db.a.create(name='apple')
bid = self.db.b.create(name='bear', fooz=[aid])
self.assertEqual(self.db.b.find(fooz=aid), [bid])
self.assertEqual(self.db.a.lookup('apple'), aid)
self.assertEqual(self.db.b.lookup('bear'), bid)
self.db.commit(); self.db.close()
# remove the multilink
self.init_ab()
self.assertEqual(self.db.a.lookup('apple'), aid)
self.assertEqual(self.db.b.lookup('bear'), bid)
# confirm journal's ok
self.db.getjournal('a', aid)
self.db.getjournal('b', bid)
def test_removeClass(self):
self.init_ml()
aid = self.db.a.create(name='apple')
bid = self.db.b.create(name='bear', fooz=[aid])
self.db.commit(); self.db.close()
# drop the b class
self.init_a()
self.assertEqual(self.db.a.get(aid, 'name'), 'apple')
self.assertEqual(self.db.a.lookup('apple'), aid)
self.db.commit(); self.db.close()
# now check we can recall the added class' items
self.init_a()
self.assertEqual(self.db.a.get(aid, 'name'), 'apple')
self.assertEqual(self.db.a.lookup('apple'), aid)
# confirm journal's ok
self.db.getjournal('a', aid)
class RDBMSTest:
''' tests specific to RDBMS backends '''
def test_indexTest(self):
self.assertEqual(self.db.sql_index_exists('_issue', '_issue_id_idx'), 1)
self.assertEqual(self.db.sql_index_exists('_issue', '_issue_x_idx'), 0)
class ClassicInitTest(unittest.TestCase):
count = 0
db = None
extra_config = ''
def setUp(self):
ClassicInitTest.count = ClassicInitTest.count + 1
self.dirname = '_test_init_%s'%self.count
try:
shutil.rmtree(self.dirname)
except OSError, error:
if error.errno not in (errno.ENOENT, errno.ESRCH): raise
def testCreation(self):
ae = self.assertEqual
# create the instance
init.install(self.dirname, 'templates/classic')
init.write_select_db(self.dirname, self.backend)
if self.extra_config:
f = open(os.path.join(self.dirname, 'config.py'), 'a')
try:
f.write(self.extra_config)
finally:
f.close()
init.initialise(self.dirname, 'sekrit')
# check we can load the package
instance = imp.load_package(self.dirname, self.dirname)
# and open the database
db = self.db = instance.open()
# check the basics of the schema and initial data set
l = db.priority.list()
ae(l, ['1', '2', '3', '4', '5'])
l = db.status.list()
ae(l, ['1', '2', '3', '4', '5', '6', '7', '8'])
l = db.keyword.list()
ae(l, [])
l = db.user.list()
ae(l, ['1', '2'])
l = db.msg.list()
ae(l, [])
l = db.file.list()
ae(l, [])
l = db.issue.list()
ae(l, [])
def tearDown(self):
if self.db is not None:
self.db.close()
try:
shutil.rmtree(self.dirname)
except OSError, error:
if error.errno not in (errno.ENOENT, errno.ESRCH): raise
code-cc4667ef3f12/test/session_common.py 0000644 0000000 0000000 00000002560 10030631223 016314 0 ustar 0000000 0000000 import os, shutil, unittest
from db_test_base import config
class SessionTest(unittest.TestCase):
def setUp(self):
# remove previous test, ignore errors
if os.path.exists(config.DATABASE):
shutil.rmtree(config.DATABASE)
os.makedirs(config.DATABASE + '/files')
self.db = self.module.Database(config, 'admin')
self.sessions = self.sessions_module.Sessions(self.db)
self.otks = self.sessions_module.OneTimeKeys(self.db)
def tearDown(self):
del self.otks
del self.sessions
if hasattr(self, 'db'):
self.db.close()
if os.path.exists(config.DATABASE):
shutil.rmtree(config.DATABASE)
def testSetSession(self):
self.sessions.set('random_key', text='hello, world!')
self.assertEqual(self.sessions.get('random_key', 'text'),
'hello, world!')
def testUpdateSession(self):
self.sessions.set('random_key', text='hello, world!')
self.assertEqual(self.sessions.get('random_key', 'text'),
'hello, world!')
self.sessions.set('random_key', text='nope')
self.assertEqual(self.sessions.get('random_key', 'text'), 'nope')
class DBMTest(SessionTest):
import roundup.backends.sessions_dbm as sessions_module
class RDBMSTest(SessionTest):
import roundup.backends.sessions_rdbms as sessions_module
code-cc4667ef3f12/test/test_actions.py 0000755 0000000 0000000 00000016321 10030631223 015763 0 ustar 0000000 0000000 from __future__ import nested_scopes
import unittest
from cgi import FieldStorage, MiniFieldStorage
from roundup import hyperdb
from roundup.date import Date, Interval
from roundup.cgi.actions import *
from roundup.cgi.exceptions import Redirect, Unauthorised, SeriousError
class MockNull:
def __init__(self, **kwargs):
for key, value in kwargs.items():
setattr(self, key, value)
def __call__(self, *args, **kwargs): return MockNull()
def __getattr__(self, name):
# This allows assignments which assume all intermediate steps are Null
# objects if they don't exist yet.
#
# For example (with just 'client' defined):
#
# client.db.config.TRACKER_WEB = 'BASE/'
setattr(self, name, MockNull())
return getattr(self, name)
def __getitem__(self, key): return self
def __nonzero__(self): return 0
def __str__(self): return ''
def true(*args, **kwargs):
return 1
class ActionTestCase(unittest.TestCase):
def setUp(self):
self.form = FieldStorage()
self.client = MockNull()
self.client.form = self.form
class ShowActionTestCase(ActionTestCase):
def assertRaisesMessage(self, exception, callable, message, *args,
**kwargs):
"""An extension of assertRaises, which also checks the exception
message. We need this because we rely on exception messages when
redirecting.
"""
try:
callable(*args, **kwargs)
except exception, msg:
self.assertEqual(str(msg), message)
else:
if hasattr(excClass,'__name__'):
excName = excClass.__name__
else:
excName = str(excClass)
raise self.failureException, excName
def testShowAction(self):
self.client.db.config.TRACKER_WEB = 'BASE/'
action = ShowAction(self.client)
self.assertRaises(ValueError, action.handle)
self.form.value.append(MiniFieldStorage('@type', 'issue'))
self.assertRaises(SeriousError, action.handle)
self.form.value.append(MiniFieldStorage('@number', '1'))
self.assertRaisesMessage(Redirect, action.handle, 'BASE/issue1')
def testShowActionNoType(self):
action = ShowAction(self.client)
self.assertRaises(ValueError, action.handle)
self.form.value.append(MiniFieldStorage('@number', '1'))
self.assertRaisesMessage(ValueError, action.handle,
'No type specified')
class RetireActionTestCase(ActionTestCase):
def testRetireAction(self):
self.client.db.security.hasPermission = true
self.client.ok_message = []
RetireAction(self.client).handle()
self.assert_(len(self.client.ok_message) == 1)
def testNoPermission(self):
self.assertRaises(Unauthorised, RetireAction(self.client).execute)
def testDontRetireAdminOrAnonymous(self):
self.client.db.security.hasPermission=true
# look up the user class
self.client.classname = 'user'
# but always look up admin, regardless of nodeid
self.client.db.user.get = lambda a,b: 'admin'
self.assertRaises(ValueError, RetireAction(self.client).handle)
# .. or anonymous
self.client.db.user.get = lambda a,b: 'anonymous'
self.assertRaises(ValueError, RetireAction(self.client).handle)
class SearchActionTestCase(ActionTestCase):
def setUp(self):
ActionTestCase.setUp(self)
self.action = SearchAction(self.client)
class StandardSearchActionTestCase(SearchActionTestCase):
def testNoPermission(self):
self.assertRaises(Unauthorised, self.action.execute)
def testQueryName(self):
self.assertEqual(self.action.getQueryName(), '')
self.form.value.append(MiniFieldStorage('@queryname', 'foo'))
self.assertEqual(self.action.getQueryName(), 'foo')
class FakeFilterVarsTestCase(SearchActionTestCase):
def setUp(self):
SearchActionTestCase.setUp(self)
self.client.db.classes.getprops = lambda: {'foo': hyperdb.Multilink('foo')}
def assertFilterEquals(self, expected):
self.action.fakeFilterVars()
self.assertEqual(self.form.getvalue('@filter'), expected)
def testEmptyMultilink(self):
self.form.value.append(MiniFieldStorage('foo', ''))
self.form.value.append(MiniFieldStorage('foo', ''))
self.assertFilterEquals(None)
def testNonEmptyMultilink(self):
self.form.value.append(MiniFieldStorage('foo', ''))
self.form.value.append(MiniFieldStorage('foo', '1'))
self.assertFilterEquals('foo')
def testEmptyKey(self):
self.form.value.append(MiniFieldStorage('foo', ''))
self.assertFilterEquals(None)
def testStandardKey(self):
self.form.value.append(MiniFieldStorage('foo', '1'))
self.assertFilterEquals('foo')
def testStringKey(self):
self.client.db.classes.getprops = lambda: {'foo': hyperdb.String()}
self.form.value.append(MiniFieldStorage('foo', 'hello'))
self.assertFilterEquals('foo')
def testTokenizedStringKey(self):
self.client.db.classes.getprops = lambda: {'foo': hyperdb.String()}
self.form.value.append(MiniFieldStorage('foo', 'hello world'))
self.assertFilterEquals('foo')
# The single value gets replaced with the tokenized list.
self.assertEqual([x.value for x in self.form['foo']], ['hello', 'world'])
class CollisionDetectionTestCase(ActionTestCase):
def setUp(self):
ActionTestCase.setUp(self)
self.action = EditItemAction(self.client)
self.now = Date('.')
# round off for testing
self.now.second = int(self.now.second)
def testLastUserActivity(self):
self.assertEqual(self.action.lastUserActivity(), None)
self.client.form.value.append(MiniFieldStorage('@lastactivity', str(self.now)))
self.assertEqual(self.action.lastUserActivity(), self.now)
def testLastNodeActivity(self):
self.action.classname = 'issue'
self.action.nodeid = '1'
def get(nodeid, propname):
self.assertEqual(nodeid, '1')
self.assertEqual(propname, 'activity')
return self.now
self.client.db.issue.get = get
self.assertEqual(self.action.lastNodeActivity(), self.now)
def testCollision(self):
self.failUnless(self.action.detectCollision(self.now, self.now + Interval("1d")))
self.failIf(self.action.detectCollision(self.now, self.now - Interval("1d")))
self.failIf(self.action.detectCollision(None, self.now))
def test_suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(RetireActionTestCase))
suite.addTest(unittest.makeSuite(StandardSearchActionTestCase))
suite.addTest(unittest.makeSuite(FakeFilterVarsTestCase))
suite.addTest(unittest.makeSuite(ShowActionTestCase))
suite.addTest(unittest.makeSuite(CollisionDetectionTestCase))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
code-cc4667ef3f12/test/test_anydbm.py 0000644 0000000 0000000 00000004006 10030631223 015567 0 ustar 0000000 0000000 #
# Copyright (c) 2001 Bizar Software Pty Ltd (http://www.bizarsoftware.com.au/)
# This module is free software, and you may redistribute it and/or modify
# under the same terms as Python, so long as this copyright message and
# disclaimer are retained in their original form.
#
# IN NO EVENT SHALL BIZAR SOFTWARE PTY LTD BE LIABLE TO ANY PARTY FOR
# DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING
# OUT OF THE USE OF THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# BIZAR SOFTWARE PTY LTD SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
# BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE. THE CODE PROVIDED HEREUNDER IS ON AN "AS IS"
# BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
# SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
#
# $Id: test_anydbm.py,v 1.3 2004-03-18 01:58:46 richard Exp $
import unittest, os, shutil, time
from db_test_base import DBTest, ROTest, SchemaTest, ClassicInitTest, config
class anydbmOpener:
from roundup.backends import anydbm as module
def nuke_database(self):
shutil.rmtree(config.DATABASE)
class anydbmDBTest(anydbmOpener, DBTest):
pass
class anydbmROTest(anydbmOpener, ROTest):
pass
class anydbmSchemaTest(anydbmOpener, SchemaTest):
pass
class anydbmClassicInitTest(ClassicInitTest):
backend = 'anydbm'
from session_common import DBMTest
class anydbmSessionTest(anydbmOpener, DBMTest):
pass
def test_suite():
suite = unittest.TestSuite()
print 'Including anydbm tests'
suite.addTest(unittest.makeSuite(anydbmDBTest))
suite.addTest(unittest.makeSuite(anydbmROTest))
suite.addTest(unittest.makeSuite(anydbmSchemaTest))
suite.addTest(unittest.makeSuite(anydbmClassicInitTest))
suite.addTest(unittest.makeSuite(anydbmSessionTest))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
# vim: set filetype=python ts=4 sw=4 et si
code-cc4667ef3f12/test/test_bsddb.py 0000644 0000000 0000000 00000004154 10030631223 015377 0 ustar 0000000 0000000 #
# Copyright (c) 2001 Bizar Software Pty Ltd (http://www.bizarsoftware.com.au/)
# This module is free software, and you may redistribute it and/or modify
# under the same terms as Python, so long as this copyright message and
# disclaimer are retained in their original form.
#
# IN NO EVENT SHALL BIZAR SOFTWARE PTY LTD BE LIABLE TO ANY PARTY FOR
# DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING
# OUT OF THE USE OF THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# BIZAR SOFTWARE PTY LTD SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
# BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE. THE CODE PROVIDED HEREUNDER IS ON AN "AS IS"
# BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
# SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
#
# $Id: test_bsddb.py,v 1.3 2004-03-18 01:58:46 richard Exp $
import unittest, os, shutil, time
from db_test_base import DBTest, ROTest, SchemaTest, ClassicInitTest, config
from roundup import backends
class bsddbOpener:
if hasattr(backends, 'bsddb'):
from roundup.backends import bsddb as module
def nuke_database(self):
shutil.rmtree(config.DATABASE)
class bsddbDBTest(bsddbOpener, DBTest):
pass
class bsddbROTest(bsddbOpener, ROTest):
pass
class bsddbSchemaTest(bsddbOpener, SchemaTest):
pass
class bsddbClassicInitTest(ClassicInitTest):
backend = 'bsddb'
from session_common import DBMTest
class bsddbSessionTest(bsddbOpener, DBMTest):
pass
def test_suite():
suite = unittest.TestSuite()
if not hasattr(backends, 'bsddb'):
print 'Skipping bsddb tests'
return suite
print 'Including bsddb tests'
suite.addTest(unittest.makeSuite(bsddbDBTest))
suite.addTest(unittest.makeSuite(bsddbROTest))
suite.addTest(unittest.makeSuite(bsddbSchemaTest))
suite.addTest(unittest.makeSuite(bsddbClassicInitTest))
suite.addTest(unittest.makeSuite(bsddbSessionTest))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
code-cc4667ef3f12/test/test_bsddb3.py 0000644 0000000 0000000 00000004202 10030631223 015454 0 ustar 0000000 0000000 #
# Copyright (c) 2001 Bizar Software Pty Ltd (http://www.bizarsoftware.com.au/)
# This module is free software, and you may redistribute it and/or modify
# under the same terms as Python, so long as this copyright message and
# disclaimer are retained in their original form.
#
# IN NO EVENT SHALL BIZAR SOFTWARE PTY LTD BE LIABLE TO ANY PARTY FOR
# DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING
# OUT OF THE USE OF THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# BIZAR SOFTWARE PTY LTD SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
# BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE. THE CODE PROVIDED HEREUNDER IS ON AN "AS IS"
# BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
# SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
#
# $Id: test_bsddb3.py,v 1.3 2004-03-18 01:58:46 richard Exp $
import unittest, os, shutil, time
from db_test_base import DBTest, ROTest, SchemaTest, ClassicInitTest, config
from roundup import backends
class bsddb3Opener:
if hasattr(backends, 'bsddb3'):
from roundup.backends import bsddb3 as module
def nuke_database(self):
shutil.rmtree(config.DATABASE)
class bsddb3DBTest(bsddb3Opener, DBTest):
pass
class bsddb3ROTest(bsddb3Opener, ROTest):
pass
class bsddb3SchemaTest(bsddb3Opener, SchemaTest):
pass
class bsddb3ClassicInitTest(ClassicInitTest):
backend = 'bsddb3'
from session_common import DBMTest
class bsddb3SessionTest(bsddb3Opener, DBMTest):
pass
def test_suite():
suite = unittest.TestSuite()
if not hasattr(backends, 'bsddb3'):
print 'Skipping bsddb3 tests'
return suite
print 'Including bsddb3 tests'
suite.addTest(unittest.makeSuite(bsddb3DBTest))
suite.addTest(unittest.makeSuite(bsddb3ROTest))
suite.addTest(unittest.makeSuite(bsddb3SchemaTest))
suite.addTest(unittest.makeSuite(bsddb3ClassicInitTest))
suite.addTest(unittest.makeSuite(bsddb3SessionTest))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
code-cc4667ef3f12/test/test_cgi.py 0000644 0000000 0000000 00000054513 10030631223 015067 0 ustar 0000000 0000000 #
# Copyright (c) 2003 Richard Jones, rjones@ekit-inc.com
# This module is free software, and you may redistribute it and/or modify
# under the same terms as Python, so long as this copyright message and
# disclaimer are retained in their original form.
#
# This module is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
#
# $Id: test_cgi.py,v 1.23 2004-02-17 03:48:08 richard Exp $
import unittest, os, shutil, errno, sys, difflib, cgi, re
from roundup.cgi import client
from roundup.cgi.exceptions import FormError
from roundup.cgi.form_parser import FormParser
from roundup import init, instance, password, hyperdb, date
NEEDS_INSTANCE = 1
class FileUpload:
def __init__(self, content, filename):
self.content = content
self.filename = filename
def makeForm(args):
form = cgi.FieldStorage()
for k,v in args.items():
if type(v) is type([]):
[form.list.append(cgi.MiniFieldStorage(k, x)) for x in v]
elif isinstance(v, FileUpload):
x = cgi.MiniFieldStorage(k, v.content)
x.filename = v.filename
form.list.append(x)
else:
form.list.append(cgi.MiniFieldStorage(k, v))
return form
class config:
TRACKER_NAME = 'testing testing'
TRACKER_WEB = 'http://testing.testing/'
cm = client.clean_message
class MessageTestCase(unittest.TestCase):
def testCleanMessageOK(self):
self.assertEqual(cm('
x
'), '
x
')
self.assertEqual(cm('x'), 'x')
self.assertEqual(cm('x'), 'x')
self.assertEqual(cm('x'),
'x')
self.assertEqual(cm('
x
'), '
x
')
self.assertEqual(cm('x'), 'x')
self.assertEqual(cm('x'), 'x')
self.assertEqual(cm('x'),
'x')
def testCleanMessageBAD(self):
self.assertEqual(cm(''),
'<script>x</script>')
self.assertEqual(cm(''),
'<iframe>x</iframe>')
class FormTestCase(unittest.TestCase):
def setUp(self):
self.dirname = '_test_cgi_form'
try:
shutil.rmtree(self.dirname)
except OSError, error:
if error.errno not in (errno.ENOENT, errno.ESRCH): raise
# create the instance
init.install(self.dirname, 'templates/classic')
init.write_select_db(self.dirname, 'anydbm')
init.initialise(self.dirname, 'sekrit')
# check we can load the package
self.instance = instance.open(self.dirname)
# and open the database
self.db = self.instance.open('admin')
self.db.user.create(username='Chef', address='chef@bork.bork.bork',
realname='Bork, Chef', roles='User')
self.db.user.create(username='mary', address='mary@test',
roles='User', realname='Contrary, Mary')
test = self.instance.dbinit.Class(self.db, "test",
string=hyperdb.String(), number=hyperdb.Number(),
boolean=hyperdb.Boolean(), link=hyperdb.Link('test'),
multilink=hyperdb.Multilink('test'), date=hyperdb.Date(),
interval=hyperdb.Interval())
# compile the labels re
classes = '|'.join(self.db.classes.keys())
self.FV_SPECIAL = re.compile(FormParser.FV_LABELS%classes,
re.VERBOSE)
def parseForm(self, form, classname='test', nodeid=None):
cl = client.Client(self.instance, None, {'PATH_INFO':'/'},
makeForm(form))
cl.classname = classname
cl.nodeid = nodeid
cl.db = self.db
return cl.parsePropsFromForm(create=1)
def tearDown(self):
self.db.close()
try:
shutil.rmtree(self.dirname)
except OSError, error:
if error.errno not in (errno.ENOENT, errno.ESRCH): raise
#
# form label extraction
#
def tl(self, s, c, i, a, p):
m = self.FV_SPECIAL.match(s)
self.assertNotEqual(m, None)
d = m.groupdict()
self.assertEqual(d['classname'], c)
self.assertEqual(d['id'], i)
for action in 'required add remove link note file'.split():
if a == action:
self.assertNotEqual(d[action], None)
else:
self.assertEqual(d[action], None)
self.assertEqual(d['propname'], p)
def testLabelMatching(self):
self.tl('', None, None, None, '')
self.tl(':required', None, None, 'required', None)
self.tl(':confirm:', None, None, 'confirm', '')
self.tl(':add:', None, None, 'add', '')
self.tl(':remove:', None, None, 'remove', '')
self.tl(':link:', None, None, 'link', '')
self.tl('test1:', 'test', '1', None, '')
self.tl('test1:required', 'test', '1', 'required', None)
self.tl('test1:add:', 'test', '1', 'add', '')
self.tl('test1:remove:', 'test', '1', 'remove', '')
self.tl('test1:link:', 'test', '1', 'link', '')
self.tl('test1:confirm:', 'test', '1', 'confirm', '')
self.tl('test-1:', 'test', '-1', None, '')
self.tl('test-1:required', 'test', '-1', 'required', None)
self.tl('test-1:add:', 'test', '-1', 'add', '')
self.tl('test-1:remove:', 'test', '-1', 'remove', '')
self.tl('test-1:link:', 'test', '-1', 'link', '')
self.tl('test-1:confirm:', 'test', '-1', 'confirm', '')
self.tl(':note', None, None, 'note', None)
self.tl(':file', None, None, 'file', None)
#
# Empty form
#
def testNothing(self):
self.assertEqual(self.parseForm({}), ({('test', None): {}}, []))
def testNothingWithRequired(self):
self.assertRaises(FormError, self.parseForm, {':required': 'string'})
self.assertRaises(FormError, self.parseForm,
{':required': 'title,status', 'status':'1'}, 'issue')
self.assertRaises(FormError, self.parseForm,
{':required': ['title','status'], 'status':'1'}, 'issue')
self.assertRaises(FormError, self.parseForm,
{':required': 'status', 'status':''}, 'issue')
self.assertRaises(FormError, self.parseForm,
{':required': 'nosy', 'nosy':''}, 'issue')
#
# Nonexistant edit
#
def testEditNonexistant(self):
self.assertRaises(FormError, self.parseForm, {'boolean': ''},
'test', '1')
#
# String
#
def testEmptyString(self):
self.assertEqual(self.parseForm({'string': ''}),
({('test', None): {}}, []))
self.assertEqual(self.parseForm({'string': ' '}),
({('test', None): {}}, []))
self.assertRaises(FormError, self.parseForm, {'string': ['', '']})
def testSetString(self):
self.assertEqual(self.parseForm({'string': 'foo'}),
({('test', None): {'string': 'foo'}}, []))
self.assertEqual(self.parseForm({'string': 'a\r\nb\r\n'}),
({('test', None): {'string': 'a\nb'}}, []))
nodeid = self.db.issue.create(title='foo')
self.assertEqual(self.parseForm({'title': 'foo'}, 'issue', nodeid),
({('issue', nodeid): {}}, []))
def testEmptyStringSet(self):
nodeid = self.db.issue.create(title='foo')
self.assertEqual(self.parseForm({'title': ''}, 'issue', nodeid),
({('issue', nodeid): {'title': None}}, []))
nodeid = self.db.issue.create(title='foo')
self.assertEqual(self.parseForm({'title': ' '}, 'issue', nodeid),
({('issue', nodeid): {'title': None}}, []))
def testFileUpload(self):
file = FileUpload('foo', 'foo.txt')
self.assertEqual(self.parseForm({'content': file}, 'file'),
({('file', None): {'content': 'foo', 'name': 'foo.txt',
'type': 'text/plain'}}, []))
def testEditFileClassAttributes(self):
self.assertEqual(self.parseForm({'name': 'foo.txt',
'type': 'application/octet-stream'},
'file'),
({('file', None): {'name': 'foo.txt',
'type': 'application/octet-stream'}},[]))
#
# Link
#
def testEmptyLink(self):
self.assertEqual(self.parseForm({'link': ''}),
({('test', None): {}}, []))
self.assertEqual(self.parseForm({'link': ' '}),
({('test', None): {}}, []))
self.assertRaises(FormError, self.parseForm, {'link': ['', '']})
self.assertEqual(self.parseForm({'link': '-1'}),
({('test', None): {}}, []))
def testSetLink(self):
self.assertEqual(self.parseForm({'status': 'unread'}, 'issue'),
({('issue', None): {'status': '1'}}, []))
self.assertEqual(self.parseForm({'status': '1'}, 'issue'),
({('issue', None): {'status': '1'}}, []))
nodeid = self.db.issue.create(status='unread')
self.assertEqual(self.parseForm({'status': 'unread'}, 'issue', nodeid),
({('issue', nodeid): {}}, []))
def testUnsetLink(self):
nodeid = self.db.issue.create(status='unread')
self.assertEqual(self.parseForm({'status': '-1'}, 'issue', nodeid),
({('issue', nodeid): {'status': None}}, []))
def testInvalidLinkValue(self):
# XXX This is not the current behaviour - should we enforce this?
# self.assertRaises(IndexError, self.parseForm,
# {'status': '4'}))
self.assertRaises(FormError, self.parseForm, {'link': 'frozzle'})
self.assertRaises(FormError, self.parseForm, {'status': 'frozzle'},
'issue')
#
# Multilink
#
def testEmptyMultilink(self):
self.assertEqual(self.parseForm({'nosy': ''}),
({('test', None): {}}, []))
self.assertEqual(self.parseForm({'nosy': ' '}),
({('test', None): {}}, []))
def testSetMultilink(self):
self.assertEqual(self.parseForm({'nosy': '1'}, 'issue'),
({('issue', None): {'nosy': ['1']}}, []))
self.assertEqual(self.parseForm({'nosy': 'admin'}, 'issue'),
({('issue', None): {'nosy': ['1']}}, []))
self.assertEqual(self.parseForm({'nosy': ['1','2']}, 'issue'),
({('issue', None): {'nosy': ['1','2']}}, []))
self.assertEqual(self.parseForm({'nosy': '1,2'}, 'issue'),
({('issue', None): {'nosy': ['1','2']}}, []))
self.assertEqual(self.parseForm({'nosy': 'admin,2'}, 'issue'),
({('issue', None): {'nosy': ['1','2']}}, []))
def testMixedMultilink(self):
form = cgi.FieldStorage()
form.list.append(cgi.MiniFieldStorage('nosy', '1,2'))
form.list.append(cgi.MiniFieldStorage('nosy', '3'))
cl = client.Client(self.instance, None, {'PATH_INFO':'/'}, form)
cl.classname = 'issue'
cl.nodeid = None
cl.db = self.db
self.assertEqual(cl.parsePropsFromForm(create=1),
({('issue', None): {'nosy': ['1','2', '3']}}, []))
def testEmptyMultilinkSet(self):
nodeid = self.db.issue.create(nosy=['1','2'])
self.assertEqual(self.parseForm({'nosy': ''}, 'issue', nodeid),
({('issue', nodeid): {'nosy': []}}, []))
nodeid = self.db.issue.create(nosy=['1','2'])
self.assertEqual(self.parseForm({'nosy': ' '}, 'issue', nodeid),
({('issue', nodeid): {'nosy': []}}, []))
self.assertEqual(self.parseForm({'nosy': '1,2'}, 'issue', nodeid),
({('issue', nodeid): {}}, []))
def testInvalidMultilinkValue(self):
# XXX This is not the current behaviour - should we enforce this?
# self.assertRaises(IndexError, self.parseForm,
# {'nosy': '4'}))
self.assertRaises(FormError, self.parseForm, {'nosy': 'frozzle'},
'issue')
self.assertRaises(FormError, self.parseForm, {'nosy': '1,frozzle'},
'issue')
self.assertRaises(FormError, self.parseForm, {'multilink': 'frozzle'})
def testMultilinkAdd(self):
nodeid = self.db.issue.create(nosy=['1'])
# do nothing
self.assertEqual(self.parseForm({':add:nosy': ''}, 'issue', nodeid),
({('issue', nodeid): {}}, []))
# do something ;)
self.assertEqual(self.parseForm({':add:nosy': '2'}, 'issue', nodeid),
({('issue', nodeid): {'nosy': ['1','2']}}, []))
self.assertEqual(self.parseForm({':add:nosy': '2,mary'}, 'issue',
nodeid), ({('issue', nodeid): {'nosy': ['1','2','4']}}, []))
self.assertEqual(self.parseForm({':add:nosy': ['2','3']}, 'issue',
nodeid), ({('issue', nodeid): {'nosy': ['1','2','3']}}, []))
def testMultilinkAddNew(self):
self.assertEqual(self.parseForm({':add:nosy': ['2','3']}, 'issue'),
({('issue', None): {'nosy': ['2','3']}}, []))
def testMultilinkRemove(self):
nodeid = self.db.issue.create(nosy=['1','2'])
# do nothing
self.assertEqual(self.parseForm({':remove:nosy': ''}, 'issue', nodeid),
({('issue', nodeid): {}}, []))
# do something ;)
self.assertEqual(self.parseForm({':remove:nosy': '1'}, 'issue',
nodeid), ({('issue', nodeid): {'nosy': ['2']}}, []))
self.assertEqual(self.parseForm({':remove:nosy': 'admin,2'},
'issue', nodeid), ({('issue', nodeid): {'nosy': []}}, []))
self.assertEqual(self.parseForm({':remove:nosy': ['1','2']},
'issue', nodeid), ({('issue', nodeid): {'nosy': []}}, []))
# add and remove
self.assertEqual(self.parseForm({':add:nosy': ['3'],
':remove:nosy': ['1','2']},
'issue', nodeid), ({('issue', nodeid): {'nosy': ['3']}}, []))
# remove one that doesn't exist?
self.assertRaises(FormError, self.parseForm, {':remove:nosy': '4'},
'issue', nodeid)
def testMultilinkRetired(self):
self.db.user.retire('2')
self.assertEqual(self.parseForm({'nosy': ['2','3']}, 'issue'),
({('issue', None): {'nosy': ['2','3']}}, []))
nodeid = self.db.issue.create(nosy=['1','2'])
self.assertEqual(self.parseForm({':remove:nosy': '2'}, 'issue',
nodeid), ({('issue', nodeid): {'nosy': ['1']}}, []))
self.assertEqual(self.parseForm({':add:nosy': '3'}, 'issue', nodeid),
({('issue', nodeid): {'nosy': ['1','2','3']}}, []))
def testAddRemoveNonexistant(self):
self.assertRaises(FormError, self.parseForm, {':remove:foo': '2'},
'issue')
self.assertRaises(FormError, self.parseForm, {':add:foo': '2'},
'issue')
#
# Password
#
def testEmptyPassword(self):
self.assertEqual(self.parseForm({'password': ''}, 'user'),
({('user', None): {}}, []))
self.assertEqual(self.parseForm({'password': ''}, 'user'),
({('user', None): {}}, []))
self.assertRaises(FormError, self.parseForm, {'password': ['', '']},
'user')
self.assertRaises(FormError, self.parseForm, {'password': 'foo',
':confirm:password': ['', '']}, 'user')
def testSetPassword(self):
self.assertEqual(self.parseForm({'password': 'foo',
':confirm:password': 'foo'}, 'user'),
({('user', None): {'password': 'foo'}}, []))
def testSetPasswordConfirmBad(self):
self.assertRaises(FormError, self.parseForm, {'password': 'foo'},
'user')
self.assertRaises(FormError, self.parseForm, {'password': 'foo',
':confirm:password': 'bar'}, 'user')
def testEmptyPasswordNotSet(self):
nodeid = self.db.user.create(username='1',
password=password.Password('foo'))
self.assertEqual(self.parseForm({'password': ''}, 'user', nodeid),
({('user', nodeid): {}}, []))
nodeid = self.db.user.create(username='2',
password=password.Password('foo'))
self.assertEqual(self.parseForm({'password': '',
':confirm:password': ''}, 'user', nodeid),
({('user', nodeid): {}}, []))
#
# Boolean
#
def testEmptyBoolean(self):
self.assertEqual(self.parseForm({'boolean': ''}),
({('test', None): {}}, []))
self.assertEqual(self.parseForm({'boolean': ' '}),
({('test', None): {}}, []))
self.assertRaises(FormError, self.parseForm, {'boolean': ['', '']})
def testSetBoolean(self):
self.assertEqual(self.parseForm({'boolean': 'yes'}),
({('test', None): {'boolean': 1}}, []))
self.assertEqual(self.parseForm({'boolean': 'a\r\nb\r\n'}),
({('test', None): {'boolean': 0}}, []))
nodeid = self.db.test.create(boolean=1)
self.assertEqual(self.parseForm({'boolean': 'yes'}, 'test', nodeid),
({('test', nodeid): {}}, []))
nodeid = self.db.test.create(boolean=0)
self.assertEqual(self.parseForm({'boolean': 'no'}, 'test', nodeid),
({('test', nodeid): {}}, []))
def testEmptyBooleanSet(self):
nodeid = self.db.test.create(boolean=0)
self.assertEqual(self.parseForm({'boolean': ''}, 'test', nodeid),
({('test', nodeid): {'boolean': None}}, []))
nodeid = self.db.test.create(boolean=1)
self.assertEqual(self.parseForm({'boolean': ' '}, 'test', nodeid),
({('test', nodeid): {'boolean': None}}, []))
#
# Number
#
def testEmptyNumber(self):
self.assertEqual(self.parseForm({'number': ''}),
({('test', None): {}}, []))
self.assertEqual(self.parseForm({'number': ' '}),
({('test', None): {}}, []))
self.assertRaises(FormError, self.parseForm, {'number': ['', '']})
def testInvalidNumber(self):
self.assertRaises(FormError, self.parseForm, {'number': 'hi, mum!'})
def testSetNumber(self):
self.assertEqual(self.parseForm({'number': '1'}),
({('test', None): {'number': 1}}, []))
self.assertEqual(self.parseForm({'number': '\n0\n'}),
({('test', None): {'number': 0}}, []))
nodeid = self.db.test.create(number=1)
self.assertEqual(self.parseForm({'number': '1'}, 'test', nodeid),
({('test', nodeid): {}}, []))
nodeid = self.db.test.create(number=0)
self.assertEqual(self.parseForm({'number': '0'}, 'test', nodeid),
({('test', nodeid): {}}, []))
def testEmptyNumberSet(self):
nodeid = self.db.test.create(number=0)
self.assertEqual(self.parseForm({'number': ''}, 'test', nodeid),
({('test', nodeid): {'number': None}}, []))
nodeid = self.db.test.create(number=1)
self.assertEqual(self.parseForm({'number': ' '}, 'test', nodeid),
({('test', nodeid): {'number': None}}, []))
#
# Date
#
def testEmptyDate(self):
self.assertEqual(self.parseForm({'date': ''}),
({('test', None): {}}, []))
self.assertEqual(self.parseForm({'date': ' '}),
({('test', None): {}}, []))
self.assertRaises(FormError, self.parseForm, {'date': ['', '']})
def testInvalidDate(self):
self.assertRaises(FormError, self.parseForm, {'date': '12'})
def testSetDate(self):
self.assertEqual(self.parseForm({'date': '2003-01-01'}),
({('test', None): {'date': date.Date('2003-01-01')}}, []))
nodeid = self.db.test.create(date=date.Date('2003-01-01'))
self.assertEqual(self.parseForm({'date': '2003-01-01'}, 'test',
nodeid), ({('test', nodeid): {}}, []))
def testEmptyDateSet(self):
nodeid = self.db.test.create(date=date.Date('.'))
self.assertEqual(self.parseForm({'date': ''}, 'test', nodeid),
({('test', nodeid): {'date': None}}, []))
nodeid = self.db.test.create(date=date.Date('1970-01-01.00:00:00'))
self.assertEqual(self.parseForm({'date': ' '}, 'test', nodeid),
({('test', nodeid): {'date': None}}, []))
#
# Test multiple items in form
#
def testMultiple(self):
self.assertEqual(self.parseForm({'string': 'a', 'issue-1@title': 'b'}),
({('test', None): {'string': 'a'},
('issue', '-1'): {'title': 'b'}
}, []))
def testMultipleExistingContext(self):
nodeid = self.db.test.create()
self.assertEqual(self.parseForm({'string': 'a', 'issue-1@title': 'b'},
'test', nodeid),({('test', nodeid): {'string': 'a'},
('issue', '-1'): {'title': 'b'}}, []))
def testLinking(self):
self.assertEqual(self.parseForm({
'string': 'a',
'issue-1@add@nosy': '1',
'issue-2@link@superseder': 'issue-1',
}),
({('test', None): {'string': 'a'},
('issue', '-1'): {'nosy': ['1']},
('issue', '-2'): {}
},
[('issue', '-2', 'superseder', [('issue', '-1')])
]
)
)
def testLinkBadDesignator(self):
self.assertRaises(FormError, self.parseForm,
{'test-1@link@link': 'blah'})
self.assertRaises(FormError, self.parseForm,
{'test-1@link@link': 'issue'})
def testLinkNotLink(self):
self.assertRaises(FormError, self.parseForm,
{'test-1@link@boolean': 'issue-1'})
self.assertRaises(FormError, self.parseForm,
{'test-1@link@string': 'issue-1'})
def testBackwardsCompat(self):
res = self.parseForm({':note': 'spam'}, 'issue')
date = res[0][('msg', '-1')]['date']
self.assertEqual(res, ({('issue', None): {}, ('msg', '-1'):
{'content': 'spam', 'author': '1', 'date': date}},
[('issue', None, 'messages', [('msg', '-1')])]))
file = FileUpload('foo', 'foo.txt')
self.assertEqual(self.parseForm({':file': file}, 'issue'),
({('issue', None): {}, ('file', '-1'): {'content': 'foo',
'name': 'foo.txt', 'type': 'text/plain'}},
[('issue', None, 'files', [('file', '-1')])]))
def test_suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(FormTestCase))
suite.addTest(unittest.makeSuite(MessageTestCase))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
# vim: set filetype=python ts=4 sw=4 et si
code-cc4667ef3f12/test/test_dates.py 0000644 0000000 0000000 00000037441 10030631223 015426 0 ustar 0000000 0000000 #
# Copyright (c) 2001 Bizar Software Pty Ltd (http://www.bizarsoftware.com.au/)
# This module is free software, and you may redistribute it and/or modify
# under the same terms as Python, so long as this copyright message and
# disclaimer are retained in their original form.
#
# IN NO EVENT SHALL BIZAR SOFTWARE PTY LTD BE LIABLE TO ANY PARTY FOR
# DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING
# OUT OF THE USE OF THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# BIZAR SOFTWARE PTY LTD SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
# BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE. THE CODE PROVIDED HEREUNDER IS ON AN "AS IS"
# BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
# SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
#
# $Id: test_dates.py,v 1.31 2003-12-04 23:06:53 richard Exp $
from __future__ import nested_scopes
import unittest, time
from roundup.date import Date, Interval, Range, fixTimeOverflow
class DateTestCase(unittest.TestCase):
def testDateInterval(self):
ae = self.assertEqual
date = Date("2000-06-26.00:34:02 + 2d")
ae(str(date), '2000-06-28.00:34:02')
date = Date("2000-02-27 + 2d")
ae(str(date), '2000-02-29.00:00:00')
date = Date("2001-02-27 + 2d")
ae(str(date), '2001-03-01.00:00:00')
def testDate(self):
ae = self.assertEqual
date = Date("2000-04-17")
ae(str(date), '2000-04-17.00:00:00')
date = Date("2000/04/17")
ae(str(date), '2000-04-17.00:00:00')
date = Date("2000-4-7")
ae(str(date), '2000-04-07.00:00:00')
date = Date("2000-4-17")
ae(str(date), '2000-04-17.00:00:00')
date = Date("01-25")
y, m, d, x, x, x, x, x, x = time.gmtime(time.time())
ae(str(date), '%s-01-25.00:00:00'%y)
date = Date("2000-04-17.03:45")
ae(str(date), '2000-04-17.03:45:00')
date = Date("2000/04/17.03:45")
ae(str(date), '2000-04-17.03:45:00')
date = Date("08-13.22:13")
ae(str(date), '%s-08-13.22:13:00'%y)
date = Date("11-07.09:32:43")
ae(str(date), '%s-11-07.09:32:43'%y)
date = Date("14:25")
ae(str(date), '%s-%02d-%02d.14:25:00'%(y, m, d))
date = Date("8:47:11")
ae(str(date), '%s-%02d-%02d.08:47:11'%(y, m, d))
ae(str(Date('2003')), '2003-01-01.00:00:00')
ae(str(Date('2004-06')), '2004-06-01.00:00:00')
def testDateError(self):
self.assertRaises(ValueError, Date, "12")
def testOffset(self):
ae = self.assertEqual
date = Date("2000-04-17", -5)
ae(str(date), '2000-04-17.05:00:00')
date = Date("01-25", -5)
y, m, d, x, x, x, x, x, x = time.gmtime(time.time())
ae(str(date), '%s-01-25.05:00:00'%y)
date = Date("2000-04-17.03:45", -5)
ae(str(date), '2000-04-17.08:45:00')
date = Date("08-13.22:13", -5)
ae(str(date), '%s-08-14.03:13:00'%y)
date = Date("11-07.09:32:43", -5)
ae(str(date), '%s-11-07.14:32:43'%y)
date = Date("14:25", -5)
ae(str(date), '%s-%02d-%02d.19:25:00'%(y, m, d))
date = Date("8:47:11", -5)
ae(str(date), '%s-%02d-%02d.13:47:11'%(y, m, d))
def testOffsetRandom(self):
ae = self.assertEqual
# XXX unsure of the usefulness of these, they're pretty random
date = Date('2000-01-01') + Interval('- 2y 2m')
ae(str(date), '1997-11-01.00:00:00')
date = Date('2000-01-01 - 2y 2m')
ae(str(date), '1997-11-01.00:00:00')
date = Date('2000-01-01') + Interval('2m')
ae(str(date), '2000-03-01.00:00:00')
date = Date('2000-01-01 + 2m')
ae(str(date), '2000-03-01.00:00:00')
date = Date('2000-01-01') + Interval('60d')
ae(str(date), '2000-03-01.00:00:00')
date = Date('2001-01-01') + Interval('60d')
ae(str(date), '2001-03-02.00:00:00')
def testOffsetAdd(self):
ae = self.assertEqual
date = Date('2000-02-28.23:59:59') + Interval('00:00:01')
ae(str(date), '2000-02-29.00:00:00')
date = Date('2001-02-28.23:59:59') + Interval('00:00:01')
ae(str(date), '2001-03-01.00:00:00')
date = Date('2000-02-28.23:58:59') + Interval('00:01:01')
ae(str(date), '2000-02-29.00:00:00')
date = Date('2001-02-28.23:58:59') + Interval('00:01:01')
ae(str(date), '2001-03-01.00:00:00')
date = Date('2000-02-28.22:58:59') + Interval('01:01:01')
ae(str(date), '2000-02-29.00:00:00')
date = Date('2001-02-28.22:58:59') + Interval('01:01:01')
ae(str(date), '2001-03-01.00:00:00')
date = Date('2000-02-28.22:58:59') + Interval('00:00:3661')
ae(str(date), '2000-02-29.00:00:00')
date = Date('2001-02-28.22:58:59') + Interval('00:00:3661')
ae(str(date), '2001-03-01.00:00:00')
def testOffsetSub(self):
ae = self.assertEqual
date = Date('2000-12-01') - Interval('- 1d')
date = Date('2000-01-01') - Interval('- 2y 2m')
ae(str(date), '2002-03-01.00:00:00')
date = Date('2000-01-01') - Interval('2m')
ae(str(date), '1999-11-01.00:00:00')
date = Date('2000-03-01') - Interval('60d')
ae(str(date), '2000-01-01.00:00:00')
date = Date('2001-03-02') - Interval('60d')
ae(str(date), '2001-01-01.00:00:00')
date = Date('2000-02-29.00:00:00') - Interval('00:00:01')
ae(str(date), '2000-02-28.23:59:59')
date = Date('2001-03-01.00:00:00') - Interval('00:00:01')
ae(str(date), '2001-02-28.23:59:59')
date = Date('2000-02-29.00:00:00') - Interval('00:01:01')
ae(str(date), '2000-02-28.23:58:59')
date = Date('2001-03-01.00:00:00') - Interval('00:01:01')
ae(str(date), '2001-02-28.23:58:59')
date = Date('2000-02-29.00:00:00') - Interval('01:01:01')
ae(str(date), '2000-02-28.22:58:59')
date = Date('2001-03-01.00:00:00') - Interval('01:01:01')
ae(str(date), '2001-02-28.22:58:59')
date = Date('2000-02-29.00:00:00') - Interval('00:00:3661')
ae(str(date), '2000-02-28.22:58:59')
date = Date('2001-03-01.00:00:00') - Interval('00:00:3661')
ae(str(date), '2001-02-28.22:58:59')
def testDateLocal(self):
ae = self.assertEqual
date = Date("02:42:20")
date = date.local(10)
y, m, d, x, x, x, x, x, x = time.gmtime(time.time())
ae(str(date), '%s-%02d-%02d.12:42:20'%(y, m, d))
def testIntervalInit(self):
ae = self.assertEqual
ae(str(Interval('3y')), '+ 3y')
ae(str(Interval('2 y 1 m')), '+ 2y 1m')
ae(str(Interval('1m 25d')), '+ 1m 25d')
ae(str(Interval('-2w 3 d ')), '- 17d')
ae(str(Interval(' - 1 d 2:50 ')), '- 1d 2:50')
ae(str(Interval(' 14:00 ')), '+ 14:00')
ae(str(Interval(' 0:04:33 ')), '+ 0:04:33')
def testIntervalInitDate(self):
ae = self.assertEqual
now = Date('.')
now.hour = now.minute = now.second = 0
then = now + Interval('2d')
ae((Interval(str(then))), Interval('- 2d'))
then = now - Interval('2d')
ae(Interval(str(then)), Interval('+ 2d'))
def testIntervalAddMonthBoundary(self):
# force the transition over a month boundary
now = Date('2003-10-30.00:00:00')
then = now + Interval('2d')
self.assertEqual(str(then), '2003-11-01.00:00:00')
now = Date('2004-02-28.00:00:00')
then = now + Interval('1d')
self.assertEqual(str(then), '2004-02-29.00:00:00')
now = Date('2003-02-28.00:00:00')
then = now + Interval('1d')
self.assertEqual(str(then), '2003-03-01.00:00:00')
now = Date('2003-01-01.00:00:00')
then = now + Interval('59d')
self.assertEqual(str(then), '2003-03-01.00:00:00')
now = Date('2004-01-01.00:00:00')
then = now + Interval('59d')
self.assertEqual(str(then), '2004-02-29.00:00:00')
def testIntervalSubtractMonthBoundary(self):
# force the transition over a month boundary
now = Date('2003-11-01.00:00:00')
then = now - Interval('2d')
self.assertEqual(str(then), '2003-10-30.00:00:00')
now = Date('2004-02-29.00:00:00')
then = now - Interval('1d')
self.assertEqual(str(then), '2004-02-28.00:00:00')
now = Date('2003-03-01.00:00:00')
then = now - Interval('1d')
self.assertEqual(str(then), '2003-02-28.00:00:00')
now = Date('2003-03-01.00:00:00')
then = now - Interval('59d')
self.assertEqual(str(then), '2003-01-01.00:00:00')
now = Date('2004-02-29.00:00:00')
then = now - Interval('59d')
self.assertEqual(str(then), '2004-01-01.00:00:00')
def testIntervalAddYearBoundary(self):
# force the transition over a year boundary
now = Date('2003-12-30.00:00:00')
then = now + Interval('2d')
self.assertEqual(str(then), '2004-01-01.00:00:00')
now = Date('2003-01-01.00:00:00')
then = now + Interval('365d')
self.assertEqual(str(then), '2004-01-01.00:00:00')
now = Date('2004-01-01.00:00:00')
then = now + Interval('366d')
self.assertEqual(str(then), '2005-01-01.00:00:00')
def testIntervalSubtractYearBoundary(self):
# force the transition over a year boundary
now = Date('2003-01-01.00:00:00')
then = now - Interval('2d')
self.assertEqual(str(then), '2002-12-30.00:00:00')
now = Date('2004-02-01.00:00:00')
then = now - Interval('365d')
self.assertEqual(str(then), '2003-02-01.00:00:00')
now = Date('2005-02-01.00:00:00')
then = now - Interval('365d')
self.assertEqual(str(then), '2004-02-02.00:00:00')
def testDateSubtract(self):
# These are thoroughly broken right now.
i = Date('2003-03-15.00:00:00') - Date('2003-03-10.00:00:00')
self.assertEqual(i, Interval('5d'))
i = Date('2003-02-01.00:00:00') - Date('2003-03-01.00:00:00')
self.assertEqual(i, Interval('-28d'))
i = Date('2003-03-01.00:00:00') - Date('2003-02-01.00:00:00')
self.assertEqual(i, Interval('28d'))
i = Date('2003-03-03.00:00:00') - Date('2003-02-01.00:00:00')
self.assertEqual(i, Interval('30d'))
i = Date('2003-03-03.00:00:00') - Date('2002-02-01.00:00:00')
self.assertEqual(i, Interval('395d'))
i = Date('2003-03-03.00:00:00') - Date('2003-04-01.00:00:00')
self.assertEqual(i, Interval('-29d'))
i = Date('2003-03-01.00:00:00') - Date('2003-02-01.00:00:00')
self.assertEqual(i, Interval('28d'))
# force the transition over a year boundary
i = Date('2003-01-01.00:00:00') - Date('2002-01-01.00:00:00')
self.assertEqual(i, Interval('365d'))
def testIntervalAdd(self):
ae = self.assertEqual
ae(str(Interval('1y') + Interval('1y')), '+ 2y')
ae(str(Interval('1y') + Interval('1m')), '+ 1y 1m')
ae(str(Interval('1y') + Interval('2:40')), '+ 1y 2:40')
ae(str(Interval('1y') + Interval('- 1y')), '')
ae(str(Interval('- 1y') + Interval('1y')), '')
ae(str(Interval('- 1y') + Interval('- 1y')), '- 2y')
ae(str(Interval('1y') + Interval('- 1m')), '+ 11m')
ae(str(Interval('1:00') + Interval('1:00')), '+ 2:00')
ae(str(Interval('0:50') + Interval('0:50')), '+ 1:40')
ae(str(Interval('1:50') + Interval('- 1:50')), '')
ae(str(Interval('- 1:50') + Interval('1:50')), '')
ae(str(Interval('- 1:50') + Interval('- 1:50')), '- 3:40')
ae(str(Interval('1:59:59') + Interval('00:00:01')), '+ 2:00')
ae(str(Interval('2:00') + Interval('- 00:00:01')), '+ 1:59:59')
def testIntervalSub(self):
ae = self.assertEqual
ae(str(Interval('1y') - Interval('- 1y')), '+ 2y')
ae(str(Interval('1y') - Interval('- 1m')), '+ 1y 1m')
ae(str(Interval('1y') - Interval('- 2:40')), '+ 1y 2:40')
ae(str(Interval('1y') - Interval('1y')), '')
ae(str(Interval('1y') - Interval('1m')), '+ 11m')
ae(str(Interval('1:00') - Interval('- 1:00')), '+ 2:00')
ae(str(Interval('0:50') - Interval('- 0:50')), '+ 1:40')
ae(str(Interval('1:50') - Interval('1:50')), '')
ae(str(Interval('1:59:59') - Interval('- 00:00:01')), '+ 2:00')
ae(str(Interval('2:00') - Interval('00:00:01')), '+ 1:59:59')
def testOverflow(self):
ae = self.assertEqual
ae(fixTimeOverflow((1,0,0,0, 0, 0, 60)), (1,0,0,0, 0, 1, 0))
ae(fixTimeOverflow((1,0,0,0, 0, 0, 100)), (1,0,0,0, 0, 1, 40))
ae(fixTimeOverflow((1,0,0,0, 0, 0, 60*60)), (1,0,0,0, 1, 0, 0))
ae(fixTimeOverflow((1,0,0,0, 0, 0, 24*60*60)), (1,0,0,1, 0, 0, 0))
ae(fixTimeOverflow((1,0,0,0, 0, 0, -1)), (-1,0,0,0, 0, 0, 1))
ae(fixTimeOverflow((1,0,0,0, 0, 0, -100)), (-1,0,0,0, 0, 1, 40))
ae(fixTimeOverflow((1,0,0,0, 0, 0, -60*60)), (-1,0,0,0, 1, 0, 0))
ae(fixTimeOverflow((1,0,0,0, 0, 0, -24*60*60)), (-1,0,0,1, 0, 0, 0))
ae(fixTimeOverflow((-1,0,0,0, 0, 0, 1)), (-1,0,0,0, 0, 0, 1))
ae(fixTimeOverflow((-1,0,0,0, 0, 0, 100)), (-1,0,0,0, 0, 1, 40))
ae(fixTimeOverflow((-1,0,0,0, 0, 0, 60*60)), (-1,0,0,0, 1, 0, 0))
ae(fixTimeOverflow((-1,0,0,0, 0, 0, 24*60*60)), (-1,0,0,1, 0, 0, 0))
def testDivision(self):
ae = self.assertEqual
ae(str(Interval('1y')/2), '+ 6m')
ae(str(Interval('1:00')/2), '+ 0:30')
ae(str(Interval('00:01')/2), '+ 0:00:30')
def testSorting(self):
ae = self.assertEqual
i1 = Interval('1y')
i2 = Interval('1d')
l = [i1, i2]; l.sort()
ae(l, [i2, i1])
l = [i2, i1]; l.sort()
ae(l, [i2, i1])
i1 = Interval('- 2d')
i2 = Interval('1d')
l = [i1, i2]; l.sort()
ae(l, [i1, i2])
i1 = Interval("1:20")
i2 = Interval("2d")
i3 = Interval("3:30")
l = [i1, i2, i3]; l.sort()
ae(l, [i1, i3, i2])
def testGranularity(self):
ae = self.assertEqual
ae(str(Date('2003-2-12', add_granularity=1)), '2003-02-12.23:59:59')
ae(str(Date('2003-1-1.23:00', add_granularity=1)), '2003-01-01.23:00:59')
ae(str(Date('2003', add_granularity=1)), '2003-12-31.23:59:59')
ae(str(Date('2003-5', add_granularity=1)), '2003-05-31.23:59:59')
ae(str(Interval('+1w', add_granularity=1)), '+ 14d')
ae(str(Interval('-2m 3w', add_granularity=1)), '- 2m 14d')
def testIntervalPretty(self):
def ae(spec, pretty):
self.assertEqual(Interval(spec).pretty(), pretty)
ae('2y', 'in 2 years')
ae('1y', 'in 1 year')
ae('2m', 'in 2 months')
ae('1m 30d', 'in 2 months')
ae('60d', 'in 2 months')
ae('59d', 'in 1 month')
ae('1m', 'in 1 month')
ae('29d', 'in 1 month')
ae('28d', 'in 4 weeks')
ae('8d', 'in 1 week')
ae('7d', 'in 7 days')
ae('1w', 'in 7 days')
ae('2d', 'in 2 days')
ae('1d', 'tomorrow')
ae('02:00:00', 'in 2 hours')
ae('01:59:00', 'in 1 3/4 hours')
ae('01:45:00', 'in 1 3/4 hours')
ae('01:30:00', 'in 1 1/2 hours')
ae('01:29:00', 'in 1 1/4 hours')
ae('01:00:00', 'in an hour')
ae('00:30:00', 'in 1/2 an hour')
ae('00:15:00', 'in 1/4 hour')
ae('00:02:00', 'in 2 minutes')
ae('00:01:00', 'in 1 minute')
ae('00:00:30', 'in a moment')
ae('-00:00:30', 'just now')
ae('-1d', 'yesterday')
ae('-1y', '1 year ago')
ae('-2y', '2 years ago')
def test_suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(DateTestCase))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
# vim: set filetype=python ts=4 sw=4 et si
code-cc4667ef3f12/test/test_hyperdbvals.py 0000644 0000000 0000000 00000012342 10030631223 016642 0 ustar 0000000 0000000 #
# Copyright (c) 2003 Richard Jones, richard@commonground.com.au
# This module is free software, and you may redistribute it and/or modify
# under the same terms as Python, so long as this copyright message and
# disclaimer are retained in their original form.
#
# This module is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
#
# $Id: test_hyperdbvals.py,v 1.1 2003-11-11 00:35:14 richard Exp $
import unittest, os, shutil, errno, sys, difflib, cgi, re, sha
from roundup import init, instance, password, hyperdb, date
class TestClass:
def getprops(self):
return {
'string': hyperdb.String(),
'number': hyperdb.Number(),
'boolean': hyperdb.Boolean(),
'password': hyperdb.Password(),
'date': hyperdb.Date(),
'interval': hyperdb.Interval(),
'link': hyperdb.Link('test'),
'link2': hyperdb.Link('test2'),
'multilink': hyperdb.Multilink('test'),
'multilink2': hyperdb.Multilink('test2'),
}
def getkey(self):
return 'string'
def lookup(self, value):
if value == 'valid':
return '1'
raise KeyError
def get(self, nodeid, propname):
assert propname.startswith('multilink')
assert nodeid is not None
return ['2', '3']
class TestClass2:
def properties(self):
return {
'string': hyperdb.String(),
}
def getkey(self):
return None
def labelprop(self, default_to_id=1):
return 'id'
class TestDatabase:
classes = {'test': TestClass(), 'test2': TestClass2()}
def getUserTimezone(self):
return 0
class RawToHyperdbTest(unittest.TestCase):
def _test(self, propname, value, itemid=None):
return hyperdb.rawToHyperdb(TestDatabase(), TestClass(), itemid,
propname, value)
def testString(self):
self.assertEqual(self._test('string', ' a string '), 'a string')
def testNumber(self):
self.assertEqual(self._test('number', ' 10 '), 10)
self.assertEqual(self._test('number', ' 1.5 '), 1.5)
def testBoolean(self):
for true in 'yes true on 1'.split():
self.assertEqual(self._test('boolean', ' %s '%true), 1)
for false in 'no false off 0'.split():
self.assertEqual(self._test('boolean', ' %s '%false), 0)
def testPassword(self):
self.assertEqual(self._test('password', ' a string '), 'a string')
val = self._test('password', ' a string ')
self.assert_(isinstance(val, password.Password))
val = self._test('password', '{plaintext}a string')
self.assert_(isinstance(val, password.Password))
val = self._test('password', '{crypt}a string')
self.assert_(isinstance(val, password.Password))
s = sha.sha('a string').hexdigest()
val = self._test('password', '{SHA}'+s)
self.assert_(isinstance(val, password.Password))
self.assertEqual(val, 'a string')
self.assertRaises(hyperdb.HyperdbValueError, self._test,
'password', '{fubar}a string')
def testDate(self):
val = self._test('date', ' 2003-01-01 ')
self.assert_(isinstance(val, date.Date))
val = self._test('date', ' 2003/01/01 ')
self.assert_(isinstance(val, date.Date))
val = self._test('date', ' 2003/1/1 ')
self.assert_(isinstance(val, date.Date))
val = self._test('date', ' 2003-1-1 ')
self.assert_(isinstance(val, date.Date))
self.assertRaises(hyperdb.HyperdbValueError, self._test, 'date',
'fubar')
def testInterval(self):
val = self._test('interval', ' +1d ')
self.assert_(isinstance(val, date.Interval))
self.assertRaises(hyperdb.HyperdbValueError, self._test, 'interval',
'fubar')
def testLink(self):
self.assertEqual(self._test('link', '1'), '1')
self.assertEqual(self._test('link', 'valid'), '1')
self.assertRaises(hyperdb.HyperdbValueError, self._test, 'link',
'invalid')
def testMultilink(self):
self.assertEqual(self._test('multilink', '', '1'), [])
self.assertEqual(self._test('multilink', '1', '1'), ['1'])
self.assertEqual(self._test('multilink', 'valid', '1'), ['1'])
self.assertRaises(hyperdb.HyperdbValueError, self._test, 'multilink',
'invalid', '1')
self.assertEqual(self._test('multilink', '+1', '1'), ['1', '2', '3'])
self.assertEqual(self._test('multilink', '+valid', '1'), ['1', '2',
'3'])
self.assertEqual(self._test('multilink', '+1,-2', '1'), ['1', '3'])
self.assertEqual(self._test('multilink', '+valid,-3', '1'), ['1', '2'])
self.assertEqual(self._test('multilink', '+1', None), ['1'])
self.assertEqual(self._test('multilink', '+valid', None), ['1'])
self.assertEqual(self._test('multilink', '', None), [])
def test_suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(RawToHyperdbTest))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
# vim: set filetype=python ts=4 sw=4 et si
code-cc4667ef3f12/test/test_indexer.py 0000644 0000000 0000000 00000004721 10030631223 015757 0 ustar 0000000 0000000 # Copyright (c) 2002 ekit.com Inc (http://www.ekit-inc.com/)
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
# $Id: test_indexer.py,v 1.4 2004-03-19 04:47:59 richard Exp $
import os, unittest, shutil
from roundup.backends.indexer_dbm import Indexer
class IndexerTest(unittest.TestCase):
def setUp(self):
if os.path.exists('test-index'):
shutil.rmtree('test-index')
os.mkdir('test-index')
os.mkdir('test-index/files')
self.dex = Indexer('test-index')
self.dex.load_index()
def test_basics(self):
self.dex.add_text('testing1', 'a the hello world')
self.assertEqual(self.dex.words, {'HELLO': {1: 1}, 'THE': {1: 1},
'WORLD': {1: 1}})
self.dex.add_text('testing2', 'blah blah the world')
self.assertEqual(self.dex.words, {'BLAH': {2: 2}, 'HELLO': {1: 1},
'THE': {2: 1, 1: 1}, 'WORLD': {2: 1, 1: 1}})
self.assertEqual(self.dex.find(['world']), {2: 'testing2',
1: 'testing1'})
self.assertEqual(self.dex.find(['blah']), {2: 'testing2'})
self.assertEqual(self.dex.find(['blah', 'hello']), {})
self.dex.save_index()
def tearDown(self):
shutil.rmtree('test-index')
def test_suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(IndexerTest))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
# vim: set filetype=python ts=4 sw=4 et si
code-cc4667ef3f12/test/test_locking.py 0000644 0000000 0000000 00000004205 10030631223 015744 0 ustar 0000000 0000000 # Copyright (c) 2002 ekit.com Inc (http://www.ekit-inc.com/)
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
# $Id: test_locking.py,v 1.4 2003-10-25 22:53:26 richard Exp $
import os, unittest, tempfile
from roundup.backends.locking import acquire_lock, release_lock
class LockingTest(unittest.TestCase):
def setUp(self):
self.path = tempfile.mktemp()
open(self.path, 'w').write('hi\n')
# XXX test disabled because it simply doesn't work on many platforms
# (Solaris and Irix are known to fail, but Linux works)
def xtest_basics(self):
f = acquire_lock(self.path)
try:
acquire_lock(self.path, block=0)
except:
pass
else:
raise AssertionError, 'no exception'
release_lock(f)
f = acquire_lock(self.path)
release_lock(f)
def tearDown(self):
os.remove(self.path)
def test_suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(LockingTest))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
# vim: set filetype=python ts=4 sw=4 et si
code-cc4667ef3f12/test/test_mailgw.py 0000644 0000000 0000000 00000101531 10030631223 015576 0 ustar 0000000 0000000 #
# Copyright (c) 2001 Richard Jones, richard@bofh.asn.au.
# This module is free software, and you may redistribute it and/or modify
# under the same terms as Python, so long as this copyright message and
# disclaimer are retained in their original form.
#
# This module is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
#
# $Id: test_mailgw.py,v 1.66 2004-03-22 07:45:40 richard Exp $
import unittest, tempfile, os, shutil, errno, imp, sys, difflib, rfc822
from cStringIO import StringIO
if not os.environ.has_key('SENDMAILDEBUG'):
os.environ['SENDMAILDEBUG'] = 'mail-test.log'
SENDMAILDEBUG = os.environ['SENDMAILDEBUG']
from roundup.mailgw import MailGW, Unauthorized, uidFromAddress, \
parseContent, IgnoreLoop, IgnoreBulk
from roundup import init, instance, rfc2822, __version__
class Message(rfc822.Message):
"""String-based Message class with equivalence test."""
def __init__(self, s):
rfc822.Message.__init__(self, StringIO(s.strip()))
def __eq__(self, other):
return (self.dict == other.dict and
self.fp.read() == other.fp.read())
class DiffHelper:
def compareMessages(self, new, old):
"""Compare messages for semantic equivalence."""
new, old = Message(new), Message(old)
del new['date'], old['date']
if not new == old:
res = []
for key in new.keys():
if key.lower() == 'x-roundup-version':
# version changes constantly, so handle it specially
if new[key] != __version__:
res.append(' %s: %s != %s' % (key, __version__,
new[key]))
elif new[key] != old[key]:
res.append(' %s: %s != %s' % (key, old[key], new[key]))
body_diff = self.compareStrings(new.fp.read(), old.fp.read())
if body_diff:
res.append('')
res.extend(body_diff)
if res:
res.insert(0, 'Generated message not correct (diff follows):')
raise AssertionError, '\n'.join(res)
def compareStrings(self, s2, s1):
'''Note the reversal of s2 and s1 - difflib.SequenceMatcher wants
the first to be the "original" but in the calls in this file,
the second arg is the original. Ho hum.
'''
l1 = s1.strip().split('\n')
l2 = s2.strip().split('\n')
if l1 == l2:
return
s = difflib.SequenceMatcher(None, l1, l2)
res = []
for value, s1s, s1e, s2s, s2e in s.get_opcodes():
if value == 'equal':
for i in range(s1s, s1e):
res.append(' %s'%l1[i])
elif value == 'delete':
for i in range(s1s, s1e):
res.append('- %s'%l1[i])
elif value == 'insert':
for i in range(s2s, s2e):
res.append('+ %s'%l2[i])
elif value == 'replace':
for i, j in zip(range(s1s, s1e), range(s2s, s2e)):
res.append('- %s'%l1[i])
res.append('+ %s'%l2[j])
return res
class MailgwTestCase(unittest.TestCase, DiffHelper):
count = 0
schema = 'classic'
def setUp(self):
MailgwTestCase.count = MailgwTestCase.count + 1
self.dirname = '_test_mailgw_%s'%self.count
try:
shutil.rmtree(self.dirname)
except OSError, error:
if error.errno not in (errno.ENOENT, errno.ESRCH): raise
# create the instance
init.install(self.dirname, 'templates/classic')
init.write_select_db(self.dirname, 'anydbm')
init.initialise(self.dirname, 'sekrit')
# check we can load the package
self.instance = instance.open(self.dirname)
# and open the database
self.db = self.instance.open('admin')
self.chef_id = self.db.user.create(username='Chef',
address='chef@bork.bork.bork', realname='Bork, Chef', roles='User')
self.richard_id = self.db.user.create(username='richard',
address='richard@test', roles='User')
self.mary_id = self.db.user.create(username='mary', address='mary@test',
roles='User', realname='Contrary, Mary')
self.john_id = self.db.user.create(username='john', address='john@test',
alternate_addresses='jondoe@test\njohn.doe@test', roles='User',
realname='John Doe')
def tearDown(self):
if os.path.exists(SENDMAILDEBUG):
os.remove(SENDMAILDEBUG)
self.db.close()
try:
shutil.rmtree(self.dirname)
except OSError, error:
if error.errno not in (errno.ENOENT, errno.ESRCH): raise
def _handle_mail(self, message):
handler = self.instance.MailGW(self.instance, self.db)
handler.trapExceptions = 0
return handler.main(StringIO(message))
def _get_mail(self):
f = open(SENDMAILDEBUG)
try:
return f.read()
finally:
f.close()
def testEmptyMessage(self):
nodeid = self._handle_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: Chef
To: issue_tracker@your.tracker.email.domain.example
Cc: richard@test
Reply-To: chef@bork.bork.bork
Message-Id:
Subject: [issue] Testing...
''')
assert not os.path.exists(SENDMAILDEBUG)
self.assertEqual(self.db.issue.get(nodeid, 'title'), 'Testing...')
def doNewIssue(self):
nodeid = self._handle_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: Chef
To: issue_tracker@your.tracker.email.domain.example
Cc: richard@test
Message-Id:
Subject: [issue] Testing...
This is a test submission of a new issue.
''')
assert not os.path.exists(SENDMAILDEBUG)
l = self.db.issue.get(nodeid, 'nosy')
l.sort()
self.assertEqual(l, [self.chef_id, self.richard_id])
return nodeid
def testNewIssue(self):
self.doNewIssue()
def testNewIssueNosy(self):
self.instance.config.ADD_AUTHOR_TO_NOSY = 'yes'
nodeid = self._handle_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: Chef
To: issue_tracker@your.tracker.email.domain.example
Cc: richard@test
Message-Id:
Subject: [issue] Testing...
This is a test submission of a new issue.
''')
assert not os.path.exists(SENDMAILDEBUG)
l = self.db.issue.get(nodeid, 'nosy')
l.sort()
self.assertEqual(l, [self.chef_id, self.richard_id])
def testAlternateAddress(self):
self._handle_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: John Doe
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
Subject: [issue] Testing...
This is a test submission of a new issue.
''')
userlist = self.db.user.list()
assert not os.path.exists(SENDMAILDEBUG)
self.assertEqual(userlist, self.db.user.list(),
"user created when it shouldn't have been")
def testNewIssueNoClass(self):
self._handle_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: Chef
To: issue_tracker@your.tracker.email.domain.example
Cc: richard@test
Message-Id:
Subject: Testing...
This is a test submission of a new issue.
''')
assert not os.path.exists(SENDMAILDEBUG)
def testNewIssueAuthMsg(self):
# TODO: fix the damn config - this is apalling
self.db.config.MESSAGES_TO_AUTHOR = 'yes'
self._handle_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: Chef
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
Subject: [issue] Testing... [nosy=mary; assignedto=richard]
This is a test submission of a new issue.
''')
self.compareMessages(self._get_mail(),
'''FROM: roundup-admin@your.tracker.email.domain.example
TO: chef@bork.bork.bork, mary@test, richard@test
Content-Type: text/plain; charset=utf-8
Subject: [issue1] Testing...
To: chef@bork.bork.bork, mary@test, richard@test
From: "Bork, Chef"
Reply-To: Roundup issue tracker
MIME-Version: 1.0
Message-Id:
X-Roundup-Name: Roundup issue tracker
X-Roundup-Loop: hello
Content-Transfer-Encoding: quoted-printable
New submission from Bork, Chef :
This is a test submission of a new issue.
----------
assignedto: richard
messages: 1
nosy: Chef, mary, richard
status: unread
title: Testing...
_______________________________________________________________________
Roundup issue tracker
_______________________________________________________________________
''')
# BUG
# def testMultipart(self):
# '''With more than one part'''
# see MultipartEnc tests: but if there is more than one part
# we return a multipart/mixed and the boundary contains
# the ip address of the test machine.
# BUG should test some binary attamchent too.
def testSimpleFollowup(self):
self.doNewIssue()
self._handle_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: mary
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
In-Reply-To:
Subject: [issue1] Testing...
This is a second followup
''')
self.compareMessages(self._get_mail(),
'''FROM: roundup-admin@your.tracker.email.domain.example
TO: chef@bork.bork.bork, richard@test
Content-Type: text/plain; charset=utf-8
Subject: [issue1] Testing...
To: chef@bork.bork.bork, richard@test
From: "Contrary, Mary"
Reply-To: Roundup issue tracker
MIME-Version: 1.0
Message-Id:
In-Reply-To:
X-Roundup-Name: Roundup issue tracker
X-Roundup-Loop: hello
Content-Transfer-Encoding: quoted-printable
Contrary, Mary added the comment:
This is a second followup
----------
status: unread -> chatting
_______________________________________________________________________
Roundup issue tracker
_______________________________________________________________________
''')
def testFollowup(self):
self.doNewIssue()
self._handle_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: richard
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
In-Reply-To:
Subject: [issue1] Testing... [assignedto=mary; nosy=+john]
This is a followup
''')
l = self.db.issue.get('1', 'nosy')
l.sort()
self.assertEqual(l, [self.chef_id, self.richard_id, self.mary_id,
self.john_id])
self.compareMessages(self._get_mail(),
'''FROM: roundup-admin@your.tracker.email.domain.example
TO: chef@bork.bork.bork, john@test, mary@test
Content-Type: text/plain; charset=utf-8
Subject: [issue1] Testing...
To: chef@bork.bork.bork, john@test, mary@test
From: richard
Reply-To: Roundup issue tracker
MIME-Version: 1.0
Message-Id:
In-Reply-To:
X-Roundup-Name: Roundup issue tracker
X-Roundup-Loop: hello
Content-Transfer-Encoding: quoted-printable
richard added the comment:
This is a followup
----------
assignedto: -> mary
nosy: +john, mary
status: unread -> chatting
_______________________________________________________________________
Roundup issue tracker
_______________________________________________________________________
''')
def testFollowupTitleMatch(self):
self.doNewIssue()
self._handle_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: richard
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
In-Reply-To:
Subject: Re: Testing... [assignedto=mary; nosy=+john]
This is a followup
''')
self.compareMessages(self._get_mail(),
'''FROM: roundup-admin@your.tracker.email.domain.example
TO: chef@bork.bork.bork, john@test, mary@test
Content-Type: text/plain; charset=utf-8
Subject: [issue1] Testing...
To: chef@bork.bork.bork, john@test, mary@test
From: richard
Reply-To: Roundup issue tracker
MIME-Version: 1.0
Message-Id:
In-Reply-To:
X-Roundup-Name: Roundup issue tracker
X-Roundup-Loop: hello
Content-Transfer-Encoding: quoted-printable
richard added the comment:
This is a followup
----------
assignedto: -> mary
nosy: +john, mary
status: unread -> chatting
_______________________________________________________________________
Roundup issue tracker
_______________________________________________________________________
''')
def testFollowupNosyAuthor(self):
self.doNewIssue()
self.db.config.ADD_AUTHOR_TO_NOSY = 'yes'
self._handle_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: john@test
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
In-Reply-To:
Subject: [issue1] Testing...
This is a followup
''')
self.compareMessages(self._get_mail(),
'''FROM: roundup-admin@your.tracker.email.domain.example
TO: chef@bork.bork.bork, richard@test
Content-Type: text/plain; charset=utf-8
Subject: [issue1] Testing...
To: chef@bork.bork.bork, richard@test
From: John Doe
Reply-To: Roundup issue tracker
MIME-Version: 1.0
Message-Id:
In-Reply-To:
X-Roundup-Name: Roundup issue tracker
X-Roundup-Loop: hello
Content-Transfer-Encoding: quoted-printable
John Doe added the comment:
This is a followup
----------
nosy: +john
status: unread -> chatting
_______________________________________________________________________
Roundup issue tracker
_______________________________________________________________________
''')
def testFollowupNosyRecipients(self):
self.doNewIssue()
self.db.config.ADD_RECIPIENTS_TO_NOSY = 'yes'
self._handle_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: richard@test
To: issue_tracker@your.tracker.email.domain.example
Cc: john@test
Message-Id:
In-Reply-To:
Subject: [issue1] Testing...
This is a followup
''')
self.compareMessages(self._get_mail(),
'''FROM: roundup-admin@your.tracker.email.domain.example
TO: chef@bork.bork.bork
Content-Type: text/plain; charset=utf-8
Subject: [issue1] Testing...
To: chef@bork.bork.bork
From: richard
Reply-To: Roundup issue tracker
MIME-Version: 1.0
Message-Id:
In-Reply-To:
X-Roundup-Name: Roundup issue tracker
X-Roundup-Loop: hello
Content-Transfer-Encoding: quoted-printable
richard added the comment:
This is a followup
----------
nosy: +john
status: unread -> chatting
_______________________________________________________________________
Roundup issue tracker
_______________________________________________________________________
''')
def testFollowupNosyAuthorAndCopy(self):
self.doNewIssue()
self.db.config.ADD_AUTHOR_TO_NOSY = 'yes'
self.db.config.MESSAGES_TO_AUTHOR = 'yes'
self._handle_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: john@test
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
In-Reply-To:
Subject: [issue1] Testing...
This is a followup
''')
self.compareMessages(self._get_mail(),
'''FROM: roundup-admin@your.tracker.email.domain.example
TO: chef@bork.bork.bork, john@test, richard@test
Content-Type: text/plain; charset=utf-8
Subject: [issue1] Testing...
To: chef@bork.bork.bork, john@test, richard@test
From: John Doe
Reply-To: Roundup issue tracker
MIME-Version: 1.0
Message-Id:
In-Reply-To:
X-Roundup-Name: Roundup issue tracker
X-Roundup-Loop: hello
Content-Transfer-Encoding: quoted-printable
John Doe added the comment:
This is a followup
----------
nosy: +john
status: unread -> chatting
_______________________________________________________________________
Roundup issue tracker
_______________________________________________________________________
''')
def testFollowupNoNosyAuthor(self):
self.doNewIssue()
self.instance.config.ADD_AUTHOR_TO_NOSY = 'no'
self._handle_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: john@test
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
In-Reply-To:
Subject: [issue1] Testing...
This is a followup
''')
self.compareMessages(self._get_mail(),
'''FROM: roundup-admin@your.tracker.email.domain.example
TO: chef@bork.bork.bork, richard@test
Content-Type: text/plain; charset=utf-8
Subject: [issue1] Testing...
To: chef@bork.bork.bork, richard@test
From: John Doe
Reply-To: Roundup issue tracker
MIME-Version: 1.0
Message-Id:
In-Reply-To:
X-Roundup-Name: Roundup issue tracker
X-Roundup-Loop: hello
Content-Transfer-Encoding: quoted-printable
John Doe added the comment:
This is a followup
----------
status: unread -> chatting
_______________________________________________________________________
Roundup issue tracker
_______________________________________________________________________
''')
def testFollowupNoNosyRecipients(self):
self.doNewIssue()
self.instance.config.ADD_RECIPIENTS_TO_NOSY = 'no'
self._handle_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: richard@test
To: issue_tracker@your.tracker.email.domain.example
Cc: john@test
Message-Id:
In-Reply-To:
Subject: [issue1] Testing...
This is a followup
''')
self.compareMessages(self._get_mail(),
'''FROM: roundup-admin@your.tracker.email.domain.example
TO: chef@bork.bork.bork
Content-Type: text/plain; charset=utf-8
Subject: [issue1] Testing...
To: chef@bork.bork.bork
From: richard
Reply-To: Roundup issue tracker
MIME-Version: 1.0
Message-Id:
In-Reply-To:
X-Roundup-Name: Roundup issue tracker
X-Roundup-Loop: hello
Content-Transfer-Encoding: quoted-printable
richard added the comment:
This is a followup
----------
status: unread -> chatting
_______________________________________________________________________
Roundup issue tracker
_______________________________________________________________________
''')
def testFollowupEmptyMessage(self):
self.doNewIssue()
self._handle_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: richard
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
In-Reply-To:
Subject: [issue1] Testing... [assignedto=mary; nosy=+john]
''')
l = self.db.issue.get('1', 'nosy')
l.sort()
self.assertEqual(l, [self.chef_id, self.richard_id, self.mary_id,
self.john_id])
# should be no file created (ie. no message)
assert not os.path.exists(SENDMAILDEBUG)
def testNosyRemove(self):
self.doNewIssue()
self._handle_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: richard
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
In-Reply-To:
Subject: [issue1] Testing... [nosy=-richard]
''')
l = self.db.issue.get('1', 'nosy')
l.sort()
self.assertEqual(l, [self.chef_id])
# NO NOSY MESSAGE SHOULD BE SENT!
assert not os.path.exists(SENDMAILDEBUG)
def testNewUserAuthor(self):
# first without the permission
# heh... just ignore the API for a second ;)
self.db.security.role['anonymous'].permissions=[]
anonid = self.db.user.lookup('anonymous')
self.db.user.set(anonid, roles='Anonymous')
self.db.security.hasPermission('Email Registration', anonid)
l = self.db.user.list()
l.sort()
message = '''Content-Type: text/plain;
charset="iso-8859-1"
From: fubar
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
Subject: [issue] Testing...
This is a test submission of a new issue.
'''
self.assertRaises(Unauthorized, self._handle_mail, message)
m = self.db.user.list()
m.sort()
self.assertEqual(l, m)
# now with the permission
p = self.db.security.getPermission('Email Registration')
self.db.security.role['anonymous'].permissions=[p]
self._handle_mail(message)
m = self.db.user.list()
m.sort()
self.assertNotEqual(l, m)
def testEnc01(self):
self.doNewIssue()
self._handle_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: mary
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
In-Reply-To:
Subject: [issue1] Testing...
Content-Type: text/plain;
charset="iso-8859-1"
Content-Transfer-Encoding: quoted-printable
A message with encoding (encoded oe =F6)
''')
self.compareMessages(self._get_mail(),
'''FROM: roundup-admin@your.tracker.email.domain.example
TO: chef@bork.bork.bork, richard@test
Content-Type: text/plain; charset=utf-8
Subject: [issue1] Testing...
To: chef@bork.bork.bork, richard@test
From: "Contrary, Mary"
Reply-To: Roundup issue tracker
MIME-Version: 1.0
Message-Id:
In-Reply-To:
X-Roundup-Name: Roundup issue tracker
X-Roundup-Loop: hello
Content-Transfer-Encoding: quoted-printable
Contrary, Mary added the comment:
A message with encoding (encoded oe =C3=B6)
----------
status: unread -> chatting
_______________________________________________________________________
Roundup issue tracker
_______________________________________________________________________
''')
def testMultipartEnc01(self):
self.doNewIssue()
self._handle_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: mary
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
In-Reply-To:
Subject: [issue1] Testing...
Content-Type: multipart/mixed;
boundary="----_=_NextPart_000_01"
This message is in MIME format. Since your mail reader does not understand
this format, some or all of this message may not be legible.
------_=_NextPart_000_01
Content-Type: text/plain;
charset="iso-8859-1"
Content-Transfer-Encoding: quoted-printable
A message with first part encoded (encoded oe =F6)
''')
self.compareMessages(self._get_mail(),
'''FROM: roundup-admin@your.tracker.email.domain.example
TO: chef@bork.bork.bork, richard@test
Content-Type: text/plain; charset=utf-8
Subject: [issue1] Testing...
To: chef@bork.bork.bork, richard@test
From: "Contrary, Mary"
Reply-To: Roundup issue tracker
MIME-Version: 1.0
Message-Id:
In-Reply-To:
X-Roundup-Name: Roundup issue tracker
X-Roundup-Loop: hello
Content-Transfer-Encoding: quoted-printable
Contrary, Mary added the comment:
A message with first part encoded (encoded oe =C3=B6)
----------
status: unread -> chatting
_______________________________________________________________________
Roundup issue tracker
_______________________________________________________________________
''')
def testContentDisposition(self):
self.doNewIssue()
self._handle_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: mary
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
In-Reply-To:
Subject: [issue1] Testing...
Content-Type: multipart/mixed; boundary="bCsyhTFzCvuiizWE"
Content-Disposition: inline
--bCsyhTFzCvuiizWE
Content-Type: text/plain; charset=us-ascii
Content-Disposition: inline
test attachment binary
--bCsyhTFzCvuiizWE
Content-Type: application/octet-stream
Content-Disposition: attachment; filename="main.dvi"
xxxxxx
--bCsyhTFzCvuiizWE--
''')
messages = self.db.issue.get('1', 'messages')
messages.sort()
file = self.db.msg.get(messages[-1], 'files')[0]
self.assertEqual(self.db.file.get(file, 'name'), 'main.dvi')
def testFollowupStupidQuoting(self):
self.doNewIssue()
self._handle_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: richard
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
In-Reply-To:
Subject: Re: "[issue1] Testing... "
This is a followup
''')
self.compareMessages(self._get_mail(),
'''FROM: roundup-admin@your.tracker.email.domain.example
TO: chef@bork.bork.bork
Content-Type: text/plain; charset=utf-8
Subject: [issue1] Testing...
To: chef@bork.bork.bork
From: richard
Reply-To: Roundup issue tracker
MIME-Version: 1.0
Message-Id:
In-Reply-To:
X-Roundup-Name: Roundup issue tracker
X-Roundup-Loop: hello
Content-Transfer-Encoding: quoted-printable
richard added the comment:
This is a followup
----------
status: unread -> chatting
_______________________________________________________________________
Roundup issue tracker
_______________________________________________________________________
''')
def testEmailQuoting(self):
self.instance.config.EMAIL_KEEP_QUOTED_TEXT = 'no'
self.innerTestQuoting('''This is a followup
''')
def testEmailQuotingRemove(self):
self.instance.config.EMAIL_KEEP_QUOTED_TEXT = 'yes'
self.innerTestQuoting('''Blah blah wrote:
> Blah bklaskdfj sdf asdf jlaskdf skj sdkfjl asdf
> skdjlkjsdfalsdkfjasdlfkj dlfksdfalksd fj
>
This is a followup
''')
def innerTestQuoting(self, expect):
nodeid = self.doNewIssue()
messages = self.db.issue.get(nodeid, 'messages')
self._handle_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: richard
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
In-Reply-To:
Subject: Re: [issue1] Testing...
Blah blah wrote:
> Blah bklaskdfj sdf asdf jlaskdf skj sdkfjl asdf
> skdjlkjsdfalsdkfjasdlfkj dlfksdfalksd fj
>
This is a followup
''')
# figure the new message id
newmessages = self.db.issue.get(nodeid, 'messages')
for msg in messages:
newmessages.remove(msg)
messageid = newmessages[0]
self.compareMessages(self.db.msg.get(messageid, 'content'), expect)
def testUserLookup(self):
i = self.db.user.create(username='user1', address='user1@foo.com')
self.assertEqual(uidFromAddress(self.db, ('', 'user1@foo.com'), 0), i)
self.assertEqual(uidFromAddress(self.db, ('', 'USER1@foo.com'), 0), i)
i = self.db.user.create(username='user2', address='USER2@foo.com')
self.assertEqual(uidFromAddress(self.db, ('', 'USER2@foo.com'), 0), i)
self.assertEqual(uidFromAddress(self.db, ('', 'user2@foo.com'), 0), i)
def testUserAlternateLookup(self):
i = self.db.user.create(username='user1', address='user1@foo.com',
alternate_addresses='user1@bar.com')
self.assertEqual(uidFromAddress(self.db, ('', 'user1@bar.com'), 0), i)
self.assertEqual(uidFromAddress(self.db, ('', 'USER1@bar.com'), 0), i)
def testUserCreate(self):
i = uidFromAddress(self.db, ('', 'user@foo.com'), 1)
self.assertNotEqual(uidFromAddress(self.db, ('', 'user@bar.com'), 1), i)
def testRFC2822(self):
ascii_header = "[issue243] This is a \"test\" - with 'quotation' marks"
unicode_header = '[issue244] \xd0\xb0\xd0\xbd\xd0\xb4\xd1\x80\xd0\xb5\xd0\xb9'
unicode_encoded = '=?utf-8?q?[issue244]_=D0=B0=D0=BD=D0=B4=D1=80=D0=B5=D0=B9?='
self.assertEqual(rfc2822.encode_header(ascii_header), ascii_header)
self.assertEqual(rfc2822.encode_header(unicode_header), unicode_encoded)
def testRegistrationConfirmation(self):
otk = "Aj4euk4LZSAdwePohj90SME5SpopLETL"
self.db.getOTKManager().set(otk, username='johannes')
self._handle_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: Chef
To: issue_tracker@your.tracker.email.domain.example
Cc: richard@test
Message-Id:
Subject: Re: Complete your registration to Roundup issue tracker
-- key %s
This is a test confirmation of registration.
''' % otk)
self.db.user.lookup('johannes')
def testFollowupOnNonIssue(self):
self.db.keyword.create(name='Foo')
self._handle_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: richard
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
In-Reply-To:
Subject: [keyword1] Testing... [name=Bar]
''')
self.assertEqual(self.db.keyword.get('1', 'name'), 'Bar')
def testResentFrom(self):
nodeid = self._handle_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: Chef
Resent-From: mary
To: issue_tracker@your.tracker.email.domain.example
Cc: richard@test
Message-Id:
Subject: [issue] Testing...
This is a test submission of a new issue.
''')
assert not os.path.exists(SENDMAILDEBUG)
l = self.db.issue.get(nodeid, 'nosy')
l.sort()
self.assertEqual(l, [self.richard_id, self.mary_id])
return nodeid
def testDejaVu(self):
self.assertRaises(IgnoreLoop, self._handle_mail,
'''Content-Type: text/plain;
charset="iso-8859-1"
From: Chef
X-Roundup-Loop: hello
To: issue_tracker@your.tracker.email.domain.example
Cc: richard@test
Message-Id:
Subject: Re: [issue] Testing...
Hi, I've been mis-configured to loop messages back to myself.
''')
def testItsBulkStupid(self):
self.assertRaises(IgnoreBulk, self._handle_mail,
'''Content-Type: text/plain;
charset="iso-8859-1"
From: Chef
Precedence: bulk
To: issue_tracker@your.tracker.email.domain.example
Cc: richard@test
Message-Id:
Subject: Re: [issue] Testing...
Hi, I'm on holidays, and this is a dumb auto-responder.
''')
def test_suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(MailgwTestCase))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
# vim: set filetype=python ts=4 sw=4 et si
code-cc4667ef3f12/test/test_mailsplit.py 0000644 0000000 0000000 00000021203 10030631223 016311 0 ustar 0000000 0000000 #
# Copyright (c) 2001 Bizar Software Pty Ltd (http://www.bizarsoftware.com.au/)
# This module is free software, and you may redistribute it and/or modify
# under the same terms as Python, so long as this copyright message and
# disclaimer are retained in their original form.
#
# IN NO EVENT SHALL BIZAR SOFTWARE PTY LTD BE LIABLE TO ANY PARTY FOR
# DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING
# OUT OF THE USE OF THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# BIZAR SOFTWARE PTY LTD SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
# BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE. THE CODE PROVIDED HEREUNDER IS ON AN "AS IS"
# BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
# SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
#
# $Id: test_mailsplit.py,v 1.15 2003-10-25 22:53:26 richard Exp $
import unittest, cStringIO
from roundup.mailgw import parseContent
class MailsplitTestCase(unittest.TestCase):
def testPreComment(self):
s = '''
blah blah blah blah... blah blah? blah blah blah blah blah. blah blah blah
blah blah blah blah blah blah blah blah blah blah blah!
issue_tracker@foo.com wrote:
> blah blah blah blahblah blahblah blahblah blah blah blah blah blah blah
> blah blah blah blah blah blah blah blah blah? blah blah blah blah blah
> blah blah blah blah blah blah blah... blah blah blah blah. blah blah
> blah blah blah blah? blah blah blah blah blah blah! blah blah!
>
> -------
> nosy: userfoo, userken
> _________________________________________________
> Roundup issue tracker
> issue_tracker@foo.com
> http://foo.com/cgi-bin/roundup.cgi/issue_tracker/
--
blah blah blah signature
userfoo@foo.com
'''
summary, content = parseContent(s, 0, 0)
self.assertEqual(summary, 'blah blah blah blah... blah blah? blah blah blah blah blah. blah blah blah')
self.assertEqual(content, 'blah blah blah blah... blah blah? blah blah blah blah blah. blah blah blah\nblah blah blah blah blah blah blah blah blah blah blah!')
def testPostComment(self):
s = '''
issue_tracker@foo.com wrote:
> blah blah blah blahblah blahblah blahblah blah blah blah blah blah
> blah
> blah blah blah blah blah blah blah blah blah? blah blah blah blah
> blah
> blah blah blah blah blah blah blah... blah blah blah blah. blah
> blah
> blah blah blah blah? blah blah blah blah blah blah! blah blah!
>
> -------
> nosy: userfoo, userken
> _________________________________________________
> Roundup issue tracker
> issue_tracker@foo.com
> http://foo.com/cgi-bin/roundup.cgi/issue_tracker/
blah blah blah blah... blah blah? blah blah blah blah blah. blah blah blah
blah blah blah blah blah blah blah blah blah blah blah!
--
blah blah blah signature
userfoo@foo.com
'''
summary, content = parseContent(s, 0, 0)
self.assertEqual(summary, 'blah blah blah blah... blah blah? blah blah blah blah blah. blah blah blah')
self.assertEqual(content, 'blah blah blah blah... blah blah? blah blah blah blah blah. blah blah blah\nblah blah blah blah blah blah blah blah blah blah blah!')
def testKeepCitation(self):
s = '''
blah blah blah blah... blah blah? blah blah blah blah blah. blah blah blah
blah blah blah blah blah blah blah blah blah blah blah!
issue_tracker@foo.com wrote:
> blah blah blah blahblah blahblah blahblah blah blah blah blah blah blah
> blah blah blah blah blah blah blah blah blah? blah blah blah blah blah
> blah blah blah blah blah blah blah... blah blah blah blah. blah blah
> blah blah blah blah? blah blah blah blah blah blah! blah blah!
>
> -------
> nosy: userfoo, userken
> _________________________________________________
> Roundup issue tracker
> issue_tracker@foo.com
> http://foo.com/cgi-bin/roundup.cgi/issue_tracker/
--
blah blah blah signature
userfoo@foo.com
'''
summary, content = parseContent(s, 1, 0)
self.assertEqual(summary, 'blah blah blah blah... blah blah? blah blah blah blah blah. blah blah blah')
self.assertEqual(content, '''\
blah blah blah blah... blah blah? blah blah blah blah blah. blah blah blah
blah blah blah blah blah blah blah blah blah blah blah!
issue_tracker@foo.com wrote:
> blah blah blah blahblah blahblah blahblah blah blah blah blah blah blah
> blah blah blah blah blah blah blah blah blah? blah blah blah blah blah
> blah blah blah blah blah blah blah... blah blah blah blah. blah blah
> blah blah blah blah? blah blah blah blah blah blah! blah blah!
>
> -------
> nosy: userfoo, userken
> _________________________________________________
> Roundup issue tracker
> issue_tracker@foo.com
> http://foo.com/cgi-bin/roundup.cgi/issue_tracker/''')
def testKeepBody(self):
s = '''
blah blah blah blah... blah blah? blah blah blah blah blah. blah blah blah
blah blah blah blah blah blah blah blah blah blah blah!
issue_tracker@foo.com wrote:
> blah blah blah blahblah blahblah blahblah blah blah blah blah blah blah
> blah blah blah blah blah blah blah blah blah? blah blah blah blah blah
> blah blah blah blah blah blah blah... blah blah blah blah. blah blah
> blah blah blah blah? blah blah blah blah blah blah! blah blah!
>
> -------
> nosy: userfoo, userken
> _________________________________________________
> Roundup issue tracker
> issue_tracker@foo.com
> http://foo.com/cgi-bin/roundup.cgi/issue_tracker/
--
blah blah blah signature
userfoo@foo.com
'''
summary, content = parseContent(s, 0, 1)
self.assertEqual(summary, 'blah blah blah blah... blah blah? blah blah blah blah blah. blah blah blah')
self.assertEqual(content, '''
blah blah blah blah... blah blah? blah blah blah blah blah. blah blah blah
blah blah blah blah blah blah blah blah blah blah blah!
issue_tracker@foo.com wrote:
> blah blah blah blahblah blahblah blahblah blah blah blah blah blah blah
> blah blah blah blah blah blah blah blah blah? blah blah blah blah blah
> blah blah blah blah blah blah blah... blah blah blah blah. blah blah
> blah blah blah blah? blah blah blah blah blah blah! blah blah!
>
> -------
> nosy: userfoo, userken
> _________________________________________________
> Roundup issue tracker
> issue_tracker@foo.com
> http://foo.com/cgi-bin/roundup.cgi/issue_tracker/
--
blah blah blah signature
userfoo@foo.com
''')
def testAllQuoted(self):
s = '\nissue_tracker@foo.com wrote:\n> testing\n'
summary, content = parseContent(s, 0, 1)
self.assertEqual(summary, '')
self.assertEqual(content, s)
def testSimple(self):
s = '''testing'''
summary, content = parseContent(s, 0, 0)
self.assertEqual(summary, 'testing')
self.assertEqual(content, 'testing')
def testParagraphs(self):
s = '''testing\n\ntesting\n\ntesting'''
summary, content = parseContent(s, 0, 0)
self.assertEqual(summary, 'testing')
self.assertEqual(content, 'testing\n\ntesting\n\ntesting')
def testSimpleFollowup(self):
s = '''>hello\ntesting'''
summary, content = parseContent(s, 0, 0)
self.assertEqual(summary, 'testing')
self.assertEqual(content, 'testing')
def testSimpleFollowupParas(self):
s = '''>hello\ntesting\n\ntesting\n\ntesting'''
summary, content = parseContent(s, 0, 0)
self.assertEqual(summary, 'testing')
self.assertEqual(content, 'testing\n\ntesting\n\ntesting')
def testEmpty(self):
s = ''
summary, content = parseContent(s, 0, 0)
self.assertEqual(summary, '')
self.assertEqual(content, '')
def testIndentationSummary(self):
s = ' Four space indent.\n\n Four space indent.\nNo indent.'
summary, content = parseContent(s, 0, 0)
self.assertEqual(summary, ' Four space indent.')
def testIndentationContent(self):
s = ' Four space indent.\n\n Four space indent.\nNo indent.'
summary, content = parseContent(s, 0, 0)
self.assertEqual(content, s)
def testMultilineSummary(self):
s = 'This is a long sentence that would normally\nbe split. More words.'
summary, content = parseContent(s, 0, 0)
self.assertEqual(summary, 'This is a long sentence that would '
'normally\nbe split.')
def testKeepMultipleHyphens(self):
body = '''Testing, testing.
----
Testing, testing.'''
summary, content = parseContent(body, 1, 0)
self.assertEqual(body, content)
def test_suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(MailsplitTestCase))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
# vim: set filetype=python ts=4 sw=4 et si
code-cc4667ef3f12/test/test_metakit.py 0000644 0000000 0000000 00000005754 10030631223 015766 0 ustar 0000000 0000000 #
# Copyright (c) 2001 Bizar Software Pty Ltd (http://www.bizarsoftware.com.au/)
# This module is free software, and you may redistribute it and/or modify
# under the same terms as Python, so long as this copyright message and
# disclaimer are retained in their original form.
#
# IN NO EVENT SHALL BIZAR SOFTWARE PTY LTD BE LIABLE TO ANY PARTY FOR
# DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING
# OUT OF THE USE OF THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# BIZAR SOFTWARE PTY LTD SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
# BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE. THE CODE PROVIDED HEREUNDER IS ON AN "AS IS"
# BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
# SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
#
# $Id: test_metakit.py,v 1.5 2004-03-24 05:33:13 richard Exp $
import unittest, os, shutil, time, weakref
from db_test_base import DBTest, ROTest, SchemaTest, ClassicInitTest, config, password
from roundup import backends
class metakitOpener:
if hasattr(backends, 'metakit'):
from roundup.backends import metakit as module
module._instances = weakref.WeakValueDictionary()
def nuke_database(self):
shutil.rmtree(config.DATABASE)
class metakitDBTest(metakitOpener, DBTest):
def testBooleanUnset(self):
# XXX: metakit can't unset Booleans :(
nid = self.db.user.create(username='foo', assignable=1)
self.db.user.set(nid, assignable=None)
self.assertEqual(self.db.user.get(nid, "assignable"), 0)
def testNumberUnset(self):
# XXX: metakit can't unset Numbers :(
nid = self.db.user.create(username='foo', age=1)
self.db.user.set(nid, age=None)
self.assertEqual(self.db.user.get(nid, "age"), 0)
def testPasswordUnset(self):
# XXX: metakit can't unset Numbers (id's) :(
x = password.Password('x')
nid = self.db.user.create(username='foo', password=x)
self.db.user.set(nid, assignable=None)
self.assertEqual(self.db.user.get(nid, "assignable"), 0)
class metakitROTest(metakitOpener, ROTest):
pass
class metakitSchemaTest(metakitOpener, SchemaTest):
pass
class metakitClassicInitTest(ClassicInitTest):
backend = 'metakit'
from session_common import DBMTest
class metakitSessionTest(metakitOpener, DBMTest):
pass
def test_suite():
suite = unittest.TestSuite()
if not hasattr(backends, 'metakit'):
print 'Skipping metakit tests'
return suite
print 'Including metakit tests'
suite.addTest(unittest.makeSuite(metakitDBTest))
suite.addTest(unittest.makeSuite(metakitROTest))
suite.addTest(unittest.makeSuite(metakitSchemaTest))
suite.addTest(unittest.makeSuite(metakitClassicInitTest))
suite.addTest(unittest.makeSuite(metakitSessionTest))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
code-cc4667ef3f12/test/test_multipart.py 0000644 0000000 0000000 00000016142 10030631223 016342 0 ustar 0000000 0000000 #
# Copyright (c) 2001 Bizar Software Pty Ltd (http://www.bizarsoftware.com.au/)
# This module is free software, and you may redistribute it and/or modify
# under the same terms as Python, so long as this copyright message and
# disclaimer are retained in their original form.
#
# IN NO EVENT SHALL BIZAR SOFTWARE PTY LTD BE LIABLE TO ANY PARTY FOR
# DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING
# OUT OF THE USE OF THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# BIZAR SOFTWARE PTY LTD SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
# BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE. THE CODE PROVIDED HEREUNDER IS ON AN "AS IS"
# BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
# SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
#
# $Id: test_multipart.py,v 1.7 2004-01-17 13:49:06 jlgijsbers Exp $
import unittest
from cStringIO import StringIO
from roundup.mailgw import Message
class TestMessage(Message):
table = {'multipart/signed': ' boundary="boundary-%(indent)s";\n',
'multipart/mixed': ' boundary="boundary-%(indent)s";\n',
'multipart/alternative': ' boundary="boundary-%(indent)s";\n',
'text/plain': ' name="foo.txt"\nfoo\n',
'application/pgp-signature': ' name="foo.gpg"\nfoo\n',
'application/pdf': ' name="foo.pdf"\nfoo\n',
'message/rfc822': 'Subject: foo\n\nfoo\n'}
def __init__(self, spec):
"""Create a basic MIME message according to 'spec'.
Each line of a spec has one content-type, which is optionally indented.
The indentation signifies how deep in the MIME hierarchy the
content-type is.
"""
parts = []
for line in spec.splitlines():
content_type = line.strip()
if not content_type:
continue
indent = self.getIndent(line)
if indent:
parts.append('--boundary-%s\n' % indent)
parts.append('Content-type: %s;\n' % content_type)
parts.append(self.table[content_type] % {'indent': indent + 1})
Message.__init__(self, StringIO(''.join(parts)))
def getIndent(self, line):
"""Get the current line's indentation, using four-space indents."""
count = 0
for char in line:
if char != ' ':
break
count += 1
return count / 4
class MultipartTestCase(unittest.TestCase):
def setUp(self):
self.fp = StringIO()
w = self.fp.write
w('Content-Type: multipart/mixed; boundary="foo"\r\n\r\n')
w('This is a multipart message. Ignore this bit.\r\n')
w('--foo\r\n')
w('Content-Type: text/plain\r\n\r\n')
w('Hello, world!\r\n')
w('\r\n')
w('Blah blah\r\n')
w('foo\r\n')
w('-foo\r\n')
w('--foo\r\n')
w('Content-Type: multipart/alternative; boundary="bar"\r\n\r\n')
w('This is a multipart message. Ignore this bit.\r\n')
w('--bar\r\n')
w('Content-Type: text/plain\r\n\r\n')
w('Hello, world!\r\n')
w('\r\n')
w('Blah blah\r\n')
w('--bar\r\n')
w('Content-Type: text/html\r\n\r\n')
w('Hello, world!\r\n')
w('--bar--\r\n')
w('--foo\r\n')
w('Content-Type: text/plain\r\n\r\n')
w('Last bit\n')
w('--foo--\r\n')
self.fp.seek(0)
def testMultipart(self):
m = Message(self.fp)
self.assert_(m is not None)
# skip the first bit
p = m.getpart()
self.assert_(p is not None)
self.assertEqual(p.fp.read(),
'This is a multipart message. Ignore this bit.\r\n')
# first text/plain
p = m.getpart()
self.assert_(p is not None)
self.assertEqual(p.gettype(), 'text/plain')
self.assertEqual(p.fp.read(),
'Hello, world!\r\n\r\nBlah blah\r\nfoo\r\n-foo\r\n')
# sub-multipart
p = m.getpart()
self.assert_(p is not None)
self.assertEqual(p.gettype(), 'multipart/alternative')
# sub-multipart text/plain
q = p.getpart()
self.assert_(q is not None)
q = p.getpart()
self.assert_(q is not None)
self.assertEqual(q.gettype(), 'text/plain')
self.assertEqual(q.fp.read(), 'Hello, world!\r\n\r\nBlah blah\r\n')
# sub-multipart text/html
q = p.getpart()
self.assert_(q is not None)
self.assertEqual(q.gettype(), 'text/html')
self.assertEqual(q.fp.read(), 'Hello, world!\r\n')
# sub-multipart end
q = p.getpart()
self.assert_(q is None)
# final text/plain
p = m.getpart()
self.assert_(p is not None)
self.assertEqual(p.gettype(), 'text/plain')
self.assertEqual(p.fp.read(),
'Last bit\n')
# end
p = m.getpart()
self.assert_(p is None)
def TestExtraction(self, spec, expected):
self.assertEqual(TestMessage(spec).extract_content(), expected)
def testTextPlain(self):
self.TestExtraction('text/plain', ('foo\n', []))
def testAttachedTextPlain(self):
self.TestExtraction("""
multipart/mixed
text/plain
text/plain""",
('foo\n',
[('foo.txt', 'text/plain', 'foo\n')]))
def testMultipartMixed(self):
self.TestExtraction("""
multipart/mixed
text/plain
application/pdf""",
('foo\n',
[('foo.pdf', 'application/pdf', 'foo\n')]))
def testMultipartAlternative(self):
self.TestExtraction("""
multipart/alternative
text/plain
application/pdf
""", ('foo\n', [('foo.pdf', 'application/pdf', 'foo\n')]))
def testDeepMultipartAlternative(self):
self.TestExtraction("""
multipart/mixed
multipart/alternative
text/plain
application/pdf
""", ('foo\n', [('foo.pdf', 'application/pdf', 'foo\n')]))
def testSignedText(self):
self.TestExtraction("""
multipart/signed
text/plain
application/pgp-signature""", ('foo\n', []))
def testSignedAttachments(self):
self.TestExtraction("""
multipart/signed
multipart/mixed
text/plain
application/pdf
application/pgp-signature""",
('foo\n',
[('foo.pdf', 'application/pdf', 'foo\n')]))
def testAttachedSignature(self):
self.TestExtraction("""
multipart/mixed
text/plain
application/pgp-signature""",
('foo\n',
[('foo.gpg', 'application/pgp-signature', 'foo\n')]))
def testMessageRfc822(self):
self.TestExtraction("""
multipart/mixed
message/rfc822""",
(None,
[('foo', 'message/rfc822', 'foo\n')]))
def test_suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(MultipartTestCase))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
# vim: set filetype=python ts=4 sw=4 et si
code-cc4667ef3f12/test/test_mysql.py 0000644 0000000 0000000 00000007251 10030631223 015467 0 ustar 0000000 0000000 #
# Copyright (c) 2001 Bizar Software Pty Ltd (http://www.bizarsoftware.com.au/)
# This module is free software, and you may redistribute it and/or modify
# under the same terms as Python, so long as this copyright message and
# disclaimer are retained in their original form.
#
# IN NO EVENT SHALL BIZAR SOFTWARE PTY LTD BE LIABLE TO ANY PARTY FOR
# DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING
# OUT OF THE USE OF THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# BIZAR SOFTWARE PTY LTD SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
# BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE. THE CODE PROVIDED HEREUNDER IS ON AN "AS IS"
# BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
# SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
#
# $Id: test_mysql.py,v 1.9 2004-03-24 06:18:59 richard Exp $
import unittest, os, shutil, time, imp
from roundup.hyperdb import DatabaseError
from roundup import init, backends
from db_test_base import DBTest, ROTest, config, SchemaTest, ClassicInitTest
# Mysql connection data
config.MYSQL_DBHOST = 'localhost'
config.MYSQL_DBUSER = 'rounduptest'
config.MYSQL_DBPASSWORD = 'rounduptest'
config.MYSQL_DBNAME = 'rounduptest'
config.MYSQL_DATABASE = (config.MYSQL_DBHOST, config.MYSQL_DBUSER,
config.MYSQL_DBPASSWORD, config.MYSQL_DBNAME)
class mysqlOpener:
if hasattr(backends, 'mysql'):
from roundup.backends import mysql as module
def setUp(self):
self.module.db_nuke(config)
def tearDown(self):
self.db.close()
self.nuke_database()
def nuke_database(self):
self.module.db_nuke(config)
class mysqlDBTest(mysqlOpener, DBTest):
def setUp(self):
mysqlOpener.setUp(self)
DBTest.setUp(self)
class mysqlROTest(mysqlOpener, ROTest):
def setUp(self):
mysqlOpener.setUp(self)
ROTest.setUp(self)
class mysqlSchemaTest(mysqlOpener, SchemaTest):
def setUp(self):
mysqlOpener.setUp(self)
SchemaTest.setUp(self)
class mysqlClassicInitTest(mysqlOpener, ClassicInitTest):
backend = 'mysql'
extra_config = '''
MYSQL_DBHOST = 'localhost'
MYSQL_DBUSER = 'rounduptest'
MYSQL_DBPASSWORD = 'rounduptest'
MYSQL_DBNAME = 'rounduptest'
MYSQL_DATABASE = (MYSQL_DBHOST, MYSQL_DBUSER, MYSQL_DBPASSWORD, MYSQL_DBNAME)
'''
def setUp(self):
mysqlOpener.setUp(self)
ClassicInitTest.setUp(self)
def tearDown(self):
ClassicInitTest.tearDown(self)
self.nuke_database()
from session_common import RDBMSTest
class mysqlSessionTest(mysqlOpener, RDBMSTest):
def setUp(self):
mysqlOpener.setUp(self)
RDBMSTest.setUp(self)
def tearDown(self):
RDBMSTest.tearDown(self)
mysqlOpener.tearDown(self)
def test_suite():
suite = unittest.TestSuite()
if not hasattr(backends, 'mysql'):
print "Skipping mysql tests"
return suite
from roundup.backends import mysql
try:
# Check if we can run mysql tests
import MySQLdb
db = mysql.Database(config, 'admin')
db.close()
except (MySQLdb.ProgrammingError, DatabaseError), msg:
print "Skipping mysql tests (%s)"%msg
else:
print 'Including mysql tests'
suite.addTest(unittest.makeSuite(mysqlDBTest))
suite.addTest(unittest.makeSuite(mysqlROTest))
suite.addTest(unittest.makeSuite(mysqlSchemaTest))
suite.addTest(unittest.makeSuite(mysqlClassicInitTest))
suite.addTest(unittest.makeSuite(mysqlSessionTest))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
code-cc4667ef3f12/test/test_postgresql.py 0000644 0000000 0000000 00000010226 10030631223 016521 0 ustar 0000000 0000000 #
# Copyright (c) 2001 Bizar Software Pty Ltd (http://www.bizarsoftware.com.au/)
# This module is free software, and you may redistribute it and/or modify
# under the same terms as Python, so long as this copyright message and
# disclaimer are retained in their original form.
#
# IN NO EVENT SHALL BIZAR SOFTWARE PTY LTD BE LIABLE TO ANY PARTY FOR
# DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING
# OUT OF THE USE OF THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# BIZAR SOFTWARE PTY LTD SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
# BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE. THE CODE PROVIDED HEREUNDER IS ON AN "AS IS"
# BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
# SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
#
# $Id: test_postgresql.py,v 1.8 2004-03-25 02:16:08 richard Exp $
import unittest
from roundup.hyperdb import DatabaseError
from db_test_base import DBTest, ROTest, config, SchemaTest, ClassicInitTest
# Postgresql connection data
# NOTE: THIS MUST BE A LOCAL DATABASE
config.POSTGRESQL_DATABASE = {'database': 'rounduptest'}
from roundup import backends
class postgresqlOpener:
if hasattr(backends, 'postgresql'):
from roundup.backends import postgresql as module
def setUp(self):
#from roundup.backends.back_postgresql import db_nuke
#db_nuke(config, 1)
pass
def tearDown(self):
self.nuke_database()
def nuke_database(self):
# clear out the database - easiest way is to nuke and re-create it
from roundup.backends.back_postgresql import db_nuke
db_nuke(config)
class postgresqlDBTest(postgresqlOpener, DBTest):
def setUp(self):
postgresqlOpener.setUp(self)
DBTest.setUp(self)
def tearDown(self):
DBTest.tearDown(self)
postgresqlOpener.tearDown(self)
def testFilteringIntervalSort(self):
# PostgreSQL sorts NULLs differently to other databases (others
# treat it as lower than real values, PG treats it as higher)
ae, filt = self.filteringSetup()
# ascending should sort None, 1:10, 1d
ae(filt(None, {}, ('+','foo'), (None,None)), ['4', '1', '2', '3'])
# descending should sort 1d, 1:10, None
ae(filt(None, {}, ('-','foo'), (None,None)), ['3', '2', '1', '4'])
class postgresqlROTest(postgresqlOpener, ROTest):
def setUp(self):
postgresqlOpener.setUp(self)
ROTest.setUp(self)
def tearDown(self):
ROTest.tearDown(self)
postgresqlOpener.tearDown(self)
class postgresqlSchemaTest(postgresqlOpener, SchemaTest):
def setUp(self):
postgresqlOpener.setUp(self)
SchemaTest.setUp(self)
def tearDown(self):
SchemaTest.tearDown(self)
postgresqlOpener.tearDown(self)
class postgresqlClassicInitTest(postgresqlOpener, ClassicInitTest):
backend = 'postgresql'
extra_config = "POSTGRESQL_DATABASE = {'database': 'rounduptest'}"
def setUp(self):
postgresqlOpener.setUp(self)
ClassicInitTest.setUp(self)
def tearDown(self):
ClassicInitTest.tearDown(self)
postgresqlOpener.tearDown(self)
from session_common import RDBMSTest
class postgresqlSessionTest(postgresqlOpener, RDBMSTest):
def setUp(self):
postgresqlOpener.setUp(self)
RDBMSTest.setUp(self)
def tearDown(self):
RDBMSTest.tearDown(self)
postgresqlOpener.tearDown(self)
def test_suite():
suite = unittest.TestSuite()
if not hasattr(backends, 'postgresql'):
print "Skipping postgresql tests"
return suite
# make sure we start with a clean slate
from roundup.backends.back_postgresql import db_nuke
db_nuke(config, 1)
# TODO: Check if we can run postgresql tests
print 'Including postgresql tests'
suite.addTest(unittest.makeSuite(postgresqlDBTest))
suite.addTest(unittest.makeSuite(postgresqlROTest))
suite.addTest(unittest.makeSuite(postgresqlSchemaTest))
suite.addTest(unittest.makeSuite(postgresqlClassicInitTest))
suite.addTest(unittest.makeSuite(postgresqlSessionTest))
return suite
code-cc4667ef3f12/test/test_schema.py 0000644 0000000 0000000 00000007241 10030631223 015561 0 ustar 0000000 0000000 #
# Copyright (c) 2001 Bizar Software Pty Ltd (http://www.bizarsoftware.com.au/)
# This module is free software, and you may redistribute it and/or modify
# under the same terms as Python, so long as this copyright message and
# disclaimer are retained in their original form.
#
# IN NO EVENT SHALL BIZAR SOFTWARE PTY LTD BE LIABLE TO ANY PARTY FOR
# DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING
# OUT OF THE USE OF THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# BIZAR SOFTWARE PTY LTD SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
# BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE. THE CODE PROVIDED HEREUNDER IS ON AN "AS IS"
# BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
# SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
#
# $Id: test_schema.py,v 1.13 2003-10-25 22:53:26 richard Exp $
import unittest, os, shutil
from roundup.backends import back_anydbm
from roundup.hyperdb import String, Password, Link, Multilink, Date, \
Interval
class config:
DATABASE='_test_dir'
MAILHOST = 'localhost'
MAIL_DOMAIN = 'fill.me.in.'
NSTANCE_NAME = 'Roundup issue tracker'
TRACKER_EMAIL = 'issue_tracker@%s'%MAIL_DOMAIN
TRACKER_WEB = 'http://some.useful.url/'
ADMIN_EMAIL = 'roundup-admin@%s'%MAIL_DOMAIN
FILTER_POSITION = 'bottom' # one of 'top', 'bottom', 'top and bottom'
ANONYMOUS_ACCESS = 'deny' # either 'deny' or 'allow'
ANONYMOUS_REGISTER = 'deny' # either 'deny' or 'allow'
MESSAGES_TO_AUTHOR = 'no' # either 'yes' or 'no'
EMAIL_SIGNATURE_POSITION = 'bottom'
class SchemaTestCase(unittest.TestCase):
def setUp(self):
# remove previous test, ignore errors
if os.path.exists(config.DATABASE):
shutil.rmtree(config.DATABASE)
os.makedirs(config.DATABASE + '/files')
self.db = back_anydbm.Database(config, 'admin')
self.db.post_init()
self.db.clear()
def tearDown(self):
self.db.close()
shutil.rmtree('_test_dir')
def testA_Status(self):
status = back_anydbm.Class(self.db, "status", name=String())
self.assert_(status, 'no class object generated')
status.setkey("name")
val = status.create(name="unread")
self.assertEqual(val, '1', 'expecting "1"')
val = status.create(name="in-progress")
self.assertEqual(val, '2', 'expecting "2"')
val = status.create(name="testing")
self.assertEqual(val, '3', 'expecting "3"')
val = status.create(name="resolved")
self.assertEqual(val, '4', 'expecting "4"')
val = status.count()
self.assertEqual(val, 4, 'expecting 4')
val = status.list()
self.assertEqual(val, ['1', '2', '3', '4'], 'blah')
val = status.lookup("in-progress")
self.assertEqual(val, '2', 'expecting "2"')
status.retire('3')
val = status.list()
self.assertEqual(val, ['1', '2', '4'], 'blah')
def testB_Issue(self):
issue = back_anydbm.Class(self.db, "issue", title=String(),
status=Link("status"))
self.assert_(issue, 'no class object returned')
def testC_User(self):
user = back_anydbm.Class(self.db, "user", username=String(),
password=Password())
self.assert_(user, 'no class object returned')
user.setkey("username")
def test_suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(SchemaTestCase))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
# vim: set filetype=python ts=4 sw=4 et si
code-cc4667ef3f12/test/test_security.py 0000644 0000000 0000000 00000011531 10030631223 016165 0 ustar 0000000 0000000 # Copyright (c) 2002 ekit.com Inc (http://www.ekit-inc.com/)
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
# $Id: test_security.py,v 1.6 2003-10-25 22:53:26 richard Exp $
import os, unittest, shutil
from roundup.password import Password
from db_test_base import setupSchema, MyTestCase, config
class PermissionTest(MyTestCase):
def setUp(self):
from roundup.backends import anydbm
# remove previous test, ignore errors
if os.path.exists(config.DATABASE):
shutil.rmtree(config.DATABASE)
os.makedirs(config.DATABASE + '/files')
self.db = anydbm.Database(config, 'admin')
setupSchema(self.db, 1, anydbm)
def testInterfaceSecurity(self):
' test that the CGI and mailgw have initialised security OK '
# TODO: some asserts
def testInitialiseSecurity(self):
''' Create some Permissions and Roles on the security object
This function is directly invoked by security.Security.__init__()
as a part of the Security object instantiation.
'''
ei = self.db.security.addPermission(name="Edit", klass="issue",
description="User is allowed to edit issues")
self.db.security.addPermissionToRole('User', ei)
ai = self.db.security.addPermission(name="View", klass="issue",
description="User is allowed to access issues")
self.db.security.addPermissionToRole('User', ai)
def testGetPermission(self):
self.db.security.getPermission('Edit')
self.db.security.getPermission('View')
self.assertRaises(ValueError, self.db.security.getPermission, 'x')
self.assertRaises(ValueError, self.db.security.getPermission, 'Edit',
'fubar')
ei = self.db.security.addPermission(name="Edit", klass="issue",
description="User is allowed to edit issues")
self.db.security.getPermission('Edit', 'issue')
ai = self.db.security.addPermission(name="View", klass="issue",
description="User is allowed to access issues")
self.db.security.getPermission('View', 'issue')
def testDBinit(self):
self.db.user.create(username="anonymous", roles='User')
def testAccessControls(self):
self.testDBinit()
ei = self.db.security.addPermission(name="Edit", klass="issue",
description="User is allowed to edit issues")
self.db.security.addPermissionToRole('User', ei)
# test class-level access
userid = self.db.user.lookup('admin')
self.assertEquals(self.db.security.hasPermission('Edit', userid,
'issue'), 1)
self.assertEquals(self.db.security.hasPermission('Edit', userid,
'user'), 1)
userid = self.db.user.lookup('anonymous')
self.assertEquals(self.db.security.hasPermission('Edit', userid,
'issue'), 1)
self.assertEquals(self.db.security.hasPermission('Edit', userid,
'user'), 0)
self.assertEquals(self.db.security.hasPermission('View', userid,
'issue'), 0)
# test node-level access
issueid = self.db.issue.create(title='foo', assignedto='admin')
userid = self.db.user.lookup('admin')
self.assertEquals(self.db.security.hasNodePermission('issue',
issueid, assignedto=userid), 1)
self.assertEquals(self.db.security.hasNodePermission('issue',
issueid, nosy=userid), 0)
self.db.issue.set(issueid, nosy=[userid])
self.assertEquals(self.db.security.hasNodePermission('issue',
issueid, nosy=userid), 1)
def test_suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(PermissionTest))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
# vim: set filetype=python ts=4 sw=4 et si
code-cc4667ef3f12/test/test_sqlite.py 0000644 0000000 0000000 00000004253 10030631223 015622 0 ustar 0000000 0000000 #
# Copyright (c) 2001 Bizar Software Pty Ltd (http://www.bizarsoftware.com.au/)
# This module is free software, and you may redistribute it and/or modify
# under the same terms as Python, so long as this copyright message and
# disclaimer are retained in their original form.
#
# IN NO EVENT SHALL BIZAR SOFTWARE PTY LTD BE LIABLE TO ANY PARTY FOR
# DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING
# OUT OF THE USE OF THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# BIZAR SOFTWARE PTY LTD SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
# BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE. THE CODE PROVIDED HEREUNDER IS ON AN "AS IS"
# BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
# SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
#
# $Id: test_sqlite.py,v 1.4 2004-03-18 01:58:46 richard Exp $
import unittest, os, shutil, time
from db_test_base import DBTest, ROTest, SchemaTest, ClassicInitTest, config
class sqliteOpener:
from roundup import backends
if hasattr(backends, 'sqlite'):
from roundup.backends import sqlite as module
def nuke_database(self):
shutil.rmtree(config.DATABASE)
class sqliteDBTest(sqliteOpener, DBTest):
pass
class sqliteROTest(sqliteOpener, ROTest):
pass
class sqliteSchemaTest(sqliteOpener, SchemaTest):
pass
class sqliteClassicInitTest(ClassicInitTest):
backend = 'sqlite'
from session_common import RDBMSTest
class sqliteSessionTest(sqliteOpener, RDBMSTest):
pass
def test_suite():
suite = unittest.TestSuite()
from roundup import backends
if not hasattr(backends, 'sqlite'):
print 'Skipping sqlite tests'
return suite
print 'Including sqlite tests'
suite.addTest(unittest.makeSuite(sqliteDBTest))
suite.addTest(unittest.makeSuite(sqliteROTest))
suite.addTest(unittest.makeSuite(sqliteSchemaTest))
suite.addTest(unittest.makeSuite(sqliteClassicInitTest))
suite.addTest(unittest.makeSuite(sqliteSessionTest))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
code-cc4667ef3f12/test/test_token.py 0000644 0000000 0000000 00000003744 10030631223 015445 0 ustar 0000000 0000000 #
# Copyright (c) 2001 Richard Jones
# This module is free software, and you may redistribute it and/or modify
# under the same terms as Python, so long as this copyright message and
# disclaimer are retained in their original form.
#
# This module is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
#
# $Id: test_token.py,v 1.3 2003-10-25 22:53:26 richard Exp $
import unittest, time
from roundup.token import token_split
class TokenTestCase(unittest.TestCase):
def testValid(self):
l = token_split('hello world')
self.assertEqual(l, ['hello', 'world'])
def testIgnoreExtraSpace(self):
l = token_split('hello world ')
self.assertEqual(l, ['hello', 'world'])
def testQuoting(self):
l = token_split('"hello world"')
self.assertEqual(l, ['hello world'])
l = token_split("'hello world'")
self.assertEqual(l, ['hello world'])
def testEmbedQuote(self):
l = token_split(r'Roch\'e Compaan')
self.assertEqual(l, ["Roch'e", "Compaan"])
l = token_split('address="1 2 3"')
self.assertEqual(l, ['address=1 2 3'])
def testEscaping(self):
l = token_split('"Roch\'e" Compaan')
self.assertEqual(l, ["Roch'e", "Compaan"])
l = token_split(r'hello\ world')
self.assertEqual(l, ['hello world'])
l = token_split(r'\\')
self.assertEqual(l, ['\\'])
l = token_split(r'\n')
self.assertEqual(l, ['\n'])
def testBadQuote(self):
self.assertRaises(ValueError, token_split, '"hello world')
self.assertRaises(ValueError, token_split, "Roch'e Compaan")
def test_suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(TokenTestCase))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
# vim: set filetype=python ts=4 sw=4 et si