code-1fb2e44d02e3/test/.cvsignore 0000644 0000000 0000000 00000000046 07675772535 014727 0 ustar 0000000 0000000 *.pyc
*.pyo
localconfig.py
db
*.cover
code-1fb2e44d02e3/test/README.txt 0000644 0000000 0000000 00000001371 07675772535 014427 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-1fb2e44d02e3/test/__init__.py 0000644 0000000 0000000 00000003110 07675772535 015033 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: __init__.py,v 1.18 2002-09-10 00:19:54 richard Exp $
import os, tempfile, unittest, shutil
import roundup.roundupdb
roundup.roundupdb.SENDMAILDEBUG=os.environ['SENDMAILDEBUG']=tempfile.mktemp()
# figure all the modules available
dir = os.path.split(__file__)[0]
test_mods = {}
for file in os.listdir(dir):
if file.startswith('test_') and file.endswith('.py'):
name = file[5:-3]
test_mods[name] = __import__(file[:-3], globals(), locals(), [])
all_tests = test_mods.keys()
def go(tests=all_tests):
l = []
for name in tests:
l.append(test_mods[name].suite())
suite = unittest.TestSuite(l)
runner = unittest.TextTestRunner()
runner.run(suite)
# vim: set filetype=python ts=4 sw=4 et si
code-1fb2e44d02e3/test/benchmark.py 0000644 0000000 0000000 00000012024 07675772535 015232 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-1fb2e44d02e3/test/test_cgi.py 0000644 0000000 0000000 00000053542 07675772535 015113 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.17 2003-06-24 03:30:40 richard Exp $
import unittest, os, shutil, errno, sys, difflib, cgi, re
from roundup.cgi import client
from roundup import init, instance, password, hyperdb, date
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(client.Client.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()
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(ValueError, self.parseForm, {':required': 'string'})
self.assertRaises(ValueError, self.parseForm,
{':required': 'title,status', 'status':'1'}, 'issue')
self.assertRaises(ValueError, self.parseForm,
{':required': ['title','status'], 'status':'1'}, 'issue')
self.assertRaises(ValueError, self.parseForm,
{':required': 'status', 'status':''}, 'issue')
self.assertRaises(ValueError, self.parseForm,
{':required': 'nosy', 'nosy':''}, 'issue')
#
# Nonexistant edit
#
def testEditNonexistant(self):
self.assertRaises(IndexError, 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(ValueError, 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'}}, []))
#
# Link
#
def testEmptyLink(self):
self.assertEqual(self.parseForm({'link': ''}),
({('test', None): {}}, []))
self.assertEqual(self.parseForm({'link': ' '}),
({('test', None): {}}, []))
self.assertRaises(ValueError, 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(ValueError, self.parseForm, {'link': 'frozzle'})
self.assertRaises(ValueError, 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(),
({('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(ValueError, self.parseForm, {'nosy': 'frozzle'},
'issue')
self.assertRaises(ValueError, self.parseForm, {'nosy': '1,frozzle'},
'issue')
self.assertRaises(ValueError, 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(ValueError, 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(ValueError, self.parseForm, {':remove:foo': '2'},
'issue')
self.assertRaises(ValueError, 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(ValueError, self.parseForm, {'password': ['', '']},
'user')
self.assertRaises(ValueError, 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(ValueError, self.parseForm, {'password': 'foo'},
'user')
self.assertRaises(ValueError, 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(ValueError, 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(ValueError, self.parseForm, {'number': ['', '']})
def testInvalidNumber(self):
self.assertRaises(ValueError, 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(ValueError, self.parseForm, {'date': ['', '']})
def testInvalidDate(self):
self.assertRaises(ValueError, 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(ValueError, self.parseForm,
{'test-1@link@link': 'blah'})
self.assertRaises(ValueError, self.parseForm,
{'test-1@link@link': 'issue'})
def testLinkNotLink(self):
self.assertRaises(ValueError, self.parseForm,
{'test-1@link@boolean': 'issue-1'})
self.assertRaises(ValueError, 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 suite():
l = [
unittest.makeSuite(FormTestCase),
unittest.makeSuite(MessageTestCase),
]
return unittest.TestSuite(l)
def run():
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
if __name__ == '__main__':
run()
# vim: set filetype=python ts=4 sw=4 et si
code-1fb2e44d02e3/test/test_dates.py 0000644 0000000 0000000 00000025527 07675772535 015453 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.24 2003-04-22 20:53:54 kedder Exp $
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-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(str(Interval(str(then))), '+ 2d')
then = now - Interval('2d')
ae(str(Interval(str(then))), '- 2d')
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 suite():
return unittest.makeSuite(DateTestCase, 'test')
# vim: set filetype=python ts=4 sw=4 et si
code-1fb2e44d02e3/test/test_db.py 0000644 0000000 0000000 00000115342 07675772535 014733 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_db.py,v 1.89 2003-05-09 01:47:51 richard Exp $
import unittest, os, shutil, time
from roundup.hyperdb import String, Password, Link, Multilink, Date, \
Interval, DatabaseError, Boolean, Number, Node
from roundup import date, password
from roundup.indexer import Indexer
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'))
session = module.Class(db, 'session', title=String())
session.disableJournalling()
db.post_init()
if create:
user.create(username="admin", roles='Admin')
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):
self.db.close()
if os.path.exists('_test_dir'):
shutil.rmtree('_test_dir')
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'
# Mysql connection data
MYSQL_DBHOST = 'localhost'
MYSQL_DBUSER = 'rounduptest'
MYSQL_DBPASSWORD = 'rounduptest'
MYSQL_DBNAME = 'rounduptest'
MYSQL_DATABASE = (MYSQL_DBHOST, MYSQL_DBUSER, MYSQL_DBPASSWORD, MYSQL_DBNAME)
class nodbconfig(config):
MYSQL_DATABASE = (config.MYSQL_DBHOST, config.MYSQL_DBUSER, config.MYSQL_DBPASSWORD)
class anydbmDBTestCase(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)
#
# schema mutation
#
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', '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', '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', 'assignedto', 'creation',
'creator', 'deadline', 'files', 'fixer', 'foo', 'id', 'messages',
'nosy', 'status', 'superseder'])
self.assertEqual(self.db.issue.list(), ['1'])
#
# basic operations
#
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 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)
def testLinkChange(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, "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)
def testMultilinkChange(self):
for commit in (0,1):
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()
self.assertEqual(self.db.issue.get(nid, "nosy"), [u1,u2])
def testDateChange(self):
for commit in (0,1):
nid = self.db.issue.create(title="spam", status='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)
def testIntervalChange(self):
for commit in (0,1):
nid = self.db.issue.create(title="spam", status='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)
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)
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)
def testKeyValue(self):
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)
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.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')
self.assertEqual(a, self.db.status.list())
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')
klass.destroy(newid)
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()
klass.destroy(newid)
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()
klass.destroy(newid)
self.assertNotEqual(len(klass.list()), n)
self.assertRaises(IndexError, klass.get, newid, 'title')
self.db.rollback()
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
#
# class create
#
# string property
ar(TypeError, self.db.status.create, name=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
time.sleep(1)
entry = self.db.getjournal('issue', '1')[-1]
(x, date_stamp, x, x, x) = entry
self.db.issue.disableJournalling()
self.db.issue.set('1', title='hello world')
self.db.commit()
entry = self.db.getjournal('issue', '1')[-1]
(x, date_stamp2, x, x, x) = entry
# see if the change was journalled when it shouldn't have been
self.assertEqual(date_stamp, date_stamp2)
time.sleep(1)
self.db.issue.enableJournalling()
self.db.issue.set('1', title='hello world 2')
self.db.commit()
entry = self.db.getjournal('issue', '1')[-1]
(x, date_stamp2, x, x, x) = entry
# see if the change was journalled
self.assertNotEqual(date_stamp, date_stamp2)
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 testSearching(self):
self.db.file.create(content='hello', type="text/plain")
self.db.file.create(content='world', type="text/frozz",
comment='blah blah')
self.db.issue.create(files=['1', '2'], title="flebble plop")
self.db.issue.create(title="flebble frooz")
self.db.commit()
self.assertEquals(self.db.indexer.search(['hello'], self.db.issue),
{'1': {'files': ['1']}})
self.assertEquals(self.db.indexer.search(['world'], self.db.issue), {})
self.assertEquals(self.db.indexer.search(['frooz'], self.db.issue),
{'2': {}})
self.assertEquals(self.db.indexer.search(['flebble'], self.db.issue),
{'2': {}, '1': {}})
def testReindexing(self):
self.db.issue.create(title="frooz")
self.db.commit()
self.assertEquals(self.db.indexer.search(['frooz'], self.db.issue),
{'1': {}})
self.db.issue.set('1', title="dooble")
self.db.commit()
self.assertEquals(self.db.indexer.search(['dooble'], self.db.issue),
{'1': {}})
self.assertEquals(self.db.indexer.search(['frooz'], self.db.issue), {})
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 testFind(self):
self.db.user.create(username='test')
ids = []
ids.append(self.db.issue.create(status="1", nosy=['1']))
oddid = self.db.issue.create(status="2", nosy=['2'], assignedto='2')
ids.append(self.db.issue.create(status="1", nosy=['1','2']))
self.db.issue.create(status="3", nosy=['1'], assignedto='1')
ids.sort()
# should match first and third
got = self.db.issue.find(status='1')
got.sort()
self.assertEqual(got, ids)
# none
self.assertEqual(self.db.issue.find(status='4'), [])
# should match first and third
got = self.db.issue.find(assignedto=None)
got.sort()
self.assertEqual(got, ids)
# should match first three
got = self.db.issue.find(status='1', nosy='2')
got.sort()
ids.append(oddid)
ids.sort()
self.assertEqual(got, ids)
# none
self.assertEqual(self.db.issue.find(status='4', nosy='3'), [])
def testStringFind(self):
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'), [])
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',
'foo': date.Interval('1:10'),
'deadline': date.Date('2003-01-01.00:00')},
{'title': 'issue two', 'status': '1',
'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'])
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'])
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
class anydbmReadOnlyDBTestCase(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')
db = anydbm.Database(config, 'admin')
setupSchema(db, 1, anydbm)
db.close()
self.db = anydbm.Database(config)
setupSchema(self.db, 0, anydbm)
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 bsddbDBTestCase(anydbmDBTestCase):
def setUp(self):
from roundup.backends import bsddb
# remove previous test, ignore errors
if os.path.exists(config.DATABASE):
shutil.rmtree(config.DATABASE)
os.makedirs(config.DATABASE + '/files')
self.db = bsddb.Database(config, 'admin')
setupSchema(self.db, 1, bsddb)
class bsddbReadOnlyDBTestCase(anydbmReadOnlyDBTestCase):
def setUp(self):
from roundup.backends import bsddb
# remove previous test, ignore errors
if os.path.exists(config.DATABASE):
shutil.rmtree(config.DATABASE)
os.makedirs(config.DATABASE + '/files')
db = bsddb.Database(config, 'admin')
setupSchema(db, 1, bsddb)
db.close()
self.db = bsddb.Database(config)
setupSchema(self.db, 0, bsddb)
class bsddb3DBTestCase(anydbmDBTestCase):
def setUp(self):
from roundup.backends import bsddb3
# remove previous test, ignore errors
if os.path.exists(config.DATABASE):
shutil.rmtree(config.DATABASE)
os.makedirs(config.DATABASE + '/files')
self.db = bsddb3.Database(config, 'admin')
setupSchema(self.db, 1, bsddb3)
class bsddb3ReadOnlyDBTestCase(anydbmReadOnlyDBTestCase):
def setUp(self):
from roundup.backends import bsddb3
# remove previous test, ignore errors
if os.path.exists(config.DATABASE):
shutil.rmtree(config.DATABASE)
os.makedirs(config.DATABASE + '/files')
db = bsddb3.Database(config, 'admin')
setupSchema(db, 1, bsddb3)
db.close()
self.db = bsddb3.Database(config)
setupSchema(self.db, 0, bsddb3)
class mysqlDBTestCase(anydbmDBTestCase):
def setUp(self):
from roundup.backends import mysql
# remove previous test, ignore errors
if os.path.exists(config.DATABASE):
shutil.rmtree(config.DATABASE)
os.makedirs(config.DATABASE + '/files')
# open database for testing
self.db = mysql.Database(config, 'admin')
setupSchema(self.db, 1, mysql)
def tearDown(self):
from roundup.backends import mysql
self.db.close()
mysql.Database.nuke(config)
class mysqlReadOnlyDBTestCase(anydbmReadOnlyDBTestCase):
def setUp(self):
from roundup.backends import mysql
# remove previous test, ignore errors
if os.path.exists(config.DATABASE):
shutil.rmtree(config.DATABASE)
os.makedirs(config.DATABASE + '/files')
self.db = mysql.Database(config)
setupSchema(self.db, 0, mysql)
def tearDown(self):
from roundup.backends import mysql
self.db.close()
mysql.Database.nuke(config)
class sqliteDBTestCase(anydbmDBTestCase):
def setUp(self):
from roundup.backends import sqlite
# remove previous test, ignore errors
if os.path.exists(config.DATABASE):
shutil.rmtree(config.DATABASE)
os.makedirs(config.DATABASE + '/files')
self.db = sqlite.Database(config, 'admin')
setupSchema(self.db, 1, sqlite)
class sqliteReadOnlyDBTestCase(anydbmReadOnlyDBTestCase):
def setUp(self):
from roundup.backends import sqlite
# remove previous test, ignore errors
if os.path.exists(config.DATABASE):
shutil.rmtree(config.DATABASE)
os.makedirs(config.DATABASE + '/files')
db = sqlite.Database(config, 'admin')
setupSchema(db, 1, sqlite)
db.close()
self.db = sqlite.Database(config)
setupSchema(self.db, 0, sqlite)
class metakitDBTestCase(anydbmDBTestCase):
def setUp(self):
from roundup.backends import metakit
import weakref
metakit._instances = weakref.WeakValueDictionary()
# remove previous test, ignore errors
if os.path.exists(config.DATABASE):
shutil.rmtree(config.DATABASE)
os.makedirs(config.DATABASE + '/files')
self.db = metakit.Database(config, 'admin')
setupSchema(self.db, 1, metakit)
def testTransactions(self):
# remember the number of items we started
num_issues = len(self.db.issue.list())
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()
num_files = len(self.db.file.list())
for i in range(10):
self.db.file.create(name="test", type="text/plain",
content="hi %d"%(i))
self.db.commit()
# TODO: would be good to be able to ensure the file is not on disk after
# a rollback...
num_files2 = len(self.db.file.list())
self.assertNotEqual(num_files, num_files2)
self.db.file.create(name="test", type="text/plain", content="hi")
num_rfiles = len(os.listdir(self.db.config.DATABASE + '/files/file/0'))
self.db.rollback()
num_rfiles2 = len(os.listdir(self.db.config.DATABASE + '/files/file/0'))
self.assertEqual(num_files2, len(self.db.file.list()))
self.assertEqual(num_rfiles2, num_rfiles-1)
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)
class metakitReadOnlyDBTestCase(anydbmReadOnlyDBTestCase):
def setUp(self):
from roundup.backends import metakit
import weakref
metakit._instances = weakref.WeakValueDictionary()
# remove previous test, ignore errors
if os.path.exists(config.DATABASE):
shutil.rmtree(config.DATABASE)
os.makedirs(config.DATABASE + '/files')
db = metakit.Database(config, 'admin')
setupSchema(db, 1, metakit)
db.close()
self.db = metakit.Database(config)
setupSchema(self.db, 0, metakit)
def suite():
p = []
l = [
unittest.makeSuite(anydbmDBTestCase, 'test'),
unittest.makeSuite(anydbmReadOnlyDBTestCase, 'test')
]
p.append('anydbm')
# return unittest.TestSuite(l)
from roundup import backends
if hasattr(backends, 'mysql'):
from roundup.backends import mysql
try:
# Check if we can run mysql tests
import MySQLdb
db = mysql.Database(nodbconfig, 'admin')
db.conn.select_db(config.MYSQL_DBNAME)
db.sql("SHOW TABLES");
tables = db.sql_fetchall()
if tables:
# Database should be empty. We don't dare to delete any data
raise DatabaseError, "(Database %s contains tables)" % config.MYSQL_DBNAME
db.sql("DROP DATABASE %s" % config.MYSQL_DBNAME)
db.sql("CREATE DATABASE %s" % config.MYSQL_DBNAME)
db.close()
except (MySQLdb.ProgrammingError, DatabaseError), msg:
print "Warning! Mysql tests will not be performed", msg
print "See doc/mysql.txt for more details."
else:
p.append('mysql')
l.append(unittest.makeSuite(mysqlDBTestCase, 'test'))
l.append(unittest.makeSuite(mysqlReadOnlyDBTestCase, 'test'))
#return unittest.TestSuite(l)
if hasattr(backends, 'sqlite'):
p.append('sqlite')
l.append(unittest.makeSuite(sqliteDBTestCase, 'test'))
l.append(unittest.makeSuite(sqliteReadOnlyDBTestCase, 'test'))
if hasattr(backends, 'bsddb'):
p.append('bsddb')
l.append(unittest.makeSuite(bsddbDBTestCase, 'test'))
l.append(unittest.makeSuite(bsddbReadOnlyDBTestCase, 'test'))
if hasattr(backends, 'bsddb3'):
p.append('bsddb3')
l.append(unittest.makeSuite(bsddb3DBTestCase, 'test'))
l.append(unittest.makeSuite(bsddb3ReadOnlyDBTestCase, 'test'))
if hasattr(backends, 'metakit'):
p.append('metakit')
l.append(unittest.makeSuite(metakitDBTestCase, 'test'))
l.append(unittest.makeSuite(metakitReadOnlyDBTestCase, 'test'))
print 'running %s backend tests'%(', '.join(p))
return unittest.TestSuite(l)
# vim: set filetype=python ts=4 sw=4 et si
code-1fb2e44d02e3/test/test_indexer.py 0000644 0000000 0000000 00000004436 07675772535 016005 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.2 2002-09-10 00:19:54 richard Exp $
import os, unittest, shutil
from roundup.indexer 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 suite():
return unittest.makeSuite(IndexerTest)
# vim: set filetype=python ts=4 sw=4 et si
code-1fb2e44d02e3/test/test_init.py 0000644 0000000 0000000 00000006664 07675772535 015317 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_init.py,v 1.23 2003-04-17 06:51:44 richard Exp $
import unittest, os, shutil, errno, imp, sys
from roundup import init
class MyTestCase(unittest.TestCase):
count = 0
def setUp(self):
MyTestCase.count = MyTestCase.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 tearDown(self):
try:
shutil.rmtree(self.dirname)
except OSError, error:
if error.errno not in (errno.ENOENT, errno.ESRCH): raise
class ClassicTestCase(MyTestCase):
backend = 'anydbm'
def testCreation(self):
ae = self.assertEqual
# create the instance
init.install(self.dirname, 'templates/classic')
init.write_select_db(self.dirname, self.backend)
init.initialise(self.dirname, 'sekrit')
# check we can load the package
instance = imp.load_package(self.dirname, self.dirname)
# and open the database
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, [])
class bsddbClassicTestCase(ClassicTestCase):
backend = 'bsddb'
class bsddb3ClassicTestCase(ClassicTestCase):
backend = 'bsddb3'
class metakitClassicTestCase(ClassicTestCase):
backend = 'metakit'
class mysqlClassicTestCase(ClassicTestCase):
backend = 'mysql'
class sqliteClassicTestCase(ClassicTestCase):
backend = 'sqlite'
def suite():
l = [
unittest.makeSuite(ClassicTestCase, 'test'),
]
from roundup import backends
if hasattr(backends, 'bsddb'):
l.append(unittest.makeSuite(bsddbClassicTestCase, 'test'))
if hasattr(backends, 'bsddb3'):
l.append(unittest.makeSuite(bsddb3ClassicTestCase, 'test'))
if hasattr(backends, 'metakit'):
l.append(unittest.makeSuite(metakitClassicTestCase, 'test'))
if hasattr(backends, 'mysql'):
l.append(unittest.makeSuite(mysqlClassicTestCase, 'test'))
if hasattr(backends, 'sqlite'):
l.append(unittest.makeSuite(sqliteClassicTestCase, 'test'))
return unittest.TestSuite(l)
# vim: set filetype=python ts=4 sw=4 et si
code-1fb2e44d02e3/test/test_locking.py 0000644 0000000 0000000 00000003737 07675772535 016000 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.3 2002-12-09 02:51:46 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 suite():
return unittest.makeSuite(LockingTest)
# vim: set filetype=python ts=4 sw=4 et si
code-1fb2e44d02e3/test/test_mailgw.py 0000644 0000000 0000000 00000101107 07675772535 015620 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.46 2003-05-06 21:49:20 kedder Exp $
import unittest, cStringIO, tempfile, os, shutil, errno, imp, sys, difflib
import rfc822
# Note: Should parse emails according to RFC2822 instead of performing a
# literal string comparision. Parsing the messages allows the tests to work for
# any legal serialization of an email.
#try :
# import email
#except ImportError :
# import rfc822 as email
from roundup.mailgw import MailGW, Unauthorized, uidFromAddress
from roundup import init, instance, rfc2822
# TODO: make this output only enough equal lines for context, not all of
# them
class DiffHelper:
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.
'''
# we have to special-case the Date: header here 'cos we can't test
# for it properly
l1=s1.strip().split('\n')
l2=[x for x in s2.strip().split('\n') if not x.startswith('Date: ')]
if l1 == l2:
return
s = difflib.SequenceMatcher(None, l1, l2)
res = ['Generated message not correct (diff follows):']
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])
raise AssertionError, '\n'.join(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.db.user.create(username='Chef', address='chef@bork.bork.bork',
realname='Bork, Chef', roles='User')
self.db.user.create(username='richard', address='richard@test',
roles='User')
self.db.user.create(username='mary', address='mary@test',
roles='User', realname='Contrary, Mary')
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(os.environ['SENDMAILDEBUG']):
os.remove(os.environ['SENDMAILDEBUG'])
self.db.close()
try:
shutil.rmtree(self.dirname)
except OSError, error:
if error.errno not in (errno.ENOENT, errno.ESRCH): raise
def testEmptyMessage(self):
message = cStringIO.StringIO('''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...
''')
handler = self.instance.MailGW(self.instance, self.db)
handler.trapExceptions = 0
nodeid = handler.main(message)
if os.path.exists(os.environ['SENDMAILDEBUG']):
error = open(os.environ['SENDMAILDEBUG']).read()
self.assertEqual('no error', error)
self.assertEqual(self.db.issue.get(nodeid, 'title'), 'Testing...')
def doNewIssue(self):
message = cStringIO.StringIO('''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.
''')
handler = self.instance.MailGW(self.instance, self.db)
handler.trapExceptions = 0
nodeid = handler.main(message)
if os.path.exists(os.environ['SENDMAILDEBUG']):
error = open(os.environ['SENDMAILDEBUG']).read()
self.assertEqual('no error', error)
l = self.db.issue.get(nodeid, 'nosy')
l.sort()
self.assertEqual(l, ['3', '4'])
return nodeid
def testNewIssue(self):
self.doNewIssue()
def testNewIssueNosy(self):
self.instance.config.ADD_AUTHOR_TO_NOSY = 'yes'
message = cStringIO.StringIO('''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.
''')
handler = self.instance.MailGW(self.instance, self.db)
handler.trapExceptions = 0
nodeid = handler.main(message)
if os.path.exists(os.environ['SENDMAILDEBUG']):
error = open(os.environ['SENDMAILDEBUG']).read()
self.assertEqual('no error', error)
l = self.db.issue.get(nodeid, 'nosy')
l.sort()
self.assertEqual(l, ['3', '4'])
def testAlternateAddress(self):
message = cStringIO.StringIO('''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()
handler = self.instance.MailGW(self.instance, self.db)
handler.trapExceptions = 0
handler.main(message)
if os.path.exists(os.environ['SENDMAILDEBUG']):
error = open(os.environ['SENDMAILDEBUG']).read()
self.assertEqual('no error', error)
self.assertEqual(userlist, self.db.user.list(),
"user created when it shouldn't have been")
def testNewIssueNoClass(self):
message = cStringIO.StringIO('''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.
''')
handler = self.instance.MailGW(self.instance, self.db)
handler.trapExceptions = 0
handler.main(message)
if os.path.exists(os.environ['SENDMAILDEBUG']):
error = open(os.environ['SENDMAILDEBUG']).read()
self.assertEqual('no error', error)
def testNewIssueAuthMsg(self):
message = cStringIO.StringIO('''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.
''')
handler = self.instance.MailGW(self.instance, self.db)
handler.trapExceptions = 0
# TODO: fix the damn config - this is apalling
self.db.config.MESSAGES_TO_AUTHOR = 'yes'
handler.main(message)
self.compareStrings(open(os.environ['SENDMAILDEBUG']).read(),
'''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()
message = cStringIO.StringIO('''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
''')
handler = self.instance.MailGW(self.instance, self.db)
handler.trapExceptions = 0
handler.main(message)
self.compareStrings(open(os.environ['SENDMAILDEBUG']).read(),
'''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()
message = cStringIO.StringIO('''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
''')
handler = self.instance.MailGW(self.instance, self.db)
handler.trapExceptions = 0
handler.main(message)
l = self.db.issue.get('1', 'nosy')
l.sort()
self.assertEqual(l, ['3', '4', '5', '6'])
self.compareStrings(open(os.environ['SENDMAILDEBUG']).read(),
'''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()
message = cStringIO.StringIO('''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
''')
handler = self.instance.MailGW(self.instance, self.db)
handler.trapExceptions = 0
handler.main(message)
self.compareStrings(open(os.environ['SENDMAILDEBUG']).read(),
'''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'
message = cStringIO.StringIO('''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
''')
handler = self.instance.MailGW(self.instance, self.db)
handler.trapExceptions = 0
handler.main(message)
self.compareStrings(open(os.environ['SENDMAILDEBUG']).read(),
'''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'
message = cStringIO.StringIO('''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
''')
handler = self.instance.MailGW(self.instance, self.db)
handler.trapExceptions = 0
handler.main(message)
self.compareStrings(open(os.environ['SENDMAILDEBUG']).read(),
'''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'
message = cStringIO.StringIO('''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
''')
handler = self.instance.MailGW(self.instance, self.db)
handler.trapExceptions = 0
handler.main(message)
self.compareStrings(open(os.environ['SENDMAILDEBUG']).read(),
'''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'
message = cStringIO.StringIO('''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
''')
handler = self.instance.MailGW(self.instance, self.db)
handler.trapExceptions = 0
handler.main(message)
self.compareStrings(open(os.environ['SENDMAILDEBUG']).read(),
'''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'
message = cStringIO.StringIO('''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
''')
handler = self.instance.MailGW(self.instance, self.db)
handler.trapExceptions = 0
handler.main(message)
self.compareStrings(open(os.environ['SENDMAILDEBUG']).read(),
'''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()
message = cStringIO.StringIO('''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]
''')
handler = self.instance.MailGW(self.instance, self.db)
handler.trapExceptions = 0
handler.main(message)
l = self.db.issue.get('1', 'nosy')
l.sort()
self.assertEqual(l, ['3', '4', '5', '6'])
# should be no file created (ie. no message)
assert not os.path.exists(os.environ['SENDMAILDEBUG'])
def testNosyRemove(self):
self.doNewIssue()
message = cStringIO.StringIO('''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]
''')
handler = self.instance.MailGW(self.instance, self.db)
handler.trapExceptions = 0
handler.main(message)
l = self.db.issue.get('1', 'nosy')
l.sort()
self.assertEqual(l, ['3'])
# NO NOSY MESSAGE SHOULD BE SENT!
self.assert_(not os.path.exists(os.environ['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()
s = '''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.
'''
message = cStringIO.StringIO(s)
handler = self.instance.MailGW(self.instance, self.db)
handler.trapExceptions = 0
self.assertRaises(Unauthorized, handler.main, 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]
handler = self.instance.MailGW(self.instance, self.db)
handler.trapExceptions = 0
message = cStringIO.StringIO(s)
handler.main(message)
m = self.db.user.list()
m.sort()
self.assertNotEqual(l, m)
def testEnc01(self):
self.doNewIssue()
message = cStringIO.StringIO('''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)
''')
handler = self.instance.MailGW(self.instance, self.db)
handler.trapExceptions = 0
handler.main(message)
self.compareStrings(open(os.environ['SENDMAILDEBUG']).read(),
'''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()
message = cStringIO.StringIO('''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)
''')
handler = self.instance.MailGW(self.instance, self.db)
handler.trapExceptions = 0
handler.main(message)
self.compareStrings(open(os.environ['SENDMAILDEBUG']).read(),
'''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()
message = cStringIO.StringIO('''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--
''')
handler = self.instance.MailGW(self.instance, self.db)
handler.trapExceptions = 0
handler.main(message)
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()
message = cStringIO.StringIO('''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
''')
handler = self.instance.MailGW(self.instance, self.db)
handler.trapExceptions = 0
handler.main(message)
self.compareStrings(open(os.environ['SENDMAILDEBUG']).read(),
'''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')
message = cStringIO.StringIO('''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
''')
handler = self.instance.MailGW(self.instance, self.db)
handler.trapExceptions = 0
handler.main(message)
# figure the new message id
newmessages = self.db.issue.get(nodeid, 'messages')
for msg in messages:
newmessages.remove(msg)
messageid = newmessages[0]
self.compareStrings(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 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 suite():
l = [unittest.makeSuite(MailgwTestCase),
]
return unittest.TestSuite(l)
# vim: set filetype=python ts=4 sw=4 et si
code-1fb2e44d02e3/test/test_mailsplit.py 0000644 0000000 0000000 00000020116 07675772535 016336 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.12 2002-10-18 03:34:58 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 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 suite():
return unittest.makeSuite(MailsplitTestCase, 'test')
# vim: set filetype=python ts=4 sw=4 et si
code-1fb2e44d02e3/test/test_multipart.py 0000644 0000000 0000000 00000007153 07675772535 016367 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.5 2002-09-10 00:19:55 richard Exp $
import unittest, cStringIO
from roundup.mailgw import Message
class MultipartTestCase(unittest.TestCase):
def setUp(self):
self.fp = cStringIO.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 suite():
return unittest.makeSuite(MultipartTestCase, 'test')
# vim: set filetype=python ts=4 sw=4 et si
code-1fb2e44d02e3/test/test_schema.py 0000644 0000000 0000000 00000007001 07675772535 015576 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.12 2002-09-20 05:08:00 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 suite():
return unittest.makeSuite(SchemaTestCase, 'test')
# vim: set filetype=python ts=4 sw=4 et si
code-1fb2e44d02e3/test/test_security.py 0000644 0000000 0000000 00000011256 07675772535 016214 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.5 2002-09-20 05:08:00 richard Exp $
import os, unittest, shutil
from roundup.password import Password
from test_db 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 suite():
return unittest.makeSuite(PermissionTest)
# vim: set filetype=python ts=4 sw=4 et si
code-1fb2e44d02e3/test/test_token.py 0000644 0000000 0000000 00000003505 07675772535 015463 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.2 2002-09-10 00:19:55 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 suite():
return unittest.makeSuite(TokenTestCase, 'test')
# vim: set filetype=python ts=4 sw=4 et si